RscArrayWriter.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Commons/Exceptions/InvalidOperationException.hpp"
#include "Arp/Base/Rsc/Commons/Rsc.hpp"
#include "Arp/Base/Rsc/Commons/RscString.hxx"
#include "Arp/Base/Rsc/Commons/RscVariant.hxx"
#include "Arp/Base/Rsc/Commons/RscTypeInfo.hpp"
#include <functional>
 
namespace Arp::Base::Rsc::Commons
{
 
class ARP_EXPORT RscArrayWriter
{
public: // usings
    using RscWriter = Arp::Base::Rsc::Commons::Services::RscWriter;     
    using WriteElementFunction = RscVariant<>::WriteElementFunction;    
 
public: // construction
    template<int N>
    explicit RscArrayWriter(const RscVariant<N>& value);
    explicit RscArrayWriter(const RscVariantBase& value);
    RscArrayWriter(size_t size, RscType elementType, WriteElementFunction writeFunction);
    RscArrayWriter(size_t size, RscType elementType, RscWriter& writer, size_t dimensions = 1);
 
public: // setter/getter operations
    size_t  GetSize(void)const;
    RscType GetElementType(void)const;
    size_t  GetPosition(void)const;
 
public: // operations
    template<class T>   void WriteNext(const T& current);
    template<int N>     void WriteNext(const RscString<N>& current);
    template<int N>     void WriteNext(const RscVariant<N>& current);
 
    template<int N>
    RscVariant<N>   WriteNextStruct();
    RscArrayWriter  WriteNextArray(size_t size);
    void            WriteNextSimple(const RscVariantBase& value);
 
private: // methods
    void    WriteElement(RscType type, const RscVariantBase& value);
    void    SetWriterTo(const RscVariantBase& value);
 
private: // fields
    RscArrayInfo            arrayInfo;
    size_t                  position = 0;
    RscWriter*              pWriter = nullptr;
    WriteElementFunction    writeElementFunction;
    size_t                  maxStringSize = 0;
};
 
// inline methods of class RscArrayWriter<T>
 
template<int N>
inline RscArrayWriter::RscArrayWriter(const RscVariant<N>& value)
    : RscArrayWriter(static_cast<const RscVariantBase&>(value))
{
}
 
template<class T>
inline void RscArrayWriter::WriteNext(const T& current)
{
    if(!RscTypeInfo::IsPrimitiveType(this->GetElementType()) && this->GetElementType() != RscType::DateTime)
    {
        throw InvalidOperationException("This method can only be used with primitive Types");
    }
    RscVariant<> currentVariant(current);
    this->WriteNextSimple(currentVariant);
}
 
template<int N>
inline void RscArrayWriter::WriteNext(const RscString<N>& current)
{
    if(this->GetElementType() != RscType::String)
    {
        throw InvalidOperationException("This instance of RscArrayWriter is not for string operations");
    }
    if(N != this->maxStringSize)
    {
        throw InvalidOperationException("Size of current doesn't fit to maxStringSize");
    }
    RscVariantBase currentVariant(current);
    this->writeElementFunction(this->GetElementType(), currentVariant);
    ++this->position;
}
 
 
template<int N>
inline void RscArrayWriter::WriteNext(const RscVariant<N>& current)
{
    if (this->GetElementType() != RscType::Object)
    {
        throw InvalidOperationException("This instance of RscArrayWriter is not hasBegunWriter to contain objects");
    }
    if (N != this->maxStringSize)
    {
        throw InvalidOperationException("Size of current value doesn't fit to maxStringSize");
    }
    this->writeElementFunction(current.GetType(), current);
    if (current.IsComplexType())
    {
        this->SetWriterTo(current);
    }
    ++this->position;
}
 
template<int N>
inline RscVariant<N> RscArrayWriter::WriteNextStruct()
{
    if(this->arrayInfo.ElementType != RscType::Struct)
    {
        throw InvalidOperationException("This method is only valid with struct element types");
    }
 
    RscVariant<N> structVariant;
 
    if(this->pWriter == nullptr)
    {
        structVariant = RscVariant<N>::CreateStructVariant(this->arrayInfo.FieldCount);
        structVariant.SetWriteElementFunction(this->writeElementFunction);
        this->writeElementFunction(RscType::Struct, structVariant);
    }
    else
    {
        structVariant = RscVariant<N>::CreateStructVariant(this->arrayInfo.FieldCount);
        this->SetWriterTo(structVariant);
    }
 
    ++this->position;
    return structVariant;
}
 
} // end of namespace Arp::Base::Rsc::Commons