RscArrayReader.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/RscVariant.hxx"
#include "Arp/Base/Rsc/Commons/RscTypeInfo.hpp"
#include "Arp/Base/Rsc/Commons/RscStructReader.hpp"
#include "Arp/Base/Commons/Exceptions/InvalidOperationException.hpp"
 
namespace Arp::Base::Rsc::Commons
{
 
class ARP_EXPORT RscArrayReader
{
public: // usings
    using Reader = Arp::Base::Rsc::Commons::Services::RscReader;        
    using ReadElementFunction = RscVariantBase::ReadElementFunction;    
 
public: // construction
    template<int N>
    explicit RscArrayReader(const RscVariant<N>& arrayVariant);
    explicit RscArrayReader(const RscVariantBase& arrayVariant);
    RscArrayReader(size_t size, RscType elementType, const ReadElementFunction& readElementFunction);
    RscArrayReader(size_t size, RscType elementType, Reader& reader);
 
public: // setter/getter operations
    size_t  GetSize(void)const;
    RscType GetElementType(void)const;
    size_t  GetDimensions(void)const;
    size_t  GetFieldCount(void)const;
    size_t  GetPosition(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);
 
    template<int N>
    RscStructReader     ReadNextStruct(void);
    RscArrayReader      ReadNextArray(void);
 
private: // methods
    void    ReadNextSimple(RscVariant<>& value);
    void    ReadElement(RscType elementType, RscVariantBase& result);
    void    SetReaderTo(RscVariantBase& value);
    void    CheckReadArgument(RscType argumentType, size_t maxLength);
 
private: // fields
    RscArrayInfo        arrayInfo;
    size_t              position = 0;
    size_t              maxStringSize = 0;
    Reader*             pReader = nullptr;
    ReadElementFunction readElementFunction;
};
 
// inline methods of class RscArrayReader
 
template<int N>
inline RscArrayReader::RscArrayReader(const RscVariant<N>& arrayVariant)
    : RscArrayReader(static_cast<const RscVariantBase&>(arrayVariant))
{
}
 
template<class T>
inline void RscArrayReader::ReadNext(T& current)
{
    if(!RscTypeInfo::IsPrimitiveType(this->GetElementType()) && this->GetElementType() != RscType::DateTime)
    {
        throw InvalidOperationException("This method can only be used with primitive Types");
    }
    if(this->GetDimensions() > 1)
    {
        throw InvalidOperationException("This element contains subarrays, please use ReadNextArray instead");
    }
    RscVariant<> currentVariant(this->GetElementType());
    this->ReadNextSimple(currentVariant);
    currentVariant.CopyTo(current);
}
 
template<int N>
inline void RscArrayReader::ReadNext(RscString<N>& current)
{
    this->CheckReadArgument(RscType::String, N);
 
    RscVariantBase currentVariant(current);
    this->readElementFunction(this->GetElementType(), currentVariant);
    ++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");
    }
 
    // in case of array info data address starts wir ArrayInformation::size,
    // in case of struct buffer starts with StructInformation::FieldCount
    this->readElementFunction(this->GetElementType(), current);
    if (current.IsComplexType())
    {
        this->SetReaderTo(current);
        current.SetReadElementFunction(this->readElementFunction);
    }
    ++this->position;
}
 
template<int N>
inline RscStructReader RscArrayReader::ReadNextStruct()
{
    if(this->GetElementType() != RscType::Struct)
    {
        throw InvalidOperationException("Operation only valid for array of structs");
    }
    if(this->GetDimensions() != 1)
    {
        throw InvalidOperationException("Array Dimensions != 1, please read subarray information first");
    }
    RscVariant<N> structVariant;
    this->ReadNext(structVariant);
 
    structVariant.SetStructInfo(this->arrayInfo.FieldCount);
 
    return RscStructReader(structVariant);
}
 
} // end of namespace Arp::Base::Rsc::Commons