tb_list.h

// ================================================================================
// ==      This file is a part of Turbo Badger. (C) 2011-2014, Emil Segerås      ==
// ==                     See tb_core.h for more information.                    ==
// ================================================================================

#ifndef TB_LIST_H
#define TB_LIST_H

#include "tb_core.h"
namespace tb {

class TBListBackend
{
public:
    TBListBackend() : m_data(nullptr) {}
    ~TBListBackend() { RemoveAll(); }
    bool Reserve(int num);
    bool GrowIfNeeded();
    bool Add(void *data);
    bool Add(void *data, int index);
    void Set(void *data, int index);
    void *Get(int index) const;
    void *operator [] (int index) const { return Get(index); }
    void *RemoveFast(int index);
    void *Remove(int index);
    void RemoveAll();
    void Swap(int index1, int index2);
    int Find(void *data) const;
    int GetNumItems() const { return m_data ? m_data->num : 0; }
    int GetCapacity() const { return m_data ? m_data->capacity : 0; }
private:
    struct TBLIST_DATA {
        int num;
        int capacity;
        void **list;
    };
    TBLIST_DATA *m_data;
};

template<class T>
class TBListOf
{
public:
    bool Reserve(int num)                   { return m_list.Reserve(num); }

    bool GrowIfNeeded()                     { return m_list.GrowIfNeeded(); }

    bool Add(T *data)                       { return m_list.Add(data); }

    bool Add(T *data, int index)            { return m_list.Add(data, index); }

    void Set(T *data, int index)            { m_list.Set(data, index); }

    T *Get(int index) const                 { return (T *) m_list.Get(index); }

    T *operator [] (int index) const        { return (T *) m_list.Get(index); }

    T *RemoveFast(int index)                { return (T *) m_list.RemoveFast(index); }

    T *Remove(int index)                    { return (T *) m_list.Remove(index); }

    void DeleteFast(int index)              { delete (T *) m_list.RemoveFast(index); }

    void Delete(int index)                  { delete (T *) m_list.Remove(index); }

    void RemoveAll()                        { m_list.RemoveAll(); }

    void DeleteAll()
    {
        for (int i = 0; i < GetNumItems(); i++)
            delete (T *) Get(i);
        m_list.RemoveAll();
    }

    void Swap(int index1, int index2)       { m_list.Swap(index1, index2); }

    int Find(T *data) const                 { return m_list.Find(data); }

    int GetNumItems() const                 { return m_list.GetNumItems(); }

    int GetCapacity() const                 { return m_list.GetCapacity(); }
private:
    TBListBackend m_list;
};

template<class T>
class TBListAutoDeleteOf : public TBListOf<T>
{
public:
    ~TBListAutoDeleteOf() { TBListOf<T>::DeleteAll(); }
};

} // namespace tb

#endif // TB_LIST_H