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 lf_token_t* _lf_tokens_allocated_in_reactions;
 
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(struct environment_t* env);
 
#endif /* LF_TOKEN_H */