home *** CD-ROM | disk | FTP | other *** search
/ C Programming Starter Kit 2.0 / SamsPublishing-CProgrammingStarterKit-v2.0-Win31.iso / bc45 / classinc.pak / ARRAYS.H < prev    next >
C/C++ Source or Header  |  1997-07-23  |  27KB  |  849 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  ARRAYS.H                                                              */
  4. /*                                                                        */
  5. /*  Copyright (c) 1991, 1994 Borland International                        */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( CLASSLIB_ARRAYS_H )
  11. #define CLASSLIB_ARRAYS_H
  12.  
  13. //#define TEMPLATES
  14.  
  15. #if !defined( __MEM_H )
  16. #include <mem.h>
  17. #endif
  18.  
  19. #if !defined( CLASSLIB_DEFS_H )
  20. #include <classlib/defs.h>
  21. #endif
  22.  
  23. #if !defined( CLASSLIB_SHDDEL_H )
  24. #include <classlib/shddel.h>
  25. #endif
  26.  
  27. #if !defined( CLASSLIB_ALLOCTR_H )
  28. #include <classlib/alloctr.h>
  29. #endif
  30.  
  31. #if !defined( CLASSLIB_VECTIMP_H )
  32. #include <classlib/vectimp.h>
  33. #endif
  34.  
  35. #pragma option -Vo-
  36. #if defined( BI_CLASSLIB_NO_po )
  37. #pragma option -po-
  38. #endif
  39.  
  40. /*------------------------------------------------------------------------*/
  41. /*                                                                        */
  42. /*  [INTERNAL USE ONLY]                                                   */
  43. /*                                                                        */
  44. /*  template <class Vect, class T> class TArrayAsVectorImp                */
  45. /*                                                                        */
  46. /*  Implements the type-independent array operations, using a vector      */
  47. /*  as the underlying implementation.  The type Vect specifies the        */
  48. /*  form of the vector, either a TCVectorImp<T0>, a TSVectorImp<T0>, a    */
  49. /*  TICVectorImp<T0>, or a TISVectorImp<T0>.  The type T specifies the    */
  50. /*  type of the objects to be put in the array.  When using               */
  51. /*  TCVectorImp<T0> or a TSVectorImp<T0> T should be the same as T0. When */
  52. /*  using TICVectorImp<T0> or TISVectorImp<T0> T should be of type        */
  53. /*  pointer to T0.  See TArrayAsVector and                                */
  54. /*  TIArrayAsVector for examples.                                         */
  55. /*                                                                        */
  56. /*------------------------------------------------------------------------*/
  57.  
  58. template <class Vect, class T> class TArrayAsVectorImp
  59. {
  60.  
  61. public:
  62.  
  63.     TArrayAsVectorImp( int upper, int lower, int delta ) :
  64.         Data( upper-lower+1,delta ),
  65.         Lowerbound( lower )
  66.         {
  67.         }
  68.  
  69.     int LowerBound() const
  70.         {
  71.         return Lowerbound;
  72.         }
  73.  
  74.     int UpperBound() const
  75.         {
  76.         return BoundBase( Data.Limit() )-1;
  77.         }
  78.  
  79.     unsigned ArraySize() const
  80.         {
  81.         return Data.Limit();
  82.         }
  83.  
  84.     int IsFull() const
  85.         {
  86.         return Data.GetDelta() == 0 && Data.Count() >= Data.Limit();
  87.         }
  88.  
  89.     int IsEmpty() const
  90.         {
  91.         return Data.Count() == 0;
  92.         }
  93.  
  94.     unsigned GetItemsInContainer() const
  95.         {
  96.         return Data.Count();
  97.         }
  98.  
  99. #if defined( BI_OLDNAMES )
  100.     int lowerBound() const { return LowerBound(); }
  101.     int upperBound() const { return UpperBound(); }
  102.     unsigned arraySize() const { return ArraySize(); }
  103.     int isFull() const { return IsFull(); }
  104.     int isEmpty() const { return IsEmpty(); }
  105.     unsigned getItemsInContainer() const { return GetItemsInContainer(); }
  106. #endif
  107.  
  108.     void Reallocate( unsigned sz, unsigned offset = 0 )
  109.         {
  110.         Data.Resize( sz, offset );
  111.         }
  112.  
  113.  
  114.     void SetData( int loc, const T& t )
  115.         {
  116.         PRECONDITION( loc >= Lowerbound && loc <= UpperBound() );
  117.         Data[ ZeroBase(loc) ] = t;
  118.         }
  119.  
  120.     void RemoveEntry( int loc )
  121.         {
  122.         SqueezeEntry( ZeroBase(loc) );
  123.         }
  124.  
  125.     void SqueezeEntry( unsigned loc )
  126.         {
  127.         PRECONDITION( loc < Data.Count() );
  128.         Data.Detach( loc );
  129.         }
  130.  
  131.     unsigned ZeroBase( int loc ) const
  132.         {
  133.         return loc - Lowerbound;
  134.         }
  135.  
  136.     int BoundBase( unsigned loc ) const
  137.         {
  138.         return loc == UINT_MAX ? INT_MAX : loc + Lowerbound;
  139.         }
  140.  
  141.     void Grow( int loc )
  142.         {
  143.         if( loc < LowerBound() )
  144.             Reallocate( ArraySize() + (loc - Lowerbound) );
  145.         else if( loc >= BoundBase( Data.Limit()) )
  146.             Reallocate( ZeroBase(loc) );
  147.         }
  148.  
  149.     int Lowerbound;
  150.  
  151.     Vect Data;
  152.  
  153. };
  154.  
  155. /*------------------------------------------------------------------------*/
  156. /*                                                                        */
  157. /*  [INTERNAL USE ONLY]                                                   */
  158. /*                                                                        */
  159. /*  template <class Vect, class T> class TDArrayAsVectorImp               */
  160. /*                                                                        */
  161. /*  Implements the fundamental array operations for direct arrays, using  */
  162. /*  a vector as the underlying implementation.                            */
  163. /*                                                                        */
  164. /*------------------------------------------------------------------------*/
  165.  
  166. template <class Vect, class T> class TDArrayAsVectorImp :
  167.     public TArrayAsVectorImp<Vect,T>
  168. {
  169.  
  170. public:
  171.  
  172.     typedef void (*IterFunc)(T&, void *);
  173.     typedef int  (*CondFunc)(const T&, void *);
  174.  
  175.     TDArrayAsVectorImp( int upper, int lower, int delta ) :
  176.         TArrayAsVectorImp<Vect,T>( upper, lower, delta )
  177.         {
  178.         }
  179.  
  180.     int Add( const T& t )
  181.         {
  182.         return Data.Add(t);
  183.         }
  184.  
  185.     int Detach( const T& t )
  186.         {
  187.         return Data.Detach(t);
  188.         }
  189.  
  190.     int Detach( int loc )
  191.         {
  192.         return Data.Detach( ZeroBase(loc) );
  193.         }
  194.  
  195.     int Destroy( const T& t )
  196.         {
  197.         return Detach(t);
  198.         }
  199.  
  200.     int Destroy( int loc )
  201.         {
  202.         return Detach(loc);
  203.         }
  204.  
  205.     int HasMember( const T& t ) const
  206.         {
  207.         return Data.Find(t) != UINT_MAX;
  208.         }
  209.  
  210.     int Find( const T& t ) const
  211.         {
  212.         return BoundBase( Data.Find( t ) );
  213.         }
  214.  
  215.     T& operator []( int loc )
  216.         {
  217.         Grow( loc+1 );
  218.         return Data[ZeroBase(loc)];
  219.         }
  220.  
  221.     T& operator []( int loc ) const
  222.         {
  223.         PRECONDITION( loc >= Lowerbound && ZeroBase(loc) < Data.Limit() );
  224.         return Data[ZeroBase(loc)];
  225.         }
  226.  
  227.     void ForEach( IterFunc iter, void *args )
  228.         {
  229.         if( !IsEmpty() )
  230.             Data.ForEach( iter, args );
  231.         }
  232.  
  233.     T *FirstThat( CondFunc cond, void *args ) const
  234.         {
  235.         if( IsEmpty() )
  236.             return 0;
  237.         return Data.FirstThat( cond, args );
  238.         }
  239.  
  240.     T *LastThat( CondFunc cond, void *args ) const
  241.         {
  242.         if( IsEmpty() )
  243.             return 0;
  244.         return Data.LastThat( cond, args );
  245.         }
  246.  
  247.     void Flush()
  248.         {
  249.         Data.Flush();
  250.         }
  251.  
  252. #if defined( BI_OLDNAMES )
  253.     int add( const T& t ) { return Add(t); }
  254.     int detach( const T& t,TShouldDelete::DeleteType=TShouldDelete::NoDelete)
  255.         { return Detach(t); }
  256.     int detach( int loc,TShouldDelete::DeleteType=TShouldDelete::NoDelete)
  257.         { return Detach(loc); }
  258.     int destroy( const T& t ) { return Destroy(t); }
  259.     int destroy( int loc,TShouldDelete::DeleteType ) { return Destroy(loc); }
  260.     int hasMember( const T& t ) const { return HasMember(t); }
  261.     void forEach( IterFunc iter, void *args )
  262.         { ForEach( iter, args ); }
  263.     T *firstThat( CondFunc cond, void *args ) const
  264.         { return FirstThat( cond, args ); }
  265.     T *lastThat( CondFunc cond, void *args ) const
  266.         { return lastThat( cond, args ); }
  267.     void flush( TShouldDelete::DeleteType = TShouldDelete::DefDelete )
  268.         { Flush(); }
  269. #endif
  270.  
  271. protected:
  272.  
  273.     const T& ItemAt( int i ) const
  274.         {
  275.         return Data[ ZeroBase(i) ];
  276.         }
  277.  
  278. };
  279.  
  280. /*------------------------------------------------------------------------*/
  281. /*                                                                        */
  282. /*  [INTERNAL USE ONLY]                                                   */
  283. /*                                                                        */
  284. /*  template <class Vect, class T> class TIArrayAsVectorImp               */
  285. /*                                                                        */
  286. /*  Implements the fundamental array operations for indirect arrays,      */
  287. /*  using a vector as the underlying implementation.                      */
  288. /*                                                                        */
  289. /*------------------------------------------------------------------------*/
  290.  
  291. template <class Vect, class T> class TIArrayAsVectorImp :
  292.     public TArrayAsVectorImp<Vect,T *>, public TShouldDelete
  293. {
  294.  
  295. public:
  296.  
  297.     typedef void (*IterFunc)(T&, void *);
  298.     typedef int  (*CondFunc)(const T&, void *);
  299.  
  300.     TIArrayAsVectorImp( int upper, int lower, int delta ) :
  301.         TArrayAsVectorImp<Vect,T *>( upper, lower, delta )
  302.         {
  303.         }
  304.  
  305.     ~TIArrayAsVectorImp()
  306.         {
  307.         Flush();
  308.         }
  309.  
  310.     int Add( T *t )
  311.         {
  312.         return Data.Add(t);
  313.         }
  314.  
  315.     int Detach( T *t,
  316.                 TShouldDelete::DeleteType dt = TShouldDelete::NoDelete )
  317.         {
  318.         return Data.Detach(t,DelObj(dt));
  319.         }
  320.  
  321.     int Detach( int loc,
  322.                 TShouldDelete::DeleteType dt = TShouldDelete::NoDelete )
  323.         {
  324.         return Data.Detach( ZeroBase(loc), DelObj(dt) );
  325.         }
  326.  
  327.     int Destroy( T *t )
  328.         {
  329.         return Detach(t,TShouldDelete::Delete);
  330.         }
  331.  
  332.     int Destroy( int loc )
  333.         {
  334.         return Detach(loc,TShouldDelete::Delete);
  335.         }
  336.  
  337.     int HasMember( const T *t ) const
  338.         {
  339.         return Data.Find(t) != UINT_MAX;
  340.         }
  341.  
  342.     int Find( const T *t ) const
  343.         {
  344.         return BoundBase( Data.Find( t ) );
  345.         }
  346.  
  347.     T *& operator []( int loc )
  348.         {
  349.         Grow( loc+1 );
  350.         return Data[ZeroBase(loc)];
  351.         }
  352.  
  353.     T *& operator []( int loc ) const
  354.         {
  355.         PRECONDITION( loc >= Lowerbound && ZeroBase(loc) < Data.Limit() );
  356.         return Data[ZeroBase(loc)];
  357.         }
  358.  
  359.     void ForEach( IterFunc iter, void *args )
  360.         {
  361.         if( !IsEmpty() )
  362.             Data.ForEach( iter, args );
  363.         }
  364.  
  365.     T *FirstThat( CondFunc cond, void *args ) const
  366.         {
  367.         if( IsEmpty() )
  368.             return 0;
  369.         return Data.FirstThat( cond, args );
  370.         }
  371.  
  372.     T *LastThat( CondFunc cond, void *args ) const
  373.         {
  374.         if( IsEmpty() )
  375.             return 0;
  376.         return Data.LastThat( cond, args );
  377.         }
  378.  
  379.     void Flush( DeleteType dt = DefDelete )
  380.         {
  381.         Data.Flush(DelObj(dt));
  382.         }
  383.  
  384. #if defined( BI_OLDNAMES )
  385.     int add( T *t ) { return Add(t); }
  386.     int detach( T *t,TShouldDelete::DeleteType dt =TShouldDelete::NoDelete)
  387.         { return Detach(t,dt); }
  388.     int detach( int loc,TShouldDelete::DeleteType dt =TShouldDelete::NoDelete)
  389.         { return Detach(loc,dt); }
  390.     int destroy( T *t ) { return Destroy(t); }
  391.     int destroy( int loc,TShouldDelete::DeleteType ) { return Destroy(loc); }
  392.     int find( const T *t ) const { return Find(t); }
  393.     int hasMember( T *t ) const { return HasMember(t); }
  394.     void forEach( IterFunc iter, void *args )
  395.         { ForEach( iter, args ); }
  396.     T *firstThat( CondFunc cond, void *args ) const
  397.         { return FirstThat( cond, args ); }
  398.     T *lastThat( CondFunc cond, void *args ) const
  399.         { return lastThat( cond, args ); }
  400.     void flush( TShouldDelete::DeleteType = TShouldDelete::DefDelete )
  401.         { Flush(); }
  402. #endif
  403.  
  404. protected:
  405.  
  406.     T *& ItemAt( int i ) const
  407.         {
  408.         return Data[ ZeroBase(i) ];
  409.         }
  410.  
  411. };
  412.  
  413. /*------------------------------------------------------------------------*/
  414. /*                                                                        */
  415. /*  template <class T,class Alloc> class TMArrayAsVector                  */
  416. /*  template <class T,class Alloc> class TMArrayAsVectorIterator          */
  417. /*                                                                        */
  418. /*  Implements a managed array of objects of type T, using a vector as    */
  419. /*  the underlying implementation.                                        */
  420. /*                                                                        */
  421. /*------------------------------------------------------------------------*/
  422.  
  423. template <class T, class Alloc> class TMArrayAsVectorIterator;
  424.  
  425. template <class T, class Alloc> class TMArrayAsVector :
  426.     public TDArrayAsVectorImp<TMCVectorImp<T,Alloc>,T>
  427. {
  428.  
  429.     friend TMArrayAsVectorIterator<T,Alloc>;
  430.  
  431. public:
  432.  
  433.     TMArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  434.         TDArrayAsVectorImp<TMCVectorImp<T,Alloc>,T>( upper, lower, delta )
  435.         {
  436.         }
  437.  
  438.     int AddAt( const T& t, int loc )
  439.         {
  440.         return Data.AddAt( t, ZeroBase(loc) );
  441.         }
  442.  
  443. #if defined( BI_OLDNAMES )
  444.     int addAt( const T& t, int loc ) { return AddAt(t,loc); }
  445. #endif
  446.  
  447. };
  448.  
  449. template <class T, class Alloc> class TMArrayAsVectorIterator :
  450.     public TMCVectorIteratorImp<T,Alloc>
  451. {
  452.  
  453. public:
  454.  
  455.     TMArrayAsVectorIterator( const TMArrayAsVector<T,Alloc>& a ) :
  456.         TMCVectorIteratorImp<T,Alloc>( a.Data ) {}
  457.  
  458. };
  459.  
  460. #if defined( BI_OLDNAMES )
  461. #define BI_MArrayAsVector TMArrayAsVector
  462. #define BI_MArrayAsVectorIterator TMArrayAsVectorIterator
  463. #endif
  464.  
  465. /*------------------------------------------------------------------------*/
  466. /*                                                                        */
  467. /*  template <class T> class TArrayAsVector                               */
  468. /*  template <class T> class TArrayAsVectorIterator                       */
  469. /*                                                                        */
  470. /*  Implements an array of objects of type T, using a vector as the       */
  471. /*  underlying implementation and TStandardAllocator as its memory        */
  472. /*  manager.                                                              */
  473. /*                                                                        */
  474. /*------------------------------------------------------------------------*/
  475.  
  476. template <class T> class TArrayAsVector :
  477.     public TMArrayAsVector<T,TStandardAllocator>
  478. {
  479.  
  480. public:
  481.  
  482.     TArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  483.         TMArrayAsVector<T,TStandardAllocator>( upper, lower, delta )
  484.         {
  485.         }
  486.  
  487. };
  488.  
  489. template <class T> class TArrayAsVectorIterator :
  490.     public TMArrayAsVectorIterator<T,TStandardAllocator>
  491. {
  492.  
  493. public:
  494.  
  495.     TArrayAsVectorIterator( const TArrayAsVector<T>& a ) :
  496.         TMArrayAsVectorIterator<T,TStandardAllocator>(a)
  497.         {
  498.         }
  499.  
  500. };
  501.  
  502. #if defined( BI_OLDNAMES )
  503. #define BI_ArrayAsVector TArrayAsVector
  504. #define BI_ArrayAsVectorIterator TArrayAsVectorIterator
  505. #endif
  506.  
  507. /*------------------------------------------------------------------------*/
  508. /*                                                                        */
  509. /*  template <class T,class Alloc> class TMSArrayAsVector                 */
  510. /*  template <class T,class Alloc> class TMSArrayAsVectorIterator         */
  511. /*                                                                        */
  512. /*  Implements a managed, sorted array of objects of type T, using a      */
  513. /*  vector as the underlying implementation.                              */
  514. /*                                                                        */
  515. /*------------------------------------------------------------------------*/
  516.  
  517. template <class T, class Alloc> class TMSArrayAsVectorIterator;
  518.  
  519. template <class T, class Alloc> class TMSArrayAsVector :
  520.     public TDArrayAsVectorImp<TMSVectorImp<T,Alloc>,T>
  521. {
  522.  
  523.     friend TMSArrayAsVectorIterator<T,Alloc>;
  524.  
  525. public:
  526.  
  527.     TMSArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  528.         TDArrayAsVectorImp<TMSVectorImp<T,Alloc>,T>( upper, lower, delta )
  529.         {
  530.         }
  531.  
  532. };
  533.  
  534. template <class T, class Alloc> class TMSArrayAsVectorIterator :
  535.     public TMSVectorIteratorImp<T,Alloc>
  536. {
  537.  
  538. public:
  539.  
  540.     TMSArrayAsVectorIterator( const TMSArrayAsVector<T,Alloc>& a ) :
  541.         TMSVectorIteratorImp<T,Alloc>( a.Data ) {}
  542.  
  543. };
  544.  
  545. #if defined( BI_OLDNAMES )
  546. #define BI_MSArrayAsVector TMSArrayAsVector
  547. #define BI_MSArrayAsVectorIterator TMSArrayAsVectorIterator
  548. #endif
  549.  
  550. /*------------------------------------------------------------------------*/
  551. /*                                                                        */
  552. /*  template <class T> class TSArrayAsVector                              */
  553. /*  template <class T> class TSArrayAsVectorIterator                      */
  554. /*                                                                        */
  555. /*  Implements a sorted array of objects of type T, using a vector as     */
  556. /*  the underlying implementation and TStandardAllocator as its memory    */
  557. /*  manager.                                                              */
  558. /*                                                                        */
  559. /*------------------------------------------------------------------------*/
  560.  
  561. template <class T> class TSArrayAsVector :
  562.     public TMSArrayAsVector<T,TStandardAllocator>
  563. {
  564.  
  565. public:
  566.  
  567.     TSArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  568.         TMSArrayAsVector<T,TStandardAllocator>( upper, lower, delta )
  569.         {
  570.         }
  571.  
  572. };
  573.  
  574. template <class T> class TSArrayAsVectorIterator :
  575.     public TMSArrayAsVectorIterator<T,TStandardAllocator>
  576. {
  577.  
  578. public:
  579.  
  580.     TSArrayAsVectorIterator( const TSArrayAsVector<T>& a ) :
  581.         TMSArrayAsVectorIterator<T,TStandardAllocator>( a ) {}
  582.  
  583. }
  584.  
  585. #if defined( BI_OLDNAMES )
  586. #define BI_SArrayAsVector TSArrayAsVector
  587. #define BI_SArrayAsVectorIterator TSArrayAsVectorIterator
  588. #endif
  589.  
  590. /*------------------------------------------------------------------------*/
  591. /*                                                                        */
  592. /*  template <class T,class Alloc> class TMIArrayAsVector                 */
  593. /*  template <class T,class Alloc> class TMIArrayAsVectorIterator         */
  594. /*                                                                        */
  595. /*  Implements a managed indirect array of objects of type T, using a     */
  596. /*  vector as the underlying implementation.                              */
  597. /*                                                                        */
  598. /*------------------------------------------------------------------------*/
  599.  
  600. template <class T, class Alloc> class TMIArrayAsVectorIterator;
  601.  
  602. template <class T, class Alloc> class TMIArrayAsVector :
  603.     public TIArrayAsVectorImp<TMICVectorImp<T,Alloc>,T>
  604. {
  605.  
  606.     friend TMIArrayAsVectorIterator<T,Alloc>;
  607.  
  608. public:
  609.  
  610.     TMIArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  611.         TIArrayAsVectorImp<TMICVectorImp<T,Alloc>,T>( upper, lower, delta )
  612.         {
  613.         }
  614.  
  615.     int AddAt( T *t, int loc )
  616.         {
  617.         return Data.AddAt( t, ZeroBase(loc) );
  618.         }
  619.  
  620. #if defined( BI_OLDNAMES )
  621.     int addAt( T *t, int loc ) { return AddAt(t,loc); }
  622. #endif
  623.  
  624. };
  625.  
  626. template <class T, class Alloc> class TMIArrayAsVectorIterator :
  627.     public TMICVectorIteratorImp<T,Alloc>
  628. {
  629.  
  630. public:
  631.  
  632.     TMIArrayAsVectorIterator( const TMIArrayAsVector<T,Alloc>& a ) :
  633.         TMICVectorIteratorImp<T,Alloc>( a.Data ) {}
  634.  
  635. };
  636.  
  637. #if defined( BI_OLDNAMES )
  638. #define BI_MIArrayAsVector TMIArrayAsVector
  639. #define BI_MIArrayAsVectorIterator TMIArrayAsVectorIterator
  640. #endif
  641.  
  642. /*------------------------------------------------------------------------*/
  643. /*                                                                        */
  644. /*  template <class T> class TIArrayAsVector                              */
  645. /*  template <class T> class TIArrayAsVectorIterator                      */
  646. /*                                                                        */
  647. /*  Implements an indirect array of objects of type T, using a vector as  */
  648. /*  the underlying implementation and TStandardAllocator as its memory    */
  649. /*  manager.                                                              */
  650. /*                                                                        */
  651. /*------------------------------------------------------------------------*/
  652.  
  653. template <class T> class TIArrayAsVector :
  654.     public TMIArrayAsVector<T,TStandardAllocator>
  655. {
  656.  
  657. public:
  658.  
  659.     TIArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  660.         TMIArrayAsVector<T,TStandardAllocator>( upper, lower, delta )
  661.         {
  662.         }
  663.  
  664. };
  665.  
  666. template <class T> class TIArrayAsVectorIterator :
  667.     public TMIArrayAsVectorIterator<T,TStandardAllocator>
  668. {
  669.  
  670. public:
  671.  
  672.     TIArrayAsVectorIterator( const TIArrayAsVector<T>& a ) :
  673.         TMIArrayAsVectorIterator<T,TStandardAllocator>(a)
  674.         {
  675.         }
  676.  
  677. };
  678.  
  679. #if defined( BI_OLDNAMES )
  680. #define BI_IArrayAsVector TIArrayAsVector
  681. #define BI_IArrayAsVectorIterator TIArrayAsVectorIterator
  682. #endif
  683.  
  684. /*------------------------------------------------------------------------*/
  685. /*                                                                        */
  686. /*  template <class T,class Alloc> class TMISArrayAsVector                */
  687. /*  template <class T,class Alloc> class TMISArrayAsVectorIterator        */
  688. /*                                                                        */
  689. /*  Implements a managed, indirect sorted array of objects of type T,     */
  690. /*  using a vector as the underlying implementation.                      */
  691. /*                                                                        */
  692. /*------------------------------------------------------------------------*/
  693.  
  694. template <class T, class Alloc> class TMISArrayAsVectorIterator;
  695.  
  696. template <class T, class Alloc> class TMISArrayAsVector :
  697.     public TIArrayAsVectorImp<TMISVectorImp<T,Alloc>,T>
  698. {
  699.  
  700.     friend TMISArrayAsVectorIterator<T,Alloc>;
  701.  
  702. public:
  703.  
  704.     TMISArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  705.         TIArrayAsVectorImp<TMISVectorImp<T,Alloc>,T>( upper, lower, delta )
  706.         {
  707.         }
  708.  
  709. };
  710.  
  711. template <class T, class Alloc> class TMISArrayAsVectorIterator :
  712.     public TMISVectorIteratorImp<T,Alloc>
  713. {
  714.  
  715. public:
  716.  
  717.     TMISArrayAsVectorIterator( const TMISArrayAsVector<T,Alloc>& a ) :
  718.         TMISVectorIteratorImp<T,Alloc>( a.Data ) {}
  719.  
  720. };
  721.  
  722. #if defined( BI_OLDNAMES )
  723. #define BI_MISArrayAsVector TMISArrayAsVector
  724. #define BI_MIArrayAsVectorIterator TMIArrayAsVectorIterator
  725. #endif
  726.  
  727. /*------------------------------------------------------------------------*/
  728. /*                                                                        */
  729. /*  template <class T> class TISArrayAsVector                             */
  730. /*  template <class T> class TISArrayAsVectorIterator                     */
  731. /*                                                                        */
  732. /*  Implements an indirect sorted array of objects of type T, using a     */
  733. /*  vector as the underlying implementation and TStandardAllocator as its */
  734. /*  memory manager.                                                       */
  735. /*                                                                        */
  736. /*------------------------------------------------------------------------*/
  737.  
  738. template <class T> class TISArrayAsVector :
  739.     public TMISArrayAsVector<T,TStandardAllocator>
  740. {
  741.  
  742. public:
  743.  
  744.     TISArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
  745.         TMISArrayAsVector<T,TStandardAllocator>( upper, lower, delta )
  746.         {
  747.         }
  748.  
  749. };
  750.  
  751. template <class T> class TISArrayAsVectorIterator :
  752.     public TMISArrayAsVectorIterator<T,TStandardAllocator>
  753. {
  754.  
  755. public:
  756.  
  757.     TISArrayAsVectorIterator( const TISArrayAsVector<T>& a ) :
  758.         TMISArrayAsVectorIterator<T,TStandardAllocator>(a)
  759.         {
  760.         }
  761.  
  762. };
  763.  
  764. #if defined( BI_OLDNAMES )
  765. #define BI_ISArrayAsVector TISArrayAsVector
  766. #define BI_ISArrayAsVectorIterator TISArrayAsVectorIterator
  767. #endif
  768.  
  769. /*------------------------------------------------------------------------*/
  770. /*                                                                        */
  771. /*  template <class T> class TArray                                       */
  772. /*  template <class T> class TArrayIterator                               */
  773. /*                                                                        */
  774. /*  Easy names for TArrayAsVector and TArrayAsVectorIterator              */
  775. /*                                                                        */
  776. /*------------------------------------------------------------------------*/
  777.  
  778. template <class T> class TArray :
  779.     public TArrayAsVector<T>
  780. {
  781.  
  782. public:
  783.  
  784.     TArray( int upper, int lower = 0, int delta = 0 ) :
  785.         TArrayAsVector<T>( upper, lower, delta )
  786.         {
  787.         }
  788.  
  789. };
  790.  
  791. template <class T> class TArrayIterator :
  792.     public TArrayAsVectorIterator<T>
  793. {
  794.  
  795. public:
  796.  
  797.  
  798.     TArrayIterator( const TArray<T>& a ) :
  799.         TArrayAsVectorIterator<T>(a)
  800.         {
  801.         }
  802.  
  803. };
  804.  
  805. /*------------------------------------------------------------------------*/
  806. /*                                                                        */
  807. /*  template <class T> class TSArray                                      */
  808. /*  template <class T> class TSArrayIterator                              */
  809. /*                                                                        */
  810. /*  Easy names for TSArrayAsVector and TSArrayAsVectorIterator            */
  811. /*                                                                        */
  812. /*------------------------------------------------------------------------*/
  813.  
  814. template <class T> class TSArray :
  815.     public TSArrayAsVector<T>
  816. {
  817.  
  818. public:
  819.  
  820.     TSArray( int upper, int lower = 0, int delta = 0 ) :
  821.         TSArrayAsVector<T>( upper, lower, delta )
  822.         {
  823.         }
  824.  
  825. };
  826.  
  827. template <class T> class TSArrayIterator :
  828.     public TSArrayAsVectorIterator<T>
  829. {
  830.  
  831. public:
  832.  
  833.  
  834.     TSArrayIterator( const TSArray<T>& a ) :
  835.         TSArrayAsVectorIterator<T>(a)
  836.         {
  837.         }
  838.  
  839. };
  840.  
  841. #if defined( BI_CLASSLIB_NO_po )
  842. #pragma option -po.
  843. #endif
  844.  
  845. #pragma option -Vo.
  846.  
  847. #endif  // CLASSLIB_ARRAYS_H
  848.  
  849.