home *** CD-ROM | disk | FTP | other *** search
/ Chip 1997 October / Chip_1997-10_cd.bin / tema / sybase / powerj / h.z / WCLISTIT.H < prev    next >
C/C++ Source or Header  |  1996-11-06  |  10KB  |  392 lines
  1. //
  2. //  wclistit.h    Defines for the WATCOM Container List Iterator Class
  3. //
  4. //  Copyright by WATCOM International Corp. 1988-1996.  All rights reserved.
  5. //
  6. #ifndef _WCLISTIT_H_INCLUDED
  7. #define _WCLISTIT_H_INCLUDED
  8. #if !defined(_ENABLE_AUTODEPEND)
  9.   #pragma read_only_file;
  10. #endif
  11.  
  12. //
  13. // There are 12 list iterator classes.
  14. //
  15. // WCValSListIter, WCValDListIter, WCPtrSListIter, WCPtrDListIter,
  16. // WCIsvSListIter and WCIsvDListIter iterate only NON-CONSTANT lists.
  17. // For example, to iterate a non-constant WCValSList, use the WCValSListIter
  18. // class.
  19. //
  20. // WCValConstSListIter, WCValConstDListIter, WCPtrConstSListIter,
  21. // WCPtrConstDListIter, WCIsvConstSListIter and WCIsvConstDListIter iterate
  22. // either constant or non-consant lists.  The insert and append member
  23. // functions are private to these iterator classes.
  24. // For example, to iterate a constant WCIsvDList, use the
  25. // WCIsvConstDListIter class.
  26. //
  27.  
  28. #pragma warning 621 9       // I want the behaviour this warning points to
  29.  
  30. #ifndef __cplusplus
  31. #error wclistit.h is for use with C++
  32. #endif
  33.  
  34. #ifndef _WCDEFS_H_INCLUDED
  35.  #include <wcdefs.h>
  36. #endif
  37. #ifndef _WCLIST_H_INCLUDED
  38.  #include <wclist.h>
  39. #endif
  40. #ifndef _WCLIBASE_H_INCLUDED
  41.  #include <wclibase.h>
  42. #endif
  43.  
  44.  
  45.  
  46.  
  47. //
  48. //  This defines an iterator class for non-const single linked list of
  49. //  values.
  50. //
  51. //  The operators --() and -=() and the insert member function are made
  52. //  private to prevent their being used with a single linked list.
  53. //
  54.  
  55. template<class Type>
  56. class WCValSListIter : public WCValListIterBase<Type, WCValSList<Type>,
  57.                                                       WCNIsvSLink<Type> >  {
  58. private:
  59.     int operator--();                                                          
  60.     int operator-=( int );
  61.     WCbool insert( Type& );
  62.  
  63. public:
  64.     inline WCValSListIter() {};
  65.     inline virtual ~WCValSListIter() {};
  66.     inline WCValSListIter( WCValSList<Type> & slist )
  67.          : WCValListIterBase( &slist ) {};
  68. };
  69.  
  70.  
  71.  
  72.  
  73. //
  74. //  This defines an iterator class for the double linked list of
  75. //  values.
  76. //
  77.  
  78. template<class Type>
  79. class WCValDListIter : public WCValListIterBase<Type, WCValDList<Type>,
  80.                                                       WCNIsvDLink<Type> >  {
  81. public:
  82.     inline WCValDListIter() {};
  83.     inline virtual ~WCValDListIter() {};
  84.     inline WCValDListIter( WCValDList<Type> & slist )
  85.          : WCValListIterBase( &slist ) {};
  86. };
  87.  
  88.  
  89.  
  90.  
  91. //
  92. //  This defines an iterator class for the single linked list of
  93. //  pointers.
  94. //
  95. //  The operators --() and -=() and the insert member function are made
  96. //  private to prevent their being used with a single linked list.
  97. //
  98.  
  99. template<class Type>
  100. class WCPtrSListIter : public WCValListIterBase<Type *, WCPtrSList<Type>,
  101.                                                      WCNIsvSLink<Type *> >  {
  102. private:
  103.     int operator--();
  104.     int operator-=( int );
  105.     WCbool insert( Type * );
  106.  
  107. public:
  108.     inline WCPtrSListIter() {};
  109.     inline virtual ~WCPtrSListIter() {};
  110.     inline WCPtrSListIter( WCPtrSList<Type> & slist )
  111.          : WCValListIterBase( &slist ) {};
  112.  
  113.     inline WCbool append( Type * datum ) {
  114.         return( WCValListIterBase::append( datum ) );
  115.     }
  116. };
  117.  
  118.  
  119.  
  120.  
  121. //
  122. //  This defines an iterator class for the double linked list of
  123. //  pointers.
  124. //
  125.  
  126. template<class Type>
  127. class WCPtrDListIter : public WCValListIterBase<Type *, WCPtrDList<Type>,
  128.                                                      WCNIsvDLink<Type *> >  {
  129. public:
  130.     inline WCPtrDListIter() {};
  131.     inline virtual ~WCPtrDListIter() {};
  132.     inline WCPtrDListIter( WCPtrDList<Type> & dlist )
  133.          : WCValListIterBase( &dlist ) {};
  134.  
  135.     inline WCbool insert( Type * datum ) {
  136.         return( WCValListIterBase::insert( datum ) );
  137.     }
  138.  
  139.     inline WCbool append( Type * datum ) {
  140.         return( WCValListIterBase::append( datum ) );
  141.     }
  142. };
  143.  
  144.  
  145.  
  146.  
  147. //
  148. //  This defines an iterator class for the intrusive single linked list.
  149. //
  150. //  The operators --() and -=() and the insert member function are made
  151. //  private to prevent their being used with a single linked list.
  152. //
  153.  
  154. template<class Type>
  155. class WCIsvSListIter : public WCIsvListIterBase<Type, WCIsvSList<Type> > {
  156. private:
  157.     Type * operator--();
  158.     Type * operator-=( int );
  159.     WCbool insert( Type * );
  160.  
  161. public:
  162.     inline WCIsvSListIter() {};
  163.     inline virtual ~WCIsvSListIter() {};
  164.     inline WCIsvSListIter( WCIsvSList<Type> & slist )
  165.          : WCIsvListIterBase( &slist ) {};
  166. };
  167.  
  168.  
  169.  
  170.  
  171. //
  172. //  This defines an iterator class for the intrusive double linked list.
  173. //
  174.  
  175. template<class Type>
  176. class WCIsvDListIter : public WCIsvListIterBase<Type, WCIsvDList<Type> > {
  177. public:
  178.     inline WCIsvDListIter() {};
  179.     inline virtual ~WCIsvDListIter() {};
  180.     inline WCIsvDListIter( WCIsvDList<Type> & dlist )
  181.          : WCIsvListIterBase( &dlist ) {};
  182. };
  183.  
  184.  
  185.  
  186.  
  187. //
  188. //  This defines an iterator class for a constant single linked list of
  189. //  values.  The append member function is made private to prevent it
  190. //  being used with a constant list.
  191. //
  192.  
  193. template<class Type>
  194. class WCValConstSListIter : public WCValSListIter<Type> {
  195. private:
  196.     WCbool append( Type& );
  197.     typedef WCValSList<Type> NonConstList;
  198.  
  199. public:
  200.     inline WCValConstSListIter() {};
  201.     inline virtual ~WCValConstSListIter() {};
  202.     inline WCValConstSListIter( const WCValSList<Type> & slist )
  203.          : WCValSListIter( (NonConstList &)slist ) {};
  204.  
  205.     inline const WCValSList<Type> * container() {
  206.         return( WCValSListIter::container() );
  207.     };
  208.  
  209.     inline void reset() {
  210.         WCValSListIter::reset();
  211.     };
  212.  
  213.     inline void reset( const WCValSList<Type> & slist ) {
  214.         WCValSListIter::reset( (NonConstList &)slist );
  215.     };
  216. };
  217.  
  218.  
  219.  
  220.  
  221. //
  222. //  This defines an iterator class for a constant double linked list of
  223. //  values.  The append and insert member functions are made private to
  224. //  prevent them being used with a constant list.
  225. //
  226.  
  227. template<class Type>
  228. class WCValConstDListIter : public WCValDListIter<Type> {
  229. private:
  230.     WCbool append( Type& );
  231.     WCbool insert( Type& );
  232.     typedef WCValDList<Type> NonConstList;
  233.  
  234. public:
  235.     inline WCValConstDListIter() {};
  236.     inline virtual ~WCValConstDListIter() {};
  237.     inline WCValConstDListIter( const WCValDList<Type> & dlist )
  238.          : WCValDListIter( (NonConstList &)dlist ) {};
  239.  
  240.     inline const WCValDList<Type> * container() {
  241.         return( WCValDListIter::container() );
  242.     };
  243.  
  244.     inline void reset() {
  245.         WCValDListIter::reset();
  246.     };
  247.  
  248.     inline void reset( const WCValDList<Type> & dlist ) {
  249.         WCValDListIter::reset( (NonConstList &)dlist );
  250.     };
  251. };
  252.  
  253.  
  254.  
  255.  
  256. //
  257. //  This defines an iterator class for a constant single linked list of
  258. //  pointers.  The append member function is made private to prevent it
  259. //  being used with a constant list.
  260. //
  261.  
  262. template<class Type>
  263. class WCPtrConstSListIter : public WCPtrSListIter<Type> {
  264. private:
  265.     WCbool append( Type * );
  266.     typedef WCPtrSList<Type> NonConstList;
  267.  
  268. public:
  269.     inline WCPtrConstSListIter() {};
  270.     inline virtual ~WCPtrConstSListIter() {};
  271.     inline WCPtrConstSListIter( const WCPtrSList<Type> & slist )
  272.          : WCPtrSListIter( (NonConstList &)slist ) {};
  273.  
  274.     inline const WCPtrSList<Type> * container() {
  275.         return( WCPtrSListIter::container() );
  276.     };
  277.  
  278.     inline void reset() {
  279.         WCPtrSListIter::reset();
  280.     };
  281.  
  282.     inline void reset( const WCPtrSList<Type> & slist ) {
  283.         WCPtrSListIter::reset( (NonConstList &)slist );
  284.     };
  285. };
  286.  
  287.  
  288.  
  289.  
  290. //
  291. //  This defines an iterator class for a constant double linked list of
  292. //  pointers.  The append and insert member functions are made private to
  293. //  prevent them being used with a constant list.
  294. //
  295.  
  296. template<class Type>
  297. class WCPtrConstDListIter : public WCPtrDListIter<Type> {
  298. private:
  299.     WCbool append( Type * );
  300.     WCbool insert( Type * );
  301.     typedef WCPtrDList<Type> NonConstList;
  302.  
  303. public:
  304.     inline WCPtrConstDListIter() {};
  305.     inline virtual ~WCPtrConstDListIter() {};
  306.     inline WCPtrConstDListIter( const WCPtrDList<Type> & dlist )
  307.          : WCPtrDListIter( (NonConstList &)dlist ) {};
  308.  
  309.     inline const WCPtrDList<Type> * container() {
  310.         return( WCPtrDListIter::container() );
  311.     };
  312.  
  313.     inline void reset() {
  314.         WCPtrDListIter::reset();
  315.     };
  316.  
  317.     inline void reset( const WCPtrDList<Type> & dlist ) {
  318.         WCPtrDListIter::reset( (NonConstList &)dlist );
  319.     };
  320. };
  321.  
  322.  
  323.  
  324.  
  325. //
  326. //  This defines an iterator class for a constant intrusive single linked
  327. //  list.  The append member function is made private to prevent it
  328. //  being used with a constant list.
  329. //
  330.  
  331. template<class Type>
  332. class WCIsvConstSListIter : public WCIsvSListIter<Type> {
  333. private:
  334.     WCbool append( Type * );
  335.     typedef WCIsvSList<Type> NonConstList;
  336.  
  337. public:
  338.     inline WCIsvConstSListIter() {};
  339.     inline virtual ~WCIsvConstSListIter() {};
  340.     inline WCIsvConstSListIter( const WCIsvSList<Type> & slist )
  341.          : WCIsvSListIter( (NonConstList &)slist ) {};
  342.  
  343.     inline const WCIsvSList<Type> * container() {
  344.         return( WCIsvSListIter::container() );
  345.     };
  346.  
  347.     inline void reset() {
  348.         WCIsvSListIter::reset();
  349.     };
  350.  
  351.     inline void reset( const WCIsvSList<Type> & slist ) {
  352.         WCIsvSListIter::reset( (NonConstList &)slist );
  353.     };
  354. };
  355.  
  356.  
  357.  
  358.  
  359. //
  360. //  This defines an iterator class for a constant intrusive double linked
  361. //  pointers.  The append and insert member functions are made private to
  362. //  prevent them being used with a constant list.
  363. //
  364.  
  365. template<class Type>
  366. class WCIsvConstDListIter : public WCIsvDListIter<Type> {
  367. private:
  368.     WCbool append( Type * );
  369.     WCbool insert( Type * );
  370.     typedef WCIsvDList<Type> NonConstList;
  371.  
  372. public:
  373.     inline WCIsvConstDListIter() {};
  374.     inline virtual ~WCIsvConstDListIter() {};
  375.     inline WCIsvConstDListIter( const WCIsvDList<Type> & dlist )
  376.          : WCIsvDListIter( (NonConstList &)dlist ) {};
  377.  
  378.     inline const WCIsvDList<Type> * container() {
  379.         return( WCIsvDListIter::container() );
  380.     };
  381.  
  382.     inline void reset() {
  383.         WCIsvDListIter::reset();
  384.     };
  385.  
  386.     inline void reset( const WCIsvDList<Type> & dlist ) {
  387.         WCIsvDListIter::reset( (NonConstList &)dlist );
  388.     };
  389. };
  390.  
  391. #endif
  392.