nbstring.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef DEF_NB_STRING
#define DEF_NB_STRING (1)
 
#include <stdint.h>
#include <stdio.h>
#include <system.h>
#include <fd_adapter.h>
class JsonRef;
class ParsedJsonDataSet;
 
 
const int native_string_storage = 15;   // Strings up to this amount are stored locally instead of allocating memory
 
 
//Flag for no position or last position in string.
//named npos to be compaitblke with other string clsses...
const size_t npos = -1;
const size_t NO_POS =-1; //More inline with netburner code foiomats constats are all caps.
 
const uint8_t FLAG_LOCAL = 0x80;
const uint8_t FLAG_CONST = 0x40;
const uint8_t FLAG_ALLOC = 0x20;
const uint8_t FLAG_CLEAR_LOCAL_MASK = 0x7F;
const int EXTRA_ALLOC_SPACE = 64;
 
 
 
 
struct nbstring_allocated_info
{
    uint8_t flag;   // 0 = local storage, > native_string_storage = allocated memory
    uint8_t unused1;
    uint16_t unused2;
    uint32_t used;      // How many bytes are used in the string
    uint32_t alloced;   // Size of data pointed at by pData (used and unused). Will be 0 for data declared as constant
    uint8_t *pData;     // Pointer to string
};
 
struct nbstring_local
{
    uint8_t siz_flag;                      // Number of bytes stored in local storage
    uint8_t stor[native_string_storage];   // actual string data stored locally
};
 
class NBStorageManager
{
   private:
    union
    {
        nbstring_local nbss;
        nbstring_allocated_info inf;
    };
 
   public:
    inline bool IsConstStore() const {return  ((inf.flag & FLAG_CONST)!=0);};
    inline bool IsLocalStore() const { return ((inf.flag & FLAG_LOCAL)!=0);};
 
    void reservespace(size_t n);
    void setusedsize(size_t n);
 
    size_t GetUsed() const;
    size_t GetAvailable() const;
    char *GetBuf();
    const char *GetConstBuf() const;
 
    void SetFromConstant(const char *c, int len);
 
    void clear();
 
    ~NBStorageManager();
    NBStorageManager();
 
    static void swap(NBStorageManager &n1, NBStorageManager &n2);
#ifdef STRING_DIAGS
    void DumpDiag();
#endif
};
 
class NBString;
 
 
class NBStringBuilder : public NBStorageManager, public fd_adapter
{
   public:
    int read(char *buf, int nbytes) override;
    int write(const char *buf, int nbytes) override;
    int close() override;
 
    void moveTo(NBString &s);
};
 
class NBString
{
    bool endswith(const char *s, size_t slen);
   protected:
    NBStorageManager nbs;
 
    void DoStorage(const char *cp, int len);
 
    static bool testInterpolationModifier(const char *begin, const char *end);
    void modifyInterpValue(char *bufStart, char *valStart, const char *valEnd, const char *modStart, const char *modEnd);
 
 
   public:
    // constructors
    NBString();
 
    NBString(const NBString &str);
 
    NBString(const NBString &str, size_t pos, size_t len = npos);
 
    NBString(const char *s);
 
    NBString(const char *s, size_t n);
 
    NBString(const JsonRef &jr);
    ~NBString();
 
    // Copy ...
    NBString &operator=(const NBString &str);
    NBString &operator=(const char *s);
    NBString &operator=(char c);
 
    //Actual assigment implimented in jsonlexer not NBString
    NBString &operator=(const JsonRef &jr);
 
 
 
    // Look up
    char &posRef(size_t pos);
    char &operator[](size_t pos);
    const char &operator[](size_t pos) const;
 
    const char *c_str() const;
 
    NBString substr(size_t pos = 0, size_t len = npos) const;
 
    int compare(const NBString &str) const;
 
    int compare(const char *s) const;
 
