home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c082_144 / 2.ddi / CLASSINC.ZIP / ARRAYS.H < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-10  |  37.8 KB  |  1,478 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  ARRAYS.H                                                              */
  4. /*                                                                        */
  5. /*  Copyright Borland International 1991, 1992                            */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( __ARRAYS_H )
  11. #define __ARRAYS_H
  12.  
  13. #define TEMPLATES
  14.  
  15. #if !defined( __DEFS_H )
  16. #include <_defs.h>
  17. #endif  // __DEFS_H
  18.  
  19. #if !defined( __RESOURCE_H )
  20. #include <Resource.h>
  21. #endif  // __RESOURCE_H
  22.  
  23. #if !defined( __COLLECT_H )
  24. #include <Collect.h>
  25. #endif  // __COLLECT_H
  26.  
  27. #if !defined( __MEM_H )
  28. #include <Mem.h>
  29. #endif  // __MEM_H
  30.  
  31. #if !defined( __VECTIMP_H )
  32. #include <VectImp.h>
  33. #endif  // __VECTIMP_H
  34.  
  35. #if !defined( __SORTABLE_H )
  36. #include <Sortable.h>
  37. #endif  // __SORTABLE_H
  38.  
  39. #if !defined( __ABSTARRY_H )
  40. #include <AbstArry.h>
  41. #endif  // __ABSTARRY_H
  42.  
  43. #pragma option -Vo-
  44. #if defined( __BCOPT__ ) && !defined( _ALLOW_po )
  45. #pragma option -po-
  46. #endif
  47.  
  48. #pragma warn -ncf
  49.  
  50. /*------------------------------------------------------------------------*/
  51. /*                                                                        */
  52. /*  template <class Vect, class T> class BI_ArrayAsVectorImp              */
  53. /*                                                                        */
  54. /*  Implements the fundamental array operations, using a vector           */
  55. /*  as the underlying implementation.  The type Vect specifies the        */
  56. /*  form of the vector, either a BI_CVectorImp<T0> or a                   */
  57. /*  BI_IVectorImp<T0>.  The type T specifies the type of the              */
  58. /*  objects to be put in the array.  When using BI_CVectorImp<T0>,        */
  59. /*  T should be the same as T0. When using BI_ICVectorImp<T0>, T          */
  60. /*  should be of type pointer to T0.  See BI_ArrayAsVector and            */
  61. /*  BI_IArrayAsVector for examples.                                       */
  62. /*                                                                        */
  63. /*------------------------------------------------------------------------*/
  64.  
  65. template <class Vect, class T>
  66. class _CLASSTYPE BI_ArrayAsVectorImp
  67. {
  68.  
  69. public:
  70.  
  71.     BI_ArrayAsVectorImp( int upper, int lower, int delta ) :
  72.         data( upper-lower+1,delta),
  73.         lowerbound(lower)
  74.         {
  75.         }
  76.  
  77.     int lowerBound() const
  78.         {
  79.         return lowerbound;
  80.         }
  81.  
  82.     int upperBound() const
  83.         {
  84.         return boundBase(data.limit())-1;
  85.         }
  86.  
  87.     sizeType arraySize() const
  88.         {
  89.         return data.limit();
  90.         }
  91.  
  92.     void add( T t )
  93.         {
  94.         data.add( t );
  95.         }
  96.  
  97.     void addAt( T t, int loc )
  98.         {
  99.         data.addAt( t, zeroBase(loc) );
  100.         }
  101.  
  102.     void detach( T t, TShouldDelete::DeleteType dt = TShouldDelete::NoDelete )
  103.         {
  104.         data.detach( t, dt );
  105.         }
  106.  
  107.     void detach( int loc,
  108.                  TShouldDelete::DeleteType dt =TShouldDelete::NoDelete
  109.                )
  110.         {
  111.         data.detach( zeroBase(loc), dt );
  112.         }
  113.  
  114.     void destroy( int i )
  115.         {
  116.         detach( i, TShouldDelete::Delete );
  117.         }
  118.  
  119.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  120.         {
  121.         data.flush( dt );
  122.         }
  123.  
  124.     int isFull() const
  125.         {
  126.         return data.getDelta() == 0 && data.count() >= data.limit();
  127.         }
  128.  
  129.     int hasMember( T t ) const
  130.         {
  131.         return data.find(t) != UINT_MAX;
  132.         }
  133.  
  134.     int isEmpty() const
  135.         {
  136.         return data.count() == 0;
  137.         }
  138.  
  139.     countType getItemsInContainer() const
  140.         {
  141.         return data.count();
  142.         }
  143.  
  144. protected:
  145.  
  146.     T itemAt( int i ) const
  147.         {
  148.         return data[ zeroBase(i) ];
  149.         }
  150.  
  151.     int find( const T t ) const
  152.         {
  153.         return boundBase(data.find( t ));
  154.         }
  155.  
  156.     void reallocate( sizeType sz, sizeType offset = 0 )
  157.         {
  158.         data.resize( sz, offset );
  159.         }
  160.  
  161.  
  162.     void setData( int loc, T t )
  163.         {
  164.         PRECONDITION( loc >= lowerbound && loc <= upperBound() );
  165.         data[ zeroBase(loc) ] = t;
  166.         }
  167.  
  168.     void insertEntry( int loc )
  169.         {
  170.         PRECONDITION( loc >= lowerbound && loc <= upperBound() );
  171.         T t;
  172.         data.addAt( t, zeroBase(loc) );
  173.         }
  174.  
  175.     void removeEntry( int loc )
  176.         {
  177.         squeezeEntry( zeroBase(loc) );
  178.         }
  179.  
  180.     void squeezeEntry( unsigned loc )
  181.         {
  182.         PRECONDITION( loc < data.count() );
  183.         data.detach( loc );
  184.         }
  185.  
  186.     unsigned zeroBase( int loc ) const
  187.         {
  188.         return loc - lowerbound;
  189.         }
  190.  
  191.     int boundBase( unsigned loc ) const
  192.         {
  193.         return loc == UINT_MAX ? INT_MAX : loc + lowerbound;
  194.         }
  195.  
  196.     void grow( int loc )
  197.         {
  198.         if( loc < lowerBound() )
  199.             reallocate( arraySize() + (loc - lowerbound) );
  200.         else if( loc >= boundBase(data.limit()) )
  201.             reallocate( zeroBase(loc) );
  202.         }
  203.  
  204.     int lowerbound;
  205.  
  206.     Vect data;
  207.  
  208. };
  209.  
  210. /*------------------------------------------------------------------------*/
  211. /*                                                                        */
  212. /*  template <class T> class BI_ArrayAsVector                             */
  213. /*                                                                        */
  214. /*  Implements an array of objects of type T, using a vector as           */
  215. /*  the underlying implementation.                                        */
  216. /*                                                                        */
  217. /*------------------------------------------------------------------------*/
  218.  
  219. template <class T> class _CLASSTYPE BI_ArrayAsVector :
  220.     public BI_ArrayAsVectorImp<BI_CVectorImp<T>,T>
  221. {
  222.  
  223. public:
  224.  
  225.     friend class _CLASSTYPE BI_ArrayAsVectorIterator<T>;
  226.  
  227.     BI_ArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  228.         BI_ArrayAsVectorImp<BI_CVectorImp<T>,T>( upper, lower, delta )
  229.         {
  230.         }
  231.  
  232.     T& operator []( int loc )
  233.         {
  234.         grow( loc+1 );
  235.         return data[zeroBase(loc)];
  236.         }
  237.  
  238.     T& operator []( int loc ) const
  239.         {
  240.         PRECONDITION( loc >= lowerbound && loc < data.count() );
  241.         return data[zeroBase(loc)];
  242.         }
  243.  
  244.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  245.         {
  246.         if( !isEmpty() )
  247.             data.forEach( f, args );
  248.         }
  249.  
  250.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  251.                        void _FAR *args
  252.                      ) const
  253.         {
  254.         if( isEmpty() )
  255.             return 0;
  256.         return data.firstThat( f, args );
  257.         }
  258.  
  259.     T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
  260.                       void _FAR *args
  261.                     ) const
  262.         {
  263.         if( isEmpty() )
  264.             return 0;
  265.         return data.lastThat( f, args );
  266.         }
  267.  
  268. };
  269.  
  270. template <class T> class _CLASSTYPE BI_ArrayAsVectorIterator :
  271.     public BI_VectorIteratorImp<T>
  272. {
  273.  
  274. public:
  275.  
  276.     BI_ArrayAsVectorIterator( const BI_ArrayAsVector<T> _FAR & a ) :
  277.         BI_VectorIteratorImp<T>(a.data) {}
  278.  
  279. };
  280.  
  281. /*------------------------------------------------------------------------*/
  282. /*                                                                        */
  283. /*  template <class T> class BI_IArrayAsVector                            */
  284. /*                                                                        */
  285. /*  Implements an indirect array of objects of type T, using a vector as  */
  286. /*  the underlying implementation.                                        */
  287. /*                                                                        */
  288. /*------------------------------------------------------------------------*/
  289.  
  290. template <class T> class _CLASSTYPE BI_IArrayAsVector :
  291.     public BI_ArrayAsVectorImp<BI_ICVectorImp<T>,T _FAR *>,
  292.     public virtual TShouldDelete
  293. {
  294.  
  295. public:
  296.  
  297.     friend class _CLASSTYPE BI_IArrayAsVectorIterator<T>;
  298.  
  299.     BI_IArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  300.         BI_ArrayAsVectorImp<BI_ICVectorImp<T>,T _FAR *>( upper, lower, delta )
  301.         {
  302.         }
  303.  
  304.     ~BI_IArrayAsVector()
  305.         {
  306.         flush();
  307.         }
  308.  
  309.     T _FAR * _FAR & operator []( int loc )
  310.         {
  311.         grow( loc+1 );
  312.         return data[zeroBase(loc)];
  313.         }
  314.  
  315.     T _FAR * _FAR & operator []( int loc ) const
  316.         {
  317.         PRECONDITION( loc >= lowerbound && zeroBase(loc) < data.limit() );
  318.         return data[zeroBase(loc)];
  319.         }
  320.  
  321.     void add( T _FAR *t )
  322.         {
  323.         BI_ArrayAsVectorImp<BI_ICVectorImp<T>,T _FAR *>::add(t);
  324.         }
  325.  
  326.     void addAt( T _FAR *t, int loc )
  327.         {
  328.         BI_ArrayAsVectorImp<BI_ICVectorImp<T>,T _FAR *>::addAt(t,loc);
  329.         }
  330.  
  331.     void detach( int loc, DeleteType dt = NoDelete )
  332.         {
  333.         data.detach( zeroBase(loc), delObj(dt) );
  334.         }
  335.  
  336.     void detach( T _FAR *t, DeleteType dt = NoDelete )
  337.         {
  338.         unsigned loc = data.find( t );
  339.         if( loc == UINT_MAX )
  340.             return;
  341.         data.detach( loc, delObj(dt) );
  342.         }
  343.  
  344.     void flush( DeleteType dt = DefDelete )
  345.         {
  346.         data.flush( delObj(dt), data.limit(), 0 );
  347.         }
  348.  
  349.     int find( const T *t ) const
  350.         {
  351.         return boundBase(data.find( (T *)t ));
  352.         }
  353.  
  354.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  355.         {
  356.         if( !isEmpty() )
  357.             data.forEach( f, args );
  358.         }
  359.  
  360.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  361.                        void _FAR *args
  362.                      ) const
  363.         {
  364.         if( isEmpty() )
  365.             return 0;
  366.         return data.firstThat( f, args );
  367.         }
  368.  
  369.     T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
  370.                       void _FAR *args
  371.                     ) const
  372.         {
  373.         if( isEmpty() )
  374.             return 0;
  375.         return data.lastThat( f, args );
  376.         }
  377.  
  378. };
  379.  
  380. template <class T> class _CLASSTYPE BI_IArrayAsVectorIterator :
  381.     public BI_IVectorIteratorImp<T>
  382. {
  383.  
  384. public:
  385.  
  386.     BI_IArrayAsVectorIterator( const BI_IArrayAsVector<T> _FAR &a ) :
  387.         BI_IVectorIteratorImp<T>(a.data) {}
  388.  
  389. };
  390.  
  391. /*------------------------------------------------------------------------*/
  392. /*                                                                        */
  393. /*  class BI_OArrayAsVector                                               */
  394. /*                                                                        */
  395. /*  Implements an array of pointers to Object,                            */
  396. /*  using a vector as the underlying implementation.                      */
  397. /*                                                                        */
  398. /*------------------------------------------------------------------------*/
  399.  
  400. class _CLASSTYPE BI_OArrayAsVector
  401. {
  402.  
  403. public:
  404.  
  405.     friend class _CLASSTYPE BI_OArrayAsVectorIterator;
  406.  
  407.     BI_OArrayAsVector() : oarray( DEFAULT_ARRAY_SIZE )
  408.         {
  409.         }
  410.  
  411.     BI_OArrayAsVector( int upr, int lwr = 0, unsigned delta = 0 ) :
  412.         oarray( upr, lwr, delta )
  413.         {
  414.         }
  415.  
  416.     Object *operator [] (int loc)
  417.         {
  418.         return oarray[loc];
  419.         }
  420.  
  421.     Object *operator [] (int loc) const
  422.         {
  423.         return oarray[loc];
  424.         }
  425.  
  426.     int lowerBound() const
  427.         {
  428.         return oarray.lowerBound();
  429.         }
  430.  
  431.     int upperBound() const
  432.         {
  433.         return oarray.upperBound();
  434.         }
  435.  
  436.     sizeType arraySize() const
  437.         {
  438.         return oarray.arraySize();
  439.         }
  440.  
  441.     void add( Object _FAR *o )
  442.         {
  443.         oarray.add(o);
  444.         }
  445.  
  446.     void addAt( Object _FAR *o, int loc )
  447.         {
  448.         oarray.addAt(o,loc);
  449.         }
  450.  
  451.     void detach( int loc,
  452.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  453.                )
  454.         {
  455.         oarray.detach( loc, dt );
  456.         }
  457.  
  458.     void detach( Object _FAR *o,
  459.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  460.                )
  461.         {
  462.         oarray.detach( o, dt );
  463.         }
  464.  
  465.     void destroy( int i )
  466.         {
  467.         oarray.destroy( i );
  468.         }
  469.  
  470.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  471.         {
  472.         oarray.flush( dt );
  473.         }
  474.  
  475.     int hasMember( Object _FAR *o ) const
  476.         {
  477.         return oarray.hasMember(o);
  478.         }
  479.  
  480.     Object _FAR *findMember( Object _FAR *o ) const
  481.         {
  482.         int loc = oarray.find(o);
  483.         return loc != INT_MAX ? oarray[loc] : 0;
  484.         }
  485.  
  486.     int isEmpty() const
  487.         {
  488.         return oarray.isEmpty();
  489.         }
  490.  
  491.     int isFull() const
  492.         {
  493.         return oarray.isFull();
  494.         }
  495.  
  496.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  497.         {
  498.         oarray.forEach( f, args );
  499.         }
  500.  
  501.     Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  502.                             void _FAR *args
  503.                           ) const
  504.         {
  505.         return oarray.firstThat( f, args );
  506.         }
  507.  
  508.     Object _FAR *lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  509.                            void _FAR *args
  510.                          ) const
  511.         {
  512.         return oarray.lastThat( f, args );
  513.         }
  514.  
  515.     int getItemsInContainer() const
  516.         {
  517.         return oarray.getItemsInContainer();
  518.         }
  519.  
  520.     int ownsElements()
  521.         {
  522.         return oarray.ownsElements();
  523.         }
  524.  
  525.     void ownsElements( int del )
  526.         {
  527.         oarray.ownsElements( del );
  528.         }
  529.  
  530. protected:
  531.  
  532.     BI_IArrayAsVector<Object> oarray;
  533.  
  534. };
  535.  
  536. class _CLASSTYPE BI_OArrayAsVectorIterator :
  537.     public BI_IArrayAsVectorIterator<Object>
  538. {
  539.  
  540. public:
  541.  
  542.     BI_OArrayAsVectorIterator( const BI_OArrayAsVector _FAR &a ) :
  543.         BI_IArrayAsVectorIterator<Object>(a.oarray)
  544.         {
  545.         restart();
  546.         }
  547.  
  548.     void restart()
  549.         {
  550.         BI_IArrayAsVectorIterator<Object>::restart();
  551.         if( current() == 0 )
  552.             (*this)++;
  553.         }
  554.  
  555. };
  556.  
  557. /*------------------------------------------------------------------------*/
  558. /*                                                                        */
  559. /*  class BI_TCArrayAsVector                                              */
  560. /*                                                                        */
  561. /*  Implements an Object array, with the full semantics of                */
  562. /*  the BC 2.0 style array, using a vector as the underlying              */
  563. /*  implementation.                                                       */
  564. /*                                                                        */
  565. /*------------------------------------------------------------------------*/
  566.  
  567. class _CLASSTYPE BI_TCArrayAsVector : public AbstractArray
  568. {
  569.  
  570. public:
  571.  
  572.     friend class _CLASSTYPE BI_TCArrayAsVectorIterator;
  573.  
  574.     BI_TCArrayAsVector( int upper, int lower = 0, sizeType delta = 0 ) :
  575.         array( upper, lower, delta )
  576.         {
  577.         }
  578.  
  579.     virtual Object& operator []( int loc )
  580.         {
  581.         return ptrToRef(array[loc]);
  582.         }
  583.  
  584.     virtual Object& operator []( int loc ) const
  585.         {
  586.         return ptrToRef(array[loc]);
  587.         }
  588.  
  589.     virtual int lowerBound() const
  590.         {
  591.         return array.lowerBound();
  592.         }
  593.  
  594.     virtual int upperBound() const
  595.         {
  596.         return array.upperBound();
  597.         }
  598.  
  599.     virtual sizeType arraySize() const
  600.         {
  601.         return array.arraySize();
  602.         }
  603.  
  604.     void add( Object _FAR &o )
  605.         {
  606.         array.add(&o);
  607.         }
  608.  
  609.     void addAt( Object _FAR &o, int loc )
  610.         {
  611.         array.addAt(&o,loc);
  612.         }
  613.  
  614.     virtual void detach( int loc, DeleteType dt = NoDelete )
  615.         {
  616.         array.detach( loc, dt );
  617.         }
  618.  
  619.     void detach( Object _FAR &o,
  620.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  621.                )
  622.         {
  623.         array.detach( &o, dt );
  624.         }
  625.  
  626.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  627.         {
  628.         array.flush( dt );
  629.         }
  630.  
  631.     int hasMember( Object _FAR &o ) const
  632.         {
  633.         return array.hasMember(&o);
  634.         }
  635.  
  636.     Object _FAR &findMember( Object _FAR &o ) const
  637.         {
  638.         return ptrToRef(array.findMember(&o));
  639.         }
  640.  
  641.     int isEmpty() const
  642.         {
  643.         return array.isEmpty();
  644.         }
  645.  
  646.     int isFull() const
  647.         {
  648.         return array.isFull();
  649.         }
  650.  
  651.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  652.         {
  653.         array.forEach( f, args );
  654.         }
  655.  
  656.     Object _FAR &firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  657.                             void _FAR *args
  658.                           ) const
  659.         {
  660.         return ptrToRef(array.firstThat( f, args ));
  661.         }
  662.  
  663.     Object _FAR &lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  664.                            void _FAR *args
  665.                          ) const
  666.         {
  667.         return ptrToRef(array.lastThat( f, args ));
  668.         }
  669.  
  670.     int getItemsInContainer() const
  671.         {
  672.         return array.getItemsInContainer();
  673.         }
  674.  
  675.     virtual classType isA() const
  676.         {
  677.         return arrayClass;
  678.         }
  679.  
  680.     virtual char _FAR *nameOf() const
  681.         {
  682.         return "BI_TCArrayAsVector";
  683.         }
  684.  
  685.     int ownsElements()
  686.         {
  687.         return array.ownsElements();
  688.         }
  689.  
  690.     void ownsElements( int del )
  691.         {
  692.         array.ownsElements( del );
  693.         }
  694.  
  695.     ContainerIterator _FAR &initIterator() const;
  696.  
  697. private:
  698.  
  699.     BI_OArrayAsVector array;
  700.  
  701. };
  702.  
  703. class _CLASSTYPE BI_TCArrayAsVectorIterator : public ContainerIterator
  704. {
  705.  
  706. public:
  707.  
  708.     BI_TCArrayAsVectorIterator( const BI_TCArrayAsVector _FAR &a ) :
  709.         iter(a.array)
  710.         {
  711.         }
  712.  
  713.     virtual operator int()
  714.         {
  715.         return int(iter);
  716.         }
  717.  
  718.     virtual Object _FAR & current()
  719.         {
  720.         return Object::ptrToRef(iter.current());
  721.         }
  722.  
  723.     virtual Object _FAR & operator ++ ( int )
  724.         {
  725.         return Object::ptrToRef(iter++);
  726.         }
  727.  
  728.     virtual Object _FAR & operator ++ ()
  729.         {
  730.         return Object::ptrToRef(++iter);
  731.         }
  732.  
  733.     virtual void restart()
  734.         {
  735.         iter.restart();
  736.         }
  737.  
  738. private:
  739.  
  740.     BI_OArrayAsVectorIterator iter;
  741.  
  742. };
  743.  
  744. inline ContainerIterator _FAR & BI_TCArrayAsVector::initIterator() const
  745.         { return *new BI_TCArrayAsVectorIterator( *this ); }
  746.  
  747. /*------------------------------------------------------------------------*/
  748. /*                                                                        */
  749. /*  template <class T> class BI_SArrayAsVector                            */
  750. /*                                                                        */
  751. /*  Implements a sorted array of objects of type T, using a vector as     */
  752. /*  the underlying implementation.                                        */
  753. /*                                                                        */
  754. /*------------------------------------------------------------------------*/
  755.  
  756. template <class T> class _CLASSTYPE BI_SArrayAsVector :
  757.     public BI_ArrayAsVectorImp<BI_SVectorImp<T>,T>
  758. {
  759.  
  760. public:
  761.  
  762.     friend class _CLASSTYPE BI_SArrayAsVectorIterator<T>;
  763.  
  764.     BI_SArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  765.         BI_ArrayAsVectorImp<BI_SVectorImp<T>,T>( upper, lower, delta )
  766.         {
  767.         }
  768.  
  769.     T& operator []( int loc )
  770.         {
  771.         grow( loc+1 );
  772.         return data[zeroBase(loc)];
  773.         }
  774.  
  775.     T& operator []( int loc ) const
  776.         {
  777.         PRECONDITION( loc >= lowerbound && loc < data.count() );
  778.         return data[zeroBase(loc)];
  779.         }
  780.  
  781.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  782.         {
  783.         if( !isEmpty() )
  784.             data.forEach( f, args );
  785.         }
  786.  
  787.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  788.                        void _FAR *args
  789.                      ) const
  790.         {
  791.         if( isEmpty() )
  792.             return 0;
  793.         return data.firstThat( f, args );
  794.         }
  795.  
  796.     T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
  797.                       void _FAR *args
  798.                     ) const
  799.         {
  800.         if( isEmpty() )
  801.             return 0;
  802.         return data.lastThat( f, args );
  803.         }
  804.  
  805. };
  806.  
  807. template <class T> class _CLASSTYPE BI_SArrayAsVectorIterator :
  808.     public BI_VectorIteratorImp<T>
  809. {
  810.  
  811. public:
  812.  
  813.     BI_SArrayAsVectorIterator( const BI_SArrayAsVector<T> _FAR & a ) :
  814.         BI_VectorIteratorImp<T>(a.data) {}
  815.  
  816. };
  817.  
  818. /*------------------------------------------------------------------------*/
  819. /*                                                                        */
  820. /*  template <class T> class BI_ISArrayAsVector                           */
  821. /*                                                                        */
  822. /*  Implements an indirect sorted array of objects of type T, using a     */
  823. /*  vector as the underlying implementation.                              */
  824. /*                                                                        */
  825. /*------------------------------------------------------------------------*/
  826.  
  827. template <class T> class _CLASSTYPE BI_ISArrayAsVector :
  828.     public BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>,
  829.     public virtual TShouldDelete
  830. {
  831.  
  832. public:
  833.  
  834.     friend class _CLASSTYPE BI_ISArrayAsVectorIterator<T>;
  835.  
  836.     BI_ISArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  837.         BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR*>( upper, lower, delta )
  838.         {
  839.         }
  840.  
  841.     ~BI_ISArrayAsVector()
  842.         {
  843.         flush();
  844.         }
  845.  
  846.     T _FAR * _FAR & operator []( int loc )
  847.         {
  848.         grow( loc+1 );
  849.         return data[zeroBase(loc)];
  850.         }
  851.  
  852.     T _FAR * _FAR & operator []( int loc ) const
  853.         {
  854.         PRECONDITION( loc >= lowerbound && loc < data.count() );
  855.         return data[zeroBase(loc)];
  856.         }
  857.  
  858.     void add( T _FAR *t )
  859.         {
  860.         BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>::add(t);
  861.         }
  862.  
  863.     void addAt( T _FAR *t, int loc )
  864.         {
  865.         BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>::addAt(t,loc);
  866.         }
  867.  
  868.     void detach( int loc, DeleteType dt = NoDelete )
  869.         {
  870.         data.detach( loc, delObj(dt) );
  871.         }
  872.  
  873.     void detach( T _FAR *t, DeleteType dt = NoDelete )
  874.         {
  875.         unsigned loc = data.find( t );
  876.         if( loc == UINT_MAX )
  877.             return;
  878.         data.detach( loc, delObj(dt) );
  879.         }
  880.  
  881.     void flush( DeleteType dt = DefDelete )
  882.         {
  883.         data.flush( delObj(dt), data.limit(), 0 );
  884.         }
  885.  
  886.     int find( const T *t ) const
  887.         {
  888.         return boundBase( data.find( (T *)t ) );
  889.         }
  890.  
  891.     void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
  892.         {
  893.         if( !isEmpty() )
  894.             data.forEach( f, args );
  895.         }
  896.  
  897.     T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
  898.                        void _FAR *args
  899.                      ) const
  900.         {
  901.         if( isEmpty() )
  902.             return 0;
  903.         return data.firstThat( f, args );
  904.         }
  905.  
  906.     T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
  907.                       void _FAR *args
  908.                     ) const
  909.         {
  910.         if( isEmpty() )
  911.             return 0;
  912.         return data.lastThat( f, args );
  913.         }
  914.  
  915. };
  916.  
  917. template <class T> class _CLASSTYPE BI_ISArrayAsVectorIterator :
  918.     public BI_IVectorIteratorImp<T>
  919. {
  920.  
  921. public:
  922.  
  923.     BI_ISArrayAsVectorIterator( const BI_ISArrayAsVector<T> _FAR &a ) :
  924.         BI_IVectorIteratorImp<T>(a.data) {}
  925.  
  926. };
  927.  
  928. /*------------------------------------------------------------------------*/
  929. /*                                                                        */
  930. /*  class BI_ISObjectVector                                               */
  931. /*                                                                        */
  932. /*  Implements a sorted vector of pointers to Object.                     */
  933. /*  This is implemented through the template BI_ISVectorImp<Object>.      */
  934. /*                                                                        */
  935. /*------------------------------------------------------------------------*/
  936.  
  937. class _CLASSTYPE BI_ISObjectVector :
  938.     public BI_InternalIVectorImp<Object, BI_ISVectorImp<void _FAR *> >
  939. {
  940.  
  941. public:
  942.  
  943.     BI_ISObjectVector( unsigned sz, unsigned d = 0 ) :
  944.         BI_InternalIVectorImp<Object, BI_ISVectorImp<void _FAR *> >(sz)
  945.         {
  946.         delta = d;
  947.         }
  948.  
  949.     ~BI_ISObjectVector()
  950.         {
  951.         flush();
  952.         }
  953.  
  954.     void add( Object _FAR *o );
  955.  
  956.     void addAt( Object _FAR *t, unsigned loc )
  957.         {
  958.         BI_InternalIVectorImp<Object, BI_ISVectorImp<void _FAR *> >::addAt(t,loc);
  959.         }
  960.  
  961.     void detach( unsigned loc, int del = 0 )
  962.         {
  963.         BI_InternalIVectorImp<Object, BI_ISVectorImp<void _FAR *> >::detach( loc, del );
  964.         }
  965.  
  966.     void detach( Object _FAR *t, int del = 0 )
  967.         {
  968.         unsigned loc = find( t );
  969.         if( loc == UINT_MAX )
  970.             return;
  971.         BI_InternalIVectorImp<Object, BI_ISVectorImp<void _FAR *> >::detach( loc, del );
  972.         }
  973.  
  974.     void flush( int del = 0 )
  975.         {
  976.         BI_InternalIVectorImp<Object, BI_ISVectorImp<void _FAR *> >::flush( del );
  977.         }
  978.  
  979.     unsigned find( Object _FAR *t ) const
  980.         {
  981.         return find( (void _FAR *)t );
  982.         }
  983.  
  984. protected:
  985.  
  986.     unsigned find( void _FAR *t ) const;
  987.  
  988. private:
  989.  
  990.     virtual void removeData( void _FAR *t )
  991.         {
  992.         delete (Object _FAR *)t;
  993.         }
  994.  
  995. };
  996.  
  997. class _CLASSTYPE BI_ISObjectVectorIterator :
  998.     public BI_IVectorIteratorImp<Object>
  999. {
  1000.  
  1001. public:
  1002.  
  1003.     BI_ISObjectVectorIterator( const BI_ISObjectVector _FAR &a ) :
  1004.         BI_IVectorIteratorImp<Object>(a) {}
  1005.  
  1006. };
  1007.  
  1008. /*------------------------------------------------------------------------*/
  1009. /*                                                                        */
  1010. /*  class BI_ISObjectArray                                                */
  1011. /*                                                                        */
  1012. /*  Implements an indirect sorted array of pointers to Object, using a    */
  1013. /*  vector as the underlying implementation.                              */
  1014. /*                                                                        */
  1015. /*------------------------------------------------------------------------*/
  1016.  
  1017. class _CLASSTYPE BI_ISObjectArray :
  1018.     public BI_ArrayAsVectorImp<BI_ISObjectVector,Object _FAR *>,
  1019.     public virtual TShouldDelete
  1020. {
  1021.  
  1022. public:
  1023.  
  1024.     friend class _CLASSTYPE BI_ISObjectArrayIterator;
  1025.  
  1026.     BI_ISObjectArray( int upr, int lwr = 0, int delta = 0 ) :
  1027.         BI_ArrayAsVectorImp<BI_ISObjectVector,Object _FAR*>( upr, lwr, delta )
  1028.         {
  1029.         }
  1030.  
  1031.     ~BI_ISObjectArray()
  1032.         {
  1033.         flush();
  1034.         }
  1035.  
  1036.     Object _FAR * _FAR & operator []( int loc )
  1037.         {
  1038.         grow( loc+1 );
  1039.         return data[zeroBase(loc)];
  1040.         }
  1041.  
  1042.     Object _FAR * _FAR & operator []( int loc ) const
  1043.         {
  1044.         PRECONDITION( loc >= lowerbound && zeroBase(loc) < data.count() );
  1045.         return data[zeroBase(loc)];
  1046.         }
  1047.  
  1048.     void add( Object _FAR *t )
  1049.         {
  1050.         BI_ArrayAsVectorImp<BI_ISObjectVector,Object _FAR *>::add(t);
  1051.         }
  1052.  
  1053.     void addAt( Object _FAR *t, int loc )
  1054.         {
  1055.         BI_ArrayAsVectorImp<BI_ISObjectVector,Object _FAR *>::addAt(t,loc);
  1056.         }
  1057.  
  1058.     void detach( int loc, DeleteType dt = NoDelete )
  1059.         {
  1060.         data.detach( zeroBase(loc), delObj(dt) );
  1061.         }
  1062.  
  1063.     void detach( Object _FAR *t, DeleteType dt = NoDelete )
  1064.         {
  1065.         data.detach( t, delObj(dt) );
  1066.         }
  1067.  
  1068.     void flush( DeleteType dt = DefDelete )
  1069.         {
  1070.         data.flush( delObj(dt) );
  1071.         }
  1072.  
  1073.     int find( const Object *t ) const
  1074.         {
  1075.         return boundBase(data.find( (Object *)t ));
  1076.         }
  1077.  
  1078.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  1079.         {
  1080.         if( !isEmpty() )
  1081.             data.forEach( f, args );
  1082.         }
  1083.  
  1084.     Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  1085.                             void _FAR *args
  1086.                           ) const
  1087.         {
  1088.         if( isEmpty() )
  1089.             return 0;
  1090.         return data.firstThat( f, args );
  1091.         }
  1092.  
  1093.     Object _FAR *lastThat( int (_FAR * f)(const Object _FAR &, void _FAR *),
  1094.                            void _FAR *args
  1095.                          ) const
  1096.         {
  1097.         if( isEmpty() )
  1098.             return 0;
  1099.         return data.lastThat( f, args );
  1100.         }
  1101.  
  1102. };
  1103.  
  1104. class _CLASSTYPE BI_ISObjectArrayIterator :
  1105.     public BI_ISObjectVectorIterator
  1106. {
  1107.  
  1108. public:
  1109.  
  1110.     BI_ISObjectArrayIterator( const BI_ISObjectArray _FAR &a ) :
  1111.         BI_ISObjectVectorIterator(a.data) {}
  1112.  
  1113. };
  1114.  
  1115. /*------------------------------------------------------------------------*/
  1116. /*                                                                        */
  1117. /*  class BI_OSArrayAsVector                                              */
  1118. /*                                                                        */
  1119. /*  Implements a sorted array of pointers to Object,                      */
  1120. /*  using a vector as the underlying implementation.                      */
  1121. /*                                                                        */
  1122. /*  Although the interface is written to take pointers to Object, in      */
  1123. /*  fact, pointers to Sortable are required.                              */
  1124. /*                                                                        */
  1125. /*------------------------------------------------------------------------*/
  1126.  
  1127. class _CLASSTYPE BI_OSArrayAsVector
  1128. {
  1129.  
  1130. public:
  1131.  
  1132.     friend class _CLASSTYPE BI_OSArrayAsVectorIterator;
  1133.  
  1134.     BI_OSArrayAsVector() : oarray( DEFAULT_ARRAY_SIZE, 0, 0 )
  1135.         {
  1136.         }
  1137.  
  1138.     BI_OSArrayAsVector( int upr, int lwr = 0, unsigned delta = 0 ) :
  1139.         oarray( upr, lwr, delta )
  1140.         {
  1141.         }
  1142.  
  1143.     Object *operator [] (int loc)
  1144.         {
  1145.         return oarray[loc];
  1146.         }
  1147.  
  1148.     Object *operator [] (int loc) const
  1149.         {
  1150.         return oarray[loc];
  1151.         }
  1152.  
  1153.     int lowerBound() const
  1154.         {
  1155.         return oarray.lowerBound();
  1156.         }
  1157.  
  1158.     int upperBound() const
  1159.         {
  1160.         return oarray.upperBound();
  1161.         }
  1162.  
  1163.     sizeType arraySize() const
  1164.         {
  1165.         return oarray.arraySize();
  1166.         }
  1167.  
  1168.     void add( Object _FAR *o )
  1169.         {
  1170.         PRECONDITION( o->isSortable() );
  1171.         oarray.add(o);
  1172.         }
  1173.  
  1174.     void addAt( Object _FAR *o, int loc )
  1175.         {
  1176.         PRECONDITION( o->isSortable() );
  1177.         oarray.addAt(o,loc);
  1178.         }
  1179.  
  1180.     void detach( int loc,
  1181.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  1182.                )
  1183.         {
  1184.         oarray.detach( loc, dt );
  1185.         }
  1186.  
  1187.     void detach( Object _FAR *o,
  1188.                  TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
  1189.                )
  1190.         {
  1191.         PRECONDITION( o->isSortable() );
  1192.         oarray.detach( o, dt );
  1193.         }
  1194.  
  1195.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  1196.         {
  1197.         oarray.flush( dt );
  1198.         }
  1199.  
  1200.     int hasMember( Object _FAR *o ) const
  1201.         {
  1202.         PRECONDITION( o->isSortable() );
  1203.         return oarray.hasMember(o);
  1204.         }
  1205.  
  1206.     Object _FAR *findMember( Object _FAR *o ) const
  1207.         {
  1208.         PRECONDITION( o->isSortable() );
  1209.         int loc = oarray.find(o);
  1210.         return loc != INT_MAX ? oarray[loc] : 0;
  1211.         }
  1212.  
  1213.     int isEmpty() const
  1214.         {
  1215.         return oarray.isEmpty();
  1216.         }
  1217.  
  1218.     int isFull() const
  1219.         {
  1220.         return oarray.isFull();
  1221.         }
  1222.  
  1223.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  1224.         {
  1225.         oarray.forEach( f, args );
  1226.         }
  1227.  
  1228.     Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  1229.                             void _FAR *args
  1230.                           ) const
  1231.         {
  1232.         return oarray.firstThat( f, args );
  1233.         }
  1234.  
  1235.     Object _FAR *lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  1236.                            void _FAR *args
  1237.                          ) const
  1238.         {
  1239.         return oarray.lastThat( f, args );
  1240.         }
  1241.  
  1242.     int getItemsInContainer() const
  1243.         {
  1244.         return oarray.getItemsInContainer();
  1245.         }
  1246.  
  1247.     int ownsElements()
  1248.         {
  1249.         return oarray.ownsElements();
  1250.         }
  1251.  
  1252.     void ownsElements( int del )
  1253.         {
  1254.         oarray.ownsElements( del );
  1255.         }
  1256.  
  1257. protected:
  1258.  
  1259.     BI_ISObjectArray oarray;
  1260.  
  1261. };
  1262.  
  1263. class _CLASSTYPE BI_OSArrayAsVectorIterator :
  1264.     public BI_ISObjectArrayIterator
  1265. {
  1266.  
  1267. public:
  1268.  
  1269.     BI_OSArrayAsVectorIterator( const BI_OSArrayAsVector _FAR &a ) :
  1270.         BI_ISObjectArrayIterator(a.oarray)
  1271.         {
  1272.         }
  1273.  
  1274. };
  1275.  
  1276. /*------------------------------------------------------------------------*/
  1277. /*                                                                        */
  1278. /*  class BI_TCSArrayAsVector                                             */
  1279. /*                                                                        */
  1280. /*  Implements a sorted Object array, with the full semantics of          */
  1281. /*  the BC 2.0 style sorted array, using a vector as the underlying       */
  1282. /*  implementation.                                                       */
  1283. /*                                                                        */
  1284. /*------------------------------------------------------------------------*/
  1285.  
  1286. class _CLASSTYPE BI_TCSArrayAsVector : public AbstractArray
  1287. {
  1288.  
  1289. public:
  1290.  
  1291.     friend class _CLASSTYPE BI_TCSArrayAsVectorIterator;
  1292.  
  1293.     BI_TCSArrayAsVector( int upper = DEFAULT_ARRAY_SIZE,
  1294.                          int lower = 0,
  1295.                          sizeType delta = 0
  1296.                        ) :
  1297.         array( upper, lower, delta )
  1298.         {
  1299.         }
  1300.  
  1301.     virtual Object& operator []( int loc )
  1302.         {
  1303.         return ptrToRef(array[loc]);
  1304.         }
  1305.  
  1306.     virtual Object& operator []( int loc ) const
  1307.         {
  1308.         return ptrToRef(array[loc]);
  1309.         }
  1310.  
  1311.     virtual int lowerBound() const
  1312.         {
  1313.         return array.lowerBound();
  1314.         }
  1315.  
  1316.     virtual int upperBound() const
  1317.         {
  1318.         return array.upperBound();
  1319.         }
  1320.  
  1321.     virtual sizeType arraySize() const
  1322.         {
  1323.         return array.arraySize();
  1324.         }
  1325.  
  1326.     void add( Object _FAR &o )
  1327.         {
  1328.         array.add(&o);
  1329.         }
  1330.  
  1331.     void addAt( Object _FAR &o, int loc )
  1332.         {
  1333.         array.addAt(&o,loc);
  1334.         }
  1335.  
  1336.     virtual void detach( int loc, DeleteType dt = NoDelete )
  1337.         {
  1338.         array.detach( loc, dt );
  1339.         }
  1340.  
  1341.     void detach( Object _FAR &o, DeleteType dt = NoDelete )
  1342.         {
  1343.         array.detach( &o, dt );
  1344.         }
  1345.  
  1346.     void flush( TShouldDelete::DeleteType dt = DefDelete )
  1347.         {
  1348.         array.flush( dt );
  1349.         }
  1350.  
  1351.     int hasMember( Object _FAR &o ) const
  1352.         {
  1353.         return array.hasMember(&o);
  1354.         }
  1355.  
  1356.     Object _FAR &findMember( Object _FAR &o ) const
  1357.         {
  1358.         return ptrToRef(array.findMember(&o));
  1359.         }
  1360.  
  1361.     int isEmpty() const
  1362.         {
  1363.         return array.isEmpty();
  1364.         }
  1365.  
  1366.     int isFull() const
  1367.         {
  1368.         return array.isFull();
  1369.         }
  1370.  
  1371.     void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
  1372.         {
  1373.         array.forEach( f, args );
  1374.         }
  1375.  
  1376.     Object _FAR &firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  1377.                             void _FAR *args
  1378.                           ) const
  1379.         {
  1380.         return ptrToRef(array.firstThat( f, args ));
  1381.         }
  1382.  
  1383.     Object _FAR &lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
  1384.                            void _FAR *args
  1385.                          ) const
  1386.         {
  1387.         return ptrToRef(array.lastThat( f, args ));
  1388.         }
  1389.  
  1390.     int getItemsInContainer() const
  1391.         {
  1392.         return array.getItemsInContainer();
  1393.         }
  1394.  
  1395.     virtual classType isA() const
  1396.         {
  1397.         return sortedArrayClass;
  1398.         }
  1399.  
  1400.     virtual char _FAR *nameOf() const
  1401.         {
  1402.         return "BI_TCSArrayAsVector";
  1403.         }
  1404.  
  1405.     int ownsElements()
  1406.         {
  1407.         return array.ownsElements();
  1408.         }
  1409.  
  1410.     void ownsElements( int del )
  1411.         {
  1412.         array.ownsElements( del );
  1413.         }
  1414.  
  1415.     ContainerIterator _FAR & initIterator() const;
  1416.  
  1417. private:
  1418.  
  1419.     BI_OSArrayAsVector array;
  1420.  
  1421. };
  1422.  
  1423. class _CLASSTYPE BI_TCSArrayAsVectorIterator : public ContainerIterator
  1424. {
  1425.  
  1426. public:
  1427.  
  1428.     BI_TCSArrayAsVectorIterator( const BI_TCSArrayAsVector _FAR &a ) :
  1429.         iter(a.array)
  1430.         {
  1431.         }
  1432.  
  1433.     virtual operator int()
  1434.         {
  1435.         return int(iter);
  1436.         }
  1437.  
  1438.     virtual Object _FAR & current()
  1439.         {
  1440.         return Object::ptrToRef(iter.current());
  1441.         }
  1442.  
  1443.     virtual Object _FAR & operator ++ ( int )
  1444.         {
  1445.         return Object::ptrToRef(iter++);
  1446.         }
  1447.  
  1448.     virtual Object _FAR & operator ++ ()
  1449.         {
  1450.         return Object::ptrToRef(++iter);
  1451.         }
  1452.  
  1453.     virtual void restart()
  1454.         {
  1455.         iter.restart();
  1456.         }
  1457.  
  1458. private:
  1459.  
  1460.     BI_OSArrayAsVectorIterator iter;
  1461.  
  1462. };
  1463.  
  1464. inline ContainerIterator _FAR & BI_TCSArrayAsVector::initIterator() const
  1465.         {
  1466.         return *new BI_TCSArrayAsVectorIterator( *this );
  1467.         }
  1468.  
  1469. #pragma warn .ncf
  1470.  
  1471. #if defined( __BCOPT__ ) && !defined( _ALLOW_po )
  1472. #pragma option -po.
  1473. #endif
  1474. #pragma option -Vo.
  1475.  
  1476. #endif  // __ARRAYS_H
  1477.  
  1478.