path: root/library/cpp/scheme/scimpl.h

#pragma once 
 
#include "scheme.h" 
 
#include <util/stream/output.h> 
 
namespace NSc { 
    struct TValue::TScCore : TAtomicRefCount<TScCore, TDestructor>, TNonCopyable { 
        TPoolPtr Pool;
        double FloatNumber = 0; 
        i64 IntNumber = 0; 
        TStringBuf String; 
        TDict Dict; 
        TArray Array; 
        TValue::EType ValueType = TValue::EType::Null;
 
        TScCore(TPoolPtr& p) 
            : Pool(p)
            , Dict(Pool->Get())
            , Array(Pool->Get())
        {
        }
 
        bool IsNull() const { 
            return TValue::EType::Null == ValueType;
        } 
 
        bool IsBool() const { 
            return TValue::EType::Bool == ValueType;
        } 
 
        bool IsIntNumber() const { 
            return TValue::EType::IntNumber == ValueType || IsBool();
        } 
 
        bool IsNumber() const { 
            return TValue::EType::FloatNumber == ValueType || IsIntNumber();
        } 
 
        bool IsString() const { 
            return TValue::EType::String == ValueType;
        } 
 
        bool IsArray() const { 
            return TValue::EType::Array == ValueType;
        } 
 
        bool IsDict() const { 
            return TValue::EType::Dict == ValueType;
        } 
 
        bool HasChildren() const { 
            return GetDict().size() + GetArray().size(); 
        } 
 
        void SetNull() { 
            ValueType = TValue::EType::Null;
        } 
 
        void SetArray() { 
            if (Y_LIKELY(IsArray())) { 
                return; 
            } 
 
            ValueType = TValue::EType::Array;
            Array.clear(); 
        } 
 
        void SetDict() { 
            if (Y_LIKELY(IsDict())) { 
                return; 
            } 
 
            ValueType = TValue::EType::Dict;
            Dict.clear(); 
        } 
 
        void SetNumber(double n) { 
            ValueType = TValue::EType::FloatNumber;
            FloatNumber = n; 
        } 
 
        void SetIntNumber(i64 n) { 
            ValueType = TValue::EType::IntNumber;
            IntNumber = n; 
        } 
 
        void SetBool(bool b) { 
            ValueType = TValue::EType::Bool;
            IntNumber = b; 
        } 
 
        void SetString(TStringBuf s) {
            SetOwnedString(Pool->AppendBuf(s));
        }

        void SetOwnedString(TStringBuf s) {
            ValueType = TValue::EType::String;
            String = s;
        } 
 
        double& GetNumberMutable(double defaultnum) { 
            switch (ValueType) { 
                case TValue::EType::Bool:
                    SetNumber(bool(IntNumber));
                    break;
                case TValue::EType::IntNumber:
                    SetNumber(IntNumber);
                    break;
                case TValue::EType::FloatNumber:
                    break;
                default:
                    SetNumber(defaultnum);
                    break;
            } 
 
            return FloatNumber; 
        } 
 
        i64& GetIntNumberMutable(i64 defaultnum) { 
            switch (ValueType) { 
                case TValue::EType::Bool:
                    SetIntNumber(bool(IntNumber));
                    break;
                case TValue::EType::IntNumber:
                    break;
                case TValue::EType::FloatNumber:
                    SetIntNumber(FloatNumber);
                    break;
                default:
                    SetIntNumber(defaultnum);
                    break;
            } 
 
            return IntNumber; 
        } 
 
        void ClearArray() { 
            if (!IsArray()) { 
                return; 
            } 
 
            Array.clear(); 
        } 
 
        void ClearDict() { 
            if (!IsDict()) { 
                return; 
            } 
 
            Dict.clear(); 
        } 
 
