home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC7.DMS / in.adf / classes.lha / Classes / DataStructures / GenArraylist.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-31  |  2.8 KB  |  115 lines
  1. #ifndef CPP_DATASTRUCTURES_GENARRAYLIST_H
  2. #define CPP_DATASTRUCTURES_GENARRAYLIST_H
  3.  
  4. // Eine Liste auf der dynamischen Array Klasse gen_array aufbauend
  5. //
  6. // Auf die Liste kann man wie auf ein Array (gen_array) zugreifen, allerdings
  7. // auch einige typische Listenoperatoren anwenden.
  8. //
  9. // Achtung: Ein Schreibzugriff auf einen größeren Index, als die Liste
  10. // lang ist, verglängert nicht automatisch die Liste. Diese wird nur durch
  11. // die Listenoperationen verlängert und verkürzt.
  12. //
  13. // Autor: Jochen Becher
  14. //
  15. // Historie:
  16. // Version 1.0 am 25. Juni 94
  17.  
  18. #ifndef CPP_DATASTRUCTURES_GENARRAY_H
  19. #include <classes/datastructures/genarray.h>
  20. #endif
  21.  
  22. class gen_arraylist : public gen_array {
  23. public:
  24.     gen_arraylist(ULONG es, ULONG s = 16) throw (MemoryX);
  25.     // die wirkliche Länge der Liste
  26.     ULONG length() const { return top; };
  27.     VOID &addTail() throw (MemoryX);
  28.     VOID &insert(ULONG index) throw (MemoryX);
  29.     VOID remove(ULONG index) throw (MemoryX);
  30.     VOID remTail();
  31.     VOID clear();
  32. private:
  33.     ULONG top;
  34. };
  35.  
  36. class gen_arraycursor {
  37. public:
  38.     gen_arraycursor(gen_arraylist &);
  39.     VOID first();
  40.     VOID last();
  41.     VOID next();
  42.     VOID prev();
  43.     VOID &item() throw (MemoryX);
  44.     BOOL isDone();
  45. private:
  46.     gen_arraylist *list;
  47.     LONG pos;
  48. };
  49.  
  50. template <class T> class arraylist : private gen_arraylist {
  51. friend class arraycursor<T>;
  52. public:
  53.     arraylist(ULONG s = 16) throw (MemoryX);
  54.     ULONG count() { return gen_arraylist::count(); };
  55.     ULONG length() const { return gen_arraylist::length(); };
  56.     T &operator[] (ULONG i) throw (MemoryX);
  57.     T &addTail() throw (MemoryX);
  58.     T &insert(ULONG index) throw (MemoryX);
  59.     VOID remove(ULONG index) throw (MemoryX);
  60.     VOID remTail() { gen_arraylist::remTail(); };
  61.     VOID clear() { gen_arraylist::clear(); };
  62. };
  63.  
  64. template <class T> class arraycursor : private gen_arraycursor {
  65. public:
  66.     arraycursor(arraylist<T> &l);
  67.     VOID first() { gen_arraycursor::first(); };
  68.     VOID last() { gen_arraycursor::last(); };
  69.     VOID next() { gen_arraycursor::next(); };
  70.     VOID prev() { gen_arraycursor::prev(); };
  71.     T &item() throw (MemoryX);
  72.     BOOL isDone() const { return gen_arraycursor::isDone(); };
  73. };
  74.  
  75. // *************************************************************
  76.  
  77. template <class T> arraylist<T>::arraylist(ULONG s)
  78.     : gen_arraylist(sizeof(T),s)
  79. {
  80. }
  81.  
  82. template <class T> T &arraylist<T>::operator[] (ULONG i)
  83. {
  84.     return (T &) gen_array::operator[] (i);
  85. }
  86.  
  87. template <class T> T &arraylist<T>::addTail()
  88. {
  89.     return (T &) gen_arraylist::addTail();
  90. }
  91.  
  92. template <class T> T &arraylist<T>::insert(ULONG index)
  93. {
  94.     return (T &) gen_arraylist::insert(index);
  95. }
  96.  
  97. template <class T> VOID arraylist<T>::remove(ULONG index)
  98. {
  99.     gen_arraylist::remove(index);
  100. }
  101.  
  102. // *************************************************************
  103.  
  104. template <class T> arraycursor<T>::arraycursor(arraylist<T> &l)
  105.     : gen_arraycursor((gen_arraylist &) l)
  106. {
  107. }
  108.  
  109. template <class T> T &arraycursor<T>::item()
  110. {
  111.     return (T &) gen_arraycursor::item();
  112. }
  113.  
  114. #endif
  115.