RscStructReader.hpp

 
//
//  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/RscString.hxx"
#include "Arp/Base/Rsc/Commons/RscVariant.hxx"
#include "Arp/Base/Rsc/Commons/RscTypeInfo.hpp"
#include "Arp/Base/Commons/Exceptions/InvalidOperationException.hpp"
#include <functional>
 
namespace Arp::Base::Rsc::Commons
{
 
using Arp::Base::Rsc::Commons::Services::RscReader;
using Arp::Base::Rsc::Commons::Internal::RscVariantAccessor;
 
// forwards
class RscArrayReader;
 
class ARP_EXPORT RscStructReader
{
public: // usings
    using ReadFieldFunction = RscVariantBase::ReadFieldFunction; 
 
public: // construction
    explicit RscStructReader(const RscVariantBase& structVariant);
 
public: // static operations
    size_t GetFieldCount(void)const;
 
public: // operations
    template<class T>   void ReadNextField(T& result);
    template<int N>     void ReadNextField(RscVariant<N>& result);
    template<int N>     void ReadNextField(RscString<N>& result);
    template<int N>     void ReadNextField(RscSecureString<N>& result);
 
private: // methods
    void    ReadField(RscType fieldType, RscVariantBase& result);
    void    SetReaderTo(RscVariantBase& value);
 
private: // fields
    RscStructInfo       structInfo;
    RscReader*          pReader = nullptr;
    ReadFieldFunction   readFieldFunction;
};
 
// inline methods of class RscStructReader
 
template<class T>
inline void RscStructReader::ReadNextField(T& result)
{
    using Arp::Base::Commons::Exceptions::InvalidOperationException;
 
    RscType fieldType = RscTypeDeduction::GetFrom(result);
    if(!RscTypeInfo::IsSimpleType(fieldType))
    {
        throw InvalidOperationException::Create("This method works only for simple types");
    }
    RscVariant<> value(fieldType);
    (void)this->readFieldFunction(fieldType, value);
    value.CopyTo(result);
}
 
template<int N>
inline void RscStructReader::ReadNextField(RscVariant<N>& result)
{
    this->readFieldFunction(RscType::Object, result);
    if (result.IsComplexType())
    {
        result.ResetComplexTypeInfo();
        if (this->pReader == nullptr)
        {
            result.SetReadElementFunction(this->readFieldFunction);
        }
        else
        {
            this->SetReaderTo(result);
        }
    }
}
 
template<int N>
inline void RscStructReader::ReadNextField(RscString<N>& result)
{
    RscVariantBase value(result);
    this->readFieldFunction(RscType::String, value);
}
 
template<int N>
inline void RscStructReader::ReadNextField(RscSecureString<N>& result)
{
    RscVariantBase value(result);
    this->readFieldFunction(RscType::SecureString, value);
}
 
} // end of namespace Arp::Base::Rsc::Commons