Enumerator.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/IEnumerator.hxx"
#include "Arp/System/Core/Exception.hpp"
#include <stack>
namespace Arp
{

template<class T>
class Enumerator : public IEnumerator<T>
{
public: // nested class Empty
    class Empty : public IEnumerator<T>
    {
    public: // construction/destruction
        Empty(void) = default;
        Empty(const Empty& arg) = default;
        Empty& operator=(const Empty& arg) = default;
        virtual ~Empty(void) = default;

    public: // overridden operations
        bool    MoveNext(void)override;
        T       GetCurrent(void)override;
    };

public: // nested class Composite
    class Composite : public IEnumerator<T>
    {
    public: // construction/destruction
        Composite(typename IEnumerator<T>::Ptr first, typename IEnumerator<T>::Ptr second);
        Composite(const Composite& arg) = default;
        Composite& operator=(const Composite& arg) = default;
        virtual ~Composite(void) = default;

    public: // overridden operations
        // inherited doc
        bool    MoveNext(void)override;
        // inherited doc
        T       GetCurrent(void)override;

    private: // fields
        typename IEnumerator<T>::Ptr first;
        typename IEnumerator<T>::Ptr second;
    };

public: // nested class StackComposite
    class StackComposite : public IEnumerator<T>
    {
    private: // usings/typdefs
        using Stack = std::stack<typename IEnumerator<T>::Ptr>;

    public: // construction/destruction
        StackComposite(void) = default;
        StackComposite(const StackComposite& arg) = default;
        StackComposite& operator=(const StackComposite& arg) = default;
        virtual ~StackComposite(void) = default;

    public: // overridden operations
        // inherited doc
        bool    MoveNext(void)override;
        // inherited doc
        T       GetCurrent(void)override;

    public: //  operations
        void    Push(typename IEnumerator<T>::Ptr e);
        size_t  GetSize() const;

    private: // fields
        Stack   enumerators;
    };

private:
    template<class Iterator>
    class IteratorAdapters
    {
        friend class Enumerator;

        struct Value
        {
            T& operator()(Iterator i)const
            {
                return *i;
            }
        };
        struct Key
        {
            T& operator()(Iterator i)const
            {
                return i->first;
            }
        };
        struct Mapped
        {
            T& operator()(Iterator i)const
            {
                return i->second;
            }
        };
    };

public:
    template<class Iterator, class IteratorAdapter = typename IteratorAdapters<Iterator>::Value>
    class StlAdapter : public IEnumerator<T>
    {
    public: // construction/destruction
        StlAdapter(Iterator begin, Iterator end);
        StlAdapter(const StlAdapter& arg) = default;
        StlAdapter& operator=(const StlAdapter& arg) = default;
        virtual ~StlAdapter(void) = default;

    public: // overridden operations
        // inherited doc
        bool    MoveNext(void)override;
        // inherited doc
        T       GetCurrent(void)override;

    private: // fields
        Iterator        begin;
        Iterator        end;
        bool            firstMove = true;
        IteratorAdapter iteratorAdapter;
    };

private:
    template<class Predicate>
    class FilterEnumerator : public IEnumerator<T>
    {
    public: // construction/destruction
        FilterEnumerator(typename IEnumerator<T>::Ptr source, Predicate predicate);

    public: // overridden operations
        // inherited doc
        bool MoveNext(void)override;
        // inherited doc
        T    GetCurrent(void)override;

    private: // fields
        typename IEnumerator<T>::Ptr source;
        Predicate                    predicate;
    };

public: // construction/destruction
    Enumerator(void) = default;
    Enumerator(const Enumerator& arg) = default;
    Enumerator& operator=(const Enumerator& arg) = default;
    virtual ~Enumerator(void) = default;

public: // static fields
    static Empty Null;

public: // static facrory operations
    static typename IEnumerator<T>::Ptr CreateEmpty(void);

    static typename IEnumerator<T>::Ptr CreateComposite(typename IEnumerator<T>::Ptr first, typename IEnumerator<T>::Ptr second);

    template<class TIterator>
    static typename IEnumerator<T>::Ptr CreateStlAdapter(TIterator begin, TIterator end);

    template<class TContainer>
    static typename IEnumerator<T>::Ptr CreateStlAdapter(TContainer& c);

    template<class TContainer>
    static typename IEnumerator<T>::Ptr CreateKeysAdapter(TContainer& c);

    template<class TContainer>
    static typename IEnumerator<T>::Ptr CreateMappedAdapter(TContainer& c);

