mirror of
https://github.com/nasa/trick.git
synced 2025-01-23 12:58:04 +00:00
14a75508a3
Changed all header file once include variables to follow the same naming convention and not start with any underscores. Also deleted old incorrect copyright notices. Also removed $Id: tags from all files. Fixes #14. Fixes #22.
438 lines
22 KiB
C++
438 lines
22 KiB
C++
|
|
#ifndef IPPYTHONEVENT_HH
|
|
#define IPPYTHONEVENT_HH
|
|
|
|
#include <string>
|
|
#include "sim_services/EventManager/include/Event.hh"
|
|
#include "sim_services/MemoryManager/include/reference.h"
|
|
#include "sim_services/SimObject/include/JobData.hh"
|
|
|
|
#ifdef SWIG
|
|
// SWIG macros are not normally run on classes in sim_services. We can add the the processed code manually
|
|
%trick_swig_class_typemap(Trick::IPPythonEvent, Trick__IPPythonEvent)
|
|
#endif
|
|
|
|
namespace Trick {
|
|
|
|
class IPPython ;
|
|
class MTV ;
|
|
|
|
/** Data associated with each event condition.\n */
|
|
struct condition_t {
|
|
|
|
condition_t() ;
|
|
/** True means condition is to be evaluated during event processing.\n */
|
|
char enabled ; /**< trick_io(*io) trick_units(--) */
|
|
/** True means that when fired, condition stays fired.\n */
|
|
char hold ; /**< trick_io(*io) trick_units(--) */
|
|
/** True when the condition evaluated to true.\n */
|
|
char fired ; /**< trick_io(*io) trick_units(--) */
|
|
/** Count of how many times this condition fired.\n */
|
|
int fired_count ; /**< trick_io(*io) trick_units(--) */
|
|
/** Last simulation time this condition fired.\n */
|
|
double fired_time ; /**< trick_io(*io) trick_units(s) */
|
|
/** The string containing condition to be evaluated.\n */
|
|
std::string str; /**< trick_io(*io) trick_units(--) */
|
|
/** Optional comment provided by user to display in mtv.\n */
|
|
std::string comment; /**< trick_io(*io) trick_units(--) */
|
|
/** Variable reference to a model variable to be used for condition.\n */
|
|
REF2 * ref ; /**< trick_io(**) trick_units(--) */
|
|
/** Job pointer to a model job to be used for condition.\n */
|
|
Trick::JobData * job ; /**< trick_io(**) trick_units(--) */
|
|
/** Type of condition string: 0=python, 1=variable, 2=job.\n */
|
|
int cond_type ; /**< trick_io(*io) trick_units(--) */
|
|
} ;
|
|
|
|
/** Data associated with each event action.\n */
|
|
struct action_t {
|
|
|
|
action_t() ;
|
|
/** True means action is to be run when fired.\n */
|
|
char enabled ; /**< trick_io(*io) trick_units(--) */
|
|
/** True when the action was run.\n */
|
|
char ran ; /**< trick_io(*io) trick_units(--) */
|
|
/** Count how many times this action has been run.\n */
|
|
int ran_count ; /**< trick_io(*io) trick_units(--) */
|
|
/** Last simulation time this action ran.\n */
|
|
double ran_time ; /**< trick_io(*io) trick_units(s) */
|
|
/** The string containing action to be run.\n */
|
|
std::string str; /**< trick_io(*io) trick_units(--) */
|
|
/** Optional comment provided by user to display in mtv.\n */
|
|
std::string comment; /**< trick_io(*io) trick_units(--) */
|
|
/** Job pointer to a model job to run as the action.\n */
|
|
JobData * job ; /**< trick_io(**) trick_units(--) */
|
|
/** Type of action string: 0=python, 1=job ON, 2=job OFF 3=job call.\n */
|
|
int act_type ; /**< trick_io(*io) trick_units(--) */
|
|
} ;
|
|
|
|
/**
|
|
This class provides python input file event capability.
|
|
@author Alex Lin, Danny Strauss
|
|
*/
|
|
|
|
class IPPythonEvent : public Trick::Event {
|
|
|
|
TRICK_MM_FRIENDS(Trick__IPPythonEvent)
|
|
|
|
public:
|
|
|
|
/** True when event is in the event_list to be processed; false when it is to be removed from event_list.\n */
|
|
bool added ; /**< trick_io(*io) trick_units(--) */
|
|
|
|
/** True for a user input event, false for a read or other trick event.\n */
|
|
bool is_user_event ; /**< trick_io(*io) trick_units(--) */
|
|
|
|
/** @userdesc True when user issues a manual command, normal condition evaluation is overriden.\n */
|
|
bool manual ; /**< trick_io(*io) trick_units(--) */
|
|
|
|
/** @userdesc True when event fired because of a manual_on or manual_fire command.\n */
|
|
bool manual_fired ; /**< trick_io(*io) trick_units(--) */
|
|
|
|
/** Toggle to turn on/off event info messages (e.g., when an event fires).\n */
|
|
static bool info_msg ; /**< trick_io(**) trick_units(--) */
|
|
|
|
/** True when ALL conditions must be true to make action(s) run; default is false.\n */
|
|
bool cond_all ; /**< trick_io(*io) trick_units(--) */
|
|
/** @userdesc True when event conditions setup was evaluated as true.\n */
|
|
char fired ; /**< trick_io(*io) trick_units(--) */
|
|
/** True when an event condition fired and its hold is true, also used for manual mode hold.\n */
|
|
char hold ; /**< trick_io(*io) trick_units(--) */
|
|
/** @userdesc True when any event action was run.\n */
|
|
char ran ; /**< trick_io(*io) trick_units(--) */
|
|
/** Count of how many conditions this event has.\n */
|
|
int condition_count ; /**< trick_io(*io) trick_units(--) */
|
|
/** @userdesc Count of how many times this event has fired.\n */
|
|
int fired_count ; /**< trick_io(*io) trick_units(--) */
|
|
/** @userdesc Last simulation time that this event fired.\n */
|
|
double fired_time ; /**< trick_io(*io) trick_units(s) */
|
|
/** Count of how many actions this event has.\n */
|
|
int action_count ; /**< trick_io(*io) trick_units(--) */
|
|
/** @userdesc Count of how many times this event has run its actions.\n */
|
|
int ran_count ; /**< trick_io(*io) trick_units(--) */
|
|
/** @userdesc Last simulation time that this event ran an action.\n */
|
|
double ran_time ; /**< trick_io(*io) trick_units(s) */
|
|
/** Array of event's conditions.\n */
|
|
condition_t * cond ; /**< trick_io(*io) trick_units(--) */
|
|
/** Array of event's actions.\n */
|
|
action_t * act ; /**< trick_io(*io) trick_units(--) */
|
|
|
|
/**
|
|
@brief Constructor.
|
|
*/
|
|
IPPythonEvent() ;
|
|
|
|
virtual ~IPPythonEvent() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to make event evaluation require that ALL of event's conditions be true to make action(s) run.
|
|
@par Python Usage:
|
|
@code <event_object>.condition_all() @endcode
|
|
@return always 0
|
|
*/
|
|
int condition_all() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to make event evaluation require that ANY of event's conditions be true to make action(s) run (this is the default).
|
|
@par Python Usage:
|
|
@code <event_object>.condition_any() @endcode
|
|
@return always 0
|
|
*/
|
|
int condition_any() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to manually fire the event next cycle and hold it fired (enter manual mode, bypasses normal condition processing).
|
|
@par Python Usage:
|
|
@code <event_object>.manual_on() @endcode
|
|
*/
|
|
virtual void manual_on() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to manually fire the event once NOW (enter manual mode, bypasses normal condition processing).
|
|
@par Python Usage:
|
|
@code <event_object>.manual_fire() @endcode
|
|
*/
|
|
virtual void manual_fire() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to manually set the event as not fired (enter manual mode, bypasses normal condition processing).
|
|
@par Python Usage:
|
|
@code <event_object>.manual_off() @endcode
|
|
*/
|
|
virtual void manual_off() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to return to normal event processing (needed to end manual mode after any manual commands).
|
|
@par Python Usage:
|
|
@code <event_object>.manual_done() @endcode
|
|
*/
|
|
virtual void manual_done() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to turn on event info messages (e.g., get a message each time an event fires).
|
|
Event info messages will be published using the Trick status message system.
|
|
@par Python Usage:
|
|
@code trick.set_event_info_msg_on() @endcode
|
|
@return always 0
|
|
*/
|
|
static void set_event_info_msg_on() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to turn off event info messages (off is the default).
|
|
No event info messages will be published using the Trick status message system.
|
|
@par Python Usage:
|
|
@code trick.set_event_info_msg_off() @endcode
|
|
@return always 0
|
|
*/
|
|
static void set_event_info_msg_off() ;
|
|
|
|
/**
|
|
@brief called by the event manager when the event is loaded from a checkpoint
|
|
*/
|
|
virtual void restart() ;
|
|
|
|
/**
|
|
@brief @userdesc Command to create a new condition and set its input string (or reset an existing condition string), num is index starting at 0.
|
|
@par Python Usage:
|
|
@code <event_object>.condition(<num>, """<str>""") @endcode
|
|
@param num - number identifying the condition, starting at 0 for the 1st condition, 1 for the 2nd, etc.
|
|
@param str - the condition input boolean expression, using Python syntax, to be evaluated each cycle
|
|
@param comment - optional description to be displayed in mtv (defaults to 1st 50 characters of str)
|
|
@param ref - optional reference to a model variable to be used for the condition (this parameter for internal use only!)
|
|
@param job - optional pointer to job to be called as the condition (this parameter for internal use only!)
|
|
@return always 0
|
|
*/
|
|
int condition(int num, std::string str, std::string comment="", REF2* ref=NULL, JobData* job=NULL) ;
|
|
|
|
/**
|
|
@brief @userdesc Command to create a new condition using a boolean model variable (or reset an existing condition variable), num is index starting at 0.
|
|
Using a model variable is more optimal than a normal condition() because there is no Python string to parse.
|
|
@par Python Usage:
|
|
@code <event_object>.condition_var(<num>, """<varname>""") @endcode
|
|
@param num - number identifying the condition, starting at 0 for the 1st condition, 1 for the 2nd, etc.
|
|
@param varname - the name of the boolean model variable, to be evaluated each cycle
|
|
@param comment - optional description to be displayed in mtv (defaults to 1st 50 characters of str)
|
|
@return always 0
|
|
*/
|
|
int condition_var(int num, std::string varname, std::string comment="") ;
|
|
|
|
/**
|
|
@brief @userdesc Command to create a new condition using a model job return val (or reset an existing condition job), num is index starting at 0.
|
|
Using a model job return value is more optimal than a normal condition() because there is no Python string to parse.
|
|
@par Python Usage:
|
|
@code <event_object>.condition_job(<num>, """<jobname>""") @endcode
|
|
@param num - number identifying the condition, starting at 0 for the 1st condition, 1 for the 2nd, etc.
|
|
@param jobname - the name of the model job, to be called and evaluated each cycle
|
|
@param comment - optional description to be displayed in mtv (defaults to 1st 50 characters of str)
|
|
@return always 0
|
|
*/
|
|
int condition_job(int num, std::string jobname, std::string comment="") ;
|
|
|
|
/**
|
|
@brief @userdesc Command to set an existing condition to hold, so that when it fires it stays in the fired state.
|
|
@par Python Usage:
|
|
@code <event_object>.condition_hold_on(<num>) @endcode
|
|
@param num - number identifying the condition
|
|
@return always 0
|
|
*/
|
|
int condition_hold_on(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Command to set an existing condition to not hold its fired state (default).
|
|
@par Python Usage:
|
|
@code <event_object>.condition_hold_off(<num>) @endcode
|
|
@param num - number identifying the condition
|
|
@return always 0
|
|
*/
|
|
int condition_hold_off(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Command to enable an existing condition (default is enabled) so that it is evaluated during event processing.
|
|
@par Python Usage:
|
|
@code <event_object>.condition_enable(<num>) @endcode
|
|
@param num - number identifying the condition
|
|
@return always 0
|
|
*/
|
|
int condition_enable(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Command to disable an existing condition so that it is not evaluated during event processing.
|
|
@par Python Usage:
|
|
@code <event_object>.condition_disable(<num>) @endcode
|
|
@param num -number identifying the condition
|
|
@return always 0
|
|
*/
|
|
int condition_disable(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Accessor function to test if the condition, indicated by num, fired (is currently in the fired state).
|
|
@par Python Usage:
|
|
@code <my_bool> = <event_object>.condition_fired(<num>) @endcode
|
|
@param num - number identifying the condition
|
|
@return true if the specified condition fired in the most recent cycle that the event was evaluated
|
|
*/
|
|
bool condition_fired(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Accessor function to see how many times the condition, indicated by num, fired.
|
|
@par Python Usage:
|
|
@code <my_int> = <event_object>.condition_fired_count<(num>) @endcode
|
|
@param num - number identifying the condition
|
|
@return number of times the specified condition has fired
|
|
*/
|
|
int condition_fired_count(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Accessor function to see when was the last time the condition, indicated by num, fired.
|
|
@par Python Usage:
|
|
@code <my_double> = <event_object>.condition_fired_time(<num>) @endcode
|
|
@param num - number identifying the condition
|
|
@return the last simulation time that this condition fired (-1.0 if never fired)
|
|
*/
|
|
double condition_fired_time(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Accessor function to return the condition string, indicated by num.
|
|
@par Python Usage:
|
|
@code <my_string> = <event_object>.condition(<num>) @endcode
|
|
@param num - number identifying the condition
|
|
@return the specified condition's input boolean expression
|
|
*/
|
|
std::string condition_string(int num) ;
|
|
|
|
|
|
/**
|
|
@brief @userdesc Command to create a new action and set its input string (or reset an existing action string), num is index starting at 0.
|
|
@par Python Usage:
|
|
@code <event_object>.action(<num>, """<str>""") @endcode
|
|
@param num - number identifying the action, starting at 0 for the 1st action, 1 for the 2nd, etc.
|
|
@param str - the action input statement(s), using Python syntax, to be run (processed) when this event is fired
|
|
@param comment - optional description to be displayed in mtv (defaults to 1st 50 characters of str)
|
|
@param job - optional pointer to job to be called in the action (this parameter for internal use only!)
|
|
@param act_type - optional type of action string: 0=python 1=Job ON, 2=Job OFF, 3=Job Call (this parameter for internal use only!)
|
|
@return always 0
|
|
*/
|
|
int action(int num, std::string str, std::string comment="", JobData* job=NULL, int act_type=0) ;
|
|
|
|
/**
|
|
@brief @userdesc Command to create a new action using a model job (or reset an existing action job), num is index starting at 0.
|
|
Using a model job is more optimal than a normal action() because there is no Python string to parse.
|
|
@par Python Usage:
|
|
@code <event_object>.action_job(<num>, """<jobname>""") @endcode
|
|
@param num - number identifying the action, starting at 0 for the 1st action, 1 for the 2nd, etc.
|
|
@param jobname - the action job name of the job to be called when this event is fired
|
|
@param comment - optional description to be displayed in mtv (defaults to 1st 50 characters of str)
|
|
@return always 0
|
|
*/
|
|
int action_job(int num, std::string jobname, std::string comment="") ;
|
|
|
|
/**
|
|
@brief @userdesc Command to create a new action to turn a model job ON, num is index starting at 0.
|
|
@par Python Usage:
|
|
@code <event_object>.action_job_on(<num>, """<jobname>""") @endcode
|
|
@param num - number identifying the action, starting at 0 for the 1st action, 1 for the 2nd, etc.
|
|
@param jobname - the action job name of the job to enable when this event is fired
|
|
@param comment - optional description to be displayed in mtv (defaults to 1st 50 characters of str)
|
|
@return always 0
|
|
*/
|
|
int action_job_on(int num, std::string jobname, std::string comment="") ;
|
|
|
|
/**
|
|
@brief @userdesc Command to create a new action to turn a model job OFF, num is index starting at 0.
|
|
@par Python Usage:
|
|
@code <event_object>.action_job_off(<num>, """<jobname>""") @endcode
|
|
@param num - number identifying the action, starting at 0 for the 1st action, 1 for the 2nd, etc.
|
|
@param jobname - the action job name of the job to disable when this event is fired
|
|
@param comment - optional description to be displayed in mtv (defaults to 1st 50 characters of str)
|
|
@return always 0
|
|
*/
|
|
int action_job_off(int num, std::string jobname, std::string comment="") ;
|
|
|
|
/**
|
|
@brief @userdesc Command to enable an existing action (default is enabled) so that it is run when fired during event processing.
|
|
@par Python Usage:
|
|
@code <event_object>.action_enable(<num>) @endcode
|
|
@param num - number identifying the action
|
|
@return always 0
|
|
*/
|
|
int action_enable(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Command to disable an existing action so that it is not run when fired during event processing.
|
|
@par Python Usage:
|
|
@code <event_object>.action_disable(<num>) @endcode
|
|
@param num - number identifying the action
|
|
@return always 0
|
|
*/
|
|
int action_disable(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Accessor function to test if the action, indicated by num, ran.
|
|
@par Python Usage:
|
|
@code <my_bool> = <event_object>.action_ran(<num>) @endcode
|
|
@param num - number identifying the action
|
|
@return true if the specified action ran at least once
|
|
*/
|
|
bool action_ran(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Accessor function to see how many times the action, indicated by num, ran.
|
|
@par Python Usage:
|
|
@code <my_int> = <event_object>.action_ran_count(<num>) @endcode
|
|
@param num - number identifying the action
|
|
@return number of times the specified action ran
|
|
*/
|
|
int action_ran_count(int num) ;
|
|
|
|
/**
|
|
@brief @userdesc Accessor function to see when was the last time the action, indicated by num, ran.
|
|
@par Python Usage:
|
|
@code <my_double> = <event_object>.action_ran_time(<num>) @endcode
|
|
@param num - number identifying the action
|
|
@return the last simulation time that this action ran (-1.0 if never ran)
|
|
*/
|
|
double action_ran_time(int num) ;
|
|
|
|
virtual int process( long long curr_time ) ;
|
|
|
|
bool process_user_event( long long curr_time ) ;
|
|
|
|
virtual void add() ;
|
|
virtual void remove() ;
|
|
|
|
/* A static method that allows us to set the IPPython * from the S_define sim_object level without
|
|
any events instantiated yet */
|
|
static void set_python_processor(Trick::IPPython * in_ip) ;
|
|
static void set_mtv(Trick::MTV * in_mtv) ;
|
|
|
|
private:
|
|
|
|
/* A static pointer to the python input processor set at the S_define level */
|
|
static Trick::IPPython * ip ;
|
|
|
|
/* A static pointer to the MTV set at the S_define level */
|
|
static Trick::MTV * mtv ;
|
|
|
|
} ;
|
|
|
|
}
|
|
|
|
Trick::IPPythonEvent * ippython_new_event(std::string event_name = "" ) ;
|
|
int ippython_delete_event(Trick::IPPythonEvent * in_event) ;
|
|
int ippython_add_event(Trick::IPPythonEvent * in_event) ;
|
|
int ippython_add_event_before( Trick::IPPythonEvent * in_event, std::string target_name, unsigned int target_inst = 1) ;
|
|
int ippython_add_event_after( Trick::IPPythonEvent * in_event, std::string target_name, unsigned int target_inst = 1) ;
|
|
int ippython_add_read( unsigned int thread_id , double in_time , char * in_string ) ;
|
|
int ippython_add_read( double in_time , char * in_string ) ;
|
|
int ippython_manual_on(std::string event_name) ;
|
|
int ippython_manual_fire(std::string event_name) ;
|
|
int ippython_manual_off(std::string event_name) ;
|
|
int ippython_manual_done(std::string event_name) ;
|
|
|
|
#ifdef SWIG
|
|
// SWIG macros are not normally run on classes in sim_services. We can add the the processed code manually
|
|
%trick_cast_as(Trick::IPPythonEvent, Trick__IPPythonEvent)
|
|
#endif
|
|
|
|
#endif
|
|
|