Ares
Public Member Functions | Public Attributes | Static Public Attributes | Private Member Functions

Extension< T > Class Template Reference

#include <src/Ext/_Container.hpp>

List of all members.

Public Member Functions

 Extension (const DWORD Canary, T *const OwnerObject)
virtual ~Extension ()
virtual size_t Size () const =0
void LoadFromINI (T *pThis, CCINIClass *pINI)
virtual void LoadFromINIFile (T *pThis, CCINIClass *pINI)
virtual void LoadFromRulesFile (T *pThis, CCINIClass *pINI)
virtual void InitializeConstants (T *pThis)
virtual void InitializeRuled (T *pThis)
virtual void Initialize (T *pThis)
virtual void InvalidatePointer (void *ptr)=0
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary
template<>
const DWORD Canary

Public Attributes

eInitState _Initialized
T *const AttachedToObject

Static Public Attributes

static const DWORD Canary

Private Member Functions

void operator= (Extension &RHS)

template<typename T>
class Extension< T >


Constructor & Destructor Documentation

template<typename T>
Extension< T >::Extension ( const DWORD  Canary,
T *const  OwnerObject 
) [inline]
                                                                    :
                _Initialized(is_Blank),
        #ifdef DEBUGBUILD
                SavedCanary(Canary),
        #endif
                AttachedToObject(OwnerObject)
                { };
template<typename T>
virtual Extension< T >::~Extension ( ) [inline, virtual]
{ };

Member Function Documentation

template<>
const DWORD Extension< AnimTypeClass >::Canary ( )
template<>
const DWORD Extension< BuildingClass >::Canary ( )
template<>
const DWORD Extension< WarheadTypeClass >::Canary ( )
template<>
const DWORD Extension< HouseClass >::Canary ( )
template<>
const DWORD Extension< HouseTypeClass >::Canary ( )
template<>
const DWORD Extension< RulesClass >::Canary ( )
template<>
const DWORD Extension< SideClass >::Canary ( )
template<>
const DWORD Extension< SuperWeaponTypeClass >::Canary ( )
template<>
const DWORD Extension< TechnoClass >::Canary ( )
template<>
const DWORD Extension< TechnoTypeClass >::Canary ( )
template<>
const DWORD Extension< CampaignClass >::Canary ( )
template<>
const DWORD Extension< BuildingTypeClass >::Canary ( )
template<>
const DWORD Extension< BulletClass >::Canary ( )
template<>
const DWORD Extension< WeaponTypeClass >::Canary ( )
template<>
const DWORD Extension< BulletTypeClass >::Canary ( )
template<typename T>
virtual void Extension< T >::Initialize ( T *  pThis) [inline, virtual]
{ };
template<typename T>
virtual void Extension< T >::InitializeConstants ( T *  pThis) [inline, virtual]
{ };
template<typename T>
virtual void Extension< T >::InitializeRuled ( T *  pThis) [inline, virtual]
{ };
template<typename T>
virtual void Extension< T >::InvalidatePointer ( void *  ptr) [pure virtual]
template<typename T>
void Extension< T >::LoadFromINI ( T *  pThis,
CCINIClass *  pINI 
) [inline]
                                                             {
                        if(!pINI) {
                                return;
                        }

                        switch(this->_Initialized) {
                                case is_Blank:
                                        this->InitializeConstants(pThis);
                                        this->_Initialized = is_Constanted;
                                case is_Constanted:
                                        this->InitializeRuled(pThis);
                                        this->_Initialized = is_Ruled;
                                case is_Ruled:
                                        this->Initialize(pThis);
                                        this->_Initialized = is_Inited;
                                case is_Inited:
                                case is_Completed:
                                        if(pINI == CCINIClass::INI_Rules) {
                                                this->LoadFromRulesFile(pThis, pINI);
                                        }
                                        this->LoadFromINIFile(pThis, pINI);
                                        this->_Initialized = is_Completed;
                        }
                }
template<typename T>
virtual void Extension< T >::LoadFromINIFile ( T *  pThis,
CCINIClass *  pINI 
) [inline, virtual]
{};
template<typename T>
virtual void Extension< T >::LoadFromRulesFile ( T *  pThis,
CCINIClass *  pINI 
) [inline, virtual]
{};
template<typename T>
void Extension< T >::operator= ( Extension< T > &  RHS) [inline, private]
                                                 {

                }
template<typename T>
virtual size_t Extension< T >::Size ( ) const [pure virtual]

Member Data Documentation

template<typename T>
eInitState Extension< T >::_Initialized
template<typename T>
T* const Extension< T >::AttachedToObject
template<typename T>
const DWORD Extension< T >::Canary [static]

The documentation for this class was generated from the following file:
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Defines