        double GetNumber(double d = 0) const { 
            switch (ValueType) { 
                case TValue::EType::Bool:
                    return (bool)IntNumber;
                case TValue::EType::IntNumber:
                    return IntNumber;
                case TValue::EType::FloatNumber:
                    return FloatNumber;
                default:
                    return d;
            } 
        } 
 
        i64 GetIntNumber(i64 n = 0) const { 
            switch (ValueType) { 
                case TValue::EType::Bool:
                    return (bool)IntNumber;
                case TValue::EType::IntNumber:
                    return IntNumber;
                case TValue::EType::FloatNumber:
                    return FloatNumber;
                default:
                    return n;
            } 
        } 
 
        bool GetBool(bool b = false) const { 
            return GetIntNumber(b); 
        } 
 
        TStringBuf GetString(TStringBuf s = TStringBuf()) const { 
            return IsString() ? String : s; 
        } 
 
        const TArray& GetArray() const { 
            return IsArray() ? Array : TValue::DefaultArray(); 
        } 
 
        TArray& GetArrayMutable() { 
            SetArray(); 
            return Array; 
        } 
 
        TDict& GetDictMutable() {
            SetDict();
            return Dict;
        }

        const TDict& GetDict() const { 
            return IsDict() ? Dict : TValue::DefaultDict(); 
        } 
 
        static void DoPush(TPoolPtr& p, TArray& a) { 
            a.push_back(TValue(p)); 
            a.back().CopyOnWrite = false; 
        } 
 
        TValue& Push() {
            SetArray(); 
            DoPush(Pool, Array);
            return Array.back(); 
        } 
 
        TValue Pop() { 
            if (!IsArray() || Array.empty()) { 
                return TValue::DefaultValue(); 
            } 
 
            TValue v = Array.back(); 
            Array.pop_back(); 
            return v; 
        } 
 
        const TValue& Get(size_t key) const { 
            return IsArray() && Array.size() > key ? Array[key] : TValue::DefaultValue(); 
        } 
 
        TValue* GetNoAdd(size_t key) {
            return IsArray() && Array.size() > key ? &Array[key] : nullptr;
        } 
 
        TValue& GetOrAdd(size_t key) {
            SetArray(); 
            for (size_t i = Array.size(); i <= key; ++i) { 
                DoPush(Pool, Array);
            } 
 
            return Array[key]; 
        } 
 
        TValue& Back() {
            SetArray(); 
 
            if (Array.empty()) { 
                DoPush(Pool, Array);
            } 
 
            return Array.back(); 
        } 
 
        TValue& Insert(size_t key) {
            SetArray(); 
 
            if (Array.size() <= key) { 
                return GetOrAdd(key);
            } else { 
                Array.insert(Array.begin() + key, TValue(Pool));
                Array[key].CopyOnWrite = false; 
                return Array[key]; 
            } 
        } 
 
        TValue Delete(size_t key) { 
            if (!IsArray() || Array.size() <= key) { 
                return TValue::DefaultValue(); 
            } 
 
            TValue v = Array[key]; 
            Array.erase(Array.begin() + key); 
            return v; 
        } 
 
        const TValue& Get(TStringBuf key) const { 
            if (!IsDict()) { 
                return TValue::DefaultValue(); 
            } 
 
            TDict::const_iterator it = Dict.find(key); 
            return it != Dict.end() ? it->second : TValue::DefaultValue(); 
        }

        TValue* GetNoAdd(TStringBuf key) {
            if (!IsDict()) { 
                return nullptr;
            } 

            return Dict.FindPtr(key);
        } 
 
        TValue& Add(TStringBuf key) {
            SetDict(); 
            TDict::iterator it = Dict.insert(std::make_pair(Pool->AppendBuf(key), TValue(Pool))).first;
            it->second.CopyOnWrite = false; 
            return it->second; 
        } 
 
