DataTag.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/System/Rsc/Services/IRscSerializable.hpp"
 
 
 
namespace Arp { namespace Plc { namespace Commons { namespace Meta
{
 
using namespace Arp::System::Rsc::Services;
 
//forwards
class DataInfo;
class IChangeNavigator;
 
class DataTag : public IRscSerializable
{
    friend class DataInfo;
 
public: // construction/destruction
    DataTag(void) = default;
    DataTag(const String& name, const void* valueAddress, DataType dataType, const TypeIdentifier& typeId, bool isBackgroundDomain = false);
    DataTag(const DataTag& arg) = default;
    DataTag(DataTag&& arg) = default;
    DataTag& operator=(const DataTag& arg) = default;
    DataTag& operator=(DataTag&& arg) = default;
    ~DataTag(void) override = default;
 
public: // setter/getter operations
    bool IsEmpty(void)const;
 
    const String& GetName(void)const;
 
    void SetDataType(DataType value);
 
    DataTypeEnum& GetDataType(void);
 
    const DataTypeEnum& GetDataType(void)const;
 
    TypeIdentifier& GetTypeIdentifier(void);
 
    const TypeIdentifier& GetTypeIdentifier(void)const;
 
    void SetValueAddress(const byte* value);
 
    const byte* GetDataAddress(void)const;
 
    const byte* GetVariableAddress(void)const;
 
    const byte* GetChangeCounterpartAddress(void)const;
 
    bool IsBackgroundDomain(void)const;
 
    bool& IsBackgroundDomain(void);
 
    bool IsNullPointer(void)const;
 
    bool IsChangeCounterpartNullPointer(void)const;
 
    bool IsEmptyOrNullPointer(void)const;
 
public: // operations
    void    ResolveIndirection(void);
 
    void    ShiftValueAddress(size_t offset);
 
    void    SetChangeCounterpart(const byte* value, const byte* typeTag);
 
    void    SetChangeCounterpart(const DataTag& changeCounterpart);
 
    void    GetChangeInfo(const byte*& valueAddressOut, const byte*& changeCounterpartAddressOut, bool& isBackgroundDomainOut)const;
 
    void    Change(IChangeNavigator* pChangeNavigator);
 
public: // IRscSerializable operations
    void    Serialize(RscWriter& writer)const override;
    void    Deserialize(RscReader& reader)override;
    static size_t GetFieldCount(void);
 
private: // methods
    void    SetName(const String& value);
    void    SwapDomain(void);
 
private: // static methods
    static const byte* ResolveIndirectAddress(const byte* address);
 
private: // fields
    String          name;
    DataTypeEnum    dataType = DataType::None;
    TypeIdentifier  typeId;
    const byte*     variableAddress = nullptr;
    const byte*     changeCounterpartAddress = nullptr;
    bool            isBackgroundDomain = false;
};
 
// inline methods of class DataTag
inline bool DataTag::IsEmpty()const
{
    return this->dataType == DataType::None;
}
 
inline void DataTag::SetName(const String& value)
{
    this->name = value;
}
 
inline const String& DataTag::GetName()const
{
    return this->name;
}
 
inline void DataTag::SetDataType(DataType value)
{
    this->dataType = value;
}
 
inline DataTypeEnum& DataTag::GetDataType()
{
    return this->dataType;
}
 
inline const DataTypeEnum& DataTag::GetDataType()const
{
    return this->dataType;
}
 
inline TypeIdentifier& DataTag::GetTypeIdentifier()
{
    return this->typeId;
}
 
inline const TypeIdentifier& DataTag::GetTypeIdentifier()const
{
    return this->typeId;
}
 
inline void DataTag::SetValueAddress(const byte* value)
{
    this->variableAddress = value;
}
 
inline void DataTag::ShiftValueAddress(size_t offset)
{
    this->variableAddress += offset;
}
 
inline const byte* DataTag::GetDataAddress()const
{
    if (this->dataType.IsIndirect())
    {
        if (this->variableAddress == nullptr)
        {
            throw InvalidOperationException(
                "Attempt to dereference variableAddress == nullptr for DataTag: name={}, dataType={}",
                this->name, this->dataType);
        }
        return ResolveIndirectAddress(this->variableAddress);
    }
    // else
    return this->variableAddress;
}
 
inline const byte* DataTag::GetVariableAddress()const
{
    return this->variableAddress;
}
 
inline void DataTag::SetChangeCounterpart(const byte* value, const byte* /*typeTag*/)
{
    this->changeCounterpartAddress = value;
}
 
inline const byte* DataTag::GetChangeCounterpartAddress()const
{
    if (this->dataType.IsIndirect())
    {
        if (this->changeCounterpartAddress == nullptr)
        {
            throw InvalidOperationException(
                "Attempt to dereference changeCounterpartAddress == nullptr for DataTag: name={}, dataType={}",
                this->name, this->dataType);
        }
        return ResolveIndirectAddress(this->changeCounterpartAddress);
    }
    // else
    return this->changeCounterpartAddress;
}
 
inline bool DataTag::IsBackgroundDomain()const
{
    return this->isBackgroundDomain;
}
 
inline bool& DataTag::IsBackgroundDomain()
{
    return this->isBackgroundDomain;
}
 
inline bool DataTag::IsNullPointer()const
{
    return (this->variableAddress == nullptr) || (this->GetDataAddress() == nullptr);
}
 
inline bool DataTag::IsChangeCounterpartNullPointer()const
{
    return (this->changeCounterpartAddress == nullptr) || (this->GetChangeCounterpartAddress() == nullptr);
}
 
inline bool DataTag::IsEmptyOrNullPointer(void) const
{
    return this->IsEmpty() || this->IsNullPointer();
}
 
inline size_t DataTag::GetFieldCount()
{
    return 6;
}
 
 
inline const byte* DataTag::ResolveIndirectAddress(const byte* address)
{
    return *reinterpret_cast<byte*const*>(address);
}
 
}}}} // end of namespace Arp::Plc::Meta