home *** CD-ROM | disk | FTP | other *** search
/ Chip 1997 October / Chip_1997-10_cd.bin / tema / sybase / powerj / h.z / WCHITER.H < prev    next >
C/C++ Source or Header  |  1996-11-06  |  9KB  |  356 lines
  1. //
  2. //  wchiter.h    Definitions for the WATCOM Container Hash Iterator Classes
  3. //
  4. //  Copyright by WATCOM International Corp. 1988-1996.  All rights reserved.
  5. //
  6. #ifndef _WCHITER_H_INCLUDED
  7. #define _WCHITER_H_INCLUDED
  8. #if !defined(_ENABLE_AUTODEPEND)
  9.   #pragma read_only_file;
  10. #endif
  11.  
  12. #ifndef __cplusplus
  13. #error wchiter.h is for use with C++
  14. #endif
  15.  
  16. #ifndef _WCDEFS_H_INCLUDED
  17.  #include <wcdefs.h>
  18. #endif
  19. #ifndef _WCEXCEPT_H_INCLUDED
  20.  #include <wcexcept.h>
  21. #endif
  22. #ifndef _WCHASH_H_INCLUDED
  23.  #include <wchash.h>
  24. #endif
  25.  
  26.  
  27. //
  28. // The WCHashIterBase is the base class for all hash iterator classes
  29. //
  30. // WCIterExcept is used as a base class to provide exception handling
  31. //
  32. //
  33.  
  34. class WCHashIterBase : public WCIterExcept {
  35. private:
  36.     typedef WCSLink BaseHashLink;
  37.  
  38. protected:
  39.     const WCHashBase *          curr_hash;
  40.     WCIsvSListIter<BaseHashLink> bucket_iter;
  41.     unsigned                    curr_bucket;
  42.     int                         at_end;
  43.  
  44.     _WPRTLINK WCbool base_advance();
  45.  
  46.     inline WCbool base_hash_valid() const {
  47.         return( ( curr_hash != 0 )&&( curr_hash->num_buckets > 0 ) );
  48.     };
  49.  
  50. public:
  51.     inline WCHashIterBase() : curr_hash( 0 ), bucket_iter()
  52.                                 , curr_bucket( 0 ), at_end( 0 ) {};
  53.  
  54.     inline WCHashIterBase( const WCHashBase& hash )
  55.                 : curr_hash( &hash ), bucket_iter() {
  56.         reset();
  57.     };
  58.  
  59.     inline virtual ~WCHashIterBase() = 0;
  60.  
  61.     _WPRTLINK void reset();
  62. };
  63.  
  64.  
  65. WCHashIterBase::~WCHashIterBase() {};
  66.  
  67.  
  68.  
  69. //
  70. // The WCValHashTableIter is the iterator for the WCValHashTable class
  71. //
  72. // WCIterExcept is used as a base class to provide exception handling
  73. //
  74.  
  75. template<class Type>
  76. class WCValHashTableIter : public WCHashIterBase {
  77. protected:
  78.     typedef WCHashLink<Type> HashLink;
  79.     
  80.     // get the current hashlink object, or 0 if current undefined
  81.     WCHashLink<Type> *base_curr_hashlink() const;
  82.  
  83. public:
  84.     inline WCValHashTableIter() {};
  85.  
  86.     inline WCValHashTableIter( const WCValHashTable<Type>& hash )
  87.                 : WCHashIterBase( hash ) {};
  88.  
  89.     inline virtual ~WCValHashTableIter() {};
  90.  
  91.     inline const WCValHashTable<Type> *container() const {
  92.         if( curr_hash == 0 ) {
  93.             base_throw_undef_iter();
  94.         }
  95.         return( (const WCValHashTable<Type> *)curr_hash );
  96.     };
  97.  
  98.     Type current() const;
  99.  
  100.     inline void reset() {
  101.         WCHashIterBase::reset();
  102.     };
  103.  
  104.     inline void reset( const WCValHashTable<Type> &hash ) {
  105.         curr_hash = &hash;
  106.         reset();
  107.     };
  108.  
  109.     inline WCbool operator++() {
  110.         return( base_advance() );
  111.     }
  112.  
  113.     inline WCbool operator()() {
  114.         return( base_advance() );
  115.     }
  116. };
  117.  
  118.  
  119. template <class Type>
  120. WCHashLink<Type> *WCValHashTableIter<Type>::base_curr_hashlink() const {
  121.     HashLink *link = 0;
  122.     if( base_hash_valid() ) {
  123.         link = (HashLink *)bucket_iter.current();
  124.     } 
  125.     return( link );
  126. };
  127.  
  128.  
  129. template <class Type>
  130. Type WCValHashTableIter<Type>::current() const {
  131.     HashLink *link = base_curr_hashlink();
  132.     if( link == 0 ) {
  133.         // bucket_iter is off end or no hash to iterate over
  134.         base_throw_undef_item();
  135.         Type temp;
  136.         return( temp );
  137.     }
  138.     return( link->data );
  139. };
  140.  
  141.  
  142.  
  143.  
  144. //
  145. // The WCPtrHashTableIter is the iterator for the WCPtrHashTable class.
  146. //
  147.  
  148. template<class Type>
  149. class WCPtrHashTableIter : public WCValHashTableIter<void *> {
  150. public:
  151.     inline WCPtrHashTableIter() {};
  152.  
  153.     inline WCPtrHashTableIter( const WCPtrHashTable<Type>& hash )
  154.                 : WCValHashTableIter( hash ) {};
  155.  
  156.     inline virtual ~WCPtrHashTableIter() {};
  157.  
  158.     inline const WCPtrHashTable<Type> *container() const {
  159.         return( (const WCPtrHashTable<Type> *)WCValHashTableIter::container() );
  160.     };
  161.  
  162.     inline Type *current() const {
  163.         return( (Type *)WCValHashTableIter::current() );
  164.     };
  165.  
  166.     inline void reset() {
  167.         WCValHashTableIter::reset();
  168.     };
  169.  
  170.     inline void reset( const WCPtrHashTable<Type> &hash ) {
  171.         WCValHashTableIter::reset( hash );
  172.     };
  173. };
  174.  
  175.  
  176.  
  177.  
  178. //
  179. // The WCValHashSetIter is the iterator for the WCValHashSet class.
  180. //
  181.  
  182. template<class Type>
  183. class WCValHashSetIter : public WCValHashTableIter<Type> {
  184. public:
  185.     inline WCValHashSetIter() {};
  186.  
  187.     inline WCValHashSetIter( const WCValHashSet<Type>& hash )
  188.                 : WCValHashTableIter( hash ) {};
  189.  
  190.     inline virtual ~WCValHashSetIter() {};
  191.  
  192.     inline const WCValHashSet<Type> *container() const {
  193.         return( (const WCValHashSet<Type> *)WCValHashTableIter::container() );
  194.     };
  195.  
  196.     inline void reset() {
  197.         WCValHashTableIter::reset();
  198.     };
  199.  
  200.     inline void reset( const WCValHashSet<Type> &hash ) {
  201.         WCValHashTableIter::reset( hash );
  202.     };
  203. };
  204.  
  205.  
  206.  
  207.  
  208. //
  209. // The WCPtrHashSetIter is the iterator for the WCPtrHashSet class.
  210. //
  211.  
  212. template<class Type>
  213. class WCPtrHashSetIter : public WCPtrHashTableIter<Type> {
  214. public:
  215.     inline WCPtrHashSetIter() {};
  216.  
  217.     inline WCPtrHashSetIter( const WCPtrHashSet<Type>& hash )
  218.                 : WCPtrHashTableIter( hash ) {};
  219.  
  220.     inline virtual ~WCPtrHashSetIter() {};
  221.  
  222.     inline const WCPtrHashSet<Type> *container() const {
  223.         return( (const WCPtrHashSet<Type> *)WCPtrHashTableIter::container() );
  224.     };
  225.  
  226.     inline void reset() {
  227.         WCPtrHashTableIter::reset();
  228.     };
  229.  
  230.     inline void reset( const WCPtrHashSet<Type> &hash ) {
  231.         WCPtrHashTableIter::reset( hash );
  232.     };
  233. };
  234.  
  235.  
  236.  
  237.  
  238. //
  239. // The WCValHashDictIter is the iterator for the WCValHashDict class.
  240. //
  241. // This class inherits privately to hide the current member function.
  242. //
  243.  
  244. template<class Key, class Value>
  245. class WCValHashDictIter
  246.         : private WCValHashTableIter<WCHashDictKeyVal<Key, Value > > {
  247. public:
  248.     inline WCValHashDictIter() {};
  249.  
  250.     inline WCValHashDictIter( const WCValHashDict<Key, Value>& hash )
  251.                 : WCValHashTableIter( hash ) {};
  252.  
  253.     inline virtual ~WCValHashDictIter() {};
  254.  
  255.     inline const WCValHashDict<Key, Value> *container() const {
  256.         return( (const WCValHashDict<Key, Value> *)WCValHashTableIter
  257.                                                         ::container() );
  258.     };
  259.  
  260.     inline wciter_state exceptions() const {
  261.         return( WCValHashTableIter::exceptions() );
  262.     };
  263.  
  264.     inline wciter_state exceptions( wciter_state const set_flags ) {
  265.         return( WCValHashTableIter::exceptions( set_flags ) );
  266.     };
  267.  
  268.     Key key() const;
  269.  
  270.     inline void reset() {
  271.         WCValHashTableIter::reset();
  272.     };
  273.  
  274.     inline void reset( const WCValHashDict<Key, Value> &hash ) {
  275.         WCValHashTableIter::reset( hash );
  276.     };
  277.  
  278.     Value value() const;
  279.  
  280.     inline WCbool operator++() {
  281.         return( WCValHashTableIter::operator++() );
  282.     };
  283.  
  284.     inline WCbool operator()() {
  285.         return( WCValHashTableIter::operator()() );
  286.     };
  287. };
  288.  
  289.  
  290. template <class Key, class Value>
  291. Key WCValHashDictIter<Key, Value>::key() const {
  292.     HashLink *link = base_curr_hashlink();
  293.     if( link == 0 ) {
  294.         // bucket_iter is off end or no hash to iterate over
  295.         base_throw_undef_item();
  296.         Key temp;
  297.         return( temp );
  298.     }
  299.     return( link->data.key );
  300. };
  301.  
  302.  
  303. template <class Key, class Value>
  304. Value WCValHashDictIter<Key, Value>::value() const {
  305.     HashLink *link = base_curr_hashlink();
  306.     if( link == 0 ) {
  307.         // bucket_iter is off end or no hash to iterate over
  308.         base_throw_undef_item();
  309.         Value temp;
  310.         return( temp );
  311.     }
  312.     return( link->data.value );
  313. };
  314.  
  315.  
  316.  
  317.  
  318. //
  319. // The WCPtrHashDictIter is the iterator for the WCPtrHashDict class.
  320. //
  321.  
  322. template<class Key, class Value>
  323. class WCPtrHashDictIter
  324.         : public WCValHashDictIter<void *, void *> {
  325. public:
  326.     inline WCPtrHashDictIter() {};
  327.  
  328.     inline WCPtrHashDictIter( const WCPtrHashDict<Key, Value>& hash )
  329.                 : WCValHashDictIter( hash ) {};
  330.  
  331.     inline virtual ~WCPtrHashDictIter() {};
  332.  
  333.     inline const WCPtrHashDict<Key, Value> *container() const {
  334.         return( (const WCPtrHashDict<Key, Value> *)WCValHashDictIter
  335.                                                         ::container() );
  336.     };
  337.  
  338.     inline Key * key() const {
  339.         return( (Key *)WCValHashDictIter::key() );
  340.     };
  341.  
  342.     inline void reset() {
  343.         WCValHashDictIter::reset();
  344.     };
  345.  
  346.     inline void reset( const WCPtrHashDict<Key, Value> &hash ) {
  347.         WCValHashDictIter::reset( hash );
  348.     };
  349.  
  350.     Value *value() const {
  351.         return( (Value *)WCValHashDictIter::value() );
  352.     };
  353. };
  354.  
  355. #endif
  356.