Ares
Classes | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes

Enumerable< T > Class Template Reference

#include <src/Enum/_Enumerator.hpp>

List of all members.

Classes

struct  comparator

Public Member Functions

 Enumerable ()
virtual ~Enumerable ()

Static Public Member Functions

static T ** stl_Find (const char *Title)
static int FindIndex (const char *Title)
static T * Find (const char *Title)
static T * FindOrAllocate (const char *Title)
static void ClearArray ()
static void LoadFromINIList (CCINIClass *pINI)
static const char * GetMainSection ()

Public Attributes

char Name [32]

Static Public Attributes

static DynamicVectorClass< T * > Array

template<typename T>
class Enumerable< T >


Constructor & Destructor Documentation

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

Member Function Documentation

template<typename T>
static void Enumerable< T >::ClearArray ( ) [inline, static]
        {
                for(int i = Array.Count - 1; i >= 0; --i) {
                        delete Array[i];
                        Array.RemoveItem(i);
                }
        }
template<typename T>
static T* Enumerable< T >::Find ( const char *  Title) [inline, static]
        {
/*              for(int i = 0; i < Array.get_Count(); ++i)
                        if(!_strcmpi(Title, Array.GetItem(i)->Name))
                                return Array.GetItem(i);
*/
                T** result = Enumerable<T>::stl_Find(Title);
                if(result == Array.end()) {
                        return NULL;
                }
                return *result;
        }
template<typename T>
static int Enumerable< T >::FindIndex ( const char *  Title) [inline, static]
        {
                for(int i = 0; i < Array.Count; ++i)
                        if(!_strcmpi(Title, Array.GetItem(i)->Name))
                                return i;
                return -1;
        }
template<typename T>
static T* Enumerable< T >::FindOrAllocate ( const char *  Title) [inline, static]
        {
                T *find = Find(Title);
                return find ? find : new T(Title);
        }
template<typename T>
static const char* Enumerable< T >::GetMainSection ( ) [static]
template<typename T>
static void Enumerable< T >::LoadFromINIList ( CCINIClass *  pINI) [inline, static]
        {
                const char *section = GetMainSection();
                int len = pINI->GetKeyCount(section);
                for(int i = 0; i < len; ++i) {
                        const char *Key = pINI->GetKeyName(section, i);
                        FindOrAllocate(Key);
                }
                for(int i = 0; i < Array.Count; ++i) {
                        Array[i]->LoadFromINI(pINI);
                }
        }
template<typename T>
static T** Enumerable< T >::stl_Find ( const char *  Title) [inline, static]
                                               {
                return std::find_if(Array.start(), Array.end(), std::bind2nd(comparator(), Title));
        }

Member Data Documentation

template<typename T>
DynamicVectorClass< T* > Enumerable< T >::Array [static]
template<typename T>
char Enumerable< T >::Name[32]

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