evpath.h

#ifndef __EVPATH__H__
#define __EVPATH__H__

#include "ffs.h"
#include "atl.h"
#ifdef  __cplusplus
extern "C" {
#endif

#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif




struct _CManager;
struct _CMConnection;
struct _CMFormat;

typedef struct _CManager *CManager;

typedef struct _CMConnection *CMConnection;

typedef struct _CMFormat *CMFormat;

typedef struct _CMTaskHandle *CMTaskHandle;

typedef struct buf_entry {
    long length;        
    void *buffer;       
} *EVevent_list;

typedef void (*CMHandlerFunc) (CManager cm, 
                               CMConnection conn,
                               void *message, void *client_data,
                               attr_list attrs);

typedef void (*CMPollFunc) (CManager cm, void *client_data);

typedef void (*CMCloseHandlerFunc) (CManager cm, CMConnection conn,
                                    void *client_data);

typedef void (*CMWriteCallbackFunc) (CManager cm, CMConnection conn,
                                     void *client_data);



/*NOLOCK*/
extern CManager CManager_create();

extern void CManager_close (CManager cm);

/*NOLOCK*/
extern void CMTrace_file_id (int ID);

extern int CMfork_comm_thread (CManager cm);

extern int CMlisten (CManager cm);

extern int CMlisten_specific (CManager cm, attr_list listen_info);

extern attr_list
CMget_contact_list (CManager cm);

extern void
CM_insert_contact_info (CManager cm, attr_list attrs);

extern attr_list
CMget_specific_contact_list (CManager cm, attr_list attrs);

extern int
CMcontact_self_check (CManager cm, attr_list attrs);

extern CMConnection
CMget_conn (CManager cm, attr_list contact_list);

extern CMConnection
CMinitiate_conn (CManager cm, attr_list contact_list);

extern void
CMConnection_close (CMConnection conn);

extern void
CMConnection_add_reference (CMConnection conn);

extern void
CMconn_register_close_handler (CMConnection conn, 
                               CMCloseHandlerFunc func, 
                               void *client_data);
extern attr_list 
CMConnection_get_attrs (CMConnection conn);

extern int
CMConnection_set_character (CMConnection conn, attr_list attrs);

extern CMConnection
CMget_indexed_conn (CManager cm, int i);

extern CMFormat
CMregister_format (CManager cm, FMStructDescList format_list);

extern CMFormat
CMregister_simple_format (CManager cm, char *format_name, FMFieldList field_list, int struct_size);

extern CMFormat CMlookup_format (CManager cm, FMStructDescList format_list);

/*NOLOCK*/
extern FMContext CMget_FMcontext(CManager cm);

extern int
CMwrite (CMConnection conn, CMFormat format, void *data);

extern int
CMwrite_attr (CMConnection conn, CMFormat format, void *data, 
              attr_list attrs);

extern void
CMregister_handler (CMFormat format, CMHandlerFunc handler, 
                    void *client_data);

extern void
CMregister_write_callback (CMConnection conn, 
                           CMWriteCallbackFunc handler,
                           void *client_data);

extern int
CMConnection_write_would_block (CMConnection conn);

extern void *CMtake_buffer (CManager cm, void *data);

extern void CMreturn_buffer (CManager cm, void *data);

#include "cm_transport.h"
typedef int (*CMNonCMHandler) (CMConnection conn, CMTransport transport,
                               char *buffer, long length);

/*NOLOCK*/
extern void
CMregister_non_CM_message_handler (int header, CMNonCMHandler handler);

/*NOLOCK*/
extern CMtrans_services
CMget_static_trans_services ();

extern void*
CMget_transport_data (CMConnection conn);

extern void
CMadd_poll (CManager cm, CMPollFunc func, void *client_data);

extern CMTaskHandle
CMadd_periodic_task (CManager cm, int period_sec, int period_usec, 
                     CMPollFunc func, void *client_data);

extern CMTaskHandle
CMadd_delayed_task (CManager cm, int secs, int usecs, CMPollFunc func,
                    void *client_data);

extern void
CMremove_task (CMTaskHandle handle);

extern void
CMadd_shutdown_task (CManager cm, CMPollFunc func, void *client_data, int task_type);

#define NO_TASK 0

#define SHUTDOWN_TASK 1

#define FREE_TASK 2

extern CMTaskHandle
CMadd_periodic (CManager cm, long period, CMPollFunc func,
                void *client_data);

extern void
CMremove_periodic (CMTaskHandle handle);

extern void
CMsleep (CManager cm, int secs);

extern void
CMusleep (CManager cm, int usecs);

extern 
void CMpoll_network (CManager cm);

extern 
void CMrun_network (CManager cm);

typedef void (*select_func) (void *param1, void*param2);

extern void
CM_fd_add_select (CManager cm, int fd, select_func handler_func,
                  void *param1, void *param2);

extern int CMCondition_get (CManager cm, CMConnection dep);

extern int CMCondition_wait (CManager cm, int condition);

extern void CMCondition_signal (CManager cm, int condition);

extern void CMCondition_set_client_data (CManager cm, int condition,
                                       void *client_data);
extern void *CMCondition_get_client_data (CManager cm, int condition);

extern int CMCondition_has_signaled (CManager cm, int condition);
extern int CMCondition_has_failed (CManager cm, int condition);

/*NOLOCK*/
extern void* CMrealloc (void *ptr, long size);
/*NOLOCK*/
extern void* CMmalloc (long size);
/*NOLOCK*/
extern void CMfree (void *ptr);

extern long CMprobe_latency (CMConnection conn, long msg_size,
                                  attr_list attrs);

extern double
CMprobe_bandwidth (CMConnection conn, long size, attr_list attrs);

extern double
CMregressive_probe_bandwidth (CMConnection conn, long size, attr_list attrs);

/*NOLOCK*/
extern int
CMget_self_ip_addr(CManager cm);

struct _EVStone;
struct _EVSource;
typedef int EVstone;
typedef int EVaction;
typedef struct _EVSource *EVsource;

typedef void (*EVSubmitCallbackFunc) (CManager cm, EVstone target, 
                                          void *client_data);

typedef int (*EVSimpleHandlerFunc) (CManager cm, void *message, void *client_data,
                                    attr_list attrs);

typedef int (*EVRawHandlerFunc) (CManager cm, void *message, int msg_len, void *client_data,
                                 attr_list attrs);

typedef void (*EVStoneCloseHandlerFunc) (CManager cm, CMConnection conn, int stone, void *client_data);

struct _event_item;

/*REMOTE*/
extern EVstone
EValloc_stone(CManager cm);

/*REMOTE*/
extern void
EVfree_stone(CManager cm, EVstone stone);

/*REMOTE*/
extern EVaction
EVassoc_terminal_action(CManager cm, EVstone stone, FMStructDescList format_list, 
                        EVSimpleHandlerFunc handler, void* client_data);

extern EVaction
EVassoc_raw_terminal_action(CManager cm, EVstone stone, 
                            EVRawHandlerFunc handler, void* client_data);

/*REMOTE*/
extern EVstone
EVcreate_terminal_action(CManager cm, FMStructDescList format_list, 
                        EVSimpleHandlerFunc handler, void* client_data);

/*REMOTE*/
extern EVaction
EVassoc_multi_action(CManager cm, EVstone stone, char *action_spec, 
                     void *client_data);

/*REMOTE*/
extern EVaction
EVassoc_immediate_action(CManager cm, EVstone stone, char *action_spec, 
                      void *client_data);

/*REMOTE*/
extern EVstone
EVcreate_immediate_action(CManager cm, char *action_spec, EVstone *target_list);

/*REMOTE*/
extern int
EVaction_set_output(CManager cm, EVstone stone, EVaction action, 
                    int output_index, EVstone target_stone);

/*REMOTE*/
extern int
EVstone_set_output(CManager cm, EVstone stone, int output_index, EVstone target_stone);

/*REMOTE*/
extern EVaction
EVassoc_filter_action(CManager cm, EVstone stone, 
                      FMStructDescList incoming_format_list, 
                      EVSimpleHandlerFunc handler, EVstone out_stone,
                      void* client_data);

/*REMOTE*/
extern EVaction
EVassoc_bridge_action(CManager cm, EVstone stone, attr_list contact_list, 
                      EVstone remote_stone);

/*REMOTE*/
extern EVstone
EVcreate_bridge_action(CManager cm, attr_list contact_list, 
                       EVstone remote_stone);

extern EVaction
EVassoc_thread_bridge_action(CManager cm, EVstone stone, CManager target_cm,
                             EVstone target_stone);

extern EVstone
EVcreate_thread_bridge_action(CManager cm, CManager target_cm,
                              EVstone target_stone);

/*REMOTE*/
extern EVaction
EVassoc_split_action(CManager cm, EVstone stone, EVstone *target_list);

/*REMOTE*/
extern EVstone
EVcreate_split_action(CManager cm, EVstone *target_list);

/*REMOTE*/
extern int
EVaction_add_split_target(CManager cm, EVstone stone, EVaction action,
                          EVstone target_stone);

/*REMOTE*/
extern void
EVaction_remove_split_target(CManager cm, EVstone stone, EVaction action,
                          EVstone target_stone);

/*REMOTE*/
extern void
EVstone_add_split_target(CManager cm, EVstone stone, EVstone target_stone);

/*REMOTE*/
extern void
EVstone_remove_split_target(CManager cm, EVstone stone, EVstone target_stone);

extern EVaction
EVassoc_congestion_action(CManager cm, EVstone stone, char *action_spec,
                          void* client_data);

/*REMOTE*/
extern EVstone
EVcreate_store_action(CManager cm, EVstone out_stone, int store_limit);

/*REMOTE*/
extern EVstone
EVcreate_stone_action(CManager cm, char *action_spec);

/*REMOTE*/
extern EVaction 
EVassoc_store_action(CManager cm, EVstone stone_num, EVstone out_stone,
                        int store_limit);

/*REMOTE*/ /* XXX??? */
extern void
EVclear_stored(CManager cm, EVstone stone_num, EVaction action_num);

extern void
EVsend_stored(CManager cm, EVstone stone_num, EVaction action_num);

extern int 
EVstore_count(CManager cm, EVstone stone_num, EVaction action_num); 

extern int
EVstore_is_sending(CManager cm, EVstone stone_num, EVaction action_num);

extern void
EVstore_start_send(CManager cm, EVstone stone_num, EVaction action_num); 

extern void
EVset_store_limit(CManager cm, EVstone stone_num, EVaction action_num,
    int store_limit);

extern EVsource
EVcreate_submit_handle(CManager cm, EVstone stone, FMStructDescList data_format);

extern void
EVfree_source(EVsource source);

typedef void (*EVFreeFunction) (void *event_data, void *client_data);

extern EVsource
EVcreate_submit_handle_free(CManager cm, EVstone stone, FMStructDescList data_format,
                            EVFreeFunction free_func, void *client_data);

extern void
EVsubmit(EVsource source, void *data, attr_list attrs);

extern void
EVsubmit_general(EVsource source, void *data, EVFreeFunction free_func,
                 attr_list attrs);

extern void
EVsubmit_encoded(CManager cm, EVstone stone, void *data, int data_len,
                 attr_list attrs);

/*REMOTE*/
extern int
EVtransfer_events(CManager cm, EVstone src_stone, EVstone dest_stone);

extern int
EVtake_event_buffer (CManager cm, void *event);

extern void
EVreturn_event_buffer (CManager cm, void *event);

extern FMFormat
EVget_src_ref_format(EVsource source);

/*REMOTE*/
extern void
EVenable_auto_stone(CManager cm, EVstone stone_num, int period_sec, 
                    int period_usec);

/*REMOTE*/
extern EVstone
EVcreate_auto_stone(CManager cm, int period_sec, int period_usec, 
                    char *action_spec, EVstone out_stone);


/*REMOTE*/
extern void
EVstall_stone(CManager cm, EVstone stone_id);

/*REMOTE*/
extern void
EVunstall_stone(CManager cm, EVstone stone_id); 

extern int
EVsubmit_or_wait(EVsource source, void *data, attr_list attrs, EVSubmitCallbackFunc cb, void *user_data);

extern int
EVsubmit_encoded_or_wait(CManager cm, EVstone stone, void *data, int data_len, attr_list attrs,
                            EVSubmitCallbackFunc cb, void *user_data);

/*REMOTE*/
extern int
EVfreeze_stone(CManager cm, EVstone stone_id);

/*REMOTE*/
extern int
EVunfreeze_stone(CManager cm, EVstone stone_id);

/*REMOTE*/
extern int
EVdrain_stone(CManager cm, EVstone stone_id);

extern EVstone
EVexecuting_stone(CManager cm);

extern EVevent_list
EVextract_stone_events(CManager cm, EVstone stone_id);

/*REMOTE*/
extern attr_list
EVextract_attr_list(CManager cm, EVstone stone_id);

/*REMOTE*/
extern void
EVset_attr_list(CManager cm, EVstone stone_id, attr_list list);

/*REMOTE*/
extern int
EVdestroy_stone(CManager cm, EVstone stone_id);

/*NOLOCK*/
extern char *
create_filter_action_spec(FMStructDescList format_list, char *function);

/*NOLOCK*/
extern char *
create_router_action_spec(FMStructDescList format_list, char *function);

/*NOLOCK*/
extern char *
create_transform_action_spec(FMStructDescList format_list, FMStructDescList out_format_list, char *function);

/*NOLOCK*/
extern char *
create_multityped_action_spec(FMStructDescList *input_format_lists, char *function);

#ifdef __COD__H__

extern void
EVadd_standard_routines(CManager cm, char *extern_string, 
                        cod_extern_entry *externs);
#endif

/*NOLOCK*/
extern void
EVadd_dll_search_dir(char *path_string);

extern void
EVadd_standard_structs(CManager cm, FMStructDescList *lists);

extern void
EVregister_close_handler(CManager cm, EVStoneCloseHandlerFunc handler, void *client_data);

void
EVdump_stone(CManager cm,  EVstone stone_num);

typedef int (*EVImmediateHandlerFunc) (CManager cm, struct _event_item *event, 
                                       void *client_data, attr_list attrs, 
                                       int out_count, int *out_stones);
extern void
EVassoc_conversion_action(CManager cm, int stone_id, int stage, FMFormat target_format,
                          FMFormat incoming_format);

extern attr_list
CMtest_transport(CMConnection conn, attr_list how);

typedef attr_list (*CMperf_upcall)(CManager cm, void *buffer, long length, int type, attr_list list);

extern void
CMinstall_perf_upcall(CManager cm, CMperf_upcall upcall);

/* @}*/

#ifdef  __cplusplus
}
#endif

#endif