RawFifoQueue.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_RAWFIFOQUEUE_HPP_
#define INCLUDE_DISTORTOS_RAWFIFOQUEUE_HPP_

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

namespace distortos
{

class RawFifoQueue
{
public:

    using StorageUniquePointer = internal::FifoQueueBase::StorageUniquePointer;

    RawFifoQueue(StorageUniquePointer&& storageUniquePointer, size_t elementSize, size_t maxElements);

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

    size_t getElementSize() const
    {
        return fifoQueueBase_.getElementSize();
    }

    int pop(void* buffer, size_t size);

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

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

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

    int tryPop(void* buffer, size_t size);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

private:

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

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

    internal::FifoQueueBase fifoQueueBase_;
};

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_RAWFIFOQUEUE_HPP_