task.hpp

#ifndef QOS_CPP_TASK
#define QOS_CPP_TASK
 
#include "include/types.hpp"
#include "include/timer.hpp"
#include "include/list.hpp"
#include "include/queue.hpp"
 
namespace qOS {


    enum class trigger : uint8_t {
        None = 0,
        byTimeElapsed,
        byNotificationQueued,
        byNotificationSimple,
        byQueueReceiver,
        byQueueFull,
        byQueueCount,
        byQueueEmpty,
        byEventFlags,
        bySchedulingRelease,
        byNoReadyTasks
    };

    enum class globalState : uint8_t {
        UNDEFINED,  
        READY,      
        WAITING,    
        SUSPENDED,  
        RUNNING     
    };

    class task;
 
 
    #ifdef DOXYGEN
    class event_t {
        protected:
            trigger Trigger{ trigger::None };
            bool FirstCall{ false };
            bool FirstIteration{ false };
            bool LastIteration{ false };
            clock_t StartDelay{ 0u };
            task* currentTask{ nullptr };
            _Event() = default;
        public:
            void *TaskData{ nullptr };
            void *EventData{ nullptr };
            inline bool firstCall( void ) const noexcept
            {
                return FirstCall;
            }

            inline bool firstIteration( void ) const noexcept
            {
                return FirstIteration;
            }

            inline bool lastIteration( void ) const noexcept
            {
                return LastIteration;
            }

            inline trigger getTrigger( void ) const noexcept
            {
                return Trigger;
            }

            inline clock_t startDelay( void ) const noexcept
            {
                return StartDelay;
            }

            inline task& thisTask( void ) noexcept
            {
                return *currentTask;
            }
    };
    #endif

    class taskEvent {
        protected:
            trigger Trigger{ trigger::None };
            bool FirstCall{ false };
            bool FirstIteration{ false };
            bool LastIteration{ false };
            clock_t StartDelay{ 0U };
            task* currentTask{ nullptr };
            taskEvent() = default;
        public:
            virtual ~taskEvent(){}
            void *TaskData{ nullptr };
            void *EventData{ nullptr };
            inline bool firstCall( void ) const noexcept
            {
                return FirstCall;
            }
            inline bool firstIteration( void ) const noexcept
            {
                return FirstIteration;
            }
            inline bool lastIteration( void ) const noexcept
            {
                return LastIteration;
            }
            inline trigger getTrigger( void ) const noexcept
            {
                return Trigger;
            }
            inline clock_t startDelay( void ) const noexcept
            {
                return StartDelay;
            }
            inline task& self( void ) noexcept
            {
                return *currentTask;
            }
            inline const task& self( void ) const noexcept
            {
                return *currentTask;
            }
            inline task& thisTask( void ) noexcept
            {
                return *currentTask;
            }
            inline const task& thisTask( void ) const noexcept {
                return *currentTask;
            }
    };
    using event_t = taskEvent&;
 

    enum class taskState {
        DISABLED_STATE = 0,
        ENABLED_STATE = 1,
        AWAKE_STATE = 2,
        ASLEEP_STATE = 3,
    };

    enum class queueLinkMode : uint32_t {
        QUEUE_RECEIVER = 4U,    
        QUEUE_FULL = 8U,        
        QUEUE_COUNT = 16U,      
        QUEUE_EMPTY = 32U,      
    };

    using taskFcn_t = void (*)( event_t );
    using notifier_t = uint32_t;


    using taskFlag_t = uint32_t;


    class task : protected node, private nonCopyable {
        friend class core;
        private:
            void *taskData{ nullptr };
            void *asyncData{ nullptr };
            taskFcn_t callback{ nullptr };
            void *aObj{ nullptr };
            queue *aQueue{ nullptr };
            size_t aQueueCount{ 0UL };
            char name[ 11 ] = ""; // skipcq: CXX-W2066, CXX-W2066
            timer time;
            cycles_t cycles{ 0UL };
            size_t entry{ SIZE_MAX };
            iteration_t iterations{ 0 };
            volatile notifier_t notifications{ 0UL };
            volatile taskFlag_t flags{ 0UL };
            priority_t priority{ 0U };
            trigger Trigger{ trigger::None };
            void setFlags( const uint32_t xFlags, const bool value ) noexcept;
            bool getFlag( const uint32_t flag ) const noexcept;
            bool deadLineReached( void ) const noexcept;
            trigger queueCheckEvents( void ) noexcept;
            static const uint32_t BIT_INIT;
            static const uint32_t BIT_ENABLED;
            static const uint32_t BIT_QUEUE_RECEIVER;
            static const uint32_t BIT_QUEUE_FULL;
            static const uint32_t BIT_QUEUE_COUNT;
            static const uint32_t BIT_QUEUE_EMPTY;
            static const uint32_t BIT_SHUTDOWN;
            static const uint32_t BIT_REMOVE_REQUEST;
            static const uint32_t EVENT_FLAGS_MASK;
            static const uint32_t QUEUE_FLAGS_MASK;
        protected:
            virtual void activities( event_t e );
        public:
            task() = default;
            virtual ~task(){}
            priority_t getPriority( void ) const noexcept;
            bool setPriority( const priority_t pValue ) noexcept;
            cycles_t getCycles( void ) const noexcept;
            taskState getState( void ) const noexcept;
            bool setState( const taskState s ) noexcept;
            inline bool suspend( void ) noexcept
            {
                return setState( taskState::DISABLED_STATE );
            }

            inline bool disable( void ) noexcept
            {
                return setState( taskState::DISABLED_STATE );
            }

            inline bool resume( void ) noexcept
            {
                return setState( taskState::ENABLED_STATE );
            }

            inline bool enable( void ) noexcept
            {
                return setState( taskState::ENABLED_STATE );
            }

            inline bool asleep( void ) noexcept
            {
                return setState( taskState::ASLEEP_STATE );
            }

            inline bool awake( void ) noexcept
            {
                return setState( taskState::AWAKE_STATE );
            }

            inline bool isEnabled( void ) const noexcept
            {
                return ( taskState::ENABLED_STATE == getState() );
            }

            void setIterations( const iteration_t iValue ) noexcept;
            bool setTime( const qOS::duration_t tValue ) noexcept;
            bool setCallback( const taskFcn_t tCallback ) noexcept;
            bool setData( void *arg ) noexcept;
            bool setName( const char *tName ) noexcept;
            const char* getName( void ) const noexcept;
            size_t getID( void ) const noexcept;
            bool attachQueue( queue &q, const queueLinkMode mode, const size_t arg = 1U ) noexcept;
            void * const & getBindedObject( void ) const noexcept;
            queue* getQueue( void ) noexcept;
            explicit operator bool() const noexcept {
                return ( SIZE_MAX != entry ) && ( nullptr == getContainer() );
            }

            static const iteration_t PERIODIC;
            static const iteration_t INDEFINITE;
            static const iteration_t SINGLE_SHOT;
    };

}
 
 
#endif /*QOS_CPP_TASK*/