string.cpp

Go to the documentation of this file.

 
#include <common/string.h>
 
using namespace MaxOS;
 
String::String() {
 
    // String that only contains the null terminator
    m_length = 0;
    allocate_self();
    m_string[0] = '\0';
 
 
}
 
String::String(char c) {
 
    // Create the memory
    m_length = 1;
    allocate_self();
 
    // Store the char
    m_string[0] = c;
    m_string[m_length] = '\0';
 
 
}
 
String::String(char const* string) {
 
    // Get the length of the string, prevent longer than 10000 because this should mean something's gone wrong
    m_length = 0;
    while (string[m_length] != '\0' && m_length <= 10000)
        m_length++;
    allocate_self();
 
    // Copy the string
    for (size_t i = 0; i < m_length; i++)
        m_string[i] = string[i];
 
    // If the length is more than 10,000 Replace the end with a warning incase future use actually requires that
    const char* warning = "MAXOS: String length exceeded 10000 - might be a bug";
    if (m_length > 10000)
        for (int i = 0; i < 52; i++)
            m_string[m_length - 52 + i] = warning[i];
 
    m_string[m_length] = '\0';
}
 
String::String(uint8_t const* string, int length) {
    // Allocate memory for the string (and null terminator)
    m_length = length;
    allocate_self();
 
    // Copy the string
    for (int i = 0; i < length; i++)
        m_string[i] = string[i];
 
    // Write the null terminator
    m_string[length] = '\0';
}
 
String::String(int value) {
 
    // Convert to a string
    const char* str = itoa(10, value);
    m_length = strlen(str);
 
    // Create space to store
    allocate_self();
 
    // Store the string
    for (size_t i = 0; i < m_length; i++)
        m_string[i] = str[i];
    m_string[m_length] = '\0';
 
}
 
String::String(uint64_t value) {
 
    // Convert to a string
    const char* str = htoa(value);
    m_length = strlen(str);
 
    // Create space to store
    allocate_self();
 
    // Store the string
    for (size_t i = 0; i < m_length; i++)
        m_string[i] = str[i];
    m_string[m_length] = '\0';
}
 
String::String(bool value) {
 
    if (value)
        *this = string("true");
    else
        *this = string("false");
 
}
 
String::String(String const& other) {
    copy(other);
}
 
String::~String() {
 
    // Free the memory
    if (!m_using_small)
        delete[] m_string;
 
}
 
void String::copy(String const& other) {
 
    // Allocate memory for the string (and null terminator)
    m_length = other.length();
    allocate_self();
 
    // Copy the string
    for (size_t i = 0; i < m_length; i++)
        m_string[i] = other[i];
 
    // Write the null terminator
    m_string[m_length] = '\0';
 
}
 
int String::lex_value(String const& string) {
 
    // Sum the ascii values of the characters in the string
    int sum = 0;
    for (size_t i = 0; i < string.length(); i++)
        sum += string[i];
 
    return sum;
}
 
void String::allocate_self() {
 
    // Clear the old buffer if in use
    if (m_string && !m_using_small)
        delete[] m_string;
 
    // Try to use the small string buffer
    m_using_small = m_length + 1 <= MAX_STRING_SMALL_STORAGE;
    m_string = m_using_small ? m_small_string : new char[m_length + 1];
 
}
 
String& String::operator =(String const& other) {
 
    // Self assignment check
    if (this == &other)
        return *this;
 
    // Copy the other string
    copy(other);
    return *this;
}
 
char* String::c_str() {
 
    return m_string;
}
 
const char* String::c_str() const {
 
    return m_string;
}
 
bool String::starts_with(String const& other) {
 
    // Must at least be able to fit the other string
    if (m_length < other.length())
        return false;
 
    // Check if the string starts with the other string
    for (size_t i = 0; i < other.length(); i++)
        if (m_string[i] != other[i])
            return false;
 
    // No string left over to check so it must contain other
    return true;
}
 
String String::substring(size_t start, size_t length) const {
 
    // Ensure the start is within bounds
    if (start >= m_length)
        return { };
 
    // Ensure the length is within bounds
    if (start + length > m_length)
        return { };
 
    // Allocate memory for the substring (and null terminator)
    String substring;
    substring.m_length = length;
    substring.allocate_self();
 
    // Copy the substring
    for (size_t i = 0; i < length; i++)
        substring.m_string[i] = m_string[start + i];
 
    // Write the null terminator
    substring.m_string[length] = '\0';
 
    return substring;
}
 
