modes.h

Go to the documentation of this file.

#ifndef MODES_H
#define MODES_H
 
#ifdef MODAL_REACTORS
 
#include <stddef.h>
#include <stdbool.h>
 
#include "lf_types.h"
#include "tag.h"
 
typedef struct event_t event_t;
typedef struct reaction_t reaction_t;
typedef struct trigger_t trigger_t;


#define _LF_SET_MODE_WITH_TYPE(mode, change_type)                                                                      \
  do {                                                                                                                 \
    ((self_base_t*)self)->_lf__mode_state.next_mode = mode;                                                            \
    ((self_base_t*)self)->_lf__mode_state.mode_change = change_type;                                                   \
  } while (0)

 
/* Typedef for reactor_mode_t struct, used for representing a mode. */
typedef struct reactor_mode_t reactor_mode_t;
/* Typedef for reactor_mode_state_t struct, used for storing modal state of reactor and/or its relation to enclosing
 * modes. */
typedef struct reactor_mode_state_t reactor_mode_state_t;
/* Typedef for mode_state_variable_reset_data_t struct, used for storing data for resetting state variables nested in
 * modes. */
typedef struct mode_state_variable_reset_data_t mode_state_variable_reset_data_t;

typedef enum { no_transition, reset_transition, history_transition } lf_mode_change_type_t;

struct reactor_mode_t {
  reactor_mode_state_t* state;
  char* name;
  instant_t deactivation_time;
  uint8_t flags;
};

struct reactor_mode_state_t {
  reactor_mode_t* parent_mode;
  reactor_mode_t* initial_mode;
  reactor_mode_t* current_mode;
  reactor_mode_t* next_mode;
  lf_mode_change_type_t mode_change;
};

struct mode_state_variable_reset_data_t {
  reactor_mode_t* mode;
  void* target;
  void* source;
  size_t size;
};

typedef struct environment_t environment_t;


void _lf_initialize_modes(environment_t* env);

void _lf_handle_mode_changes(environment_t* env);

void _lf_handle_mode_triggered_reactions(environment_t* env);

bool _lf_mode_is_active(reactor_mode_t* mode);

void _lf_initialize_mode_states(environment_t* env, reactor_mode_state_t* states[], int states_size);

void _lf_process_mode_changes(environment_t* env, reactor_mode_state_t* states[], int states_size,
                              mode_state_variable_reset_data_t reset_data[], int reset_data_size,
                              trigger_t* timer_triggers[], int timer_triggers_size);

void _lf_add_suspended_event(event_t* event);

void _lf_handle_mode_startup_reset_reactions(environment_t* env, reaction_t** startup_reactions,
                                             int startup_reactions_size, reaction_t** reset_reactions,
                                             int reset_reactions_size, reactor_mode_state_t* states[], int states_size);

void _lf_handle_mode_shutdown_reactions(environment_t* env, reaction_t** shutdown_reactions,
                                        int shutdown_reactions_size);

void _lf_terminate_modal_reactors(environment_t* env);
 
#else  /* IF NOT MODAL_REACTORS */
/*
 * Reactions and triggers must have a mode pointer to set up connection to enclosing modes,
 * also when they are precompiled without modal reactors in order to later work in modal reactors.
 * Hence define mode type as void in the absence of modes to treat mode pointer as void pointers for that time being.
 */
typedef void reactor_mode_t;
#endif /* MODAL_REACTORS */
#endif /* MODES_H */