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(const NotificationRegistration&) = delete;
    NotificationRegistration(NotificationRegistration&& other);
    ~NotificationRegistration() override;
 
    NotificationRegistration& operator=(const NotificationRegistration&) = delete;
    NotificationRegistration& operator=(NotificationRegistration&& other);
 
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)
{
    this->Initialize();
}
 
 
template<typename PayloadType>
NotificationRegistration<PayloadType>::NotificationRegistration(
    NotificationRegistration<PayloadType>&& other)
    : base_type(std::move(other)),
      NotificationSending(std::exchange(other.NotificationSending, nullptr)),
      NotificationNameId(std::exchange(other.NotificationNameId, NotificationNameIdType()))
{
}
 
 
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::exchange(other.NotificationSending, nullptr);
    this->NotificationNameId = std::exchange(other.NotificationNameId, NotificationNameIdType());
 
    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