RscImplWriteEnumerator.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Core/delegate.hxx"
#include "Arp/Base/Rsc/Commons/IRscWriteEnumerator.hxx"
#include "Arp/Base/Rsc/Commons/RscArrayWriter.hpp"
#include <functional>
 
namespace Arp::Base::Rsc::Commons::Services
{
 
template<class T>
class RscImplWriteEnumerator : public IRscWriteEnumerator<T>
{
public: // usings
    using BeginFunction     = std::function<void(size_t)>;                      
    using NextFunction      = std::function<void(const T&)>;                    
    using NextArrayFunction = std::function<RscArrayWriter(size_t, RscType)>;   
    using EndFunction       = std::function<void()>;                            
 
public: // construction
    RscImplWriteEnumerator(void);
 
public: // properties
    BeginFunction       Begin;      
    NextFunction        Next;       
    NextArrayFunction   NextArray;  
    EndFunction         End;        
 
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;
};
 
// inline methods of class RscImplWriteEnumerator
 
template<class T>
inline RscImplWriteEnumerator<T>::RscImplWriteEnumerator() = default;
 
template<class T>
inline void RscImplWriteEnumerator<T>::BeginWrite(size_t count)
{
    if(!this->Begin)
    {
        throw InvalidOperationException("Begin has to be initialized first.");
    }
    this->Begin(count);
}
 
template<class T>
inline void RscImplWriteEnumerator<T>::WriteNext(const T& current)
{
    if(!this->Next)
    {
        throw InvalidOperationException("Next has to be initialized first.");
    }
    return this->Next(current);
}
 
template<class T>
inline RscArrayWriter RscImplWriteEnumerator<T>::WriteNext(size_t arraySize, RscType elementType)
{
    if (!this->NextArray)
    {
        throw InvalidOperationException("NextArray has to be initialized first.");
    }
    return this->NextArray(arraySize, elementType);
}
 
template<class T>
inline void RscImplWriteEnumerator<T>::EndWrite(void)
{
    if(this->End)
    {
        this->End();
    }
}
 
} // end of namespace Arp::Base::Rsc::Commons::Services