From 72fcefe6ed74be94e332282d8ee95b8cef84194a Mon Sep 17 00:00:00 2001 From: Jeff Lenk Date: Fri, 14 Jun 2013 11:42:58 -0500 Subject: [PATCH] vs2010 reswig --- .../mod_managed/freeswitch_wrap.2010.cxx | 1009 ++++++++++++++++- .../mod_managed/managed/swig.2010.cs | 929 ++++++++++++++- 2 files changed, 1873 insertions(+), 65 deletions(-) diff --git a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx index cf0259c89b..791af45492 100644 --- a/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx +++ b/src/mod/languages/mod_managed/freeswitch_wrap.2010.cxx @@ -2796,6 +2796,72 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_SWITCH_GLOBAL_dirs_get() { } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_filenames_conf_name_set(void * jarg1, char * jarg2) { + switch_filenames *arg1 = (switch_filenames *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (switch_filenames *)jarg1; + arg2 = (char *)jarg2; + { + if (arg1->conf_name) delete [] arg1->conf_name; + if (arg2) { + arg1->conf_name = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->conf_name, (const char *)arg2); + } else { + arg1->conf_name = 0; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_filenames_conf_name_get(void * jarg1) { + char * jresult ; + switch_filenames *arg1 = (switch_filenames *) 0 ; + char *result = 0 ; + + arg1 = (switch_filenames *)jarg1; + result = (char *) ((arg1)->conf_name); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_filenames() { + void * jresult ; + switch_filenames *result = 0 ; + + result = (switch_filenames *)new switch_filenames(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_filenames(void * jarg1) { + switch_filenames *arg1 = (switch_filenames *) 0 ; + + arg1 = (switch_filenames *)jarg1; + delete arg1; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_SWITCH_GLOBAL_filenames_set(void * jarg1) { + switch_filenames *arg1 = (switch_filenames *) 0 ; + + arg1 = (switch_filenames *)jarg1; + SWITCH_GLOBAL_filenames = *arg1; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_SWITCH_GLOBAL_filenames_get() { + void * jresult ; + switch_filenames *result = 0 ; + + result = (switch_filenames *)&SWITCH_GLOBAL_filenames; + jresult = (void *)result; + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_SWITCH_MAX_STACKS_get() { int jresult ; int result; @@ -6142,6 +6208,96 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_app_log(void * jarg1) { } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_func_set(void * jarg1, void * jarg2) { + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + switch_thread_start_t arg2 ; + switch_thread_start_t *argp2 ; + + arg1 = (switch_thread_data_t *)jarg1; + argp2 = (switch_thread_start_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_thread_start_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->func = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_func_get(void * jarg1) { + void * jresult ; + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + switch_thread_start_t result; + + arg1 = (switch_thread_data_t *)jarg1; + result = ((arg1)->func); + jresult = new switch_thread_start_t((const switch_thread_start_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_obj_set(void * jarg1, void * jarg2) { + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + void *arg2 = (void *) 0 ; + + arg1 = (switch_thread_data_t *)jarg1; + arg2 = (void *)jarg2; + if (arg1) (arg1)->obj = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_obj_get(void * jarg1) { + void * jresult ; + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + void *result = 0 ; + + arg1 = (switch_thread_data_t *)jarg1; + result = (void *) ((arg1)->obj); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_alloc_set(void * jarg1, int jarg2) { + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + int arg2 ; + + arg1 = (switch_thread_data_t *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->alloc = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_thread_data_t_alloc_get(void * jarg1) { + int jresult ; + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + int result; + + arg1 = (switch_thread_data_t *)jarg1; + result = (int) ((arg1)->alloc); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_thread_data_t() { + void * jresult ; + switch_thread_data_t *result = 0 ; + + result = (switch_thread_data_t *)new switch_thread_data_t(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_thread_data_t(void * jarg1) { + switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; + + arg1 = (switch_thread_data_t *)jarg1; + delete arg1; +} + + SWIGEXPORT void SWIGSTDCALL CSharp_switch_hold_record_t_on_set(void * jarg1, void * jarg2) { switch_hold_record_t *arg1 = (switch_hold_record_t *) 0 ; switch_time_t arg2 ; @@ -6268,92 +6424,714 @@ SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_hold_record_t(void * jarg1) { } -SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_func_set(void * jarg1, void * jarg2) { - switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; - switch_thread_start_t arg2 ; - switch_thread_start_t *argp2 ; +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_uuid_set(void * jarg1, char * jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + char *arg2 = (char *) 0 ; - arg1 = (switch_thread_data_t *)jarg1; - argp2 = (switch_thread_start_t *)jarg2; - if (!argp2) { - SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_thread_start_t", 0); - return ; + arg1 = (switch_device_node_t *)jarg1; + arg2 = (char *)jarg2; + { + if (arg1->uuid) delete [] arg1->uuid; + if (arg2) { + arg1->uuid = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->uuid, (const char *)arg2); + } else { + arg1->uuid = 0; + } } - arg2 = *argp2; - if (arg1) (arg1)->func = arg2; } -SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_func_get(void * jarg1) { - void * jresult ; - switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; - switch_thread_start_t result; +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_device_node_t_uuid_get(void * jarg1) { + char * jresult ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + char *result = 0 ; - arg1 = (switch_thread_data_t *)jarg1; - result = ((arg1)->func); - jresult = new switch_thread_start_t((const switch_thread_start_t &)result); + arg1 = (switch_device_node_t *)jarg1; + result = (char *) ((arg1)->uuid); + jresult = SWIG_csharp_string_callback((const char *)result); return jresult; } -SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_obj_set(void * jarg1, void * jarg2) { - switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; - void *arg2 = (void *) 0 ; +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_xml_cdr_set(void * jarg1, void * jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_xml_t arg2 = (switch_xml_t) 0 ; - arg1 = (switch_thread_data_t *)jarg1; - arg2 = (void *)jarg2; - if (arg1) (arg1)->obj = arg2; + arg1 = (switch_device_node_t *)jarg1; + arg2 = (switch_xml_t)jarg2; + if (arg1) (arg1)->xml_cdr = arg2; } -SWIGEXPORT void * SWIGSTDCALL CSharp_switch_thread_data_t_obj_get(void * jarg1) { +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_xml_cdr_get(void * jarg1) { void * jresult ; - switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; - void *result = 0 ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_xml_t result; - arg1 = (switch_thread_data_t *)jarg1; - result = (void *) ((arg1)->obj); + arg1 = (switch_device_node_t *)jarg1; + result = (switch_xml_t) ((arg1)->xml_cdr); jresult = (void *)result; return jresult; } -SWIGEXPORT void SWIGSTDCALL CSharp_switch_thread_data_t_alloc_set(void * jarg1, int jarg2) { - switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; - int arg2 ; +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t__event_set(void * jarg1, void * jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_event_t *arg2 = (switch_event_t *) 0 ; - arg1 = (switch_thread_data_t *)jarg1; - arg2 = (int)jarg2; - if (arg1) (arg1)->alloc = arg2; + arg1 = (switch_device_node_t *)jarg1; + arg2 = (switch_event_t *)jarg2; + if (arg1) (arg1)->event = arg2; } -SWIGEXPORT int SWIGSTDCALL CSharp_switch_thread_data_t_alloc_get(void * jarg1) { - int jresult ; - switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; - int result; +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t__event_get(void * jarg1) { + void * jresult ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_event_t *result = 0 ; - arg1 = (switch_thread_data_t *)jarg1; - result = (int) ((arg1)->alloc); + arg1 = (switch_device_node_t *)jarg1; + result = (switch_event_t *) ((arg1)->event); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_callstate_set(void * jarg1, int jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_channel_callstate_t arg2 ; + + arg1 = (switch_device_node_t *)jarg1; + arg2 = (switch_channel_callstate_t)jarg2; + if (arg1) (arg1)->callstate = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_node_t_callstate_get(void * jarg1) { + int jresult ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_channel_callstate_t result; + + arg1 = (switch_device_node_t *)jarg1; + result = (switch_channel_callstate_t) ((arg1)->callstate); jresult = result; return jresult; } -SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_thread_data_t() { - void * jresult ; - switch_thread_data_t *result = 0 ; +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_hold_record_set(void * jarg1, void * jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_hold_record_t *arg2 = (switch_hold_record_t *) 0 ; - result = (switch_thread_data_t *)new switch_thread_data_t(); + arg1 = (switch_device_node_t *)jarg1; + arg2 = (switch_hold_record_t *)jarg2; + if (arg1) (arg1)->hold_record = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_hold_record_get(void * jarg1) { + void * jresult ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_hold_record_t *result = 0 ; + + arg1 = (switch_device_node_t *)jarg1; + result = (switch_hold_record_t *) ((arg1)->hold_record); jresult = (void *)result; return jresult; } -SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_thread_data_t(void * jarg1) { - switch_thread_data_t *arg1 = (switch_thread_data_t *) 0 ; +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_hup_profile_set(void * jarg1, void * jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_caller_profile_t *arg2 = (switch_caller_profile_t *) 0 ; - arg1 = (switch_thread_data_t *)jarg1; + arg1 = (switch_device_node_t *)jarg1; + arg2 = (switch_caller_profile_t *)jarg2; + if (arg1) (arg1)->hup_profile = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_hup_profile_get(void * jarg1) { + void * jresult ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_caller_profile_t *result = 0 ; + + arg1 = (switch_device_node_t *)jarg1; + result = (switch_caller_profile_t *) ((arg1)->hup_profile); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_parent_set(void * jarg1, void * jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_device_record_s *arg2 = (switch_device_record_s *) 0 ; + + arg1 = (switch_device_node_t *)jarg1; + arg2 = (switch_device_record_s *)jarg2; + if (arg1) (arg1)->parent = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_parent_get(void * jarg1) { + void * jresult ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + switch_device_record_s *result = 0 ; + + arg1 = (switch_device_node_t *)jarg1; + result = (switch_device_record_s *) ((arg1)->parent); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_node_t_next_set(void * jarg1, void * jarg2) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + device_uuid_node_s *arg2 = (device_uuid_node_s *) 0 ; + + arg1 = (switch_device_node_t *)jarg1; + arg2 = (device_uuid_node_s *)jarg2; + if (arg1) (arg1)->next = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_node_t_next_get(void * jarg1) { + void * jresult ; + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + device_uuid_node_s *result = 0 ; + + arg1 = (switch_device_node_t *)jarg1; + result = (device_uuid_node_s *) ((arg1)->next); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_device_node_t() { + void * jresult ; + switch_device_node_t *result = 0 ; + + result = (switch_device_node_t *)new switch_device_node_t(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_device_node_t(void * jarg1) { + switch_device_node_t *arg1 = (switch_device_node_t *) 0 ; + + arg1 = (switch_device_node_t *)jarg1; + delete arg1; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_total_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->total = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_total_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->total); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_offhook_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->offhook = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_offhook_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->offhook); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_active_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->active = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_active_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->active); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_held_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->held = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_held_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->held); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_hup_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->hup = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_hup_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->hup); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_ringing_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->ringing = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_ringing_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->ringing); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_stats_t_early_set(void * jarg1, unsigned long jarg2) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t arg2 ; + + arg1 = (switch_device_stats_t *)jarg1; + arg2 = (uint32_t)jarg2; + if (arg1) (arg1)->early = arg2; +} + + +SWIGEXPORT unsigned long SWIGSTDCALL CSharp_switch_device_stats_t_early_get(void * jarg1) { + unsigned long jresult ; + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + uint32_t result; + + arg1 = (switch_device_stats_t *)jarg1; + result = (uint32_t) ((arg1)->early); + jresult = (unsigned long)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_device_stats_t() { + void * jresult ; + switch_device_stats_t *result = 0 ; + + result = (switch_device_stats_t *)new switch_device_stats_t(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_device_stats_t(void * jarg1) { + switch_device_stats_t *arg1 = (switch_device_stats_t *) 0 ; + + arg1 = (switch_device_stats_t *)jarg1; + delete arg1; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_device_id_set(void * jarg1, char * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (char *)jarg2; + { + if (arg1->device_id) delete [] arg1->device_id; + if (arg2) { + arg1->device_id = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->device_id, (const char *)arg2); + } else { + arg1->device_id = 0; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_device_record_t_device_id_get(void * jarg1) { + char * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + char *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (char *) ((arg1)->device_id); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_uuid_set(void * jarg1, char * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (char *)jarg2; + { + if (arg1->uuid) delete [] arg1->uuid; + if (arg2) { + arg1->uuid = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->uuid, (const char *)arg2); + } else { + arg1->uuid = 0; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_device_record_t_uuid_get(void * jarg1) { + char * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + char *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (char *) ((arg1)->uuid); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_refs_set(void * jarg1, int jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + int arg2 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->refs = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_record_t_refs_get(void * jarg1) { + int jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + int result; + + arg1 = (switch_device_record_t *)jarg1; + result = (int) ((arg1)->refs); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_stats_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_device_stats_t *arg2 = (switch_device_stats_t *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (switch_device_stats_t *)jarg2; + if (arg1) (arg1)->stats = *arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_stats_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_device_stats_t *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (switch_device_stats_t *)& ((arg1)->stats); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_state_set(void * jarg1, int jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_device_state_t arg2 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (switch_device_state_t)jarg2; + if (arg1) (arg1)->state = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_record_t_state_get(void * jarg1) { + int jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_device_state_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = (switch_device_state_t) ((arg1)->state); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_last_state_set(void * jarg1, int jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_device_state_t arg2 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (switch_device_state_t)jarg2; + if (arg1) (arg1)->last_state = arg2; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_device_record_t_last_state_get(void * jarg1) { + int jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_device_state_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = (switch_device_state_t) ((arg1)->last_state); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_active_start_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; + + arg1 = (switch_device_record_t *)jarg1; + argp2 = (switch_time_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->active_start = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_active_start_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = ((arg1)->active_start); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_active_stop_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; + + arg1 = (switch_device_record_t *)jarg1; + argp2 = (switch_time_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->active_stop = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_active_stop_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = ((arg1)->active_stop); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_last_call_time_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t arg2 ; + switch_time_t *argp2 ; + + arg1 = (switch_device_record_t *)jarg1; + argp2 = (switch_time_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_time_t", 0); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->last_call_time = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_last_call_time_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_time_t result; + + arg1 = (switch_device_record_t *)jarg1; + result = ((arg1)->last_call_time); + jresult = new switch_time_t((const switch_time_t &)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_uuid_list_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + device_uuid_node_s *arg2 = (device_uuid_node_s *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (device_uuid_node_s *)jarg2; + if (arg1) (arg1)->uuid_list = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_uuid_list_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + device_uuid_node_s *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (device_uuid_node_s *) ((arg1)->uuid_list); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_uuid_tail_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + device_uuid_node_s *arg2 = (device_uuid_node_s *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (device_uuid_node_s *)jarg2; + if (arg1) (arg1)->uuid_tail = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_uuid_tail_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + device_uuid_node_s *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (device_uuid_node_s *) ((arg1)->uuid_tail); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_mutex_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_mutex_t *arg2 = (switch_mutex_t *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (switch_mutex_t *)jarg2; + if (arg1) (arg1)->mutex = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_mutex_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_mutex_t *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (switch_mutex_t *) ((arg1)->mutex); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_device_record_t_pool_set(void * jarg1, void * jarg2) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_memory_pool_t *arg2 = (switch_memory_pool_t *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; + arg2 = (switch_memory_pool_t *)jarg2; + if (arg1) (arg1)->pool = arg2; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_device_record_t_pool_get(void * jarg1) { + void * jresult ; + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + switch_memory_pool_t *result = 0 ; + + arg1 = (switch_device_record_t *)jarg1; + result = (switch_memory_pool_t *) ((arg1)->pool); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_switch_device_record_t() { + void * jresult ; + switch_device_record_t *result = 0 ; + + result = (switch_device_record_t *)new switch_device_record_t(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_switch_device_record_t(void * jarg1) { + switch_device_record_t *arg1 = (switch_device_record_t *) 0 ; + + arg1 = (switch_device_record_t *)jarg1; delete arg1; } @@ -12288,6 +13066,24 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_get_stacksizes(void * jarg1, void } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_core_gen_encoded_silence(void * jarg1, void * jarg2, void * jarg3) { + unsigned char *arg1 = (unsigned char *) 0 ; + switch_codec_implementation_t *arg2 = (switch_codec_implementation_t *) 0 ; + switch_size_t arg3 ; + switch_size_t *argp3 ; + + arg1 = (unsigned char *)jarg1; + arg2 = (switch_codec_implementation_t *)jarg2; + argp3 = (switch_size_t *)jarg3; + if (!argp3) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null switch_size_t", 0); + return ; + } + arg3 = *argp3; + switch_core_gen_encoded_silence(arg1,(switch_codec_implementation const *)arg2,arg3); +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_core_dbtype() { int jresult ; switch_cache_db_handle_type_t result; @@ -14927,6 +15723,20 @@ SWIGEXPORT char * SWIGSTDCALL CSharp_switch_util_quote_shell_arg(char * jarg1) { } +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_util_quote_shell_arg_pool(char * jarg1, void * jarg2) { + char * jresult ; + char *arg1 = (char *) 0 ; + switch_memory_pool_t *arg2 = (switch_memory_pool_t *) 0 ; + char *result = 0 ; + + arg1 = (char *)jarg1; + arg2 = (switch_memory_pool_t *)jarg2; + result = (char *)switch_util_quote_shell_arg_pool((char const *)arg1,arg2); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT char * SWIGSTDCALL CSharp_switch_url_encode(char * jarg1, char * jarg2, unsigned long jarg3) { char * jresult ; char *arg1 = (char *) 0 ; @@ -27639,6 +28449,109 @@ SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_state_thread_trylock(void * jar } +SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_handle_cause(void * jarg1, int jarg2) { + switch_channel_t *arg1 = (switch_channel_t *) 0 ; + switch_call_cause_t arg2 ; + + arg1 = (switch_channel_t *)jarg1; + arg2 = (switch_call_cause_t)jarg2; + switch_channel_handle_cause(arg1,arg2); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_global_init(void * jarg1) { + switch_memory_pool_t *arg1 = (switch_memory_pool_t *) 0 ; + + arg1 = (switch_memory_pool_t *)jarg1; + switch_channel_global_init(arg1); +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_global_uninit() { + switch_channel_global_uninit(); +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_channel_set_device_id(void * jarg1, char * jarg2) { + char * jresult ; + switch_channel_t *arg1 = (switch_channel_t *) 0 ; + char *arg2 = (char *) 0 ; + char *result = 0 ; + + arg1 = (switch_channel_t *)jarg1; + arg2 = (char *)jarg2; + result = (char *)switch_channel_set_device_id(arg1,(char const *)arg2); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_clear_device_record(void * jarg1) { + switch_channel_t *arg1 = (switch_channel_t *) 0 ; + + arg1 = (switch_channel_t *)jarg1; + switch_channel_clear_device_record(arg1); +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_switch_channel_get_device_record(void * jarg1) { + void * jresult ; + switch_channel_t *arg1 = (switch_channel_t *) 0 ; + switch_device_record_t *result = 0 ; + + arg1 = (switch_channel_t *)jarg1; + result = (switch_device_record_t *)switch_channel_get_device_record(arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_switch_channel_release_device_record(void * jarg1) { + switch_device_record_t **arg1 = (switch_device_record_t **) 0 ; + + arg1 = (switch_device_record_t **)jarg1; + switch_channel_release_device_record(arg1); +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_bind_device_state_handler(void * jarg1, void * jarg2) { + int jresult ; + switch_device_state_function_t arg1 = (switch_device_state_function_t) 0 ; + void *arg2 = (void *) 0 ; + switch_status_t result; + + arg1 = (switch_device_state_function_t)jarg1; + arg2 = (void *)jarg2; + result = (switch_status_t)switch_channel_bind_device_state_handler(arg1,arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_switch_channel_unbind_device_state_handler(void * jarg1) { + int jresult ; + switch_device_state_function_t arg1 = (switch_device_state_function_t) 0 ; + switch_status_t result; + + arg1 = (switch_device_state_function_t)jarg1; + result = (switch_status_t)switch_channel_unbind_device_state_handler(arg1); + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_switch_channel_device_state2str(int jarg1) { + char * jresult ; + switch_device_state_t arg1 ; + char *result = 0 ; + + arg1 = (switch_device_state_t)jarg1; + result = (char *)switch_channel_device_state2str(arg1); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + SWIGEXPORT int SWIGSTDCALL CSharp_switch_buffer_create(void * jarg1, void * jarg2, void * jarg3) { int jresult ; switch_memory_pool_t *arg1 = (switch_memory_pool_t *) 0 ; diff --git a/src/mod/languages/mod_managed/managed/swig.2010.cs b/src/mod/languages/mod_managed/managed/swig.2010.cs index 880e33cd0a..d5b3f73cc2 100644 --- a/src/mod/languages/mod_managed/managed/swig.2010.cs +++ b/src/mod/languages/mod_managed/managed/swig.2010.cs @@ -908,6 +908,17 @@ public class freeswitch { } } + public static switch_filenames SWITCH_GLOBAL_filenames { + set { + freeswitchPINVOKE.SWITCH_GLOBAL_filenames_set(switch_filenames.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.SWITCH_GLOBAL_filenames_get(); + switch_filenames ret = (cPtr == IntPtr.Zero) ? null : new switch_filenames(cPtr, false); + return ret; + } + } + public static int switch_core_db_close(SWIGTYPE_p_sqlite3 db) { int ret = freeswitchPINVOKE.switch_core_db_close(SWIGTYPE_p_sqlite3.getCPtr(db)); return ret; @@ -2885,6 +2896,11 @@ public class freeswitch { return ret; } + public static void switch_core_gen_encoded_silence(SWIGTYPE_p_unsigned_char data, switch_codec_implementation read_impl, SWIGTYPE_p_switch_size_t len) { + freeswitchPINVOKE.switch_core_gen_encoded_silence(SWIGTYPE_p_unsigned_char.getCPtr(data), switch_codec_implementation.getCPtr(read_impl), SWIGTYPE_p_switch_size_t.getCPtr(len)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + public static switch_cache_db_handle_type_t switch_core_dbtype() { switch_cache_db_handle_type_t ret = (switch_cache_db_handle_type_t)freeswitchPINVOKE.switch_core_dbtype(); return ret; @@ -3628,6 +3644,11 @@ public class freeswitch { return ret; } + public static string switch_util_quote_shell_arg_pool(string arg0, SWIGTYPE_p_apr_pool_t pool) { + string ret = freeswitchPINVOKE.switch_util_quote_shell_arg_pool(arg0, SWIGTYPE_p_apr_pool_t.getCPtr(pool)); + return ret; + } + public static string switch_url_encode(string url, string buf, uint len) { string ret = freeswitchPINVOKE.switch_url_encode(url, buf, len); return ret; @@ -4441,6 +4462,52 @@ public class freeswitch { return ret; } + public static void switch_channel_handle_cause(SWIGTYPE_p_switch_channel channel, switch_call_cause_t cause) { + freeswitchPINVOKE.switch_channel_handle_cause(SWIGTYPE_p_switch_channel.getCPtr(channel), (int)cause); + } + + public static void switch_channel_global_init(SWIGTYPE_p_apr_pool_t pool) { + freeswitchPINVOKE.switch_channel_global_init(SWIGTYPE_p_apr_pool_t.getCPtr(pool)); + } + + public static void switch_channel_global_uninit() { + freeswitchPINVOKE.switch_channel_global_uninit(); + } + + public static string switch_channel_set_device_id(SWIGTYPE_p_switch_channel channel, string device_id) { + string ret = freeswitchPINVOKE.switch_channel_set_device_id(SWIGTYPE_p_switch_channel.getCPtr(channel), device_id); + return ret; + } + + public static void switch_channel_clear_device_record(SWIGTYPE_p_switch_channel channel) { + freeswitchPINVOKE.switch_channel_clear_device_record(SWIGTYPE_p_switch_channel.getCPtr(channel)); + } + + public static switch_device_record_t switch_channel_get_device_record(SWIGTYPE_p_switch_channel channel) { + IntPtr cPtr = freeswitchPINVOKE.switch_channel_get_device_record(SWIGTYPE_p_switch_channel.getCPtr(channel)); + switch_device_record_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_record_t(cPtr, false); + return ret; + } + + public static void switch_channel_release_device_record(SWIGTYPE_p_p_switch_device_record_s dcdrp) { + freeswitchPINVOKE.switch_channel_release_device_record(SWIGTYPE_p_p_switch_device_record_s.getCPtr(dcdrp)); + } + + public static switch_status_t switch_channel_bind_device_state_handler(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void function, SWIGTYPE_p_void user_data) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_bind_device_state_handler(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void.getCPtr(function), SWIGTYPE_p_void.getCPtr(user_data)); + return ret; + } + + public static switch_status_t switch_channel_unbind_device_state_handler(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void function) { + switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_channel_unbind_device_state_handler(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void.getCPtr(function)); + return ret; + } + + public static string switch_channel_device_state2str(switch_device_state_t device_state) { + string ret = freeswitchPINVOKE.switch_channel_device_state2str((int)device_state); + return ret; + } + public static switch_status_t switch_buffer_create(SWIGTYPE_p_apr_pool_t pool, SWIGTYPE_p_p_switch_buffer buffer, SWIGTYPE_p_switch_size_t max_len) { switch_status_t ret = (switch_status_t)freeswitchPINVOKE.switch_buffer_create(SWIGTYPE_p_apr_pool_t.getCPtr(pool), SWIGTYPE_p_p_switch_buffer.getCPtr(buffer), SWIGTYPE_p_switch_size_t.getCPtr(max_len)); if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); @@ -7499,6 +7566,24 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_GLOBAL_dirs_get")] public static extern IntPtr SWITCH_GLOBAL_dirs_get(); + [DllImport("mod_managed", EntryPoint="CSharp_switch_filenames_conf_name_set")] + public static extern void switch_filenames_conf_name_set(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_filenames_conf_name_get")] + public static extern string switch_filenames_conf_name_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_filenames")] + public static extern IntPtr new_switch_filenames(); + + [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_filenames")] + public static extern void delete_switch_filenames(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_GLOBAL_filenames_set")] + public static extern void SWITCH_GLOBAL_filenames_set(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_GLOBAL_filenames_get")] + public static extern IntPtr SWITCH_GLOBAL_filenames_get(); + [DllImport("mod_managed", EntryPoint="CSharp_SWITCH_MAX_STACKS_get")] public static extern int SWITCH_MAX_STACKS_get(); @@ -8366,6 +8451,30 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_app_log")] public static extern void delete_switch_app_log(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_func_set")] + public static extern void switch_thread_data_t_func_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_func_get")] + public static extern IntPtr switch_thread_data_t_func_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_obj_set")] + public static extern void switch_thread_data_t_obj_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_obj_get")] + public static extern IntPtr switch_thread_data_t_obj_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_set")] + public static extern void switch_thread_data_t_alloc_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_get")] + public static extern int switch_thread_data_t_alloc_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_thread_data_t")] + public static extern IntPtr new_switch_thread_data_t(); + + [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_thread_data_t")] + public static extern void delete_switch_thread_data_t(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_hold_record_t_on_set")] public static extern void switch_hold_record_t_on_set(HandleRef jarg1, HandleRef jarg2); @@ -8396,29 +8505,191 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_hold_record_t")] public static extern void delete_switch_hold_record_t(HandleRef jarg1); - [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_func_set")] - public static extern void switch_thread_data_t_func_set(HandleRef jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_uuid_set")] + public static extern void switch_device_node_t_uuid_set(HandleRef jarg1, string jarg2); - [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_func_get")] - public static extern IntPtr switch_thread_data_t_func_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_uuid_get")] + public static extern string switch_device_node_t_uuid_get(HandleRef jarg1); - [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_obj_set")] - public static extern void switch_thread_data_t_obj_set(HandleRef jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_xml_cdr_set")] + public static extern void switch_device_node_t_xml_cdr_set(HandleRef jarg1, HandleRef jarg2); - [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_obj_get")] - public static extern IntPtr switch_thread_data_t_obj_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_xml_cdr_get")] + public static extern IntPtr switch_device_node_t_xml_cdr_get(HandleRef jarg1); - [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_set")] - public static extern void switch_thread_data_t_alloc_set(HandleRef jarg1, int jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t__event_set")] + public static extern void switch_device_node_t__event_set(HandleRef jarg1, HandleRef jarg2); - [DllImport("mod_managed", EntryPoint="CSharp_switch_thread_data_t_alloc_get")] - public static extern int switch_thread_data_t_alloc_get(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t__event_get")] + public static extern IntPtr switch_device_node_t__event_get(HandleRef jarg1); - [DllImport("mod_managed", EntryPoint="CSharp_new_switch_thread_data_t")] - public static extern IntPtr new_switch_thread_data_t(); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_callstate_set")] + public static extern void switch_device_node_t_callstate_set(HandleRef jarg1, int jarg2); - [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_thread_data_t")] - public static extern void delete_switch_thread_data_t(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_callstate_get")] + public static extern int switch_device_node_t_callstate_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hold_record_set")] + public static extern void switch_device_node_t_hold_record_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hold_record_get")] + public static extern IntPtr switch_device_node_t_hold_record_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hup_profile_set")] + public static extern void switch_device_node_t_hup_profile_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_hup_profile_get")] + public static extern IntPtr switch_device_node_t_hup_profile_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_parent_set")] + public static extern void switch_device_node_t_parent_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_parent_get")] + public static extern IntPtr switch_device_node_t_parent_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_next_set")] + public static extern void switch_device_node_t_next_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_node_t_next_get")] + public static extern IntPtr switch_device_node_t_next_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_device_node_t")] + public static extern IntPtr new_switch_device_node_t(); + + [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_device_node_t")] + public static extern void delete_switch_device_node_t(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_set")] + public static extern void switch_device_stats_t_total_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_total_get")] + public static extern uint switch_device_stats_t_total_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_set")] + public static extern void switch_device_stats_t_offhook_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_offhook_get")] + public static extern uint switch_device_stats_t_offhook_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_set")] + public static extern void switch_device_stats_t_active_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_active_get")] + public static extern uint switch_device_stats_t_active_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_set")] + public static extern void switch_device_stats_t_held_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_held_get")] + public static extern uint switch_device_stats_t_held_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_set")] + public static extern void switch_device_stats_t_hup_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_hup_get")] + public static extern uint switch_device_stats_t_hup_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_set")] + public static extern void switch_device_stats_t_ringing_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_ringing_get")] + public static extern uint switch_device_stats_t_ringing_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_set")] + public static extern void switch_device_stats_t_early_set(HandleRef jarg1, uint jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_stats_t_early_get")] + public static extern uint switch_device_stats_t_early_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_device_stats_t")] + public static extern IntPtr new_switch_device_stats_t(); + + [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_device_stats_t")] + public static extern void delete_switch_device_stats_t(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_device_id_set")] + public static extern void switch_device_record_t_device_id_set(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_device_id_get")] + public static extern string switch_device_record_t_device_id_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_set")] + public static extern void switch_device_record_t_uuid_set(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_get")] + public static extern string switch_device_record_t_uuid_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_refs_set")] + public static extern void switch_device_record_t_refs_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_refs_get")] + public static extern int switch_device_record_t_refs_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_stats_set")] + public static extern void switch_device_record_t_stats_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_stats_get")] + public static extern IntPtr switch_device_record_t_stats_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_state_set")] + public static extern void switch_device_record_t_state_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_state_get")] + public static extern int switch_device_record_t_state_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_state_set")] + public static extern void switch_device_record_t_last_state_set(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_state_get")] + public static extern int switch_device_record_t_last_state_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_active_start_set")] + public static extern void switch_device_record_t_active_start_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_active_start_get")] + public static extern IntPtr switch_device_record_t_active_start_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_active_stop_set")] + public static extern void switch_device_record_t_active_stop_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_active_stop_get")] + public static extern IntPtr switch_device_record_t_active_stop_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_call_time_set")] + public static extern void switch_device_record_t_last_call_time_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_last_call_time_get")] + public static extern IntPtr switch_device_record_t_last_call_time_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_list_set")] + public static extern void switch_device_record_t_uuid_list_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_list_get")] + public static extern IntPtr switch_device_record_t_uuid_list_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_tail_set")] + public static extern void switch_device_record_t_uuid_tail_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_uuid_tail_get")] + public static extern IntPtr switch_device_record_t_uuid_tail_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_mutex_set")] + public static extern void switch_device_record_t_mutex_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_mutex_get")] + public static extern IntPtr switch_device_record_t_mutex_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_pool_set")] + public static extern void switch_device_record_t_pool_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_device_record_t_pool_get")] + public static extern IntPtr switch_device_record_t_pool_get(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_new_switch_device_record_t")] + public static extern IntPtr new_switch_device_record_t(); + + [DllImport("mod_managed", EntryPoint="CSharp_delete_switch_device_record_t")] + public static extern void delete_switch_device_record_t(HandleRef jarg1); [DllImport("mod_managed", EntryPoint="CSharp_MESSAGE_STRING_ARG_MAX_get")] public static extern int MESSAGE_STRING_ARG_MAX_get(); @@ -9782,6 +10053,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_core_get_stacksizes")] public static extern int switch_core_get_stacksizes(HandleRef jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_gen_encoded_silence")] + public static extern void switch_core_gen_encoded_silence(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); + [DllImport("mod_managed", EntryPoint="CSharp_switch_core_dbtype")] public static extern int switch_core_dbtype(); @@ -10367,6 +10641,9 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_util_quote_shell_arg")] public static extern string switch_util_quote_shell_arg(string jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_util_quote_shell_arg_pool")] + public static extern string switch_util_quote_shell_arg_pool(string jarg1, HandleRef jarg2); + [DllImport("mod_managed", EntryPoint="CSharp_switch_url_encode")] public static extern string switch_url_encode(string jarg1, string jarg2, uint jarg3); @@ -13565,6 +13842,36 @@ class freeswitchPINVOKE { [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_state_thread_trylock")] public static extern int switch_channel_state_thread_trylock(HandleRef jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_handle_cause")] + public static extern void switch_channel_handle_cause(HandleRef jarg1, int jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_global_init")] + public static extern void switch_channel_global_init(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_global_uninit")] + public static extern void switch_channel_global_uninit(); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_set_device_id")] + public static extern string switch_channel_set_device_id(HandleRef jarg1, string jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_clear_device_record")] + public static extern void switch_channel_clear_device_record(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_get_device_record")] + public static extern IntPtr switch_channel_get_device_record(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_release_device_record")] + public static extern void switch_channel_release_device_record(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_bind_device_state_handler")] + public static extern int switch_channel_bind_device_state_handler(HandleRef jarg1, HandleRef jarg2); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_unbind_device_state_handler")] + public static extern int switch_channel_unbind_device_state_handler(HandleRef jarg1); + + [DllImport("mod_managed", EntryPoint="CSharp_switch_channel_device_state2str")] + public static extern string switch_channel_device_state2str(int jarg1); + [DllImport("mod_managed", EntryPoint="CSharp_switch_buffer_create")] public static extern int switch_buffer_create(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3); @@ -17390,6 +17697,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_f_p_switch_core_session_enum_switch_channel_callstate_t_p_switch_device_record_s__void obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_f_p_switch_core_session_enum_switch_media_type_t__p_stfu_instance_t { private HandleRef swigCPtr; @@ -19880,6 +20217,36 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class SWIGTYPE_p_p_switch_device_record_s { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_p_switch_device_record_s(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_p_switch_device_record_s() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_p_switch_device_record_s obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class SWIGTYPE_p_p_switch_event { private HandleRef swigCPtr; @@ -24568,7 +24935,8 @@ public enum switch_channel_callstate_t { CCS_EARLY, CCS_ACTIVE, CCS_HELD, - CCS_HANGUP + CCS_HANGUP, + CCS_UNHOLD } } @@ -24680,6 +25048,8 @@ public enum switch_channel_flag_t { CF_ZRTP_PASSTHRU, CF_ZRTP_HASH, CF_CHANNEL_SWAP, + CF_DEVICE_LEG, + CF_FINAL_DEVICE_LEG, CF_PICKUP, CF_CONFIRM_BLIND_TRANSFER, CF_NO_PRESENCE, @@ -26876,6 +27246,470 @@ namespace FreeSWITCH.Native { using System; using System.Runtime.InteropServices; +public class switch_device_node_t : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal switch_device_node_t(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(switch_device_node_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~switch_device_node_t() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + freeswitchPINVOKE.delete_switch_device_node_t(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public string uuid { + set { + freeswitchPINVOKE.switch_device_node_t_uuid_set(swigCPtr, value); + } + get { + string ret = freeswitchPINVOKE.switch_device_node_t_uuid_get(swigCPtr); + return ret; + } + } + + public switch_xml xml_cdr { + set { + freeswitchPINVOKE.switch_device_node_t_xml_cdr_set(swigCPtr, switch_xml.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_xml_cdr_get(swigCPtr); + switch_xml ret = (cPtr == IntPtr.Zero) ? null : new switch_xml(cPtr, false); + return ret; + } + } + + public switch_event _event { + set { + freeswitchPINVOKE.switch_device_node_t__event_set(swigCPtr, switch_event.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t__event_get(swigCPtr); + switch_event ret = (cPtr == IntPtr.Zero) ? null : new switch_event(cPtr, false); + return ret; + } + } + + public switch_channel_callstate_t callstate { + set { + freeswitchPINVOKE.switch_device_node_t_callstate_set(swigCPtr, (int)value); + } + get { + switch_channel_callstate_t ret = (switch_channel_callstate_t)freeswitchPINVOKE.switch_device_node_t_callstate_get(swigCPtr); + return ret; + } + } + + public switch_hold_record_t hold_record { + set { + freeswitchPINVOKE.switch_device_node_t_hold_record_set(swigCPtr, switch_hold_record_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_hold_record_get(swigCPtr); + switch_hold_record_t ret = (cPtr == IntPtr.Zero) ? null : new switch_hold_record_t(cPtr, false); + return ret; + } + } + + public switch_caller_profile hup_profile { + set { + freeswitchPINVOKE.switch_device_node_t_hup_profile_set(swigCPtr, switch_caller_profile.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_hup_profile_get(swigCPtr); + switch_caller_profile ret = (cPtr == IntPtr.Zero) ? null : new switch_caller_profile(cPtr, false); + return ret; + } + } + + public switch_device_record_t parent { + set { + freeswitchPINVOKE.switch_device_node_t_parent_set(swigCPtr, switch_device_record_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_parent_get(swigCPtr); + switch_device_record_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_record_t(cPtr, false); + return ret; + } + } + + public switch_device_node_t next { + set { + freeswitchPINVOKE.switch_device_node_t_next_set(swigCPtr, switch_device_node_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_node_t_next_get(swigCPtr); + switch_device_node_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_node_t(cPtr, false); + return ret; + } + } + + public switch_device_node_t() : this(freeswitchPINVOKE.new_switch_device_node_t(), true) { + } + +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + +public class switch_device_record_t : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal switch_device_record_t(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(switch_device_record_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~switch_device_record_t() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + freeswitchPINVOKE.delete_switch_device_record_t(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public string device_id { + set { + freeswitchPINVOKE.switch_device_record_t_device_id_set(swigCPtr, value); + } + get { + string ret = freeswitchPINVOKE.switch_device_record_t_device_id_get(swigCPtr); + return ret; + } + } + + public string uuid { + set { + freeswitchPINVOKE.switch_device_record_t_uuid_set(swigCPtr, value); + } + get { + string ret = freeswitchPINVOKE.switch_device_record_t_uuid_get(swigCPtr); + return ret; + } + } + + public int refs { + set { + freeswitchPINVOKE.switch_device_record_t_refs_set(swigCPtr, value); + } + get { + int ret = freeswitchPINVOKE.switch_device_record_t_refs_get(swigCPtr); + return ret; + } + } + + public switch_device_stats_t stats { + set { + freeswitchPINVOKE.switch_device_record_t_stats_set(swigCPtr, switch_device_stats_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_stats_get(swigCPtr); + switch_device_stats_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_stats_t(cPtr, false); + return ret; + } + } + + public switch_device_state_t state { + set { + freeswitchPINVOKE.switch_device_record_t_state_set(swigCPtr, (int)value); + } + get { + switch_device_state_t ret = (switch_device_state_t)freeswitchPINVOKE.switch_device_record_t_state_get(swigCPtr); + return ret; + } + } + + public switch_device_state_t last_state { + set { + freeswitchPINVOKE.switch_device_record_t_last_state_set(swigCPtr, (int)value); + } + get { + switch_device_state_t ret = (switch_device_state_t)freeswitchPINVOKE.switch_device_record_t_last_state_get(swigCPtr); + return ret; + } + } + + public SWIGTYPE_p_switch_time_t active_start { + set { + freeswitchPINVOKE.switch_device_record_t_active_start_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_active_start_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public SWIGTYPE_p_switch_time_t active_stop { + set { + freeswitchPINVOKE.switch_device_record_t_active_stop_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_active_stop_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public SWIGTYPE_p_switch_time_t last_call_time { + set { + freeswitchPINVOKE.switch_device_record_t_last_call_time_set(swigCPtr, SWIGTYPE_p_switch_time_t.getCPtr(value)); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + } + get { + SWIGTYPE_p_switch_time_t ret = new SWIGTYPE_p_switch_time_t(freeswitchPINVOKE.switch_device_record_t_last_call_time_get(swigCPtr), true); + if (freeswitchPINVOKE.SWIGPendingException.Pending) throw freeswitchPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + } + + public switch_device_node_t uuid_list { + set { + freeswitchPINVOKE.switch_device_record_t_uuid_list_set(swigCPtr, switch_device_node_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_uuid_list_get(swigCPtr); + switch_device_node_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_node_t(cPtr, false); + return ret; + } + } + + public switch_device_node_t uuid_tail { + set { + freeswitchPINVOKE.switch_device_record_t_uuid_tail_set(swigCPtr, switch_device_node_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_uuid_tail_get(swigCPtr); + switch_device_node_t ret = (cPtr == IntPtr.Zero) ? null : new switch_device_node_t(cPtr, false); + return ret; + } + } + + public SWIGTYPE_p_switch_mutex_t mutex { + set { + freeswitchPINVOKE.switch_device_record_t_mutex_set(swigCPtr, SWIGTYPE_p_switch_mutex_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_mutex_get(swigCPtr); + SWIGTYPE_p_switch_mutex_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_switch_mutex_t(cPtr, false); + return ret; + } + } + + public SWIGTYPE_p_apr_pool_t pool { + set { + freeswitchPINVOKE.switch_device_record_t_pool_set(swigCPtr, SWIGTYPE_p_apr_pool_t.getCPtr(value)); + } + get { + IntPtr cPtr = freeswitchPINVOKE.switch_device_record_t_pool_get(swigCPtr); + SWIGTYPE_p_apr_pool_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_apr_pool_t(cPtr, false); + return ret; + } + } + + public switch_device_record_t() : this(freeswitchPINVOKE.new_switch_device_record_t(), true) { + } + +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +public enum switch_device_state_t { + SDS_DOWN, + SDS_RINGING, + SDS_ACTIVE, + SDS_ACTIVE_MULTI, + SDS_HELD, + SDS_HANGUP +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + +public class switch_device_stats_t : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal switch_device_stats_t(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(switch_device_stats_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~switch_device_stats_t() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + freeswitchPINVOKE.delete_switch_device_stats_t(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public uint total { + set { + freeswitchPINVOKE.switch_device_stats_t_total_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_total_get(swigCPtr); + return ret; + } + } + + public uint offhook { + set { + freeswitchPINVOKE.switch_device_stats_t_offhook_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_offhook_get(swigCPtr); + return ret; + } + } + + public uint active { + set { + freeswitchPINVOKE.switch_device_stats_t_active_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_active_get(swigCPtr); + return ret; + } + } + + public uint held { + set { + freeswitchPINVOKE.switch_device_stats_t_held_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_held_get(swigCPtr); + return ret; + } + } + + public uint hup { + set { + freeswitchPINVOKE.switch_device_stats_t_hup_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_hup_get(swigCPtr); + return ret; + } + } + + public uint ringing { + set { + freeswitchPINVOKE.switch_device_stats_t_ringing_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_ringing_get(swigCPtr); + return ret; + } + } + + public uint early { + set { + freeswitchPINVOKE.switch_device_stats_t_early_set(swigCPtr, value); + } + get { + uint ret = freeswitchPINVOKE.switch_device_stats_t_early_get(swigCPtr); + return ret; + } + } + + public switch_device_stats_t() : this(freeswitchPINVOKE.new_switch_device_stats_t(), true) { + } + +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + +using System; +using System.Runtime.InteropServices; + public class switch_dialplan_interface : IDisposable { private HandleRef swigCPtr; protected bool swigCMemOwn; @@ -28164,6 +28998,8 @@ public enum switch_event_types_t { SWITCH_EVENT_CONFERENCE_DATA, SWITCH_EVENT_CALL_SETUP_REQ, SWITCH_EVENT_CALL_SETUP_RESULT, + SWITCH_EVENT_CALL_DETAIL, + SWITCH_EVENT_DEVICE_STATE, SWITCH_EVENT_ALL } @@ -28178,6 +29014,65 @@ public enum switch_event_types_t { namespace FreeSWITCH.Native { +using System; +using System.Runtime.InteropServices; + +public class switch_filenames : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal switch_filenames(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(switch_filenames obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~switch_filenames() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if (swigCPtr.Handle != IntPtr.Zero) { + if (swigCMemOwn) { + swigCMemOwn = false; + freeswitchPINVOKE.delete_switch_filenames(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + GC.SuppressFinalize(this); + } + } + + public string conf_name { + set { + freeswitchPINVOKE.switch_filenames_conf_name_set(swigCPtr, value); + } + get { + string ret = freeswitchPINVOKE.switch_filenames_conf_name_get(swigCPtr); + return ret; + } + } + + public switch_filenames() : this(freeswitchPINVOKE.new_switch_filenames(), true) { + } + +} + +} +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 2.0.1 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +namespace FreeSWITCH.Native { + [System.Flags] public enum switch_file_flag_enum_t { SWITCH_FILE_FLAG_READ = (1 << 0), SWITCH_FILE_FLAG_WRITE = (1 << 1),