RscStructWriter.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Rsc/Commons/RscVariant.hxx"
#include "Arp/Base/Rsc/Commons/RscTypeInfo.hpp"
#include "Arp/Base/Commons/Exceptions/InvalidOperationException.hpp"
 
namespace Arp::Base::Rsc::Commons
{
 
// type imports
using Arp::Base::Rsc::Commons::Services::RscWriter;
 
class ARP_EXPORT RscStructWriter
{
public: // usings
    using WriteElementFunction  = RscVariantBase::WriteElementFunction; 
 
public: // construction
    explicit RscStructWriter(const RscVariantBase& structVariant);
 
public: // static operations
    size_t GetFieldCount(void)const;
 
public: // operations
    template<class T>   void WriteNextField(const T& value);
    template<int N>     void WriteNextField(const RscVariant<N>& value);
    template<int N>     void WriteNextField(const RscString<N>& value);
    template<int N>     void WriteNextField(const RscSecureString<N>& value);
 
private: // methods
    void    WriteField(RscType valueType, const RscVariantBase& value);
    void    SetWriterTo(const RscVariantBase& value);
 
private: // fields
    RscStructInfo           structInfo;
    RscWriter*              pWriter = nullptr;
    WriteElementFunction    writeFieldFunction;
};
 
// inline methods of class RscStructWriter
 
template<class T>
inline void RscStructWriter::WriteNextField(const T& value)
{
    RscType type = RscTypeDeduction::GetFrom(value);
    if (!RscTypeInfo::IsSimpleType(type))
    {
        throw InvalidOperationException("This operation is only valid for simple types");
    }
    // else
    RscVariant<0> variant(value);
    this->writeFieldFunction(type, variant);
}
 
template<int N>
inline void RscStructWriter::WriteNextField(const RscVariant<N>& value)
{
    if(value.GetType() == RscType::Array)
    {
        this->writeFieldFunction(RscType::Array, value);
        if(this->pWriter == nullptr)
        {
            value.SetWriteElementFunction(this->writeFieldFunction);
        }
        else
        {
            this->SetWriterTo(value);
        }
    }
    else if (value.GetType() == RscType::Struct)
    {
        this->writeFieldFunction(RscType::Struct, value);
        if (this->pWriter == nullptr)
        {
            value.SetWriteElementFunction(this->writeFieldFunction);
        }
        else
        {
            this->SetWriterTo(value);
        }
    }
    else
    {
        this->writeFieldFunction(value.GetType(), value);
    }
}
 
template<int N>
inline void RscStructWriter::WriteNextField(const RscString<N>& value)
{
    RscVariantBase variantField(value);
    this->writeFieldFunction(RscType::String, variantField);
}
 
template<int N>
inline void RscStructWriter::WriteNextField(const RscSecureString<N>& value)
{
    RscVariantBase variantField(value);
    this->writeFieldFunction(RscType::SecureString, variantField);
}
 
} // end of namespace Arp::Base::Rsc::Commons