//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================

#ifndef DMATTRIBUTEVAR_H
#define DMATTRIBUTEVAR_H
#ifdef _WIN32
#pragma once
#endif

#include "Color.h"
#include "datamodel/dmattribute.h"
#include "datamodel/dmelement.h"
#include "mathlib/vector.h"
#include "mathlib/vector2d.h"
#include "mathlib/vector4d.h"
#include "mathlib/vmatrix.h"
#include "tier1/utlvector.h"

template <class C, bool D>
class CDmeHandle;

//-----------------------------------------------------------------------------
// Specialization for color
//-----------------------------------------------------------------------------
class CDmaColor : public CDmaVar<Color> {
   public:
    // Set methods
    void SetColor(int r, int g, int b, int a = 0);
    void SetRed(int r);
    void SetGreen(int g);
    void SetBlue(int b);
    void SetAlpha(int a);

    // Sets the color as a 32-bit integer
    void SetRawColor(int color);

    // Get methods
    unsigned char r() const;
    unsigned char g() const;
    unsigned char b() const;
    unsigned char a() const;
    const unsigned char &operator[](int index) const;
};

//-----------------------------------------------------------------------------
// Specialization for object ids
//-----------------------------------------------------------------------------
class CDmaObjectId : public CDmaVar<DmObjectId_t> {
   public:
    void CreateObjectId();
    void Invalidate();
    bool IsValid() const;
    bool IsEqual(const DmObjectId_t &id) const;
    const DmObjectId_t &operator=(const DmObjectId_t &src);
    const CDmaObjectId &operator=(const CDmaObjectId &src);
    const DmObjectId_t &Set(const DmObjectId_t &src);
};

//-----------------------------------------------------------------------------
// Specialization for binary block
//-----------------------------------------------------------------------------
class CDmaBinaryBlock : public CDmaVar<CUtlBinaryBlock> {
   public:
    void Get(void *pValue, int nMaxLen) const;
    void Set(const void *pValue, int nLen);
    const void *Get() const;
    const unsigned char &operator[](int i) const;

    // Returns buffer length
    int Length() const;
};

//-----------------------------------------------------------------------------
// Specialization for elements
//-----------------------------------------------------------------------------
template <class T>
class CDmaElement : public CDmaVar<DmElementHandle_t> {
    typedef CDmaVar<DmElementHandle_t> BaseClass;

   public:
    // Used to initialize the attribute in an element's OnConstruction method
    void InitAndCreate(CDmElement *pOwner, const char *pAttributeName,
                       const char *pElementName = NULL, int flags = 0);
    void Init(CDmElement *pOwner, const char *pAttributeName, int flags = 0);

    // Returns the type of elements allowed into this attribute.
    // UTL_INVAL_SYMBOL allows everything.
    UtlSymId_t GetElementType() const;

    // Get/set
    void Set(T *pElement);
    T *GetElement() const;

    // Cast
    T *operator->() const;
    operator T *() const;

    // NULL check
    bool operator!() const;

    // Assignment.. wish I knew how to un-inline these methods
    template <class S>
    CDmaElement<T> &operator=(S *pElement) {
        Set(static_cast<T *>(pElement));
        return *this;
    }

    template <class S>
    CDmaElement<T> &operator=(const CDmaElement<S> &src) {
        Set(static_cast<T *>(src.Get()));
        return *this;
    }

    template <class S>
    bool operator==(const CDmaElement<S> &src) const {
        return Value() == src.Value();
    }

    template <class S>
    bool operator!=(const CDmaElement<S> &src) const {
        return Value() != src.Value();
    }
};

//-----------------------------------------------------------------------------
// Can access any array attribute, regardless of type
// See below for type-specific array accessors which have more features
//-----------------------------------------------------------------------------
class CDmrGenericArrayConst {
   public:
    CDmrGenericArrayConst(const CDmAttribute *pAttribute);
    CDmrGenericArrayConst(const CDmElement *pElement,
                          const char *pAttributeName);

    // Array count
    int Count() const;

    // Gets
    const void *GetUntyped(int i) const;

    // String conversion
    const char *GetAsString(int i, char *pBuffer, size_t nBufLen) const;

    const CDmAttribute *GetAttribute() const;
    bool IsValid() const;

   protected:
    CDmrGenericArrayConst();
    void Init(const CDmAttribute *pAttribute);
    void Init(const CDmElement *pElement, const char *pAttributeName);

    CDmAttribute *m_pAttribute;
};

class CDmrGenericArray : public CDmrGenericArrayConst {
   public:
    CDmrGenericArray(CDmAttribute *pAttribute);
    CDmrGenericArray(CDmElement *pElement, const char *pAttributeName);

    void EnsureCount(int num);

    // Sets multiple elements at the same time
    int AddToTail();
    void Remove(int elem);  // preserves order, shifts elements
    void RemoveAll();       // doesn't deallocate memory
    void SetMultiple(int i, int nCount, DmAttributeType_t valueType,
                     const void *pValue);
    void Set(int i, DmAttributeType_t valueType, const void *pValue);

    // String conversion
    void SetFromString(int i, const char *pValue);

    CDmAttribute *GetAttribute();
    const CDmAttribute *GetAttribute() const;
};

