TPointerCollection.hpp

Go to the documentation of this file.

#ifndef __TPointerCollection__
#define __TPointerCollection__

//  ===========================================================================

#include "../Basics/CCountedObject.hpp"
#include "TPointerDeleter.hpp"
using Exponent::Basics::CCountedObject;
using Exponent::Collections::TPointerDeleter;
using Exponent::Collections::TObjectDeleter;
using Exponent::Collections::TObjectNuller;

//  ===========================================================================


namespace Exponent
{
    namespace Collections
    {
        template<class TypeName> class TPointerCollection : public CCountedObject
        {
            EXPONENT_CLASS_DECLARATION;
//  ===========================================================================

        public:

//  ===========================================================================

            static TObjectDeleter<TypeName> TPOINTER_COLLECTION_DEFAULT_DELETER;        
            static TObjectNuller<TypeName>  TPOINTER_COLLECTION_DEFAULT_NULLER;         
//  ===========================================================================

            const static long TPOINTERCOLLECTION_DEFAULT_GROW_SIZE      = 32;           
            const static long TPOINTERCOLLECTION_FAILED_TO_FIND_POINTER = -1;           
//  ===========================================================================

            typedef int (_cdecl *qsortCompare)(const void*, const void*);

//  ===========================================================================

            TPointerCollection(TPointerDeleter<TypeName> *pointerDeleter = &TPOINTER_COLLECTION_DEFAULT_DELETER);

            virtual ~TPointerCollection();

//  ===========================================================================

            TypeName *operator [] (const long index);

//  ===========================================================================

            TypeName *elementAtIndex(const long index);

            const TypeName *constElementAtIndex(const long index) const;

            void addElement(TypeName *pointer);

            void addElementAtIndex(const long index, TypeName *pointer);

            void deletePointerAtIndex(const long index);

            TypeName *removeElementAtIndexWithoutDeletion(const long index);

//  ===========================================================================

            void swapIndexes(const long index1, const long index2);

            void reorder(const bool resize = true);

//  ===========================================================================

            long getIndexOfPointer(const TypeName *pointer);

            bool isPointerInArray(const TypeName *pointer);

            long getArraySize() const;

            long getInsertIndex() const;

            void clearArray();

            bool isArrayEmpty() const;

            void setGrowSize(const long growSize = TPOINTERCOLLECTION_DEFAULT_GROW_SIZE);

            long getNumberOfElementsUntilNextGrow();

//  ===========================================================================

            void registerPointerDeleter(TPointerDeleter<TypeName> *pointerDeleter = &TPOINTER_COLLECTION_DEFAULT_DELETER) { m_pointerDeletionHandler = pointerDeleter; }

//  ===========================================================================

            TypeName **getMutableInternalBuffer() { return m_array; }

            void sortArray(qsortCompare compareFunction);

//  ===========================================================================

        protected:

//  ===========================================================================

            void initialise();

            void expand();

            void freePointers();

//  ===========================================================================

            TypeName **m_array;                                         
            TPointerDeleter<TypeName> *m_pointerDeletionHandler;        
            long m_arraySize;                                           
            long m_growSize;                                            
            long m_insertIndex;                                         
//  ===========================================================================

        };

         EXPONENT_TEMPLATE_CLASS_IMPLEMENTATION(TPointerCollection<TypeName>, TypeName, CCountedObject);

