ceptr_types.h

#ifndef _CEPTR_TYPES_H
#define _CEPTR_TYPES_H

#include <stdint.h>
#include <stdio.h>
#include "uthash.h"
#include <stdbool.h>

// NOTE: the actual values of the types matter because they must match the order they show
// up in the definition trees
enum SemanticTypes {SEM_TYPE_STRUCTURE=1,SEM_TYPE_SYMBOL,SEM_TYPE_PROCESS,SEM_TYPE_RECEPTOR,SEM_TYPE_PROTOCOL};
#define is_symbol(s) ((s).semtype == SEM_TYPE_SYMBOL)
#define is_process(s) ((s).semtype == SEM_TYPE_PROCESS)
#define is_structure(s) ((s).semtype == SEM_TYPE_STRUCTURE)
#define is_protocol(s) ((s).semtype == SEM_TYPE_PROTOCOL)
#define is_receptor(s) ((s).semtype == SEM_TYPE_RECEPTOR)

typedef uint32_t Context;     // 4G types of receptors
typedef uint16_t SemanticType; // 256 types of semantic things (but using 2 bytes for struct alignment!)
typedef uint16_t SemanticAddr;// 64K types of symbols/structure per receptor

typedef struct SemanticID {
    Context context;
    SemanticType semtype;
    SemanticAddr id;
    //c    uint8_t _reserved; // add an extra 8 bits to make this a 64bit structure.
} SemanticID;

// creating aliases for SemanticIDs as hints for use.
typedef SemanticID Symbol;
typedef SemanticID Structure;
typedef SemanticID Process;
typedef SemanticID Protocol;
typedef SemanticID Recept;


// ** types for matrix trees
typedef uint16_t Mlevel;
typedef uint32_t Mindex;
typedef uint32_t Mmagic;

typedef struct N {
    Symbol symbol;
    Mindex parenti;
    uint32_t flags;
    uint32_t cur_child;  // for active run-trees
    size_t size;
    void *surface;  // this item must be last!!!
} N;

typedef struct L {
    Mindex nodes;
    N *nP;
} L;

typedef struct M {
    Mmagic magic;
    Mlevel levels;
    L *lP;
} M;

// node entries are fixed size but the surface when serialized is an offset
// in the blob not a pointer
#define SERIALIZED_NODE_SIZE (sizeof(N)-sizeof(void *)+sizeof(size_t))
#define SERIALIZED_LEVEL_SIZE(l) (sizeof(Mindex)+SERIALIZED_NODE_SIZE*l->nodes)
#define SERIALIZED_HEADER_SIZE(levels) (sizeof(S)+sizeof(uint32_t)*(levels))

typedef struct S {
    Mmagic magic;
    size_t total_size;
    Mlevel levels;
    uint32_t blob_offset;
    uint32_t level_offsets[];
} S;

#define NULL_ADDR -1
typedef struct Maddr {
    Mlevel l;
    Mindex i;
} Maddr;

// ** generic tree type defs
typedef struct H {
    M *m;
    Maddr a;
} H;

enum treeImplementations {ptrImpl=0xfffffffe,matrixImpl=0xffffffff};
#define FIRST_TREE_IMPL_TYPE ptrImpl
#define LAST_TREE_IMPL_TYPE matrixImpl


// ** types for pointer trees
typedef struct Tstruct {
    uint32_t child_count;
    struct T *parent;
    struct T **children;
} Tstruct;

typedef struct Tcontents {
    Symbol symbol;
    size_t size;
    void *surface;
} Tcontents;

typedef struct Tcontext {
    uint32_t flags;
} Tcontext;

typedef struct T {
    Tstruct structure;
    Tcontext context;
    Tcontents contents;
} T;

#define RUN_TREE_NOT_EVAULATED       0
#define RUN_TREE_EVALUATED           0xffffffff

typedef struct rT {
    Tstruct structure;
    Tcontext context;
    Tcontents contents;
    uint32_t cur_child;
} rT;

// macro helper to get at the cur_child element of a run-tree node when given a regular
// node (does the casting to make code look cleaner)
#define rt_cur_child(tP) (((rT *)tP)->cur_child)

typedef uint32_t TreeHash;

// ** types for labels
typedef uint32_t Label;

typedef struct table_elem {
    UT_hash_handle hh;         
    Label label;               
    int path_s;                
} table_elem;
typedef table_elem *LabelTable;

// for now store instances in an INSTANCES semantic tree
typedef T *Instances;

typedef struct ConversationState ConversationState;
struct ConversationState {
    T *converse_pointer;    
    T *cid;                 
    ConversationState *next;
};

// ** types for processing
// run-tree context
typedef struct R R;
struct R {
    int id;           
    int err;          
    int state;        
    T *run_tree;      
    T *node_pointer;  
    T *parent;        
    int idx;          
    R *caller;        
    R *callee;        
    T *sem_map;       
    ConversationState *conversation;  
};

// ** structure to hold in process accounting
typedef struct Accounting Accounting;
struct Accounting {
    uint64_t elapsed_time;
};

// Processing Queue element
typedef struct Qe Qe;
struct Qe {
    int id;
    R *context;
    Accounting accounts;
    Qe *next;
    Qe *prev;
};

typedef struct ReceptorAddress {
    int addr;
} ReceptorAddress;

typedef struct Receptor Receptor;

// Processing Queue structure
typedef struct Q Q;
struct Q {
    Receptor *r;         
    int contexts_count;  
    Qe *active;          
    Qe *completed;       
    Qe *blocked;         
    pthread_mutex_t mutex;
};

// SemTable structures
typedef struct ContextStore {
    T *definitions;
    //LabelTable table;    ///< the label table for this context?
} ContextStore;

//@todo convert to malloc
#define MAX_CONTEXTS 100
typedef struct SemTable {
    int contexts;
    ContextStore stores[MAX_CONTEXTS];
} SemTable;


// ** types for receptors
enum ReceptorStates {Alive=0,Dead};

struct Receptor {
    T *root;             
    Context parent;      
    Context context;     
    ReceptorAddress addr;
    SemTable *sem;       
    T *flux;             
    T *pending_signals;
    T *pending_responses;
    T *conversations;
    pthread_mutex_t pending_signals_mutex;
    pthread_mutex_t pending_responses_mutex;
    Instances instances; 
    Q *q;                
    int state;           
    T *edge;             
};

typedef struct UUIDt {
    uint64_t data;
    uint64_t time;
} UUIDt;

// aspects appear on either side of the membrane
enum AspectType {EXTERNAL_ASPECT=0,INTERNAL_ASPECT};
typedef Symbol Aspect;  //aspects are identified by a semantic Symbol identifier

typedef struct Xaddr {
    Symbol symbol;
    int addr;
} Xaddr;

typedef int Error;

// ** types for scapes

typedef struct scape_elem {
    TreeHash key;            
    Xaddr value;             
    UT_hash_handle hh;       
} scape_elem;
typedef scape_elem *ScapeData;

typedef struct Scape {
    Symbol key_source;
    Symbol data_source;
    ScapeData data;      
} Scape;

#endif