home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tlx501.zip / PTRARRAY.INL < prev    next >
Text File  |  1996-01-05  |  11KB  |  310 lines
  1. /****************************************************************************
  2.     $Id: ptrarray.inl 1.1 1994/09/26 15:27:48 ron Exp $
  3.  
  4.     Copyright (c) 1991-94 Tarma Software Research. All rights reserved.
  5.  
  6.     Project:    Tarma Library for C++ V5.0
  7.     Author:    Ron van der Wal
  8.  
  9.     Inline functions belonging to ptrarray.h. You should not #include this
  10.     file directly.
  11.  
  12.     $Log: ptrarray.inl $
  13.     Revision 1.1  1994/09/26  15:27:48  ron
  14.     Initial revision
  15.     
  16. ****************************************************************************/
  17.  
  18. //----- TLPtrVector
  19.  
  20. template<class T> inline
  21. TLPtrVector<T> &TLPtrVector<T>::operator =(const TLPtrVector<T> &aVector)
  22.     { return (TLPtrVector<T> &)TLVPVector::operator =(aVector); }
  23.  
  24. template<class T> inline TLPtrVector<T> &TLPtrVector<T>::operator =(T *aPtr)
  25.     { return (TLPtrVector<T> &)TLVPVector::operator =(aPtr); }
  26.  
  27. template<class T> inline T *&TLPtrVector<T>::operator [](tIndex aIndex)
  28.     { return (T *&)TLVPVector::operator [](aIndex); }
  29.  
  30. template<class T> inline T *TLPtrVector<T>::operator [](tIndex aIndex) const
  31.     { return (T *)TLVPVector::operator [](aIndex); }
  32.  
  33. template<class T> inline T *&TLPtrVector<T>::PeekAt(tIndex aIndex)
  34.     { return (T *&)TLVPVector::PeekAt(aIndex); }
  35.  
  36. template<class T> inline T *TLPtrVector<T>::PeekAt(tIndex aIndex) const
  37.     { return (T *)TLVPVector::PeekAt(aIndex); }
  38.  
  39. template<class T> inline tIndex    TLPtrVector<T>::IndexOf(const T *aPtr) const
  40.     { return TLVPVector::IndexOf(aPtr); }
  41.  
  42. template<class T> inline T **TLPtrVector<T>::StorageVector() const
  43.     { return (T **)TLVPVector::StorageVector(); }
  44.  
  45. //-----    TLPtrArray
  46.  
  47. template<class T>
  48. inline TLPtrArray<T> &TLPtrArray<T>::operator =(const TLPtrArray<T> &aArray)
  49.     { return (TLPtrArray<T> &)TLVPArray::operator =(aArray); }
  50.  
  51. template<class T> inline TLPtrArray<T> &TLPtrArray<T>::operator =(T *aPtr)
  52.     { return (TLPtrArray<T> &)TLVPArray::operator =(aPtr); }
  53.  
  54. template<class T> inline T *&TLPtrArray<T>::operator [](tIndex aIndex)
  55.     { return (T *&)TLVPArray::operator [](aIndex); }
  56.  
  57. template<class T> inline T *TLPtrArray<T>::operator [](tIndex aIndex) const
  58.     { return (T *)TLVPArray::operator [](aIndex); }
  59.  
  60. template<class T> inline T *&TLPtrArray<T>::PeekAt(tIndex aIndex)
  61.     { return (T *&)TLVPArray::PeekAt(aIndex); }
  62.  
  63. template<class T> inline T *TLPtrArray<T>::PeekAt(tIndex aIndex) const
  64.     { return (T *)TLVPArray::PeekAt(aIndex); }
  65.  
  66. template<class T> inline tIndex TLPtrArray<T>::IndexOf(const T *aPtr) const
  67.     { return TLVPArray::IndexOf(aPtr); }
  68.  
  69. //-----    TLPtrSeq
  70.  
  71. template<class T>
  72. inline TLPtrSeq<T> &TLPtrSeq<T>::operator =(const TLPtrSeq<T> &aSeq)
  73.     { return (TLPtrSeq<T> &)TLVPSeq::operator =(aSeq); }
  74.  
  75. template<class T> inline TLPtrSeq<T> &TLPtrSeq<T>::operator =(T *aPtr)
  76.     { return (TLPtrSeq<T> &)TLVPSeq::operator =(aPtr); }
  77.  
  78. template<class T>
  79. inline TLPtrSeq<T> &TLPtrSeq<T>::operator +=(const TLPtrSeq<T> &aSeq)
  80.     { return (TLPtrSeq<T> &)TLVPSeq::operator +=(aSeq); }
  81.  
  82. template<class T> inline TLPtrSeq<T> &TLPtrSeq<T>::operator +=(T *aPtr)
  83.     { return (TLPtrSeq<T> &)TLVPSeq::operator +=(aPtr); }
  84.  
  85. template<class T> inline void TLPtrSeq<T>::Append(T *aPtr)
  86.     { TLVPSeq::Append(aPtr); }
  87.  
  88. template<class T> inline void TLPtrSeq<T>::Append(T **aVector, tSize aSize)
  89.     { TLVPSeq::Append((void **)aVector, aSize); }
  90.  
  91. template<class T> inline void TLPtrSeq<T>::Append(const TLPtrSeq<T> &aSeq)
  92.     { TLVPSeq::Append(aSeq); }
  93.  
  94. template<class T> inline void TLPtrSeq<T>::Prepend(T *aPtr)
  95.     { TLVPSeq::Prepend(aPtr); }
  96.  
  97. template<class T> inline void TLPtrSeq<T>::Prepend(T **aVector, tSize aSize)
  98.     { TLVPSeq::Prepend((void **)aVector, aSize); }
  99.  
  100. template<class T> inline void TLPtrSeq<T>::Prepend(const TLPtrSeq<T> &aSeq)
  101.     { TLVPSeq::Prepend(aSeq); }
  102.  
  103. template<class T> inline void TLPtrSeq<T>::Insert(T *aPtr)
  104.     { TLVPSeq::Insert(aPtr); }
  105.  
  106. template<class T> inline void TLPtrSeq<T>::InsertAt(tIndex aIndex, T *aPtr)
  107.     { TLVPSeq::InsertAt(aIndex, aPtr); }
  108.  
  109. template<class T>
  110. inline void TLPtrSeq<T>::InsertAt(tIndex aIndex, T **aVector, tSize aSize)
  111.     { TLVPSeq::InsertAt(aIndex, (void **)aVector, aSize); }
  112.  
  113. template<class T>
  114. inline void TLPtrSeq<T>::InsertAt(tIndex aIndex, const TLPtrSeq<T> &aSeq)
  115.     { TLVPSeq::InsertAt(aIndex, aSeq); }
  116.  
  117. template<class T> inline void TLPtrSeq<T>::Replace(tIndex aIndex, T *aPtr)
  118.     { TLVPSeq::Replace(aIndex, aPtr); }
  119.  
  120. template<class T>
  121. inline void TLPtrSeq<T>::Replace(tIndex aIndex, T **aVector, tSize aSize)
  122.     { TLVPSeq::Replace(aIndex, (void **)aVector, aSize); }
  123.  
  124. template<class T>
  125. inline void TLPtrSeq<T>::Replace(tIndex aIndex, const TLPtrSeq<T> &aSeq)
  126.     { TLVPSeq::Replace(aIndex, aSeq); }
  127.  
  128. template<class T> inline T *TLPtrSeq<T>::Extract(T *p)
  129.     { return (T *)TLVPSeq::Extract(p); }
  130.  
  131. template<class T> inline T *TLPtrSeq<T>::Extract(tIndex aIndex)
  132.     { return (T *)TLVPSeq::Extract(aIndex); }
  133.  
  134. template<class T> inline T *TLPtrSeq<T>::ExtractFirst()
  135.     { return (T *)TLVPSeq::ExtractFirst(); }
  136.  
  137. template<class T> inline T *TLPtrSeq<T>::ExtractLast()
  138.     { return (T *)TLVPSeq::ExtractLast(); }
  139.  
  140. template<class T> inline T *&TLPtrSeq<T>::operator [](tIndex aIndex)
  141.     { return (T *&)TLVPSeq::operator [](aIndex); }
  142.  
  143. template<class T> inline T *TLPtrSeq<T>::operator [](tIndex aIndex) const
  144.     { return (T *)TLVPSeq::operator [](aIndex); }
  145.  
  146. template<class T> inline T *&TLPtrSeq<T>::PeekAt(tIndex aIndex)
  147.     { return (T *&)TLVPSeq::PeekAt(aIndex); }
  148.  
  149. template<class T> inline T *TLPtrSeq<T>::PeekAt(tIndex aIndex) const
  150.     { return (T *)TLVPSeq::PeekAt(aIndex); }
  151.  
  152. template<class T> inline T *&TLPtrSeq<T>::PeekReverse(tIndex aIndex)
  153.     { return (T *&)TLVPSeq::PeekReverse(aIndex); }
  154.  
  155. template<class T> inline T *TLPtrSeq<T>::PeekReverse(tIndex aIndex) const
  156.     { return (T *)TLVPSeq::PeekReverse(aIndex); }
  157.  
  158. template<class T> inline T *&TLPtrSeq<T>::PeekFirst()
  159.     { return (T *&)TLVPSeq::PeekFirst(); }
  160.  
  161. template<class T> inline T *TLPtrSeq<T>::PeekFirst() const
  162.     { return (T *)TLVPSeq::PeekFirst(); }
  163.  
  164. template<class T> inline T *&TLPtrSeq<T>::PeekLast()
  165.     { return (T *&)TLVPSeq::PeekLast(); }
  166.  
  167. template<class T> inline T *TLPtrSeq<T>::PeekLast() const
  168.     { return (T *)TLVPSeq::PeekLast(); }
  169.  
  170. template<class T> inline bool TLPtrSeq<T>::Contains(T *p) const
  171.     { return TLVPSeq::Contains(p); }
  172.  
  173. template<class T> inline tIndex TLPtrSeq<T>::IndexOf(const T *aPtr) const
  174.     { return TLVPSeq::IndexOf(aPtr); }
  175.  
  176. template<class T>
  177. inline bool TLPtrSeq<T>::Search(const T *aPtr, tIndex &aIndex) const
  178.     { return TLVPSeq::Search(aPtr, aIndex); }
  179.  
  180. //-----    TLPtrQueue
  181.  
  182. template<class T>
  183. inline TLPtrQueue<T> &TLPtrQueue<T>::operator =(const TLPtrQueue<T> &q)
  184.     { return (TLPtrQueue<T> &)TLVPQueue::operator =(q); }
  185.  
  186. template<class T> inline TLPtrQueue<T> &TLPtrQueue<T>::operator =(T *p)
  187.     { return (TLPtrQueue<T> &)TLVPQueue::operator =(p); }
  188.  
  189. template<class T> inline void TLPtrQueue<T>::AddLeft(T *p)
  190.     { TLVPQueue::AddLeft(p); }
  191.  
  192. template<class T> inline void TLPtrQueue<T>::AddRight(T *p)
  193.     { TLVPQueue::AddRight(p); }
  194.  
  195. template<class T> inline T *TLPtrQueue<T>::ExtractLeft()
  196.     { return (T *)TLVPQueue::ExtractLeft(); }
  197.  
  198. template<class T> inline T *TLPtrQueue<T>::ExtractRight()
  199.     { return (T *)TLVPQueue::ExtractRight(); }
  200.  
  201. template<class T> inline T *&TLPtrQueue<T>::PeekLeft()
  202.     { return (T *&)TLVPQueue::PeekLeft(); }
  203.  
  204. template<class T> inline T *TLPtrQueue<T>::PeekLeft() const
  205.     { return (T *)TLVPQueue::PeekLeft(); }
  206.  
  207. template<class T> inline T *&TLPtrQueue<T>::PeekRight()
  208.     { return (T *&)TLVPQueue::PeekRight(); }
  209.  
  210. template<class T> inline T *TLPtrQueue<T>::PeekRight() const
  211.     { return (T *)TLVPQueue::PeekRight(); }
  212.  
  213. template<class T> inline void TLPtrQueue<T>::Enqueue(T *p)
  214.     { TLVPQueue::Enqueue(p); }
  215.  
  216. template<class T> inline void TLPtrQueue<T>::EnqueueUnique(T *p)
  217.     { TLVPQueue::EnqueueUnique(p); }
  218.  
  219. template<class T> inline T *TLPtrQueue<T>::Dequeue()
  220.     { return (T *)TLVPQueue::Dequeue(); }
  221.  
  222. template<class T> inline T *&TLPtrQueue<T>::PeekHead()
  223.     { return (T *&)TLVPQueue::PeekHead(); }
  224.  
  225. template<class T> inline T *TLPtrQueue<T>::PeekHead() const
  226.     { return (T *)TLVPQueue::PeekHead(); }
  227.  
  228. template<class T> inline T *&TLPtrQueue<T>::PeekTail()
  229.     { return (T *&)TLVPQueue::PeekTail(); }
  230.  
  231. template<class T> inline T *TLPtrQueue<T>::PeekTail() const
  232.     { return (T *)TLVPQueue::PeekTail(); }
  233.  
  234. template<class T> inline bool TLPtrQueue<T>::Contains(T *p) const
  235.     { return TLVPQueue::Contains(p); }
  236.  
  237. template<class T> inline T *TLPtrQueue<T>::Extract(T *p)
  238.     { return (T *)TLVPQueue::Extract(p); }
  239.  
  240. template<class T> inline void TLPtrQueue<T>::Remove(T *p)
  241.     { TLVPQueue::Remove(p); }
  242.  
  243. //-----    TLPtrStack
  244.  
  245. template<class T>
  246. inline TLPtrStack<T> &TLPtrStack<T>::operator =(const TLPtrStack<T> &s)
  247.     { return (TLPtrStack<T> &)TLVPStack::operator =(s); }
  248.  
  249. template<class T> inline TLPtrStack<T> &TLPtrStack<T>::operator =(T *p)
  250.     { return (TLPtrStack<T> &)TLVPStack::operator =(p); }
  251.  
  252. template<class T> inline void TLPtrStack<T>::Push(T *p)
  253.     { TLVPStack::Push(p); }
  254.  
  255. template<class T> inline void TLPtrStack<T>::Push(T **v, tSize sz)
  256.     { TLVPStack::Push((void **)v, sz); }
  257.  
  258. template<class T> inline T *TLPtrStack<T>::Pop()
  259.     { return (T *)TLVPStack::Pop(); }
  260.  
  261. template<class T> inline T *TLPtrStack<T>::Pop(T *p)
  262.     { return (T *)TLVPStack::Pop(p); }
  263.  
  264. template<class T> inline void TLPtrStack<T>::Remove(T *p)
  265.     { TLVPStack::Remove(p); }
  266.  
  267. template<class T> inline T *&TLPtrStack<T>::PeekTop()
  268.     { return (T *&)TLVPStack::PeekTop(); }
  269.  
  270. template<class T> inline T *TLPtrStack<T>::PeekTop() const
  271.     { return (T *)TLVPStack::PeekTop(); }
  272.  
  273. template<class T> inline bool TLPtrStack<T>::Contains(T *p)
  274.     { return TLVPStack::Contains(p); }
  275.  
  276. //-----    TLPtrSet
  277.  
  278. template<class T>
  279. inline TLPtrSet<T> &TLPtrSet<T>::operator =(const TLPtrSet<T> &aSet)
  280.     { return (TLPtrSet<T> &)TLVPSet::operator =(aSet); }
  281.  
  282. template<class T> inline TLPtrSet<T> &TLPtrSet<T>::operator =(T *aPtr)
  283.     { return (TLPtrSet<T> &)TLVPSet::operator =(aPtr); }
  284.  
  285. template<class T>
  286. inline TLPtrSet<T> &TLPtrSet<T>::operator +=(const TLPtrSet<T> &aSet)
  287.     { return (TLPtrSet<T> &)TLVPSet::operator +=(aSet); }
  288.  
  289. template<class T> inline TLPtrSet<T> &TLPtrSet<T>::operator +=(T *aPtr)
  290.     { return (TLPtrSet<T> &)TLVPSet::operator +=(aPtr); }
  291.  
  292. template<class T> inline void TLPtrSet<T>::Insert(T *aPtr)
  293.     { TLVPSet::Insert(aPtr); }
  294.  
  295. template<class T> inline T *  TLPtrSet<T>::Extract(T *aPtr)
  296.     { return (T *)TLVPSet::Extract(aPtr); }
  297.  
  298. template<class T> inline void TLPtrSet<T>::Remove(T *aPtr)
  299.     { TLVPSet::Remove(aPtr); }
  300.  
  301. template<class T> inline bool TLPtrSet<T>::Contains(const T *aPtr) const
  302.     { return TLVPSet::Contains(aPtr); }
  303.  
  304. template<class T> inline T *&TLPtrSet<T>::PeekAt(tIndex i)
  305.     { return (T *&)TLVPSet::PeekAt(i); }
  306.  
  307. template<class T> inline T *TLPtrSet<T>::PeekAt(tIndex i) const
  308.     { return (T *)TLVPSet::PeekAt(i); }
  309.  
  310.