TnbPointerVector.h

[詳解]

#pragma once
#include "TnbVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CPointerVectorT : public IConstCollectionT<TYP*>
{
    DEFSUPER(IConstCollectionT<TYP*>);
    CVectorT< CPointerHandleT<TYP> > m_vhPointer;   
public:
 
    explicit CPointerVectorT(size_t size = 0) : _super()
    {
        m_vhPointer.SetIncrementSize(size);
    }
    
    CPointerVectorT(const CPointerVectorT<TYP>& v) : _super(), m_vhPointer(v.m_vhPointer)
    {
    }
 
    CPointerVectorT& operator=(const CPointerVectorT<TYP>& other) 
    {
        m_vhPointer = other.m_vhPointer;
        return *this;
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const { return true; }
 
    virtual void Unlock(void) const {}
 
    virtual TYP* const& At(INDEX index) const
    {
        return *(m_vhPointer.At(index).ReferP());
    }
 
    virtual ~CPointerVectorT(void) 
    {
    }
 
    bool Remove(INDEX index)
    {
        return m_vhPointer.Remove(index);
    }
 
    void RemoveAll(void)
    {
        m_vhPointer.RemoveAll();
    }
 
    size_t RemoveElements(INDEX index, size_t size = 0)
    {
        return m_vhPointer.RemoveElements(index, size);
    }
 
    void SetSize(size_t size)
    {
        m_vhPointer.SetSize(size);
    }
 
    INDEX Add(TYP* P)
    {
        return m_vhPointer.Add(P); 
    }
 
    bool Insert(INDEX index, TYP* P)
    {
        return m_vhPointer.Insert(index, P); 
    }
 
    bool Set(INDEX index, TYP* P)
    {
        return m_vhPointer.Set(index, P); 
    }
    
    TYP* operator[](INDEX index) const 
    {
        return Get(index); 
    }
    
    virtual size_t GetSize( void ) const
    { 
        return m_vhPointer.GetSize(); 
    }
 
    virtual void Serialize(ISerializer& _sr) const
    {
        throw CNotSupportException();
    }
};
 
 
 
}; // TNB