NotificationRegistration.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//

#pragma once

#include "Arp/System/Nm/INotificationSending.hpp"
#include "Arp/System/Nm/NotificationRegistrationBase.hpp"

namespace Arp { namespace System { namespace Nm
{


template<typename PayloadType>
class NotificationRegistration
    : public NotificationRegistrationBase<NotificationRegistration<PayloadType>>
{
private:
    using base_type = NotificationRegistrationBase<NotificationRegistration<PayloadType>>;

public:
    using payload_type = PayloadType;

    NotificationRegistration() = default;

    NotificationRegistration(const String& notificationName, const String& senderName,
                             Severity severity, INotificationSending& notificationSending);

    NotificationRegistration(NotificationRegistration&& other);
    ~NotificationRegistration() override;

    NotificationRegistration& operator=(NotificationRegistration&& other);

    NotificationRegistration(const NotificationRegistration&) = delete;
    NotificationRegistration& operator=(const NotificationRegistration&) = delete;


public:
    template<typename... Args>
    NotificationIdType SendNotification(Args&& ... args);

    template<typename... Args>
    NotificationIdType SendNotificationWithTimestamp(const DateTime& timestamp, Args&& ... args);

    NotificationNameIdType GetNotificationNameId() const override;

private:
    void Initialize();
    void DisposeImpl() override;


private: // fields
    INotificationSending* NotificationSending = nullptr;
    NotificationNameIdType NotificationNameId;
};


template<typename PayloadType>
NotificationRegistration<PayloadType>::NotificationRegistration(const String& notificationName,
        const String& senderName, Severity severity, INotificationSending& notificationSending)
    : base_type(notificationName, senderName, severity),
      NotificationSending(&notificationSending),
      NotificationNameId()
{
    this->Initialize();
}


template<typename PayloadType>
NotificationRegistration<PayloadType>::NotificationRegistration(
    NotificationRegistration<PayloadType>&& other)
    : base_type(std::move(other)),
      NotificationSending(std::move(other.NotificationSending)),
      NotificationNameId(std::move(other.NotificationNameId))
{
    other.NotificationSending = nullptr;
    other.severity = Severity::Default;
}


template<typename PayloadType>
NotificationRegistration<PayloadType>::~NotificationRegistration()
{
    this->Dispose();
}


template<typename PayloadType>
NotificationRegistration<PayloadType>& NotificationRegistration<PayloadType>::operator=(
    NotificationRegistration<PayloadType>&& other)
{
    if (this == &other)
    {
        return *this;
    }

    base_type::operator=(std::move(other));

    this->NotificationSending = std::move(other.NotificationSending);
    other.NotificationSending = nullptr;

    this->NotificationNameId = std::move(other.NotificationNameId);

    return *this;
}


template<typename PayloadType>
void NotificationRegistration<PayloadType>::Initialize()
{
    if (this->NotificationSending != nullptr && !this->NotificationNameId.IsValid())
    {
        this->NotificationNameId = this->NotificationSending->RegisterNotification(
                                       this->NotificationName, this->SenderName, this->severity, this->GetPayloadTypeId());
    }
}


template<typename PayloadType>
void NotificationRegistration<PayloadType>::DisposeImpl()
{
    if (this->NotificationSending != nullptr && this->NotificationNameId.IsValid())
    {
        this->NotificationSending->UnregisterNotification(this->NotificationNameId);
        this->NotificationNameId = NotificationNameIdType();
    }
}


template<typename PayloadType>
template<typename... Args>
NotificationIdType NotificationRegistration<PayloadType>::SendNotification(Args&& ... args)
{
    return this->SendNotificationWithTimestamp(DateTime::Now(), std::forward<Args>(args)...);
}


template<typename PayloadType>
template<typename... Args>
NotificationIdType NotificationRegistration<PayloadType>::SendNotificationWithTimestamp(
    const DateTime& timestamp, Args&& ... args)
{
    if (this->NotificationSending == nullptr)
    {
        return NotificationIdType();
    }
    if (!this->NotificationNameId.IsValid())
    {
        return NotificationIdType();
    }
    return this->NotificationSending->SendNotification(
               this->NotificationNameId, timestamp, PayloadType{std::forward<Args>(args)...});
}


template<class PayloadType>
NotificationNameIdType NotificationRegistration<PayloadType>::GetNotificationNameId() const
{
    return this->NotificationNameId;
}


}}} // namespace Arp::System::Nm