NotificationRegistrationBase.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
 
#pragma once
 
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Nm/NotificationManagerTypes.hpp"
#include "Arp/System/Nm/Severity.hpp"
#include "Arp/System/Commons/Diagnostics/Logging/Loggable.hxx"
 
namespace Arp { namespace System { namespace Nm
{
 
 
template<class Derived>
class NotificationRegistrationBase
    : protected Arp::System::Commons::Diagnostics::Logging::Loggable <
      NotificationRegistrationBase<Derived >>
{
private:
    friend Derived;
 
    NotificationRegistrationBase() = default;
    NotificationRegistrationBase(
        const String notificationName, const String senderName, Severity severity);
    NotificationRegistrationBase(NotificationRegistrationBase&& other) = default;
 
public:
    NotificationRegistrationBase(const NotificationRegistrationBase&) = delete;
 
    virtual ~NotificationRegistrationBase() = default;
 
    NotificationRegistrationBase& operator=(NotificationRegistrationBase&& other) = default;
    NotificationRegistrationBase& operator=(const NotificationRegistrationBase&) = delete;
 
    void Dispose() noexcept;
 
    const String GetNotificationName() const;
 
    virtual NotificationNameIdType GetNotificationNameId() const = 0;
 
    const String GetSenderName() const;
 
    Severity GetSeverity() const;
 
    PayloadTypeIdType GetPayloadTypeId() const;
 
protected:
    virtual void DisposeImpl() = 0;
 
private:
    String NotificationName;
    String SenderName;
    Severity severity = Severity::Default;
};
 
 
template<class Derived>
NotificationRegistrationBase<Derived>::NotificationRegistrationBase(
    const String notificationName, const String senderName, Severity severity)
    : NotificationName(std::move(notificationName)),
      SenderName(std::move(senderName)),
      severity(std::move(severity))
{
}
 
 
template<class Derived>
void NotificationRegistrationBase<Derived>::Dispose() noexcept
{
    try
    {
        this->DisposeImpl();
    }
    catch (const Arp::Exception& e)
    {
        this->log.Error("Caught exception while unregistering notificationName={}: {}",
                        this->NotificationName, e.ToString());
    }
    catch (...)
    {
        this->log.Error(
            "Caught exception while unregistering notificationName={}", this->NotificationName);
    }
}
 
 
template<class Derived>
const String NotificationRegistrationBase<Derived>::GetNotificationName() const
{
    return this->NotificationName;
}
 
 
template<class Derived>
const String NotificationRegistrationBase<Derived>::GetSenderName() const
{
    return this->SenderName;
}
 
 
template<class Derived>
Severity NotificationRegistrationBase<Derived>::GetSeverity() const
{
    return this->severity;
}
 
 
template<class Derived>
PayloadTypeIdType NotificationRegistrationBase<Derived>::GetPayloadTypeId() const
{
    return Derived::payload_type::GetPayloadTypeId();
}
 
 
}}} // namespace Arp::System::Nm