tb_str.h

// ================================================================================
// ==      This file is a part of Turbo Badger. (C) 2011-2014, Emil Segerås      ==
// ==                     See tb_core.h for more information.                    ==
// ================================================================================

#ifndef TB_STR_H
#define TB_STR_H

#include "tb_types.h"
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <utility>
#include <string>

namespace tb {

#define TB_ALL_TO_TERMINATION 2147483647

const char *stristr(const char *arg1, const char *arg2);

class TBStrC
{
protected:
    char *s;
public:
    TBStrC(const char *str) : s(const_cast<char *>(str)) {}

    inline int Length() const                           { return (int)strlen(s); }
    inline bool IsEmpty() const                         { return s[0] == 0; }

    inline int Compare(const char* str) const           { return strcmp(s, str); }
    inline bool Equals(const char* str) const           { return !strcmp(s, str); }
    const char *CStr() const                            { return s; }

    inline const char & operator[](int n) const         { assert(n >= 0); assert(n <= Length()); return s[n]; }
    explicit inline operator const char *() const       { return s; }
    bool operator ==(const char *b) const               { return strcmp(s, b) == 0; }
    bool operator ==(const TBStrC &b) const             { return strcmp(s, b.s) == 0; }
    bool operator !=(const TBStrC &b) const             { return strcmp(s, b.s) != 0; }
    bool operator <(const TBStrC &b) const              { return strcmp(s, b.s) < 0; }

    bool operator ==(const std::string &b) const        { return s == b; }
};

class TBStr : public TBStrC
{
public:
    ~TBStr();
    TBStr();
    TBStr(const TBStr &str);
    TBStr(TBStr && str);
    TBStr(const char* str);
    TBStr(const char* str, int len);

    bool Set(TBStr str) { *this = str; return true; }
    bool SetFormatted(const char* format, ...) TB_POST_FORMAT(2,3);

    void Clear();

    void Remove(int ofs, int len);

    bool Insert(int ofs, const char *ins, int ins_len = TB_ALL_TO_TERMINATION);

    bool Append(const char *ins, int ins_len = TB_ALL_TO_TERMINATION) {
        return Insert((int)strlen(s), ins, ins_len);
    }

    bool Append(const TBStr & str) {
        return Insert((int)strlen(s), (const char *)str, str.Length());
    }

    char *CStr() const                                  { return s; }

    double atof() const                                 { return ::atof(s); }

    int atoi() const                                    { return ::atoi(s); }

    long atol() const                                   { return ::atol(s); }

    explicit inline operator char *() const             { return s; }

    inline operator std::string() const                 { return std::string(s); }

    explicit operator bool() const;

    TBStr & operator = (TBStr str)                      { std::swap(s, str.s); return *this; }

    char & operator *()                                 { return s[0]; }

    const char & operator *() const                     { return s[0]; }

    friend class TBValue;
};

} // namespace tb

#endif // TB_STR_H