federate.h

Go to the documentation of this file.

 
#ifndef FEDERATE_H
#define FEDERATE_H
 
#include <stdbool.h>
 
#include "tag.h"
#include "lf_types.h"
#include "environment.h"
#include "low_level_platform.h"
 
#ifndef ADVANCE_MESSAGE_INTERVAL
#define ADVANCE_MESSAGE_INTERVAL MSEC(10)
#endif
 
// Data types
 
typedef struct federate_instance_t {
  int socket_TCP_RTI;
 
  lf_thread_t RTI_socket_listener;
 
  size_t number_of_inbound_p2p_connections;
 
  lf_thread_t* inbound_socket_listeners;
 
  size_t number_of_outbound_p2p_connections;
 
  int sockets_for_inbound_p2p_connections[NUMBER_OF_FEDERATES];
 
  int sockets_for_outbound_p2p_connections[NUMBER_OF_FEDERATES];
 
  lf_thread_t inbound_p2p_handling_thread_id;
 
  int server_socket;
 
  int server_port;
 
  tag_t last_TAG;
 
  bool is_last_TAG_provisional;
 
  bool has_upstream;
 
  bool has_downstream;
 
  bool received_stop_request_from_rti;
 
  tag_t last_sent_LTC;
 
  tag_t last_sent_NET;
 
  instant_t min_delay_from_physical_action_to_federate_output;
 
#ifdef FEDERATED_DECENTRALIZED
  lf_thread_t staaSetter;
#endif
} federate_instance_t;
 
#ifdef FEDERATED_DECENTRALIZED
typedef struct staa_t {
  lf_action_base_t** actions;
  size_t STAA;
  size_t num_actions;
} staa_t;
#endif
 
typedef struct federation_metadata_t {
  const char* federation_id;
  char* rti_host;
  int rti_port;
  char* rti_user;
} federation_metadata_t;
 
typedef enum parse_rti_code_t { SUCCESS, INVALID_PORT, INVALID_HOST, INVALID_USER, FAILED_TO_PARSE } parse_rti_code_t;
 
// Global variables
 
extern lf_mutex_t lf_outbound_socket_mutex;
 
extern lf_cond_t lf_port_status_changed;
 
// Public functions (in alphabetical order)
 
void lf_connect_to_federate(uint16_t);
 
void lf_connect_to_rti(const char* hostname, int port_number);
 
void lf_create_server(int specified_port);
 
void lf_enqueue_port_absent_reactions(environment_t* env);
 
void* lf_handle_p2p_connections_from_federates(void*);
 
void lf_latest_tag_confirmed(tag_t);
 
parse_rti_code_t lf_parse_rti_addr(const char* rti_addr);
 
void lf_reset_status_fields_on_input_port_triggers();
 
int lf_send_message(int message_type, unsigned short port, unsigned short federate, const char* next_destination_str,
                    size_t length, unsigned char* message);
 
void lf_send_neighbor_structure_to_RTI(int);
 
tag_t lf_send_next_event_tag(environment_t* env, tag_t tag, bool wait_for_reply);
 
void lf_send_port_absent_to_federate(environment_t* env, interval_t additional_delay, unsigned short port_ID,
                                     unsigned short fed_ID);
 
int lf_send_stop_request_to_rti(tag_t stop_tag);
 
int lf_send_tagged_message(environment_t* env, interval_t additional_delay, int message_type, unsigned short port,
                           unsigned short federate, const char* next_destination_str, size_t length,
                           unsigned char* message);
 
void lf_set_federation_id(const char* fid);
 
#ifdef FEDERATED_DECENTRALIZED
void lf_spawn_staa_thread(void);
#endif
 
void lf_stall_advance_level_federation(environment_t* env, size_t level);
 
void lf_stall_advance_level_federation_locked(size_t level);
 
void lf_synchronize_with_other_federates();
 
bool lf_update_max_level(tag_t tag, bool is_provisional);
 
#ifdef FEDERATED_DECENTRALIZED
instant_t lf_wait_until_time(tag_t tag);
#endif // FEDERATED_DECENTRALIZED
 
#endif // FEDERATE_H