        TValue& GetOrAdd(TStringBuf key) {
            SetDict(); 
            TDict::insert_ctx ctx; 
            TDict::iterator it = Dict.find(key, ctx); 
 
            if (it == Dict.end()) { 
                it = Dict.insert_direct(std::make_pair(Pool->AppendBuf(key), TValue(Pool)), ctx);
                it->second.CopyOnWrite = false; 
            } 
 
            return it->second; 
        } 
 
        TValue Delete(TStringBuf key) { 
            if (!IsDict()) { 
                return TValue::DefaultValue(); 
            } 
 
            TDict::iterator it = Dict.find(key); 
 
            if (it == Dict.end()) { 
                return TValue::DefaultValue(); 
            } 
 
            TValue v = it->second; 
            Dict.erase(key); 
            return v; 
        } 
    }; 
 
    TValue::TScCore* TValue::NewCore(TPoolPtr& p) { 
        return new (p->Pool.Allocate<TScCore>()) TScCore(p); 
    } 
 
    TValue::TValue() {
        auto p = TPoolPtr(new NDefinitions::TPool);
        TheCore = NewCore(p);
    }

    TValue::TValue(double t) 
        : TValue()
    { 
        SetNumber(t); 
    } 
 
    TValue::TValue(unsigned long long t) 
        : TValue()
    { 
        SetIntNumber(t); 
    } 
 
    TValue::TValue(unsigned long t) 
        : TValue()
    { 
        SetIntNumber(t); 
    } 
 
    TValue::TValue(unsigned t) 
        : TValue()
    { 
        SetIntNumber(t); 
    } 
 
    TValue::TValue(long long t) 
        : TValue()
    { 
        SetIntNumber(t); 
    } 
 
    TValue::TValue(long t) 
        : TValue()
    { 
        SetIntNumber(t); 
    } 
 
    TValue::TValue(int t) 
        : TValue()
    { 
        SetIntNumber(t); 
    } 
 
    //TValue::TValue(bool t) 
    //    : TValue() 
    //{ 
    //    SetBool(t); 
    //} 
 
    TValue::TValue(TStringBuf t) 
        : TValue()
    { 
        SetString(t); 
    } 
 
    TValue::TValue(const char* t) 
        : TValue()
    { 
        SetString(t); 
    } 
 
    TValue::TValue(TValue& v) 
        : TheCore(v.TheCore)
        , CopyOnWrite(v.CopyOnWrite)
    {
    }
 
    TValue::TValue(const TValue& v) 
        : TheCore(v.TheCore)
        , CopyOnWrite(true) 
    {
    }
 
    TValue::TValue(TValue&& v) noexcept 
        : TheCore(std::move(v.TheCore))
        , CopyOnWrite(v.CopyOnWrite) 
    {}
 
    TValue::operator double() const { 
        return GetNumber(); 
    } 
 
    TValue::operator float() const { 
        return GetNumber(); 
    } 
 
    TValue::operator long long() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator long() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator int() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator short() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator char() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator unsigned long long() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator unsigned long() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator unsigned() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator unsigned short() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator unsigned char() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator signed char() const { 
        return GetIntNumber(); 
    } 
 
    TValue::operator TStringBuf() const { 
        return GetString(); 
    } 
 
    TValue::operator const ::NSc::TArray&() const { 
        return GetArray(); 
    } 

    TValue::operator const ::NSc::TDict&() const { 
        return GetDict(); 
    } 
 
    TValue& TValue::operator=(double t) { 
        return SetNumber(t); 
    } 
 
    TValue& TValue::operator=(unsigned long long t) { 
        return SetIntNumber(t); 
    } 
 
    TValue& TValue::operator=(unsigned long t) { 
        return SetIntNumber(t); 
    } 
 
    TValue& TValue::operator=(unsigned t) { 
        return SetIntNumber(t); 
    } 
 
    TValue& TValue::operator=(long long t) { 
        return SetIntNumber(t); 
    } 
 
    TValue& TValue::operator=(long t) { 
        return SetIntNumber(t); 
    } 
 
