ds_string.h

/* Copyright (C) 2017 - 2024, Thornwave Labs Inc - All Rights Reserved.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
 * Proprietary and confidential.
 * Written by Razvan Turiac <razvan.turiac@thornwave.com>
*/
 
#ifndef _DS_STRING_H
#define _DS_STRING_H
 
 
#include <stdint.h>
#include <stddef.h>
 
#include <stdarg.h>
#include <math.h>
 
 
 
class DsString
{
public:
    static const size_t npos = -1;      
 
    DsString(size_t max_length = 31);
 
    
    DsString(const char* str, size_t max_length = DsString::npos);
    
    
    DsString(const DsString &src);
 
    
    DsString(DsString &&src);
 
    
    ~DsString();
 
 
    DsString& operator=(const DsString &rhs);
 
    
    DsString& operator=(DsString &&rhs);
 
    
    DsString& operator=(const char* rhs);
 
    
    DsString& operator+=(const char* rhs);
 
    
    DsString operator+(const DsString &rhs);
 
    
    void append(char c, size_t count);
 
    
    void append(const char* str);
 
    
    void append(const char* str, size_t count);
 
    
    inline void append(char c)
    {
        append(c, 1);
    }
 
 
    inline void append(const DsString &str)
    {
        append(str.mString);
    }
 
    
    void insert(size_t pos, char c, size_t count);
 
    
    inline void insert(size_t pos, char c)
    {
        insert(pos, c, 1);
    }
 
    
    void insert(size_t pos, const char* str);
 
 
    void erase(size_t pos, size_t count);
 
 
    inline void erase_first(size_t count)
    {
        erase(0, count);
    }
 
    
    inline void erase_last(size_t count)
    {
        if (count <= mLength)
            erase(mLength - count, count);
        else
            clear();
    }
 
    
    void clear(void);
    
 
    void substr(char *substr, size_t pos, size_t count) const;
 
 
    const char* c_str(void) const
    {
        return mString;
    }
 
    
    operator const char*() const
    {
        return mString;
    }
 
    
    size_t length(void) const
    {
        return mLength;
    }
 
    
    size_t maxLength(void) const
    {
        return mCapacity - 1;
    }
 
    
    bool empty(void) const
    {
        return mLength == 0;
    }
 
    
    char front(void)
    {
        return mString[0];
    }
 
 
    char back(void)
    {
        if (mLength)
            return mString[mLength - 1];
        else
            return 0;
    }
 
 
    bool operator==(const char* rhs) const;
 
    
    inline bool operator!=(const char* rhs) const
    {
        return !(*this == rhs);
    }
 
    
    bool operator>=(const char* rhs) const;
    
    
    bool operator<=(const char* rhs) const;
 
 
    inline bool operator>(const char* rhs) const
    {
        return !(*this <= rhs);
    }
 
    
    inline bool operator<(const char* rhs) const
    {
        return !(*this >= rhs);
    }
 
 
    size_t format(const char* format, ...);
 
    
    size_t format(const char* format, va_list args);
 
    
    size_t find(char c, size_t pos = 0);
 
    
    size_t find(const char* substr, size_t pos = 0);
 
 
private:
    size_t mCapacity;
    size_t mLength;
    char* mString;
};
 
#endif