    template<class Predicate>
    static typename IEnumerator<T>::Ptr CreateFilter(typename IEnumerator<T>::Ptr source, Predicate predicate);

public: // abstract/overridden operations inherited from IEnumerator
    // inherited doc
    virtual bool    MoveNext(void) = 0;
    // inherited doc
    virtual T       GetCurrent(void)override;

private: // usings
    using TCurrent = typename std::remove_const<typename std::remove_reference<T>::type>::type;

protected:
    TCurrent current; 
};

// inline methods of class Enumerator<T>::Empty
template<class T>
inline bool Enumerator<T>::Empty::MoveNext()
{
    return false;
}

template<class T>
inline T Enumerator<T>::Empty::GetCurrent()
{
    throw Exception("IEnumerator::GetCurrent() is not supported by empty enumerators");
}

// inline methods of class Enumerator<T>::Composite
template<class T>
inline Enumerator<T>::Composite::Composite(typename IEnumerator<T>::Ptr first, typename IEnumerator<T>::Ptr second)
    : first(first)
    , second(second)
{
}

template<class T>
inline bool Enumerator<T>::Composite::MoveNext()
{
    if (this->first)
    {
        if (this->first->MoveNext())
        {
            return true;
        }
        // else
        this->first.reset();
    }
    return this->second->MoveNext();
}

template<class T>
inline T Enumerator<T>::Composite::GetCurrent()
{
    if (this->first)
    {
        return this->first->GetCurrent();
    }
    // else
    return this->second->GetCurrent();
}

// inline methods of class Enumerator<T>::StackComposite
template<class T>
inline void Enumerator<T>::StackComposite::Push(typename IEnumerator<T>::Ptr e)
{
    this->enumerators.push(e);
}

template<class T>
inline bool Enumerator<T>::StackComposite::MoveNext()
{
    while (!this->enumerators.empty())
    {
        if (this->enumerators.top()->MoveNext())
        {
            return true;
        }
        // else must pop last enumerator
        this->enumerators.pop();
    }
    // reaching this point means stack is empty
    return false;
}

template<class T>
inline T Enumerator<T>::StackComposite::GetCurrent()
{
    return this->enumerators.top()->GetCurrent();
}

template<class T>
inline size_t Enumerator<T>::StackComposite::GetSize() const
{
    return this->enumerators.size();
}

// inline methods of class Enumerator<T>::StlAdapter
template<class T>
template<class Iterator, class IteratorAdapter>
inline Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::StlAdapter(Iterator begin, Iterator end)
    : begin(begin)
    , end(end)
    , iteratorAdapter()
{
}

template<class T>
template<class Iterator, class IteratorAdapter>
inline bool Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::MoveNext()
{
    if (this->firstMove)
    {
        this->firstMove = false;
        return this->begin != this->end;
    }
    // else
    return ++this->begin != this->end;
}

template<class T>
template<class Iterator, class IteratorAdapter>
inline T Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::GetCurrent()
{
    return this->iteratorAdapter(this->begin);
}

// inline methods of class Enumerator<T>::FilterEnumerator
template<class T>
template<class Predicate>
inline Enumerator<T>::FilterEnumerator<Predicate>::FilterEnumerator(
    typename IEnumerator<T>::Ptr source, Predicate predicate)
    : source(std::move(source)), predicate(std::move(predicate))
{
}


template<class T>
template<class Predicate>
inline bool Enumerator<T>::FilterEnumerator<Predicate>::MoveNext()
{
    while (this->source->MoveNext())
    {
        if (this->predicate(this->source->GetCurrent()))
        {
            return true;
        }
    }
    return false;
}


template<class T>
template<class Predicate>
inline T Enumerator<T>::FilterEnumerator<Predicate>::GetCurrent()
{
    return this->source->GetCurrent();
}


// inline methods of class Enumerator<T>
template<class T>
inline T Enumerator<T>::GetCurrent()
{
    return this->current;
}

template<class T>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateEmpty()
{
    return std::make_shared<Empty>();
}

template<class T>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateComposite(typename IEnumerator<T>::Ptr first, typename IEnumerator<T>::Ptr second)
{
    return std::make_shared<Composite>(first, second);
}

template<class T>
template<class TIterator>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateStlAdapter(TIterator begin, TIterator end)
{
    return std::make_shared<StlAdapter<TIterator>>(begin, end);
}

template<class T>
template<class TContainer>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateStlAdapter(TContainer& c)
{
    return CreateStlAdapter(c.begin(), c.end());
}

template<class T>
template<class TContainer>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateKeysAdapter(TContainer& c)
{
    return std::make_shared<StlAdapter<typename TContainer::const_iterator, typename IteratorAdapters<typename TContainer::const_iterator>::Key>>(c.begin(), c.end());
}

template<class T>
template<class TContainer>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateMappedAdapter(TContainer& c)
{
    return std::make_shared<StlAdapter<typename TContainer::const_iterator, typename IteratorAdapters<typename TContainer::const_iterator>::Mapped>>(c.begin(), c.end());
}


template<class T>
template<class Predicate>
inline typename  IEnumerator<T>::Ptr Enumerator<T>::CreateFilter(
    typename IEnumerator<T>::Ptr source, Predicate predicate)
{
    return std::make_shared<Enumerator<T>::FilterEnumerator<Predicate>>(source, predicate);
}


// Initializing of static fields of class Enumerator<T>
template<class T>
typename Enumerator<T>::Empty Enumerator<T>::Null;

} // end of namespace Arp