RawMessageQueue.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_RAWMESSAGEQUEUE_HPP_
#define INCLUDE_DISTORTOS_RAWMESSAGEQUEUE_HPP_

#include "distortos/internal/synchronization/MessageQueueBase.hpp"

namespace distortos
{

class RawMessageQueue
{
public:

    using EntryStorage = internal::MessageQueueBase::EntryStorage;

    using EntryStorageUniquePointer = internal::MessageQueueBase::EntryStorageUniquePointer;

    template<typename T>
    using ValueStorage = internal::MessageQueueBase::ValueStorage<T>;

    using ValueStorageUniquePointer = internal::MessageQueueBase::ValueStorageUniquePointer;

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

    size_t getCapacity() const
    {
        return messageQueueBase_.getCapacity();
    }

    size_t getElementSize() const
    {
        return elementSize_;
    }

    int pop(uint8_t& priority, void* buffer, size_t size);

    template<typename T>
    int pop(uint8_t& priority, T& buffer)
    {
        return pop(priority, &buffer, sizeof(buffer));
    }

    int push(uint8_t priority, const void* data, size_t size);

    template<typename T>
    int push(const uint8_t priority, const T& data)
    {
        return push(priority, &data, sizeof(data));
    }

    int tryPop(uint8_t& priority, void* buffer, size_t size);

    template<typename T>
    int tryPop(uint8_t& priority, T& buffer)
    {
        return tryPop(priority, &buffer, sizeof(buffer));
    }

    int tryPopFor(TickClock::duration duration, uint8_t& priority, void* buffer, size_t size);

    template<typename Rep, typename Period>
    int tryPopFor(const std::chrono::duration<Rep, Period> duration, uint8_t& priority, void* const buffer,
            const size_t size)
    {
        return tryPopFor(std::chrono::duration_cast<TickClock::duration>(duration), priority, buffer, size);
    }

    template<typename Rep, typename Period, typename T>
    int tryPopFor(const std::chrono::duration<Rep, Period> duration, uint8_t& priority, T& buffer)
    {
        return tryPopFor(std::chrono::duration_cast<TickClock::duration>(duration), priority, &buffer, sizeof(buffer));
    }

    int tryPopUntil(TickClock::time_point timePoint, uint8_t& priority, void* buffer, size_t size);

    template<typename Duration>
    int tryPopUntil(const std::chrono::time_point<TickClock, Duration> timePoint, uint8_t& priority, void* const buffer,
            const size_t size)
    {
        return tryPopUntil(std::chrono::time_point_cast<TickClock::duration>(timePoint), priority, buffer, size);
    }

    template<typename Duration, typename T>
    int tryPopUntil(const std::chrono::time_point<TickClock, Duration> timePoint, uint8_t& priority, T& buffer)
    {
        return tryPopUntil(std::chrono::time_point_cast<TickClock::duration>(timePoint), priority, &buffer,
                sizeof(buffer));
    }

    int tryPush(uint8_t priority, const void* data, size_t size);

    template<typename T>
    int tryPush(const uint8_t priority, const T& data)
    {
        return tryPush(priority, &data, sizeof(data));
    }

    int tryPushFor(TickClock::duration duration, uint8_t priority, const void* data, size_t size);

    template<typename Rep, typename Period>
    int tryPushFor(const std::chrono::duration<Rep, Period> duration, const uint8_t priority, const void* const data,
            const size_t size)
    {
        return tryPushFor(std::chrono::duration_cast<TickClock::duration>(duration), priority, data, size);
    }

    template<typename Rep, typename Period, typename T>
    int tryPushFor(const std::chrono::duration<Rep, Period> duration, const uint8_t priority, const T& data)
    {
        return tryPushFor(std::chrono::duration_cast<TickClock::duration>(duration), priority, &data, sizeof(data));
    }

    int tryPushUntil(TickClock::time_point timePoint, uint8_t priority, const void* data, size_t size);

    template<typename Duration>
    int tryPushUntil(const std::chrono::time_point<TickClock, Duration> timePoint, const uint8_t priority,
            const void* const data, const size_t size)
    {
        return tryPushUntil(std::chrono::time_point_cast<TickClock::duration>(timePoint), priority, data, size);
    }

    template<typename Duration, typename T>
    int tryPushUntil(const std::chrono::time_point<TickClock, Duration> timePoint, const uint8_t priority,
            const T& data)
    {
        return tryPushUntil(std::chrono::time_point_cast<TickClock::duration>(timePoint), priority, &data,
                sizeof(data));
    }

private:

    int popInternal(const internal::SemaphoreFunctor& waitSemaphoreFunctor, uint8_t& priority, void* buffer,
            size_t size);

    int pushInternal(const internal::SemaphoreFunctor& waitSemaphoreFunctor, uint8_t priority, const void* data,
            size_t size);

    internal::MessageQueueBase messageQueueBase_;

    const size_t elementSize_;
};

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_RAWMESSAGEQUEUE_HPP_