NonBlockingNotificationRegistration.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
 
 
#pragma once
 
 
#include "Arp/System/Nm/NonBlockingNotificationSendingAdapter.hpp"
#include "Arp/System/Nm/NotificationRegistrationBase.hpp"
 
 
namespace Arp { namespace System { namespace Nm
{
 
 
template<typename PayloadType>
class NonBlockingNotificationRegistration
    : public NotificationRegistrationBase<NonBlockingNotificationRegistration<PayloadType>>
{
private:
    using base_type =
        NotificationRegistrationBase<NonBlockingNotificationRegistration<PayloadType>>;
 
public:
    using payload_type = PayloadType;
 
    NonBlockingNotificationRegistration() = default;
 
    NonBlockingNotificationRegistration(const String& notificationName, const String& senderName,
                                        Severity severity, INonBlockingNotificationSending& notificationSending);
 
    NonBlockingNotificationRegistration(const String& notificationName, const String& senderName,
                                        Severity severity, NonBlockingNotificationSendingAdapter* adapter);
 
    NonBlockingNotificationRegistration(const NonBlockingNotificationRegistration&) = delete;
    NonBlockingNotificationRegistration(NonBlockingNotificationRegistration&& other);
    ~NonBlockingNotificationRegistration() override;
 
 
    NonBlockingNotificationRegistration& operator=(const NonBlockingNotificationRegistration&) = delete;
    NonBlockingNotificationRegistration& operator=(NonBlockingNotificationRegistration&& other);
 
    template<typename... Args>
    Future<NotificationIdType> SendNotification(Args&& ... args);
 
    template<typename... Args>
    Future<NotificationIdType> SendNotificationWithTimestamp(
        const DateTime& timestamp, Args&& ... args);
 
    NotificationNameIdType GetNotificationNameId() const override;
 
    NotificationIdType GetLastNotificationId() const;
 
    bool IsCompleted() const;
 
private:
    void Initialize();
    void DisposeImpl() override;
 
    bool IsNotificationNameIdValid() const;
 
 
private:
    INonBlockingNotificationSending* NotificationSending = nullptr;
    Future<NotificationNameIdType>   futureNotificationNameId;
    Future<NotificationIdType>       futureNotificationId;
    Future<void>                     futureUnregister;
 
    enum class State
    {
        Uninitialized,
        RegisterCalled,
        SendCalled,
        UnregisterCalled
    };
    State state = State::Uninitialized;
};
 
 
template<typename PayloadType>
NonBlockingNotificationRegistration<PayloadType>::NonBlockingNotificationRegistration(
    const String& notificationName, const String& senderName, Severity severity,
    INonBlockingNotificationSending& notificationSending)
    : base_type(notificationName, senderName, severity), NotificationSending(&notificationSending)
{
    this->Initialize();
}
 
template<typename PayloadType>
NonBlockingNotificationRegistration<PayloadType>::NonBlockingNotificationRegistration(
    const String& notificationName, const String& senderName, Severity severity,
    NonBlockingNotificationSendingAdapter* adapter)
    : base_type(notificationName, senderName, severity),
      NotificationSending(adapter)
{
    this->Initialize();
}
 
 
template<typename PayloadType>
NonBlockingNotificationRegistration<PayloadType>::NonBlockingNotificationRegistration(
    NonBlockingNotificationRegistration<PayloadType>&& other)
    : base_type(std::move(other)),
      NotificationSending(std::move(other.NotificationSending)),
      futureNotificationNameId(std::move(other.futureNotificationNameId)),
      futureNotificationId(std::move(other.futureNotificationId)),
      futureUnregister(std::move(other.futureUnregister)),
      state(std::move(other.state))
{
    other.NotificationSending = nullptr;
    other.state = State::Uninitialized;
}
 
 
template<typename PayloadType>
NonBlockingNotificationRegistration<PayloadType>::~NonBlockingNotificationRegistration()
{
    this->Dispose();
}
 
 
template<typename PayloadType>
NonBlockingNotificationRegistration<PayloadType>& NonBlockingNotificationRegistration<PayloadType>::
operator=(NonBlockingNotificationRegistration<PayloadType>&& other)
{
    if (this == &other)
    {
        return *this;
    }
 
    base_type::operator=(std::move(other));
 
    this->NotificationSending = std::move(other.NotificationSending);
    other.NotificationSending = nullptr;
 
    this->futureNotificationNameId = std::move(other.futureNotificationNameId);
    this->futureNotificationId = std::move(other.futureNotificationId);
    this->futureUnregister = std::move(other.futureUnregister);
 
    this->state = std::move(other.state);
    other.state = State::Uninitialized;
 
    return *this;
}
 
 
template<typename PayloadType>
void NonBlockingNotificationRegistration<PayloadType>::Initialize()
{
    if ((this->NotificationSending != nullptr) && (!this->IsNotificationNameIdValid()))
    {
        auto* adapterPtr =
            dynamic_cast<NonBlockingNotificationSendingAdapter*>(this->NotificationSending);
        if (adapterPtr != nullptr)
        {
            adapterPtr->NonBlockingRegisterNotification(this->NotificationName, this->SenderName,
                    this->severity, this->GetPayloadTypeId(), this->futureNotificationNameId);
        }
        else
        {
            this->futureNotificationNameId =
                this->NotificationSending->NonBlockingRegisterNotification(this->NotificationName,
                        this->SenderName, this->severity, this->GetPayloadTypeId());
        }
        this->state = State::RegisterCalled;
    }
}
 
 
template<typename PayloadType>
void NonBlockingNotificationRegistration<PayloadType>::DisposeImpl()
{
    if ((this->NotificationSending != nullptr) && this->IsNotificationNameIdValid())
    {
        auto* adapterPtr =
            dynamic_cast<NonBlockingNotificationSendingAdapter*>(this->NotificationSending);
        if (adapterPtr != nullptr)
        {
            adapterPtr->NonBlockingUnregisterNotification(
                this->GetNotificationNameId(), this->futureUnregister);
        }
        else
        {
            this->futureUnregister = this->NotificationSending->NonBlockingUnregisterNotification(
                                         this->GetNotificationNameId());
        }
        this->futureNotificationNameId = Future<NotificationNameIdType>();
        this->futureNotificationId = Future<NotificationIdType>();
        this->state = State::UnregisterCalled;
 
        if (adapterPtr != nullptr)
        {
            delete this->NotificationSending;
        }
        this->NotificationSending = nullptr;
    }
}
 
 
template<typename PayloadType>
template<typename... Args>
Future<NotificationIdType> NonBlockingNotificationRegistration<PayloadType>::SendNotification(
    Args&& ... args)
{
    return this->SendNotificationWithTimestamp(DateTime::Now(), std::forward<Args>(args)...);
}
 
 
template<typename PayloadType>
template<typename... Args>
Future<NotificationIdType>
NonBlockingNotificationRegistration<PayloadType>::SendNotificationWithTimestamp(
    const DateTime& timestamp, Args&& ... args)
{
    if ((this->NotificationSending == nullptr) || (!this->IsNotificationNameIdValid()))
    {
        this->futureNotificationId = Future<NotificationIdType>();
    }
    else
    {
#ifndef ARP_CXX_COMPILER_MSC
        // This optimization is not enabled on MSVC++. Capturing an c-string by value does not work.
        auto adapterPtr =
            dynamic_cast<NonBlockingNotificationSendingAdapter*>(this->NotificationSending);
        if (adapterPtr != nullptr)
        {
            std::function<RawPayloadType()> createPayloadFunctor = [args...]()
            {
                return PayloadType{args...}.MoveOutRawPayload();
            };
            adapterPtr->NonBlockingSendNotification(this->futureNotificationNameId.GetValue(),
                                                    timestamp, std::move(createPayloadFunctor), this->futureNotificationId);
        }
        else
#endif // #ifndef ARP_CXX_COMPILER_MSC
        {
            this->futureNotificationId = this->NotificationSending->NonBlockingSendNotification(
                                             this->futureNotificationNameId.GetValue(), timestamp,
                                             PayloadType{std::forward<Args>(args)...});
        }
        this->state = State::SendCalled;
    }
    return this->futureNotificationId;
}
 
 
template<class PayloadType>
NotificationNameIdType
NonBlockingNotificationRegistration<PayloadType>::GetNotificationNameId() const
{
    return this->futureNotificationNameId.GetValue();
}
 
 
template<class PayloadType>
NotificationIdType NonBlockingNotificationRegistration<PayloadType>::GetLastNotificationId() const
{
    return this->futureNotificationId.GetValue();
}
 
 
template<class PayloadType>
bool NonBlockingNotificationRegistration<PayloadType>::IsCompleted() const
{
    switch (this->state)
    {
        case State::Uninitialized:
            return true;
 
        case State::RegisterCalled:
            return this->futureNotificationNameId.HasValue();
 
        case State::SendCalled:
            return this->futureNotificationId.HasValue();
 
        case State::UnregisterCalled:
            return this->futureUnregister.HasValue();
 
        default:
            return false;
    }
}
 
 
template<class PayloadType>
bool NonBlockingNotificationRegistration<PayloadType>::IsNotificationNameIdValid() const
{
    return this->futureNotificationNameId.HasValue() &&
           this->futureNotificationNameId.GetValue().IsValid();
}
 
 
}}} // namespace Arp::System::Nm