home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bc45 / classinc.pak / DICT.H < prev    next >
Text File  |  1997-07-23  |  11KB  |  362 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  DICT.H                                                                */
  4. /*                                                                        */
  5. /*  Copyright (c) 1993, 1994 Borland International                        */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( CLASSLIB_DICT_H )
  11. #define CLASSLIB_DICT_H
  12.  
  13. #if !defined( CLASSLIB_DEFS_H )
  14. #include <classlib/defs.h>
  15. #endif
  16.  
  17. #if !defined( CLASSLIB_SHDDEL_H )
  18. #include <classlib/shddel.h>
  19. #endif
  20.  
  21. #if !defined( CLASSLIB_HASHIMP_H )
  22. #include <classlib/hashimp.h>
  23. #endif
  24.  
  25. #pragma option -Vo-
  26. #if defined( BI_CLASSLIB_NO_po )
  27. #pragma option -po-
  28. #endif
  29.  
  30. /*------------------------------------------------------------------------*/
  31. /*                                                                        */
  32. /*  template <class T,class A> class TMDictionaryAsHashTable              */
  33. /*  template <class T,class A> class TMDictionaryAsHashTableIterator      */
  34. /*                                                                        */
  35. /*  Managed dictionary and iterator                                       */
  36. /*                                                                        */
  37. /*  Implements the dictionary container using a hash table.  Assumes      */
  38. /*  that T is of class TAssociation.                                      */
  39. /*                                                                        */
  40. /*------------------------------------------------------------------------*/
  41.  
  42. template <class T,class A> class TMDictionaryAsHashTableIterator;
  43.  
  44. template <class T,class A> class TMDictionaryAsHashTable :
  45.     public TShouldDelete
  46. {
  47. public:
  48.  
  49.     friend class TMDictionaryAsHashTableIterator<T,A>;
  50.  
  51.     TMDictionaryAsHashTable( unsigned size = DEFAULT_HASH_TABLE_SIZE ) :
  52.         HashTable(size)
  53.         {
  54.         }
  55.         
  56.     int Add( const T& t )
  57.         {
  58.         return Find( t ) ? 0 : HashTable.Add( t );
  59.         }
  60.         
  61.     int Detach( const T& t, DeleteType dt = DefDelete );
  62.         
  63.     T *Find( const T& t )
  64.         {
  65.         return HashTable.Find( t );
  66.         }
  67.  
  68.     void Flush( DeleteType dt = DefDelete );
  69.         
  70.     void ForEach( void (*func)(T&, void *),
  71.                   void *args )
  72.         {
  73.         HashTable.ForEach( func, args );
  74.         }
  75.         
  76.     unsigned GetItemsInContainer() const
  77.         {
  78.         return HashTable.GetItemsInContainer();
  79.         }
  80.         
  81.     int IsEmpty() const
  82.         {
  83.         return HashTable.IsEmpty();
  84.         }
  85.         
  86. protected:
  87.  
  88.     TMHashTableImp<T,A> HashTable;
  89.  
  90. private:
  91.  
  92.     static void DeleteElement( T& t, void * );
  93.     
  94. };
  95.  
  96. template <class T, class A>
  97. int TMDictionaryAsHashTable<T,A>::Detach( const T& t,
  98.                                           DeleteType dt = DefDelete )
  99. {
  100.     if( DelObj(dt) )
  101.         {
  102.         T *assoc = Find(t);
  103.         if( assoc )
  104.             assoc->DeleteElements();
  105.         }
  106.     return HashTable.Detach( t );
  107. }
  108.         
  109. template <class T, class A>
  110. void TMDictionaryAsHashTable<T,A>::Flush( DeleteType dt = DefDelete )
  111. {
  112.     if( DelObj(dt) )
  113.         {
  114.         HashTable.ForEach( DeleteElement, 0 );
  115.         }
  116.     HashTable.Flush();
  117. }
  118.         
  119. template <class T, class A>
  120. void TMDictionaryAsHashTable<T,A>::DeleteElement( T& t, void * )
  121. {
  122.     t.DeleteElements();
  123. }
  124.  
  125. template <class T,class A>
  126. class TMDictionaryAsHashTableIterator :
  127.     public TMHashTableIteratorImp<T,A>
  128. {
  129. public:
  130.  
  131.     TMDictionaryAsHashTableIterator( const TMDictionaryAsHashTable<T,A>& t ) :
  132.         TMHashTableIteratorImp<T,A>( t.HashTable )
  133.         {
  134.         }
  135.         
  136. };
  137.  
  138. /*------------------------------------------------------------------------*/
  139. /*                                                                        */
  140. /*  template <class T> class TDictionaryAsHashTable                       */
  141. /*  template <class T> class TDictionaryAsHashTableIterator               */
  142. /*                                                                        */
  143. /*  Standard dictionary and iterator                                      */
  144. /*                                                                        */
  145. /*------------------------------------------------------------------------*/
  146.  
  147. template <class T> class TDictionaryAsHashTable :
  148.     public TMDictionaryAsHashTable<T,TStandardAllocator>
  149. {
  150.  
  151. public:
  152.  
  153.     TDictionaryAsHashTable( unsigned size = DEFAULT_HASH_TABLE_SIZE ) :
  154.         TMDictionaryAsHashTable<T,TStandardAllocator>(size)
  155.         {
  156.         }
  157.         
  158. };
  159.  
  160. template <class T>
  161. class TDictionaryAsHashTableIterator :
  162.     public TMDictionaryAsHashTableIterator<T,TStandardAllocator>
  163. {
  164. public:
  165.  
  166.     TDictionaryAsHashTableIterator( const TDictionaryAsHashTable<T>& t ) :
  167.         TMDictionaryAsHashTableIterator<T,TStandardAllocator>( t )
  168.         {
  169.         }
  170.         
  171. };
  172.  
  173. /*------------------------------------------------------------------------*/
  174. /*                                                                        */
  175. /*  template <class T,class A> class TMIDictionaryAsHashTable             */
  176. /*  template <class T,class A> class TMIDictionaryAsHashTableIterator     */
  177. /*                                                                        */
  178. /*  Managed indirect dictionary and iterator                              */
  179. /*                                                                        */
  180. /*------------------------------------------------------------------------*/
  181.  
  182. template <class T,class A> class TMIDictionaryAsHashTableIterator;
  183.  
  184. template <class T,class A> class TMIDictionaryAsHashTable :
  185.     public TShouldDelete
  186. {
  187.  
  188. public:
  189.  
  190.     friend class TMIDictionaryAsHashTableIterator<T,A>;
  191.  
  192.     TMIDictionaryAsHashTable( unsigned size = DEFAULT_HASH_TABLE_SIZE ) :
  193.         HashTable(size)
  194.         {
  195.         }
  196.         
  197.     int Add( T *t )
  198.         {
  199.         return Find( t ) ? 0 : HashTable.Add( t );
  200.         }
  201.         
  202.     int Detach( T *t, DeleteType dt = DefDelete );
  203.         
  204.     T *Find( T *t )
  205.         {
  206.         return HashTable.Find( t );
  207.         }
  208.  
  209.     void Flush( DeleteType dt = DefDelete );
  210.         
  211.     void ForEach( void (*func)(T&, void *),
  212.                   void *args )
  213.         {
  214.         HashTable.ForEach( func, args );
  215.         }
  216.         
  217.     unsigned GetItemsInContainer() const
  218.         {
  219.         return HashTable.GetItemsInContainer();
  220.         }
  221.         
  222.     int IsEmpty() const
  223.         {
  224.         return HashTable.IsEmpty();
  225.         }
  226.         
  227. protected:
  228.  
  229.     TMIHashTableImp<T,A> HashTable;
  230.     
  231. private:
  232.  
  233.     static void DeleteElement( T& t, void * );
  234.     
  235. };
  236.  
  237. template <class T, class A>
  238. int TMIDictionaryAsHashTable<T,A>::Detach( T *t, DeleteType dt = DefDelete )
  239. {
  240.     if( DelObj(dt) )
  241.         {
  242.         T *assoc = Find(t);
  243.         if( assoc )
  244.             assoc->DeleteElements();
  245.         }
  246.     return HashTable.Detach( t, DelObj(dt) );
  247. }
  248.         
  249. template <class T, class A>
  250. void TMIDictionaryAsHashTable<T,A>::Flush( DeleteType dt = DefDelete )
  251. {
  252.     if( DelObj(dt) )
  253.         {
  254.         HashTable.ForEach( DeleteElement, 0 );
  255.         }
  256.     HashTable.Flush(DelObj(dt));
  257. }
  258.         
  259. template <class T, class A>
  260. void TMIDictionaryAsHashTable<T,A>::DeleteElement( T& t, void * )
  261. {
  262.     t.DeleteElements();
  263. }
  264.  
  265. template <class T,class A>
  266. class TMIDictionaryAsHashTableIterator :
  267.     public TMIHashTableIteratorImp<T,A>
  268. {
  269. public:
  270.  
  271.     TMIDictionaryAsHashTableIterator( const TMIDictionaryAsHashTable<T,A>& t ) :
  272.         TMIHashTableIteratorImp<T,A>( t.HashTable )
  273.         {
  274.         }
  275.         
  276. };
  277.  
  278. /*------------------------------------------------------------------------*/
  279. /*                                                                        */
  280. /*  template <class T> class TIDictionaryAsHashTable                      */
  281. /*  template <class T> class TIDictionaryAsHashTableIterator              */
  282. /*                                                                        */
  283. /*  Standard indirect dictionary and iterator                             */
  284. /*                                                                        */
  285. /*------------------------------------------------------------------------*/
  286.  
  287. template <class T> class TIDictionaryAsHashTableIterator;
  288.  
  289. template <class T> class TIDictionaryAsHashTable :
  290.     public TMIDictionaryAsHashTable<T,TStandardAllocator>
  291. {
  292.  
  293. public:
  294.  
  295.     friend class TIDictionaryAsHashTableIterator<T>;
  296.  
  297.     TIDictionaryAsHashTable( unsigned size = DEFAULT_HASH_TABLE_SIZE ) :
  298.         TMIDictionaryAsHashTable<T,TStandardAllocator>(size)
  299.         {
  300.         }
  301.  
  302. };
  303.  
  304. template <class T> class TIDictionaryAsHashTableIterator :
  305.     public TMIDictionaryAsHashTableIterator<T,TStandardAllocator>
  306. {
  307. public:
  308.  
  309.     TIDictionaryAsHashTableIterator( const TIDictionaryAsHashTable<T>& t ) :
  310.         TMIDictionaryAsHashTableIterator<T,TStandardAllocator>( t )
  311.         {
  312.         }
  313.         
  314. };
  315.  
  316. /*------------------------------------------------------------------------*/
  317. /*                                                                        */
  318. /*  template <class T> class TDictionary                                  */
  319. /*  template <class T> class TDictionaryIterator                          */
  320. /*                                                                        */
  321. /*  Easy names for TDictionaryAsHashTable and                             */
  322. /*  TDictionaryAsHashTableIterator                                        */
  323. /*                                                                        */
  324. /*------------------------------------------------------------------------*/
  325.  
  326. template <class T> class TDictionary :
  327.     public TDictionaryAsHashTable<T>
  328. {
  329.  
  330. public:
  331.  
  332.     TDictionary( unsigned size = DEFAULT_HASH_TABLE_SIZE ) :
  333.         TDictionaryAsHashTable<T>( size )
  334.         {
  335.         }
  336.  
  337. };
  338.  
  339. template <class T> class TDictionaryIterator :
  340.     public TDictionaryAsHashTableIterator<T>
  341. {
  342.  
  343. public:
  344.  
  345.  
  346.     TDictionaryIterator( const TDictionary<T>& a ) :
  347.         TDictionaryAsHashTableIterator<T>(a)
  348.         {
  349.         }
  350.  
  351. };
  352.  
  353. #if defined( BI_CLASSLIB_NO_po )
  354. #pragma option -po.
  355. #endif
  356.  
  357. #pragma option -Vo.
  358.  
  359. #endif  // CLASSLIB_DICT_H
  360.  
  361. 
  362.