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:
    virtual ~SpecializedPayload() = 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