    /*
     * The following methods implement finding a string within another string.
     * str - The string to find in this string.
     * pos - The position in this string to start searching.
     * n - How many characters of str to search for.
     * c - What character to find.
     *
     * Returns a -1 if unable to find or if the search fails.
     */
    size_t find(const NBString str, size_t pos = 0) const;
 
    size_t find(const char *str, size_t pos = 0) const;
 
    size_t find(const char *s, size_t pos, size_t n) const;
 
    size_t find(char c, size_t pos = 0) const;
 
    size_t replace(const char *findStr, char rep, size_t startPos = 0, size_t end = 0);
 
    size_t replace(char c, char rep, size_t startPos = 0, size_t end = 0);
 
 
    bool endswith(const char *s);
 
 
    void shrink(int n);
 
 
    size_t size() const;
 
    size_t length() const;
 
    void clear();
 
    bool empty() const;
 
    NBString &Append(const char *str, size_t len);
 
    NBString &FdAppend(int fd, size_t len);
 
    NBString &Reserve(size_t len);
 
    NBString &operator+=(const NBString &str);
    NBString &operator+=(const char *str);
    NBString &operator+=(char c);
 
 
    NBString & ToB64Url();
 
 
 
#ifdef STRING_DIAGS
    void DumpDiag();
#endif
 
    friend void swap(NBString &x, NBString &y);
 
    friend void NBStringBuilder::moveTo(NBString &);
    // concatinate
    friend NBString operator+(const NBString &lhs, const NBString &rhs);
    friend NBString operator+(const NBString &lhs, const char *rhs);
    friend NBString operator+(const char *lhs, const NBString &rhs);
    friend NBString operator+(const NBString &lhs, char rhs);
    friend NBString operator+(char lhs, const NBString &rhs);
 
    // Compare...
    friend bool operator==(const NBString &lhs, const NBString &rhs);
    friend bool operator==(const char *lhs, const NBString &rhs);
    friend bool operator==(const NBString &lhs, const char *rhs);
    friend bool operator!=(const NBString &lhs, const NBString &rhs);
    friend bool operator!=(const char *lhs, const NBString &rhs);
    friend bool operator!=(const NBString &lhs, const char *rhs);
    friend bool operator<(const NBString &lhs, const NBString &rhs);
    friend bool operator<(const char *lhs, const NBString &rhs);
    friend bool operator<(const NBString &lhs, const char *rhs);
    friend bool operator<=(const NBString &lhs, const NBString &rhs);
    friend bool operator<=(const char *lhs, const NBString &rhs);
    friend bool operator<=(const NBString &lhs, const char *rhs);
    friend bool operator>(const NBString &lhs, const NBString &rhs);
    friend bool operator>(const char *lhs, const NBString &rhs);
    friend bool operator>(const NBString &lhs, const char *rhs);
    friend bool operator>=(const NBString &lhs, const NBString &rhs);
    friend bool operator>=(const char *lhs, const NBString &rhs);
    friend bool operator>=(const NBString &lhs, const char *rhs);
 
    // Member functions to add that are not in the standard string classes
 
    int vsiprintf(const char *format, va_list &vl);
 
    int sprintf(const char *format, ...);
 
    int sprintf(NBString const format, ...);
 
    int siprintf(const char *format, ...);
 
    int siprintf(NBString const format, ...);
 
    int stoi() const;
 
    long stol() const;
 
    unsigned int stoui() const;
    unsigned int stouihex() const;
 
    unsigned long stoul() const;
    unsigned long stoulhex() const;
 
 
    double stod() const;
 
    IPADDR to_ipaddr() const;
 
 
    /*
    Calculate the base64url encode and returnt he string.
    */
    friend NBString  b64UrlToString(const puint8_t p, int len);
 
 
 
 
    /* Possible future additions, Compare substrings.
    int compare (size_t pos, size_t len, const NBString& str) const;
    int compare (size_t pos, size_t len, const NBString& str,size_t subpos, size_t sublen) const;
    int compare (size_t pos, size_t len, const char* s) const;
    int compare (size_t pos, size_t len, const char* s, size_t n) const;
    */
 
