Stack.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_STACK_HPP_
#define INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_STACK_HPP_

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

#include <memory>

#if defined(DISTORTOS_ARCHITECTURE_ASCENDING_STACK) || defined(DISTORTOS_ARCHITECTURE_EMPTY_STACK)
#error "Support for \"empty ascending\", \"empty descending\" or \"full ascending\" stack not implemented!"
#endif  // defined(DISTORTOS_ARCHITECTURE_ASCENDING_STACK) || defined(DISTORTOS_ARCHITECTURE_EMPTY_STACK)

namespace distortos
{

namespace internal
{

class RunnableThread;

class Stack
{
public:

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

    Stack(StorageUniquePointer&& storageUniquePointer, size_t size);

    Stack(void* storage, size_t size);

    ~Stack();

    bool checkStackGuard() const;

    bool checkStackPointer(const void* const stackPointer) const
    {
        return stackPointer >= static_cast<uint8_t*>(adjustedStorage_) + stackGuardSize &&
                stackPointer <= static_cast<uint8_t*>(adjustedStorage_) + adjustedSize_;
    }

    size_t getHighWaterMark() const;

    size_t getSize() const
    {
        return adjustedSize_ > stackGuardSize ? adjustedSize_ - stackGuardSize : 0;
    }

    void* getStackPointer() const
    {
        return stackPointer_;
    }

    int initialize(RunnableThread& runnableThread);

    void setStackPointer(void* const stackPointer)
    {
        stackPointer_ = stackPointer;
    }

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

private:

    StorageUniquePointer storageUniquePointer_;

    void* const adjustedStorage_;

    const size_t adjustedSize_;

    void* stackPointer_;
};

}   // namespace internal

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_INTERNAL_SCHEDULER_STACK_HPP_