home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / vgserv45.zip / BASE / HPTWGS2 / include / fcwlist.h < prev    next >
C/C++ Source or Header  |  2001-03-21  |  16KB  |  736 lines
  1. /*****************************************************************************/
  2. /*                                                                           */
  3. /*                           OCO SOURCE MATERIALS                            */
  4. /*                             IBM CONFIDENTIAL                              */
  5. /*                                    OR                                     */
  6. /*                        IBM CONFIDENTIAL RESTRICTED                        */
  7. /*            WHEN COMBINED WITH THE AGGREGATED OCO SOURCE MODULES           */
  8. /*                           FOR THIS PROGRAM PRODUCT                        */
  9. /*                                                                           */
  10. /*      VisualAge Generator Server for OS/2, AIX, HP-UX, and Windows NT      */
  11. /*                          Version 3.0  5697-C28                            */
  12. /*                    (C) COPYRIGHT IBM CORP. 1994,1997                      */
  13. /*                                                                           */
  14. /*****************************************************************************/
  15. // List base class
  16.  
  17. #ifndef FCWLIST_H
  18. #define FCWLIST_H
  19.  
  20. // ------------------------------------------------------------
  21. // extrace from EFKSVLST.HPP for List processing support
  22. // ------------------------------------------------------------
  23.  
  24. class sequence;
  25.  
  26. class seqnode
  27. {
  28.   protected:
  29.      seqnode();
  30.  
  31.     seqnode * pNext, * pPrev;
  32.  
  33.     friend class cursor;
  34.     friend class sequence;
  35. };
  36.  
  37. inline seqnode :: seqnode() :
  38.    pPrev( NULL ),
  39.    pNext( NULL )
  40. {}
  41.  
  42.  
  43. class cursor
  44. {
  45.   public:
  46.  
  47.     seqnode * pCurNode() const;
  48.  
  49.     cursor (const sequence&);
  50.     cursor (const cursor&);
  51.     seqnode * element();
  52.  
  53.     int setToFirst();
  54.     int setToLast();
  55.     int setToNext();
  56.     int setToPosition(int);
  57.     int setToPrevious();
  58.     void clearPosition();
  59.  
  60.     int isFirst() const;
  61.     int isLast() const;
  62.     int isValid() const;
  63.  
  64.   protected:
  65.  
  66.     const sequence * const pSeq;
  67.     seqnode * pElement;
  68.  
  69.   friend class sequence;
  70. };
  71.  
  72. class sequence
  73. {
  74.   public:
  75.  
  76.     int numberOfElements()     const;
  77.     int isEmpty()              const;
  78.     int isFirst(const cursor&) const;
  79.     int isLast(const cursor&)  const;
  80.  
  81.   protected:
  82.  
  83.     sequence ();
  84.  
  85.     void addAsFirst (seqnode*);
  86.     void addAsLast (seqnode*);
  87.     void addAsPrevious (seqnode*, seqnode*);
  88.     void addAsNext     (seqnode*, seqnode*);
  89.  
  90.     seqnode * elementAtPosition(int) const;
  91.  
  92.     seqnode * lastElement() const;
  93.     seqnode * firstElement() const;
  94.  
  95.     void unlinkNode(seqnode*);
  96.  
  97.     int numElements;
  98.     seqnode * pFirst, * pLast;
  99.  
  100.     friend class cursor;
  101. };
  102.  
  103. inline sequence::sequence() : numElements(0), pFirst(0), pLast(0)
  104. {
  105. }
  106.  
  107. inline int sequence::numberOfElements() const
  108. {
  109.   return numElements;
  110. }
  111.  
  112. inline int sequence::isEmpty() const
  113. {
  114.   return (pFirst == 0) ? 1 : 0;
  115. }
  116.  
  117. inline int sequence::isFirst(const cursor& c) const
  118. {
  119.   return (pFirst == c.pElement) ? 1 : 0;
  120. }
  121.  
  122. inline int sequence::isLast(const cursor& c) const
  123. {
  124.   return (pLast == c.pElement) ? 1 : 0;
  125. }
  126.  
  127. inline seqnode * sequence::lastElement() const
  128. {
  129.   return pLast;
  130. }
  131.  
  132. inline seqnode * sequence::firstElement() const
  133. {
  134.   return pFirst;
  135. }
  136.  
  137. inline cursor::cursor (const sequence& L) : pSeq(&L), pElement(pSeq -> pFirst)
  138. {
  139. }
  140.  
  141. inline cursor::cursor (const cursor& C) : pSeq(C.pSeq), pElement(C.pElement)
  142. {
  143. }
  144.  
  145. inline seqnode * cursor::pCurNode() const
  146. {
  147.   return pElement;
  148. }
  149.  
  150. inline seqnode * cursor::element()
  151. {
  152.   return pElement;
  153. }
  154.  
  155. inline int cursor::setToFirst()
  156. {
  157.   pElement = pSeq -> pFirst;
  158.   return pElement ? 1 : 0;
  159. }
  160.  
  161. inline int cursor::setToLast()
  162. {
  163.   pElement = pSeq -> pLast;
  164.   return pElement ? 1 : 0;
  165. }
  166.  
  167. inline int cursor::setToNext()
  168. {
  169.   if (pElement)
  170.     pElement = pElement -> pNext;
  171.   return pElement ? 1 : 0;
  172. }
  173.  
  174. inline int cursor::setToPrevious()
  175. {
  176.   if (pElement)
  177.     pElement = pElement -> pPrev;
  178.  
  179.   return pElement ? 1 : 0;
  180. }
  181.  
  182. inline void cursor::clearPosition()
  183. {
  184.   pElement = 0;
  185. }
  186.  
  187. inline int cursor::isFirst() const
  188. {
  189.   return (pElement == pSeq -> pFirst) ? 1 : 0;
  190. }
  191.  
  192. inline int cursor::isLast() const
  193. {
  194.   return (pElement == pSeq -> pLast) ? 1 : 0;
  195. }
  196.  
  197. inline int cursor::isValid() const
  198. {
  199.   return pElement ? 1 : 0;
  200. }
  201.  
  202. // ************************************
  203. // template implemenation for Sequence
  204. // ************************************
  205.  
  206. template <class T> class Sequence;
  207.  
  208. template <class T>
  209. class Cursor : public cursor
  210. {
  211.   public:
  212.     Cursor (const Sequence<T>&);
  213.     Cursor (const Cursor<T>&);
  214.     T const& element();
  215. };
  216.  
  217. template <class T>
  218. class SeqNode : public seqnode
  219. {
  220.   private:
  221.  
  222.     T data;
  223.  
  224.   public:
  225.  
  226.     SeqNode (T const&);
  227.     ~SeqNode();
  228.  
  229.     friend class Sequence<T>;
  230.     friend class Cursor<T>;
  231. };
  232.  
  233. template <class T>
  234. class Sequence : public sequence
  235. {
  236.   public:
  237.  
  238.     Sequence();
  239.     Sequence(const Sequence<T>&);
  240.     ~Sequence();
  241.  
  242.     T const& elementAtPosition(int) const;
  243.     void add(T const&);
  244.     void addAsFirst(T const&);
  245.     void addAsLast(T const&);
  246.     void addAsPrevious(T const&, const Cursor<T>&);
  247.     void addAsNext    (T const&, const Cursor<T>&);
  248.  
  249.     T const& lastElement() const;
  250.     T const& firstElement() const;
  251.  
  252.     void replaceAt(Cursor<T>&, T const&);
  253.     void removeAt(Cursor<T>&);
  254.  
  255.     void clear();
  256. };
  257.  
  258. template <class T>
  259. inline void Sequence<T>::clear()
  260. {
  261.   // this is quicker than calling removenode for each element
  262.  
  263.   SeqNode<T> * pNode, * pNextNode;
  264.  
  265.   for (pNode = (SeqNode<T>*) pFirst; pNode; pNode = (SeqNode<T>*) pNextNode)
  266.   {
  267.     pNextNode = (SeqNode<T>*) pNode->pNext;
  268.     delete pNode;
  269.   }
  270.  
  271.   pFirst = pLast = 0;
  272.   numElements = 0;
  273. }
  274.  
  275.  
  276. template <class T>
  277. inline Cursor<T>::Cursor (const Sequence<T>& L) : cursor(L)
  278. {
  279. }
  280.  
  281. template <class T>
  282. inline Cursor<T>::Cursor (const Cursor<T>& L) : cursor(L)
  283. {
  284. }
  285.  
  286. template <class T>
  287. inline T const& Cursor<T>::element()
  288. {
  289.   return ( (SeqNode<T> *) cursor::element() ) -> data;
  290. }
  291.  
  292. // SeqNode implementations
  293.  
  294. template <class T>
  295. inline SeqNode<T>::SeqNode (T const& a) : data(a)
  296. {
  297. }
  298.  
  299. template <class T>
  300. inline SeqNode<T>::~SeqNode ()
  301. {
  302. }
  303.  
  304. // Sequence implementations
  305.  
  306. template <class T>
  307. inline Sequence<T>::Sequence () : sequence ()
  308. {
  309. }
  310.  
  311. template <class T>
  312. inline Sequence<T>::Sequence (const Sequence<T>& seq) : sequence ()
  313. {
  314.   Cursor<T> cur(seq);
  315.  
  316.   for (cur.setToFirst(); cur.isValid(); cur.setToNext())
  317.     addAsLast(cur.element());
  318. }
  319.  
  320. template <class T>
  321. inline Sequence<T>::~Sequence ()
  322. {
  323.   clear();
  324. }
  325.  
  326. template <class T>
  327. inline T const& Sequence<T>::firstElement() const
  328. {
  329.   // possible error here
  330.  
  331.   return ((SeqNode<T>*) sequence::firstElement()) -> data;
  332. }
  333.  
  334. template <class T>
  335. inline T const& Sequence<T>::lastElement() const
  336. {
  337.   // possible error here
  338.  
  339.   return ((SeqNode<T>*) sequence::lastElement()) -> data;
  340. }
  341.  
  342. template <class T>
  343. inline T const& Sequence<T>::elementAtPosition(int i) const
  344. {
  345.   seqnode * p = sequence::elementAtPosition(i);
  346.  
  347.   // possible error here
  348.  
  349.   return ( (SeqNode<T> *) p ) -> data;
  350. }
  351.  
  352. template <class T>
  353. inline void Sequence<T>::add(T const& a)
  354. {
  355.   sequence :: addAsLast (new SeqNode<T>(a));
  356. }
  357.  
  358. template <class T>
  359. inline void Sequence<T>::addAsFirst(T const& a)
  360. {
  361.   sequence :: addAsFirst (new SeqNode<T>(a));
  362. }
  363.  
  364. template <class T>
  365. inline void Sequence<T>::addAsLast (T const& a)
  366. {
  367.   sequence :: addAsLast (new SeqNode<T>(a));
  368. }
  369.  
  370. template <class T>
  371. inline void Sequence<T>::addAsPrevious (T const& a, const Cursor<T>& c)
  372. {
  373.   sequence :: addAsPrevious (new SeqNode<T>(a), c.pCurNode() );
  374. }
  375.  
  376. template <class T>
  377. inline void Sequence<T>::addAsNext     (T const& a, const Cursor<T>& c)
  378. {
  379.   sequence :: addAsNext     (new SeqNode<T>(a), c.pCurNode() );
  380. }
  381.  
  382. template <class T>
  383. inline void Sequence<T>::replaceAt(Cursor<T>& curs, T const& a)
  384. {
  385.   ((SeqNode<T> *) curs.pCurNode()) -> data = a;
  386. }
  387.  
  388. template <class T>
  389. inline void Sequence<T>::removeAt(Cursor<T>& curs)
  390. {
  391.   if (curs.pCurNode())
  392.   {
  393.     SeqNode<T> * pNode = (SeqNode<T> *) curs.pCurNode();
  394.     sequence::unlinkNode(pNode);
  395.     curs.clearPosition();
  396.     delete pNode;
  397.   }
  398. }
  399.  
  400. // ************************************
  401. // template implemenation for IESequence
  402. // ************************************
  403.  
  404. template <class T>
  405. class EqualitySequence : public Sequence<T>
  406. {
  407.   public:
  408.  
  409.     EqualitySequence();
  410.     EqualitySequence(const EqualitySequence<T>&);
  411.  
  412.     void addAsFirst(T const&);
  413.     void addAsLast(T const&);
  414.     void addAsPrevious(T const&, const Cursor<T>&);
  415.     void addAsNext    (T const&, const Cursor<T>&);
  416.  
  417.     int contains(T const&);
  418. };
  419.  
  420. template <class T>
  421. inline void EqualitySequence<T>::addAsFirst(T const& a)
  422. {
  423.   if (! contains(a))
  424.     Sequence<T> :: addAsFirst (a);
  425. }
  426.  
  427. template <class T>
  428. inline void EqualitySequence<T>::addAsLast (T const& a)
  429. {
  430.   if (! contains(a))
  431.     Sequence<T> :: addAsLast (a);
  432. }
  433.  
  434. template <class T>
  435. inline void EqualitySequence<T>::addAsPrevious (T const& a, const Cursor<T>& c)
  436. {
  437.   if (! contains(a))
  438.     Sequence<T> :: addAsPrevious (a, c);
  439. }
  440.  
  441. template <class T>
  442. inline void EqualitySequence<T>::addAsNext     (T const& a, const Cursor<T>& c)
  443. {
  444.   if (! contains(a))
  445.     Sequence<T> :: addAsNext (a, c);
  446. }
  447.  
  448. template <class T>
  449. inline int EqualitySequence<T>::contains(T const& el)
  450. {
  451.   Cursor<T> cur(*this);
  452.  
  453.   for (cur.setToFirst(); cur.isValid(); cur.setToNext())
  454.     if (cur.element() == el)
  455.       return 1;
  456.  
  457.   return 0;
  458. }
  459.  
  460. template <class T>
  461. inline EqualitySequence<T>::EqualitySequence () : Sequence<T> ()
  462. {
  463. }
  464.  
  465. template <class T>
  466. inline EqualitySequence<T>::EqualitySequence (const EqualitySequence<T>& seq) : Sequence<T> (seq)
  467. {
  468.   Cursor<T> cur(seq);
  469.  
  470.   for (cur.setToFirst(); cur.isValid(); cur.setToNext())
  471.     Sequence<T> :: addAsLast (cur.element());
  472. }
  473.  
  474. // ************************************
  475. // template implemenation for IESequence
  476. // ************************************
  477.  
  478. template <class T>
  479. class OrderedSequence : public Sequence<T>
  480. {
  481.   private:
  482.  
  483.     int (*pCompare) ( T const&, T const&);
  484.  
  485.     // these add functions are disabled for ordered squences
  486.     void addAsFirst(T const&) {}
  487.     void addAsLast(T const&) {}
  488.     void addAsPrevious(T const&, const Cursor<T>&) {}
  489.     void addAsNext    (T const&, const Cursor<T>&) {}
  490.  
  491.   public:
  492.  
  493.     OrderedSequence(int (*) (T const&,T const&));
  494.     OrderedSequence(const OrderedSequence<T>&);
  495.  
  496.     void add(T const&);
  497. };
  498.  
  499. template <class T>
  500. inline void OrderedSequence<T>::add (T const& el)
  501. {
  502.   Cursor<T> cur(*this);
  503.  
  504.   for (cur.setToFirst(); cur.isValid(); cur.setToNext())
  505.   {
  506.     if ( (*pCompare) (el, cur.element()) < 0)
  507.     {
  508.       Sequence<T> :: addAsPrevious (el, cur);
  509.       return;
  510.     }
  511.   }
  512.  
  513.   Sequence<T> :: addAsLast (el);
  514. }
  515.  
  516. template <class T>
  517. inline OrderedSequence<T>::OrderedSequence ( int (*pComp) (T const&, T const&))
  518.   : Sequence<T> (), pCompare(pComp)
  519. {
  520. }
  521.  
  522. template <class T>
  523. inline OrderedSequence<T>::OrderedSequence (const OrderedSequence<T>& seq)
  524.   : Sequence<T> (seq)
  525. {
  526.   pCompare = seq.pCompare;
  527.  
  528.   Cursor<T> cur(seq);
  529.  
  530.   for (cur.setToFirst(); cur.isValid(); cur.setToNext())
  531.     Sequence<T> :: addAsLast (cur.element());
  532. }
  533.  
  534. // *****************************
  535. // stack implementation
  536. // *****************************
  537.  
  538. class stacknode
  539. {
  540.   protected:
  541.     stacknode();
  542.     stacknode *pNext;
  543.  
  544.   friend class stack;
  545. };
  546.  
  547. inline stacknode :: stacknode() :
  548.    pNext( NULL )
  549. {}
  550.  
  551. class stack
  552. {
  553.   public:
  554.  
  555.     void  push(stacknode *);
  556.     stacknode *pop();
  557.     stacknode *peek();
  558.     int isEmpty() const;
  559.     void clear();
  560.     int numberOfElements()     const;
  561.  
  562.   protected:
  563.     stack();
  564.     stacknode *pTop;
  565. };
  566.  
  567. inline stack::stack() : pTop(0)
  568. {
  569. }
  570.  
  571. inline int stack::isEmpty() const
  572. {
  573.   return (pTop == 0) ? 1 : 0;
  574. }
  575.  
  576. // *****************************
  577. // template stack implementation
  578. // *****************************
  579.  
  580. template <class T> class IStack;
  581.  
  582. template <class T>
  583. class StackNode : public stacknode
  584. {
  585.   private:
  586.  
  587.     T data;
  588.  
  589.   public:
  590.  
  591.     StackNode(T const&);
  592.  
  593.     friend IStack<T>;
  594. };
  595.  
  596. template <class T>
  597. inline StackNode<T>::StackNode(T const& a) :
  598.    data(a)
  599. {
  600. }
  601.  
  602. template <class T>
  603. class IStack : public stack
  604. {
  605.   protected:
  606.  
  607.   public:
  608.  
  609.     IStack();
  610.     IStack(IStack<T>&);
  611.     ~IStack();
  612.  
  613.     void push(T const&);
  614.     void pop(T&);
  615.     void pop();
  616.     void peek(T&);
  617.     int isEmpty() const;
  618.  
  619.     void clear();
  620. };
  621.  
  622. template <class T>
  623. inline void IStack<T>::clear()
  624. {
  625.   StackNode<T> * pNode, * pNextNode;
  626.  
  627.   for (pNode = (StackNode<T>*) pTop; pNode; pNode = (StackNode<T>*) pNextNode)
  628.   {
  629.     pNextNode = (StackNode<T>*) pNode->pNext;
  630.     delete pNode;
  631.   }
  632.   pTop = 0;
  633. }
  634.  
  635. template <class T>
  636. inline IStack<T>::IStack() : stack()
  637. {
  638. }
  639.  
  640. template <class T>
  641. inline IStack<T>::IStack(IStack<T>& stk) : stack()
  642. {
  643.   for (StackNode<T>* pNode = (StackNode<T>*) stk.pTop; pNode; pNode = (StackNode<T>*) pNode->pNext)
  644.     push(pNode->data);
  645. }
  646.  
  647. template <class T>
  648. inline IStack<T>::~IStack()
  649. {
  650.   clear();
  651. }
  652.  
  653. template <class T>
  654. inline void IStack<T>::push(T const& a)
  655. {
  656.   stack::push(new StackNode<T>(a));
  657. }
  658.  
  659. template <class T>
  660. inline void IStack<T>::pop(T& a)
  661. {
  662.   // possible error
  663.  
  664.   StackNode<T> * p = (StackNode<T>*) stack::pop();
  665.  
  666.   if (p)
  667.   {
  668.     a = p -> data;
  669.     delete p;
  670.   }
  671. }
  672.  
  673. template <class T>
  674. inline void IStack<T>::pop()
  675. {
  676.   StackNode<T> * p = (StackNode<T>*) stack::pop();
  677.  
  678.   if (p)
  679.     delete p;
  680. }
  681.  
  682. template <class T>
  683. inline void IStack<T>::peek(T& a)
  684. {
  685.   // possible error
  686.  
  687.   StackNode<T> * p = (StackNode<T>*) stack::peek();
  688.  
  689.   if (p)
  690.     a = p -> data;
  691. }
  692.  
  693. template <class T>
  694. inline int IStack<T>::isEmpty() const
  695. {
  696.   return stack::isEmpty();
  697. }
  698.  
  699. /*****************************************************************************/
  700. /* Provide macro for list/cursor type names                                  */
  701. /*****************************************************************************/
  702. #define LIST(TYPE)  Sequence<TYPE>
  703. #define SLIST(TYPE) OrderedSequence<TYPE>
  704. #define ELIST(TYPE) EqualitySequence<TYPE>
  705. #define STACK(TYPE) IStack<TYPE>
  706.  
  707. #define CURSOR(TYPE)  Cursor<TYPE>
  708.  
  709. /*****************************************************************************/
  710. /* Provide easy way to delete objects from list of pointers.                 */
  711. /*****************************************************************************/
  712. #define DELETE_LIST(LIST, PTYPE)                                    \
  713.   {                                                                 \
  714.     PTYPE tempType;                                                 \
  715.     Cursor<PTYPE> cursor(LIST);                                     \
  716.     for (cursor.setToFirst(); cursor.isValid(); cursor.setToNext()) \
  717.     {                                                               \
  718.        tempType = cursor.element();                                 \
  719.        delete tempType;                                             \
  720.     }                                                               \
  721.   }
  722.  
  723.  
  724. /*****************************************************************************/
  725. /* Provide easy way to traverse all elements of list.                        */
  726. /*****************************************************************************/
  727. #define FORALL(CURSOR)  for (CURSOR.setToFirst(); \
  728.                              CURSOR.isValid();    \
  729.                              CURSOR.setToNext())
  730.  
  731. // --------------------------------------------------------
  732. // end if extract
  733. // --------------------------------------------------------
  734.  
  735. #endif
  736.