//-----------------------------------------------------------------------------
// Helper template for external array attribute vars
// NOTE: To use this class, don't use CDmaArrayBase directly. Instead, use
//		CDmaArray<T> var;	<- Instantiate an array attribute var as a
//member of a element class 		CDmrArray<T> var;	<- Used to reference an existing
//array attribute + read/modify it 		CDmrArrayConst<T> var;	<- Used to
//reference an existing array attribute + read it (no modify)
//
// Also, there is a CDmaStringArray/CDmrStringArray/CDmrStringArrayConst for
// strings and a CDmaElementArray/CDmrElementArray/CDmrElementArrayConst for
// elements
//-----------------------------------------------------------------------------
template <class T, class B>
class CDmaArrayConstBase : public B {
   public:
    // Accessors
    const CUtlVector<T> &Get() const;
    const T *Base() const;

    // Iteration
    int Count() const;
    const T &operator[](int i) const;
    const T &Element(int i) const;
    const T &Get(int i) const;
    const void *GetUntyped(int i) const;
    bool IsValidIndex(int i) const;
    int InvalidIndex(void) const;

    // Search
    int Find(const T &value) const;

    // Attribute-related methods
    const CDmAttribute *GetAttribute() const;
    CDmElement *GetOwner();
    bool IsDirty() const;

   protected:
    CDmaArrayConstBase();

    CDmAttribute *m_pAttribute;
};

template <class T, class B>
class CDmaArrayBase : public CDmaArrayConstBase<T, B> {
   public:
    // Insertion
    int AddToTail();
    int InsertBefore(int elem);
    int AddToTail(const T &src);
    int InsertBefore(int elem, const T &src);
    int AddMultipleToTail(int num);
    int InsertMultipleBefore(int elem, int num);
    void EnsureCount(int num);

    // Element Modification
    void Set(int i, const T &value);
    void SetMultiple(int i, int nCount, const T *pValue);
    void Swap(int i, int j);

    // Copy related methods
    void CopyArray(const T *pArray, int size);

    // this is basically just a faster version of CopyArray which uses pointer
    // swap NOTE: This doesn't work for element arrays
    void SwapArray(CUtlVector<T> &array);

    // Removal
    void FastRemove(int elem);
    void Remove(int elem);
    void RemoveMultiple(int elem, int num);
    void RemoveAll();

    // Memory management
    void EnsureCapacity(int num);
    void Purge();

    // Attribute-related methods
    CDmAttribute *GetAttribute();
    const CDmAttribute *GetAttribute() const;
};

//-----------------------------------------------------------------------------
// Specialization for string arrays
// NOTE: To use this class, don't use CDmaStringArrayBase directly. Instead, use
//		CDmaStringArray var;	<- Instantiate an array attribute var as
//a member of a element class 		CDmrStringArray var;	<- Used to reference an
//existing array attribute + read/modify it 		CDmrStringArrayConst var; <- Used to
//reference an existing array attribute + read it (no modify)
//-----------------------------------------------------------------------------
template <class BaseClass>
class CDmaStringArrayConstBase : public BaseClass {
   public:
    const char *operator[](int i) const;
    const char *Element(int i) const;
    const char *Get(int i) const;
    const CUtlVector<CUtlString> &Get() const;

    // Returns strlen of element i
    int Length(int i) const;
};

template <class B>
class CDmaStringArrayBase
    : public CDmaStringArrayConstBase<CDmaArrayBase<CUtlString, B> > {
    typedef CDmaStringArrayConstBase<CDmaArrayBase<CUtlString, B> > BaseClass;

   public:
    // Sets an element in the array
    void Set(int i, const char *pValue);

    // Adds an element, uses copy constructor
    int AddToTail(const char *pValue);
    int InsertBefore(int elem, const char *pValue);
};

//-----------------------------------------------------------------------------
// Specialization for elements
// NOTE: To use this class, don't use CDmaElementArrayBase directly. Instead,
// use
//		CDmaElementArray< element_type > var;	<- Instantiate an array
//attribute var as a member of a element class 		CDmrElementArray< element_type >
//var;	<- Used to reference an existing array attribute + read/modify it
//		CDmrElementArrayConst< element_type > var; <- Used to reference an
//existing array attribute + read it (no modify)
//-----------------------------------------------------------------------------
template <class E, class BaseClass>
class CDmaElementArrayConstBase : public BaseClass {
   public:
    // Returns the element type
    UtlSymId_t GetElementType() const;

    // Array access
    E *operator[](int i) const;
    E *Element(int i) const;
    E *Get(int i) const;
    const DmElementHandle_t &GetHandle(int i) const;
    const CUtlVector<DmElementHandle_t> &Get() const;

    // Search
    int Find(const E *pValue) const;
    int Find(DmElementHandle_t h) const;
};

template <class E, class B>
class CDmaElementArrayBase
    : public CDmaElementArrayConstBase<E,
                                       CDmaArrayBase<DmElementHandle_t, B> > {
    typedef CDmaElementArrayConstBase<E, CDmaArrayBase<DmElementHandle_t, B> >
        BaseClass;

   public:
    void SetHandle(int i, DmElementHandle_t h);
    void Set(int i, E *pElement);

    // Insertion
    int AddToTail();
    int AddToTail(DmElementHandle_t src);
    int AddToTail(E *pValue);
    int InsertBefore(int elem);
    int InsertBefore(int elem, DmElementHandle_t src);
    int InsertBefore(int elem, E *pValue);

    template <class C, bool D>
    int AddToTail(const CDmeHandle<C, D> &value) {
        return BaseClass::AddToTail(value.GetHandle());
    }

    template <class C, bool D>
    int InsertBefore(int elem, const CDmeHandle<C, D> &value) {
        return BaseClass::InsertBefore(elem, value.GetHandle());
    }
};

