home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / gnu / aplusplus-1.01-src.lha / APlusPlus-1.01 / include / APlusPlus / exec / List.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-04  |  7.7 KB  |  196 lines
  1. #ifndef APP_List_H
  2. #define APP_List_H
  3. /******************************************************************************
  4.  **
  5.  **    C++ Class Library for the Amiga© system software.
  6.  **
  7.  **    Copyright (C) 1994 by Armin Vogt  **  EMail: armin@uni-paderborn.de
  8.  **    All Rights Reserved.
  9.  **
  10.  **    $VER: apphome:APlusPlus/exec/List.h 1.04 (04.05.94) $
  11.  **    
  12.  ******************************************************************************/
  13.  
  14.  
  15. extern "C" {
  16. #ifdef __GNUG__
  17. #include <inline/exec.h>
  18. #include <clib/alib_protos.h>
  19. #endif
  20.  
  21. #ifdef __SASC
  22. #include <proto/exec.h>
  23. #endif
  24.  
  25. #include <exec/lists.h>
  26. }
  27. #include <iostream.h>
  28.  
  29.  
  30. class MinListC;
  31.  
  32. class MinNodeC : private MinNode
  33. {
  34.    friend MinListC;
  35.    private:
  36.       /** set a node to a state when its repeated remove cannot cause pointer trash.
  37.        ** (succ and pred point to the node itself, so Remove() cannot afflict other memory)
  38.        **/
  39.       void neutralize() { mln_Succ = mln_Pred = this; }
  40.  
  41.    public:
  42.       MinNodeC() { neutralize(); }           // allowes removing an unattached node
  43.       virtual ~MinNodeC();
  44.       MinNodeC *succ() { return (MinNodeC*)(mln_Succ->mln_Succ==NULL?NULL:mln_Succ); }
  45.       MinNodeC *pred() { return (MinNodeC*)(mln_Pred->mln_Pred==NULL?NULL:mln_Pred); }
  46.       void remove() { Remove((Node*)(MinNode*)this); neutralize(); }
  47.       BOOL isLonelyNode() { return (succ()==this); }
  48.  
  49.       virtual BOOL applyMinNodeC(void *any);    // your subclass should overwrite this
  50.       MinListC *findList(void);    // get the MinListC object that this is linked to.
  51. };
  52.  
  53.  
  54. void MinListC__Destruct(MinListC *list);
  55. BOOL MinListC__Member(MinListC *list,MinNodeC *find);
  56. MinNodeC *MinListC__RemoveSafely(MinListC *list,MinNodeC *node);
  57.  
  58.  
  59. class MinListC : private MinList
  60. {
  61.    public:
  62.       MinListC() { NewList((List*)(MinList*)this); }
  63.       virtual ~MinListC();
  64.  
  65.       BOOL empty() { return (mlh_Head->mln_Succ==0); }
  66.       BOOL isEmpty() { return empty(); }
  67.       MinNodeC *head() { return (MinNodeC*)( empty() ? NULL : mlh_Head ); }
  68.       MinNodeC *tail() { return (MinNodeC*)( empty() ? NULL : mlh_TailPred ); }
  69.  
  70.       void addHead(MinNodeC *node) { AddHead((List*)(MinList*)this,(Node*)(MinNode*)node); }
  71.       void addTail(MinNodeC *node) { AddTail((List*)(MinList*)this,(Node*)(MinNode*)node); }
  72.  
  73.       MinNodeC *remHead() { MinNodeC *node = (MinNodeC*)RemHead((List*)(MinList*)this);
  74.                             if (node) node->neutralize(); return node; }
  75.       MinNodeC *remTail() { MinNodeC *node = (MinNodeC*)RemTail((List*)(MinList*)this);
  76.                             if (node) node->neutralize(); return node; }
  77.  
  78.       BOOL member(MinNodeC *node) { return MinListC__Member(this,node); }
  79.       MinNodeC *remove(MinNodeC *node) { return MinListC__RemoveSafely(this,node); }
  80.       void insert(MinNodeC *node,MinNodeC *pred);  // insert new node before pred
  81.  
  82.       BOOL apply(void *any);
  83.       // run the applyMinNodeC on all list nodes with <any> as parameter.
  84.       // Stops if applyNodeC returned FALSE, and returns FALSE!!! else returns TRUE.
  85. };
  86.  
  87. class ListC;
  88.  
  89. class NodeC : private Node
  90. {
  91.    private:
  92.       void neutralize() { ln_Succ = ln_Pred = this; }
  93.  
  94.    protected:
  95.       UBYTE*& name_ref() { return (UBYTE*&)ln_Name; }
  96.  
  97.    public:
  98.       NodeC(BYTE pri = 0, UBYTE type = NT_USER) { ln_Pri = pri; ln_Name = NULL; ln_Type = type; }
  99.       NodeC(BYTE pri, const UBYTE* name = 0, UBYTE type = NT_USER)
  100.             { ln_Pri = pri; ln_Name = (char*)name; ln_Type = type; }
  101.       NodeC(const UBYTE* name, UBYTE type = NT_USER)
  102.             { ln_Pri = 0; ln_Name = (char*)name; ln_Type = type; }
  103.       virtual ~NodeC();         // removes node from any list
  104.  
  105.       NodeC *succ() { return (NodeC*)(ln_Succ->ln_Succ==NULL?NULL:ln_Succ); }
  106.       NodeC *pred() { return (NodeC*)(ln_Pred->ln_Pred==NULL?NULL:ln_Pred); }
  107.       void remove() { Remove((Node*)this); neutralize(); }
  108.       BOOL isLonelyNode() { return (ln_Succ==this); }
  109.  
  110.       virtual BOOL applyNodeC(void *any);       // your subclass should overwrite this
  111.  
  112.       BYTE priority() { return ln_Pri; }              // read priority
  113.       void setPriority(BYTE pri) { ln_Pri = pri; }    // write priority
  114.  
  115.       const UBYTE* name() { return (UBYTE*)ln_Name; }                      // read name
  116.       void setName(const UBYTE* set_name) { ln_Name = (char*)set_name; }   // write name
  117.  
  118.       UBYTE type() { return ln_Type; }                // read type
  119.       void setType(UBYTE type) { ln_Type = type; }    // write type
  120.  
  121.       UBYTE& type_ref() { return ln_Type; }
  122.  
  123.       ListC *findList() { return (ListC*) ((MinNodeC*)(List*)this)->findList(); }
  124.  
  125.       //operator MinNodeC* () { return (MinNodeC*)(MinNode*)(Node*)this; }
  126. };
  127.  
  128.  
  129. /**********************************************************************************************
  130.          » ListC class «
  131.    encapsulates the EXEC list.
  132.  **********************************************************************************************/
  133. class ListC : private List
  134. {
  135.    public:
  136.       ListC(UBYTE type = 0) { NewList((List*)this); lh_Type = type; }
  137.       virtual ~ListC();
  138.  
  139.       BOOL empty() { return (lh_Head->ln_Succ==0); }
  140.       BOOL isEmpty() { return empty(); }     // synonym for empty()
  141.       NodeC *head() { return (NodeC*)( empty() ? NULL : lh_Head ); }
  142.       NodeC *tail() { return (NodeC*)( empty() ? NULL : lh_TailPred ); }
  143.  
  144.       ListC& addHead(NodeC *node) { AddHead((List*)this,(Node*)node); return *this; }
  145.       ListC& addTail(NodeC *node) { AddTail((List*)this,(Node*)node); return *this; }
  146.       ListC& enqueue(NodeC *node) { Enqueue((List*)this,(Node*)node); return *this; }
  147.       void   insert(NodeC *node,NodeC *pred);  // insert new node before pred
  148.       NodeC *remHead() { return (NodeC*) ((MinListC*)this)->remHead(); }
  149.       NodeC *remTail() { return (NodeC*) ((MinListC*)this)->remTail(); }
  150.       NodeC *remove(NodeC *node) { return (NodeC*)MinListC__RemoveSafely((MinListC*)this,(MinNodeC*)node); }
  151.  
  152.       BOOL member(NodeC *node)
  153.             { return MinListC__Member((MinListC*)this,(MinNodeC*)node); }
  154.       NodeC *findName(const UBYTE* name)
  155.             { return (NodeC*)FindName((List*)this,(UBYTE*)name); }
  156.  
  157.       BOOL apply(void *any);
  158. };
  159.  
  160.  
  161. inline void MinListC::insert(MinNodeC *node,MinNodeC *pred)
  162. {
  163.    if (!member(node) && member(pred))  // must not insert already inserted node or behind non-member!
  164.       Insert((List*)this,(Node*)node,(Node*)pred);
  165. }
  166.  
  167. inline void ListC::insert(NodeC *node,NodeC *pred)
  168. {
  169.    if (!member(node) && member(pred))  // must not insert already inserted node or behind non-member!
  170.       Insert((List*)this,(Node*)node,(Node*)pred);
  171. }
  172.  
  173. /** Give your node type and a pointer to your list and you will get a pointer "node" to
  174.  ** your node type in the subsequent loop body. Of course your node type must be derived
  175.  ** from MinNode or Node class as must your list be derived from MinList or List class.
  176.  ** This loop does NOT allow to delete the node object within the loop, since the successor
  177.  ** could not be read from an invalid node! Also FOREACHOF() within another FOREACHOF loop
  178.  ** shadowes the first node. Instead use the macro with explicit variable name.
  179.  ** This hides the type conflict with the return type of the list classes in the absence of
  180.  ** parameterized classes (templates). As soon as templates are available all list classes
  181.  ** will be doubled with template classes.
  182.  **/
  183. #define FOREACHOF(type,list) for(type *node=(type*)((list)->head());node;node=(type*)node->succ())
  184. #define FOREACHOFNAME(type,list,node) for(type *node=(type*)((list)->head());node;node=(type*)node->succ())
  185.  
  186.  
  187. /** This loop allows deleting the object addressed in 'node'.
  188.  ** Add NEXTSAFE behind your loop body (behind the closing brace if there is one)
  189.  **/
  190. #define FOREACHSAFE(type,list) for(type *node=(type*)((list)->head()),*next=NULL;node;node=next) \
  191.    { next=(type*)node->succ();
  192.  
  193. #define NEXTSAFE }
  194.  
  195. #endif    /* APP_List_H */
  196.