Cosmos::Event Class Reference

Class to manage Event information. More...

#include <event.h>

Collaboration diagram for Cosmos::Event:

Public Member Functions
	Event ()
	Default constructor. More...
	~Event ()
	Destructor. More...
void	set_command (string jstring)
	Sets Event information from a JSON formatted string. More...
void	set_utcexec ()
	Sets Event::utcexec to current time. More...
void	set_actual ()
	Sets Event::flag to indicate the event has actually executed (i.e. EVENT_FLAG_ACTUAL) More...
string	get_name ()
	Retrieves Event::name. More...
string	get_event_string ()
	Retrieves Event information. More...
double	getUtc ()
	Retrieves Event::mjd. More...
string	getTime ()
	Retrieves Event::mjd. More...
double	getUtcExec ()
	Retrieves Event::utcexec. More...
string	get_data ()
	Retrieves Event::data. More...
bool	is_ready ()
	Determines if it is time for the Event to execute. More...
bool	is_repeat ()
	Determines if the Event repeatable. More...
bool	is_command ()
	Determines if the Event is a command. More...
bool	is_conditional ()
	Determines if the Event is a conditional command. More...
bool	is_solo ()
	Determines if the Event is a solo command. More...
bool	is_alreadyrun ()
	Determines if the Event has already run. More...
void	set_alreadyrun (bool value)
string	generator (string name, string data, double utc, string condition, uint32_t flag)
string	generator (eventstruc event)
bool	condition_true (cosmosstruc *cinfo)

Public Attributes
double	mjd
double	utcexec =0.
string	name
uint32_t	type
uint32_t	flag
string	data
string	condition
bool	already_ran
uint32_t	true_count =0
string	event_string

Friends
std::ostream &	operator<< (std::ostream &out, const Event &cmd)
	Extraction operator. More...
bool	operator== (const Event &cmd1, const Event &cmd2)
	Equality operator. More...

Detailed Description

Class to manage Event information.

An Event is a collection of information related to a single occurance.

Constructor & Destructor Documentation

Cosmos::Event::Event

(

)

Default constructor.

             :
    mjd(0),
    utcexec(0),
    name(""),
    type(0),
    flag(0),
    data(""),
    condition(""),
    already_ran(false)
{}

Cosmos::Event::~Event

(

)

Destructor.

{}

Member Function Documentation

void Cosmos::Event::set_command

(

string

jstring

)

Sets Event information from a JSON formatted string.

Parameters

jstring

Event information string formatted as JSON

This function copies all Event information (from a JSON formatted string) into the current Event object

{
    // clear Event information in agent
    cosmosstruc * dummy = json_init();
//    json_mapbaseentries(dummy);

    json_clear_cosmosstruc(JSON_STRUCT_EVENT, dummy);

    // load Event information (from jstring) into agent
    json_parse(jstring, dummy);

    mjd = dummy->event[0].utc;
    utcexec = dummy->event[0].utcexec;
    name = dummy->event[0].name;
    type = dummy->event[0].type;
    flag = dummy->event[0].flag;
    data = dummy->event[0].data;
    condition = dummy->event[0].condition;
}

void Cosmos::Event::set_utcexec ( )

inline

Sets Event::utcexec to current time.

This function is called after event execution and updates the execution time.

{   utcexec = currentmjd(0.);   }

void Cosmos::Event::set_actual ( )

inline

Sets Event::flag to indicate the event has actually executed (i.e. EVENT_FLAG_ACTUAL)

This function is called after event execution and updates the execution status.

{   flag |= EVENT_FLAG_ACTUAL;  }

string Cosmos::Event::get_name ( )

inline

Retrieves Event::name.

Returns

string representing Event name

{   return name; }

string Cosmos::Event::get_event_string

(

)

Retrieves Event information.

Returns

string representing Event information (as a JSON formatted string)

{
    JSONObject jobj;
    jobj.addElement("event_utc", JSONValue(mjd));
    if (utcexec != 0.)
    {
        jobj.addElement("event_utcexec", JSONValue(utcexec));
    }
    jobj.addElement("event_name", JSONValue(name));
    jobj.addElement("event_type", JSONValue(type));
    jobj.addElement("event_flag", JSONValue(flag));
    jobj.addElement("event_data", JSONValue(data));
    if (flag & EVENT_FLAG_CONDITIONAL)
    {
        jobj.addElement("event_condition", JSONValue(condition));
    }

    return jobj.to_json_string();
}

double Cosmos::Event::getUtc ( )

inline

Retrieves Event::mjd.

Returns

double representing Event start time

{   return mjd; }

string Cosmos::Event::getTime ( )

inline

Retrieves Event::mjd.

Returns

double representing Event start time

{   return mjd2iso8601( getUtc() ); }

double Cosmos::Event::getUtcExec ( )

inline

Retrieves Event::utcexec.

Returns

double representing Event execution time

{   return utcexec; }

string Cosmos::Event::get_data ( )

inline

