b2FreeList.h

/*
* Copyright (c) 2014 Google, Inc.
*
* This software is provided 'as-is', without any express or implied
* warranty.  In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/
#ifndef B2_FREE_LIST_H
#define B2_FREE_LIST_H

#include <Box2D/Common/b2IntrusiveList.h>
#include <Box2D/Common/b2Settings.h>

#ifndef B2_FREE_LIST_CHECK_ALLOCATED_ON_FREE
#define B2_FREE_LIST_CHECK_ALLOCATED_ON_FREE 0
#endif // B2_FREE_LIST_CHECK_ALLOCATED_ON_FREE


class b2FreeList
{
public:
    b2FreeList() { }

    ~b2FreeList() { }

    b2IntrusiveListNode* Allocate();

    void Free(b2IntrusiveListNode* node);

    void AddToFreeList(b2IntrusiveListNode* node);

    void RemoveAll();

    const b2IntrusiveListNode& GetAllocatedList() const {
        return m_allocated;
    }

    const b2IntrusiveListNode& GetFreeList() const {
        return m_free;
    }

protected:
    b2IntrusiveListNode m_allocated;
    b2IntrusiveListNode m_free;
};


template<typename T>
class b2TypedFreeList {
public:
    b2TypedFreeList() { }

    ~b2TypedFreeList() { }

    T* Allocate() {
        b2IntrusiveListNode* const node = m_freeList.Allocate();
        if (!node) return NULL;
        return T::GetInstanceFromListNode(node);
    }

    void Free(T* instance) {
        b2Assert(instance);
        m_freeList.Free(instance->GetListNode());
    }

    void AddToFreeList(T* instance)
    {
        b2Assert(instance);
        m_freeList.AddToFreeList(instance->GetListNode());
    }

    // Get the underlying b2FreeList.
    b2FreeList* GetFreeList() { return &m_freeList; }
    const b2FreeList* GetFreeList() const { return &m_freeList; }

protected:
    b2FreeList m_freeList;
};

#endif  // B2_FREE_LIST_H