lib/java_string: replace std::vector with std::string

JavaCompat::importJavaFormatToString() → JavaCompat::importJavaString()
JavaCompat::exportStringToJavaFormat() → JavaCompat::exportJavaString()

src/lib/java_string.cpp

@@ -14,30 +14,31 @@
 //If not, see https://www.gnu.org/licenses/agpl-3.0.en.html
 
 #include <tinyutf8/tinyutf8.h>
-#include <vector>
+#include <string>
 #include "error.h++"
 
 #include "java_string.h++"
 
 namespace JavaCompat {
-    tiny_utf8::string importJavaFormatToString(uint8_t data[]) {
-        std::vector<uint8_t> output;
-        tiny_utf8::string outputString;
+    //FIXME: contrary to what I said, we need to explicitly pass the data
+    // size because files could have been tampered with or corrupted
+    tiny_utf8::string importJavaString(uint8_t data[]) {
+        std::string stdString;
         uint16_t size = static_cast<uint16_t>(data[0])<<8 | static_cast<uint16_t>(data[1]);
 
         for(uint8_t i=2; i<size; i++){
             if(i != 0){
                 if(data[i] == 0x80 && data[i-1] == 0xc0){
-                    output[output.size() - 1] = 0x00;
+                    stdString[stdString.length() - 1] = '\0';
                     continue;
                 }
             }
-            output.push_back(data[i]);
+            stdString.push_back((char) data[i]);
         }
-        return tiny_utf8::string(output.begin(), output.end());
+        return tiny_utf8::string(stdString);
     }
     /*
-    ErrorOr<uint8_t*> exportStringToJavaFormat(tiny_utf8::string data) {
+    ErrorOr<uint8_t*> exportJavaString(tiny_utf8::string data) {
         return ErrorOr(nullptr);
     }
     */

src/lib/java_string.h++

@@ -17,6 +17,8 @@
 #include "error.h++"
 
 namespace JavaCompat {
-    tiny_utf8::string importJavaFormatToString(uint8_t data[]);
-    ErrorOr<uint8_t*> exportStringToJavaFormat(tiny_utf8::string data);
+    //FIXME: contrary to what I said, we need to explicitly pass the data
+    // size because files could have been tampered with or corrupted
+    tiny_utf8::string importJavaString(uint8_t data[]);
+    ErrorOr<uint8_t*> exportJavaString(tiny_utf8::string data);
 }

src/test/java_string.cpp

@@ -23,48 +23,61 @@
 
 int main(){
 
+    // metadata for things in resources/unicode_data/
+    // normal_utf-8: 116 bytes, 85 characters ??
+    // java-style_unicode: 119 bytes, 85 characters ??
+
     std::cout << "################################################################################" << std::endl;
     std::cout << "Java String Tests" << std::endl;
     std::cout << "################################################################################" << std::endl;
 
-	std::streampos javaSize;
-	char* javaData;
-	std::ifstream javaFile("./resources/unicode_data/java-style_unicode", std::ios::in | std::ios::binary | std::ios::ate);
-	if(javaFile.is_open()){
-		javaSize = javaFile.tellg();
-		javaData = new char[javaSize];
-		javaFile.seekg(0, std::ios::beg);
-		javaFile.read(javaData, javaSize);
-		javaFile.close();
-	}
+    char* nextChar = new char;
 
-    tiny_utf8::string importString = JavaCompat::importJavaFormatToString((uint8_t*) javaData);
+    std::streampos javaSize;
+    std::string javaStdString;
+    const char* javaFilePath = "./resources/unicode_data/java-style_unicode";
+    std::ifstream javaFile(javaFilePath, std::ios::in | std::ios::binary | std::ios::ate);
+    if(javaFile.is_open()){
+        javaSize = javaFile.tellg();
+        javaFile.seekg(0, std::ios::beg);
 
-    std::streampos normalSize;
-	char* normalData;
-	std::ifstream normalFile("./resources/unicode_data/normal_utf-8", std::ios::in | std::ios::binary | std::ios::ate);
-	if(normalFile.is_open()){
-		normalSize = normalFile.tellg();
-		normalData = new char[normalSize];
-		normalFile.seekg(0, std::ios::beg);
-		normalFile.read(normalData, normalSize);
-		normalFile.close();
-	}
+        for (int i=0; i<javaSize; i++) {
+            javaFile.read(nextChar, 1);
+            javaStdString.push_back(*nextChar);
+        }
 
-    std::vector<char> normalDataVector = std::vector<char>();
-    for(int i=0; i<normalSize; i++){
-        normalDataVector.push_back(normalData[i]);
+        javaFile.close();
+    } else {
+        std::cerr << "Failed to open file: " << javaFilePath << std::endl;
+        return 2;
     }
 
-    tiny_utf8::string normalString = tiny_utf8::string(normalDataVector.begin(), normalDataVector.end());
+    tiny_utf8::string importedString = JavaCompat::importJavaString(reinterpret_cast<uint8_t*>(javaStdString.data()));
 
-    std::cout << normalString.size() << std::endl;
-    std::cout << importString.size() << std::endl;
+    std::streampos normalSize;
+    std::string normalStdString;
+    const char* normalFilePath = "./resources/unicode_data/normal_utf-8";
+    std::ifstream normalFile(normalFilePath, std::ios::in | std::ios::binary | std::ios::ate);
+    if(normalFile.is_open()){
+        normalSize = normalFile.tellg();
+        normalFile.seekg(0, std::ios::beg);
 
-    ASSERT(normalString == importString);
+        for (int i=0; i<normalSize; i++) {
+            normalFile.read(nextChar, 1);
+            normalStdString.push_back(*nextChar);
+        }
+
+        normalFile.close();
+    } else {
+        std::cerr << "Failed to open file: " << normalFilePath << std::endl;
+        return 2;
+    }
+
+    tiny_utf8::string normalString = tiny_utf8::string(normalStdString);
+
+    ASSERT(normalString == importedString);
     std::cout << "Passed Import Java string test." << std::endl;
 
-	
-	return 0;
-}
 
+return 0;
+}