---

Array.h

Go to the documentation of this file.

/*
    File:           Array.h

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

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

#ifndef __Array__
#define __Array__

#include <iostream.h>
#include "cl/Basics.h"
#include <stdio.h>

#define TMPLArray   template<class T>
#define TArray      Array<T>

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

TMPLArray class Array
{
public:
                    Array();
                    Array(UInt32 size, Int alloc = kFirstAllocation);       
                    Array(const TArray &array);
                   ~Array();
    
//  Array operators
    
    inline T        &operator [] (Int i);       
    inline const T  &operator [] (Int i) const; 
    inline Int      NumItems() const;           
    
    TArray          &operator = (const TArray &array);  
    
//  Useful for stack implementations

    inline T        &Top();                     
    inline Void     Pop();                      
    inline Void     Push(const T &t);           
    
// List Operations

    inline Void     Append(const T &t);         
    inline T        &Last();                    
    Void            Clear();                    

    Void            PreAllocate(UInt32 numItems);
    Void            SetSize(Int newSize);       
    Void            Add(Int n = 1);             
    Void            Shrink(Int n = 1);          
    Void            Insert(Int i, Int n = 1);   
    Void            Delete(Int i, Int n = 1);   
    Void            ShrinkWrap();               
    Void            ClearTo(const T &t);        

    Void            Append(const TArray &a);    
    Void            SwapWith(TArray &a);        
    Void            Replace(TArray &a);         
    const T         &Item(Int i) const
                    { return(SELF[i]); };
    T               &Item(Int i)
                    { return(SELF[i]); };
    
// Low level access

    inline T        *Ref() const;               
    inline T        *Detach();                  
    Void            Attach(T *itemsPtr, Int numItems, Bool shared);
    Void            WriteFile(const Char *filename);
    Void            ReadFile(const Char *filename);

    Int             FWrite(FILE *file);
    Int             FRead(FILE *file);

//  Private...

protected:
    T               *item;      
    UInt32          items;      
    UInt32          allocated;  
    
    Void            Grow();
};  

TMPLArray ostream &operator << (ostream &s, TArray &array);
TMPLArray istream &operator >> (istream &s, TArray &array);


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


TMPLArray inline TArray::Array() : item(0), items(0), allocated(0)
{
}

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

TMPLArray inline T &TArray::operator [] (Int i)
{
    CheckRange(i, 0, items, "(Array::[]) index out of range");

    return(item[i]);
}

TMPLArray inline const T &TArray::operator [] (Int i) const
{
    CheckRange(i, 0, items, "(Array::[]) index out of range");

    return(item[i]);
}

TMPLArray inline T &TArray::Top()
{
    return(item[items - 1]);
}

TMPLArray inline T &TArray::Last()
{
    return(item[items - 1]);
}

TMPLArray inline Void TArray::Push(const T &t)
{
    if (items >= allocated)
        Grow();
    
    item[items++] = t;
}

TMPLArray inline Void TArray::Append(const T &t)
{
    if (items >= allocated)
        Grow();
    
    item[items++] = t;
}

TMPLArray inline Void TArray::Pop()
{   
    items--;
}

TMPLArray inline Void TArray::Clear()
{   
    items = 0;
    allocated = 0;
    delete[] item;
    item = 0;
}

TMPLArray inline T *TArray::Ref() const
{
    return(item);
}

TMPLArray inline T *TArray::Detach()
{
    T* result = item;

    items = 0;
    allocated = 0;
    item = 0;

    return(result);
}

TMPLArray inline Void TArray::ClearTo(const T &t)
{
    for (Int i = 0; i < items; i++)
        item[i] = t;
}

#ifndef __ArrayTmpl__
#include "cl/Array.cc"
#endif

#endif

---