qafContainer.h

/* 
** Qaf Framework 1.2
** June 2006
** 
** Pedro Luchini de Moraes, Public Domain - Free Lunch Code
*/

#ifndef QAF_UTIL_CONTAINER_H
#define QAF_UTIL_CONTAINER_H

#include <math.h>
#include <stdexcept>
#include <stdlib.h>


namespace qaf {

    template <typename T>
    class Container {
    public:
        Container () {
            // No elements yet:
            count = 0;
            
            // Start with a capacity of 1:
            capacity = 1;
            data = new T[1];
        }
        
        Container ( const T * elems, int _count ) {
            count = _count;
            capacity = _count;
            data = new T[count];
            
            for ( int i = 0; i < count; i++ )
                data[i] = elems[i];
        }
        
        Container ( const Container & orig ) {
            count    = orig.count;
            capacity = orig.capacity;
            data     = new T[capacity];
            
            for ( int i = 0; i < count; i++ )
                data[i] = orig.data[i];
        }
        
        inline Container & operator = ( const Container & other ) {
            reserve( other.count );
            
            for ( int i = 0; i < other.count; i++ )
                data[i] = other.data[i];
            
            count = other.count;
            
            return (*this);
        }
        
        
        inline void add ( const T & elem ) {
            // Ensure we've got room for the new element:
            reserve( count + 1 );
            
            // Store the new element:
            data[count] = elem;
            
            count++;
        }
        
        inline void add ( int index, const T & elem ) {
            // Check for index validity:
            if ( index < 0 || index > count )
                throw std::out_of_range("Container index out of range");
            
            // Ensure we've got room for the new element:
            reserve( count + 1 );
            
            // Shift everyone from "index" onwards to higher indices:
            for ( int i = count; i > index; i-- )
                data[i] = data[i - 1];
            
            // Store the new element:
            data[index] = elem;
            count++;
        }
        
        inline int indexOf ( const T & elem ) const {
            for ( int i = 0; i < count; i++ )
                if ( data[i] == elem )
                    return i;
            
            return -1;
        }
        
        inline void remove ( int index ) {
            // Check for index validity:
            if ( index < 0 || index >= count )
                throw std::out_of_range("Container index out of range");
            
            // Shift everyone from "index + 1" onwards to lower indices:
            for ( int i = index; i < count - 1; i++ )
                data[i] = data[i + 1];
            
            // One less element:
            count--;
        }
        
        inline bool removeFirst ( const T & elem ) {
            int index = indexOf( elem );
            
            if ( index == -1 )
                return false;
            else {
                remove( index );
                return true;
            }
        }
        
        inline bool removeAll ( const T & elem ) {
            bool foundIt = false;
            
            for ( int i = count - 1; i >= 0; i-- ) {
                if ( data[i] == elem ) {
                    remove( i );
                    foundIt = true;
                }
            }
            
            return foundIt;
        }
        
        inline void removeAll () {
            count = 0;
        }
        
        inline int getCount () const {
            return count;
        }
        
        inline const T & operator[] ( int index ) const {
            // Check for index validity:
            if ( index < 0 || index >= count )
                throw std::out_of_range("Container index out of range");
            
            return data[index];
        }
        
        inline T & operator[] ( int index ) {
            // Check for index validity:
            if ( index < 0 || index >= count )
                throw std::out_of_range("Container index out of range");
            
            return data[index];
        }
        
        inline const T & elem ( int index ) const {
            return operator[]( index );
        }
        
        inline T & elem ( int index ) {
            return operator[]( index );
        }
        
        inline const T & tail () const {
            return operator[]( count - 1 );
        }
        
        
        inline T & tail () {
            return operator[]( count - 1 );
        }
        
        
        inline const T * getData () const {
            return data;
        }
        
        inline void toBeginning ( int index ) {
            // Check for index validity:
            if ( index < 0 || index >= count )
                throw std::out_of_range("Container index out of range");
            
            // Ignore if the object is already at the head of the Container:
            if ( index == 0 )
                return;
            
            // The element being moved:
            T elem = data[index];
            
            // Shift everyone towards the end:
            for ( int i = index; i >= 1; i-- )
                data[i] = data[i - 1];
            
            // Place the element at index 0:
            data[0] = elem;
        }
        
        inline void toEnd ( int index ) {
            // Check for index validity:
            if ( index < 0 || index >= count )
                throw std::out_of_range("Container index out of range");
            
            // Ignore if the object is already at the tail of the Container:
            if ( index == count - 1 )
                return;
            
            // The element being moved:
            T elem = data[index];
            
            // Shift everyone towards the beginning:
            for ( int i = index + 1; i < count; i++ )
                data[i - 1] = data[i];
            
            // Place the element at index "count - 1":
            data[count - 1] = elem;
        }
        
        inline void swap ( int i, int j ) {
            // Check for index validity:
            if ( i < 0 || i >= count ||
                 j < 0 || j >= count )
                throw std::out_of_range("Container index out of range");
            
            // Nothing to do if the indices are the same:
            if ( i == j )
                return;
            
            T tmp = data[j];
            data[j] = data[i];
            data[i] = tmp;
        }
        
        
        virtual ~Container () {
            delete[] data;
        }
        
    private:
        T * data;
        int capacity;
        int count;
        
        // Ensures the container's capacity will be "size" or larger.
        void reserve ( int size ) {
            if ( capacity < size ) {
                // Increase capacity in steps of 125%, until it's large enough.
                do {
                    capacity = (int) ceil( capacity * 1.25 );
                } while ( capacity < size );
                
                // Allocate new storage space:
                T * newData = new T[capacity];
                
                // Copy data to the new storage space:
                for ( int i = 0; i < count; i++ )
                    newData[i] = data[i];
                
                // Replace old data:
                delete[] data;
                data = newData;
            }
        }
    };

}

#endif

---