Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

ObjArray.h

Go to the documentation of this file.
00001 /*
00002     File:           ObjArray.h
00003 
00004     Function:       Defines an array type that manages its own storage space, 
00005                     and can be used as a stack or a rudimentary list.
00006                     
00007     Author(s):      Andrew Willmott
00008 
00009     Copyright:      (c) 1995-2000, Andrew Willmott
00010  */
00011 
00012 #ifndef __ObjArray__
00013 #define __ObjArray__
00014 
00015 #include <iostream.h>
00016 #include "cl/Basics.h"
00017 #include "cl/Action.h"
00018 #include "cl/Object.h"
00019 
00020 const Int kFirstObjAlloc = 16;  // Default number of items to initially 
00021                                 // allocate to the array
00022 
00023 class ObjArray : public Object
00024 {
00025 public:
00026                         ObjArray();
00027                         ObjArray(Int size, Int alloc = kFirstObjAlloc);     
00028                         ObjArray(const ObjArray &array);
00029                         ~ObjArray();
00030     
00031 //  ObjArray operators
00032     
00033     inline ObjectPtr    operator [] (Int i) const;  // indexing operator
00034     inline Int          NumItems() const;   // Number of items in the array
00035     ObjArray            &operator >> (Action<ObjectPtr> &a);
00036     ObjArray            &operator = (const ObjArray &array);
00037 
00038 //  Useful for stack implementations
00039 
00040     inline ObjectPtr    Top();              // Return last item (top-of-stack)
00041     inline Void         Pop();              // Delete last item (pop)
00042     inline Void         Push(ObjectPtr objPtr); // Add item to end of array 
00043     
00044 // List Operations
00045 
00046     inline Void         Set(Int i, ObjectPtr objPtr);
00047                         // Change item i to objPtr
00048     inline Void         Append(ObjectPtr objPtr);    
00049                         // Append item to end of array
00050     inline Void         Prepend(ObjectPtr objPtr);
00051                         // Prepend item to start of array
00052     inline Void         Insert(Int i, ObjectPtr objPtr);  // Insert item at i
00053     inline Void         Delete(Int i);                    // Delete item at i
00054 
00055     Void                Clear();            // Delete all items
00056 
00057     Void                Print(ostream &s) const;
00058     Void                Parse(istream &s);
00059     ObjectPtr           Clone() const;              // Return copy of list
00060     Void                Free();                     // Free all storage
00061 
00062     Void                SetSize(Int newSize);       // Set array size directly
00063     Void                Add(Int n);                 // Add n items to the array
00064     Void                Shrink(Int n);              // shrink the array n items
00065     Void                Insert(Int i, Int n);       // Insert n items at i
00066     Void                Delete(Int i, Int n);       // Delete n items at i
00067     Void                ShrinkWrap();               
00068                         // Ensure allocated space = space being used.
00069     
00070 // Low level access
00071 
00072     inline ObjectPtr    *Ref();                     // Return pointer to array
00073 
00074 //  Private...
00075 
00076 protected:
00077     
00078     Void                Grow();
00079     
00080     ObjectPtr           *item;      // pointer to array
00081     SInt32              items;      // items in the array
00082     SInt32              allocated;  // number of items we have space allocated for. 
00083 };  
00084 
00085 
00086 // --- Inlines ----------------------------------------------------------------
00087 
00088 
00089 inline ObjArray::ObjArray() : items(0), item(0), allocated(0)
00090 {
00091 }
00092 
00093 inline Int ObjArray::NumItems() const
00094 {
00095     return(items);
00096 }
00097 
00098 inline ObjectPtr ObjArray::operator [] (Int i) const
00099 {
00100     CheckRange(i, 0, items, "(ObjArray::[]) index out of range");
00101 
00102     return(item[i]);
00103 }
00104 
00105 inline ObjectPtr ObjArray::Top()
00106 {
00107     return(item[items - 1]);
00108 }
00109 
00110 inline Void ObjArray::Push(ObjectPtr objPtr)
00111 {
00112     if (items >= allocated)
00113         Grow();
00114     
00115     item[items++] = objPtr;
00116 }
00117 
00118 inline Void ObjArray::Pop()
00119 {   
00120     items--;
00121     item[items]->Free();
00122 }
00123 
00124 inline Void ObjArray::Set(Int i, ObjectPtr objPtr)
00125 {
00126     CheckRange(i, 0, items, "(ObjArray::Set) index out of range");
00127 
00128     item[i]->Free();
00129     item[i] = objPtr;
00130 }
00131 
00132 inline Void ObjArray::Append(ObjectPtr objPtr)
00133 {
00134     if (items >= allocated)
00135         Grow();
00136     
00137     item[items++] = objPtr;
00138 }
00139 
00140 inline Void ObjArray::Prepend(ObjectPtr objPtr)
00141 {
00142     Insert(0, 1);   
00143     item[0] = objPtr;
00144 }
00145 
00146 inline Void ObjArray::Insert(Int i, ObjectPtr objPtr)
00147 {
00148     Insert(i, 1);   
00149     item[i] = objPtr;
00150 }
00151 
00152 inline Void ObjArray::Delete(Int i)
00153 {
00154     Delete(i, 1);   
00155 }
00156 
00157 inline ObjectPtr *ObjArray::Ref()
00158 {
00159     return(item);
00160 }
00161 
00162 #endif

Generated at Sat Aug 5 00:16:32 2000 for Class Library by doxygen 1.1.0 written by Dimitri van Heesch, © 1997-2000