home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 February / PCWorld_2000-02_cd.bin / Software / TemaCD / tcvpa / data1.cab / MyFileGroup / INCLUDE / Array.hpp next >
C/C++ Source or Header  |  1999-06-03  |  15KB  |  599 lines
  1. #ifndef _INC_ARRAY_HPP
  2. #define _INC_ARRAY_HPP
  3. #ifdef BUILD_TCCORE
  4. #define TCCORELIB __declspec(dllexport)
  5. #else
  6. #ifdef BUILD_LOCAL
  7. #define TCCORELIB
  8. #else
  9. #define TCCORELIB __declspec(dllimport)
  10. #endif
  11. #endif
  12.  
  13. // **********************************************************************
  14. class TCCORELIB TC_C_Array 
  15. {
  16. private:  char* pData ;
  17. private:  int m_CountUsed ;
  18. private:  int m_CountAlloc ;
  19. private:  int m_ItemSize ;
  20. private:  int m_Grow ;
  21. private:  void _Realloc (int new_num)  ;
  22. public:  void _ReplaceItem (int idx,void*ptr)  ;
  23. public:  void _AddMore (void *ptr,int add_itms)  ;
  24. public:  void _SetBound (int n_items)  ;
  25. public:  void _AddPtr (void *ptr)  ;
  26. public:  int _IndexOfPtr (void *p)  ;
  27. public:  int _InsertPtr (int idx, void *ptr)  ;
  28. public:  void _Remove (int idx)  ;
  29. public:  void _Truncate ()  ;
  30. public:   TC_C_Array (int item_size)  ;
  31. public: virtual  ~TC_C_Array ()  ;
  32. public:  void SetGrow (int grow)  ;
  33. public:  BOOL Swap (int dst,int src,int num=1)  ;
  34. public:  BOOL ValidIndex (int idx) 
  35. {
  36. return ( ((UINT)idx) < (UINT)m_CountUsed );
  37. } // end of func
  38. // **********************************************************************
  39.  
  40. public:  char* _PData () 
  41. {
  42. return pData;
  43. } // end of func
  44. // **********************************************************************
  45.  
  46. public:  int Count () const
  47. {
  48. return m_CountUsed;
  49. } // end of func
  50. // **********************************************************************
  51.  
  52. public:  int SizeOfItem ()  ;
  53.  
  54. }; // end of class TC_C_Array
  55.  
  56. // **********************************************************************
  57.  
  58. // **********************************************************************
  59.  template <class T>
  60. class TC_TArrayPTR 
  61.     : public TC_C_Array
  62. {
  63. public:  BOOL bDeleteAll ;
  64. public:   TC_TArrayPTR () 
  65. : TC_C_Array( sizeof(void*) )
  66. {
  67. bDeleteAll = 0;
  68. } // end of func
  69. // **********************************************************************
  70.  
  71. public: virtual  ~TC_TArrayPTR () 
  72. {
  73. if( bDeleteAll ) DeleteAll();
  74. } // end of func
  75. // **********************************************************************
  76.  
  77. public:  int IndexOf (T *ptr,int start=0) 
  78. {
  79. for( int idx=start; idx < Count(); idx++ )
  80.  if( Get(idx) == ptr )
  81.   return idx;
  82. return -1;
  83. } // end of func
  84. // **********************************************************************
  85.  
  86. public:  int Add (T *ptr) 
  87. {
  88. _AddPtr( (ptr) ? (void*)&ptr : 0  );
  89. return Count()-1;
  90. } // end of func
  91. // **********************************************************************
  92.  
  93. public:  int AddUnq (T *ptr) 
  94. {
  95. int idx = IndexOf(ptr);
  96. if( idx >= 0 ) return idx;
  97. Add(ptr);
  98. return Count()-1;
  99. } // end of func
  100. // **********************************************************************
  101.  
  102. public:  int Insert (int idx, T *ptr) 
  103. {
  104. return _InsertPtr( idx, (ptr) ? (void*)&ptr : 0 );
  105. } // end of func
  106. // **********************************************************************
  107.  
  108. public:  T* Get (int idx) 
  109. {
  110. if( ValidIndex(idx) ) return (T*)(((void**)_PData())[idx]);
  111. return 0;
  112. } // end of func
  113. // **********************************************************************
  114.  
  115. public:  void Remove (int idx) 
  116. {
  117. _Remove( idx );
  118. } // end of func
  119. // **********************************************************************
  120.  
  121. public:  void Remove (T *ptr) 
  122. {
  123. _Remove( IndexOf(ptr) );
  124. } // end of func
  125. // **********************************************************************
  126.  
  127. public:  void Replace (int idx, T *ptr) 
  128. {
  129. if( !ValidIndex(idx) ) return;
  130. ((void**)_PData())[idx] = (void*)ptr;
  131. } // end of func
  132. // **********************************************************************
  133.  
  134. public:  void Delete (int idx) 
  135. {
  136. if( !ValidIndex(idx) ) return;
  137. T * ptr = ((T**)_PData())[idx];
  138. if(ptr) delete ptr;
  139. if( ((T**)_PData())[idx] == ptr ) Remove(idx);
  140. } // end of func
  141. // **********************************************************************
  142.  
  143. public:  void Delete (T *ptr) 
  144. {
  145. Delete( IndexOf(ptr) );
  146. } // end of func
  147. // **********************************************************************
  148.  
  149. public:  void DeleteAll () 
  150. {
  151. while( Count() ) Delete( Count()-1 );
  152. } // end of func
  153. // **********************************************************************
  154.  
  155. public:  void Truncate () 
  156. {
  157. _Truncate();
  158. } // end of func
  159. // **********************************************************************
  160.  
  161. public:  T* PLast () 
  162. {
  163. return Get(Count()-1);
  164. } // end of func
  165. // **********************************************************************
  166.  
  167. public:  T& operator [] (int idx) 
  168. {
  169. T * ptr = Get(idx);
  170. assert( "TC_TArrayPTR::operator []()" && ptr != 0 );
  171. return *ptr;
  172. } // end of func
  173. // **********************************************************************
  174.  
  175.  
  176. }; // end of class TC_TArrayPTR
  177.  
  178. // **********************************************************************
  179.  
  180. // **********************************************************************
  181.  template <class T>
  182. class TC_TArrayC 
  183.     : public TC_C_Array
  184. {
  185. public:  BOOL bAutoExpand ;
  186. public:   TC_TArrayC () 
  187. : TC_C_Array( sizeof(T) )
  188. {
  189. bAutoExpand = 0;
  190. } // end of func
  191. // **********************************************************************
  192.  
  193. public:  TC_TArrayC <T> & operator = (const TC_TArrayC <T> & src_) 
  194. {
  195. TC_TArrayC <T> * src = (TC_TArrayC <T> *)&src_;
  196. if( src == this ) return (*this);
  197. Truncate();
  198. _SetBound( src->Count() );
  199. memcpy( _PData(), src->_PData(), Count() * sizeof(T) );
  200. return (*this);
  201. } // end of func
  202. // **********************************************************************
  203.  
  204. public:  T& operator [] (int idx) 
  205. {
  206. if( idx < 0 )
  207. {
  208.     assert("TC_TArrayC::operator []()" && idx >= 0 );
  209.     return ((T*)0)[0];
  210. }
  211.  
  212. if( idx >= Count() )
  213. {
  214.     if( !bAutoExpand )
  215.     {
  216.         assert("TC_TArrayC::operator []()" && idx < Count() );
  217.         return ((T*)0)[0];
  218.     }
  219.     _SetBound(idx+1);
  220. }
  221.  
  222. return ((T*)_PData())[idx];
  223. } // end of func
  224. // **********************************************************************
  225.  
  226. public:  int IndexOf (T val) 
  227. {
  228. return _IndexOfPtr(&val);
  229. /*
  230. for( int ret = 0; ret < Count(); ret++ )
  231. {
  232.     if( ((T*)_PData())[ret] == val ) return ret;
  233.     //if( !memcmp( ((T*)_PData())+ret, &val, sizeof(T) ) ) return ret;
  234. }
  235. return -1;
  236. */
  237. } // end of func
  238. // **********************************************************************
  239.  
  240. public:  T& Last () 
  241. {
  242. assert( "TC_TArrayC::Last()" && Count() > 0 );
  243. return ((T*)_PData())[Count()-1];
  244. } // end of func
  245. // **********************************************************************
  246.  
  247. public:  int Add (T val) 
  248. {
  249. _AddPtr( &val );
  250. return Count()-1;
  251. } // end of func
  252. // **********************************************************************
  253.  
  254. public:  int Add () 
  255. {
  256. _AddPtr( 0 );
  257. return Count()-1;
  258. } // end of func
  259. // **********************************************************************
  260.  
  261. public:  void AddUnq (T val) 
  262. {
  263. if( IndexOf(val) < 0 ) Add(val);
  264. } // end of func
  265. // **********************************************************************
  266.  
  267. public:  int Insert (int idx, T val) 
  268. {
  269. return _InsertPtr( idx, &val );
  270. } // end of func
  271. // **********************************************************************
  272.  
  273. public:  int Insert (int idx) 
  274. {
  275. return _InsertPtr( idx, NULL );
  276. } // end of func
  277. // **********************************************************************
  278.  
  279. public:  void SetVals (T val) 
  280. {
  281. for( int cnt=0; cnt < Count(); cnt++ ) ((T*)_PData())[cnt] = val;
  282. } // end of func
  283. // **********************************************************************
  284.  
  285. public:  void Remove (int idx) 
  286. {
  287. _Remove(idx);
  288. } // end of func
  289. // **********************************************************************
  290.  
  291. public:  void Truncate () 
  292. {
  293. _Truncate();
  294. } // end of func
  295. // **********************************************************************
  296.  
  297. public:  void SetBound (int size) 
  298. {
  299. if( size < 0 ) size = 0;
  300. if( size == Count() ) return;
  301. if( size < Count() )
  302. {
  303.     while( size < Count() ) Remove(Count()-1);
  304.     return;
  305. }
  306.  
  307. while( size > Count() ) Add();
  308. } // end of func
  309. // **********************************************************************
  310.  
  311.  
  312. }; // end of class TC_TArrayC
  313.  
  314. // **********************************************************************
  315. class _TC_CSandwichObject
  316. {
  317. public:
  318. void * ptr;
  319.     _TC_CSandwichObject( void *p ) { ptr = p; }
  320. };
  321.  
  322. inline void * operator new ( size_t, _TC_CSandwichObject & s )
  323. {
  324.     return s.ptr;
  325. }
  326.  
  327. // **********************************************************************
  328.  template <class T>
  329. class TC_TArrayCPP 
  330.     : public TC_C_Array
  331. {
  332. public:  BOOL bAutoExpand ;
  333. public:   TC_TArrayCPP () 
  334. : TC_C_Array( sizeof(T) )
  335. {
  336. bAutoExpand = 0;
  337. } // end of func
  338. // **********************************************************************
  339.  
  340. public:  TC_TArrayCPP <T> & operator = (const TC_TArrayCPP <T> & src_) 
  341. {
  342. TC_TArrayCPP <T> * src = (TC_TArrayCPP <T> *)&src_;
  343. if( src == this ) return (*this);
  344. DeleteAll();
  345.  
  346. for( int cnt=0; cnt < src->Count(); cnt++ )
  347. {
  348.     Add();
  349.     Last() = (*src)[cnt];
  350. }
  351.  
  352. return (*this);
  353. } // end of func
  354. // **********************************************************************
  355.  
  356. public:   ~TC_TArrayCPP () 
  357. {
  358. DeleteAll();
  359. } // end of func
  360. // **********************************************************************
  361.  
  362. public:  T& operator [] (int idx) 
  363. {
  364. if( idx < 0 )
  365. {
  366.     assert("TC_TArrayCPP::operator []()" && idx >= 0 );
  367.     return ((T*)0)[0];
  368. }
  369.  
  370. if( idx >= Count() )
  371. {
  372.     if( !bAutoExpand )
  373.     {
  374.         assert("TC_TArrayCPP::operator []()" && idx < Count() );
  375.         return ((T*)0)[0];
  376.     }
  377.     while( Count() <= idx ) Add();
  378. }
  379.  
  380. return ((T*)_PData())[idx];
  381. } // end of func
  382. // **********************************************************************
  383.  
  384. public:  T& Last () 
  385. {
  386. assert( "TC_TArrayCPP::Last()" && Count() > 0 );
  387. return ((T*)_PData())[Count()-1];
  388. } // end of func
  389. // **********************************************************************
  390.  
  391. public:  int Add () 
  392. {
  393. /*_AddPtr( _GetObject() );
  394. return Count()-1;*/
  395.  
  396. _AddPtr( 0 );
  397. _TC_CSandwichObject d( _PData() + sizeof(T)*(Count()-1) );
  398. new (d) T();
  399. return Count()-1;
  400. } // end of func
  401. // **********************************************************************
  402.  
  403. public:  int Insert (int idx) 
  404. {
  405. /*return _InsertPtr( idx, _GetObject() );*/
  406.  
  407. idx = _InsertPtr( idx, 0 );
  408. _TC_CSandwichObject d( _PData() + sizeof(T)*idx );
  409. new (d) T();
  410. return idx;
  411. } // end of func
  412. // **********************************************************************
  413.  
  414. public:  void Delete (int idx) 
  415. {
  416. if( !ValidIndex(idx) ) return;
  417. /*{ T obj; memcpy( &obj, ((T*)_PData()) + idx, sizeof(T) ); }*/
  418.  
  419. ((T*)(_PData() + idx*sizeof(T))) -> ~T();
  420.  
  421. _Remove(idx);
  422. } // end of func
  423. // **********************************************************************
  424.  
  425. public:  void DeleteAll () 
  426. {
  427. while( Count() ) Delete( Count()-1 );
  428. } // end of func
  429. // **********************************************************************
  430.  
  431. public:  void SetBound (int size) 
  432. {
  433. if( size < 0 ) size = 0;
  434. if( size == Count() ) return;
  435. if( size < Count() )
  436. {
  437.     while( size < Count() ) Delete(Count()-1);
  438.     return;
  439. }
  440.  
  441. while( size > Count() ) Add();
  442. } // end of func
  443. // **********************************************************************
  444.  
  445.  
  446. }; // end of class TC_TArrayCPP
  447.  
  448. // **********************************************************************
  449.  
  450. // **********************************************************************
  451. class TCCORELIB TC_CArrayString 
  452.     : public TC_TArrayCPP <TC_CString>
  453. {
  454. public:  int Add (LPCSTR str)  ;
  455. public:  int Add ()  ;
  456. public:  void Insert (int idx, LPCSTR str)  ;
  457. public:  int Insert (int idx)  ;
  458. public:  int IndexOf (LPCSTR str)  ;
  459. public:  int IndexOf_I (LPCSTR str)  ;
  460. public:  int AddUnq (LPCSTR str)  ;
  461. public:  int AddUnq_I (LPCSTR str)  ;
  462.  
  463. }; // end of class TC_CArrayString
  464.  
  465. // **********************************************************************
  466. typedef TC_TArrayC <signed char>    TCArrayCHAR;
  467. typedef TC_TArrayC <unsigned char>    TCArrayBYTE;
  468.  
  469. typedef TC_TArrayC <int>            TCArrayINT;
  470. typedef TC_TArrayC <unsigned>        TCArrayUINT;
  471.  
  472. typedef TC_TArrayC <short> TCArraySHORT;
  473. typedef TC_TArrayC <unsigned short> TCArrayUSHORT;
  474.  
  475. typedef TC_TArrayC <long> TCArrayLONG;
  476. typedef TC_TArrayC <unsigned long> TCArrayULONG;
  477.  
  478. typedef TC_TArrayC <float> TCArrayFLOAT;
  479. typedef TC_TArrayC <double> TCArrayDOUBLE;
  480.  
  481. typedef TC_TArrayC <char*> TCArrayPCHAR;
  482. typedef TC_TArrayC <void*> TCArrayPVOID;
  483.  
  484.  
  485. #define TCArrayUCHAR    TCArrayBYTE
  486. #define TCArrayDWORD    TCArrayULONG
  487. //**************************************************** void* + void*
  488. struct TC_PtrPtr
  489. {
  490.     void * p1;
  491.     void * p2;
  492.     TC_PtrPtr() { p1=p2=0; }
  493. };
  494. typedef TC_TArrayCPP <TC_PtrPtr> TCArrayPtrPtr;
  495. //**************************************************** Str + Str
  496. struct TC_StrStr
  497. {
  498.     TC_CString s1;
  499.     TC_CString s2;
  500.     TC_StrStr& operator = (const TC_StrStr& src)
  501.     {
  502.         s1 = src.s1;
  503.         s2 = src.s2;
  504.         return *this;
  505.     }
  506. };
  507. typedef TC_TArrayCPP <TC_StrStr> TCArrayStrStr;
  508. //**************************************************** Str + Str + Str
  509. struct TC_StrStrStr
  510. {
  511.     TC_CString s1;
  512.     TC_CString s2;
  513.     TC_CString s3;
  514.     TC_StrStrStr& operator = (const TC_StrStrStr& src)
  515.     {
  516.         s1 = src.s1;
  517.         s2 = src.s2;
  518.         s3 = src.s3;
  519.         return *this;
  520.     }
  521. };
  522. typedef TC_TArrayCPP <TC_StrStrStr> TCArrayStrStrStr;
  523. //**************************************************** Str + Int
  524. struct TC_StrNum
  525. {
  526.     TC_CString str;
  527.     int num;
  528.     TC_StrNum() { num = 0; }
  529.     TC_StrNum& operator = (const TC_StrNum& src)
  530.     {
  531.         str = src.str;
  532.         num = src.num;
  533.         return *this;
  534.     }
  535. };
  536. typedef TC_TArrayCPP <TC_StrNum> TCArrayStrNum;
  537. //**************************************************** Str + Str + Int
  538. struct TC_StrStrNum
  539. {
  540.     TC_CString s1;
  541.     TC_CString s2;
  542.     int  num;
  543.     TC_StrStrNum() { num = 0; }
  544.     TC_StrStrNum& operator = (const TC_StrStrNum& src)
  545.     {
  546.         s1 = src.s1;
  547.         s2 = src.s2;
  548.         num = src.num;
  549.         return *this;
  550.     }
  551. };
  552. typedef TC_TArrayCPP <TC_StrStrNum> TCArrayStrStrNum;
  553. //**************************************************** Str + Int + Int
  554. struct TC_StrNumNum
  555. {
  556.     TC_CString str;
  557.     int  n1;
  558.     int  n2;
  559.     TC_StrNumNum() { n1 = n2 = 0; }
  560.     TC_StrNumNum& operator = (const TC_StrNumNum& src)
  561.     {
  562.         str = src.str;
  563.         n1 = src.n1;
  564.         n2 = src.n2;
  565.         return *this;
  566.     }
  567. };
  568. typedef TC_TArrayCPP <TC_StrNumNum> TCArrayStrNumNum;
  569. //**************************************************** Str + char[]
  570. struct TC_StrArr
  571. {
  572.     TC_CString str;
  573.     TCArrayCHAR arr;
  574.     TC_StrArr& operator = (const TC_StrArr& src)
  575.     {
  576.         str = src.str;
  577.         arr = src.arr;
  578.         return *this;
  579.     }
  580. };
  581. typedef TC_TArrayCPP <TC_StrArr> TCArrayStrArr;
  582. //**************************************************** Str + Str[]
  583. struct TC_StrArrStr
  584. {
  585.     TC_CString str;
  586.     TC_CArrayString as;
  587.     TC_StrArrStr& operator = (const TC_StrArrStr& src)
  588.     {
  589.         str = src.str;
  590.         as = src.as;
  591.         return *this;
  592.     }
  593. };
  594. typedef TC_TArrayCPP <TC_StrArrStr> TCArrayStrArrStr;
  595. //****************************************************
  596. TCCORELIB int tcTokenizeString (LPCSTR src, LPCSTR schr, TC_CArrayString &dst, BOOL trim=FALSE)  ;
  597.  
  598. #endif // _INC_ARRAY_HPP
  599.