Enumerator.StlAdapter.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/Detail/Enumerator.hxx"
#include "Arp/Base/Core/Detail/Enumerator.IteratorAdapters.hxx"
#include <stack>
 
namespace Arp { namespace Base { namespace Core
{
 
template<class T>
template<class Iterator, class IteratorAdapter>
class Enumerator<T>::StlAdapter : public IEnumerator<T>
{
public: // construction/destruction
    StlAdapter(Iterator begin, Iterator end);
    StlAdapter(const StlAdapter& arg) = delete;
    StlAdapter(StlAdapter&& arg)noexcept;
    StlAdapter& operator=(const StlAdapter& arg) = delete;
    StlAdapter& operator=(StlAdapter&& arg)noexcept;
    ~StlAdapter(void)override;
 
public: // overridden operations
    bool    MoveNext(void)override;
    T       GetCurrent(void)override;
 
private: // fields
    Iterator        begin;
    Iterator        end;
    bool            wasMoved = false;
    IteratorAdapter iteratorAdapter;
};
 
// inline methods of class Enumerator<T>::StlAdapter
 
template<class T>
template<class Iterator, class IteratorAdapter>
inline Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::StlAdapter(StlAdapter&& arg)noexcept = default;
 
template<class T>
template<class Iterator, class IteratorAdapter>
inline Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>& Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::operator=(StlAdapter&& arg)noexcept = default;
 
template<class T>
template<class Iterator, class IteratorAdapter>
inline Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::~StlAdapter() = default;
 
template<class T>
template<class Iterator, class IteratorAdapter>
inline Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::StlAdapter(Iterator begin, Iterator end)
    : begin(begin)
    , end(end)
{
}
 
// inherited doc
template<class T>
template<class Iterator, class IteratorAdapter>
inline bool Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::MoveNext()
{
    if (this->begin == this->end)
    {
        return false;
    }
    if (!this->wasMoved)
    {
        this->wasMoved = true;
    }
    else
    {
        ++this->begin;
    }
    return this->begin != this->end;
}
 
// inherited doc
template<class T>
template<class Iterator, class IteratorAdapter>
inline T Enumerator<T>::StlAdapter<Iterator, IteratorAdapter>::GetCurrent()
{
    if ((!this->wasMoved) || (this->begin == this->end))
    {
        throw Exception("Enumerator<T>::StlAdapter::GetCurrent(): StlAdapter enumerator is empty or enumerating has ended yet");
    }
    return this->iteratorAdapter(this->begin);
}
 
// Implementation of factory operation of class Enumerator<T>
 
template<class T>
template<class TIterator>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateStlAdapter(TIterator begin, TIterator end)
{
    return std::make_shared<StlAdapter<TIterator, typename IteratorAdapters<TIterator>::Value>>(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>::CreateStlAdapter(const 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());
}
 
 
 
}}} // end of namespace Arp::Base::Core