    TValue& TValue::operator=(int t) { 
        return SetIntNumber(t); 
    } 
 
    //TValue& TValue::operator=(bool t) { 
    //    return SetBool(t); 
    //} 
 
    TValue& TValue::operator=(TStringBuf t) { 
        return SetString(t); 
    } 
 
    TValue& TValue::operator=(const char* t) { 
        return SetString(t); 
    } 
 
    TValue& TValue::operator=(TValue& v) & {
        if (!Same(*this, v)) {
            //Extend TheCore lifetime not to trigger possible v deletion via parent-child chain 
            auto tmpCore = TheCore; 
            TheCore = v.TheCore; 
            CopyOnWrite = v.CopyOnWrite;
        } 
        return *this; 
    } 
 
    TValue& TValue::operator=(const TValue& v) & {
        if (!Same(*this, v)) { 
            //Extend TheCore lifetime not to trigger possible v deletion via parent-child chain
            auto tmpCore = TheCore;
            TheCore = v.TheCore; 
            CopyOnWrite = true; 
        } 
        return *this; 
    } 
 
    TValue& TValue::operator=(TValue&& v) & noexcept {
        if (!Same(*this, v)) { 
            //Extend TheCore lifetime not to trigger possible v deletion via parent-child chain
            auto tmpCore = TheCore;
            TheCore = std::move(v.TheCore); 
            CopyOnWrite = v.CopyOnWrite; 
        } 
        return *this; 
    } 
 
    bool TValue::Has(size_t idx) const { 
        return IsArray() && GetArray().size() > idx; 
    } 
 
    bool TValue::Has(TStringBuf s) const { 
        return GetDict().contains(s);
    } 
 
    TValue& TValue::GetOrAddUnsafe(size_t idx) { 
        return CoreMutable().GetOrAdd(idx);
    } 
 
    TValue& TValue::GetOrAdd(TStringBuf idx) { 
        return CoreMutable().GetOrAdd(idx);
    } 
 
    const TValue& TValue::Get(size_t idx) const { 
        return Core().Get(idx); 
    } 
 
    TValue* TValue::GetNoAdd(size_t idx) {
        return CoreMutable().GetNoAdd(idx); 
    } 
 
    const TValue& TValue::Get(TStringBuf idx) const { 
        return Core().Get(idx); 
    } 
 
    TValue* TValue::GetNoAdd(TStringBuf key) {
        return CoreMutable().GetNoAdd(key); 
    } 
 
    TValue& TValue::Back() { 
        return CoreMutable().Back();
    } 

    const TValue& TValue::Back() const { 
        const TArray& arr = GetArray(); 
        return arr.empty() ? DefaultValue() : arr.back(); 
    } 
 
    TValue TValue::Delete(size_t idx) { 
        return CoreMutable().Delete(idx); 
    } 
 
    TValue TValue::Delete(TStringBuf idx) { 
        return CoreMutable().Delete(idx); 
    } 
 
    TValue& TValue::AddAll(std::initializer_list<std::pair<TStringBuf, TValue>> t) { 
        for (const auto& el : t) { 
            Add(el.first) = el.second; 
        } 
        return *this; 
    } 
 
    TValue& TValue::InsertUnsafe(size_t idx) { 
        return CoreMutable().Insert(idx);
    } 
 
    template <class TIt> 
    TValue& TValue::AppendAll(TIt begin, TIt end) { 
        GetArrayMutable().AppendAll(begin, end);
        return *this;
    } 
 
    template <class TColl> 
    TValue& TValue::AppendAll(TColl&& coll) { 
        return AppendAll(std::begin(coll), std::end(coll));
    } 
 
    TValue& TValue::AppendAll(std::initializer_list<TValue> coll) { 
        return AppendAll(coll.begin(), coll.end()); 
    } 
 
    TValue& TValue::Push() { 
        return CoreMutable().Push();
    } 
 
    TValue TValue::Pop() { 
        return CoreMutable().Pop(); 
    } 
 
