Enumerator.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Core/Exception.hpp"
#include "Arp/Base/Core/IEnumerator.hxx"
 
namespace Arp { namespace Base { namespace Core
{
 
template<class T>
class Enumerator : public IEnumerator<T>
{
public: // forwards of nested classes
    class Empty;
    class Composite;
    class StackComposite;
 
    template<class Predicate>
    class Filter;
    template<class Iterator, class IteratorAdapter>
    class StlAdapter;
    template<typename SourceEnumerator, typename TransformOperation>
    class Transform;
    template<class Iterator>
    class IteratorAdapters;
 
public: // construction/destruction
    Enumerator(void);
    Enumerator(const Enumerator& arg) = delete;
    Enumerator(Enumerator&& arg)noexcept;
    Enumerator& operator=(const Enumerator& arg) = delete;
    Enumerator& operator=(Enumerator&& arg)noexcept;
    ~Enumerator(void)override;
 
public: // static factory 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 CreateStlAdapter(const 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: // overridden operations inherited from IEnumerator
    T   GetCurrent(void)override;
 
private: // usings
    // remove const and & qualifier
    using TCurrent = typename std::remove_const<typename std::remove_reference<T>::type>::type;
 
protected:
    TCurrent current{}; 
};
 
// inline methods of class Enumerator<T>
 
template<class T>
inline Enumerator<T>::Enumerator() = default;
 
template<class T>
inline Enumerator<T>::Enumerator(Enumerator&& arg)noexcept = default;
 
template<class T>
inline typename Enumerator<T>::Enumerator& Enumerator<T>::operator=(Enumerator&& arg)noexcept = default;
 
template<class T>
inline Enumerator<T>::~Enumerator() = default;
 
// inherited doc
template<class T>
inline T Enumerator<T>::GetCurrent()
{
    return this->current;
}
 
}}} // end of namespace Arp::Base::Core
 
namespace Arp {
using Arp::Base::Core::Enumerator;
}