NonBlockingNotificationRegistration3ArgumentsBuffer.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/NonBlockingNotificationRegistration3ArgumentsBufferBase.hpp"
#include <algorithm>
#include <limits>
#include <numeric>
 
namespace Arp { namespace System { namespace Nm
{
 
template<typename ArgumentsType>
class NonBlockingNotificationRegistration3ArgumentsBuffer
    : public NonBlockingNotificationRegistration3ArgumentsBufferBase
{
private:
    using Mutex = Arp::System::Commons::Threading::Mutex;
    using LockGuard = Arp::System::Commons::Threading::LockGuard;
 
public:
    explicit NonBlockingNotificationRegistration3ArgumentsBuffer(size_t capacity);
 
    InsertResult Insert(const ArgumentsType& argument);
 
    struct RemoveResult
    {
        ArgumentsType Args{};
        bool IsValid = false;
    };
    RemoveResult Remove(size_t index);
 
    bool IsFull() const;
    bool IsFree(size_t index) const;
 
private:
    bool IsFullUnsynced() const;
    bool IsFreeUnsynced(size_t index) const;
 
private:
    std::vector<ArgumentsType> arguments;
    std::vector<size_t> freeList;
    size_t next = 0;
    mutable Mutex mutex;
};
 
template<typename ArgumentsType>
NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::NonBlockingNotificationRegistration3ArgumentsBuffer(
    size_t capacity)
    : arguments(capacity), freeList(capacity)
{
    std::iota(freeList.begin(), freeList.end(), 1);
}
 
template<typename ArgumentsType>
typename NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::InsertResult
NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::Insert(const ArgumentsType& argument)
{
    LockGuard lock(this->mutex);
    if (this->IsFullUnsynced())
    {
        return {this->arguments.size(), false};
    }
 
    size_t current = this->next;
    this->arguments.at(current) = argument;
    this->next = std::exchange(this->freeList.at(current), this->arguments.size());
    return {current, true};
}
 
template<typename ArgumentsType>
typename NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::RemoveResult
NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::Remove(size_t index)
{
    LockGuard lock(this->mutex);
    if ((index >= this->arguments.size()) || this->IsFreeUnsynced(index))
    {
        return {{}, false};
    }
 
    this->freeList.at(index) = this->next;
    this->next = index;
    return {this->arguments.at(index), true};
}
 
template<typename ArgumentsType>
bool NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::IsFull() const
{
    LockGuard lock(this->mutex);
    return this->IsFullUnsynced();
}
 
template<typename ArgumentsType>
bool NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::IsFree(size_t index) const
{
    LockGuard lock(this->mutex);
    return this->IsFreeUnsynced(index);
}
 
template<typename ArgumentsType>
bool NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::IsFullUnsynced() const
{
    return this->next == this->arguments.size();
}
 
template<typename ArgumentsType>
bool NonBlockingNotificationRegistration3ArgumentsBuffer<ArgumentsType>::IsFreeUnsynced(size_t index) const
{
    return (index < this->arguments.size()) &&
           ((this->next == index) ||
            (std::find(this->freeList.begin(), this->freeList.end(), index) != this->freeList.end()));
}
 
}}} // namespace Arp::System::Nm