TypeInfo.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/TypeIdentifier.hpp"
#include "Arp/Plc/Commons/Meta/ArrayDimension.hpp"
#include "Arp/Plc/Commons/Meta/ArrayDimensions.hpp"
#include "Arp/Plc/Commons/Meta/StandardAttributes.hpp"
#include "Arp/Plc/Commons/Meta/CustomAttribute.hpp"
#include "Arp/Plc/Commons/Meta/CustomAttributes.hpp"
#include "Arp/System/Rsc/Services/IRscSerializable.hpp"
#include <vector>
#include <numeric>
 
namespace Arp { namespace Plc { namespace Commons { namespace Meta
{
 
 
using namespace Arp::System::Rsc::Services;
 
 
class TypeInfo : public IRscSerializable
{
public: // construction/destruction
    TypeInfo(void) = default;
    TypeInfo(DataType dataType, const TypeIdentifier& typeId, size_t size, size_t alignment);
    ARP_DEPRECATED("Use ChildTypeInfo to define arrays")
    TypeInfo(DataType elementType, const TypeIdentifier& elementTypeId, size_t elementSize, size_t alignment, const ArrayDimension& arrayDimension);
    ARP_DEPRECATED("Use ChildTypeInfo to define ArrayDimensions")
    TypeInfo(DataType elementType, const TypeIdentifier& elementTypeId, size_t elementSize, size_t alignment, const ArrayDimensions& arrayDimensions);
    TypeInfo(DataType dataType, const TypeIdentifier& typeId, size_t size, size_t alignment, StandardAttributes standardAttributes,
             const CustomAttributes& customAttributes);
    TypeInfo(DataType dataType, const TypeIdentifier& typeId);
    TypeInfo(const TypeInfo& arg) = default;
    TypeInfo(TypeInfo&& arg) = default;
    TypeInfo& operator=(const TypeInfo& arg) = default;
    TypeInfo& operator=(TypeInfo&& arg) = default;
    ~TypeInfo(void) override = default;
 
protected:
    TypeInfo(DataType dataType, const TypeIdentifier& typeId, size_t size, size_t alignment, const ArrayDimensions& arrayDimensions,
             StandardAttributes standardAttributes, const CustomAttributes& customAttributes);
 
 
public: // static fields
    static const TypeInfo Empty;
 
public: // IRscSerializable operatios
    void Serialize(RscWriter& writer)const override;
    void Deserialize(RscReader& reader)override;
 
public: // static operations
    static size_t GetFieldCount(void);
 
public: // setter/getter operations
    bool IsEmpty(void)const;
 
    bool IsHidden(void)const;
 
    size_t GetTypeSize()const;
 
    void SetDataType(DataTypeEnum arg);
 
    DataTypeEnum GetDataType()const;
 
    const CustomAttributes& GetAttributes(void)const;
 
    void SetTypeIdentifier(const TypeIdentifier& value);
 
    const TypeIdentifier& GetTypeIdentifier(void)const;
 
    size_t GetAlignment(void)const;
 
    ARP_DEPRECATED("Use ChildTypeInfo::GetArrayDimensions()")
    const ArrayDimensions& GetArrayDimensions(void)const;
 
    void SetStandardAttributes(StandardAttribute value);
 
    const StandardAttributes& GetStandardAttributes(void)const;
 
    size_t GetCacheSize(void)const;
 
public: // operations
    void AddStandardAttribute(StandardAttribute value);
 
    void AddCustomAttribute(const String& name, const RscVariant<256>& value);
 
private: // methods
    ARP_DEPRECATED("To be removed")
    void InsertDimension(ArrayDimension& dimension);
 
protected: // fields
    DataTypeEnum        dataType = DataType::None;
    TypeIdentifier      typeId;
    size_t              size = 0;
    size_t              alignment = 0;
    ArrayDimensions     dimensions; // To be moved to ChildTypeInfo
    StandardAttributes  standardAttributes;
    CustomAttributes    customAttributes;
 
private: // fields
};
 
// inline methods of class TypeInfo
 
inline size_t TypeInfo::GetFieldCount(void)
{
    return 7;
}
 
inline bool TypeInfo::IsEmpty()const
{
    return this->dataType.IsEmpty();
}
 
inline bool TypeInfo::IsHidden()const
{
    return this->standardAttributes.IsSet(StandardAttribute::Hidden);
}
 
inline size_t TypeInfo::GetTypeSize()const
{
    if (this->size != 0)
    {
        return this->size;
    }
    // else
    return this->dataType.GetSize();
}
 
inline void TypeInfo::SetDataType(DataTypeEnum arg)
{
    this->dataType = arg;
}
inline DataTypeEnum TypeInfo::GetDataType()const
{
    return this->dataType;
}
 
inline const CustomAttributes& TypeInfo::GetAttributes(void)const
{
    return this->customAttributes;
}
 
inline void TypeInfo::SetTypeIdentifier(const TypeIdentifier& value)
{
    this->typeId = value;
}
 
inline const TypeIdentifier& TypeInfo::GetTypeIdentifier()const
{
    return this->typeId;
}
 
inline const ArrayDimensions& TypeInfo::GetArrayDimensions(void)const
{
    return this->dimensions;
}
 
inline size_t TypeInfo::GetAlignment(void)const
{
    return this->alignment;
}
 
inline void TypeInfo::SetStandardAttributes(StandardAttribute value)
{
    this->standardAttributes = value;
}
 
inline const StandardAttributes& TypeInfo::GetStandardAttributes()const
{
    return this->standardAttributes;
}
 
inline void TypeInfo::AddStandardAttribute(StandardAttribute value)
{
    this->standardAttributes = this->standardAttributes.GetValue() | value;
}
 
inline void TypeInfo::AddCustomAttribute(const String& name, const RscVariant<256>& value)
{
    customAttributes.push_back(CustomAttribute(name, value));
}
 
inline size_t TypeInfo::GetCacheSize(void)const
{
    size_t cacheSize = 0;
    cacheSize += sizeof(this->dataType);
    cacheSize += this->typeId.GetCacheSize();
    cacheSize += sizeof(this->size);
    cacheSize += sizeof(this->alignment);
    cacheSize += this->dimensions.GetCacheSize();
    cacheSize += this->standardAttributes.GetCacheSize();
    cacheSize += std::accumulate(this->customAttributes.begin(), this->customAttributes.end(), static_cast<size_t>(0),
                                 [](size_t result, const CustomAttribute & each)
    {
        return result + each.GetCacheSize();
    });
    return cacheSize;
}
 
}}}} // end of namespace Arp::Plc::Commons::Meta