LinkedObjectList.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * LinkedObjectList.h
 *
 ****/
#pragma once

#include "LinkedObject.h"

class LinkedObjectList
{
public:
    LinkedObjectList()
    {
    }

    LinkedObjectList(LinkedObject* object) : mHead(object)
    {
    }

    bool add(LinkedObject* object);

    bool add(const LinkedObject* object)
    {
        return add(const_cast<LinkedObject*>(object));
    }

    bool insert(LinkedObject* object)
    {
        if(object == nullptr) {
            return false;
        }

        object->mNext = mHead;
        mHead = object;
        return true;
    }

    bool insert(const LinkedObject* object)
    {
        return insert(const_cast<LinkedObject*>(object));
    }

    bool remove(LinkedObject* object);

    LinkedObject* pop()
    {
        if(mHead == nullptr) {
            return nullptr;
        }
        auto obj = mHead;
        mHead = mHead->mNext;
        obj->mNext = nullptr;
        return obj;
    }

    void clear()
    {
        mHead = nullptr;
    }

    LinkedObject* head()
    {
        return mHead;
    }

    const LinkedObject* head() const
    {
        return mHead;
    }

    bool isEmpty() const
    {
        return mHead == nullptr;
    }

protected:
    LinkedObject* mHead{nullptr};
};

template <typename ObjectType> class LinkedObjectListTemplate : public LinkedObjectList
{
public:
    using Iterator =
        typename LinkedObjectTemplate<ObjectType>::template IteratorTemplate<ObjectType, ObjectType*, ObjectType&>;
    using ConstIterator =
        typename LinkedObjectTemplate<ObjectType>::template IteratorTemplate<const ObjectType, const ObjectType*,
                                                                             const ObjectType&>;

    LinkedObjectListTemplate() = default;

    LinkedObjectListTemplate(ObjectType* object) : LinkedObjectList(object)
    {
    }

    ObjectType* head()
    {
        return reinterpret_cast<ObjectType*>(mHead);
    }

    const ObjectType* head() const
    {
        return reinterpret_cast<const ObjectType*>(mHead);
    }

    Iterator begin()
    {
        return head();
    }

    Iterator end()
    {
        return nullptr;
    }

    ConstIterator begin() const
    {
        return head();
    }

    ConstIterator end() const
    {
        return nullptr;
    }

    bool add(ObjectType* object)
    {
        return LinkedObjectList::add(object);
    }

    bool add(const ObjectType* object)
    {
        return LinkedObjectList::add(object);
    }

    bool insert(ObjectType* object)
    {
        return LinkedObjectList::insert(object);
    }

    bool insert(const ObjectType* object)
    {
        return LinkedObjectList::insert(object);
    }

    ObjectType* pop()
    {
        return reinterpret_cast<ObjectType*>(LinkedObjectList::pop());
    }

    size_t count() const
    {
        return std::count_if(begin(), end(), [](const ObjectType&) { return true; });
    }

    bool contains(const ObjectType& object) const
    {
        return std::find(begin(), end(), object);
    }
};

template <typename ObjectType> class OwnedLinkedObjectListTemplate : public LinkedObjectListTemplate<ObjectType>
{
public:
    OwnedLinkedObjectListTemplate() = default;

    OwnedLinkedObjectListTemplate(const OwnedLinkedObjectListTemplate& other) = delete;
    OwnedLinkedObjectListTemplate& operator=(const OwnedLinkedObjectListTemplate& other) = delete;

    ~OwnedLinkedObjectListTemplate()
    {
        clear();
    }

    bool remove(ObjectType* object)
    {
        bool res = LinkedObjectList::remove(object);
        delete object;
        return res;
    }

    void clear()
    {
        while(remove(this->head())) {
            //
        }
    }
};