Retrieves Event::data.

Returns

string representing Event data

{   return data; }

bool Cosmos::Event::is_ready ( )

inline

Determines if it is time for the Event to execute.

Returns

True if Event is ready to execute, otherwise false

{   return (mjd <= currentmjd(0.)); }

bool Cosmos::Event::is_repeat ( )

inline

Determines if the Event repeatable.

Returns

True if Event is repeatable, otherwise false

{   return (flag & EVENT_FLAG_REPEAT);  }

bool Cosmos::Event::is_command ( )

inline

Determines if the Event is a command.

Returns

True if Event is a command, otherwise false

{   return (type & EVENT_TYPE_COMMAND); }

bool Cosmos::Event::is_conditional ( )

inline

Determines if the Event is a conditional command.

Returns

True if Event is a conditional command, otherwise false

{   return (flag & EVENT_FLAG_CONDITIONAL); }

bool Cosmos::Event::is_solo ( )

inline

Determines if the Event is a solo command.

Returns

True if Event is a solo command, otherwise false

{   return (flag & EVENT_FLAG_SOLO);    }

bool Cosmos::Event::is_alreadyrun ( )

inline

Determines if the Event has already run.

Returns

True if Event has already run, otherwise false

{   return (flag & EVENT_FLAG_TRUE);    }

void Cosmos::Event::set_alreadyrun ( bool  value )

inline

{ if (value) flag |= EVENT_FLAG_TRUE; else flag &= ~EVENT_FLAG_TRUE; }

string Cosmos::Event::generator	(	string	name,
		string	data,
		double	utc,
		string	condition,
		uint32_t	flag
	)

  {

    this->name = name;
    this->data = data;
    this->mjd  = mjd;
    this->condition = condition;
    this->flag = flag;
    this->utcexec = 0.;
    this->type = EVENT_TYPE_COMMAND;
    event_string = "";
    event_string = this->get_event_string();

    return event_string;
}

string Cosmos::Event::generator

(

eventstruc

event

)

                                        {

    // returns a string with the event and also puts the string in "event_string"
    return generator(event.name, event.data, event.utc, event.condition, event.flag);;
}

bool Cosmos::Event::condition_true

(

cosmosstruc *

cinfo

)

{
    const char *cp = condition.c_str();
    if (cinfo != nullptr)
    { // Note: an equation must be enclosed by parentheses.
        double r =  json_equation(cp, cinfo);
        if (fabs(r - 1.0) < std::numeric_limits<double>::epsilon())
        {
            ++true_count;
            if (true_count >= 5 * (flag&EVENT_FLAG_PRIORITY)/32)
            {
                return true;
            }
        }
    }
    return false;
}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  out, const Event &  cmd  )

friend

Extraction operator.

Parameters

out	Reference to ostream
cmd	Reference to const Event

Returns

Reference to modified ostream

Writes the given Event to the given output stream (in JSON format) and returns a reference to the modified ostream.

{
    JSONObject jobj;
    jobj.addElement("event_utc", JSONValue(cmd.mjd));
    if (cmd.utcexec != 0.)
    {
        jobj.addElement("event_utcexec", JSONValue(cmd.utcexec));
    }
    jobj.addElement("event_name", JSONValue(cmd.name));
    jobj.addElement("event_type", JSONValue(cmd.type));
    jobj.addElement("event_flag", JSONValue(cmd.flag));
    jobj.addElement("event_data", JSONValue(cmd.data));
    if (cmd.flag & EVENT_FLAG_CONDITIONAL)
    {
        jobj.addElement("event_condition", JSONValue(cmd.condition));
    }
    out << std::setprecision(15) << jobj.to_json_string();
    return out;
}

bool operator== ( const Event &  cmd1, const Event &  cmd2  )

friend

Equality operator.

Parameters

cmd1	First event
cmd2	Second event

Returns

True if events are exactly the same, otherwise false

{
    return (    cmd1.name==cmd2.name &&
                cmd1.mjd==cmd2.mjd &&
                cmd1.utcexec==cmd2.utcexec &&
                cmd1.type==cmd2.type &&
                cmd1.flag==cmd2.flag &&
                cmd1.data==cmd2.data &&
                cmd1.condition==cmd2.condition);
}

Member Data Documentation

double Cosmos::Event::mjd

Event start time (Modified Julian Date)

double Cosmos::Event::utcexec =0.

Event execution time (Coordinated Universal Time) – JIMNOTE: but appears to be using MJD in the code? should it be named mjdexec?

string Cosmos::Event::name

Event name

uint32_t Cosmos::Event::type

Event type

uint32_t Cosmos::Event::flag

Event flag

string Cosmos::Event::data

Event data

string Cosmos::Event::condition

Event condition

bool Cosmos::Event::already_ran

Event run indicators

uint32_t Cosmos::Event::true_count =0

string Cosmos::Event::event_string

Event information stored as a JSON string

---

The documentation for this class was generated from the following files:

• event.h
• event.cpp