         template<class TypeName> TObjectDeleter<TypeName> TPointerCollection<TypeName>::TPOINTER_COLLECTION_DEFAULT_DELETER;
         template<class TypeName> TObjectNuller<TypeName>  TPointerCollection<TypeName>::TPOINTER_COLLECTION_DEFAULT_NULLER;

//  ===========================================================================
         template<class TypeName> TPointerCollection<TypeName>::TPointerCollection(TPointerDeleter<TypeName> *pointerDeleter)
                                                              : m_array(NULL)
                                                              , m_pointerDeletionHandler(NULL)
                                                              , m_arraySize(0)
                                                              , m_growSize(0)
                                                              , m_insertIndex(0)
        {
            EXPONENT_CLASS_CONSTRUCTION(TPointerCollection<TypeName>);

            // First we want to register the pointer deleter
            this->registerPointerDeleter(pointerDeleter);

            // Set the default growing size
            this->setGrowSize();

            // We have no pointers just yet
            m_arraySize   = 0;
            m_insertIndex = 0;
            NULL_POINTER(m_array);
        }

//  ===========================================================================
        template<class TypeName> TPointerCollection<TypeName>::~TPointerCollection()
        {
            EXPONENT_CLASS_DESTRUCTION(TPointerCollection<TypeName>);
            this->freePointers();
        }

//  ===========================================================================
        template<class TypeName> TypeName *TPointerCollection<TypeName>::operator [] (const long index)
        {
            return this->elementAtIndex(index);
        }
//  ===========================================================================
        template<class TypeName> TypeName *TPointerCollection<TypeName>::elementAtIndex(const long index)
        {
            // Check the index is within the correct range and we have valid pointers
            if (m_array && (index >= 0) && (index < m_arraySize))
            {
                // Return the pointer
                return m_array[index];
            }

            // They failed
            return NULL;
        }
//  ===========================================================================
        template<class TypeName> const TypeName *TPointerCollection<TypeName>::constElementAtIndex(const long index) const
        {
            // Check the index is within the correct range and we have valid pointers
            if (m_array && (index >= 0) && (index < m_arraySize))
            {
                // Return the pointer
                return m_array[index];
            }

            // They failed
            return NULL;
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::addElement(TypeName *pointer)
        {
            // If we dont yet have an array, we want to create it
            if (m_array == NULL)
            {
                this->initialise();
            }

            // Check if we need more elements
            if (m_insertIndex >= m_arraySize)
            {
                this->expand();
            }

            // Add the element to the array
            m_array[m_insertIndex++] = pointer;

            // Notify handler
            if (m_pointerDeletionHandler)
            {
                m_pointerDeletionHandler->pointerAdded(pointer);
            }
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::addElementAtIndex(const long index, TypeName *pointer)
        {
            // Check we have valid indicies and pointers
            if (m_array && (index >= 0 && index < m_arraySize))
            {
                // Delete the current position
                this->deletePointerAtIndex(index);

                // Now null the pointer in the array
                m_array[index] = pointer;

                // Notify handler
                if (m_pointerDeletionHandler)
                {
                    m_pointerDeletionHandler->pointerAdded(pointer);
                }
            }
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::deletePointerAtIndex(const long index)
        {
            // Check we have valid indicies and pointers
            if (m_array && (index >= 0 && index < m_arraySize))
            {
                // If we have a handler, let it do the deleting
                if (m_pointerDeletionHandler)
                {
                    // Check its valid
                    if (m_array[index] != NULL)
                    {
                        // Delete it
                        m_pointerDeletionHandler->deletePointer(m_array[index]);
                    }
                }

                // Now null the pointer in the array
                NULL_POINTER(m_array[index]);
            }
        }

//  ===========================================================================
        template<class TypeName> TypeName *TPointerCollection<TypeName>::removeElementAtIndexWithoutDeletion(const long index)
        {
            // Check we have pointers and valid indicies
            if (m_array && (index >= 0 && index < m_arraySize))
            {
                // Get the object
                TypeName *object = m_array[index];

                // Null the position pointer
                NULL_POINTER(m_array[index]);

                // Return the new object
                return object;
            }

            // They failed!
            return NULL;
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::swapIndexes(const long index1, const long index2)
        {
            // If we have validity
            if (m_array && index1 >= 0 && index2 >= 0 && index1 < m_arraySize && index2 < m_arraySize)
            {
                // Copy the pointer
                TypeName *ptr   = m_array[index1];

                // Move first pointer
                m_array[index1] = m_array[index2];

                // STore the copy
                m_array[index2] = ptr;
            }
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::reorder(const bool resize)
        {
            // Check that we have values that are valid
            if (m_array == NULL)
            {
                return;
            }

            // Create a temporary array
            TypeName **tempArray = new TypeName*[m_arraySize];

            // Pointr to the final size
            long index = 0;

            // Copy everything
            for (long i = 0; i < m_arraySize; i++)
            {
                // Null the position
                NULL_POINTER(tempArray[i]);

                // If its non null
                if (m_array[i] != NULL)
                {
                    // We want to add it
                    tempArray[index++] = m_array[i];
                }
            }

            // We only resize if requested
            if (resize)
            {
                // We want to shrink the array
                if (index == m_arraySize)
                {
                    // Dont need to do anything, no nulls
                }
                else
                {
                    // Fewer elements
                    TypeName **tempArray2 = new TypeName*[index];

                    // Copy everything
                    for (long i = 0; i < index; i++)
                    {
                        // We want to store it
                        tempArray2[i] = tempArray[i];
                    }

                    // Store the new size
                    m_arraySize   = index;
                    m_insertIndex = m_arraySize;

                    // Delete the old array
                    FREE_ARRAY_POINTER(m_array);
                    FREE_ARRAY_POINTER(tempArray);

                    // Store the array
                    m_array = tempArray2;

                }
            }
            else
            {
                // Delete the old array
                FREE_ARRAY_POINTER(m_array);

                // Store the array
                m_array = tempArray;

                // Store the size ad the insert index
                // Size of the array has not changed
                m_insertIndex = index;
            }
        }

//  ===========================================================================
        template<class TypeName> long TPointerCollection<TypeName>::getIndexOfPointer(const TypeName *pointer)
        {
            // If we have an array
            if (m_array)
            {
                // Loop through the pointers
                for (long i = 0; i < m_arraySize; i++)
                {
                    // If its the one..
                    if (pointer == m_array[i])
                    {
                        // Then we are done
                        return i;
                    }
                }
            }

            // Pointer is not in the array
            return TPOINTERCOLLECTION_FAILED_TO_FIND_POINTER;
        }

//  ===========================================================================
        template<class TypeName> bool TPointerCollection<TypeName>::isPointerInArray(const TypeName *pointer)
        {
            return (this->getIndexOfPointer(pointer) != TPOINTERCOLLECTION_FAILED_TO_FIND_POINTER);
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::clearArray()
        {
            this->freePointers();
        }

//  ===========================================================================
        template<class TypeName> long TPointerCollection<TypeName>::getArraySize() const
        {
            return m_arraySize;
        }

//  ===========================================================================
        template<class TypeName> long TPointerCollection<TypeName>::getInsertIndex() const
        {
            return m_insertIndex;
        }

//  ===========================================================================
        template<class TypeName> bool TPointerCollection<TypeName>::isArrayEmpty() const
        {
            return (m_arraySize == 0);
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::setGrowSize(const long growSize)
        {
            m_growSize = growSize;
        }

//  ===========================================================================
        template<class TypeName> long TPointerCollection<TypeName>::getNumberOfElementsUntilNextGrow()
        {
            return m_arraySize - m_insertIndex;
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::sortArray(qsortCompare compareFunction)
        {
            qsort(m_array, m_arraySize, sizeof(TypeName *), compareFunction);
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::initialise()
        {
            // Delete any old array that we may have
            this->freePointers();

            // Expand to the initial size
            this->expand();
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::expand()
        {
            // Create a temporary array
            TypeName **tempArray = new TypeName*[m_arraySize + m_growSize];

            // Copy everything in
            for (long i = 0; i < m_arraySize + m_growSize; i++)
            {
                // Copy as necessary
                tempArray[i] = (i < m_arraySize) ? m_array[i] : NULL;
            }

            // Increase the array size
            m_arraySize += m_growSize;

            // Delete the old array
            FREE_ARRAY_POINTER(m_array);

            // Now store the new pointers
            m_array = tempArray;
        }

//  ===========================================================================
        template<class TypeName> void TPointerCollection<TypeName>::freePointers()
        {
            // Only if we have pointers
            if (m_array)
            {
                // If we have a handler, let it do the deleting
                if (m_pointerDeletionHandler)
                {
                    // Delete all the elements
                    for (long i = 0; i < m_arraySize; i++)
                    {
                        // Check its valid
                        if (m_array[i] != NULL)
                        {
                            // Delete it
                            m_pointerDeletionHandler->deletePointer(m_array[i]);
                        }
                    }
                }

                // Delete the array
                FREE_ARRAY_POINTER(m_array);
            }
            m_arraySize   = 0;
            m_insertIndex = 0;
        }

    }
}
#endif  // End of TPointerCollection.hpp

---