// NOTE: The next couple classes are implementation details used to create
// CDmrAray/CDmaArray

//-----------------------------------------------------------------------------
// Base classes that contain data or refer to it; used for array accessor
// classes
//-----------------------------------------------------------------------------
template <typename T>
class CDmaDataInternal {
   protected:
    typedef typename CDmAttributeInfo<T>::StorageType_t D;

    const T &Value() const { return m_Storage; }
    T &Value() { return m_Storage; }
    const D &Data() const { return m_Storage; }
    D &Data() { return m_Storage; }

   private:
    D m_Storage;
};

template <typename T>
class CDmaDataExternal {
   protected:
    typedef typename CDmAttributeInfo<T>::StorageType_t D;

    CDmaDataExternal() : m_pStorage(0) {}
    void Attach(void *pData) { m_pStorage = (D *)pData; }
    const T &Value() const { return *m_pStorage; }
    T &Value() { return *m_pStorage; }
    const D &Data() const { return *m_pStorage; }
    D &Data() { return *m_pStorage; }

   private:
    D *m_pStorage;
};

//-----------------------------------------------------------------------------
// Versions for access, or for attribute vars
//-----------------------------------------------------------------------------
template <class T, class B>
class CDmaDecorator : public B {
   public:
    void Init(CDmElement *pOwner, const char *pAttributeName, int flags = 0);
};

template <class T, class BaseClass>
class CDmrDecoratorConst : public BaseClass {
   public:
    void Init(const CDmAttribute *pAttribute);
    void Init(const CDmElement *pElement, const char *pAttributeName);

    bool IsValid() const;
};

template <class T, class BaseClass>
class CDmrDecorator : public BaseClass {
   public:
    void Init(CDmAttribute *pAttribute);
    void Init(CDmElement *pElement, const char *pAttributeName,
              bool bAddAttribute = false);

    bool IsValid() const;
};

#define DECLARE_ATTRIBUTE_ARRAY_VARIABLE(_className, _elementType) \
   public:                                                         \
    _className() {}

#define DECLARE_ATTRIBUTE_ARRAY_REFERENCE(_className, _elementType)       \
   public:                                                                \
    _className() {}                                                       \
    _className(CDmAttribute *pAttribute) { BaseClass::Init(pAttribute); } \
    _className(CDmElement *pElement, const char *pAttributeName,          \
               bool bAddAttribute = false) {                              \
        BaseClass::Init(pElement, pAttributeName, bAddAttribute);         \
    }                                                                     \
    _className(CDmaArray<_className> &var) {                              \
        BaseClass::Init(var.GetAttribute());                              \
    }                                                                     \
    _className(CDmrArray<_className> &var) {                              \
        BaseClass::Init(var.GetAttribute());                              \
    }

#define DECLARE_ATTRIBUTE_ARRAY_CONST_REFERENCE(_className, _elementType) \
   public:                                                                \
    _className() {}                                                       \
    _className(const CDmAttribute *pAttribute) {                          \
        BaseClass::Init(pAttribute);                                      \
    }                                                                     \
    _className(const CDmElement *pElement, const char *pAttributeName) {  \
        BaseClass::Init(pElement, pAttributeName);                        \
    }                                                                     \
    _className(const CDmaArray<_className> &var) {                        \
        BaseClass::Init(var.GetAttribute());                              \
    }                                                                     \
    _className(const CDmrArrayConst<_className> &var) {                   \
        BaseClass::Init(var.GetAttribute());                              \
    }                                                                     \
    _className(const CDmrArray<_className> &var) {                        \
        BaseClass::Init(var.GetAttribute());                              \
    }

template <class T>
class CDmrArray;
template <class T>
class CDmrArrayConst;
template <class T>
class CDmaArray;