    TValue::EType TValue::GetType() const { 
        return Core().ValueType; 
    } 
 
    bool TValue::IsNull() const { 
        return Core().IsNull(); 
    } 
 
    bool TValue::IsNumber() const { 
        return Core().IsNumber(); 
    } 
 
    bool TValue::IsIntNumber() const { 
        return Core().IsIntNumber(); 
    } 
 
    bool TValue::IsBool() const { 
        return Core().IsBool(); 
    } 
 
    bool TValue::IsString() const { 
        return Core().IsString(); 
    } 
 
    bool TValue::IsArray() const { 
        return Core().IsArray(); 
    } 
 
    bool TValue::IsDict() const { 
        return Core().IsDict(); 
    } 
 
    TValue& TValue::SetNumber(double i) { 
        CoreMutableForSet().SetNumber(i);
        return *this; 
    } 
 
    TValue& TValue::SetIntNumber(i64 n) { 
        CoreMutableForSet().SetIntNumber(n);
        return *this; 
    } 
 
    TValue& TValue::SetBool(bool val) { 
        CoreMutableForSet().SetBool(val);
        return *this; 
    } 
 
    TValue& TValue::SetString(TStringBuf s) { 
        CoreMutableForSet().SetString(s);
        return *this; 
    } 
 
    double TValue::GetNumber(double d) const { 
        return Core().GetNumber(d); 
    } 
 
    i64 TValue::GetIntNumber(i64 n) const { 
        return Core().GetIntNumber(n); 
    } 
 
    bool TValue::GetBool(bool b) const { 
        return Core().GetBool(b); 
    } 
 
    double& TValue::GetNumberMutable(double defaultval) { 
        return CoreMutable().GetNumberMutable(defaultval); 
    } 
 
    i64& TValue::GetIntNumberMutable(i64 defaultval) { 
        return CoreMutable().GetIntNumberMutable(defaultval); 
    } 
 
    TStringBuf TValue::GetString(TStringBuf d) const { 
        return Core().GetString(d); 
    } 
 
    TValue& TValue::SetArray() { 
        CoreMutable().SetArray(); 
        return *this; 
    } 
 
    TValue& TValue::ClearArray() { 
        CoreMutable().ClearArray(); 
        return *this; 
    } 
 
    TValue& TValue::SetDict() { 
        CoreMutable().SetDict(); 
        return *this; 
    } 
 
    TValue& TValue::ClearDict() { 
        CoreMutable().ClearDict(); 
        return *this; 
    } 
 
    const TArray& TValue::GetArray() const { 
        return Core().GetArray(); 
    } 
 
    TArray& TValue::GetArrayMutable() { 
        return CoreMutable().GetArrayMutable(); 
    } 
 
    const TDict& TValue::GetDict() const { 
        return Core().GetDict(); 
    } 
 
    TDict& TValue::GetDictMutable() {
        return CoreMutable().GetDictMutable();
    }

    size_t TValue::StringSize() const { 
        return GetString().size(); 
    } 
 
    size_t TValue::ArraySize() const { 
        return GetArray().size(); 
    } 
 
    size_t TValue::DictSize() const { 
        return GetDict().size(); 
    } 
 
    bool TValue::StringEmpty() const { 
        return GetString().empty(); 
    } 
 
    bool TValue::ArrayEmpty() const { 
        return GetArray().empty(); 
    } 
 
    bool TValue::DictEmpty() const { 
        return GetDict().empty(); 
    } 
 
    TValue::TValue(TPoolPtr& p) 
        : TheCore(NewCore(p))
    {
    } 
 
    TValue::TScCore& TValue::CoreMutable() { 
        if (Y_UNLIKELY(!TheCore)) { 
            *this = TValue();
        } else if (Y_UNLIKELY(CopyOnWrite) && Y_UNLIKELY(TheCore->RefCount() > 1)) { 
            *this = Clone(); 
        } 
 
        CopyOnWrite = false; 
 
        return *TheCore; 
    } 
 
