NotificationManager.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
 
#pragma once
 
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Nm/INonBlockingNotificationSending.hpp"
#include "Arp/System/Nm/INotificationManagerInfo.hpp"
#include "Arp/System/Nm/INotificationReceiving.hpp"
#include "Arp/System/Nm/INotificationSending.hpp"
#include "Arp/System/Nm/NonBlockingNotificationRegistration.hpp"
#include "Arp/System/Nm/NonBlockingNotificationRegistration3.hpp"
#include "Arp/System/Nm/NonBlockingNotificationSendingAdapter.hpp"
#include "Arp/System/Nm/NotificationRegistration.hpp"
#include "Arp/System/Nm/NotificationSubscriber.hpp"
#include <memory>
 
namespace Arp { namespace System { namespace Nm
{
 
class NotificationManager
    : public INotificationSending
    , public INonBlockingNotificationSending
    , public INotificationManagerInfo
    , public INotificationReceiving
    , private Loggable<NotificationManager, true>
{
    friend class NonBlockingNotificationSendingAdapter;
 
public: // usings
    using Instance = NotificationManager;
    using InstancePtr = std::unique_ptr<Instance>;
 
private:
    class Impl;
 
public:
    explicit NotificationManager(size_t nonBlockingNotificationSendingProxyQueueLength = 128);
    NotificationManager(const NotificationManager&) = delete;
    NotificationManager(NotificationManager&&)noexcept = delete;
    NotificationManager& operator=(const NotificationManager&) = delete;
    NotificationManager& operator=(NotificationManager&&)noexcept = delete;
    ~NotificationManager(void)override;
 
public: // static singleton operations
    static Instance&    CreateInstance(size_t nonBlockingNotificationSendingProxyQueueLength = 128);
    static bool         IsCreated(void);
    static void         DisposeInstance(void);
    static Instance&    GetInstance(void);
 
public: // operations
    // High level operations using proxy objects
    template<typename PayloadType>
    NotificationRegistration<PayloadType> CreateNotificationRegistration(
        const String& notificationName, const String& senderName, Severity severity);
 
    template<typename PayloadType>
    NonBlockingNotificationRegistration<PayloadType> CreateNonBlockingNotificationRegistration(
        const String& notificationName, const String& senderName, Severity severity);
 
    template<typename PayloadType>
    NonBlockingNotificationRegistration<PayloadType> CreateNonBlockingNotificationRegistration2(
        const String& notificationName, const String& senderName, Severity severity);
 
    template<typename PayloadType, typename ArgumentsType = typename PayloadType::ArgumentsType>
    NonBlockingNotificationRegistration3<PayloadType, ArgumentsType> CreateNonBlockingNotificationRegistration3(
        const String& notificationName, const String& senderName, Severity severity,
        size_t argumentsBufferCapacity = GetDefaultArgumentsBufferCapacity());
 
    NotificationSubscriber CreateNotificationSubscriber(const String& notificationName);
 
    // Methods of INotificationSending
    NotificationNameIdType RegisterNotification(const String& notificationName, const String& senderName,
            Severity severity, PayloadTypeIdType payloadTypeId) override;
    void UnregisterNotification(NotificationNameIdType notificationNameId) override;
 
    NotificationIdType SendNotification(
        NotificationNameIdType notificationNameId, Arp::DateTime timestamp, const RawPayloadType& payload) override;
    NotificationIdType SendNotification(
        NotificationNameIdType notificationNameId, Arp::DateTime timestamp, const IPayload& payload) override;
 
    // Methods of INonBlockingNotificationSending
    Future<NotificationNameIdType> NonBlockingRegisterNotification(const String& notificationName,
            const String& senderName, Severity severity, PayloadTypeIdType payloadTypeId) override;
 
    void NonBlockingRegisterNotification(const String& notificationName, const String& senderName, Severity severity,
                                         PayloadTypeIdType payloadTypeId, Future<NotificationNameIdType> result);
 
    Future<void> NonBlockingUnregisterNotification(NotificationNameIdType notificationNameId) override;
 
    void NonBlockingUnregisterNotification(NotificationNameIdType notificationNameId, Future<void> result);
 
    Future<NotificationIdType> NonBlockingSendNotification(
        NotificationNameIdType notificationNameId, Arp::DateTime timestamp, const RawPayloadType& payload) override;
 
    void NonBlockingSendNotification(NotificationNameIdType notificationNameId, Arp::DateTime timestamp,
                                     std::function<RawPayloadType()> createPayloadFunctor, Future<NotificationIdType> result);
 
    Future<NotificationIdType> NonBlockingSendNotification(
        NotificationNameIdType notificationNameId, Arp::DateTime timestamp, const IPayload& payload) override;
 
private:
    void NonBlockingSendNotification(NotificationNameIdType notificationNameId, Arp::DateTime timestamp,
                                     NonBlockingNotificationSendingAdapter::CreatePayloadFunctor createPayloadFunctor,
                                     NonBlockingNotificationSendingAdapter::CreatePayloadFunctorArg createPayloadFunctorArg,
                                     Future<NotificationIdType> result);
 
    static size_t GetDefaultArgumentsBufferCapacity();
 
public:
    // Methods of INotificationManagerInfo
    String GetNotificationName(NotificationNameIdType notificationNameId) const override;
    NotificationNameIdType GetNotificationNameId(const String& notificationName) override;
 
    NotificationNameIdList GetNotificationNameIdsByStatus(
        const NotificationRegistrationStatus& status) const override;
    NotificationNameIdList GetAllKnownNotificationNameIds() const override;
    NotificationRegistrationInfo GetNotificationRegistration(
        NotificationNameIdType notificationNameId) const override;
 
    PayloadTypeIdType GetPayloadTypeId(const String& payloadTypeName) override;
    String GetPayloadTypeName(const PayloadTypeIdType& payloadTypeId) const override;
 
    Arp::uint64 GetNumberOfSubmittedNotifications() const override;
 
    // Methods of INotificationReceiving
    NotificationNameIdType Subscribe(const String& notificationName, INotificationSubscriber* subscriber) override;
    void Unsubscribe(NotificationNameIdType notificationNameId, INotificationSubscriber* subscriber) override;
    void UnsubscribeFromAll(INotificationSubscriber* subscriber) override;
 
    void ReplaceSubscriber(INotificationSubscriber* oldSubscriber, INotificationSubscriber* newSubscriber);
 
private:
    const std::unique_ptr<Impl> pImpl;
 
private: // static fields
    static InstancePtr instancePtr;
};
 
template<typename PayloadType>
NotificationRegistration<PayloadType> NotificationManager::CreateNotificationRegistration(
    const String& notificationName, const String& senderName, Severity severity)
{
    return NotificationRegistration<PayloadType>(notificationName, senderName, severity, *(this));
}
 
template<typename PayloadType>
NonBlockingNotificationRegistration<PayloadType> NotificationManager::CreateNonBlockingNotificationRegistration(
    const String& notificationName, const String& senderName, Severity severity)
{
    return NonBlockingNotificationRegistration<PayloadType>(notificationName, senderName, severity, *this);
}
 
template<typename PayloadType>
NonBlockingNotificationRegistration<PayloadType> NotificationManager::CreateNonBlockingNotificationRegistration2(
    const String& notificationName, const String& senderName, Severity severity)
{
    return NonBlockingNotificationRegistration<PayloadType>(
               notificationName, senderName, severity, new NonBlockingNotificationSendingAdapter(*this));
}
 
template<typename PayloadType, typename ArgumentsType>
NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>
NotificationManager::CreateNonBlockingNotificationRegistration3(
    const String& notificationName, const String& senderName, Severity severity, size_t argumentsBufferCapacity)
{
    return NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>(notificationName, senderName, severity,
            argumentsBufferCapacity, std::make_unique<NonBlockingNotificationSendingAdapter>(*this));
}
 
}}} // end of namespace Arp::System::Nm