TnbAttributedVector.h

[詳解]

#pragma once
#include "TnbVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP, typename ATT = DWORD>
class CAttributedVectorT : public CVectorT<TYP>
{
    DEFSUPER(CVectorT<TYP>);
public:
 
    CAttributedVectorT(void) : _super()
    {
    }
 
    CAttributedVectorT(const CAttributedVectorT& other) : _super(other), m_vAttr(other.m_vAttr)
    {
    }
 
    virtual ~CAttributedVectorT(void)
    {
    }
 
    CAttributedVectorT& operator=(const CAttributedVectorT& other)
    {
        _super::operator=(other);
        m_vAttr = other.m_vAttr;
        return *this;
    }
 
    CAttributedVectorT& operator+=(const CAttributedVectorT& other)
    {
        _super::operator+=(other);
        m_vAttr += other.m_vAttr;
        return *this;
    }
 
    CAttributedVectorT operator+(const CAttributedVectorT& other) const
    {
        CAttributedVectorT av;
        CVectorT<TYP>& v1 = av;
        const CVectorT<TYP>& v2 = *this;
        v1 = v2 + other;
        av.m_vAttr = m_vAttr + other.m_vAttr;
        return av;
    }
 
    virtual const CVectorT<TYP>& Refer(void) const
    {
        return *this;
    }
 
    virtual bool Remove(INDEX index)
    {
        return _super::Remove(index) && m_vAttr.Remove(index);
    }
 
    virtual size_t SetElements(size_t size, const TYP* P = NULL)
    {
        size_t r = _super::SetElements(size, P);
        m_vAttr.RemoveAll();
        m_vAttr.SetSize(_super::GetSize());
        return r;
    }
 
    virtual bool Set(INDEX index, const TYP& t)
    {
        return Set(index, t, 0);
    }
 
    virtual bool SetEx(INDEX index, const TYP& t)
    {
        return SetEx(index, t, 0);
    }
 
    virtual bool RemoveAll(void)
    {
        return _super::RemoveAll() && m_vAttr.RemoveAll();
    }
 
    virtual void Swap(INDEX index1, INDEX index2)
    {
        _super::Swap(index1, index2);
        m_vAttr.Swap(index1, index2);
    }
 
    INDEX Add(const TYP& t, const ATT& attribute)
    {
        INDEX r1 = _super::Add(t);
        INDEX r2 = m_vAttr.Add(attribute);
        if ( IsInvalid(r1)  || IsInvalid(r2) )
        {
            return INVALID_INDEX;
        }
        ASSERTLIB( r1 == r2 );
        return r1;
    }
 
    INDEX AddEx(const TYP& t, const ATT& attribute)
    {
        EXCLUSIVE(this);
        return Add(t, attribute);
    }
 
    bool Set(INDEX index, const TYP& t, const ATT& attribute)
    {
        return _super::Set(index, t) && m_vAttr.Set(index, attribute);
    }
 
    bool SetEx(INDEX index, const TYP& t, const ATT& attribute)
    {
        EXCLUSIVE(this);
        return Set(index, t, attribute);
    }
 
    ATT GetAttribute(INDEX index) const
    {
        EXCLUSIVE(this);
        return m_vAttr.Get(index);
    }
 
    bool SetAttribute(INDEX index, const ATT& attribute)
    {
        return m_vAttr.SetEx(index, attribute);
    }
 
    bool Insert(INDEX index, const TYP& t, const ATT& attribute = ATT())
    {
        EXCLUSIVE(this);
        return _super::Insert(inex, t) && m_vAttr.Insert(index, attribute);
    }
 
    virtual bool SetSize(size_t size)
    {
        return _super::SetSize(size) && m_vAttr.SetSize(size);
    }
 
    virtual void Serialize(ISerializer& _sr) const
    {
        _super::Serialize(_sr);
        _sr << m_vAttr;
    }
 
    virtual void Deserialize(const IDeserializer& ds)
    {
        _super::Deserialize(ds);
        ds >> m_vAttr;
    }
 
private:
    CVectorT<ATT>       m_vAttr;    
};
 
 
 
}; // TNB