lf_token.h

Go to the documentation of this file.

 
#ifndef LF_TOKEN_H
#define LF_TOKEN_H
 
#include <stdlib.h> // Defines size_t
 
// Forward declarations
struct environment_t;
 
 
typedef enum token_freed {
  NOT_FREED = 0,        // Nothing was freed.
  VALUE_FREED,          // The value (payload) was freed.
  TOKEN_FREED,          // The token was freed but not the value.
  TOKEN_AND_VALUE_FREED // Both were freed
} token_freed;
 
 
typedef struct token_type_t {
  size_t element_size;
  void (*destructor)(void* value);
  void* (*copy_constructor)(void* value);
} token_type_t;
 
typedef struct lf_token_t {
  void* value;
  size_t length;
  token_type_t* type;
  size_t ref_count;
  struct lf_token_t* next;
} lf_token_t;
 
typedef struct lf_sparse_io_record_t {
  int size;                 // -1 if overflowed. 0 if empty.
  size_t capacity;          // Max number of writes to be considered sparse.
  size_t* present_channels; // Array of channel indices that are present.
} lf_sparse_io_record_t;
 
typedef struct token_template_t {
  token_type_t type;
  lf_token_t* token;
  size_t length; // The token's length, for convenient access in reactions.
} token_template_t;
 
// Forward declaration for self_base_t
typedef struct self_base_t self_base_t;
 
typedef struct lf_port_base_t {
  token_template_t tmplt; // Type and token information (template is a C++ keyword).
  bool is_present;
  lf_sparse_io_record_t* sparse_record; // NULL if there is no sparse record.
  int destination_channel;              // -1 if there is no destination.
  int num_destinations;                 // The number of destination reactors this port writes to.
  self_base_t* source_reactor;          // Pointer to the self struct of the reactor that provides data to this port.
                                        // If this is an input, that reactor will normally be the container of the
                                        // output port that sends it data.
} lf_port_base_t;
 
 
extern int _lf_count_token_allocations;
 
 
lf_token_t* lf_new_token(void* port_or_action, void* val, size_t len);
 
lf_token_t* lf_writable_copy(lf_port_base_t* port);
 
 
token_freed _lf_free_token(lf_token_t* token);
 
lf_token_t* _lf_new_token(token_type_t* type, void* value, size_t length);
 
lf_token_t* _lf_get_token(token_template_t* tmplt);
 
void _lf_initialize_template(token_template_t* tmplt, size_t element_size);
 
lf_token_t* _lf_initialize_token_with_value(token_template_t* tmplt, void* value, size_t length);
 
lf_token_t* _lf_initialize_token(token_template_t* tmplt, size_t length);
 
void _lf_free_all_tokens();
 
void _lf_replace_template_token(token_template_t* tmplt, lf_token_t* newtoken);
 
token_freed _lf_done_using(lf_token_t* token);
 
void _lf_free_token_copies(void);
 
#endif /* LF_TOKEN_H */