IceContainer.h

Go to the documentation of this file.

// Include Guard
#ifndef __ICECONTAINER_H__
#define __ICECONTAINER_H__

        #define CONTAINER_STATS

        enum FindMode
        {
                FIND_CLAMP,
                FIND_WRAP,

                FIND_FORCE_DWORD = 0x7fffffff
        };

        class ICECORE_API Container
        {
                public:
                // Constructor / Destructor
                                                                Container();
                                                                Container(const Container& object);
                                                                Container(udword size, float growth_factor);
                                                                ~Container();
                // Management


                inline_ Container&              Add(udword entry)
                                                                {
                                                                        // Resize if needed
                                                                        if(mCurNbEntries==mMaxNbEntries)        Resize();

                                                                        // Add new entry
                                                                        mEntries[mCurNbEntries++]       = entry;
                                                                        return *this;
                                                                }

                inline_ Container&              Add(const udword* entries, udword nb)
                                                                {
                                                                        // Resize if needed
                                                                        if(mCurNbEntries+nb>mMaxNbEntries)      Resize(nb);

                                                                        // Add new entry
                                                                        CopyMemory(&mEntries[mCurNbEntries], entries, nb*sizeof(udword));
                                                                        mCurNbEntries+=nb;
                                                                        return *this;
                                                                }



                inline_ Container&              Add(float entry)
                                                                {
                                                                        // Resize if needed
                                                                        if(mCurNbEntries==mMaxNbEntries)        Resize();

                                                                        // Add new entry
                                                                        mEntries[mCurNbEntries++]       = IR(entry);
                                                                        return *this;
                                                                }

                inline_ Container&              Add(const float* entries, udword nb)
                                                                {
                                                                        // Resize if needed
                                                                        if(mCurNbEntries+nb>mMaxNbEntries)      Resize(nb);

                                                                        // Add new entry
                                                                        CopyMemory(&mEntries[mCurNbEntries], entries, nb*sizeof(float));
                                                                        mCurNbEntries+=nb;
                                                                        return *this;
                                                                }

                inline_ Container&              AddUnique(udword entry)
                                                                {
                                                                        if(!Contains(entry))    Add(entry);
                                                                        return *this;
                                                                }



                                Container&              Empty();



                inline_ void                    Reset()
                                                                {
                                                                        // Avoid the write if possible
                                                                        // ### CMOV
                                                                        if(mCurNbEntries)       mCurNbEntries = 0;
                                                                }

                // HANDLE WITH CARE
                inline_ void                    ForceSize(udword size)
                                                                {
                                                                        mCurNbEntries = size;
                                                                }



                                bool                    SetSize(udword nb);



                                bool                    Refit();

                // Checks whether the container already contains a given value.
                                bool                    Contains(udword entry, udword* location=null) const;
                // Deletes an entry - doesn't preserve insertion order.
                                bool                    Delete(udword entry);
                // Deletes an entry - does preserve insertion order.
                                bool                    DeleteKeepingOrder(udword entry);
                inline_ void                    DeleteLastEntry()                                               { if(mCurNbEntries)     mCurNbEntries--;                        }
                inline_ void                    DeleteIndex(udword index)                               { mEntries[index] = mEntries[--mCurNbEntries];  }

                // Helpers
                                Container&              FindNext(udword& entry, FindMode find_mode=FIND_CLAMP);
                                Container&              FindPrev(udword& entry, FindMode find_mode=FIND_CLAMP);
                // Data access.
                inline_ udword                  GetNbEntries()                                  const   { return mCurNbEntries;                                 }       
                inline_ udword                  GetEntry(udword i)                              const   { return mEntries[i];                                   }       
                inline_ udword*                 GetEntries()                                    const   { return mEntries;                                              }       

                inline_ udword                  GetFirst()                                              const   { return mEntries[0];                                   }
                inline_ udword                  GetLast()                                               const   { return mEntries[mCurNbEntries-1];             }

                // Growth control
                inline_ float                   GetGrowthFactor()                               const   { return mGrowthFactor;                                 }       
                inline_ void                    SetGrowthFactor(float growth)                   { mGrowthFactor = growth;                               }       
                inline_ bool                    IsFull()                                                const   { return mCurNbEntries==mMaxNbEntries;  }       
                inline_ BOOL                    IsNotEmpty()                                    const   { return mCurNbEntries;                                 }       

                inline_ udword                  operator[](udword i)                    const   { ASSERT(i>=0 && i<mCurNbEntries); return mEntries[i];  }
                inline_ udword&                 operator[](udword i)                                    { ASSERT(i>=0 && i<mCurNbEntries); return mEntries[i];  }

                // Stats
                                udword                  GetUsedRam()                                    const;

                                //void                  operator = (const Container& object);

#ifdef CONTAINER_STATS
                inline_ udword                  GetNbContainers()                               const   { return mNbContainers;         }
                inline_ udword                  GetTotalBytes()                                 const   { return mUsedRam;                      }
                private:

                static  udword                  mNbContainers;          
                static  udword                  mUsedRam;                       
#endif
                private:
                // Resizing
                                bool                    Resize(udword needed=1);
                // Data
                                udword                  mMaxNbEntries;          
                                udword                  mCurNbEntries;          
                                udword*                 mEntries;                       
                                float                   mGrowthFactor;          
        };

#endif // __ICECONTAINER_H__