    size_t copy(char *s, size_t len, size_t pos = 0) const;
 
    size_t strcopy(char *s, size_t len, size_t pos = 0) const;
 
    bool Interpolate(NBString &dest);
 
    inline bool Interpolate() { return Interpolate(*this); }
};
 
NBString  b64UrlToString(const puint8_t p, int len);
 
 
class NBInterpolatedString : public NBString
{
    bool bNeedInterpolate;
public:
    // constructors
    NBInterpolatedString();
 
    NBInterpolatedString(const NBString &str);
 
    NBInterpolatedString(const NBString &str, size_t pos, size_t len = npos);
 
    NBInterpolatedString(const char *s);
 
    NBInterpolatedString(const char *s, size_t n);
 
    ~NBInterpolatedString();
 
    // Copy ...
    NBInterpolatedString &operator=(const NBString &str);
    NBInterpolatedString &operator=(const char *s);
 
    NBString &Append(const char *str, size_t len);
 
    NBString &FdAppend(int fd, size_t len);
 
    NBString &operator+=(const NBString &str);
    NBString &operator+=(const char *str);
    NBString &operator+=(char c);
 
    NBInterpolatedString &Interpolate();
};
 
 
 
 
 
 
 
// concatinate
NBString operator+(const NBString &lhs, const NBString &rhs);
NBString operator+(const NBString &lhs, const char *rhs);
NBString operator+(const char *lhs, const NBString &rhs);
NBString operator+(const NBString &lhs, char rhs);
NBString operator+(char lhs, const NBString &rhs);
 
// Compare...
inline bool operator==(const NBString &lhs, const NBString &rhs)
{
    return lhs.compare(rhs) == 0;
};
inline bool operator==(const char *lhs, const NBString &rhs)
{
    return rhs.compare(lhs) == 0;
};
inline bool operator==(const NBString &lhs, const char *rhs)
{
    return lhs.compare(rhs) == 0;
};
inline bool operator!=(const NBString &lhs, const NBString &rhs)
{
    return lhs.compare(rhs) != 0;
};
inline bool operator!=(const char *lhs, const NBString &rhs)
{
    return rhs.compare(lhs) != 0;
};
inline bool operator!=(const NBString &lhs, const char *rhs)
{
    return lhs.compare(rhs) != 0;
};
inline bool operator<(const NBString &lhs, const NBString &rhs)
{
    return lhs.compare(rhs) > 0;
};
inline bool operator<(const char *lhs, const NBString &rhs)
{
    return rhs.compare(lhs) < 0;
};
inline bool operator<(const NBString &lhs, const char *rhs)
{
    return lhs.compare(rhs) > 0;
};
inline bool operator<=(const NBString &lhs, const NBString &rhs)
{
    return lhs.compare(rhs) >= 0;
};
inline bool operator<=(const char *lhs, const NBString &rhs)
{
    return rhs.compare(lhs) <= 0;
};
inline bool operator<=(const NBString &lhs, const char *rhs)
{
    return lhs.compare(rhs) >= 0;
};
inline bool operator>(const NBString &lhs, const NBString &rhs)
{
    return lhs.compare(rhs) < 0;
};
inline bool operator>(const char *lhs, const NBString &rhs)
{
    return rhs.compare(lhs) > 0;
};
inline bool operator>(const NBString &lhs, const char *rhs)
{
    return lhs.compare(rhs) < 0;
};
inline bool operator>=(const NBString &lhs, const NBString &rhs)
{
    return lhs.compare(rhs) <= 0;
};
inline bool operator>=(const char *lhs, const NBString &rhs)
{
    return rhs.compare(lhs) >= 0;
};
inline bool operator>=(const NBString &lhs, const char *rhs)
{
    return lhs.compare(rhs) <= 0;
};
 
 
 
 
#endif