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