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

Container< T > Class Template Reference

#include <src/Ext/_Container.hpp>

Inheritance diagram for Container< T >:
hash_map

List of all members.

Public Member Functions

void PointerGotInvalid (void *ptr)
 Container ()
virtual ~Container ()
E_TFindOrAllocate (S_T *key)
E_TFind (S_T *key)
void Remove (S_T *key)
void Remove (typename C_Map::iterator i)
void Empty ()
void LoadAllFromINI (CCINIClass *pINI)
void LoadFromINI (S_T *key, CCINIClass *pINI)
void LoadAllFromRules (CCINIClass *pINI)
void SaveStatic ()
void Save (S_T *key, IStream *pStm)
E_TSaveKey (S_T *key, IStream *pStm)
void LoadStatic ()
void Load (S_T *key, IStream *pStm)
E_TLoadKey (S_T *key, IStream *pStm)
template<>
RulesExt::TTSavingObject
template<>
IStream * SavingStream

Static Public Attributes

static S_TSavingObject
static IStream * SavingStream

Protected Member Functions

virtual void InvalidatePointer (void *ptr)
void InvalidateExtDataPointer (void *ptr)

Private Types

typedef T::TT S_T
typedef T::ExtData E_T
typedef hash_map< S_T *, E_T * > C_Map

template<typename T>
class Container< T >


Member Typedef Documentation

template<typename T>
typedef hash_map<S_T*, E_T*> Container< T >::C_Map [private]
template<typename T>
typedef T::ExtData Container< T >::E_T [private]
template<typename T>
typedef T::TT Container< T >::S_T [private]

Constructor & Destructor Documentation

template<typename T>
Container< T >::Container ( ) [inline]
                    {
        }
template<typename T>
virtual Container< T >::~Container ( ) [inline, virtual]
                             {
                Empty();
        }

Member Function Documentation

template<typename T>
void Container< T >::Empty ( ) [inline]
                     {
                for(typename C_Map::iterator i = this->begin(); i != this->end(); ) {
                        delete i->second;
                        erase(i++);
        //              ++i;
                }
        }
template<typename T>
E_T* Container< T >::Find ( S_T key) [inline]
                            {
                typename C_Map::iterator i = this->find(key);
                if(i == this->end()) {
                        return NULL;
                }
                return i->second;
        }
template<typename T>
E_T* Container< T >::FindOrAllocate ( S_T key) [inline]
                                      {
                if(key == NULL) {
                        const std::type_info &info = typeid(*this);
                        Debug::Log("CTOR of %s attempted for a NULL pointer! WTF!\n", info.name());
                        return NULL;
                }
                typename C_Map::iterator i = this->find(key);
                if(i == this->end()) {
                        E_T * val = new E_T(/*typename*/ E_T::Canary, key);
                        val->InitializeConstants(key);
                        i = this->insert(typename C_Map::value_type(key, val)).first;
                }
                return i->second;
        }
template<typename T>
void Container< T >::InvalidateExtDataPointer ( void *  ptr) [inline, protected]
                                                 {
                for(typename C_Map::iterator i = this->begin(); i != this->end(); ++i) {
                        i->second->InvalidatePointer(ptr);
                }
        }
template<typename T>
virtual void Container< T >::InvalidatePointer ( void *  ptr) [inline, protected, virtual]
                                                  {
        };
template<typename T>
void Container< T >::Load ( S_T key,
IStream *  pStm 
) [inline]
                                           {
                this->LoadKey(key, pStm);
        }
template<typename T>
void Container< T >::LoadAllFromINI ( CCINIClass *  pINI) [inline]
                                              {
                for(typename C_Map::iterator i = this->begin(); i != this->end(); i++) {
                        i->second->LoadFromINI(i->first, pINI);
                }
        }
template<typename T>
void Container< T >::LoadAllFromRules ( CCINIClass *  pINI) [inline]
                                                {
                for(typename C_Map::iterator i = this->begin(); i != this->end(); i++) {
                        i->second->LoadFromRulesFile(i->first, pINI);
                }
        }
template<typename T>
void Container< T >::LoadFromINI ( S_T key,
CCINIClass *  pINI 
) [inline]
                                                    {
                typename C_Map::iterator i = this->find(key);
                if(i != this->end()) {
                        i->second->LoadFromINI(key, pINI);
                }
        }
template<typename T>
E_T* Container< T >::LoadKey ( S_T key,
IStream *  pStm 
) [inline]
                                              {
                ULONG out;

                const std::type_info &info = typeid(key);
                Debug::Log("Loading Key [%s] (%X)\n", info.name(), key);

                if(key == NULL) {
                        Debug::Log("Load attempted for a NULL pointer! WTF!\n");
                        return NULL;
                }
                E_T* buffer = this->FindOrAllocate(key);
                long origPtr;
                pStm->Read(&origPtr, 4, &out);
                pStm->Read(buffer, buffer->Size(), &out);
                Debug::Log("LoadKey Swizzle: %X => %X\n", origPtr, buffer);
                SwizzleManagerClass::Instance.Here_I_Am(origPtr, (void *)buffer);
                SWIZZLE(buffer->AttachedToObject);
#ifdef DEBUGBUILD
                        assert(buffer->SavedCanary == typename E_T::Canary);
#endif
                return buffer;
        };
template<typename T>
void Container< T >::LoadStatic ( ) [inline]
template<typename T>
void Container< T >::PointerGotInvalid ( void *  ptr) [inline]
                                          {
                this->InvalidatePointer(ptr);
                this->InvalidateExtDataPointer(ptr);
        }
template<typename T>
void Container< T >::Remove ( typename C_Map::iterator  i) [inline]
                                              {
                if(i != this->end()) {
                        delete i->second;
                        erase(i);
                }
        }
template<typename T>
void Container< T >::Remove ( S_T key) [inline]
                              {
                typename C_Map::iterator i = this->find(key);
                if(i != this->end()) {
                        delete i->second;
                        erase(i);
                }
        }
template<typename T>
void Container< T >::Save ( S_T key,
IStream *  pStm 
) [inline]
                                           {
                this->SaveKey(key, pStm);
        }
template<typename T>
E_T* Container< T >::SaveKey ( S_T key,
IStream *  pStm 
) [inline]
                                              {
                ULONG out;

                const std::type_info &info = typeid(key);
                Debug::Log("Saving Key [%s] (%X)\n", info.name(), key);

                if(key == NULL) {
                        return NULL;
                }
                E_T* buffer = this->Find(key);
                Debug::Log("\tKey maps to %X\n", buffer);
                if(buffer) {
                        pStm->Write(&buffer, 4, &out);
                        pStm->Write(buffer, buffer->Size(), &out);
//                      Debug::Log("Save used up 0x%X bytes (HRESULT 0x%X)\n", out, res);
                }

                Debug::Log("\n\n");
                return buffer;
        };
template<typename T>
void Container< T >::SaveStatic ( ) [inline]
template<>
IStream * Container< RulesExt >::SavingStream ( )

Member Data Documentation

template<typename T>
S_T* Container< T >::SavingObject [static]
template<typename T>
IStream* Container< T >::SavingStream [static]

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