DynamicPortsBuilder.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/Plc/Commons/DataTypeEnum.hpp"
#include "Arp/Plc/Commons/Meta/TypeSystem/DataInfoDeduction.hxx"
#include "Arp/Plc/Commons/Meta/TypeSystem/TypeDefinition.hpp"
#include <array>
 
namespace Arp { namespace Plc { namespace Commons { namespace Meta
{
 
class DynamicPortsBuilder
{
public:
    template<typename TProgram, size_t MaxNumPorts>
    static DynamicPortsBuilder Create(const String& libraryNamespace, const String& programInstanceName,
                                      std::array<byte*, MaxNumPorts>& ports, size_t portsOffset);
 
private:
    DynamicPortsBuilder(const String& libraryNamespace, const String& programTypeName,
                        const String& programInstanceName, size_t programSize, size_t programAlign, size_t portsOffset,
                        size_t maximumNumberOfPorts, byte** ports);
 
public:
    size_t GetMaximumNumberOfPorts() const;
 
    size_t GetNumberOfPorts() const;
 
    const TypeSystem::TypeDefinition& GetTypeDefinition() const;
 
    template<typename T>
    void AddPort(const String& portName, T& value, StandardAttribute standardAttributes);
 
private:
    void AddPort(const String& name, DataTypeEnum dataType, const String& typeName, size_t size, size_t alignment,
                 const ArrayDimensions& dimensions, StandardAttribute standardAttributes, byte* pValue);
    void CheckNumberOfPorts() const;
    void CheckName(const String& name) const;
    void CheckDataType(const String& name, const String& typeName, DataTypeEnum dataType) const;
 
private:
    TypeSystem::TypeDefinition typeDefinition;
    String libraryNamespace;
    String programTypeName;
    String programInstanceName;
    size_t portsOffset;
    size_t maximumNumberOfPorts;
    byte** ports;
};
 
template<typename TProgram, size_t MaxNumPorts>
DynamicPortsBuilder DynamicPortsBuilder::Create(const String& libraryNamespace, const String& programInstanceName,
        std::array<byte*, MaxNumPorts>& ports, size_t portsOffset)
{
    return DynamicPortsBuilder(libraryNamespace, CommonTypeName<TProgram>(), programInstanceName, sizeof(TProgram),
                               alignof(TProgram), portsOffset, MaxNumPorts, ports.data());
}
 
template<typename T>
void DynamicPortsBuilder::AddPort(const String& portName, T& value, StandardAttribute standardAttributes)
{
    using namespace Arp::Plc::Commons::Meta::TypeSystem;
 
    DataInfoDeduction deduction(libraryNamespace);
    DataInfo dataInfo = deduction(portName, value);
    this->AddPort(portName, dataInfo.GetDataType(), dataInfo.GetTypeIdentifier().GetName(), sizeof(T), alignof(T),
                  dataInfo.GetArrayDimensions(), standardAttributes, reinterpret_cast<byte*>(&value));
}
 
}}}} // end of namespace Arp::Plc::Commons::Meta