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 / utility / AttrList.h < prev   
Encoding:
C/C++ Source or Header  |  1994-05-09  |  3.9 KB  |  135 lines

  1. #ifndef APP_AttrList_H
  2. #define APP_AttrList_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/intuition/AttrList.h 1.04 (04.05.94) $
  11.  **    
  12.  ******************************************************************************/
  13.  
  14. extern "C" {
  15. #include <utility/tagitem.h>
  16. #ifdef __GNUG__
  17. #include <inline/utility.h>
  18. #endif
  19.  
  20. #ifdef __SASC
  21. #include <proto/utility.h>
  22. #endif
  23. }
  24. #include <iostream.h>
  25. #include <APlusPlus/environment/APPObject.h>
  26.  
  27.  
  28. /******************************************************************************
  29.  
  30.         AttrList class 
  31.     
  32.     This class handles Amiga® TagItem lists (arrays) for the uniform usage 
  33.     throughout the A++ Library.
  34.     
  35.     Common terms for understanding TagItem lists:
  36.     A 'tag list' is an array of 'tag items' each consisting of a 'tag value' indicating 
  37.     the 'type' of the tag (therefore called 'TagValue' or 'TagType', sometimes 'Tag') 
  38.     and a 'tag data' describing the 'data value' of the tag (refered to as 'DataValue' 
  39.     or 'TagData').
  40.  
  41.  ******************************************************************************/
  42.  
  43. typedef struct TagItem *TagList;
  44. // pointer to the first TagItem element of a TagItem array terminated with {TAG_END,0}
  45. // divided into several array chunks that are linked with {TAG_MORE,<TagList>}.
  46.     
  47. class AttrIterator;
  48. class AttrList
  49. {
  50.     friend AttrIterator;
  51.     friend ostream& operator << (ostream& OS,const AttrList& attrlist);
  52.     
  53.     private:
  54.         static struct TagItem *tmp;    // temporary taglist memory for temporary AttList objects
  55.         static AttrList *tmpUser;        
  56.         static int tmpMaxLength;    
  57.         
  58.         struct TagItem *copyTagItems(struct TagItem *tlist);
  59.         void freeTagItems(struct TagItem *tlist);
  60.         
  61.     protected:
  62.         struct TagItem *taglist;
  63.                                 
  64.     public:
  65.         AttrList(struct TagItem *tl=NULL);
  66.         AttrList(LONG tag1Type,...);
  67.         AttrList(const AttrList& from);
  68.         ~AttrList();
  69.               
  70.         AttrList& operator=(const AttrList& from);    // assignment is copying
  71.                 
  72.         operator struct TagItem*() const { return taglist; }
  73.           
  74.         BOOL addAttrs(const AttrList& attrlist);
  75.         AttrList& operator += (const AttrList&    add) { addAttrs(add); return *this; }
  76.         BOOL updateAttrs(const AttrList& attrlist);
  77.       // tags in 'this' that are present in both 'this' and 'attrlist' are updated to
  78.       // the tag data value found in 'attrlist'.
  79.         
  80.         LONG getTagData(Tag tag,LONG defaultValue=0) const { 
  81.               return (LONG)GetTagData(tag,defaultValue,taglist); }
  82.             
  83.         ULONG mapAttrs(AttrList& mapAt);
  84.         ULONG filterAttrs(AttrList& filterAt);
  85.         
  86.         ULONG mapAttrs(struct TagItem *mapList);
  87.         ULONG filterAttrs(struct TagItem *filterList);
  88.  
  89.         ULONG mapAttrs(Tag tag1Type,...) { return mapAttrs((struct TagItem*)&tag1Type); }
  90.         ULONG filterAttrs(Tag tag1Type,...) { return filterAttrs((struct TagItem*)&tag1Type); }
  91.  
  92.  
  93.         
  94. };
  95.  
  96. inline AttrList operator + (const AttrList& op1,const AttrList& op2)
  97. {
  98.     AttrList tmp(op1);
  99.     return tmp.addAttrs(op2);
  100. }
  101.  
  102. ostream& operator << (ostream& OS,struct TagItem *tl);
  103.  
  104. class AttrIterator
  105. {
  106.     protected:
  107.         const AttrList *al;
  108.         struct TagItem *tstate,*atTag;    
  109.         
  110.     public:
  111.         AttrIterator(const AttrList& alist) { al = &alist; atTag = tstate = alist.taglist; }
  112.           
  113.         BOOL operator () () { return ((atTag = NextTagItem(&tstate))!=NULL); }
  114.         void reset() { atTag = tstate = al->taglist; }
  115.           
  116.         BOOL findTagItem(Tag tagVal);
  117.         // find next occurancy of 'tagVal' tag item and set iterator to its position
  118.         // if 'tagVal' could not be found the iterator remains at its position and the method returns FALSE.
  119.           
  120.         Tag tag() { return atTag->ti_Tag; }
  121.         LONG data() { return atTag->ti_Data; } 
  122. };
  123.  
  124. class AttrManipulator : public AttrIterator
  125. {
  126.     public:
  127.         AttrManipulator(AttrList& calist) : AttrIterator((const AttrList&)calist) {}
  128.         
  129.         void writeTag(Tag tagValue) { atTag->ti_Tag = tagValue; }
  130.         void writeData(LONG tagData) { atTag->ti_Data = tagData; }   
  131.         
  132. };
  133.  
  134. #endif
  135.