home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c082_144 / 2.ddi / CLASSINC.ZIP / BAGS.H < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-10  |  14.0 KB  |  527 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  BAGS.H                                                                */
  4. /*                                                                        */
  5. /*  Copyright Borland International 1991, 1992                            */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( __BAGS_H )
  11. #define __BAGS_H
  12.  
  13. #if !defined( __CHECKS_H )
  14. #include <Checks.h>
  15. #endif  // __CHECKS_H
  16.  
  17. #if !defined( __SHDDEL_H )
  18. #include <ShdDel.h>
  19. #endif  // __SHDDEL_H
  20.  
  21. #if !defined( __VECTIMP_H )
  22. #include <VectImp.h>
  23. #endif  // __VECTIMP_H
  24.  
  25. #if !defined( __RESOURCE_H )
  26. #include <Resource.h>
  27. #endif  // __RESOURCE_H
  28.  
  29. #if !defined( __COLLECT_H )
  30. #include <Collect.h>
  31. #endif  // __COLLECT_H
  32.  
  33. #pragma option -Vo-
  34. #if defined( __BCOPT__ ) && !defined( _ALLOW_po )
  35. #pragma option -po-
  36. #endif
  37.  
  38. /*------------------------------------------------------------------------*/
  39. /*                                                                        */
  40. /*  template <class Vect, class T> class BI_BagAsVectorImp                */
  41. /*                                                                        */
  42. /*  Implements a bag, using a vector as the underlying implementation.    */
  43. /*  The type Vect specifies the form of the vector, either a              */
  44. /*  BI_CVectorImp<T0> or a BI_ICVectorImp<T0>.  The type T specifies the  */
  45. /*  type of the objects to be put in the bag.  When using                 */
  46. /*  BI_VectorImp<T0>, T should be the same as T0. When using              */
  47. /*  BI_IVectorImp<T0>, T should be of type pointer to T0.  See            */
  48. /*  BI_BagAsVector and BI_IBagAsVector for examples.                      */
  49. /*                                                                        */
  50. /*------------------------------------------------------------------------*/
  51.  
  52. template <class Vect, class T> class _CLASSTYPE BI_BagAsVectorImp
  53. {
  54.  
  55. public:
  56.  
  57.     BI_BagAsVectorImp( unsigned sz = DEFAULT_BAG_SIZE ) :
  58.         data(sz,1)
  59.         {
  60.         }
  61.  
  62.     void add( T t )
  63.         {
  64.         data.add( t );
  65.         }
  66.  
  67.     void detach( T t, TShouldDelete::DeleteType = TShouldDelete::NoDelete )
  68.         {
  69.         data.detach( t );
  70.         }
  71.  
  72.     void flush( TShouldDelete::DeleteType = TShouldDelete::DefDelete )
  73.         {
  74.         data.flush();
  75.         }
  76.  
  77.     int hasMember( T t ) const
  78.         {
  79.         return data.find(t) != UINT_MAX;
  80.         }
  81.  
  82.     T findMember( T t ) const
  83.         {
  84.         PRECONDITION( hasMember(t) );
  85.         return data[data.find(t)];
  86.         }
  87.  
  88.     int isEmpty() const
  89.         {
  90.         return data.isEmpty();
  91.         }
  92.  
  93.     int isFull() const
  94.         { return 0;
  95.         }
  96.  
  97.     int getItemsInContainer() const
  98.         {
  99.         return data.top();
  100.         }
  101.  
  102. protected:
  103.  
  104.     Vect data;
  105.  
  106. };
  107.  
  108. /*------------------------------------------------------------------------*/
  109. /*                                                                        */
  110. /*  template <class T> class BI_BagAsVector                               */
  111. /*                                                                        */
  112. /*  Implements a bag of objects of type T, using a vector as              */
  113. /*  the underlying implementation.                                        */
  114. /*                                                                        */
  115. /*------------------------------------------------------------------------*/
  116.  
  117. template <class T> class _CLASSTYPE BI_BagAsVector :
  118.     public BI_BagAsVectorImp<BI_CVectorImp<T>,T>
  119. {
  120.  
  121. public:
  122.  
  123.     friend class _CLASSTYPE BI_BagAsVectorIterator<T>;
  124.  
  125.     BI_BagAsVector( unsigned sz = DEFAULT_BAG_SIZE ) :
  126.         BI_BagAsVectorImp<BI_CVectorImp<T>,T>( sz )
  127.         {
  128.         }
  129.  
  130.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  131.         {
  132.         data.forEach( f, args, 0, data.top() );
  133.         }
  134.  
  135.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  136.                        void _FAR *args
  137.                      ) const
  138.         {
  139.         return data.firstThat( f, args, 0, data.top() );
  140.         }
  141.  
  142.     T _FAR *lastThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  143.                       void _FAR *args
  144.                     ) const
  145.         {
  146.         return data.lastThat( f, args, 0, data.top() );
  147.         }
  148.  
  149. protected:
  150.  
  151.     virtual T _FAR *find( T ) const;
  152.  
  153. };
  154.  
  155. template <class T> T _FAR *BI_BagAsVector<T>::find( T t ) const
  156. {
  157.     if( isEmpty() )
  158.         return 0;
  159.     for( int index = 0; index < data.top(); index++ )
  160.         if( data[index] == t )
  161.             return &(data[index]);
  162.     return 0;
  163. }
  164.  
  165. template <class T> class _CLASSTYPE BI_BagAsVectorIterator :
  166.     public BI_VectorIteratorImp<T>
  167. {
  168.  
  169. public:
  170.  
  171.     BI_BagAsVectorIterator( const BI_BagAsVector<T> _FAR & b ) :
  172.         BI_VectorIteratorImp<T>(b.data,0,b.data.top()) {}
  173.  
  174. };
  175.  
  176. /*------------------------------------------------------------------------*/
  177. /*                                                                        */
  178. /*  template <class T> class BI_IBagAsVector                              */
  179. /*                                                                        */
  180. /*  Implements a bag of pointers to objects of type T,                    */
  181. /*  using a vector as the underlying implementation.                      */
  182. /*                                                                        */
  183. /*------------------------------------------------------------------------*/
  184.  
  185. template <class T> class _CLASSTYPE BI_IBagAsVector :
  186.     public BI_BagAsVectorImp<BI_ICVectorImp<T>,T _FAR *>,
  187.     public virtual TShouldDelete
  188. {
  189.  
  190. public:
  191.  
  192.     friend class _CLASSTYPE BI_IBagAsVectorIterator<T>;
  193.  
  194.     BI_IBagAsVector( unsigned sz = DEFAULT_BAG_SIZE ) :
  195.         BI_BagAsVectorImp<BI_ICVectorImp<T>,T _FAR *>(sz)
  196.         {
  197.         }
  198.  
  199.     ~BI_IBagAsVector()
  200.         {
  201.         flush();
  202.         }
  203.  
  204.     void add( T _FAR *t )
  205.         {
  206.         BI_BagAsVectorImp<BI_ICVectorImp<T>,T _FAR *>::add(t);
  207.         }
  208.  
  209.     void detach( T _FAR *t, DeleteType dt = NoDelete )
  210.         {
  211.         data.detach( t, delObj(dt) );
  212.         }
  213.  
  214.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  215.         {
  216.         data.flush( delObj(dt), data.top(), 0 );
  217.         }
  218.  
  219.     T _FAR *findMember( T _FAR *t ) const
  220.         {
  221.         unsigned loc = data.find(t);
  222.         return (T _FAR *)( loc == UINT_MAX ? 0 : data[loc] );
  223.         }
  224.  
  225.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  226.         {
  227.         data.forEach( f, args, 0, data.top() );
  228.         }
  229.  
  230.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  231.                        void _FAR *args
  232.                      ) const
  233.         {
  234.         return data.firstThat( f, args, 0, data.top() );
  235.         }
  236.  
  237.     T _FAR *lastThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  238.                       void _FAR *args
  239.                     ) const
  240.         {
  241.         return data.lastThat( f, args, 0, data.top() );
  242.         }
  243.  
  244. };
  245.  
  246. template <class T> class _CLASSTYPE BI_IBagAsVectorIterator :
  247.     public BI_IVectorIteratorImp<T>
  248. {
  249.  
  250. public:
  251.  
  252.     BI_IBagAsVectorIterator( const BI_IBagAsVector<T> _FAR & s ) :
  253.         BI_IVectorIteratorImp<T>(s.data,0,s.data.top()) {}
  254.  
  255. };
  256.  
  257. /*------------------------------------------------------------------------*/
  258. /*                                                                        */
  259. /*  class BI_OBagAsVector                                                 */
  260. /*                                                                        */
  261. /*  Implements a bag of pointers to Object,                               */
  262. /*  using a vector as the underlying implementation.                      */
  263. /*                                                                        */
  264. /*------------------------------------------------------------------------*/
  265.  
  266. class _CLASSTYPE BI_OBagAsVector
  267. {
  268.  
  269. public:
  270.  
  271.     friend class _CLASSTYPE BI_OBagAsVectorIterator;
  272.  
  273.     BI_OBagAsVector( unsigned sz = DEFAULT_BAG_SIZE ) :
  274.         obag( sz )
  275.         {
  276.         }
  277.  
  278.     void add( Object _FAR *o )
  279.         {
  280.         obag.add(o);
  281.         }
  282.  
  283.     void detach( Object _FAR *o,
  284.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  285.                )
  286.         {
  287.         obag.detach( o, dt );
  288.         }
  289.  
  290.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  291.         {
  292.         obag.flush( dt );
  293.         }
  294.  
  295.     int hasMember( Object _FAR *o ) const
  296.         {
  297.         return obag.hasMember(o);
  298.         }
  299.  
  300.     Object _FAR *findMember( Object _FAR *o ) const
  301.         {
  302.         Object _FAR *obj = obag.findMember( o );
  303.         return obj != 0 ? obj : 0;
  304.         }
  305.  
  306.     int isEmpty() const
  307.         {
  308.         return obag.isEmpty();
  309.         }
  310.  
  311.     int isFull() const
  312.         {
  313.         return obag.isFull();
  314.         }
  315.  
  316.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  317.         {
  318.         obag.forEach( f, args );
  319.         }
  320.  
  321.     Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  322.                             void _FAR *args
  323.                           ) const
  324.         {
  325.         return obag.firstThat( f, args );
  326.         }
  327.  
  328.     Object _FAR *lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  329.                            void _FAR *args
  330.                          ) const
  331.         {
  332.         return obag.lastThat( f, args );
  333.         }
  334.  
  335.     int getItemsInContainer() const
  336.         {
  337.         return obag.getItemsInContainer();
  338.         }
  339.  
  340.     int ownsElements()
  341.         {
  342.         return obag.ownsElements();
  343.         }
  344.  
  345.     void ownsElements( int del )
  346.         {
  347.         obag.ownsElements( del );
  348.         }
  349.  
  350. protected:
  351.  
  352.     BI_IBagAsVector<Object> obag;
  353.  
  354. };
  355.  
  356. class _CLASSTYPE BI_OBagAsVectorIterator :
  357.     public BI_IBagAsVectorIterator<Object>
  358. {
  359.  
  360. public:
  361.  
  362.     BI_OBagAsVectorIterator( const BI_OBagAsVector _FAR & b ) :
  363.         BI_IBagAsVectorIterator<Object>(b.obag)
  364.         {
  365.         }
  366.  
  367. };
  368.  
  369. /*------------------------------------------------------------------------*/
  370. /*                                                                        */
  371. /*  class BI_TCBagAsVector                                                */
  372. /*                                                                        */
  373. /*  Implements an Object bag, with the full semantics of                  */
  374. /*  the BC 2.0 style Bag, using a vector as the underlying                */
  375. /*  implementation.                                                       */
  376. /*                                                                        */
  377. /*------------------------------------------------------------------------*/
  378.  
  379. class _CLASSTYPE BI_TCBagAsVector : public Collection
  380. {
  381.  
  382. public:
  383.  
  384.     friend class _CLASSTYPE BI_TCBagAsVectorIterator;
  385.  
  386.     BI_TCBagAsVector( int sz = DEFAULT_BAG_SIZE ) :
  387.         bag(sz)
  388.         {
  389.         }
  390.  
  391.     virtual void add( Object _FAR & o )
  392.         {
  393.         bag.add( &o );
  394.         }
  395.  
  396.     virtual void detach( Object _FAR & o,
  397.                     TShouldDelete::DeleteType dt = TShouldDelete::NoDelete )
  398.         {
  399.         bag.detach( &o, dt );
  400.         }
  401.  
  402.     virtual void flush(TShouldDelete::DeleteType dt=TShouldDelete::DefDelete )
  403.         {
  404.         bag.flush( dt );
  405.         }
  406.  
  407.     virtual int isEmpty() const
  408.         {
  409.         return bag.isEmpty();
  410.         }
  411.  
  412.     virtual countType getItemsInContainer() const
  413.         {
  414.         return bag.getItemsInContainer();
  415.         }
  416.  
  417.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  418.         {
  419.         bag.forEach( f, args );
  420.         }
  421.  
  422.     Object _FAR & firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  423.                              void _FAR *args
  424.                            ) const
  425.         {
  426.         return ptrToRef(bag.firstThat( f, args ));
  427.         }
  428.  
  429.     Object _FAR & lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  430.                             void _FAR *args
  431.                           ) const
  432.         {
  433.         return ptrToRef(bag.lastThat( f, args ));
  434.         }
  435.  
  436.     virtual int hasMember( Object _FAR & o ) const
  437.         {
  438.         return bag.hasMember( &o );
  439.         }
  440.  
  441.     virtual Object _FAR & findMember( Object _FAR & o ) const
  442.         {
  443.         return ptrToRef(bag.findMember(&o));
  444.         }
  445.  
  446.     virtual ContainerIterator _FAR & initIterator() const;
  447.  
  448.     virtual classType isA() const
  449.         {
  450.         return bagClass;
  451.         }
  452.  
  453.     virtual char _FAR *nameOf() const
  454.         {
  455.         return "BI_TCBagAsVector";
  456.         }
  457.  
  458.     int ownsElements()
  459.         {
  460.         return bag.ownsElements();
  461.         }
  462.  
  463.     void ownsElements( int del )
  464.         {
  465.         bag.ownsElements( del );
  466.         }
  467.  
  468. protected:
  469.  
  470.     BI_OBagAsVector bag;
  471.  
  472. };
  473.  
  474. class _CLASSTYPE BI_TCBagAsVectorIterator : public ContainerIterator
  475. {
  476.  
  477. public:
  478.  
  479.     BI_TCBagAsVectorIterator( const BI_TCBagAsVector _FAR &b ) :
  480.         iter(b.bag)
  481.         {
  482.         }
  483.  
  484.     virtual operator int()
  485.         {
  486.         return int(iter);
  487.         }
  488.  
  489.     virtual Object _FAR & current()
  490.         {
  491.         return Object::ptrToRef(iter.current());
  492.         }
  493.  
  494.     virtual Object _FAR & operator ++ ( int )
  495.         {
  496.         return Object::ptrToRef(iter++);
  497.         }
  498.  
  499.     virtual Object _FAR & operator ++ ()
  500.         {
  501.         return Object::ptrToRef(++iter);
  502.         }
  503.  
  504.     virtual void restart()
  505.         {
  506.         iter.restart();
  507.         }
  508.  
  509. private:
  510.  
  511.     BI_OBagAsVectorIterator iter;
  512.  
  513. };
  514.  
  515. inline ContainerIterator _FAR & BI_TCBagAsVector::initIterator() const
  516. {
  517.     return *new BI_TCBagAsVectorIterator( *this );
  518. }
  519.  
  520. #if defined( __BCOPT__ ) && !defined( _ALLOW_po )
  521. #pragma option -po.
  522. #endif
  523. #pragma option -Vo.
  524.  
  525. #endif  // __BAGS_H
  526.  
  527.