Main Page | Class Hierarchy | Class List | Directories | File List | Class Members | File Members | Related Pages

GMap.h

00001 #ifndef _GMAP_H
00002 #define _GMAP_H
00003 
00004 #define GMapTemplate        template <typename N, typename V>
00005 #define GMapClass           GMap<N,V>
00006 
00007 GMapTemplate
00008 class GMap
00009 {
00010     class Mapping
00011     {
00012     public:
00013         N Name;
00014         V Value;
00015 
00016         Mapping()
00017         {
00018             Name = 0;
00019             Value = 0;
00020         }
00021     };
00022 
00023     List<Mapping> Maps;
00024     N NewName;
00025     bool CaseSen;
00026     
00027     // New
00028     const char *New(const char *s) { return (const char*)NewStr(s); }
00029     char *New(char *s) { return NewStr(s); }
00030     const char16 *New(const char16 *s) { return (const char16*) NewStrW(s); }
00031     char16 *New(char16 *s) { return NewStrW(s); }
00032     int New(int i) { return i; }
00033 
00034     // Cmp
00035     int Cmp(const char *a, const char *b)
00036     {
00037         return CaseSen ? strcmp(a, b) : stricmp(a, b);
00038     }
00039     
00040     int Cmp(char *a, char *b)
00041     {
00042         return CaseSen ? strcmp(a, b) : stricmp(a, b);
00043     }
00044     
00045     int Cmp(const char16 *a, const char16 *b)
00046     {
00047         return CaseSen ? StrcmpW(a, b) : StricmpW(a, b);
00048     }
00049     
00050     int Cmp(char16 *a, char16 *b)
00051     {
00052         return CaseSen ? StrcmpW(a, b) : StricmpW(a, b);
00053     }
00054     
00055     int Cmp(int a, int b)
00056     {
00057         return a - b;
00058     }
00059 
00060     // Delete
00061     void Delete(char *&a) { DeleteArray(a); }
00062     void Delete(char16 *&a) { DeleteArray(a); }
00063     void Delete(int &a) { }
00064 
00065 protected:
00066     Mapping *Get(N n)
00067     {
00068         for (Mapping *m=Maps.First(); m; m=Maps.Next())
00069         {
00070             if (Cmp(m->Name, n) == 0)
00071             {
00072                 return m;
00073             }
00074         }
00075 
00076         return 0;
00077     }
00078 
00079 public:
00080     GMap(bool Case = false)
00081     {
00082         NewName = 0;
00083         CaseSen = Case;
00084     }
00085     
00086     ~GMap()
00087     {
00088         Empty();
00089     }
00090 
00091     void Empty()
00092     {
00093         for (Mapping *m=Maps.First(); m; m=Maps.Next())
00094         {
00095             Delete(m->Name);
00096             Delete(m->Value);
00097         }
00098 
00099         Maps.DeleteObjects();
00100         NewName = 0;
00101     }
00102 
00103     N NameAt(int i)
00104     {
00105         Mapping *m = Maps[i];
00106         if (m)
00107         {
00108             return m->Name;
00109         }
00110         return 0;
00111     }
00112 
00113     N Reverse(V v)
00114     {
00115         for (Mapping *m=Maps.First(); m; m=Maps.Next())
00116         {
00117             if (Cmp(v, m->Value) == 0)
00118             {
00119                 return m->Name;
00120             }
00121         }
00122 
00123         return 0;
00124     }
00125 
00126     int Length()
00127     {
00128         return Maps.GetItems();
00129     }
00130 
00131     bool HasMap(N s)
00132     {
00133         return Get(s) != 0;
00134     }
00135     
00136     GMapClass &operator [](N s)
00137     {
00138         NewName = s;
00139         return *this;
00140     }
00141 
00142     GMapClass &operator =(V v)
00143     {
00144         if (NewName)
00145         {
00146             Mapping *m = Get(NewName);
00147             if (NOT m)
00148             {
00149                 m = NEW(Mapping);
00150                 if (m)
00151                 {
00152                     m->Name = New(NewName);
00153                     Maps.Insert(m);
00154                 }
00155             }
00156 
00157             if (m)
00158             {
00159                 Delete(m->Value);
00160                 m->Value = New(v);
00161             }
00162         }
00163 
00164         return *this;
00165     }
00166 
00167     operator V()
00168     {
00169         Mapping *m;
00170         if (m = Get(NewName))
00171         {
00172             return m->Value;
00173         }
00174 
00175         return 0;
00176     }
00177 };
00178 
00179 typedef GMap<char*, char*> GStrMap;
00180 
00181 #endif

Generated on Wed Oct 26 14:46:49 2005 for Lgi by  doxygen 1.4.1