cStructElem.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cStructElem_H
#define _INC_cStructElem_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "../Variant/cVariantType.h"
#include "GrayCore/include/cArchive.h"
#include "GrayCore/include/cString.h"
 
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cStructElem);
        DECLARE_INTERFACE(IScriptableSetter);
        DECLARE_INTERFACE(IScriptableGetter);
        class cVariant;
 
        class GRAYLIB_LINK cStructElem
        {
 
        public:
                VARTYPE_TYPE m_eVarType;        
                size_t m_offset;        
                UINT m_extra;           
 
        public:
                // get structure value.
                inline void* GetValPtr(const void* pBaseInst) const noexcept
                {
                        return(((BYTE*)const_cast<void*>(pBaseInst)) + m_offset);
                }
 
                size_t get_TypeLength() const;
                size_t GetDataLength(const void* pBaseInst) const;
                COMPARE_t CompareVal(const void* pBase1, const void* pBase2) const;
                COMPARE_t CompareVar(void* pBaseInst, const cVariant& vVal) const;
 
                int GetValInt(const void* pBaseInst) const;
                cString GetValStr(const void* pBaseInst) const;
                bool GetValVar(const void* pBaseInst, cVariant& vVal) const;
 
                bool SetValInt(void* pBaseInst, int iVal) const;
                bool SetValStr(void* pBaseInst, cString sVal) const;
                bool SetValVar(void* pBaseInst, const cVariant& vVal) const;
 
                HRESULT SetValCheck(void* pBaseInst, const cVariant& vVal) const;
 
                // Move the element. Read or Write.
                HRESULT SerializeInput(cStreamInput& file, void* pBaseInst) const;
                HRESULT SerializeOutput(cStreamOutput& file, const void* pBaseInst) const;
                HRESULT Serialize(cStream& file, bool bModeWrite, void* pBaseInst) const
                {
                        if (bModeWrite)
                                return SerializeOutput(file, pBaseInst);
                        else
                                return SerializeInput(file, pBaseInst);
                }
                HRESULT Serialize(cArchive& a, void* pBaseInst) const
                {
                        if (a.IsStoring())
                                return SerializeOutput(a.ref_Out(), pBaseInst);
                        else
                                return SerializeInput(a.ref_Inp(), pBaseInst);
                }
 
                HRESULT ScriptWrite(IScriptableSetter* pScript, const void* pBaseInst, const ATOMCHAR_t* pszPropName) const;
                HRESULT ScriptRead(IScriptableGetter* pScript, void* pBaseInst, const ATOMCHAR_t* pszPropName) const;
 
                UNITTEST_FRIEND(cStructElem);
        };
 
        class GRAYLIB_LINK cStructNamedElem     // associate members of some class/structure with entries in the registry.
        {
 
        public:
                // StrT::k_LEN_MAX_KEY
                const ATOMCHAR_t* m_pszKey;     
                cStructElem m_elem;                     
 
        public:
                operator const ATOMCHAR_t* () const noexcept    // if we use cAtomRef for this we can't do static init!!
                {
                        return m_pszKey;
                }
                const ATOMCHAR_t* get_Name() const noexcept
                {
                        return m_pszKey;        
                }
 
                // get structure value.
                void* GetValPtr(const void* pBaseInst) const
                {
                        return m_elem.GetValPtr(pBaseInst);
                }
                bool GetValVar(const void* pBaseInst, cVariant& vVal) const
                {
                        return(m_elem.GetValVar(pBaseInst, vVal));
                }
                bool SetValVar(void* pBaseInst, const cVariant& vVal) const
                {
                        return(m_elem.SetValVar(pBaseInst, vVal));
                }
                HRESULT SetValCheck(void* pBaseInst, const cVariant& vVal) const
                {
                        return(m_elem.SetValCheck(pBaseInst, vVal));
                }
 
                HRESULT Serialize(cStream& file, bool bModeWrite, void* pBaseInst)
                {
                        return m_elem.Serialize(file, bModeWrite, pBaseInst);
                }
                COMPARE_t Compare(const void* pBase1, const void* pBase2) const
                {
                        return m_elem.CompareVal(pBase1, pBase2);
                }
 
                // IScriptableSetter ------------------
 
                HRESULT ScriptWrite(IScriptableSetter* pScript, const void* pBaseInst) const
                {
                        return m_elem.ScriptWrite(pScript, pBaseInst, m_pszKey);
                }
                HRESULT ScriptRead(IScriptableGetter* pScript, void* pBaseInst) const
                {
                        return m_elem.ScriptRead(pScript, pBaseInst, m_pszKey);
                }
 
                // Assumes an array of cStructNamedElem.
 
                const cStructNamedElem* FindArrayKey(const ATOMCHAR_t* pszKey, size_t iSizeElem) const;
                void ScriptWriteArray(IScriptableSetter* pScript, const void* pBaseInst) const;
                void ScriptReadArray(IScriptableGetter* pScript, void* pBaseInst) const;
 
                COMPARE_t CompareArray(const void* pBase1, const void* pBase2, size_t iSizeElem) const;
        };
};
#endif // _INC_cStructElem_H