LinkedObject.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.
 *
 * LinkedObject.h
 *
 ****/
#pragma once
 
#include <iterator>
#include <algorithm>
 
class LinkedObject
{
public:
    virtual ~LinkedObject() = default;
 
    virtual LinkedObject* next() const
    {
        return mNext;
    }
 
    bool insertAfter(LinkedObject* object)
    {
        if(object == nullptr) {
            return false;
        }
        mNext = object->mNext;
        object->mNext = this;
        return true;
    }
 
    bool operator==(const LinkedObject& other) const
    {
        return this == &other;
    }
 
    bool operator!=(const LinkedObject& other) const
    {
        return this != &other;
    }
 
private:
    friend class LinkedObjectList;
    LinkedObject* mNext{nullptr};
};
 
template <typename ObjectType> class LinkedObjectTemplate : public LinkedObject
{
public:
    template <typename T, typename TPtr, typename TRef> class IteratorTemplate
    {
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
 
        IteratorTemplate(TPtr x) : mObject(x)
        {
        }
 
        IteratorTemplate(TRef& x) : mObject(&x)
        {
        }
 
        IteratorTemplate(const IteratorTemplate& other) : mObject(other.mObject)
        {
        }
 
        IteratorTemplate& operator++()
        {
            this->mObject = static_cast<TPtr>(this->mObject->next());
            return *this;
        }
 
        IteratorTemplate operator++(int)
        {
            Iterator tmp(*this);
            operator++();
            return tmp;
        }
 
        bool operator==(const IteratorTemplate& rhs) const
        {
            return mObject == rhs.mObject;
        }
 
        bool operator!=(const IteratorTemplate& rhs) const
        {
            return mObject != rhs.mObject;
        }
 
        TRef operator*()
        {
            return *mObject;
        }
 
        TPtr operator->()
        {
            return mObject;
        }
 
        operator TPtr()
        {
            return mObject;
        }
 
    private:
        TPtr mObject;
    };
 
    using Iterator = IteratorTemplate<ObjectType, ObjectType*, ObjectType&>;
    using ConstIterator = IteratorTemplate<const ObjectType, const ObjectType*, const ObjectType&>;
 
    ObjectType* getNext() const
    {
        return static_cast<ObjectType*>(this->next());
    }
 
    bool insertAfter(ObjectType* object)
    {
        return LinkedObject::insertAfter(object);
    }
 
    Iterator begin() const
    {
        return Iterator(this);
    }
 
    Iterator end() const
    {
        return Iterator(nullptr);
    }
 
    Iterator cbegin() const
    {
        return ConstIterator(this);
    }
 
    Iterator cend() const
    {
        return ConstIterator(nullptr);
    }
};