---

NArray.h

Go to the documentation of this file.

/*
    File:           NArray.h

    Function:       Defines an array type that manages its own storage space,
                    and can be used as a stack or a list.
                    This is the sister of the array class -- it, so
                    it doesn't have to be instantiated for every new
                    data type, at the cost of an extra word of storage.

                    Array<> should be used just for standard data types
                    (char, int, float, double) and NArray for everything else.
                    
                    
    Author(s):      Andrew Willmott

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

#ifndef __NArray__
#define __NArray__

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

const Int kFirstNAllocation = 16;   



class NBaseArray
{
public:
    inline          NBaseArray(UInt32 eltSize);
                    NBaseArray(UInt32 eltSize, Int size, Int alloc = kFirstNAllocation);        
                    NBaseArray(const NBaseArray &array);
                   ~NBaseArray();
    
//  NBaseArray operators
    
    inline Int      NumItems() const;   
    
    NBaseArray      &operator = (const NBaseArray &array);  
    
//  Useful for stack implementations

    inline Void     Pop();                      
    
// List Operations

    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            Append(const NBaseArray &a);
    Void            SwapWith(NBaseArray &a);    
    Void            Replace(NBaseArray &a);     
    Void            MemMap(const Char* filename);
    Void            WriteFile(const Char *filename);
    Void            ReadFile(const Char *filename);

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

    Void            Attach(Void *ptr, Int numItems, Bool shared = false);
    
    UInt32          EltSize()
                    { return(eltSize); };

protected:
    Byte            *item;      
    UInt32          items;      
    UInt32          allocated;  
    UInt32          eltSize;

    Void            Grow();
};  



#define TMPLArray   template<class T>
#define TNArray     NArray<T>

TMPLArray class NArray : public NBaseArray
{
public:
                    NArray() : NBaseArray(sizeof(T)) {};
                    NArray(Int size, Int alloc = kFirstNAllocation) :
                        NBaseArray(sizeof(T), size, alloc) {};

    inline T        &operator [] (Int i);       
    inline const T  &operator [] (Int i) const; 

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

    inline T        &Top();                     
    inline Void     Push(const T &t);           

    const T         &Item(Int i) const
                    { return(SELF[i]); };
    T               &Item(Int i)
                    { return(SELF[i]); };

    Void            ClearTo(const T &t);        
    Void            Append(const TNArray &a)    
                    { ((NBaseArray*) this)->Append(a); };
                    // C++: can't live with it, pass the beer nuts.

// Low level access

    inline T        *Ref() const;               
    inline T        *Detach();                  
};

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


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


inline NBaseArray::NBaseArray(UInt32 es) 
    : items(0), item(0), allocated(0), eltSize(es)
{
}

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

inline Void NBaseArray::Pop()
{   
    items--;
}

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

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

    return(*((T*) (item + i * eltSize)));
}

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

    return(*((T*) (item + i * eltSize)));
}

TMPLArray inline T &TNArray::Top()
{
    return(*(((T*) item) + (items - 1)));
}

TMPLArray inline T &TNArray::Last()
{
    return(*(((T*) item) + (items - 1)));
}

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

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

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

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

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

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

    return(result);
}

// --- I/O --------------------------------------------------------------------

// XXX convert these to generic NBaseArray routine with the stream
// function handed in

TMPLArray ostream &operator << (ostream &s, TNArray &array)
{   
    Int     i;
    Char    sepChar;

    s << '[';
    if (array.NumItems() >= 16)
        sepChar = '\n';
    else
        sepChar = ' ';
    
    if (array.NumItems() > 0)
    {
        s << array[0];

        for (i = 1; i < array.NumItems(); i++)
            s << sepChar << array[i];
    }
    
    s << ']';

    return(s);
}

TMPLArray istream &operator >> (istream &s, TNArray &array)
{
    Char    c;
    
    //  Expected format: [a b c d ...]
    
    while (isspace(s.peek()))           //  chomp white space
        s.get(c);
        
    if (s.peek() == '[')                        
    {
        s.get(c);
        array.Clear();
        
        while (isspace(s.peek()))       //  chomp white space
            s.get(c);
        
        while (s.peek() != ']')
        {           
            array.Add(1);
            s >> array.Top();           //  read an item
        
            if (!s)
            {
                _Warning("Couldn't read array component");
                return(s);
            }
    
            while (isspace(s.peek()))   //  chomp white space
                s.get(c);
        }           
        s.get(c);
    }
    else
    {
        s.clear(ios::failbit);
        _Warning("Error: Expected '[' while reading array");
        return(s);
    }
    
    return(s);
}


#endif

---