TaskTypes.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 https://www.thecoderscorner.com (Dave Cherry)..
 * This product is licensed under an Apache license, see the LICENSE file in the top-level directory.
 */
 
#ifndef TASKMANAGER_IO_TASKTYPES_H
#define TASKMANAGER_IO_TASKTYPES_H

 
#include "TaskPlatformDeps.h"
 
#define TASKMGR_INVALIDID 0xffffU

typedef unsigned int taskid_t;

class Executable {
public:
    virtual void exec() = 0;

    virtual ~Executable() = default;
};
 
// forward references to TaskManager to avoid circular include.
class TaskManager;
extern TaskManager taskManager;

class BaseEvent : public Executable {
private:
    TaskManager *taskMgrAssociation;
    volatile bool triggered;
    volatile bool finished;
public:
    explicit BaseEvent(TaskManager *taskMgrToUse = &taskManager) :
            taskMgrAssociation(taskMgrToUse), triggered(false), finished(false) {}

    virtual uint32_t timeOfNextCheck() = 0;

    void setTriggered(bool t) {
        triggered = t;
    }

    bool isTriggered() const {
        return triggered;
    }

    bool isComplete() const {
        return finished;
    }

    void setCompleted(bool complete) {
        finished = complete;
    }

    void markTriggeredAndNotify();
};

#ifdef TM_ALLOW_CAPTURED_LAMBDA
#include <functional>
typedef std::function<void()> TimerFn;
#else
typedef void (*TimerFn)();
#endif

enum TimerUnit : uint8_t {
    TIME_MICROS = 0,
    TIME_SECONDS = 1,
    TIME_MILLIS = 2,
 
    TM_TIME_REPEATING = 0x10,
    TM_TIME_RUNNING = 0x20,
};

enum ExecutionType : uint8_t {
    EXECTYPE_FUNCTION = 0,
    EXECTYPE_EXECUTABLE = 1,
    EXECTYPE_EVENT = 2,
 
    EXECTYPE_MASK = 0x03,
    EXECTYPE_DELETE_ON_DONE = 0x08,
 
    EXECTYPE_DEL_EXECUTABLE = EXECTYPE_EXECUTABLE | EXECTYPE_DELETE_ON_DONE,
    EXECTYPE_DEL_EVENT = EXECTYPE_EVENT | EXECTYPE_DELETE_ON_DONE
};

class TimerTask {
private:
#ifdef TM_ALLOW_CAPTURED_LAMBDA
    volatile union {
        Executable *taskRef;
        BaseEvent *eventRef;
    };
    TimerFn callback;
#else
    volatile union {
        TimerFn callback;
        Executable *taskRef;
        BaseEvent *eventRef;
    };
#endif

    tm_internal::TimerTaskAtomicPtr next;

    volatile uint32_t scheduledAt;
    volatile sched_t myTimingSchedule;
 
    // 8 bit values start here.

    volatile TimerUnit timingInformation;
    tm_internal::TmAtomicBool taskInUse;
    volatile ExecutionType executeMode;
    tm_internal::TmAtomicBool taskEnabled;
public:
    TimerTask();

    unsigned long microsFromNow();

    void initialise(sched_t when, TimerUnit unit, TimerFn execCallback, bool repeating);

    void initialise(sched_t when, TimerUnit unit, Executable *executable, bool deleteWhenDone, bool repeating);

    void initialiseEvent(BaseEvent *event, bool deleteWhenDone);

    void handleScheduling(sched_t when, TimerUnit unit, bool repeating);

    bool isInUse() { return tm_internal::atomicReadBool(&taskInUse); }

    bool isRepeating() const;

    void clear();

    bool allocateIfPossible() {
        return tm_internal::atomicSwapBool(&taskInUse, false, true);
    }

    void markRunning() { timingInformation = TimerUnit(timingInformation | TM_TIME_RUNNING); }

    void clearRunning() { timingInformation = TimerUnit(timingInformation & ~TM_TIME_RUNNING); }

    bool isRunning() const { return (timingInformation & TM_TIME_RUNNING) != 0; }

    bool isEvent() {
        auto execType = ExecutionType(executeMode & EXECTYPE_MASK);
        return (isInUse() && execType == EXECTYPE_EVENT);
    }

    TimerTask *getNext() { return tm_internal::atomicReadPtr(&next); }

    void setNext(TimerTask *nextTask) { tm_internal::atomicWritePtr(&this->next, nextTask); }

    void execute();

    void processEvent();

    bool isMicrosSchedule()  { return (timingInformation & 0x0fU)==TIME_MICROS; }
    bool isMillisSchedule()  { return (timingInformation & 0x0fU)==TIME_MILLIS; }

    bool isEnabled() { return tm_internal::atomicReadBool(&taskEnabled); }

    void setEnabled(bool ena) { tm_internal::atomicWriteBool(&taskEnabled, ena); }
};
 
#endif //TASKMANAGER_IO_TASKTYPES_H