RscArrayReader.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Rsc/Services/Rsc.h"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Rsc/Services/RscValueAdapter.hxx"
#include "Arp/System/Rsc/Services/RscVariant.hxx"
#include "Arp/System/Rsc/Services/RscStructReader.hxx"
#include <functional>
 
namespace Arp { namespace System { namespace Rsc { namespace Services
{
 
class RscArrayReader
{
public: // typedefs
    //using ReadElementFunction = std::function<RscType(RscType expectedType, byte*)>;
    using ReadElementFunction = RscVariant<>::ReadElementFunction;
 
public: // construction/destruction
    template<int N>
    RscArrayReader(const RscVariant<N>& value);
 
    RscArrayReader(size_t size, RscType elementType, ReadElementFunction readFunction);
 
    RscArrayReader(size_t size, RscType elementType, RemotingReader& reader);
 
    RscArrayReader(const RscArrayReader& arg) = default;
 
    RscArrayReader& operator=(const RscArrayReader& arg) = default;
    ~RscArrayReader(void) = default;
 
public: // setter/getter operations
    size_t  GetSize(void)const;
 
    RscType GetElementType(void)const;
 
    size_t GetDimensions(void)const;
 
    size_t  GetPosition(void)const;
 
    size_t GetFieldCount(void)const;
 
public: // operations
    template<class T>
    void ReadNext(T& current);
 
    template<int N>
    void ReadNext(RscString<N>& current);
 
    template<int N>
    void ReadNext(RscVariant<N>& current);
 
    void ReadNext(byte* pCurrent);
 
    RscArrayReader ReadNextArray(void);
 
    template<int MaxStringSize>
    RscStructReader<MaxStringSize> ReadNextStruct(void);
 
private: // methods
    RscType ReadRemotingValue(RscType expectedType, byte* pValue);
    void    CheckReadArgument(RscType argumentType, size_t maxLength);
 
private: // fields
    RscArrayInformation arrayInformation;
    size_t              position = 0;
    size_t              maxStringSize = 0;
    RemotingReader*     pReader = nullptr;
    ReadElementFunction readElementFunction;
};
 
// inline methods of class RscArrayReader<T>
 
template<int N>
inline RscArrayReader::RscArrayReader(const RscVariant<N>& value)
    : arrayInformation(value.GetArrayInformation())
    , pReader(value.typeInfo.pReader)
    , maxStringSize(N)
{
    if(value.GetType() != RscType::Array)
    {
        throw ArgumentException("'value' doesn't contain an array");
    }
    if (this->GetElementType() == RscType::None)
    {
        throw ArgumentException::Create("arrayElementType", this->GetElementType());
    }
 
    if(this->GetDimensions() == 0)
    {
        throw ArgumentException("{0}: dimension size has to be >= 0", __FUNCTION__);
    }
 
    if (value.typeInfo.pReadElementFunction != nullptr)
    {
        this->readElementFunction = *value.typeInfo.pReadElementFunction;
    }
    else if(this->pReader != nullptr)
    {
        this->readElementFunction = [&](RscType expectedType, byte * pValue)
        {
            return ReadRemotingValue(expectedType, pValue);
        };
    }
    else
    {
        throw ArgumentException("ReadElementFunction in RscVariant has to be defined");
    }
}
 
inline size_t RscArrayReader::GetSize()const
{
    return this->arrayInformation.Size;
}
 
inline RscType RscArrayReader::GetElementType()const
{
    return this->arrayInformation.ElementType;
}
 
inline size_t RscArrayReader::GetDimensions(void) const
{
    return this->arrayInformation.Dimensions;
}
 
inline size_t RscArrayReader::GetPosition()const
{
    return this->position;
}
 
inline size_t RscArrayReader::GetFieldCount(void) const
{
    return this->arrayInformation.FieldCount;
}
 
template<class T>
inline void RscArrayReader::ReadNext(T& current)
{
    if(!IsPrimitiveRscType(this->GetElementType()))
    {
        throw InvalidOperationException("This method can only be used with primitve Types");
    }
    if(this->GetDimensions() > 1)
    {
        throw InvalidOperationException("This element contains subarrays, please use ReadNextArray instead");
    }
    this->ReadNext(reinterpret_cast<byte*>(&current));
}
 
template<>
inline void RscArrayReader::ReadNext(DateTime& current)
{
    if(this->GetElementType() != RscType::DateTime)
    {
        throw InvalidOperationException("This method can only handle arrays of DateTime");
    }
    if(this->GetDimensions() > 1)
    {
        throw InvalidOperationException("This element contains subarrays, please use ReadNextArray instead");
    }
    this->ReadNext(reinterpret_cast<byte*>(&current));
}
 
template<int N>
inline void RscArrayReader::ReadNext(RscString<N>& current)
{
    this->CheckReadArgument(RscType::Utf8String, N);
    this->readElementFunction(this->GetElementType(), (byte*)current.CStr());
    ++this->position;
}
 
template<int N>
inline void RscArrayReader::ReadNext(RscVariant<N>& current)
{
    if(this->maxStringSize != N)
    {
        throw InvalidOperationException("Size of current doesn't fit to N");
    }
    RscType readType = this->readElementFunction(this->GetElementType(), current.GetDataAddress()); // in case of array info DataAdress starts wir ArrayInformation::size, in case of struct buffer starts with StructInformation::FieldCount
    current.SetType(readType);
    if(current.ContainsTypeInformation())
    {
        current.typeInfo.pReader = this->pReader;
        current.typeInfo.pReadElementFunction = &this->readElementFunction;
    }
    ++this->position;
}
 
template<int MaxStringSize>
inline RscStructReader<MaxStringSize> RscArrayReader::ReadNextStruct(void)
{
    if(this->GetElementType() != RscType ::Struct)
    {
        throw InvalidOperationException("{}: Method only valid for array of struct", __FUNCTION__);
    }
    if(this->GetDimensions() != 1)
    {
        throw InvalidOperationException("{}: Array Dimensions != 1, please read subarray information first", __FUNCTION__);
    }
    RscVariant<MaxStringSize> structVariant;
    this->ReadNext(structVariant);
 
    structVariant.GetStructInformation().FieldCount = this->arrayInformation.FieldCount;
 
    return RscStructReader<MaxStringSize>(structVariant);
}
 
}}}} // end of namespace Arp::System::Rsc::Services