RscWriteEnumerator.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Rsc/Commons/Rsc.hpp"
#include "Arp/Base/Rsc/Commons/RscArrayWriter.hpp"
#include "Arp/Base/Rsc/Commons/IRscWriteEnumerator.hxx"
#include "Arp/Base/Rsc/Commons/Services/RscWriter.hpp"
#include "Arp/Base/Commons/Exceptions/InvalidOperationException.hpp"
 
namespace Arp::Base::Rsc::Commons::Services
{
 
template<class T>
class RscWriteEnumerator : public IRscWriteEnumerator<T>
{
public: // construction
    RscWriteEnumerator(RscWriter& rscWriter, bool isArrayEnumerator);
 
    // canonical construction/destruction/assignment
    RscWriteEnumerator(const RscWriteEnumerator& arg) = delete;
    RscWriteEnumerator(RscWriteEnumerator&& arg)noexcept;
    RscWriteEnumerator& operator=(const RscWriteEnumerator& arg) = delete;
    RscWriteEnumerator& operator=(RscWriteEnumerator&& arg)noexcept;
    ~RscWriteEnumerator(void)noexcept;
 
public: // operations of IRscWriteEnumerator
    void            BeginWrite(size_t currentArrayLength = (size_t) -1)override;
    void            WriteNext(const T& current)override;
    RscArrayWriter  WriteNext(size_t arraySize, RscType arrayElementType)override;
    void            EndWrite(void)override;
 
private: // fields
    RscWriter&  rscWriter;
    bool        isArrayEnumerator = false;
    size_t      arrayLength = 0;
    bool        ended = false;
    RscType     rscType = RscTypeDeduction().Get<T>();
    size_t      fieldCount = 0;
    bool        isConcreteType = RscTypeInfo::IsConcreteType(this->rscType);
};
 
// inline methods of class RscEnumerator
 
template<class T>
inline RscWriteEnumerator<T>::RscWriteEnumerator(RscWriteEnumerator&& arg)noexcept = default;
 
template<class T>
RscWriteEnumerator<T>& RscWriteEnumerator<T>::operator=(RscWriteEnumerator&& arg)noexcept = default;
 
template<class T>
inline RscWriteEnumerator<T>::~RscWriteEnumerator()noexcept = default;
 
template<class T>
inline RscWriteEnumerator<T>::RscWriteEnumerator(RscWriter& rscWriter, bool isArrayEnumerator)
    : isArrayEnumerator(isArrayEnumerator)
    , rscWriter(rscWriter)
    , rscType(RscTypeDeduction::GetFrom(T()))
    , fieldCount(StructInfo<T>().FieldCount)
{
}
 
template<class T>
inline void RscWriteEnumerator<T>::BeginWrite(size_t currentArrayLength)
{
    this->arrayLength = currentArrayLength;
 
    if(this->isArrayEnumerator)
    {
        if(this->arrayLength == (size_t) -1)
        {
            throw ArgumentException("Array length has to be defined for array enumerators.");
        }
        this->rscWriter.WriteTag(RscType::Array);
        // Write element Tag
        if(this->rscType == RscType::Struct)
        {
            this->rscWriter.WriteStructInfo(this->fieldCount);
        }
        else
        {
            this->rscWriter.WriteTag(this->rscType);
        }
        this->rscWriter.WriteArrayLength(this->arrayLength);
    }
    else // standard enumerator
    {
        if(this->arrayLength != (size_t) -1)
        {
            throw ArgumentException("Array length could not be defined for standard enumerators.");
        }
        this->rscWriter.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;
        this->rscWriter.Write(current, this->isConcreteType);
    }
    else // use standard enumerator
    {
        this->rscWriter.WriteEnumeratorTag(this->rscType);
        if(this->rscType == RscType::Struct)
        {
            this->rscWriter.WriteFieldCount(this->fieldCount);
        }
        this->rscWriter.Write(current, true);
    }
}
 
template<class T>
inline RscArrayWriter RscWriteEnumerator<T>::WriteNext(size_t arraySize, RscType arrayElementType)
{
    this->rscWriter.WriteTag(RscType::Array);
    this->rscWriter.WriteTag(arrayElementType);
    this->rscWriter.WriteArrayLength(arraySize);
    return RscArrayWriter(arraySize, arrayElementType, this->rscWriter);
}
 
template<class T>
inline void RscWriteEnumerator<T>::EndWrite()
{
    if(this->isArrayEnumerator)
    {
        if(this->arrayLength != 0)
        {
            throw InvalidOperationException("End of array enumerator was not reached yet");
        }
    }
    else // standard enumeration was written
    {
        this->rscWriter.WriteEnumeratorTag(RscType::End);
    }
    this->ended = true;
}
 
} // end of namespace Arp::Base::Rsc::Commons::Services