Scheduler.h

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, LLC.
******************************************************************************/
/*
Scheduler header file
 
Author: Alex Reynolds
*/
#ifndef SCHEDULER_H
#define SCHEDULER_H
 
#include "data_management/GraphTreeObject.h"
#include "architecture/EventLogger.h"
#include "architecture/TimeManager.h"
#include "core/clockwerkerrors.h"
 
namespace clockwerk {
 
    class Executive;
    class Model;
    class Event;
    class Monitor;
    class Task;
    class Construct;
 
    /// @brief  Base class implementation of the scheduler
    ///
    /// This class is a base implementation of scheduler. It is an empty
    /// base class and cannot be used without implementation in a derived
    /// child class.
    ///
    /// The scheduler is the engine that runs simulations and software. It
    /// defines the sequence and method of execution for models, tasks,
    /// monitors, and events and is tasked with their actual execution. 
    /// It also manages faults and errors arising from them.
    class Scheduler : public GraphTreeObject {
    public:
        /// @brief   Constructor for the scheduler.
        /// @note    Does note resolve all dependencies - executive needs to be set
        Scheduler(Executive &executive) : exc(&executive) {create();}
 
        /// @brief   Function to set up our scheduler
        void create();
 
        /// @brief   Function to start and configure the scheduler
        /// @return  Error code corresponding to success/failure
        virtual int startup() {return NO_ERROR;}
 
        /// @brief   Function to step the scheduler by a single step
        /// @return  Error code corresponding to success/failure
        virtual int step(const clockwerk::Time &step_size = clockwerk::Time(0, NSEC_MAX + 1)) {return NO_ERROR;}
 
        /// @brief   Function to run the scheduler until pre-determined end conditions
        ///          identified/calculated by the scheduler
        /// @return  Error code corresponding to success/failure
        /// @note    The scheduler MUST define stopping conditions. Otherwise, will run indefinitely
        virtual int run() {return NO_ERROR;}
 
        /// @brief   Function to register tasks with the scheduler. Depending
        ///          on the scheduler implementation these may be unused
        /// @param task The task to register
        /// @param schedule_slot The slot to register the task to
        /// @return Error code corresponding to success/failure
        virtual int registerTask(Task* task) {return NO_ERROR;}
 
        /// @brief   Function to set the scheduler for termination
        /// @note    Does nothing by default (we don't necessarily want this)
        ///          behavior execpt in certain cases, but always want the handle
        virtual void terminate() {}
 
        /// @brief   Function to indicate whether the scheduler is terminated
        /// @return  The termination flag status
        /// @note    Does nothing by default (we don't necessarily want this)
        ///          behavior execpt in certain cases, but always want the handle
        virtual bool isTerminated() {return false;}
 
        /// Event logger for debugging and key events
        Executive* exc;
    protected:
        // Our local logging level
        log_level_e _local_log_level = NONE;
    };
 
}
 
#endif