IceContainer.cpp

Go to the documentation of this file.

// Precompiled Header
#include "Stdafx.h"

using namespace IceCore;

// Static members
#ifdef CONTAINER_STATS
udword Container::mNbContainers = 0;
udword Container::mUsedRam = 0;
#endif



Container::Container() : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(2.0f)
{
#ifdef CONTAINER_STATS
        mNbContainers++;
        mUsedRam+=sizeof(Container);
#endif
}



Container::Container(udword size, float growth_factor) : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(growth_factor)
{
#ifdef CONTAINER_STATS
        mNbContainers++;
        mUsedRam+=sizeof(Container);
#endif
        SetSize(size);
}



Container::Container(const Container& object) : mMaxNbEntries(0), mCurNbEntries(0), mEntries(null), mGrowthFactor(2.0f)
{
#ifdef CONTAINER_STATS
        mNbContainers++;
        mUsedRam+=sizeof(Container);
#endif
        *this = object;
}



Container::~Container()
{
        Empty();
#ifdef CONTAINER_STATS
        mNbContainers--;
        mUsedRam-=GetUsedRam();
#endif
}



Container& Container::Empty()
{
#ifdef CONTAINER_STATS
        mUsedRam-=mMaxNbEntries*sizeof(udword);
#endif
        DELETEARRAY(mEntries);
        mCurNbEntries = mMaxNbEntries = 0;
        return *this;
}



bool Container::Resize(udword needed)
{
#ifdef CONTAINER_STATS
        // Subtract previous amount of bytes
        mUsedRam-=mMaxNbEntries*sizeof(udword);
#endif

        // Get more entries
        mMaxNbEntries = mMaxNbEntries ? udword(float(mMaxNbEntries)*mGrowthFactor) : 2; // Default nb Entries = 2
        if(mMaxNbEntries<mCurNbEntries + needed)        mMaxNbEntries = mCurNbEntries + needed;

        // Get some bytes for new entries
        udword* NewEntries = new udword[mMaxNbEntries];
        CHECKALLOC(NewEntries);

#ifdef CONTAINER_STATS
        // Add current amount of bytes
        mUsedRam+=mMaxNbEntries*sizeof(udword);
#endif

        // Copy old data if needed
        if(mCurNbEntries)       CopyMemory(NewEntries, mEntries, mCurNbEntries*sizeof(udword));

        // Delete old data
        DELETEARRAY(mEntries);

        // Assign new pointer
        mEntries = NewEntries;

        return true;
}



bool Container::SetSize(udword nb)
{
        // Make sure it's empty
        Empty();

        // Checkings
        if(!nb) return false;

        // Initialize for nb entries
        mMaxNbEntries = nb;

        // Get some bytes for new entries
        mEntries = new udword[mMaxNbEntries];
        CHECKALLOC(mEntries);

#ifdef CONTAINER_STATS
        // Add current amount of bytes
        mUsedRam+=mMaxNbEntries*sizeof(udword);
#endif
        return true;
}



bool Container::Refit()
{
#ifdef CONTAINER_STATS
        // Subtract previous amount of bytes
        mUsedRam-=mMaxNbEntries*sizeof(udword);
#endif

        // Get just enough entries
        mMaxNbEntries = mCurNbEntries;
        if(!mMaxNbEntries)      return false;

        // Get just enough bytes
        udword* NewEntries = new udword[mMaxNbEntries];
        CHECKALLOC(NewEntries);

#ifdef CONTAINER_STATS
        // Add current amount of bytes
        mUsedRam+=mMaxNbEntries*sizeof(udword);
#endif

        // Copy old data
        CopyMemory(NewEntries, mEntries, mCurNbEntries*sizeof(udword));

        // Delete old data
        DELETEARRAY(mEntries);

        // Assign new pointer
        mEntries = NewEntries;

        return true;
}



bool Container::Contains(udword entry, udword* location) const
{
        // Look for the entry
        for(udword i=0;i<mCurNbEntries;i++)
        {
                if(mEntries[i]==entry)
                {
                        if(location)    *location = i;
                        return true;
                }
        }
        return false;
}



bool Container::Delete(udword entry)
{
        // Look for the entry
        for(udword i=0;i<mCurNbEntries;i++)
        {
                if(mEntries[i]==entry)
                {
                        // Entry has been found at index i. The strategy is to copy the last current entry at index i, and decrement the current number of entries.
                        DeleteIndex(i);
                        return true;
                }
        }
        return false;
}



bool Container::DeleteKeepingOrder(udword entry)
{
        // Look for the entry
        for(udword i=0;i<mCurNbEntries;i++)
        {
                if(mEntries[i]==entry)
                {
                        // Entry has been found at index i.
                        // Shift entries to preserve order. You really should use a linked list instead.
                        mCurNbEntries--;
                        for(udword j=i;j<mCurNbEntries;j++)
                        {
                                mEntries[j] = mEntries[j+1];
                        }
                        return true;
                }
        }
        return false;
}



Container& Container::FindNext(udword& entry, FindMode find_mode)
{
        udword Location;
        if(Contains(entry, &Location))
        {
                Location++;
                if(Location==mCurNbEntries)     Location = find_mode==FIND_WRAP ? 0 : mCurNbEntries-1;
                entry = mEntries[Location];
        }
        return *this;
}



Container& Container::FindPrev(udword& entry, FindMode find_mode)
{
        udword Location;
        if(Contains(entry, &Location))
        {
                Location--;
                if(Location==0xffffffff)        Location = find_mode==FIND_WRAP ? mCurNbEntries-1 : 0;
                entry = mEntries[Location];
        }
        return *this;
}



udword Container::GetUsedRam() const
{
        return sizeof(Container) + mMaxNbEntries * sizeof(udword);
}

/*void Container::operator=(const Container& object)
{
        SetSize(object.GetNbEntries());
        CopyMemory(mEntries, object.GetEntries(), mMaxNbEntries*sizeof(udword));
        mCurNbEntries = mMaxNbEntries;
}*/