NonBlockingNotificationRegistration3.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Commons/Threading/LockGuard.hpp"
#include "Arp/System/Commons/Threading/Mutex.hpp"
#include "Arp/System/Nm/NonBlockingNotificationRegistration3ArgumentsBuffer.hpp"
#include "Arp/System/Nm/NonBlockingNotificationRegistration3Base.hpp"
#include "Arp/System/Nm/NonBlockingNotificationSendingAdapter.hpp"
#include "Arp/System/Nm/NotificationRegistrationBase.hpp"
#include <limits>
#include <numeric>
namespace Arp { namespace System { namespace Nm
{
 
class NotificationManager;
 
template<typename PayloadType, typename ArgumentsType = typename PayloadType::ArgumentsType>
class NonBlockingNotificationRegistration3
    : public NotificationRegistrationBase<NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>>
    , public NonBlockingNotificationRegistration3Base
{
    friend class NotificationManager; // to call private constructor
 
private:
    using base_type = NotificationRegistrationBase<NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>>;
 
public:
    using payload_type = PayloadType;
    using arguments_type = ArgumentsType;
 
    static_assert(std::is_constructible<PayloadType, typename std::add_const<ArgumentsType>::type>::value,
                  "PayloadType must be constructible by const ArgumentsType!");
    static_assert(std::is_default_constructible<ArgumentsType>::value, "ArgumentType must be default constructible");
    static_assert(std::is_copy_assignable<ArgumentsType>::value, "ArgumentsType must be copy assignable");
 
private:
    NonBlockingNotificationRegistration3(const String& notificationName, const String& senderName, Severity severity,
                                         size_t argumentsBufferCapacity, std::unique_ptr<NonBlockingNotificationSendingAdapter> adapter);
 
public:
    NonBlockingNotificationRegistration3() = default;
 
    NonBlockingNotificationRegistration3(const NonBlockingNotificationRegistration3&) = delete;
    NonBlockingNotificationRegistration3(NonBlockingNotificationRegistration3&& other) noexcept;
    ~NonBlockingNotificationRegistration3() override;
 
    NonBlockingNotificationRegistration3& operator=(const NonBlockingNotificationRegistration3&) = delete;
    NonBlockingNotificationRegistration3& operator=(NonBlockingNotificationRegistration3&& other) noexcept;
 
    template<typename... Args>
    Future<NotificationIdType> SendNotification(Args&& ... args);
 
    template<typename... Args>
    Future<NotificationIdType> SendNotificationWithTimestamp(const DateTime& timestamp, Args&& ... args);
 
    NotificationNameIdType GetNotificationNameId() const override;
 
private:
    void DisposeImpl() override;
 
    using CreatePayloadFunctorArg = NonBlockingNotificationSendingAdapter::CreatePayloadFunctorArg;
    static RawPayloadType CreatePayload(CreatePayloadFunctorArg arg);
 
protected:
    using ArgumentsBuffer = NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>;
 
private:
    // shared ownership is required here
    std::shared_ptr<ArgumentsBuffer> argumentsBuffer = nullptr;
};
 
template<typename PayloadType, typename ArgumentsType>
NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::NonBlockingNotificationRegistration3(
    const String& notificationName, const String& senderName, Severity severity, size_t argumentsBufferCapacity,
    std::unique_ptr<NonBlockingNotificationSendingAdapter> adapter)
    : base_type(notificationName, senderName, severity),
      NonBlockingNotificationRegistration3Base(std::move(adapter)),
      argumentsBuffer(std::make_shared<ArgumentsBuffer>(argumentsBufferCapacity))
{
    this->Register(notificationName, senderName, severity, this->GetPayloadTypeId());
}
 
template<typename PayloadType, typename ArgumentsType>
NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::NonBlockingNotificationRegistration3(
    NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>&& other) noexcept
    : base_type(std::move(other)),
      NonBlockingNotificationRegistration3Base(std::move(other)),
      argumentsBuffer(std::move(other.argumentsBuffer))
{
}
 
template<typename PayloadType, typename ArgumentsType>
NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::~NonBlockingNotificationRegistration3()
{
    this->Dispose();
}
 
template<typename PayloadType, typename ArgumentsType>
NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>&
NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::operator=(
    NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>&& other) noexcept
{
    if (this == &other)
    {
        return *this;
    }
 
    base_type::operator=(std::move(other));
    NonBlockingNotificationRegistration3Base::operator=(std::move(other));
 
    this->argumentsBuffer = std::move(other.argumentsBuffer);
 
    return *this;
}
 
template<typename PayloadType, typename ArgumentsType>
void NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::DisposeImpl()
{
    this->Unregister();
}
 
template<typename PayloadType, typename ArgumentsType>
template<typename... Args>
Future<NotificationIdType> NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::SendNotification(
    Args&& ... args)
{
    return this->SendNotificationWithTimestamp(DateTime::Now(), std::forward<Args>(args)...);
}
 
template<typename PayloadType, typename ArgumentsType>
template<typename... Args>
Future<NotificationIdType>
NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::SendNotificationWithTimestamp(
    const DateTime& timestamp, Args&& ... args)
{
    static_assert(std::is_constructible<ArgumentsType, Args...>::value,
                  "The ArgumentsType must be constructible by the passed arguments (Args).");
 
    if (this->IsReadyToSend())
    {
        auto insertResult = this->argumentsBuffer->Insert(ArgumentsType{std::forward<Args>(args)...});
        this->SendNotificationInternal(
            timestamp, this->argumentsBuffer, insertResult, &NonBlockingNotificationRegistration3::CreatePayload);
    }
    else
    {
        this->ResetFutureNotificationId();
    }
    return this->GetFutureNotificationId();
}
 
template<typename PayloadType, typename ArgumentsType>
NotificationNameIdType NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::GetNotificationNameId() const
{
    return this->GetNotificationNameIdInternal();
}
 
template<typename PayloadType, typename ArgumentsType>
RawPayloadType NonBlockingNotificationRegistration3<PayloadType, ArgumentsType>::CreatePayload(
    CreatePayloadFunctorArg arg)
{
    auto buffer = std::dynamic_pointer_cast<ArgumentsBuffer>(arg.BufferPtr);
    if (!buffer)
    {
        return {};
    }
 
    auto removeResult = buffer->Remove(arg.Index);
    if (!removeResult.IsValid)
    {
        return {};
    }
 
    return PayloadType{removeResult.Args}.MoveOutRawPayload();
}
 
}}} // namespace Arp::System::Nm