Move char string code into cpp

include/core/utils/ArrayString.hpp

@@ -29,198 +29,57 @@ namespace Core {
         char* data;
 
     public:
-        CharString(char* buffer, i32 bufferSize)
-            : length(0), capacity(bufferSize), hash(0), data(buffer) {
-            data[0] = '\0';
-        }
-
+        CharString(char* buffer, i32 bufferSize);
         CharString(const CharString&) = delete;
         CharString& operator=(const CharString&) = delete;
 
-        check_return Error copyFrom(const CharString& s) {
-            clear();
-            return s.toString(*this);
-        }
-
-        bool operator==(const char* s) const {
-            const char* p = data;
-            while(*s == *p && *s != '\0') {
-                s++;
-                p++;
-            }
-            return *s == *p;
-        }
-
-        bool operator==(const CharString& other) const {
-            if(length != other.getLength()) {
-                return false;
-            }
-            for(int i = 0; i < length; i++) {
-                if(data[i] != other[i]) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        bool operator!=(const char* s) const {
-            return !((*this) == s);
-        }
-
-        bool operator!=(const CharString& other) const {
-            return !((*this) == other);
-        }
-
-        char operator[](int index) const {
-            return data[index];
-        }
-
-        int getLength() const {
-            return length;
-        }
-
-        constexpr int getCapacity() const {
-            return capacity - 1;
-        }
-
-        check_return Error append(char c) {
-            return add(c);
-        }
-
-        check_return Error append(signed char c) {
-            return append(static_cast<char>(c));
-        }
-
-        check_return Error append(unsigned char c) {
-            return append(static_cast<char>(c));
-        }
-
-        check_return Error append(wchar_t c) {
-            return append(static_cast<c32>(c));
-        }
-
-        check_return Error append(c32 c) {
-            char buffer[5];
-            unicodeToChar(c, buffer);
-            return append(static_cast<const char*>(buffer));
-        }
-
-        check_return Error append(const char* s) {
-            // stringLength as s could be some part of data
-            for(int i = stringLength(s); i > 0; i--) {
-                CORE_RETURN_ERROR(append(*(s++)));
-            }
-            return Error::NONE;
-        }
-
-        check_return Error append(const c32* s) {
-            // stringLength as s could be some part of data
-            for(int i = stringLength(s); i > 0; i--) {
-                CORE_RETURN_ERROR(append(*(s++)));
-            }
-            return Error::NONE;
-        }
-
-        check_return Error append(const signed char* s) {
-            return append(reinterpret_cast<const char*>(s));
-        }
-
-        check_return Error append(const unsigned char* s) {
-            return append(reinterpret_cast<const char*>(s));
-        }
-
-        check_return Error append(signed short s) {
-            return convertAppend(s);
-        }
-
-        check_return Error append(unsigned short s) {
-            return convertAppend(s);
-        }
-
-        check_return Error append(signed int i) {
-            return convertAppend(i);
-        }
-
-        check_return Error append(unsigned int i) {
-            return convertAppend(i);
-        }
-
-        check_return Error append(signed long l) {
-            return convertAppend(l);
-        }
-
-        check_return Error append(unsigned long l) {
-            return convertAppend(l);
-        }
-
-        check_return Error append(signed long long ll) {
-            return convertAppend(ll);
-        }
-
-        check_return Error append(unsigned long long ll) {
-            return convertAppend(ll);
-        }
-
-        check_return Error append(float f) {
-            return convertAppend(f);
-        }
-
-        check_return Error append(double d) {
-            return convertAppend(d);
-        }
-
-        check_return Error append(long double ld) {
-            return convertAppend(ld);
-        }
-
-        check_return Error append(bool b) {
-            return b ? append("true") : append("false");
-        }
-
-        check_return Error append(Error e) {
-            return append(getErrorName(e));
-        }
+        check_return Error copyFrom(const CharString& s);
+        bool operator==(const char* s) const;
+        bool operator==(const CharString& other) const;
+        bool operator!=(const char* s) const;
+        bool operator!=(const CharString& other) const;
+        char operator[](int index) const;
+        int getLength() const;
+        int getCapacity() const;
+        check_return Error append(char c);
+        check_return Error append(signed char c);
+        check_return Error append(unsigned char c);
+        check_return Error append(wchar_t c);
+        check_return Error append(c32 c);
+        check_return Error append(const char* s);
+        check_return Error append(const c32* s);
+        check_return Error append(const signed char* s);
+        check_return Error append(const unsigned char* s);
+        check_return Error append(signed short s);
+        check_return Error append(unsigned short s);
+        check_return Error append(signed int i);
+        check_return Error append(unsigned int i);
+        check_return Error append(signed long l);
+        check_return Error append(unsigned long l);
+        check_return Error append(signed long long ll);
+        check_return Error append(unsigned long long ll);
+        check_return Error append(float f);
+        check_return Error append(double d);
+        check_return Error append(long double ld);
+        check_return Error append(bool b);
+        check_return Error append(Error e);
 
         template<typename T>
         check_return Error append(const T& t) {
             return t.toString(*this);
         }
 
-        check_return Error toString(CharString& s) const {
-            int l = length; // length changes if &s == this
-            for(int i = 0; i < l; i++) {
-                CORE_RETURN_ERROR(s.append(data[i]));
-            }
-            return Error::NONE;
-        }
+        check_return Error toString(CharString& s) const;
 
         template<int L>
         check_return Error toString(Char32String<L>& s) const {
             return s.append(static_cast<const char*>(data));
         }
 
-        void clear() {
-            length = 0;
-            hash = 0;
-            data[0] = '\0';
-        }
-
-        u32 hashCode() const {
-            return hash;
-        }
-
-        check_return Error print() const {
-            for(int i = 0; i < length; i++) {
-                CORE_RETURN_ERROR(Core::putChar(data[i]));
-            }
-            return Error::NONE;
-        }
-
-        check_return Error printLine() const {
-            CORE_RETURN_ERROR(print());
-            CORE_RETURN_ERROR(Core::putChar('\n'));
-            return Error::NONE;
-        }
+        void clear();
+        u32 hashCode() const;
+        check_return Error print() const;
+        check_return Error printLine() const;
 
         template<typename... Args>
         check_return Error format(CharString& s, Args&&... args) {
@@ -233,130 +92,21 @@ namespace Core {
             return e;
         }
 
-        bool startsWidth(const CharString& other, int from = 0) const {
-            if(from > length - other.getLength()) {
-                return false;
-            }
-            for(int i = 0; i < other.getLength(); i++) {
-                if(data[from + i] != other[i]) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        int search(const CharString& other, int from = 0) const {
-            for(int i = from; i < length; i++) {
-                if(startsWidth(other, i)) {
-                    return i;
-                }
-            }
-            return -1;
-        }
-
-        bool contains(const CharString& other, int from = 0) const {
-            return search(other, from) >= 0;
-        }
-
-        int search(char u, int from = 0) const {
-            for(int i = from; i < length; i++) {
-                if(data[i] == u) {
-                    return i;
-                }
-            }
-            return -1;
-        }
-
-        bool contains(char u, int from = 0) const {
-            return search(u, from) >= 0;
-        }
-
-        check_return Error substring(CharString& s, int from, int to) const {
-            s.clear();
-            from = Math::max(from, 0);
-            to = Math::min(to, length - 1);
-            for(int i = from; i <= to; i++) {
-                CORE_RETURN_ERROR(s.append(data[i]));
-            }
-            return Error::NONE;
-        }
-
-        check_return Error substring(CharString& s, int from = 0) const {
-            return substring(s, from, length - 1);
-        }
-
+        bool startsWidth(const CharString& other, int from = 0) const;
+        int search(const CharString& other, int from = 0) const;
+        bool contains(const CharString& other, int from = 0) const;
+        int search(char u, int from = 0) const;
+        bool contains(char u, int from = 0) const;
+        check_return Error substring(CharString& s, int from, int to) const;
+        check_return Error substring(CharString& s, int from = 0) const;
         check_return Error replace(CharString& s, const CharString& search,
-                                   const CharString& replace) {
-            int i = 0;
-            while(i < length) {
-                if(startsWidth(search, i)) {
-                    CORE_RETURN_ERROR(s.append(replace));
-                    i += search.getLength();
-                } else {
-                    CORE_RETURN_ERROR(s.append(data[i]));
-                    i++;
-                }
-            }
-            return copyFrom(s);
-        }
-
-        void replace(char search, char replace) {
-            hash = 0;
-            for(int i = 0; i < length; i++) {
-                if(data[i] == search) {
-                    data[i] = replace;
-                }
-                addToHash(static_cast<c32>(data[i]));
-            }
-        }
-
-        operator const char*() const {
-            return data;
-        }
+                                   const CharString& replace);
+        void replace(char search, char replace);
+        operator const char*() const;
 
     private:
-        Error add(char c) {
-            if(length >= capacity - 1) {
-                return Error::CAPACITY_REACHED;
-            }
-            data[length++] = c;
-            data[length] = '\0';
-            addToHash(static_cast<c32>(c));
-            return Error::NONE;
-        }
-
-        template<unsigned int L>
-        void unicodeToChar(c32 c, char (&buffer)[L]) {
-            static_assert(L >= 5, "to small char buffer");
-            buffer[0] = '\0';
-            if(c < (1 << 7)) {
-                buffer[0] = static_cast<char>(((c >> 0) & 0x7F) | 0x0);
-                buffer[1] = '\0';
-            } else if(c < (1 << 11)) {
-                buffer[0] = static_cast<char>(((c >> 6) & 0x1F) | 0xC0);
-                buffer[1] = static_cast<char>(((c >> 0) & 0x3F) | 0x80);
-                buffer[2] = '\0';
-            } else if(c < (1 << 16)) {
-                buffer[0] = static_cast<char>(((c >> 12) & 0x0F) | 0xE0);
-                buffer[1] = static_cast<char>(((c >> 6) & 0x3F) | 0x80);
-                buffer[2] = static_cast<char>(((c >> 0) & 0x3F) | 0x80);
-                buffer[3] = '\0';
-            } else if(c < (1 << 21)) {
-                buffer[0] = static_cast<char>(((c >> 18) & 0x07) | 0xF0);
-                buffer[1] = static_cast<char>(((c >> 12) & 0x3F) | 0x80);
-                buffer[2] = static_cast<char>(((c >> 6) & 0x3F) | 0x80);
-                buffer[3] = static_cast<char>(((c >> 0) & 0x3F) | 0x80);
-                buffer[4] = '\0';
-            }
-        }
-
-        check_return static Error printChar(c32 u, u32 shift, u32 a, u32 o) {
-            return Core::putChar(static_cast<int>(((u >> shift) & a) | o));
-        }
-
-        void addToHash(c32 u) {
-            hash = static_cast<u32>(2120251889) * hash + static_cast<u32>(u);
-        }
+        Error add(char c);
+        void addToHash(c32 u);
 
         template<typename T, typename... Args>
         check_return Error formatBuffer(CharString& s, int index, const T& t,
@@ -376,12 +126,7 @@ namespace Core {
             return formatBuffer(s, index, Core::forward<Args>(args)...);
         }
 
-        check_return Error formatBuffer(CharString& s, int index) {
-            while(index < length) {
-                CORE_RETURN_ERROR(s.append(data[index++]));
-            }
-            return Error::NONE;
-        }
+        check_return Error formatBuffer(CharString& s, int index);
 
         template<typename T>
         check_return Error convertAppend(T t) {

src/ArrayString.cpp

@@ -2,6 +2,9 @@
 
 #include "core/utils/Error.hpp"
 
+using CharString = Core::CharString;
+using Error = Core::Error;
+
 static c32 read(const char*& s) {
     if(*s == '\0') {
         return 0;
@@ -9,7 +12,7 @@ static c32 read(const char*& s) {
     return static_cast<c32>(*(s++));
 }
 
-Core::Error Core::readUnicode(c32& u, const char*& s) {
+Error Core::readUnicode(c32& u, const char*& s) {
     u = read(s);
     if((u & 0x80) == 0) {
         return Error::NONE;
@@ -42,3 +45,310 @@ Core::Error Core::readUnicode(c32& u, const char*& s) {
     }
     return Error::INVALID_CHAR;
 }
+
+template<unsigned int L>
+void unicodeToChar(c32 c, char (&buffer)[L]) {
+    static_assert(L >= 5, "to small char buffer");
+    buffer[0] = '\0';
+    if(c < (1 << 7)) {
+        buffer[0] = static_cast<char>(((c >> 0) & 0x7F) | 0x0);
+        buffer[1] = '\0';
+    } else if(c < (1 << 11)) {
+        buffer[0] = static_cast<char>(((c >> 6) & 0x1F) | 0xC0);
+        buffer[1] = static_cast<char>(((c >> 0) & 0x3F) | 0x80);
+        buffer[2] = '\0';
+    } else if(c < (1 << 16)) {
+        buffer[0] = static_cast<char>(((c >> 12) & 0x0F) | 0xE0);
+        buffer[1] = static_cast<char>(((c >> 6) & 0x3F) | 0x80);
+        buffer[2] = static_cast<char>(((c >> 0) & 0x3F) | 0x80);
+        buffer[3] = '\0';
+    } else if(c < (1 << 21)) {
+        buffer[0] = static_cast<char>(((c >> 18) & 0x07) | 0xF0);
+        buffer[1] = static_cast<char>(((c >> 12) & 0x3F) | 0x80);
+        buffer[2] = static_cast<char>(((c >> 6) & 0x3F) | 0x80);
+        buffer[3] = static_cast<char>(((c >> 0) & 0x3F) | 0x80);
+        buffer[4] = '\0';
+    }
+}
+
+CharString::CharString(char* buffer, i32 bufferSize)
+    : length(0), capacity(bufferSize), hash(0), data(buffer) {
+    data[0] = '\0';
+}
+
+Error CharString::copyFrom(const CharString& s) {
+    clear();
+    return s.toString(*this);
+}
+
+bool CharString::operator==(const char* s) const {
+    const char* p = data;
+    while(*s == *p && *s != '\0') {
+        s++;
+        p++;
+    }
+    return *s == *p;
+}
+
+bool CharString::operator==(const CharString& other) const {
+    if(length != other.getLength()) {
+        return false;
+    }
+    for(int i = 0; i < length; i++) {
+        if(data[i] != other[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool CharString::operator!=(const char* s) const {
+    return !((*this) == s);
+}
+
+bool CharString::operator!=(const CharString& other) const {
+    return !((*this) == other);
+}
+
+char CharString::operator[](int index) const {
+    return data[index];
+}
+
+int CharString::getLength() const {
+    return length;
+}
+
+int CharString::getCapacity() const {
+    return capacity - 1;
+}
+
+Error CharString::append(char c) {
+    return add(c);
+}
+
+Error CharString::append(signed char c) {
+    return append(static_cast<char>(c));
+}
+
+Error CharString::append(unsigned char c) {
+    return append(static_cast<char>(c));
+}
+
+Error CharString::append(wchar_t c) {
+    return append(static_cast<c32>(c));
+}
+
+Error CharString::append(c32 c) {
+    char buffer[5];
+    unicodeToChar(c, buffer);
+    return append(static_cast<const char*>(buffer));
+}
+
+Error CharString::append(const char* s) {
+    // stringLength as s could be some part of data
+    for(int i = stringLength(s); i > 0; i--) {
+        CORE_RETURN_ERROR(append(*(s++)));
+    }
+    return Error::NONE;
+}
+
+Error CharString::append(const c32* s) {
+    // stringLength as s could be some part of data
+    for(int i = stringLength(s); i > 0; i--) {
+        CORE_RETURN_ERROR(append(*(s++)));
+    }
+    return Error::NONE;
+}
+
+Error CharString::append(const signed char* s) {
+    return append(reinterpret_cast<const char*>(s));
+}
+
+Error CharString::append(const unsigned char* s) {
+    return append(reinterpret_cast<const char*>(s));
+}
+
+Error CharString::append(signed short s) {
+    return convertAppend(s);
+}
+
+Error CharString::append(unsigned short s) {
+    return convertAppend(s);
+}
+
+Error CharString::append(signed int i) {
+    return convertAppend(i);
+}
+
+Error CharString::append(unsigned int i) {
+    return convertAppend(i);
+}
+
+Error CharString::append(signed long l) {
+    return convertAppend(l);
+}
+
+Error CharString::append(unsigned long l) {
+    return convertAppend(l);
+}
+
+Error CharString::append(signed long long ll) {
+    return convertAppend(ll);
+}
+
+Error CharString::append(unsigned long long ll) {
+    return convertAppend(ll);
+}
+
+Error CharString::append(float f) {
+    return convertAppend(f);
+}
+
+Error CharString::append(double d) {
+    return convertAppend(d);
+}
+
+Error CharString::append(long double ld) {
+    return convertAppend(ld);
+}
+
+Error CharString::append(bool b) {
+    return b ? append("true") : append("false");
+}
+
+Error CharString::append(Error e) {
+    return append(getErrorName(e));
+}
+
+Error CharString::toString(CharString& s) const {
+    int l = length; // length changes if &s == this
+    for(int i = 0; i < l; i++) {
+        CORE_RETURN_ERROR(s.append(data[i]));
+    }
+    return Error::NONE;
+}
+
+void CharString::clear() {
+    length = 0;
+    hash = 0;
+    data[0] = '\0';
+}
+
+u32 CharString::hashCode() const {
+    return hash;
+}
+
+Error CharString::print() const {
+    for(int i = 0; i < length; i++) {
+        CORE_RETURN_ERROR(Core::putChar(data[i]));
+    }
+    return Error::NONE;
+}
+
+Error CharString::printLine() const {
+    CORE_RETURN_ERROR(print());
+    CORE_RETURN_ERROR(Core::putChar('\n'));
+    return Error::NONE;
+}
+
+bool CharString::startsWidth(const CharString& other, int from) const {
+    if(from > length - other.getLength()) {
+        return false;
+    }
+    for(int i = 0; i < other.getLength(); i++) {
+        if(data[from + i] != other[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+int CharString::search(const CharString& other, int from) const {
+    for(int i = from; i < length; i++) {
+        if(startsWidth(other, i)) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+bool CharString::contains(const CharString& other, int from) const {
+    return search(other, from) >= 0;
+}
+
+int CharString::search(char u, int from) const {
+    for(int i = from; i < length; i++) {
+        if(data[i] == u) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+bool CharString::contains(char u, int from) const {
+    return search(u, from) >= 0;
+}
+
+Error CharString::substring(CharString& s, int from, int to) const {
+    s.clear();
+    from = Math::max(from, 0);
+    to = Math::min(to, length - 1);
+    for(int i = from; i <= to; i++) {
+        CORE_RETURN_ERROR(s.append(data[i]));
+    }
+    return Error::NONE;
+}
+
+Error CharString::substring(CharString& s, int from) const {
+    return substring(s, from, length - 1);
+}
+
+Error CharString::replace(CharString& s, const CharString& search,
+                          const CharString& replace) {
+    int i = 0;
+    while(i < length) {
+        if(startsWidth(search, i)) {
+            CORE_RETURN_ERROR(s.append(replace));
+            i += search.getLength();
+        } else {
+            CORE_RETURN_ERROR(s.append(data[i]));
+            i++;
+        }
+    }
+    return copyFrom(s);
+}
+
+void CharString::replace(char search, char replace) {
+    hash = 0;
+    for(int i = 0; i < length; i++) {
+        if(data[i] == search) {
+            data[i] = replace;
+        }
+        addToHash(static_cast<c32>(data[i]));
+    }
+}
+
+CharString::operator const char*() const {
+    return data;
+}
+
+Error CharString::add(char c) {
+    if(length >= capacity - 1) {
+        return Error::CAPACITY_REACHED;
+    }
+    data[length++] = c;
+    data[length] = '\0';
+    addToHash(static_cast<c32>(c));
+    return Error::NONE;
+}
+
+void CharString::addToHash(c32 u) {
+    hash = static_cast<u32>(2120251889) * hash + static_cast<u32>(u);
+}
+
+Error CharString::formatBuffer(CharString& s, int index) {
+    while(index < length) {
+        CORE_RETURN_ERROR(s.append(data[index++]));
+    }
+    return Error::NONE;
+}