home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 10 / ioProg_10.iso / soft / optima / hpp.z / WMVECTOR.HPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-30  |  9.9 KB  |  356 lines
  1.  
  2. #ifndef _WMVECTOR_HPP_INCLUDED
  3. #define _WMVECTOR_HPP_INCLUDED
  4.  
  5. #ifndef _WNO_PRAGMA_PUSH
  6. #pragma pack(push,4);
  7. #pragma enum int;
  8. #endif
  9.  
  10. #ifndef _WVECTOR_HPP_INCLUDED
  11. #include "wvector.hpp"
  12. #endif
  13.  
  14. class WBaseSemaphore;
  15.  
  16. //-------------------------------------------------------------------
  17. //
  18. // WMTVectorBase
  19. //
  20. // The base class for our simple container class.  It holds a list
  21. // of pointers to WObject.  This version is thread-safe (but slower).
  22. //
  23. // Note that for certain operations (like GetCount) you should first
  24. // lock the list.  You'll want to do this anyhow in case you need
  25. // to manipulate the list.
  26. //
  27. //-------------------------------------------------------------------
  28.  
  29. class WCMCLASS WMTVectorBase : public WVectorBase {
  30.  
  31.     public:
  32.         /**********************************************************
  33.          * Methods
  34.          **********************************************************/
  35.  
  36.         // Lock
  37.         //
  38.         // Force a lock on the list.  Note that you are responsible
  39.         // for unlocking it!.
  40.  
  41.         WBool Lock() const;
  42.  
  43.         // Unlock
  44.         //
  45.         // Unlock the list.
  46.  
  47.         WBool Unlock() const;
  48.  
  49.         /**********************************************************
  50.          * Overrides
  51.          **********************************************************/
  52.  
  53.         virtual int      Append( WObject * );
  54.         virtual void     Clear( WBool force=FALSE );
  55.         virtual int      Index( WObject * ) const;
  56.         virtual int      Insert( int, WObject * );
  57.         virtual WObject *Remove( WObject * );
  58.         virtual WObject *RemoveAt( int index );
  59.  
  60.     protected:
  61.         WMTVectorBase( WBool destroyObjects=FALSE );
  62.  
  63.         ~WMTVectorBase();
  64.  
  65.         WBool operator==( const WVectorBase& ) const;
  66.  
  67.         WBool operator==( const WMTVectorBase& ) const;
  68.  
  69.         WObject * operator[]( int index ) const;
  70.  
  71.         void Copy( const WVectorBase& );
  72.  
  73.         void Copy( const WMTVectorBase& );
  74.  
  75.         virtual WBool Equal( const WObject * l, const WObject * r ) const;
  76.  
  77.     protected:
  78.  
  79.         WBaseSemaphore *_mutex;
  80. };
  81.  
  82. //-----------------------------------------------------------------
  83. //
  84. // WMTVector
  85. //
  86. // Templated class for holding pointers to WObject derived classes.
  87. //
  88. //-----------------------------------------------------------------
  89.  
  90. template<class T>
  91. class WCMCLASS WMTVector : public WMTVectorBase {
  92.      
  93.     public: 
  94.  
  95.         WMTVector( WBool destroyObjects=FALSE );
  96.       
  97.         WMTVector( const WVector<T>& );
  98.         
  99.         WMTVector( const WMTVector<T>& );
  100.         
  101.         WMTVector<T>& operator=( const WVector<T>& );
  102.       
  103.         WMTVector<T>& operator=( const WMTVector<T>& );
  104.       
  105.         WBool operator==( const WVector<T>& ) const;
  106.  
  107.         WBool operator==( const WMTVector<T>& ) const;
  108.         
  109.         WBool operator!=( const WVector<T>& ) const;
  110.  
  111.         WBool operator!=( const WMTVector<T>& ) const;
  112.         
  113.         /**************************************************************
  114.          * Overrides
  115.          **************************************************************/
  116.  
  117.         T * operator[]( int index ) const
  118.                 { return (T *)WMTVectorBase::operator[]( index ); }
  119.  
  120.         T * Remove( WObject * obj );
  121.  
  122.         T * RemoveAt( int index );
  123.  
  124.     protected:
  125.         virtual WBool Equal( const WObject * lhs, const WObject * rhs ) const;
  126. };
  127.  
  128. template<class T>
  129. WMTVector<T>::WMTVector( WBool destroyObjects )
  130.     : WMTVectorBase( destroyObjects ) {
  131. }
  132.  
  133. template<class T>
  134. WMTVector<T>::WMTVector( const WVector<T>& rhs )
  135.     : WMTVectorBase( false ) {
  136.     Copy( (const WVectorBase&) rhs );
  137. }
  138.  
  139. template<class T>
  140. WMTVector<T>::WMTVector( const WMTVector<T>& rhs )
  141.     : WMTVectorBase( false ) {
  142.     Copy( (const WMTVectorBase&) rhs );
  143. }
  144.  
  145. template<class T>
  146. WMTVector<T>& WMTVector<T>::operator=( const WVector<T>& rhs ) {
  147.     Copy( (const WVectorBase&) rhs );
  148.     return *this;
  149. }
  150.  
  151. template<class T>
  152. WMTVector<T>& WMTVector<T>::operator=( const WMTVector<T>& rhs ) {
  153.     Copy( (const WMTVectorBase&) rhs );
  154.     return *this;
  155. }
  156.  
  157. template<class T>
  158. WBool WMTVector<T>::operator==( const WVector<T>& rhs ) const {
  159.     return WMTVectorBase::operator==( (const WVectorBase&) rhs );
  160. }
  161.  
  162. template<class T>
  163. WBool WMTVector<T>::operator==( const WMTVector<T>& rhs ) const {
  164.     return WMTVectorBase::operator==( (const WMTVectorBase&) rhs );
  165. }
  166.  
  167. template<class T>
  168. WBool WMTVector<T>::operator!=( const WVector<T>& rhs ) const {
  169.     return !operator==( rhs );
  170. }
  171.  
  172. template<class T>
  173. WBool WMTVector<T>::operator!=( const WMTVector<T>& rhs ) const {
  174.     return !operator==( rhs );
  175. }
  176.  
  177. template<class T>
  178. WBool WMTVector<T>::Equal( const WObject * lhs, const WObject * rhs ) const {
  179.         return (WBool)( *(T *)lhs == *(T *)rhs );
  180. }
  181.  
  182. template<class T>
  183. T * WMTVector<T>::Remove( WObject * obj ) {
  184.     return (T *)WMTVectorBase::Remove( obj );
  185. }
  186.  
  187. template<class T>
  188. T * WMTVector<T>::RemoveAt( int index ) {
  189.     return (T *)WMTVectorBase::RemoveAt( index );
  190. }
  191.  
  192. //-----------------------------------------------------------------
  193. //
  194. // WMTSortableVector
  195. //
  196. // A sortable version of WMTVector.
  197. //
  198. //-----------------------------------------------------------------
  199.  
  200. template<class T>
  201. class WCMCLASS WMTSortableVector : public WMTVector<T> {
  202.      
  203.     public:
  204.         typedef WBool WCMDEF (*WMTVectorIterateRoutine )( const T *obj,
  205.                                                           void *userData );
  206.  
  207.         typedef int WCMDEF (*WMTVectorCompareRoutine)( const T *lhs,
  208.                                                        const T *rhs );
  209.  
  210.         typedef int WCMDEF (*WMTVectorBSearchRoutine)( const T *obj,
  211.                                                        void *userData );
  212.  
  213.     public: 
  214.         WMTSortableVector( WBool destroyObjects=FALSE );
  215.       
  216.         WMTSortableVector( const WVector<T>& );
  217.         
  218.         WMTSortableVector( const WMTVector<T>& );
  219.         
  220.         WMTSortableVector<T>& operator=( const WVector<T>& );
  221.       
  222.         WMTSortableVector<T>& operator=( const WMTVector<T>& );
  223.       
  224.         WBool operator==( const WVector<T>& ) const;
  225.  
  226.         WBool operator==( const WMTVector<T>& ) const;
  227.         
  228.         WBool operator!=( const WVector<T>& ) const;
  229.  
  230.         WBool operator!=( const WMTVector<T>& ) const;
  231.         
  232.         /**************************************************************
  233.          * Methods
  234.          **************************************************************/
  235.  
  236.         // BSearch
  237.         //
  238.         // Does a binary search the list (must be sorted).  Pass in
  239.         // a user-defined comparison function, which must return -1, 0
  240.         // or 1 (as with the bsearch function). No default behaviour
  241.         // is supplied.
  242.  
  243.         T * BSearch( WMTVectorBSearchRoutine routine, void *userData );
  244.  
  245.         // Iterate
  246.         //
  247.         // Iterate through the list, calling a user-defined function
  248.         // each time through.  The user-defined function should return
  249.         // TRUE if the iteration should continue.
  250.  
  251.         void Iterate( WMTVectorIterateRoutine routine, void *userData=NULL );
  252.  
  253.         // Sort
  254.         //
  255.         // Sorts the vector.  A user-supplied comparison routine can
  256.         // be used (should return -1, 0 or 1 as used with qsort) or
  257.         // if none is provided comparison is done using the
  258.         // CompareToSelf method of the objects.
  259.  
  260.         void Sort( WMTVectorCompareRoutine routine=NULL );
  261.  
  262.     protected:
  263.         static int DefaultCompare( const T *lhs, const T *rhs );
  264. };
  265.  
  266. template<class T>
  267. WMTSortableVector<T>::WMTSortableVector( WBool destroyObjects )
  268.     : WMTVector( destroyObjects ) {
  269. }
  270.  
  271. template<class T>
  272. WMTSortableVector<T>::WMTSortableVector( const WVector<T>& rhs )
  273.     : WMTVector( rhs ) {
  274. }
  275.  
  276. template<class T>
  277. WMTSortableVector<T>::WMTSortableVector( const WMTVector<T>& rhs )
  278.     : WMTVector( rhs ) {
  279. }
  280.  
  281. template<class T>
  282. WMTSortableVector<T>& WMTSortableVector<T>::operator=( const WVector<T>& rhs ) {
  283.     Copy( (const WVectorBase&) rhs );
  284.     return *this;
  285. }
  286.  
  287. template<class T>
  288. WMTSortableVector<T>& WMTSortableVector<T>::operator=( const WMTVector<T>& rhs ) {
  289.     Copy( (const WMTVectorBase&) rhs );
  290.     return *this;
  291. }
  292.  
  293. template<class T>
  294. WBool WMTSortableVector<T>::operator==( const WVector<T>& rhs ) const {
  295.     return WMTVector<T>::operator==( rhs );
  296. }
  297.  
  298. template<class T>
  299. WBool WMTSortableVector<T>::operator==( const WMTVector<T>& rhs ) const {
  300.     return WMTVector<T>::operator==( rhs );
  301. }
  302.  
  303. template<class T>
  304. WBool WMTSortableVector<T>::operator!=( const WVector<T>& rhs ) const {
  305.     return !operator==( rhs );
  306. }
  307.  
  308. template<class T>
  309. WBool WMTSortableVector<T>::operator!=( const WMTVector<T>& rhs ) const {
  310.     return !operator==( rhs );
  311. }
  312.  
  313. template<class T>
  314. T * WMTSortableVector<T>::BSearch( WMTVectorBSearchRoutine routine,
  315.                                    void *userData ) {
  316.     if( !routine ) return NULL;
  317.     Lock();
  318.     T * o = (T *) DoBSearch( (WVectorBaseBSearchRoutine) routine,
  319.                                userData );
  320.     Unlock();
  321.     return o;
  322. }
  323.  
  324. template<class T>
  325. void WMTSortableVector<T>::Iterate( WMTVectorIterateRoutine routine,
  326.                                     void *userData ) {
  327.     if( !routine ) return;
  328.     Lock();
  329.     DoIterate( (WVectorBaseIterateRoutine) routine, userData );
  330.     Unlock();
  331. }
  332.  
  333. template<class T>
  334. void WMTSortableVector<T>::Sort( WMTVectorCompareRoutine routine ) {
  335.     if( !routine ) routine = DefaultCompare;
  336.     Lock();
  337.     DoSort( (WVectorBaseCompareRoutine) routine );
  338.     Unlock();
  339. }
  340.  
  341. template<class T>
  342. static int WMTSortableVector<T>::DefaultCompare( const T *lhp, const T *rhp )
  343. {
  344.     const T & lhs( *lhp );
  345.     const T & rhs( *rhp );
  346.  
  347.     return lhs.CompareToSelf( rhs );
  348. }
  349.  
  350. #ifndef _WNO_PRAGMA_PUSH
  351. #pragma enum pop;
  352. #pragma pack(pop);
  353. #endif
  354.  
  355. #endif // _WMVECTOR_HPP_INCLUDED
  356.