Enumerator.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
 
#ifndef ARP_USE_ARP_SYSTEM_CORE
 
#include "Arp/Base/Core/Enumerator.hxx"
 
#else
 
#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
        {
            typename Iterator::reference operator()(Iterator i)const
            {
                return *i;
            }
        };
        struct ConstKey
        {
            const typename Iterator::value_type::first_type& operator()(Iterator i)const
            {
                return i->first;
            }
        };
        struct Mapped
        {
            typename Iterator::value_type::second_type& operator()(Iterator i)const
            {
                return i->second;
            }
        };
        struct ConstMapped
        {
            const typename Iterator::value_type::second_type& 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;
    };
 
private:
    template<typename SourceEnumerator, typename TransformOperation>
    class TransformEnumerator : public Arp::IEnumerator<T>
    {
    public:
        using Source = SourceEnumerator;
 
        TransformEnumerator(std::shared_ptr<SourceEnumerator> source, TransformOperation transformOp);
 
        bool MoveNext() override;
        T    GetCurrent() override;
 
    private:
        std::shared_ptr<SourceEnumerator> source;
        TransformOperation                transformOp;
    };
 
 
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 CreateKeysAdapter(const TContainer& c);
 
    template<class TContainer>
    static typename IEnumerator<T>::Ptr CreateMappedAdapter(TContainer& c);
 
    template<class TContainer>
    static typename IEnumerator<T>::Ptr CreateMappedAdapter(const TContainer& c);
 
    template<class Predicate>
    static typename IEnumerator<T>::Ptr CreateFilter(typename IEnumerator<T>::Ptr source, Predicate predicate);
 
    template<class SourceEnumerator, class TransformOperation>
    static typename IEnumerator<T>::Ptr CreateTransform(std::shared_ptr<SourceEnumerator> source, TransformOperation transformOp);
 
 
public: // abstract/overridden operations inherited from IEnumerator
    // inherited doc
    virtual bool    MoveNext(void) = 0;
    // inherited doc
    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>::TransformEnumerator
template<class T>
template<class SourceEnumerator, class TransformOperation>
Enumerator<T>::TransformEnumerator<SourceEnumerator, TransformOperation>::TransformEnumerator(
    std::shared_ptr<SourceEnumerator> source, TransformOperation transformOp)
    : source(std::move(source)), transformOp(std::move(transformOp))
{
}
 
 
template<class T>
template<class SourceEnumerator, class TransformOperation>
bool Enumerator<T>::TransformEnumerator<SourceEnumerator, TransformOperation>::MoveNext()
{
    return this->source->MoveNext();
}
 
 
template<class T>
template<class SourceEnumerator, class TransformOperation>
T Enumerator<T>::TransformEnumerator<SourceEnumerator, TransformOperation>::GetCurrent()
{
    return this->transformOp(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::iterator, typename IteratorAdapters<typename TContainer::iterator>::ConstKey>>(c.begin(), c.end());
}
 
template<class T>
template<class TContainer>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateKeysAdapter(const TContainer& c)
{
    return std::make_shared<StlAdapter<typename TContainer::const_iterator, typename IteratorAdapters<typename TContainer::const_iterator>::ConstKey>>(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::iterator, typename IteratorAdapters<typename TContainer::iterator>::Mapped>>(c.begin(), c.end());
}
 
template<class T>
template<class TContainer>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateMappedAdapter(const TContainer& c)
{
    return std::make_shared<StlAdapter<typename TContainer::const_iterator, typename IteratorAdapters<typename TContainer::const_iterator>::ConstMapped>>(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>>(std::move(source), predicate);
}
 
template<class T>
template<class SourceEnumerator, class TransformOperation>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateTransform(std::shared_ptr<SourceEnumerator> source, TransformOperation transformOp)
{
    return std::make_shared<Enumerator<T>::TransformEnumerator<SourceEnumerator, TransformOperation>>(
               std::move(source), transformOp);
}
 
// Initializing of static fields of class Enumerator<T>
template<class T>
typename Enumerator<T>::Empty Enumerator<T>::Null;
 
} // end of namespace Arp
 
#endif // ndef ARP_USE_ARP_SYSTEM_CORE