//-----------------------------------------------------------------------------
// Versions for access, or for attribute vars
//-----------------------------------------------------------------------------
template <class T>
class CDmaArray : public CDmaDecorator<
                      T, CDmaArrayBase<T, CDmaDataInternal<CUtlVector<T> > > > {
    DECLARE_ATTRIBUTE_ARRAY_VARIABLE(CDmaArray, T);

   public:
    const CDmaArray<T> &operator=(const CDmaArray<T> &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

    template <class C>
    const CDmaArray<T> &operator=(const C &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

   private:
    CDmaArray(const CDmaArray &array) {}
};

template <class T>
class CDmrArrayConst
    : public CDmrDecoratorConst<
          T, CDmaArrayConstBase<T, CDmaDataExternal<CUtlVector<T> > > > {
    typedef CDmrDecoratorConst<
        T, CDmaArrayConstBase<T, CDmaDataExternal<CUtlVector<T> > > >
        BaseClass;
    DECLARE_ATTRIBUTE_ARRAY_CONST_REFERENCE(CDmrArrayConst, T);
};

template <class T>
class CDmrArray : public CDmrDecorator<
                      T, CDmaArrayBase<T, CDmaDataExternal<CUtlVector<T> > > > {
    typedef CDmrDecorator<T,
                          CDmaArrayBase<T, CDmaDataExternal<CUtlVector<T> > > >
        BaseClass;
    DECLARE_ATTRIBUTE_ARRAY_REFERENCE(CDmrArray, T);

   public:
    const CDmrArray<T> &operator=(const CDmrArray<T> &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

    template <class C>
    const CDmrArray<T> &operator=(const C &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }
};

class CDmrStringArray;

class CDmaStringArray
    : public CDmaDecorator<
          CUtlString,
          CDmaStringArrayBase<CDmaDataInternal<CUtlVector<CUtlString> > > > {
    DECLARE_ATTRIBUTE_ARRAY_VARIABLE(CDmaStringArray, CUtlString);

   public:
    const CDmaStringArray &operator=(const CDmaStringArray &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

    template <class C>
    const CDmaStringArray &operator=(const C &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

   private:
    CDmaStringArray(const CDmaStringArray &array) {}
};

class CDmrStringArray
    : public CDmrDecorator<
          CUtlString,
          CDmaStringArrayBase<CDmaDataExternal<CUtlVector<CUtlString> > > > {
    typedef CDmrDecorator<
        CUtlString,
        CDmaStringArrayBase<CDmaDataExternal<CUtlVector<CUtlString> > > >
        BaseClass;
    DECLARE_ATTRIBUTE_ARRAY_REFERENCE(CDmrStringArray, CUtlString);

   public:
    CDmrStringArray(CDmaStringArray &var) { Init(var.GetAttribute()); }
    CDmrStringArray(CDmrStringArray &var) { Init(var.GetAttribute()); }

    const CDmrStringArray &operator=(const CDmrStringArray &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

    template <class C>
    const CDmrStringArray &operator=(const C &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }
};

class CDmrStringArrayConst
    : public CDmrDecoratorConst<
          CUtlString,
          CDmaStringArrayConstBase<CDmaArrayConstBase<
              CUtlString, CDmaDataExternal<CUtlVector<CUtlString> > > > > {
    typedef CDmrDecoratorConst<
        CUtlString,
        CDmaStringArrayConstBase<CDmaArrayConstBase<
            CUtlString, CDmaDataExternal<CUtlVector<CUtlString> > > > >
        BaseClass;
    DECLARE_ATTRIBUTE_ARRAY_CONST_REFERENCE(CDmrStringArrayConst, CUtlString);

   public:
    CDmrStringArrayConst(const CDmaStringArray &var) {
        Init(var.GetAttribute());
    }
    CDmrStringArrayConst(const CDmrStringArray &var) {
        Init(var.GetAttribute());
    }
    CDmrStringArrayConst(const CDmrStringArrayConst &var) {
        Init(var.GetAttribute());
    }
};

//-----------------------------------------------------------------------------
// Prevent CDmaArray for DmElementHandle_t
//-----------------------------------------------------------------------------
template <>
class CDmaArray<DmElementHandle_t> {
   private:
    CDmaArray();
};

template <class E>
class CDmrElementArray;

template <class E = CDmElement>
class CDmaElementArray
    : public CDmaElementArrayBase<
          E, CDmaDataInternal<CUtlVector<DmElementHandle_t> > > {
    DECLARE_ATTRIBUTE_ARRAY_VARIABLE(CDmaElementArray, DmElementHandle_t);

   public:
    void Init(CDmElement *pOwner, const char *pAttributeName, int flags = 0) {
        Assert(pOwner);
        this->m_pAttribute = pOwner->AddExternalAttribute(
            pAttributeName, AT_ELEMENT_ARRAY,
            &CDmaElementArrayBase<
                E, CDmaDataInternal<CUtlVector<DmElementHandle_t> > >::Value());
        this->m_pAttribute->SetElementTypeSymbol(E::GetStaticTypeSymbol());
        if (flags) {
            this->m_pAttribute->AddFlag(flags);
        }
    }

    template <typename C>
    CDmaElementArray<E> &operator=(const C &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

    // NOTE: The copy operator= must be defined in addition to the generic one
    const CDmaElementArray<E> &operator=(const CDmaElementArray<E> &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

   private:
    template <class C>
    CDmaElementArray(const CDmaElementArray<C> &var);
};

template <class E = CDmElement>
class CDmrElementArrayConst
    : public CDmaElementArrayConstBase<
          E, CDmaArrayConstBase<
                 DmElementHandle_t,
                 CDmaDataExternal<CUtlVector<DmElementHandle_t> > > > {
   public:
    CDmrElementArrayConst() { this->m_pAttribute = NULL; }

    CDmrElementArrayConst(const CDmAttribute *pAttribute) { Init(pAttribute); }

    CDmrElementArrayConst(const CDmElement *pElement,
                          const char *pAttributeName) {
        Init(pElement, pAttributeName);
    }

    template <typename C>
    CDmrElementArrayConst(const CDmaElementArray<C> &var) {
        Init(var.GetAttribute());
    }

    template <typename C>
    CDmrElementArrayConst(const CDmrElementArray<C> &var) {
        Init(var.GetAttribute());
    }

    template <typename C>
    CDmrElementArrayConst(const CDmrElementArrayConst<C> &var) {
        Init(var.GetAttribute());
    }

    void Init(const CDmAttribute *pAttribute) {
        if (pAttribute && pAttribute->GetType() == AT_ELEMENT_ARRAY) {
            this->m_pAttribute = const_cast<CDmAttribute *>(pAttribute);
            this->Attach(this->m_pAttribute->GetAttributeData());
        } else {
            this->m_pAttribute = NULL;
            this->Attach(NULL);
        }
    }

    void Init(const CDmElement *pElement, const char *pAttributeName) {
        const CDmAttribute *pAttribute = NULL;
        if (pElement && pAttributeName && pAttributeName[0]) {
            pAttribute = (CDmAttribute *)pElement->GetAttribute(pAttributeName);
        }
        Init(pAttribute);
    }

    bool IsValid() const { return this->m_pAttribute != NULL; }
};

template <class T = CDmElement>
class CDmrElementArray
    : public CDmaElementArrayBase<
          T, CDmaDataExternal<CUtlVector<DmElementHandle_t> > > {
   public:
    CDmrElementArray() { this->m_pAttribute = NULL; }

    CDmrElementArray(CDmAttribute *pAttribute) { Init(pAttribute); }

    CDmrElementArray(CDmElement *pElement, const char *pAttributeName,
                     bool bAddAttribute = false) {
        Init(pElement, pAttributeName, bAddAttribute);
    }

    template <typename C>
    CDmrElementArray(CDmaElementArray<C> &var) {
        Init(var.GetAttribute());
    }

    template <typename C>
    CDmrElementArray(CDmrElementArray<C> &var) {
        Init(var.GetAttribute());
    }

    void Init(CDmAttribute *pAttribute) {
        if (pAttribute && pAttribute->GetType() == AT_ELEMENT_ARRAY) {
            this->m_pAttribute = pAttribute;
            this->Attach(this->m_pAttribute->GetAttributeData());
        } else {
            this->m_pAttribute = NULL;
            this->Attach(NULL);
        }
    }

    void Init(CDmElement *pElement, const char *pAttributeName,
              bool bAddAttribute = false) {
        CDmAttribute *pAttribute = NULL;
        if (pElement && pAttributeName && pAttributeName[0]) {
            pAttribute = pElement->GetAttribute(pAttributeName);
            if (bAddAttribute && !pAttribute) {
                pAttribute =
                    pElement->CreateAttribute(pAttributeName, AT_ELEMENT_ARRAY);

                // FIXME: Should we do this?
                pAttribute->SetElementTypeSymbol(T::GetStaticTypeSymbol());
            }
        }
        Init(pAttribute);
    }

    bool IsValid() const { return this->m_pAttribute != NULL; }

    template <typename C>
    CDmrElementArray<T> &operator=(const C &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }

    // NOTE: The copy operator= must be defined in addition to the generic one
    const CDmrElementArray<T> &operator=(const CDmrElementArray<T> &val) {
        CopyArray(val.Base(), val.Count());
        return *this;
    }
};

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaVar
//
//-----------------------------------------------------------------------------
template <class T>
inline CDmaVar<T>::CDmaVar() {
    m_pAttribute = NULL;
    CDmAttributeInfo<T>::SetDefaultValue(m_Storage);
}

template <class T>
inline void CDmaVar<T>::Init(CDmElement *pOwner, const char *pAttributeName,
                             int flags) {
    Assert(pOwner);
    m_pAttribute = pOwner->AddExternalAttribute(
        pAttributeName, CDmAttributeInfo<T>::AttributeType(), &m_Storage);
    Assert(m_pAttribute);
    if (flags) {
        m_pAttribute->AddFlag(flags);
    }
}

template <class T>
inline void CDmaVar<T>::InitAndSet(CDmElement *pOwner,
                                   const char *pAttributeName, const T &value,
                                   int flags) {
    Init(pOwner, pAttributeName);
    Set(value);

    // this has to happen AFTER set so the set happens before FATTRIB_READONLY
    if (flags) {
        m_pAttribute->AddFlag(flags);
    }
}

template <class T>
inline const T &CDmaVar<T>::Set(const T &val) {
    Assert(m_pAttribute);
    m_pAttribute->SetValue(val);
    return m_Storage;
}

template <class T>
inline const T &CDmaVar<T>::operator=(const T &val) {
    return Set(val);
}

template <class T>
inline const CDmaVar<T> &CDmaVar<T>::operator=(const CDmaVar<T> &src) {
    Set(src.Get());
    return *this;
}

template <class T>
inline const T &CDmaVar<T>::operator+=(const T &val) {
    return Set(Value() + val);
}

template <class T>
inline const T &CDmaVar<T>::operator-=(const T &val) {
    return Set(Value() - val);
}

template <class T>
inline const T &CDmaVar<T>::operator/=(const T &val) {
    return Set(Value() / val);
}

template <class T>
inline const T &CDmaVar<T>::operator*=(const T &val) {
    return Set(Value() * val);
}

template <class T>
inline const T &CDmaVar<T>::operator^=(const T &val) {
    return Set(Value() ^ val);
}

template <class T>
inline const T &CDmaVar<T>::operator|=(const T &val) {
    return Set(Value() | val);
}

template <class T>
inline const T &CDmaVar<T>::operator&=(const T &val) {
    return Set(Value() & val);
}

template <class T>
inline T CDmaVar<T>::operator++() {
    return Set(Value() + 1);
}

template <class T>
inline T CDmaVar<T>::operator--() {
    return Set(Value() - 1);
}

template <class T>
inline T CDmaVar<T>::operator++(int)  // postfix version..
{
    T oldValue = Value();
    Set(Value() + 1);
    return oldValue;
}

template <class T>
inline T CDmaVar<T>::operator--(int)  // postfix version..
{
    T oldValue = Value();
    Set(Value() - 1);
    return oldValue;
}

template <class T>
inline CDmaVar<T>::operator const T &() const {
    return Value();
}

template <class T>
inline const T &CDmaVar<T>::Get() const {
    return Value();
}

template <class T>
inline const T *CDmaVar<T>::operator->() const {
    return &Value();
}

template <class T>
inline CDmAttribute *CDmaVar<T>::GetAttribute() {
    Assert(m_pAttribute);
    return m_pAttribute;
}

template <class T>
inline const CDmAttribute *CDmaVar<T>::GetAttribute() const {
    Assert(m_pAttribute);
    return m_pAttribute;
}

template <class T>
inline bool CDmaVar<T>::IsDirty() const {
    Assert(m_pAttribute);
    return m_pAttribute->IsFlagSet(FATTRIB_DIRTY);
}

template <class T>
inline const T &CDmaVar<T>::Value() const {
    return m_Storage;
}

template <class T>
inline T &CDmaVar<T>::Value() {
    return m_Storage;
}

template <>
inline const DmElementHandle_t &CDmaVar<DmElementHandle_t>::Value() const {
    return m_Storage.m_Handle;
}

template <>
inline DmElementHandle_t &CDmaVar<DmElementHandle_t>::Value() {
    return m_Storage.m_Handle;
}

template <class T>
inline const typename CDmaVar<T>::D &CDmaVar<T>::Storage() const {
    return m_Storage;
}

template <class T>
inline typename CDmaVar<T>::D &CDmaVar<T>::Storage() {
    return m_Storage;
}

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaColor
//
//-----------------------------------------------------------------------------
inline void CDmaColor::SetColor(int r, int g, int b, int a) {
    Color clr(r, g, b, a);
    m_pAttribute->SetValue(clr);
}

inline void CDmaColor::SetRed(int r) {
    Color org = Value();
    org[0] = r;
    m_pAttribute->SetValue(org);
}

inline void CDmaColor::SetGreen(int g) {
    Color org = Value();
    org[1] = g;
    m_pAttribute->SetValue(org);
}

inline void CDmaColor::SetBlue(int b) {
    Color org = Value();
    org[2] = b;
    m_pAttribute->SetValue(org);
}

inline void CDmaColor::SetAlpha(int a) {
    Color org = Value();
    org[3] = a;
    m_pAttribute->SetValue(org);
}

inline unsigned char CDmaColor::r() const { return (unsigned char)Value().r(); }

inline unsigned char CDmaColor::g() const { return (unsigned char)Value().g(); }

inline unsigned char CDmaColor::b() const { return (unsigned char)Value().b(); }

inline unsigned char CDmaColor::a() const { return (unsigned char)Value().a(); }

inline const unsigned char &CDmaColor::operator[](int index) const {
    return Value()[index];
}

inline void CDmaColor::SetRawColor(int color) {
    Color clr;
    clr.SetRawColor(color);
    m_pAttribute->SetValue(clr);
}

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaObjectId
//
//-----------------------------------------------------------------------------
inline void CDmaObjectId::CreateObjectId() {
    DmObjectId_t id;
    CreateUniqueId(&id);
    m_pAttribute->SetValue(id);
}

inline void CDmaObjectId::Invalidate() {
    DmObjectId_t id;
    InvalidateUniqueId(&id);
    m_pAttribute->SetValue(id);
}

inline bool CDmaObjectId::IsValid() const { return IsUniqueIdValid(Value()); }

inline bool CDmaObjectId::IsEqual(const DmObjectId_t &id) const {
    return IsUniqueIdEqual(Value(), id);
}

inline const DmObjectId_t &CDmaObjectId::operator=(const DmObjectId_t &src) {
    m_pAttribute->SetValue(src);
    return Value();
}

inline const CDmaObjectId &CDmaObjectId::operator=(const CDmaObjectId &src) {
    m_pAttribute->SetValue(src.Get());
    return *this;
}

inline const DmObjectId_t &CDmaObjectId::Set(const DmObjectId_t &src) {
    m_pAttribute->SetValue(src);
    return Value();
}

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaString
//
//-----------------------------------------------------------------------------
inline const char *CDmaString::Get() const { return Value().Get(); }

inline CDmaString::operator const char *() const { return Value().Get(); }

inline void CDmaString::Set(const char *pValue) {
    CUtlString str(pValue, pValue ? Q_strlen(pValue) + 1 : 0);
    m_pAttribute->SetValue(str);
}

// Returns strlen
inline int CDmaString::Length() const { return Value().Length(); }

inline CDmaString &CDmaString::operator=(const char *src) {
    Set(src);
    return *this;
}

inline const CDmaString &CDmaString::operator=(const CDmaString &src) {
    Set(src.Get());
    return *this;
}

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaBinaryBlock
//
//-----------------------------------------------------------------------------
inline void CDmaBinaryBlock::Get(void *pValue, int nMaxLen) const {
    Value().Get(pValue, nMaxLen);
}

inline void CDmaBinaryBlock::Set(const void *pValue, int nLen) {
    CUtlBinaryBlock block(pValue, nLen);
    m_pAttribute->SetValue(block);
}

inline const void *CDmaBinaryBlock::Get() const { return Value().Get(); }

inline const unsigned char &CDmaBinaryBlock::operator[](int i) const {
    return Value()[i];
}

inline int CDmaBinaryBlock::Length() const { return Value().Length(); }

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaElement
//
//-----------------------------------------------------------------------------
template <class T>
inline void CDmaElement<T>::InitAndCreate(CDmElement *pOwner,
                                          const char *pAttributeName,
                                          const char *pElementName, int flags) {
    Init(pOwner, pAttributeName);

    DmElementHandle_t hElement = DMELEMENT_HANDLE_INVALID;
    if (!g_pDataModel->IsUnserializing()) {
        hElement = g_pDataModel->CreateElement(
            T::GetStaticTypeSymbol(), pElementName, pOwner->GetFileId());
    }
    Assert(m_pAttribute);
    m_pAttribute->SetValue(hElement);

    // this has to happen AFTER set so the set happens before FATTRIB_READONLY
    m_pAttribute->AddFlag(flags | FATTRIB_MUSTCOPY);
}

template <class T>
inline void CDmaElement<T>::Init(CDmElement *pOwner, const char *pAttributeName,
                                 int flags) {
    BaseClass::Init(pOwner, pAttributeName);

    Assert(m_pAttribute);
    m_pAttribute->SetElementTypeSymbol(T::GetStaticTypeSymbol());
    if (flags) {
        m_pAttribute->AddFlag(flags);
    }
}

template <class T>
inline UtlSymId_t CDmaElement<T>::GetElementType() const {
    return this->Data().m_ElementType;
}

template <class T>
inline T *CDmaElement<T>::GetElement() const {
    CDmElement *pElement = g_pDataModel->GetElement(Value());
    Assert(!pElement || pElement->IsA(T::GetStaticTypeSymbol()));
    return static_cast<T *>(pElement);
}

template <class T>
inline T *CDmaElement<T>::operator->() const {
    return GetElement();
}

template <class T>
inline CDmaElement<T>::operator T *() const {
    return GetElement();
}

template <class T>
inline void CDmaElement<T>::Set(T *pElement) {
    Assert(m_pAttribute);
    m_pAttribute->SetValue(pElement ? pElement->GetHandle()
                                    : DMELEMENT_HANDLE_INVALID);
}

template <class T>
inline bool CDmaElement<T>::operator!() const {
    return (GetElement() == NULL);
}

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaArrayBase
//
//-----------------------------------------------------------------------------
template <class T, class B>
inline const CUtlVector<T> &CDmaArrayConstBase<T, B>::Get() const {
    return this->Value();
}

template <class T, class B>
inline const T *CDmaArrayConstBase<T, B>::Base() const {
    return this->Value().Base();
}

template <class T, class B>
inline const T &CDmaArrayConstBase<T, B>::operator[](int i) const {
    return this->Value()[i];
}

template <class T, class B>
const T &CDmaArrayConstBase<T, B>::Element(int i) const {
    return this->Value()[i];
}

template <class T, class B>
inline const T &CDmaArrayConstBase<T, B>::Get(int i) const {
    return this->Value()[i];
}

template <class T, class B>
const void *CDmaArrayConstBase<T, B>::GetUntyped(int i) const {
    return &(this->Value()[i]);
}

template <class T, class B>
inline int CDmaArrayConstBase<T, B>::Count() const {
    return this->Value().Count();
}

template <class T, class B>
inline bool CDmaArrayConstBase<T, B>::IsValidIndex(int i) const {
    return this->Value().IsValidIndex(i);
}

template <class T, class B>
inline int CDmaArrayConstBase<T, B>::InvalidIndex(void) const {
    return this->Value().InvalidIndex();
}

template <class T, class B>
inline const CDmAttribute *CDmaArrayConstBase<T, B>::GetAttribute() const {
    Assert(m_pAttribute);
    return m_pAttribute;
}

template <class T, class B>
inline CDmElement *CDmaArrayConstBase<T, B>::GetOwner() {
    return m_pAttribute->GetOwner();
}

template <class T, class B>
inline bool CDmaArrayConstBase<T, B>::IsDirty() const {
    return m_pAttribute->IsFlagSet(FATTRIB_DIRTY);
}

template <class T, class B>
inline CDmAttribute *CDmaArrayBase<T, B>::GetAttribute() {
    Assert(this->m_pAttribute);
    return this->m_pAttribute;
}

template <class T, class B>
inline const CDmAttribute *CDmaArrayBase<T, B>::GetAttribute() const {
    Assert(this->m_pAttribute);
    return this->m_pAttribute;
}

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaStringArrayBase
//
//-----------------------------------------------------------------------------
template <class B>
inline const char *CDmaStringArrayConstBase<B>::operator[](int i) const {
    return this->Value()[i].Get();
}

template <class B>
inline const char *CDmaStringArrayConstBase<B>::Element(int i) const {
    return this->Value()[i].Get();
}

template <class B>
inline const char *CDmaStringArrayConstBase<B>::Get(int i) const {
    return this->Value()[i].Get();
}

template <class B>
inline const CUtlVector<CUtlString> &CDmaStringArrayConstBase<B>::Get() const {
    return this->Value();
}

// Returns strlen of element i
template <class B>
inline int CDmaStringArrayConstBase<B>::Length(int i) const {
    return this->Value()[i].Length();
}

template <class B>
inline void CDmaStringArrayBase<B>::Set(int i, const char *pValue) {
    CUtlString str(pValue, Q_strlen(pValue) + 1);
    BaseClass::Set(i, str);
}

// Adds an element, uses copy constructor
template <class B>
inline int CDmaStringArrayBase<B>::AddToTail(const char *pValue) {
    CUtlString str(pValue, Q_strlen(pValue) + 1);
    return BaseClass::AddToTail(str);
}

template <class B>
inline int CDmaStringArrayBase<B>::InsertBefore(int elem, const char *pValue) {
    CUtlString str(pValue, Q_strlen(pValue) + 1);
    return BaseClass::InsertBefore(elem, str);
}

//-----------------------------------------------------------------------------
//
// Inline methods for CDmaElementArrayBase
//
//-----------------------------------------------------------------------------
template <class E, class B>
inline UtlSymId_t CDmaElementArrayConstBase<E, B>::GetElementType() const {
    return this->Data().m_ElementType;
}

template <class E, class B>
inline E *CDmaElementArrayConstBase<E, B>::operator[](int i) const {
    return GetElement<E>(this->Value()[i]);
}

template <class E, class B>
inline E *CDmaElementArrayConstBase<E, B>::Element(int i) const {
    return GetElement<E>(this->Value()[i]);
}

template <class E, class B>
inline E *CDmaElementArrayConstBase<E, B>::Get(int i) const {
    return GetElement<E>(this->Value()[i]);
}

template <class E, class B>
inline const DmElementHandle_t &CDmaElementArrayConstBase<E, B>::GetHandle(
    int i) const {
    return this->Value()[i];
}

template <class E, class B>
inline const CUtlVector<DmElementHandle_t>
    &CDmaElementArrayConstBase<E, B>::Get() const {
    return this->Value();
}

// Search
template <class E, class B>
inline int CDmaElementArrayConstBase<E, B>::Find(const E *pValue) const {
    if (!pValue) return -1;
    return B::Find(pValue->GetHandle());
}

template <class E, class B>
inline int CDmaElementArrayConstBase<E, B>::Find(DmElementHandle_t h) const {
    return B::Find(h);
}

template <class E, class B>
inline void CDmaElementArrayBase<E, B>::SetHandle(int i, DmElementHandle_t h) {
    BaseClass::Set(i, h);
}

template <class E, class B>
inline void CDmaElementArrayBase<E, B>::Set(int i, E *pElement) {
    BaseClass::Set(i,
                   pElement ? pElement->GetHandle() : DMELEMENT_HANDLE_INVALID);
}

// Adds an element, uses copy constructor
template <class E, class B>
inline int CDmaElementArrayBase<E, B>::AddToTail() {
    return BaseClass::AddToTail();
}

template <class E, class B>
inline int CDmaElementArrayBase<E, B>::AddToTail(E *pValue) {
    return BaseClass::AddToTail(pValue ? pValue->GetHandle()
                                       : DMELEMENT_HANDLE_INVALID);
}

template <class E, class B>
inline int CDmaElementArrayBase<E, B>::AddToTail(DmElementHandle_t src) {
    return BaseClass::AddToTail(src);
}

template <class E, class B>
inline int CDmaElementArrayBase<E, B>::InsertBefore(int elem) {
    return BaseClass::InsertBefore(elem);
}

template <class E, class B>
inline int CDmaElementArrayBase<E, B>::InsertBefore(int elem, E *pValue) {
    return BaseClass::InsertBefore(
        elem, pValue ? pValue->GetHandle() : DMELEMENT_HANDLE_INVALID);
}

template <class E, class B>
inline int CDmaElementArrayBase<E, B>::InsertBefore(int elem,
                                                    DmElementHandle_t src) {
    return BaseClass::InsertBefore(elem, src);
}

//-----------------------------------------------------------------------------
//
// Inline methods for CDmrGenericArray
//
//-----------------------------------------------------------------------------
inline const CDmAttribute *CDmrGenericArrayConst::GetAttribute() const {
    Assert(m_pAttribute);
    return m_pAttribute;
}

inline bool CDmrGenericArrayConst::IsValid() const {
    return m_pAttribute != NULL;
}

inline CDmAttribute *CDmrGenericArray::GetAttribute() {
    Assert(m_pAttribute);
    return m_pAttribute;
}

inline const CDmAttribute *CDmrGenericArray::GetAttribute() const {
    Assert(m_pAttribute);
    return m_pAttribute;
}

#endif  // DMATTRIBUTEVAR_H