DynamicThread.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_DYNAMICTHREAD_HPP_
#define INCLUDE_DISTORTOS_DYNAMICTHREAD_HPP_

#include "distortos/internal/scheduler/DynamicThreadBase.hpp"

#include "distortos/assert.h"

namespace distortos
{


#ifdef DISTORTOS_THREAD_DETACH_ENABLE

class DynamicThread : public Thread
{
public:

    template<typename Function, typename... Args>
    DynamicThread(size_t stackSize, bool canReceiveSignals, size_t queuedSignals, size_t signalActions,
            uint8_t priority, SchedulingPolicy schedulingPolicy, Function&& function, Args&&... args);

    template<typename Function, typename... Args>
    DynamicThread(const DynamicThreadParameters parameters, Function&& function, Args&&... args) :
            DynamicThread{parameters.stackSize, parameters.canReceiveSignals, parameters.queuedSignals,
                    parameters.signalActions, parameters.priority, parameters.schedulingPolicy,
                    std::forward<Function>(function), std::forward<Args>(args)...}
    {

    }

    ~DynamicThread() override;

    int detach() override;

#if DISTORTOS_SIGNALS_ENABLE == 1

    int generateSignal(uint8_t signalNumber) override;

#endif  // DISTORTOS_SIGNALS_ENABLE == 1

    uint8_t getEffectivePriority() const override;

    ThreadIdentifier getIdentifier() const override;

#if DISTORTOS_SIGNALS_ENABLE == 1

    SignalSet getPendingSignalSet() const override;

#endif  // DISTORTOS_SIGNALS_ENABLE == 1

    uint8_t getPriority() const override;

    SchedulingPolicy getSchedulingPolicy() const override;

    size_t getStackHighWaterMark() const override;

    size_t getStackSize() const override;

    ThreadState getState() const override;

    int join() override;

#if DISTORTOS_SIGNALS_ENABLE == 1

    int queueSignal(uint8_t signalNumber, sigval value) override;

#endif  // DISTORTOS_SIGNALS_ENABLE == 1

    void setPriority(uint8_t priority, bool alwaysBehind = {}) override;

    void setSchedulingPolicy(SchedulingPolicy schedulingPolicy) override;

    int start();

    DynamicThread(const DynamicThread&) = delete;
    DynamicThread(DynamicThread&&) = default;
    const DynamicThread& operator=(const DynamicThread&) = delete;
    DynamicThread& operator=(DynamicThread&&) = delete;

private:

    std::unique_ptr<internal::DynamicThreadBase> detachableThread_;
};

#else   // !def DISTORTOS_THREAD_DETACH_ENABLE

class DynamicThread : public internal::DynamicThreadBase
{
public:

    using internal::DynamicThreadBase::DynamicThreadBase;
};

#endif  // !def DISTORTOS_THREAD_DETACH_ENABLE

template<typename Function, typename... Args>
DynamicThread makeDynamicThread(const size_t stackSize, const bool canReceiveSignals, const size_t queuedSignals,
        const size_t signalActions, const uint8_t priority, const SchedulingPolicy schedulingPolicy,
        Function&& function, Args&&... args)
{
    return {stackSize, canReceiveSignals, queuedSignals, signalActions, priority, schedulingPolicy,
            std::forward<Function>(function), std::forward<Args>(args)...};
}

template<typename Function, typename... Args>
DynamicThread makeDynamicThread(const DynamicThreadParameters parameters, Function&& function, Args&&... args)
{
    return {parameters, std::forward<Function>(function), std::forward<Args>(args)...};
}

template<typename Function, typename... Args>
DynamicThread makeAndStartDynamicThread(const size_t stackSize, const bool canReceiveSignals,
        const size_t queuedSignals, const size_t signalActions, const uint8_t priority,
        const SchedulingPolicy schedulingPolicy, Function&& function, Args&&... args)
{
    auto thread = makeDynamicThread(stackSize, canReceiveSignals, queuedSignals, signalActions, priority,
            schedulingPolicy, std::forward<Function>(function), std::forward<Args>(args)...);
    {
        const auto ret = thread.start();
        assert(ret == 0 && "Could not start thread!");
    }
    return thread;
}

template<typename Function, typename... Args>
DynamicThread makeAndStartDynamicThread(const DynamicThreadParameters parameters, Function&& function, Args&&... args)
{
    auto thread = makeDynamicThread(parameters, std::forward<Function>(function), std::forward<Args>(args)...);
    {
        const auto ret = thread.start();
        assert(ret == 0 && "Could not start thread!");
    }
    return thread;
}


#ifdef DISTORTOS_THREAD_DETACH_ENABLE

template<typename Function, typename... Args>
DynamicThread::DynamicThread(const size_t stackSize, const bool canReceiveSignals, const size_t queuedSignals,
        const size_t signalActions, const uint8_t priority, const SchedulingPolicy schedulingPolicy,
        Function&& function, Args&&... args) :
        detachableThread_{new internal::DynamicThreadBase{stackSize, canReceiveSignals, queuedSignals, signalActions,
                priority, schedulingPolicy, *this, std::forward<Function>(function), std::forward<Args>(args)...}}
{

}

#endif  // def DISTORTOS_THREAD_DETACH_ENABLE

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_DYNAMICTHREAD_HPP_