ObjectList.h

Go to the documentation of this file.

#pragma once
#include <EASTL/vector.h>
#include "ObjectProxy.h"

class ObjectList;

struct OBJLIST
{
    Thing*                              t_thing;
    struct OBJLIST*                     prev;
    struct OBJLIST*                     next;
};

struct Internal_It
{
    ObjectList*                                     _ol;
    struct OBJLIST**                                _curr;
};

enum class ObjectListType
{
    None,
    FreeList,
    UsedList,
    TypeList
};

class ObjectList
{
public:
    ObjectList(enum class ObjectListType t = ObjectListType::None);
    ~ObjectList();

    ObjectList(const ObjectList & cpy);
    void setObjectListType(enum class ObjectListType _t);
    ObjectList& operator=(ObjectList const& rhs);

    OBJLIST* insert(Thing* t);
    void remove(Thing* t, bool OBJ3_DELETE = false); // Remove from Thing::List 

    Thing* front() const;
    Thing* tail() const;
    Thing* pop_front();
    Thing* pop_back();

    Thing* getNextThing(Thing* t) const; // Gets Child Pointer
    Thing* getPreviousThing(Thing* t) const; // Gets Parent Pointer

    size_t count() const; 
    enum class ObjectListType whatListAmI() const;

    template<typename Lambda>
    Thing*  processList(Lambda&& f); // Takes a std::function<bool(Thing*t)> and calls that for each thing. `Break;` is return false. *** CAN RETURN NULLPTR! ***

    inline Thing*  processList2(eastl::function<bool(Thing*)> f)
    {
        return processList(f);
    }

    void reset(); // Reset the list head and tail to 0.
    bool isEmpty() const; // Is there even a list here?s
    OBJLIST* AmIInList(Thing * t) const;

    Thing*  getNth(size_t i) const;

    eastl::vector<Thing*>         toThingVector();
    eastl::vector<ObjectProxy>    toObjectProxyVector();

    template <class Archive>
    void save(Archive& ar) const
    {
        ar(_count, _ListType);
        ThingNum curr;
        for (auto it = _start; it; it = it->next)
        {
            curr = it->t_thing->ThingNum;
            ASSERT(curr > 0);
            ar(curr);
        }
    }

    template <class Archive>
    void load(Archive& ar)
    {
        reset();

        size_t currCount; 
        ThingNum curr;
        ar(currCount, _ListType);

        for (auto i = 0; i < currCount; i++)
        {
            ar(curr);
            ASSERT(curr > 0);
            if (gsi.ObjectMan.isLoadingCritical())
            {
                gsi.ObjectMan.addObjectListToMap(this, curr);
            }
            else
            {
                ASSERT(gsi.ObjectMan.getThingNoChecks(curr));
                auto t = gsi.ObjectMan.getThingNoChecks(curr);
                if (_ListType == ObjectListType::FreeList)
                    t->FreeList = insert(t);
                else if (_ListType == ObjectListType::UsedList)
                    t->UsedList = insert(t);
                else if (_ListType == ObjectListType::TypeList)
                    t->TypeList[t->Type] = insert(t);
                else 
                    insert(t);
            }
        }
    }
private:
    static eastl::vector<Internal_It>                       _sit;

    enum class ObjectListType                               _ListType;
    struct OBJLIST*                                         _start;
    struct OBJLIST*                                         _end;
    size_t                                                  _count;
};

template <typename Lambda>
Thing* ObjectList::processList(Lambda&& f)
{
    if (_count)
    {
        auto it = _start;
        _sit.push_back({ this, &it });
        while (true)
        {
            if (!f(it->t_thing))
            {
                _sit.pop_back();
                return it->t_thing;
            }
            if (!it || !it->next) break;
            it = it->next;
        }
        _sit.pop_back();
    }
    return nullptr;
}