common::Vector<String> String::split(String const& delimiter) const {
    common::Vector<String> strings;
 
    // Go through the string and split it by the delimiter
    size_t start = 0;
    for (size_t i = 0; i <= m_length - delimiter.length(); i++) {
 
        // Check if matches at this position
        bool matches = true;
        for (size_t j = 0; j < delimiter.length(); j++)
            if (m_string[i + j] != delimiter[j]) {
                matches = false;
                break;
            }
 
        if (!matches)
            continue;
 
        // Add the splice of the string
        strings.push_back(substring(start, i - start));
        start = i + delimiter.length();
        i += delimiter.length() - 1;
    }
 
    // Add the last string to the vector
    strings.push_back(substring(start, m_length - start));
 
    return strings;
}
 
size_t String::length(bool count_ansi) const {
 
    // If ansi characters are not to be counted
    if (count_ansi)
        return m_length;
 
    // Calculate the length of the string without ansi characters
    int total_length = 0;
    int clean_length = 0;
    while (m_string[total_length] != '\0') {
 
        // If the character is an ansi character, skip it
        if (m_string[total_length] == '\033')
            while (m_string[total_length] != 'm')
                total_length++;
 
        // Increment the length
        clean_length++;
        total_length++;
    }
 
    // Return the length
    return clean_length;
}
 
bool String::equals(String const& other) const {
 
    // Check if the lengths are equal
    if (m_length != other.length())
        return false;
 
    // Check if the characters are equal
    for (size_t i = 0; i < m_length; i++)
        if (m_string[i] != other[i])
            return false;
 
    // The strings are equal
    return true;
 
}
 
bool String::operator ==(String const& other) const {
 
    // Check if the strings are equal
    return equals(other);
}
 
bool String::operator !=(String const& other) const {
 
    // Self assignment check
    if (*this == other)
        return false;
 
    return !equals(other);
}
 
bool String::operator <(String const& other) const {
 
    return lex_value(*this) < lex_value(other);
 
}
 
bool String::operator >(String const& other) const {
 
    return lex_value(*this) > lex_value(other);
 
}
 
bool String::operator <=(String const& other) const {
 
    return lex_value(*this) <= lex_value(other);
 
}
 
bool String::operator >=(String const& other) const {
 
    return lex_value(*this) >= lex_value(other);
 
}
 
String String::operator +(String const& other) const {
 
    // The concatenated string
    String concatenated;
    concatenated.m_length = m_length + other.length();
    concatenated.allocate_self();
 
    // Copy the first string
    for (size_t i = 0; i < m_length; i++)
        concatenated.m_string[i] = m_string[i];
 
    // Copy the second string
    for (size_t i = 0; i < other.length(); i++)
        concatenated.m_string[m_length + i] = other[i];
 
    // Write the null terminator
    concatenated.m_string[concatenated.m_length] = '\0';
 
    // Return the concatenated string
    return concatenated;
}
 
String& String::operator +=(String const& other) {
 
    // Add the other string to this string
    String concatenated = *this + other;
    copy(concatenated);
    return *this;
}
 
 
char& String::operator [](size_t index) {
    return m_string[index];
}
 
 
char& String::operator [](size_t index) const {
    return m_string[index];
}
 
String String::operator *(int times) const {
 
    // The repeated string
    String repeated;
    repeated.m_length = m_length * times;
    repeated.allocate_self();
 
    // Copy the string
    for (int i = 0; i < times; i++)
        for (size_t j = 0; j < m_length; j++)
            repeated.m_string[i * m_length + j] = m_string[j];
 
    // Write the null terminator
    repeated.m_string[repeated.m_length] = '\0';
 
    // Return the repeated string
    return repeated;
 
}
 
String String::center(size_t width, char fill) const {
 
    // The number of characters to add
    size_t add = (width - m_length) / 2;
 
    // The centered string
    String centered;
    centered.m_length = width;
    centered.allocate_self();
 
    // Fill the right side (before)
    for (size_t i = 0; i < add; i++)
        centered.m_string[i] = fill;
 
    // Copy the string (middle)
    for (size_t i = 0; i < m_length; i++)
        centered.m_string[add + i] = m_string[i];
 
    // Fill the left side (after)
    for (size_t i = add + m_length; i < width; i++)
        centered.m_string[i] = fill;
 
    // Write the null terminator
    centered.m_string[width] = '\0';
 
    return centered;
}
 
