Executive.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.
******************************************************************************/
/*
Executive header file
 
Author: Alex Reynolds
*/
#ifndef EXECUTIVE_H
#define EXECUTIVE_H
 
#include "data_management/GraphTreeObject.h"
#include "architecture/EventLogger.h"
#include "architecture/TimeManager.h"
#include "architecture/Scheduler.h"
#include "core/clockwerkerrors.h"
 
namespace clockwerk {
 
    /// @brief  Central control mechanism to run simulations and software
    /// 
    ///  The executive is a generic base class for operating embedded,
    ///  simulation, and other software models. It contains reference
    ///  objects to the following:
    ///  - Event logger - A method for controlling output to screen/file for debugging
    ///  - Scheduler - An implementation of the scheduling class to set run parameters
    ///
    ///  The executive class is designed to resolve into specific derived
    ///  class implementations, but does not have to be. It is perfectly 
    ///  possible to build an entire executive out of the base class here.
    class Executive : public GraphTreeObject {
    public:
        /// /  @brief   Constructor for the executive
        Executive() {_schedule = nullptr; _time = nullptr;}
        virtual ~Executive() {}
 
        /// /  @brief   Function to execute startup for the executive and its kids
        /// /  @return  Error code corresponding to success/failure
        virtual int startup() {if(_schedule!=nullptr) {return _schedule->startup();} else {return ERROR_NULLPTR;}}
 
        /// /  @brief   Function to execute step for the executive and its kids
        /// /  @return  Error code corresponding to success/failure
        virtual int step() {if(_schedule!=nullptr) {return _schedule->step();} else {return ERROR_NULLPTR;}}
 
        /// /  @brief   Function to execute run for the executive and its kids
        /// /  @return  Error code corresponding to success/failure
        virtual int run() {if(_schedule!=nullptr) {return _schedule->run(); } else {return ERROR_NULLPTR;}}
 
        /// /  @brief   This function shadows the schedule's terminate call
        /// /           for ease of use
        virtual void terminate() {_schedule->terminate();}
 
        /// /  @brief   This function shadows the scheduler's isTerminated call
        /// /           for ease of use
        virtual bool isTerminated() {return _schedule->isTerminated();}
 
        /// /  @brief   Function to set the scheduler for the executive
        void schedule(Scheduler* sched) {_schedule = sched;}
 
        /// /  @brief   Getter for the schedule. Returns pointer to schedule
        clockwerk::Scheduler* schedule() {return _schedule;}
 
        /// /  @brief   Getter for the event logger. Returns pointer to event logger
        clockwerk::EventLogger* eventLog() {return &event_logger;}
 
        /// /  @brief   Getter for a pointer to the time manager.
        /// /  @note    Returns nullpointer if time is unused
        clockwerk::TimeManager* time() {return _time;}
        void time(TimeManager* mgr) {_time = mgr;}
    protected:
        ///  Scheduler to execute everything
        clockwerk::Scheduler* _schedule;
 
        ///  Event logger for debugging and key events
        EventLogger event_logger;
 
        ///  Time manager -- tracked as a pointer because executive does
        ///  not depend on time, but we want access for the majority of 
        ///  applications
        TimeManager* _time;
    };
 
}
 
#endif