---

ObjArray.h

Go to the documentation of this file.

/*
    File:           ObjArray.h

    Function:       Defines an array type that manages its own storage space, 
                    and can be used as a stack or a rudimentary list.
                    
    Author(s):      Andrew Willmott

    Copyright:      (c) 1995-2000, Andrew Willmott
 */

#ifndef __ObjArray__
#define __ObjArray__

#include <iostream.h>
#include "cl/Basics.h"
#include "cl/Action.h"
#include "cl/Object.h"

const Int kFirstObjAlloc = 16;  // Default number of items to initially 
                                // allocate to the array

class ObjArray : public Object
{
public:
                        ObjArray();
                        ObjArray(Int size, Int alloc = kFirstObjAlloc);     
                        ObjArray(const ObjArray &array);
                        ~ObjArray();
    
//  ObjArray operators
    
    inline ObjectPtr    operator [] (Int i) const;  // indexing operator
    inline Int          NumItems() const;   // Number of items in the array
    ObjArray            &operator >> (Action<ObjectPtr> &a);
    ObjArray            &operator = (const ObjArray &array);

//  Useful for stack implementations

    inline ObjectPtr    Top();              // Return last item (top-of-stack)
    inline Void         Pop();              // Delete last item (pop)
    inline Void         Push(ObjectPtr objPtr); // Add item to end of array 
    
// List Operations

    inline Void         Set(Int i, ObjectPtr objPtr);
                        // Change item i to objPtr
    inline Void         Append(ObjectPtr objPtr);    
                        // Append item to end of array
    inline Void         Prepend(ObjectPtr objPtr);
                        // Prepend item to start of array
    inline Void         Insert(Int i, ObjectPtr objPtr);  // Insert item at i
    inline Void         Delete(Int i);                    // Delete item at i

    Void                Clear();            // Delete all items

    Void                Print(ostream &s) const;
    Void                Parse(istream &s);
    ObjectPtr           Clone() const;              // Return copy of list
    Void                Free();                     // Free all storage

    Void                SetSize(Int newSize);       // Set array size directly
    Void                Add(Int n);                 // Add n items to the array
    Void                Shrink(Int n);              // shrink the array n items
    Void                Insert(Int i, Int n);       // Insert n items at i
    Void                Delete(Int i, Int n);       // Delete n items at i
    Void                ShrinkWrap();               
                        // Ensure allocated space = space being used.
    
// Low level access

    inline ObjectPtr    *Ref();                     // Return pointer to array

//  Private...

protected:
    
    Void                Grow();
    
    ObjectPtr           *item;      // pointer to array
    SInt32              items;      // items in the array
    SInt32              allocated;  // number of items we have space allocated for. 
};  


// --- Inlines ----------------------------------------------------------------


inline ObjArray::ObjArray() : items(0), item(0), allocated(0)
{
}

inline Int ObjArray::NumItems() const
{
    return(items);
}

inline ObjectPtr ObjArray::operator [] (Int i) const
{
    CheckRange(i, 0, items, "(ObjArray::[]) index out of range");

    return(item[i]);
}

inline ObjectPtr ObjArray::Top()
{
    return(item[items - 1]);
}

inline Void ObjArray::Push(ObjectPtr objPtr)
{
    if (items >= allocated)
        Grow();
    
    item[items++] = objPtr;
}

inline Void ObjArray::Pop()
{   
    items--;
    item[items]->Free();
}

inline Void ObjArray::Set(Int i, ObjectPtr objPtr)
{
    CheckRange(i, 0, items, "(ObjArray::Set) index out of range");

    item[i]->Free();
    item[i] = objPtr;
}

inline Void ObjArray::Append(ObjectPtr objPtr)
{
    if (items >= allocated)
        Grow();
    
    item[items++] = objPtr;
}

inline Void ObjArray::Prepend(ObjectPtr objPtr)
{
    Insert(0, 1);   
    item[0] = objPtr;
}

inline Void ObjArray::Insert(Int i, ObjectPtr objPtr)
{
    Insert(i, 1);   
    item[i] = objPtr;
}

inline Void ObjArray::Delete(Int i)
{
    Delete(i, 1);   
}

inline ObjectPtr *ObjArray::Ref()
{
    return(item);
}

#endif

---