MessageQueueBase.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_INTERNAL_SYNCHRONIZATION_MESSAGEQUEUEBASE_HPP_
#define INCLUDE_DISTORTOS_INTERNAL_SYNCHRONIZATION_MESSAGEQUEUEBASE_HPP_

#include "distortos/Semaphore.hpp"

#include "distortos/internal/synchronization/QueueFunctor.hpp"
#include "distortos/internal/synchronization/SemaphoreFunctor.hpp"

#include "estd/SortedIntrusiveForwardList.hpp"

#include <memory>

namespace distortos
{

namespace internal
{

class MessageQueueBase
{
public:

    struct Entry
    {
        constexpr Entry(const uint8_t priorityy, void* const storagee) :
                node{},
                priority{priorityy},
                storage{storagee}
        {

        }

        estd::IntrusiveForwardListNode node;

        uint8_t priority;

        void* storage;
    };

    using EntryStorage = typename std::aligned_storage<sizeof(Entry), alignof(Entry)>::type;

    using EntryStorageUniquePointer = std::unique_ptr<EntryStorage[], void(&)(EntryStorage*)>;

    template<typename T>
    using ValueStorage = typename std::aligned_storage<sizeof(T), alignof(T)>::type;

    using ValueStorageUniquePointer = std::unique_ptr<void, void(&)(void*)>;

    struct DescendingPriority
    {
        constexpr DescendingPriority()
        {

        }

        bool operator()(const Entry& left, const Entry& right) const
        {
            return left.priority < right.priority;
        }
    };

    using EntryList = estd::SortedIntrusiveForwardList<DescendingPriority, Entry, &Entry::node>;

    using FreeEntryList = EntryList::UnsortedIntrusiveForwardList;

    class InternalFunctor : public estd::TypeErasedFunctor<void(EntryList&, FreeEntryList&)>
    {

    };

    MessageQueueBase(EntryStorageUniquePointer&& entryStorageUniquePointer,
            ValueStorageUniquePointer&& valueStorageUniquePointer, size_t elementSize, size_t maxElements);

    ~MessageQueueBase();

    size_t getCapacity() const
    {
        return popSemaphore_.getMaxValue();
    }

    int pop(const SemaphoreFunctor& waitSemaphoreFunctor, uint8_t& priority, const QueueFunctor& functor);

    int push(const SemaphoreFunctor& waitSemaphoreFunctor, uint8_t priority, const QueueFunctor& functor);

private:

    int popPush(const SemaphoreFunctor& waitSemaphoreFunctor, const InternalFunctor& internalFunctor,
            Semaphore& waitSemaphore, Semaphore& postSemaphore);

    Semaphore popSemaphore_;

    Semaphore pushSemaphore_;

    const EntryStorageUniquePointer entryStorageUniquePointer_;

    const ValueStorageUniquePointer valueStorageUniquePointer_;

    EntryList entryList_;

    FreeEntryList freeEntryList_;
};

}   // namespace internal

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_INTERNAL_SYNCHRONIZATION_MESSAGEQUEUEBASE_HPP_