RscImplReadEnumerator.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/IRscReadEnumerator.hxx"
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
template<class T>
class RscImplReadEnumerator : public IRscReadEnumerator<T>
{
public: // typedefs
    typedef std::function<size_t()>                 BeginFunction;
    typedef std::function<bool(T&)>                 NextFunction;
    typedef std::function<bool(RscArrayReader&)>    NextArrayFunction;
    typedef std::function<void()>                   EndFunction;
 
public: // construction/destruction
    RscImplReadEnumerator(void) = default;
    RscImplReadEnumerator(const RscImplReadEnumerator& arg) = default;
    RscImplReadEnumerator& operator=(const RscImplReadEnumerator& arg) = default;
    ~RscImplReadEnumerator(void) = default;
 
public: // properties
    BeginFunction       Begin;
 
    NextFunction        Next;
 
    NextArrayFunction   NextArray;
 
    EndFunction         End;
 
public: // setter/getter operations
 
public: // operations of IRscReadEnumerator
    size_t  BeginRead(void)override;
    bool    ReadNext(T&)override;
    bool    ReadNext(RscArrayReader& current)override;
    void    EndRead(void)override;
 
private: // fields
};
 
// inline methods of class RscImplReadEnumerator
template<class T>
inline size_t RscImplReadEnumerator<T>::BeginRead()
{
    if(!this->Begin)
    {
        throw InvalidOperationException("BeginWrite has to be intialized first.");
    }
    return this->Begin();
}
 
template<class T>
inline bool RscImplReadEnumerator<T>::ReadNext(T& current)
{
    if(!this->Next)
    {
        throw InvalidOperationException("Next has to be intialized first.");
    }
    return this->Next(current);
}
 
template<class T>
inline bool RscImplReadEnumerator<T>::ReadNext(RscArrayReader& current)
{
    if (!this->NextArray)
    {
        throw InvalidOperationException("NextArray has to be intialized first.");
    }
    return this->NextArray(current);
}
 
template<class T>
inline void RscImplReadEnumerator<T>::EndRead(void)
{
    if(this->End)
    {
        this->End();
    }
}
 
}}}} // end of namespace Arp::System::Rsc::Services