home *** CD-ROM | disk | FTP | other *** search
/ Chip 1997 October / Chip_1997-10_cd.bin / tema / sybase / powerj / h.z / WCLIST.H < prev    next >
C/C++ Source or Header  |  1996-11-06  |  8KB  |  289 lines
  1. //
  2. //  wclist.h    Defines the WATCOM Container List Classes
  3. //
  4. //  Copyright by WATCOM International Corp. 1988-1996.  All rights reserved.
  5. //
  6. #ifndef _WCLIST_H_INCLUDED
  7. #define _WCLIST_H_INCLUDED
  8. #if !defined(_ENABLE_AUTODEPEND)
  9.   #pragma read_only_file;
  10. #endif
  11.  
  12. #pragma warning 621 9       // I want the behaviour this warning points to
  13.  
  14. #ifndef __cplusplus
  15. #error wclist.h is for use with C++
  16. #endif
  17.  
  18. #ifndef _WCDEFS_H_INCLUDED
  19.  #include <wcdefs.h>
  20. #endif
  21. #ifndef _WCEXCEPT_H_INCLUDED
  22.  #include <wcexcept.h>
  23. #endif
  24. #ifndef _WCLCOM_H_INCLUDED
  25.  #include <wclcom.h>
  26. #endif
  27. #ifndef _WCLBASE_H_INCLUDED
  28.  #include <wclbase.h>
  29. #endif
  30.  
  31.  
  32. //
  33. //  This defines a single linked list of values of type <Type>
  34. //
  35. //  The base class is invoked to process the copy and assignment
  36. //  constructors.  The copies are shallow, in that only the values
  37. //  contained in the list are copied.  If the contained values
  38. //  themselves have defined copy constructors, they can effect a
  39. //  deeper copy.
  40. //
  41.  
  42. template<class Type>
  43. class WCValSList : public WCValListBase< Type,
  44.                    WCIsvSListBase<WCNIsvSLink<Type> >, WCNIsvSLink<Type> > {
  45. private:
  46.     // This virtual function defines equivalence for the base classes.
  47.     virtual int base_equivalent( const Type &elem1, const Type &elem2 ) const {
  48.         return( elem1 == elem2 );
  49.     };
  50.  
  51. public:
  52.     inline WCValSList( void * (*user_alloc)( size_t )
  53.                 , void (*user_dealloc)( void *, size_t )
  54.                 ) : WCValListBase( user_alloc, user_dealloc ) {};
  55.  
  56.     inline WCValSList() : WCValListBase( 0, 0 ) {};
  57.  
  58.     inline ~WCValSList() {};
  59.  
  60.     inline WCValSList( const WCValSList & olist ) {
  61.         base_construct( &olist );
  62.     };
  63.  
  64.     inline WCValSList & operator=( const WCValSList & olist ) {
  65.         base_assign( &olist );
  66.         return( *this );
  67.     };
  68. };
  69.  
  70.  
  71.  
  72.  
  73. //
  74. //  This defines a double linked list of values of type <Type>
  75. //
  76. //  The base class is invoked to process the copy and assignment
  77. //  constructors.  The copies are shallow, in that only the values
  78. //  contained in the list are copied.  If the contained values
  79. //  themselves have defined copy constructors, they can effect a
  80. //  deeper copy.
  81. //
  82.  
  83. template<class Type>
  84. class WCValDList : public WCValListBase<Type,
  85.                    WCIsvDListBase<WCNIsvDLink<Type> >, WCNIsvDLink<Type> > {
  86. private:
  87.     // This virtual function defines equivalence for the base classes.
  88.     virtual int base_equivalent( const Type &elem1, const Type &elem2 ) const {
  89.         return( elem1 == elem2 );
  90.     };
  91.  
  92. public:
  93.     inline WCValDList( void * (*user_alloc)( size_t ) 
  94.                 , void (*user_dealloc)( void *, size_t )
  95.                 ) : WCValListBase( user_alloc, user_dealloc ) {};
  96.  
  97.     inline WCValDList() : WCValListBase( 0, 0 ) {};
  98.  
  99.     inline ~WCValDList() {};
  100.  
  101.     inline WCValDList( const WCValDList & olist ) {
  102.         base_construct( &olist );
  103.     };
  104.  
  105.     inline WCValDList & operator=( const WCValDList & olist ) {
  106.         base_assign( &olist );
  107.         return( *this );
  108.     };
  109. };
  110.  
  111.  
  112.  
  113.  
  114. //
  115. //  This defines a single linked list of pointers of type <Type>
  116. //
  117. //  The base class is invoked to process the copy and assignment
  118. //  constructors.  The copies are shallow, in that only the pointers
  119. //  contained in the list are copied.
  120. //  deeper copy.
  121. //
  122.  
  123. template<class Type>
  124. class WCPtrSList : public WCPtrListBase<Type, WCValSList<Type *> > {
  125. private:
  126.     // This virtual function defines equivalence for the base classes.
  127.     virtual int base_equivalent( Type * const &elem1
  128.                                , Type * const &elem2 ) const {
  129.         return( *(const Type *)elem1 == *(const Type *)elem2 );
  130.     };
  131.  
  132. public:
  133.     inline WCPtrSList( void * (*user_alloc)( size_t )
  134.                 , void (*user_dealloc)( void *, size_t )
  135.                 ) : WCPtrListBase( user_alloc, user_dealloc ) {};
  136.  
  137.     inline WCPtrSList() : WCPtrListBase( 0, 0 ) {};
  138.  
  139.     inline ~WCPtrSList() {};
  140.  
  141.     inline WCPtrSList( const WCPtrSList & olist ) {
  142.         base_construct( &olist );
  143.     };
  144.  
  145.     inline int index( const Type * ptr ) const {
  146.         return( WCPtrListBase::index( (Type * const)ptr ) );
  147.     };
  148.  
  149.     inline WCPtrSList & operator=( const WCPtrSList & olist ) {
  150.         base_assign( &olist );
  151.         return( *this );
  152.     };
  153. };
  154.  
  155.  
  156.  
  157.  
  158. //
  159. //  This defines a double linked list of pointers of type <Type>
  160. //
  161. //  The base class is invoked to process the copy and assignment
  162. //  constructors.  The copies are shallow, in that only the pointers
  163. //  contained in the list are copied.
  164. //
  165.  
  166. template<class Type>
  167. class WCPtrDList : public WCPtrListBase<Type, WCValDList<Type *> > {
  168. private:
  169.     // This virtual function defines equivalence for the base classes.
  170.     virtual int base_equivalent( Type * const &elem1
  171.                                , Type * const &elem2 ) const {
  172.         return( *(const Type *)elem1 == *(const Type *)elem2 );
  173.     };
  174.  
  175. public:
  176.     inline WCPtrDList( void * (*user_alloc)( size_t )
  177.                 , void (*user_dealloc)( void *, size_t )
  178.                 ) : WCPtrListBase( user_alloc, user_dealloc ) {};
  179.  
  180.     inline WCPtrDList() : WCPtrListBase( 0, 0 ) {};
  181.  
  182.     inline ~WCPtrDList() {};
  183.  
  184.     inline WCPtrDList( const WCPtrDList & olist ) {
  185.         base_construct( &olist );
  186.     };
  187.  
  188.     inline int index( const Type * ptr ) const {
  189.         return( WCPtrListBase::index( (Type * const)ptr ) );
  190.     };
  191.  
  192.     inline WCPtrDList & operator=( const WCPtrDList & olist ) {
  193.         base_assign( &olist );
  194.         return( *this );
  195.     };
  196. };
  197.  
  198.  
  199.  
  200.  
  201. //
  202. //  This defines a single linked list of values of type <Type>,
  203. //  stored intrusively.
  204. //
  205. //  The copy and assignment constructors are made private so
  206. //  that a second copy of the list is not made (intrusive lists
  207. //  require modification of the base links, making second copies
  208. //  a problem).
  209. //
  210.  
  211. template<class Type>
  212. class WCIsvSList : public WCPtrListBase<Type, WCIsvSListBase<Type> > {
  213. private:
  214.     WCIsvSList( const WCIsvSList & );
  215.     WCIsvSList & operator=( const WCIsvSList & );
  216.  
  217. protected:
  218.     //
  219.     // This constuctor is necessary for inherited classes such as WCStack and
  220.     // WCQueue to be able to support user allocators and deallocators.
  221.     // It is not intended for users of the class.
  222.     //
  223.     inline WCIsvSList( void * (*)( size_t ), void (*)( void *, size_t ) ) {};
  224.  
  225. public:    
  226.     inline WCIsvSList() {};
  227.     inline ~WCIsvSList() {};
  228.  
  229.     inline void forAll( void (*fn)( Type *, void * ), void *data ) {
  230.         WCPtrListBase::forAll( fn, data );
  231.     };
  232.  
  233.     inline int index( int (*test_fn)( const Type *, void * )
  234.                     , void *data ) const {
  235.         return( WCPtrListBase::index( test_fn, data ) );
  236.     };
  237.  
  238.     inline int index( const Type *elem ) const {
  239.         return( WCPtrListBase::index( elem ) );
  240.     };
  241. };
  242.  
  243.  
  244.  
  245.  
  246. //
  247. //  This defines a double linked list of values of type <Type>,
  248. //  stored intrusively.
  249. //
  250. //  The copy and assignment constructors are made private so
  251. //  that a second copy of the list is not made (intrusive lists
  252. //  require modification of the base links, making second copies
  253. //  a problem).
  254. //
  255.  
  256. template<class Type>
  257. class WCIsvDList : public WCPtrListBase<Type, WCIsvDListBase<Type> > {
  258. private:
  259.     WCIsvDList( const WCIsvDList & );
  260.     WCIsvDList & operator=( const WCIsvDList & );
  261.  
  262. protected:
  263.     //
  264.     // This constuctor is necessary for inherited classes such as WCStack and
  265.     // WCQueue to be able to support user allocators and deallocators.
  266.     // It is not intended for users of the class.
  267.     //
  268.     inline WCIsvDList( void * (*)( size_t ), void (*)( void *, size_t ) ) {};
  269.  
  270. public:    
  271.     inline WCIsvDList() {};
  272.     inline ~WCIsvDList() {};
  273.  
  274.     inline void forAll( void (*fn)( Type *, void * ), void *data ) {
  275.         WCPtrListBase::forAll( fn, data );
  276.     };
  277.  
  278.     inline int index( int (*test_fn)( const Type *, void * )
  279.                     , void *data ) const {
  280.         return( WCPtrListBase::index( test_fn, data ) );
  281.     };
  282.  
  283.     inline int index( const Type *elem ) const {
  284.         return( WCPtrListBase::index( elem ) );
  285.     };
  286. };
  287.  
  288. #endif
  289.