SpecializedPayload.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
 
#pragma once
 
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Commons/Exceptions/ArgumentException.hpp"
#include "Arp/System/Nm/GenericPayload.hpp"
#include "Arp/System/Nm/IPayload.hpp"
#include "Arp/System/Nm/Notification.hpp"
#include "Arp/System/Nm/NotificationManager.hpp"
#include "Arp/System/Nm/RscVariantHelpers.hpp"
#include <type_traits>
 
namespace Arp { namespace System { namespace Nm
{
 
 
class LongStringPayloadField;
 
 
template<typename PayloadType>
class SpecializedPayload : public IPayload
{
    friend class LongStringPayloadField;
 
public:
    using ValueType = RawPayloadType::value_type;
    using FieldType = Arp::System::Rsc::Services::RscType;
 
    explicit SpecializedPayload(const Notification& notification);
 
    explicit SpecializedPayload(const GenericPayload& payloadArg);
 
protected:
    explicit SpecializedPayload(const String& formatString);
 
public:
    ~SpecializedPayload() override = 0;
 
    static PayloadTypeIdType GetPayloadTypeId();
 
    static const String GetPayloadTypeName();
 
    // Methods of IPayload
    PayloadTypeIdType GetId() const final;
    const String GetName() const final;
    const RawPayloadType& GetAsRawPayloadType() const final;
    const String ToString() const override;
 
    RawPayloadType&& MoveOutRawPayload();
 
    bool IsReadOnly() const;
 
protected: // operations
    void SetFormatString(const String& formatString);
 
 
    static size_t FieldIndexToFormatStringIndex(size_t fieldIndex);
 
    // The second template parameter of the following templates is used to conditionally
    // enable the corresponding member function based on the type T.
    // There is one variant for Enums (handeled as strings) and other types.
    // Since GetRscType<String>() != RscVariant(String()).GetType() there is a
    // special case for AddField<String>.
 
    template < typename T, typename std::enable_if < (!std::is_same<T, String>::value)&&
               (!std::is_enum<T>::value) >::type* = nullptr >
    size_t AddField()
    {
        return this->payload.AddField(Arp::System::Rsc::Services::GetRscType<T>());
    }
 
 
    template < typename T, typename std::enable_if < std::is_same<T, String>::value ||
               std::is_enum<T>::value >::type* = nullptr >
    size_t AddField()
    {
        return this->payload.AddField(Arp::System::Rsc::Services::RscType::String);
    }
 
 
    template < typename T, typename std::enable_if < !std::is_enum<T>::value >::type* = nullptr >
    void SetFieldValue(size_t fieldIndex, const T& value)
    {
        this->payload.SetFieldValue(fieldIndex, ValueType(value));
    }
 
    template<typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
    void SetFieldValue(size_t fieldIndex, T value)
    {
        try
        {
            this->payload.SetFieldValue(fieldIndex, Enum<T>(value).ToString());
        }
        catch (const std::out_of_range&)
        {
            throw Arp::System::Commons::ArgumentException::Create("value", static_cast<int>(value),
                    String::Format(
                        "The supplied value is not a enumerated value of {}", TypeName<T>().Value)
                    .CStr());
        }
    }
 
 
    template < typename T, typename std::enable_if < !std::is_enum<T>::value >::type* = nullptr >
    const T GetFieldValueAs(size_t fieldIndex) const
    {
        const ValueType& value = this->payload.GetFieldValue(fieldIndex);
        if (value.GetType() == Rsc::Services::RscType::None)
        {
            return T();
        }
        return rscvariant_cast<T>(value);
    }
 
    template<typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
    const T GetFieldValueAs(size_t fieldIndex) const
    {
        return Enum<T>::Parse(this->GetFieldValueAs<String>(fieldIndex));
    }
 
    size_t GetFieldCount() const;
 
private:
    GenericPayload payload;
};
 
 
class SpecializedPayloadHelper
{
    static INotificationManagerInfo& GetINotificationManagerInfo();
 
    template<typename PayloadType>
    friend class SpecializedPayload;
};
 
 
template<typename PayloadType>
SpecializedPayload<PayloadType>::SpecializedPayload(const String& formatString)
    : payload(GetId(), GetName())
{
    this->payload.SetFieldValue(this->payload.GetFieldIndexFormatString(), formatString);
}
 
 
template<typename PayloadType>
SpecializedPayload<PayloadType>::SpecializedPayload(const Notification& notification)
    : payload(GetId(), GetName(), notification)
{
}
 
 
template<typename PayloadType>
SpecializedPayload<PayloadType>::SpecializedPayload(const GenericPayload& payloadArg)
    : payload(GetId(), GetName(), payloadArg.GetAsRawPayloadType())
{
}
 
 
template<typename PayloadType>
SpecializedPayload<PayloadType>::~SpecializedPayload() = default;
 
 
template<typename PayloadType>
PayloadTypeIdType SpecializedPayload<PayloadType>::GetPayloadTypeId()
{
    static PayloadTypeIdType id;
    if (!id.IsValid())
    {
        id = SpecializedPayloadHelper::GetINotificationManagerInfo().GetPayloadTypeId(
                 GetPayloadTypeName());
    }
    return id;
}
 
 
template<typename PayloadType>
PayloadTypeIdType SpecializedPayload<PayloadType>::GetId() const
{
    return GetPayloadTypeId();
}
 
 
template<typename PayloadType>
const String SpecializedPayload<PayloadType>::GetPayloadTypeName()
{
    return TypeName<PayloadType>().Value;
}
 
 
template<typename PayloadType>
const String SpecializedPayload<PayloadType>::GetName() const
{
    return GetPayloadTypeName();
}
 
 
template<typename PayloadType>
const RawPayloadType& SpecializedPayload<PayloadType>::GetAsRawPayloadType() const
{
    return this->payload.GetAsRawPayloadType();
}
 
 
template<typename PayloadType>
const String SpecializedPayload<PayloadType>::ToString() const
{
    return this->payload.ToString();
}
 
template<typename PayloadType>
RawPayloadType&& SpecializedPayload<PayloadType>::MoveOutRawPayload()
{
    return this->payload.MoveOutRawPayload();
}
 
template<typename PayloadType>
bool SpecializedPayload<PayloadType>::IsReadOnly() const
{
    return this->payload.IsReadOnly();
}
 
 
template<typename PayloadType>
void SpecializedPayload<PayloadType>::SetFormatString(const String& formatString)
{
    this->payload.SetFieldValue(this->payload.GetFieldIndexFormatString(), formatString);
}
 
 
template<typename PayloadType>
size_t SpecializedPayload<PayloadType>::FieldIndexToFormatStringIndex(size_t fieldIndex)
{
    return fieldIndex - 1;
}
 
 
template<typename PayloadType>
size_t SpecializedPayload<PayloadType>::GetFieldCount() const
{
    return this->payload.GetFieldCount();
}
 
 
}}} // end of namespace Arp::System::Nm