String String::strip(char strip_char) const {
 
    // The stripped string
    String stripped;
    stripped.copy(*this);
 
    // Search from the back for the earliest non-whitespace character
    size_t end = m_length - 1;
    while (end >= 0 && (m_string[end] == strip_char || m_string[end] == '\n' || m_string[end] == '\t'))
        end--;
 
    // Make sure there is something to strip
    if (end < 0)
        return stripped;
 
    // Split the string to remove the end
    return stripped.substring(0, end + 1);
}
 
String String::formatted(char const* format, ...) {
 
    // Create a pointer to the data
    va_list parameters;
    va_start(parameters, format);
 
    return formatted(format, parameters);
 
}
 
String String::formatted(char const* format, va_list parameters) {
 
    String out;
 
    // Loop through the format string
    for (; *format != '\0'; format++) {
 
        // If it is not a %, print the character
        if (*format != '%') {
            out += (string) (char) (*format);
            continue;
        }
 
        // Move to the next character
        format++;
        switch (*format) {
            case 'd': {
                // Print a decimal
                int number = va_arg (parameters, int);
                out += (string) (number);
                break;
            }
            case 'x': {
                // Print a hex
                uint64_t number = va_arg (parameters, uint64_t);
                out += (string) (number);
                break;
            }
            case 's': {
                // Print a string
                char* str = va_arg (parameters, char*);
                out += (string) (str);
                break;
            }
        }
    }
 
    return out;
 
}
 
int strlen(const char* str) {
    int len = 0;
    for (; str[len] != '\0'; len++);
    return len;
}
 
char* itoa(int base, int64_t number) {
 
    // If there is no buffer use a default buffer
    static char buffer[50] = { 0 };
 
    int i = 49;
    bool is_negative = number < 0;
 
    // Null terminate the string
    buffer[i] = '\0';
    --i;
 
    if (number == 0) {
        buffer[i] = '0';
        return &buffer[i];
    }
 
 
    for (; number && i; --i, number /= base)
        buffer[i] = "0123456789ABCDEF"[number % base];
 
    if (is_negative) {
        buffer[i] = '-';
        return &buffer[i];
    }
 
    return &buffer[i + 1];
}
 
char* htoa(uint64_t number) {
    // If there is no buffer use a default buffer
    static char buffer[50] = { 0 };
    int i = 49;
 
    // Null terminate the string
    buffer[i] = '\0';
    --i;
 
    if (number == 0) {
        buffer[i] = '0';
        return &buffer[i];
    }
 
    for (; number && i; --i, number /= 16)
        buffer[i] = "0123456789ABCDEF"[number % 16];
 
    return &buffer[i + 1];
}
 
bool strcmp(char const* str1, char const* str2) {
 
    // Check if the strings are equal
    for (int i = 0; str1[i] != '\0' || str2[i] != '\0'; i++)
        if (str1[i] != str2[i])
            return false;
 
    // The strings are equal
    return true;
 
}
 
bool strcmp(char const* str1, String const& str2) {
 
    // Use the other strcmp function
    return strcmp(str1, str2.c_str());
 
}
 
bool strcmp(String const& str1, char const* str2) {
 
    // Use the other strcmp function
    return strcmp(str1.c_str(), str2);
}
 
bool strcmp(String const& str1, String const& str2) {
 
    // Use the other strcmp function
    return strcmp(str1.c_str(), str2.c_str());
 
}
 
bool strncmp(char const* str1, char const* str2, int length) {
 
    // Check if the strings are equal
    for (int i = 0; i < length; i++)
        if (str1[i] != str2[i])
            return false;
 
    // Strings are equal
    return true;
 
}
 
bool strncmp(char const* str1, String const& str2, int length) {
 
    // Use the other strncmp function
    return strncmp(str1, str2.c_str(), length);
 
}
 
bool strncmp(String const& str1, char const* str2, int length) {
 
    // Use the other strncmp function
    return strncmp(str1.c_str(), str2, length);
 
}
 
bool strncmp(String const& str1, String const& str2, int length) {
 
    // Use the other strncmp function
    return strncmp(str1.c_str(), str2.c_str(), length);
}
 
StringBuilder& StringBuilder::operator <<(char const* str) {
    out += string(str);
    return *this;
}
 
StringBuilder& StringBuilder::operator <<(String const& other) {
    out += other;
    return *this;
}
 
StringBuilder& StringBuilder::operator <<(int value) {
    out += string(value);
    return *this;
}
 
StringBuilder& StringBuilder::operator <<(uint64_t value) {
    out += string(value);
    return *this;
}
 
StringBuilder& StringBuilder::operator <<(bool value) {
    out += string(value);
    return *this;
}