cVarMap.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cVarMap_H
#define _INC_cVarMap_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cVariant.h"
#include "../Scriptable/IScriptableObj.h"
#ifdef USE_ISCRIPTABLE
#include "../Scriptable/cScriptableInterface.h"
#endif
#include "GrayCore/include/cAtom.h"
#include "GrayCore/include/cArraySortRef.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cNonCopyable.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cVarMap);
 
        class GRAYLIB_LINK cVarTuple
                : public cRefBase
                , public cHeapObject
                , public CObject
                , public IScriptableSetter      // for set from database.
                , public cNonCopyable
        {
 
        protected:
                CHEAPOBJECT_IMPL;
        private:
                cAtomRef m_aKey;                
        public:
                cVariant m_vVal;                
 
        public:
                cVarTuple(cAtomRef aKey)
                        : m_aKey(aKey)
                {
                }
                cVarTuple(cAtomRef aKey, const cVariant& vVal)
                        : m_aKey(aKey), m_vVal(vVal)
                {
                }
                virtual ~cVarTuple()
                {
                }
 
                virtual bool isValidCheck() const noexcept override // memory allocation and structure definitions are valid.
                {
                        if (!COBJECT_IsValidCheck())
                                return false;
                        if (!cHeapObject::isValidCheck())
                                return false;
                        if (!m_aKey.isValidCheck())
                                return false;
                        if (!IS_TYPE_OF(cVarTuple, this))       // structure definitions are valid.
                                return false;
                        return true;
                }
 
                ATOMCODE_t get_HashCode() const noexcept
                {
                        DEBUG_CHECK(isValidCheck());
                        return m_aKey.get_HashCode();
                }
                cAtomRef get_KeyA() const noexcept
                {
                        DEBUG_CHECK(isValidCheck());
                        return m_aKey;
                }
                HRESULT DisposeThis()
                {
                        m_vVal.SetNoType();
                        return S_OK;
                }
 
                size_t GetHeapStats(OUT ITERATE_t& iAllocCount) const
                {
                        return m_vVal.GetHeapStats(iAllocCount) + m_aKey.GetHeapStats(iAllocCount);
                }
 
                HRESULT SerializeOutput(cStreamOutput& file) const;
 
                // If loading this as a NAME=VAL
                STDMETHOD(s_Put)(const ATOMCHAR_t* pszPropName, const cVariant& vValSet) override;
        };
 
        typedef cRefPtr<cVarTuple> cVarTuplePtr;
 
        class GRAYLIB_LINK cVarMap
                : public IScriptableEnumerator
                , public IScriptableGetter
                , public IScriptableSetter
                , public cVariantCommon
        {
        public:
                cArraySortHash<cVarTuple, ATOMCODE_t> m_aTuples;        
 
                static const ATOMCHAR_t* k_pszKeyDefault;       
 
#ifdef USE_ISCRIPTABLE
                CSCRIPT_CLASS_DEF0(VarMap);
                enum M_TYPE_
                {
#define cVarMapMethod(a,b,c,d) M_##a,
#include "cVarMapMethods.tbl"
#undef cVarMapMethod
                        M_QTY,
                };
                static cScriptableMethod sm_Methods[M_QTY + 1];
#endif
 
        private:
                HRESULT DumpTags(cStreamOutput* pOut, const ATOMCHAR_t* pszFormat, bool bValue) const;
                HRESULT s_LoadTagType(const cVariant& vVal, VARTYPE_TYPE eVarTypeChange = VARTYPE_NoType);
 
        public:
                cVarMap()
                {
                }
                cVarMap(const cVarMap& rMap)
                        : m_aTuples(rMap.m_aTuples)
                {
                        // Copy
                }
 
                // Parse the key name. Is it legal? Is an array? [] = find unused array entry.
                static cAtomRef GRAYCALL MakeKeyNameRef(const ATOMCHAR_t*& pszKey, bool bMustExist, bool bAllowDots );
 
                size_t GetHeapStats(OUT ITERATE_t& iAllocCount) const;
                HRESULT SerializeOutput(cStreamOutput& file) const;
                HRESULT SerializeInput(cStreamInput& file);
 
                ITERATE_t get_KeyQty() const
                {
                        return m_aTuples.GetSize();
                }
 
                cVarTuplePtr GetMapElement(ITERATE_t index) const
                {
                        return m_aTuples.GetAt(index);
                }
 
                const cVariant& GetMapElementVal(ITERATE_t index) const
                {
                        // Get just the value. ignore the tag name.
                        if (m_aTuples.IsValidIndex(index))
                                return m_aTuples.GetAt(index)->m_vVal;
                        return cVariant::k_VarNULL;
                }
 
                // Search for a key.
                cVarTuplePtr FindKeyPtrA(cAtomRef aKey) const;
                cVarTuplePtr FindKeyPtr(const ATOMCHAR_t* pszKey) const;
                cVarTuplePtr MakeKeyPtrA(cAtomRef aKey);
                cVarTuplePtr MakeKeyPtr(const ATOMCHAR_t* pszKey);
 
                cVarTuplePtr FindKeyPtrX(const ATOMCHAR_t* pszKeyX) const;
                cVarTuplePtr MakeKeyPtrX(const ATOMCHAR_t* pszKeyX);
 
                bool RemoveKeyA(cAtomRef aKey);
                bool RemoveKey(const ATOMCHAR_t* pszKey);
 
                // Set/Create the Vars
                HRESULT SetValA(cAtomRef aKey, const cVariant& vVal);
                HRESULT SetValNULL(cAtomRef aKey);
                HRESULT SetValVarN(const ATOMCHAR_t* pszKey, const cVariant& vVal);
                HRESULT SetValVar(const ATOMCHAR_t* pszKey, const cVariant& vVal);
                HRESULT SetValStr(const ATOMCHAR_t* pszKey, const ATOMCHAR_t* pszVal);
 
                // Get values for vars.
                // Just get it's value immediately. default to 0 or "" if missing.
                const cVariant& GetValVar(const ATOMCHAR_t* pszKey) const
                {
                        cVarTuplePtr pVar = FindKeyPtr(pszKey);
                        if (pVar != nullptr)
                                return pVar->m_vVal;
                        return cVariant::k_VarNULL;
                }
                const cVariant& operator[](const ATOMCHAR_t* pszKey) const
                {
                        return GetValVar(pszKey);
                }
 
                cVariant& RefValVar(const ATOMCHAR_t* pszKey);
                cVariant& operator[](const ATOMCHAR_t* pszKey)
                {
                        return RefValVar(pszKey);
                }
 
                cStringA GetValAsStr(const ATOMCHAR_t* pszKey) const;
                UINT32 GetValAsDWord(const ATOMCHAR_t* pszKey, UINT32 uValDefault = 0) const;
                int GetValAsInt(const ATOMCHAR_t* pszKey, int iValDefault = 0) const;
                float GetValAsFloat(const ATOMCHAR_t* pszKey, float fValDefault = 0.0f) const;
 
                // IScriptableSetter, IScriptableGetter
                STDMETHOD(s_GetEnum)(ITERATE_t i, OUT cStringA& rsPropName, OUT cVariant& rvValRet);
                STDMETHOD(s_GetByName)(const ATOMCHAR_t* pszPropName, OUT cVariant& vValRet);
                STDMETHOD(s_Put)(const ATOMCHAR_t* pszPropName, const cVariant& vValSet);
 
                // HTML parsing helpers
                StrLen_t AddHtmlArgsLen(const ATOMCHAR_t* pszArgs);
 
                // Search for a value (not a key)
                ITERATE_t FindValAsStr(const ATOMCHAR_t* pszVal) const;
                ITERATE_t FindValAsInt(int iVal, const ATOMCHAR_t* pszPrefix = nullptr) const;
 
                // Use these to extend a IScriptableObj
                void s_WriteTags(IScriptableSetter& s, const ATOMCHAR_t* pszKeyPrefix = nullptr) const;
                ITERATE_t AddTuple(cVarTuple* pVar);
 
#ifdef USE_ISCRIPTABLE
                HRESULT s_InvokeExtProp(const cVariant& vArgs, cVariant& vValRet);
                HRESULT LoadTuple(IScriptableEnumerator& section);
#endif
 
                HRESULT DumpTagsHead(cStreamOutput* pOut, const ATOMCHAR_t* pszName) const;
                void FixWeird();
 
                StrLen_t GetStr(ATOMCHAR_t* pszArgs, StrLen_t nLenMax, const ATOMCHAR_t* pszLineBreak = nullptr) const;
                HRESULT SetStr(const ATOMCHAR_t* pszArgs);
                COMPARE_t Compare(const cVarMap* pMap) const;
 
                HRESULT SetFromArrays(int iQty, const char** ppszNames, const char** ppszVals);
 
                UNITTEST2_PREDEF(cVarMap);
        };
 
        class GRAYLIB_LINK cVariantMap : public cVarMap, public cRefBase
        {
 
        public:
                cVariantMap()
                {
                }
                cVariantMap(const cVarMap& rMap)
                        : cVarMap(rMap)
                {
                }
        };
}
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
namespace Gray
{
        template class GRAYLIB_LINK CArray< cRefPtr<GrayLib::cVarTuple>, GrayLib::cVarTuple* >;
        template class GRAYLIB_LINK cArrayTyped< cRefPtr<GrayLib::cVarTuple>, GrayLib::cVarTuple* >;
        template class GRAYLIB_LINK cArraySorted< cRefPtr<GrayLib::cVarTuple>, GrayLib::cVarTuple*, ATOMCODE_t >;
        template class GRAYLIB_LINK cArraySortRef<GrayLib::cVarTuple, ATOMCODE_t>;
        template class GRAYLIB_LINK cArraySortHash<GrayLib::cVarTuple, ATOMCODE_t>;
}
#endif
 
#endif // _INC_cVarMap_H