    TValue::TScCore& TValue::CoreMutableForSet() {
        if (Y_UNLIKELY(!TheCore) || Y_UNLIKELY(CopyOnWrite) && Y_UNLIKELY(TheCore->RefCount() > 1)) {
            *this = TValue();
        }

        CopyOnWrite = false;

        return *TheCore;
    }

    const TValue::TScCore& TValue::Core() const { 
        return TheCore ? *TheCore : DefaultCore(); 
    } 
 
    TValue& TValue::SetNull() { 
        CoreMutableForSet().SetNull();
        return *this; 
    } 
 
    namespace NPrivate { 
        int CompareStr(const NSc::TValue& a, TStringBuf b); 
 
        int CompareInt(const NSc::TValue& a, i64 r); 
 
        int CompareFloat(const NSc::TValue& a, double r); 
    } 
 
    bool operator==(const TValue& a, const TValue& b);
 
    bool operator!=(const TValue& a, const TValue& b);
 
    bool operator<=(const TValue&, const TValue&) = delete;
    bool operator>=(const TValue&, const TValue&) = delete;
    bool operator<(const TValue&, const TValue&) = delete;
    bool operator>(const TValue&, const TValue&) = delete;
 
#define LIBRARY_SCHEME_DECLARE_TVALUE_OPS(T, Impl) \ 
    bool operator==(const NSc::TValue& a, T b);    \
    bool operator==(T b, const NSc::TValue& a);    \
    bool operator!=(const NSc::TValue& a, T b);    \
    bool operator!=(T b, const NSc::TValue& a);    \
    bool operator<=(const NSc::TValue& a, T b);    \
    bool operator<=(T b, const NSc::TValue& a);    \
    bool operator>=(const NSc::TValue& a, T b);    \
    bool operator>=(T b, const NSc::TValue& a);    \
    bool operator<(const NSc::TValue& a, T b);     \
    bool operator<(T b, const NSc::TValue& a);     \
    bool operator>(const NSc::TValue& a, T b);     \
    bool operator>(T b, const NSc::TValue& a);
 
#define LIBRARY_SCHEME_DECLARE_TVALUE_INT_OPS(T)            \
    LIBRARY_SCHEME_DECLARE_TVALUE_OPS(signed T, CompareInt) \ 
    LIBRARY_SCHEME_DECLARE_TVALUE_OPS(unsigned T, CompareInt) 
 
    //LIBRARY_SCHEME_DECLARE_TVALUE_OPS(bool, CompareInt) 
    LIBRARY_SCHEME_DECLARE_TVALUE_OPS(char, CompareInt) 
    LIBRARY_SCHEME_DECLARE_TVALUE_INT_OPS(char) 
    LIBRARY_SCHEME_DECLARE_TVALUE_INT_OPS(short) 
    LIBRARY_SCHEME_DECLARE_TVALUE_INT_OPS(int) 
    LIBRARY_SCHEME_DECLARE_TVALUE_INT_OPS(long) 
    LIBRARY_SCHEME_DECLARE_TVALUE_INT_OPS(long long) 
 
    LIBRARY_SCHEME_DECLARE_TVALUE_OPS(float, CompareFloat) 
    LIBRARY_SCHEME_DECLARE_TVALUE_OPS(double, CompareFloat) 
 
    LIBRARY_SCHEME_DECLARE_TVALUE_OPS(TStringBuf, CompareStr) 
    LIBRARY_SCHEME_DECLARE_TVALUE_OPS(const TString&, CompareStr)
    LIBRARY_SCHEME_DECLARE_TVALUE_OPS(const char* const, CompareStr) 
 
#undef LIBRARY_SCHEME_DECLARE_TVALUE_OPS 
#undef LIBRARY_SCHEME_DECLARE_TVALUE_INT_OPS 
 
}