Enumerator.Transform.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"
 
namespace Arp { namespace Base { namespace Core
{
 
template<class T>
template<typename U, typename O>
class Enumerator<T>::Transform : public IEnumerator<T>
{
private: // usings
    using SourcePtr = typename IEnumerator<U>::Ptr;
    using TransformOperation = O;
 
public: // construction/destruction
    Transform(SourcePtr sourcePtr, O transformOp);
    Transform(const Transform& arg) = delete;
    Transform(Transform&& arg)noexcept;
    Transform& operator=(const Transform& arg) = delete;
    Transform& operator=(Transform&& arg)noexcept;
    ~Transform(void)override;
 
public: // overridden operations
    bool MoveNext(void)override;
    T    GetCurrent(void)override;
 
private: // fields
    SourcePtr           sourcePtr;
    TransformOperation  transformOp;
};
 
// inline methods of class Enumerator<T>::TransformEnumerator
 
template<class T>
template<class U, class O>
inline Enumerator<T>::Transform<U, O>::Transform(Transform&& arg)noexcept = default;
 
template<class T>
template<class U, class O>
inline typename Enumerator<T>::Transform<U, O>& Enumerator<T>::Transform<U, O>::operator=(Transform&& arg)noexcept = default;
 
template<class T>
template<class U, class O>
inline Enumerator<T>::Transform<U, O>::~Transform() = default;
 
template<class T>
template<class U, class O>
Enumerator<T>::Transform<U, O>::Transform(SourcePtr sourcePtr, O transformOp)
    : sourcePtr(std::move(sourcePtr)), transformOp(std::move(transformOp))
{
}
 
// inherited doc
template<class T>
template<class U, class O>
bool Enumerator<T>::Transform<U, O>::MoveNext()
{
    return this->sourcePtr->MoveNext();
}
 
// inherited doc
template<class T>
template<class U, class O>
T Enumerator<T>::Transform<U, O>::GetCurrent()
{
    return this->transformOp(this->sourcePtr->GetCurrent());
}
 
// Implementation of factory operation of class Enumerator<T>
 
template<class T>
template<class S, class O>
inline typename IEnumerator<T>::Ptr Enumerator<T>::CreateTransform(std::shared_ptr<S> sourcePtr, O transformOperation)
{
    using U = typename S::ValueType;
    return std::make_shared<Enumerator<T>::Transform<U, O>>(std::move(sourcePtr), std::move(transformOperation));
}
 
}}} // end of namespace Arp::Base::Core