RscWriteEnumerator.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Rsc/Services/RscException.hpp"
#include "Arp/System/Rsc/Services/IRscWriteEnumerator.hxx"
#include "Arp/System/Rsc/Services/RscWriter.hpp"
#include "Arp/System/Rsc/Services/RscArrayWriter.hpp"
 
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
template<class T>
class RscWriteEnumerator : public IRscWriteEnumerator<T>
{
public: // typedefs
 
public: // construction/destruction
    RscWriteEnumerator(RscWriter& rscWriter, bool isArrayEnumerator);
    RscWriteEnumerator(const RscWriteEnumerator& arg) = default;
    ~RscWriteEnumerator(void);
 
public: // operations of IRscWriteEnumerator
    void            BeginWrite(size_t arrayLengthArg = (size_t) -1)override;
    void            WriteNext(const T& current)override;
    RscArrayWriter  WriteNext(size_t arraySize, RscType arrayElementType)override;
    void            EndWrite(void)override;
 
private: // deleted methods
    RscWriteEnumerator& operator=(const RscWriteEnumerator& arg) = delete;
 
private: // fields
    RemotingWriter& remotingWriter;
    bool isArrayEnumerator;
    RscType rscType;
    size_t arrayLength = 0;
    bool endWritten = false;
    size_t fieldCount = 0;
};
 
// inline methods of class RscEnumerator
template<class T>
inline RscWriteEnumerator<T>::RscWriteEnumerator(RscWriter& rscWriter, bool isArrayEnumeratorArg)
    : isArrayEnumerator(isArrayEnumeratorArg)
    , remotingWriter(rscWriter.GetRemotingWriter())
    , rscType(GetRscTypeFrom(T()))
    , fieldCount(StructInfo<T>().FieldCount)
{
}
 
template<class T>
inline RscWriteEnumerator<T>::~RscWriteEnumerator()
{
    if(!this->endWritten)
    {
        Log::Error("Rsc Enumerating was not ended properly, call EndWrite() method when writing was finished.");
    }
}
 
template<class T>
inline void RscWriteEnumerator<T>::BeginWrite(size_t arrayLengthArg)
{
    this->arrayLength = arrayLengthArg;
 
    if(this->isArrayEnumerator)
    {
        if(this->arrayLength == (size_t) -1)
        {
            throw ArgumentException("Array length has to be defined for array enumerators.");
        }
        this->remotingWriter.WriteTag(RscType::Array);
        // Write element Tag
        if(this->rscType == RscType::Struct)
        {
            this->remotingWriter.WriteBeginStruct(this->fieldCount);
        }
        else
        {
            this->remotingWriter.WriteTag(this->rscType);
        }
        this->remotingWriter.WriteArrayLength(this->arrayLength);
    }
    else // standard enumerator
    {
        if(this->arrayLength != (size_t) -1)
        {
            throw ArgumentException("Array length could not be defined for standard enumerators.");
        }
        this->remotingWriter.WriteTag(RscType::Enumerator);
    }
}
 
template<class T>
inline void RscWriteEnumerator<T>::WriteNext(const T& current)
{
    if(this->isArrayEnumerator)
    {
        if(this->arrayLength == 0)
        {
            throw InvalidOperationException("End of array enumerator reached");
        }
        // else
        --this->arrayLength;
    }
    else // use standard enumerator
    {
        this->remotingWriter.WriteEnumeratorTag(this->rscType);
        if(this->rscType == RscType::Struct)
        {
            this->remotingWriter.WriteFieldCount(this->fieldCount);
        }
    }
    RscValueAdapter<T> valueAdapter(current);
    valueAdapter.Write(this->remotingWriter, false);
}
 
template<class T>
inline RscArrayWriter RscWriteEnumerator<T>::WriteNext(size_t arraySize, RscType arrayElementType)
{
    this->remotingWriter.WriteTag(RscType::Array);
    this->remotingWriter.WriteTag(arrayElementType);
    this->remotingWriter.WriteArrayLength(arraySize);
    return RscArrayWriter(arraySize, arrayElementType, this->remotingWriter);
}
 
template<class T>
inline void RscWriteEnumerator<T>::EndWrite(void)
{
    if(this->isArrayEnumerator)
    {
        if(this->arrayLength != 0)
        {
            throw InvalidOperationException("End of array enumerator was not reached yet");
        }
    }
    else // use standard enumerator
    {
        this->remotingWriter.WriteEnumeratorTag(RscType::End);
    }
 
    this->endWritten = true;
}
 
}}}} // end of namespace Arp::System::Rsc::Services