RscImplWriteEnumerator.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/delegate.hxx"
#include "Arp/System/Rsc/Services/IRscWriteEnumerator.hxx"
#include "Arp/System/Rsc/Services/RscArrayWriter.hpp"
#include <functional>


namespace Arp { namespace System { namespace Rsc { namespace Services
{

template<class T>
class RscImplWriteEnumerator : public IRscWriteEnumerator<T>
{
public: // typedefs
    typedef std::function<void(size_t)>                     BeginFunction;
    typedef std::function<void(const T&)>                   NextFunction;
    typedef std::function<RscArrayWriter(size_t, RscType)>  NextArrayFunction;
    typedef std::function<void()>                           EndFunction;

public: // construction/destruction
    RscImplWriteEnumerator(void) = default;
    RscImplWriteEnumerator(const RscImplWriteEnumerator& arg) = default;
    RscImplWriteEnumerator& operator=(const RscImplWriteEnumerator& arg) = default;
    ~RscImplWriteEnumerator(void) = default;

public: // properties
    BeginFunction       Begin;

    NextFunction        Next;

    NextArrayFunction   NextArray;

    EndFunction         End;

public: // setter/getter operations

public: // operations of IRscWriteEnumerator
    void            BeginWrite(size_t)override;
    void            WriteNext(const T&)override;
    RscArrayWriter  WriteNext(size_t arraySize, RscType elementType)override;
    void            EndWrite(void)override;

private: // fields
};

template<class T>
inline void RscImplWriteEnumerator<T>::BeginWrite(size_t count)
{
    if(!this->Begin)
    {
        throw InvalidOperationException("BeginWrite has to be intialized first.");
    }
    this->Begin(count);
}

template<class T>
inline void RscImplWriteEnumerator<T>::WriteNext(const T& current)
{
    if(!this->Next)
    {
        throw InvalidOperationException("WriteNext has to be intialized first.");
    }
    return this->Next(current);
}

template<class T>
inline RscArrayWriter RscImplWriteEnumerator<T>::WriteNext(size_t arraySize, RscType elementType)
{
    if (!this->NextArray)
    {
        throw InvalidOperationException("WriteNext has to be intialized first.");
    }
    return this->NextArray(arraySize, elementType);
}

template<class T>
inline void RscImplWriteEnumerator<T>::EndWrite(void)
{
    if(this->End)
    {
        this->End();
    }
}

}}}} // end of namespace Arp::System::Rsc::Services