TagsList.h

#pragma once
 
class BinStream;
class BaseClass;
 
class APICALL TagsList
{
public:
    TagsList();
    ~TagsList();
    TagsList(const char* QuoteName);
    //new/delete are using pool, so this is fast
    void operator delete(void* ptr, size_t size);
    void* operator new(size_t size);
 
    int to_int () const;
    float to_float() const;
    bool to_bool() const;
    const char* to_string() const;
    float to_float();
    int get_data(void* buffer, int maxlength);
    
    static comms::cStr& LastTagFile();
    static comms::cStr& LastTag();
    static comms::cStr& defTab();
 
    int GetTagsFromString(const char* XMLSource);
    int PutTagsIntoString(comms::cStr* To, int shift = 0, bool fast = false);
    int GetTagsFromJsonString(const char* jsonSource);
    int PutTagsIntoJsonString(comms::cStr* Source, int shift = 0, bool treatAllAsText = false);
    bool ReadTagsFromFile(const char* FilePath);
    void WriteTagsToFile(const char* FilePath, bool OnlyChanged = false);
 
    void Assign(int v);
    void Assign(const char* s);
    // get/set parent for this tag 
    void SetParent(TagsList* Parent);
    TagsList* GetParent() const;
 
    TagsList* AddSubTag(TagsList* SubQ);
    TagsList* AddSubTag(const char* quotename, const char* body = "");
    TagsList* AddSubTag(const char* quotename, int body);
    TagsList* AddSubTag(const char* quotename, DWORD body);
    TagsList* AddSubTag(const char* quotename, short body);
    TagsList* AddSubTag(const char* quotename, WORD body);
    TagsList* AddSubTag(const char* quotename, char body);
    TagsList* AddSubTag(const char* quotename, float body);
    TagsList* AddSubTag(const char* quotename, void* data, int Length);
    TagsList& operator << (const char* string);
    TagsList& operator << (int value);
    TagsList& operator << (bool value);
    TagsList& operator << (float value);
    TagsList& operator << (const comms::cVec2& value);
    TagsList& operator << (const comms::cVec3& value);
    TagsList& operator << (const comms::cVec4& value);
    TagsList& operator << (const comms::cMat3& value);
    TagsList& operator << (const comms::cMat4& value);
    TagsList& operator << (BaseClass* BC);
    template <class X>
    TagsList& operator << (const cList<X>& array);
    template <typename X, typename TYPE>
    void StoreField(const char* tagname, const cList<X>& array, TYPE X::* member);
 
    void operator >> (comms::cStr& string_value);
    void operator >> (int& value);
    void operator >> (float& value);
    void operator >> (bool& value);
    void operator >> (comms::cVec2& value);
    void operator >> (comms::cVec3& value);
    void operator >> (comms::cVec4& value);
    void operator >> (comms::cMat3& value);
    void operator >> (comms::cMat4& value);
    void operator >> (BaseClass* BC);
    template <class X>
    void operator >> (cList<X>& array);
    template <typename X, typename TYPE>
    void RestoreField(cList<X>& array, TYPE X::* member);
    
    
    void bin_ToBS(BinStream& BS);
    void text_ToBS(BinStream& BS);
    bool FromBS(BinStream& BS);
    
    comms::cStr& body();
        
    TagsList* GetSubTag(int Index);
    TagsList* elem(int Index); 
    TagsList* operator[](int Index);
    TagsList* GetSubTag(const char* SubQuoteName);
    int GetSubTagIndex(const char* SubQuoteName);
    TagsList* elem(const char* SubQuoteName); 
    TagsList* operator[](const char* SubQuoteName);
    int GetSubTagsCount();
    int length();
 
    void RemoveSubTag(int idx);
    void RemoveSubTag(const char* id);
    TagsList* RemoveAndGetSubTag(int idx);
 
    const char* GetTagName();
    void SetTagName(const char* Name);
    void FreeTag();
    void operator = (TagsList& src);
    static const char* GetConstantLocation(const char* str);
    static int& GetConstantLocationValueRef(const char* str);
    static const char* GetConstantSubstringLocation(const char* str, int Len, int** value = nullptr);
 
    void setAsArray(bool isArray);
    bool isArray() const;
private:
    const char* _tagname;
    const char* _tag(const char* tag);
    comms::cList<TagsList*> SubTags;
    comms::cStr TagBody;
    TagsList* _parent;
    bool _isArray;
 
};
 
template <class X>
void TagsList::operator>>(cList<X>& array) {
    array.Free();
    if (this) {
        const char* s = body().ToCharPtr();
        if (body().Length()) {
            cPtrDiff num = *((int*)s);
            cPtrDiff sz = *((int*)(s + 4));
            if (sz == sizeof(X)) {
                X val;
                array.Add(val, num);
                memcpy(array.ToPtr(), s + 8, num * sz);
            }
        }
    }
}
 
template <typename X, typename TYPE>
void TagsList::RestoreField(cList<X>& array, TYPE X::* member) {
    if (this) {
        const char* s = body().ToCharPtr();
        if (body().Length()) {
            cPtrDiff num = *((int*)s);
            cPtrDiff sz = *((int*)(s + 4));
            if (sz == sizeof(TYPE)) {
                TYPE val;
                if (array.Count() < num) {
                    X ref;
                    array.Add(ref, num - array.Count());
                }
                TYPE* TL = (TYPE*)(s + 8);
                for (int i = 0; i < num; i++) {
                    array[i].*member = *TL;
                    TL++;
                }
            }
        }
    }
}
 
template <class X>
TagsList& TagsList::operator<<(const cList<X>& array) {
    TagsList* T = AddSubTag(LastTag());
    if (array.Count()) {
        T->body().SetLength(4 + 4 + array.Count() * sizeof(X));
        char* s = T->body().ToNonConstCharPtr();
        *((int*)s) = array.Count();
        *((int*)(s + 4)) = sizeof(X);
        memcpy(s + 8, array.ToPtr(), cPtrDiff(array.Count()) * sizeof(X));
    }
    LastTag().Clear();
    return *T;
}
 
template <typename X, typename TYPE>
void TagsList::StoreField(const char* tagname, const cList<X>& array, TYPE X::* member) {
    TagsList* T = AddSubTag(tagname);
    if (array.Count()) {
        T->body().SetLength(4 + 4 + array.Count() * sizeof(TYPE));
        char* s = T->body().ToNonConstCharPtr();
        *((int*)s) = array.Count();
        *((int*)(s + 4)) = sizeof(TYPE);
        TYPE* TL = (TYPE*)(s + 8);
        for (int i = 0; i < array.Count();i++) {
            *TL = array[i].*member;
            TL++;
        }
    }
}
 
void ToBase64(BYTE* buf, int Len, comms::cStr& dest);
void ToBase64(BYTE* buf, int Len, std::string& dest);
int ReadBase64(const char* src, BYTE* buf, int MaxLen);
 
TagsList* new_TagsList();
inline TagsList* new_TagsList(const char* s){
    TagsList* x=new_TagsList();
    x->SetTagName(s);
    return x;
}
void delete_TagsList(TagsList* x);
inline void TagsList::operator delete(void* ptr, size_t size) {
    delete_TagsList((TagsList*)ptr);
}
inline void* TagsList::operator new(size_t size) {
    return new_TagsList();
}
 
inline comms::cStr& TagsList::body() {
    return TagBody;
}
 
inline void TagsList::setAsArray(bool isArray) {
    this->_isArray = isArray;
}
 
inline bool TagsList::isArray() const {
    return _isArray;
}