From 6dbaa03f439dd2c51112b7b2d6f9eab0985e3cfa Mon Sep 17 00:00:00 2001 From: Anthony Minessale Date: Wed, 23 Sep 2009 16:11:58 +0000 Subject: [PATCH] part 1 of c# wrapper for esl lib git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@14955 d0543943-73ff-0310-b7d9-9358b9ac24b2 --- libs/esl/Makefile | 8 +- libs/esl/managed/ESL.cs | 18 + libs/esl/managed/ESLPINVOKE.cs | 309 +++++++ libs/esl/managed/ESLconnection.cs | 139 +++ libs/esl/managed/ESLevent.cs | 132 +++ libs/esl/managed/Makefile | 23 + libs/esl/managed/SWIGTYPE_p_esl_event_t.cs | 27 + libs/esl/managed/SWIGTYPE_p_esl_priority_t.cs | 27 + libs/esl/managed/esl_wrap.cpp | 837 ++++++++++++++++++ 9 files changed, 1519 insertions(+), 1 deletion(-) create mode 100644 libs/esl/managed/ESL.cs create mode 100644 libs/esl/managed/ESLPINVOKE.cs create mode 100644 libs/esl/managed/ESLconnection.cs create mode 100644 libs/esl/managed/ESLevent.cs create mode 100644 libs/esl/managed/Makefile create mode 100644 libs/esl/managed/SWIGTYPE_p_esl_event_t.cs create mode 100644 libs/esl/managed/SWIGTYPE_p_esl_priority_t.cs create mode 100644 libs/esl/managed/esl_wrap.cpp diff --git a/libs/esl/Makefile b/libs/esl/Makefile index 1ddcb2db07..00ae81ed22 100644 --- a/libs/esl/Makefile +++ b/libs/esl/Makefile @@ -48,6 +48,7 @@ clean: $(MAKE) -C python clean $(MAKE) -C ruby clean $(MAKE) -C java clean + $(MAKE) -C managed clean reswig: swigclean $(MAKE) -C perl reswig @@ -56,6 +57,7 @@ reswig: swigclean $(MAKE) -C python reswig $(MAKE) -C ruby reswig $(MAKE) -C java reswig + $(MAKE) -C managed reswig swigclean: clean $(MAKE) -C perl swigclean @@ -64,6 +66,7 @@ swigclean: clean $(MAKE) -C python swigclean $(MAKE) -C ruby swigclean $(MAKE) -C java swigclean + $(MAKE) -C managed swigclean perlmod: $(MYLIB) $(MAKE) MYLIB="../$(MYLIB)" SOLINK="$(SOLINK)" CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" CXX_CFLAGS="$(CXX_CFLAGS)" -C perl @@ -83,7 +86,10 @@ rubymod: $(MYLIB) javamod: $(MYLIB) $(MAKE) MYLIB="../$(MYLIB)" SOLINK="$(SOLINK)" CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" CXX_CFLAGS="$(CXX_CFLAGS)" -C java +managedmod: $(MYLIB) + $(MAKE) MYLIB="../$(MYLIB)" SOLINK="$(SOLINK)" CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" CXX_CFLAGS="$(CXX_CFLAGS)" -C managed + phpmod-install: phpmod $(MAKE) -C php install -everymod: perlmod phpmod luamod pymod rubymod javamod +everymod: perlmod phpmod luamod pymod rubymod javamod managedmod diff --git a/libs/esl/managed/ESL.cs b/libs/esl/managed/ESL.cs new file mode 100644 index 0000000000..160026d1e2 --- /dev/null +++ b/libs/esl/managed/ESL.cs @@ -0,0 +1,18 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.35 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class ESL { + public static void eslSetLogLevel(int level) { + ESLPINVOKE.eslSetLogLevel(level); + } + +} diff --git a/libs/esl/managed/ESLPINVOKE.cs b/libs/esl/managed/ESLPINVOKE.cs new file mode 100644 index 0000000000..224b476587 --- /dev/null +++ b/libs/esl/managed/ESLPINVOKE.cs @@ -0,0 +1,309 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.35 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +class ESLPINVOKE { + + protected class SWIGExceptionHelper { + + public delegate void ExceptionDelegate(string message); + public delegate void ExceptionArgumentDelegate(string message, string paramName); + + static ExceptionDelegate applicationDelegate = new ExceptionDelegate(SetPendingApplicationException); + static ExceptionDelegate arithmeticDelegate = new ExceptionDelegate(SetPendingArithmeticException); + static ExceptionDelegate divideByZeroDelegate = new ExceptionDelegate(SetPendingDivideByZeroException); + static ExceptionDelegate indexOutOfRangeDelegate = new ExceptionDelegate(SetPendingIndexOutOfRangeException); + static ExceptionDelegate invalidCastDelegate = new ExceptionDelegate(SetPendingInvalidCastException); + static ExceptionDelegate invalidOperationDelegate = new ExceptionDelegate(SetPendingInvalidOperationException); + static ExceptionDelegate ioDelegate = new ExceptionDelegate(SetPendingIOException); + static ExceptionDelegate nullReferenceDelegate = new ExceptionDelegate(SetPendingNullReferenceException); + static ExceptionDelegate outOfMemoryDelegate = new ExceptionDelegate(SetPendingOutOfMemoryException); + static ExceptionDelegate overflowDelegate = new ExceptionDelegate(SetPendingOverflowException); + static ExceptionDelegate systemDelegate = new ExceptionDelegate(SetPendingSystemException); + + static ExceptionArgumentDelegate argumentDelegate = new ExceptionArgumentDelegate(SetPendingArgumentException); + static ExceptionArgumentDelegate argumentNullDelegate = new ExceptionArgumentDelegate(SetPendingArgumentNullException); + static ExceptionArgumentDelegate argumentOutOfRangeDelegate = new ExceptionArgumentDelegate(SetPendingArgumentOutOfRangeException); + + [DllImport("ESL", EntryPoint="SWIGRegisterExceptionCallbacks_ESL")] + public static extern void SWIGRegisterExceptionCallbacks_ESL( + ExceptionDelegate applicationDelegate, + ExceptionDelegate arithmeticDelegate, + ExceptionDelegate divideByZeroDelegate, + ExceptionDelegate indexOutOfRangeDelegate, + ExceptionDelegate invalidCastDelegate, + ExceptionDelegate invalidOperationDelegate, + ExceptionDelegate ioDelegate, + ExceptionDelegate nullReferenceDelegate, + ExceptionDelegate outOfMemoryDelegate, + ExceptionDelegate overflowDelegate, + ExceptionDelegate systemExceptionDelegate); + + [DllImport("ESL", EntryPoint="SWIGRegisterExceptionArgumentCallbacks_ESL")] + public static extern void SWIGRegisterExceptionCallbacksArgument_ESL( + ExceptionArgumentDelegate argumentDelegate, + ExceptionArgumentDelegate argumentNullDelegate, + ExceptionArgumentDelegate argumentOutOfRangeDelegate); + + static void SetPendingApplicationException(string message) { + SWIGPendingException.Set(new System.ApplicationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingArithmeticException(string message) { + SWIGPendingException.Set(new System.ArithmeticException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingDivideByZeroException(string message) { + SWIGPendingException.Set(new System.DivideByZeroException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIndexOutOfRangeException(string message) { + SWIGPendingException.Set(new System.IndexOutOfRangeException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidCastException(string message) { + SWIGPendingException.Set(new System.InvalidCastException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingInvalidOperationException(string message) { + SWIGPendingException.Set(new System.InvalidOperationException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingIOException(string message) { + SWIGPendingException.Set(new System.IO.IOException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingNullReferenceException(string message) { + SWIGPendingException.Set(new System.NullReferenceException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOutOfMemoryException(string message) { + SWIGPendingException.Set(new System.OutOfMemoryException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingOverflowException(string message) { + SWIGPendingException.Set(new System.OverflowException(message, SWIGPendingException.Retrieve())); + } + static void SetPendingSystemException(string message) { + SWIGPendingException.Set(new System.SystemException(message, SWIGPendingException.Retrieve())); + } + + static void SetPendingArgumentException(string message, string paramName) { + SWIGPendingException.Set(new System.ArgumentException(message, paramName, SWIGPendingException.Retrieve())); + } + static void SetPendingArgumentNullException(string message, string paramName) { + Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new System.ArgumentNullException(paramName, message)); + } + static void SetPendingArgumentOutOfRangeException(string message, string paramName) { + Exception e = SWIGPendingException.Retrieve(); + if (e != null) message = message + " Inner Exception: " + e.Message; + SWIGPendingException.Set(new System.ArgumentOutOfRangeException(paramName, message)); + } + + static SWIGExceptionHelper() { + SWIGRegisterExceptionCallbacks_ESL( + applicationDelegate, + arithmeticDelegate, + divideByZeroDelegate, + indexOutOfRangeDelegate, + invalidCastDelegate, + invalidOperationDelegate, + ioDelegate, + nullReferenceDelegate, + outOfMemoryDelegate, + overflowDelegate, + systemDelegate); + + SWIGRegisterExceptionCallbacksArgument_ESL( + argumentDelegate, + argumentNullDelegate, + argumentOutOfRangeDelegate); + } + } + + protected static SWIGExceptionHelper swigExceptionHelper = new SWIGExceptionHelper(); + + public class SWIGPendingException { + [ThreadStatic] + private static Exception pendingException = null; + private static int numExceptionsPending = 0; + + public static bool Pending { + get { + bool pending = false; + if (numExceptionsPending > 0) + if (pendingException != null) + pending = true; + return pending; + } + } + + public static void Set(Exception e) { + if (pendingException != null) + throw new ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e); + pendingException = e; + lock(typeof(ESLPINVOKE)) { + numExceptionsPending++; + } + } + + public static Exception Retrieve() { + Exception e = null; + if (numExceptionsPending > 0) { + if (pendingException != null) { + e = pendingException; + pendingException = null; + lock(typeof(ESLPINVOKE)) { + numExceptionsPending--; + } + } + } + return e; + } + } + + + protected class SWIGStringHelper { + + public delegate string SWIGStringDelegate(string message); + static SWIGStringDelegate stringDelegate = new SWIGStringDelegate(CreateString); + + [DllImport("ESL", EntryPoint="SWIGRegisterStringCallback_ESL")] + public static extern void SWIGRegisterStringCallback_ESL(SWIGStringDelegate stringDelegate); + + static string CreateString(string cString) { + return cString; + } + + static SWIGStringHelper() { + SWIGRegisterStringCallback_ESL(stringDelegate); + } + } + + static protected SWIGStringHelper swigStringHelper = new SWIGStringHelper(); + + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_event_set")] + public static extern void ESLevent_event_set(HandleRef jarg1, HandleRef jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_event_get")] + public static extern IntPtr ESLevent_event_get(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_serialized_string_set")] + public static extern void ESLevent_serialized_string_set(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_serialized_string_get")] + public static extern string ESLevent_serialized_string_get(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_mine_set")] + public static extern void ESLevent_mine_set(HandleRef jarg1, int jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_mine_get")] + public static extern int ESLevent_mine_get(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_new_ESLevent__SWIG_0")] + public static extern IntPtr new_ESLevent__SWIG_0(string jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_new_ESLevent__SWIG_1")] + public static extern IntPtr new_ESLevent__SWIG_1(HandleRef jarg1, int jarg2); + + [DllImport("ESL", EntryPoint="CSharp_new_ESLevent__SWIG_2")] + public static extern IntPtr new_ESLevent__SWIG_2(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_delete_ESLevent")] + public static extern void delete_ESLevent(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_serialize")] + public static extern string ESLevent_serialize(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_setPriority")] + public static extern bool ESLevent_setPriority(HandleRef jarg1, HandleRef jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_getHeader")] + public static extern string ESLevent_getHeader(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_getBody")] + public static extern string ESLevent_getBody(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_getType")] + public static extern string ESLevent_getType(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_addBody")] + public static extern bool ESLevent_addBody(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_addHeader")] + public static extern bool ESLevent_addHeader(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_delHeader")] + public static extern bool ESLevent_delHeader(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_firstHeader")] + public static extern string ESLevent_firstHeader(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLevent_nextHeader")] + public static extern string ESLevent_nextHeader(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_new_ESLconnection__SWIG_0")] + public static extern IntPtr new_ESLconnection__SWIG_0(string jarg1, string jarg2, string jarg3); + + [DllImport("ESL", EntryPoint="CSharp_new_ESLconnection__SWIG_1")] + public static extern IntPtr new_ESLconnection__SWIG_1(int jarg1); + + [DllImport("ESL", EntryPoint="CSharp_delete_ESLconnection")] + public static extern void delete_ESLconnection(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_socketDescriptor")] + public static extern int ESLconnection_socketDescriptor(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_connected")] + public static extern int ESLconnection_connected(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_getInfo")] + public static extern IntPtr ESLconnection_getInfo(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_send")] + public static extern int ESLconnection_send(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_sendRecv")] + public static extern IntPtr ESLconnection_sendRecv(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_api")] + public static extern IntPtr ESLconnection_api(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_bgapi")] + public static extern IntPtr ESLconnection_bgapi(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_sendEvent")] + public static extern int ESLconnection_sendEvent(HandleRef jarg1, HandleRef jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_recvEvent")] + public static extern IntPtr ESLconnection_recvEvent(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_recvEventTimed")] + public static extern IntPtr ESLconnection_recvEventTimed(HandleRef jarg1, int jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_filter")] + public static extern IntPtr ESLconnection_filter(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_events")] + public static extern int ESLconnection_events(HandleRef jarg1, string jarg2, string jarg3); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_execute")] + public static extern int ESLconnection_execute(HandleRef jarg1, string jarg2, string jarg3, string jarg4); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_executeAsync")] + public static extern int ESLconnection_executeAsync(HandleRef jarg1, string jarg2, string jarg3, string jarg4); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_setAsyncExecute")] + public static extern int ESLconnection_setAsyncExecute(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_setEventLock")] + public static extern int ESLconnection_setEventLock(HandleRef jarg1, string jarg2); + + [DllImport("ESL", EntryPoint="CSharp_ESLconnection_disconnect")] + public static extern int ESLconnection_disconnect(HandleRef jarg1); + + [DllImport("ESL", EntryPoint="CSharp_eslSetLogLevel")] + public static extern void eslSetLogLevel(int jarg1); +} diff --git a/libs/esl/managed/ESLconnection.cs b/libs/esl/managed/ESLconnection.cs new file mode 100644 index 0000000000..962e237a81 --- /dev/null +++ b/libs/esl/managed/ESLconnection.cs @@ -0,0 +1,139 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.35 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class ESLconnection : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ESLconnection(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(ESLconnection obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~ESLconnection() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) { + swigCMemOwn = false; + ESLPINVOKE.delete_ESLconnection(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + GC.SuppressFinalize(this); + } + } + + public ESLconnection(string host, string port, string password) : this(ESLPINVOKE.new_ESLconnection__SWIG_0(host, port, password), true) { + } + + public ESLconnection(int socket) : this(ESLPINVOKE.new_ESLconnection__SWIG_1(socket), true) { + } + + public int socketDescriptor() { + int ret = ESLPINVOKE.ESLconnection_socketDescriptor(swigCPtr); + return ret; + } + + public int connected() { + int ret = ESLPINVOKE.ESLconnection_connected(swigCPtr); + return ret; + } + + public ESLevent getInfo() { + IntPtr cPtr = ESLPINVOKE.ESLconnection_getInfo(swigCPtr); + ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true); + return ret; + } + + public int send(string cmd) { + int ret = ESLPINVOKE.ESLconnection_send(swigCPtr, cmd); + return ret; + } + + public ESLevent sendRecv(string cmd) { + IntPtr cPtr = ESLPINVOKE.ESLconnection_sendRecv(swigCPtr, cmd); + ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true); + return ret; + } + + public ESLevent api(string cmd, string arg) { + IntPtr cPtr = ESLPINVOKE.ESLconnection_api(swigCPtr, cmd, arg); + ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true); + return ret; + } + + public ESLevent bgapi(string cmd, string arg) { + IntPtr cPtr = ESLPINVOKE.ESLconnection_bgapi(swigCPtr, cmd, arg); + ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true); + return ret; + } + + public int sendEvent(ESLevent send_me) { + int ret = ESLPINVOKE.ESLconnection_sendEvent(swigCPtr, ESLevent.getCPtr(send_me)); + return ret; + } + + public ESLevent recvEvent() { + IntPtr cPtr = ESLPINVOKE.ESLconnection_recvEvent(swigCPtr); + ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true); + return ret; + } + + public ESLevent recvEventTimed(int ms) { + IntPtr cPtr = ESLPINVOKE.ESLconnection_recvEventTimed(swigCPtr, ms); + ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true); + return ret; + } + + public ESLevent filter(string header, string value) { + IntPtr cPtr = ESLPINVOKE.ESLconnection_filter(swigCPtr, header, value); + ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true); + return ret; + } + + public int events(string etype, string value) { + int ret = ESLPINVOKE.ESLconnection_events(swigCPtr, etype, value); + return ret; + } + + public int execute(string app, string arg, string uuid) { + int ret = ESLPINVOKE.ESLconnection_execute(swigCPtr, app, arg, uuid); + return ret; + } + + public int executeAsync(string app, string arg, string uuid) { + int ret = ESLPINVOKE.ESLconnection_executeAsync(swigCPtr, app, arg, uuid); + return ret; + } + + public int setAsyncExecute(string val) { + int ret = ESLPINVOKE.ESLconnection_setAsyncExecute(swigCPtr, val); + return ret; + } + + public int setEventLock(string val) { + int ret = ESLPINVOKE.ESLconnection_setEventLock(swigCPtr, val); + return ret; + } + + public int disconnect() { + int ret = ESLPINVOKE.ESLconnection_disconnect(swigCPtr); + return ret; + } + +} diff --git a/libs/esl/managed/ESLevent.cs b/libs/esl/managed/ESLevent.cs new file mode 100644 index 0000000000..9ff75fcb5c --- /dev/null +++ b/libs/esl/managed/ESLevent.cs @@ -0,0 +1,132 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.35 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class ESLevent : IDisposable { + private HandleRef swigCPtr; + protected bool swigCMemOwn; + + internal ESLevent(IntPtr cPtr, bool cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = new HandleRef(this, cPtr); + } + + internal static HandleRef getCPtr(ESLevent obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } + + ~ESLevent() { + Dispose(); + } + + public virtual void Dispose() { + lock(this) { + if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) { + swigCMemOwn = false; + ESLPINVOKE.delete_ESLevent(swigCPtr); + } + swigCPtr = new HandleRef(null, IntPtr.Zero); + GC.SuppressFinalize(this); + } + } + + public SWIGTYPE_p_esl_event_t event { + set { + ESLPINVOKE.ESLevent_event_set(swigCPtr, SWIGTYPE_p_esl_event_t.getCPtr(value)); + } + get { + IntPtr cPtr = ESLPINVOKE.ESLevent_event_get(swigCPtr); + SWIGTYPE_p_esl_event_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_esl_event_t(cPtr, false); + return ret; + } + } + + public string serialized_string { + set { + ESLPINVOKE.ESLevent_serialized_string_set(swigCPtr, value); + } + get { + string ret = ESLPINVOKE.ESLevent_serialized_string_get(swigCPtr); + return ret; + } + } + + public int mine { + set { + ESLPINVOKE.ESLevent_mine_set(swigCPtr, value); + } + get { + int ret = ESLPINVOKE.ESLevent_mine_get(swigCPtr); + return ret; + } + } + + public ESLevent(string type, string subclass_name) : this(ESLPINVOKE.new_ESLevent__SWIG_0(type, subclass_name), true) { + } + + public ESLevent(SWIGTYPE_p_esl_event_t wrap_me, int free_me) : this(ESLPINVOKE.new_ESLevent__SWIG_1(SWIGTYPE_p_esl_event_t.getCPtr(wrap_me), free_me), true) { + } + + public ESLevent(ESLevent me) : this(ESLPINVOKE.new_ESLevent__SWIG_2(ESLevent.getCPtr(me)), true) { + } + + public string serialize(string format) { + string ret = ESLPINVOKE.ESLevent_serialize(swigCPtr, format); + return ret; + } + + public bool setPriority(SWIGTYPE_p_esl_priority_t priority) { + bool ret = ESLPINVOKE.ESLevent_setPriority(swigCPtr, SWIGTYPE_p_esl_priority_t.getCPtr(priority)); + if (ESLPINVOKE.SWIGPendingException.Pending) throw ESLPINVOKE.SWIGPendingException.Retrieve(); + return ret; + } + + public string getHeader(string header_name) { + string ret = ESLPINVOKE.ESLevent_getHeader(swigCPtr, header_name); + return ret; + } + + public string getBody() { + string ret = ESLPINVOKE.ESLevent_getBody(swigCPtr); + return ret; + } + + public string getType() { + string ret = ESLPINVOKE.ESLevent_getType(swigCPtr); + return ret; + } + + public bool addBody(string value) { + bool ret = ESLPINVOKE.ESLevent_addBody(swigCPtr, value); + return ret; + } + + public bool addHeader(string header_name, string value) { + bool ret = ESLPINVOKE.ESLevent_addHeader(swigCPtr, header_name, value); + return ret; + } + + public bool delHeader(string header_name) { + bool ret = ESLPINVOKE.ESLevent_delHeader(swigCPtr, header_name); + return ret; + } + + public string firstHeader() { + string ret = ESLPINVOKE.ESLevent_firstHeader(swigCPtr); + return ret; + } + + public string nextHeader() { + string ret = ESLPINVOKE.ESLevent_nextHeader(swigCPtr); + return ret; + } + +} diff --git a/libs/esl/managed/Makefile b/libs/esl/managed/Makefile new file mode 100644 index 0000000000..8ce9a9890e --- /dev/null +++ b/libs/esl/managed/Makefile @@ -0,0 +1,23 @@ +LOCAL_CFLAGS= +LOCAL_LDFLAGS= +WRAP_GCC_WARNING_SILENCE=-Wno-unused-function + +all: ESL.so + +esl_wrap.cpp: + swig -module ESL -csharp -c++ -DMULTIPLICITY -I../src/include -o esl_wrap.cpp ../ESL.i + +esl_wrap.o: esl_wrap.cpp + $(CXX) $(CXX_CFLAGS) $(CXXFLAGS) $(LOCAL_CFLAGS) $(WRAP_GCC_WARNING_SILENCE) -c esl_wrap.cpp -o esl_wrap.o + +ESL.so: esl_wrap.o + $(CXX) $(SOLINK) esl_wrap.o $(MYLIB) $(LOCAL_LDFLAGS) -o ESL.so -L. $(LIBS) + +clean: + rm -f *.o *.so *~ + +swigclean: + rm -f esl_wrap.* ESL.so + +reswig: swigclean esl_wrap.cpp + diff --git a/libs/esl/managed/SWIGTYPE_p_esl_event_t.cs b/libs/esl/managed/SWIGTYPE_p_esl_event_t.cs new file mode 100644 index 0000000000..b20f2d8785 --- /dev/null +++ b/libs/esl/managed/SWIGTYPE_p_esl_event_t.cs @@ -0,0 +1,27 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.35 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_esl_event_t { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_esl_event_t(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_esl_event_t() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_esl_event_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} diff --git a/libs/esl/managed/SWIGTYPE_p_esl_priority_t.cs b/libs/esl/managed/SWIGTYPE_p_esl_priority_t.cs new file mode 100644 index 0000000000..e6e1ed55cd --- /dev/null +++ b/libs/esl/managed/SWIGTYPE_p_esl_priority_t.cs @@ -0,0 +1,27 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.35 + * + * Do not make changes to this file unless you know what you are doing--modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +using System; +using System.Runtime.InteropServices; + +public class SWIGTYPE_p_esl_priority_t { + private HandleRef swigCPtr; + + internal SWIGTYPE_p_esl_priority_t(IntPtr cPtr, bool futureUse) { + swigCPtr = new HandleRef(this, cPtr); + } + + protected SWIGTYPE_p_esl_priority_t() { + swigCPtr = new HandleRef(null, IntPtr.Zero); + } + + internal static HandleRef getCPtr(SWIGTYPE_p_esl_priority_t obj) { + return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr; + } +} diff --git a/libs/esl/managed/esl_wrap.cpp b/libs/esl/managed/esl_wrap.cpp new file mode 100644 index 0000000000..bf9237a1ba --- /dev/null +++ b/libs/esl/managed/esl_wrap.cpp @@ -0,0 +1,837 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.35 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifdef __cplusplus +template class SwigValueWrapper { + T *tt; +public: + SwigValueWrapper() : tt(0) { } + SwigValueWrapper(const SwigValueWrapper& rhs) : tt(new T(*rhs.tt)) { } + SwigValueWrapper(const T& t) : tt(new T(t)) { } + ~SwigValueWrapper() { delete tt; } + SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; } + operator T&() const { return *tt; } + T *operator&() { return tt; } +private: + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + + + +#include +#include +#include + + +/* Support for throwing C# exceptions from C/C++. There are two types: + * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */ +typedef enum { + SWIG_CSharpApplicationException, + SWIG_CSharpArithmeticException, + SWIG_CSharpDivideByZeroException, + SWIG_CSharpIndexOutOfRangeException, + SWIG_CSharpInvalidCastException, + SWIG_CSharpInvalidOperationException, + SWIG_CSharpIOException, + SWIG_CSharpNullReferenceException, + SWIG_CSharpOutOfMemoryException, + SWIG_CSharpOverflowException, + SWIG_CSharpSystemException +} SWIG_CSharpExceptionCodes; + +typedef enum { + SWIG_CSharpArgumentException, + SWIG_CSharpArgumentNullException, + SWIG_CSharpArgumentOutOfRangeException +} SWIG_CSharpExceptionArgumentCodes; + +typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *); +typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *); + +typedef struct { + SWIG_CSharpExceptionCodes code; + SWIG_CSharpExceptionCallback_t callback; +} SWIG_CSharpException_t; + +typedef struct { + SWIG_CSharpExceptionArgumentCodes code; + SWIG_CSharpExceptionArgumentCallback_t callback; +} SWIG_CSharpExceptionArgument_t; + +static SWIG_CSharpException_t SWIG_csharp_exceptions[] = { + { SWIG_CSharpApplicationException, NULL }, + { SWIG_CSharpArithmeticException, NULL }, + { SWIG_CSharpDivideByZeroException, NULL }, + { SWIG_CSharpIndexOutOfRangeException, NULL }, + { SWIG_CSharpInvalidCastException, NULL }, + { SWIG_CSharpInvalidOperationException, NULL }, + { SWIG_CSharpIOException, NULL }, + { SWIG_CSharpNullReferenceException, NULL }, + { SWIG_CSharpOutOfMemoryException, NULL }, + { SWIG_CSharpOverflowException, NULL }, + { SWIG_CSharpSystemException, NULL } +}; + +static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = { + { SWIG_CSharpArgumentException, NULL }, + { SWIG_CSharpArgumentNullException, NULL }, + { SWIG_CSharpArgumentOutOfRangeException, NULL }, +}; + +static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) { + SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback; + if (code >=0 && (size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) { + callback = SWIG_csharp_exceptions[code].callback; + } + callback(msg); +} + +static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) { + SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback; + if (code >=0 && (size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) { + callback = SWIG_csharp_exceptions_argument[code].callback; + } + callback(msg, param_name); +} + + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_ESL( + SWIG_CSharpExceptionCallback_t applicationCallback, + SWIG_CSharpExceptionCallback_t arithmeticCallback, + SWIG_CSharpExceptionCallback_t divideByZeroCallback, + SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, + SWIG_CSharpExceptionCallback_t invalidCastCallback, + SWIG_CSharpExceptionCallback_t invalidOperationCallback, + SWIG_CSharpExceptionCallback_t ioCallback, + SWIG_CSharpExceptionCallback_t nullReferenceCallback, + SWIG_CSharpExceptionCallback_t outOfMemoryCallback, + SWIG_CSharpExceptionCallback_t overflowCallback, + SWIG_CSharpExceptionCallback_t systemCallback) { + SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback; + SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback; + SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback; + SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback; + SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback; + SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback; + SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback; + SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback; + SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback; + SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback; + SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback; +} + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_ESL( + SWIG_CSharpExceptionArgumentCallback_t argumentCallback, + SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback, + SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) { + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback; + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback; + SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback; +} + + +/* Callback for returning strings to C# without leaking memory */ +typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *); +static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL; + + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_ESL(SWIG_CSharpStringHelperCallback callback) { + SWIG_csharp_string_callback = callback; +} + + +/* Contract support */ + +#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else + + +#include "esl.h" +#include "esl_oop.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT void SWIGSTDCALL CSharp_ESLevent_event_set(void * jarg1, void * jarg2) { + ESLevent *arg1 = (ESLevent *) 0 ; + esl_event_t *arg2 = (esl_event_t *) 0 ; + + arg1 = (ESLevent *)jarg1; + arg2 = (esl_event_t *)jarg2; + if (arg1) (arg1)->event = arg2; + +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ESLevent_event_get(void * jarg1) { + void * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + esl_event_t *result = 0 ; + + arg1 = (ESLevent *)jarg1; + result = (esl_event_t *) ((arg1)->event); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ESLevent_serialized_string_set(void * jarg1, char * jarg2) { + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + + arg1 = (ESLevent *)jarg1; + arg2 = (char *)jarg2; + { + if (arg1->serialized_string) delete [] arg1->serialized_string; + if (arg2) { + arg1->serialized_string = (char *) (new char[strlen((const char *)arg2)+1]); + strcpy((char *)arg1->serialized_string, (const char *)arg2); + } else { + arg1->serialized_string = 0; + } + } +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_serialized_string_get(void * jarg1) { + char * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *result = 0 ; + + arg1 = (ESLevent *)jarg1; + result = (char *) ((arg1)->serialized_string); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_ESLevent_mine_set(void * jarg1, int jarg2) { + ESLevent *arg1 = (ESLevent *) 0 ; + int arg2 ; + + arg1 = (ESLevent *)jarg1; + arg2 = (int)jarg2; + if (arg1) (arg1)->mine = arg2; + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLevent_mine_get(void * jarg1) { + int jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + int result; + + arg1 = (ESLevent *)jarg1; + result = (int) ((arg1)->mine); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESLevent__SWIG_0(char * jarg1, char * jarg2) { + void * jresult ; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) NULL ; + ESLevent *result = 0 ; + + arg1 = (char *)jarg1; + arg2 = (char *)jarg2; + result = (ESLevent *)new ESLevent((char const *)arg1,(char const *)arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESLevent__SWIG_1(void * jarg1, int jarg2) { + void * jresult ; + esl_event_t *arg1 = (esl_event_t *) 0 ; + int arg2 = (int) 0 ; + ESLevent *result = 0 ; + + arg1 = (esl_event_t *)jarg1; + arg2 = (int)jarg2; + result = (ESLevent *)new ESLevent(arg1,arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESLevent__SWIG_2(void * jarg1) { + void * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + ESLevent *result = 0 ; + + arg1 = (ESLevent *)jarg1; + result = (ESLevent *)new ESLevent(arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_ESLevent(void * jarg1) { + ESLevent *arg1 = (ESLevent *) 0 ; + + arg1 = (ESLevent *)jarg1; + delete arg1; + +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_serialize(void * jarg1, char * jarg2) { + char * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) NULL ; + char *result = 0 ; + + arg1 = (ESLevent *)jarg1; + arg2 = (char *)jarg2; + result = (char *)(arg1)->serialize((char const *)arg2); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_setPriority(void * jarg1, void * jarg2) { + unsigned int jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + esl_priority_t arg2 = (esl_priority_t) ESL_PRIORITY_NORMAL ; + bool result; + esl_priority_t *argp2 ; + + arg1 = (ESLevent *)jarg1; + argp2 = (esl_priority_t *)jarg2; + if (!argp2) { + SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null esl_priority_t", 0); + return 0; + } + arg2 = *argp2; + result = (bool)(arg1)->setPriority(arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_getHeader(void * jarg1, char * jarg2) { + char * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *result = 0 ; + + arg1 = (ESLevent *)jarg1; + arg2 = (char *)jarg2; + result = (char *)(arg1)->getHeader((char const *)arg2); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_getBody(void * jarg1) { + char * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *result = 0 ; + + arg1 = (ESLevent *)jarg1; + result = (char *)(arg1)->getBody(); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_getType(void * jarg1) { + char * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *result = 0 ; + + arg1 = (ESLevent *)jarg1; + result = (char *)(arg1)->getType(); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_addBody(void * jarg1, char * jarg2) { + unsigned int jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + arg1 = (ESLevent *)jarg1; + arg2 = (char *)jarg2; + result = (bool)(arg1)->addBody((char const *)arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_addHeader(void * jarg1, char * jarg2, char * jarg3) { + unsigned int jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + + arg1 = (ESLevent *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + result = (bool)(arg1)->addHeader((char const *)arg2,(char const *)arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_delHeader(void * jarg1, char * jarg2) { + unsigned int jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + arg1 = (ESLevent *)jarg1; + arg2 = (char *)jarg2; + result = (bool)(arg1)->delHeader((char const *)arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_firstHeader(void * jarg1) { + char * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *result = 0 ; + + arg1 = (ESLevent *)jarg1; + result = (char *)(arg1)->firstHeader(); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_nextHeader(void * jarg1) { + char * jresult ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *result = 0 ; + + arg1 = (ESLevent *)jarg1; + result = (char *)(arg1)->nextHeader(); + jresult = SWIG_csharp_string_callback((const char *)result); + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESLconnection__SWIG_0(char * jarg1, char * jarg2, char * jarg3) { + void * jresult ; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + ESLconnection *result = 0 ; + + arg1 = (char *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + result = (ESLconnection *)new ESLconnection((char const *)arg1,(char const *)arg2,(char const *)arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESLconnection__SWIG_1(int jarg1) { + void * jresult ; + int arg1 ; + ESLconnection *result = 0 ; + + arg1 = (int)jarg1; + result = (ESLconnection *)new ESLconnection(arg1); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_delete_ESLconnection(void * jarg1) { + ESLconnection *arg1 = (ESLconnection *) 0 ; + + arg1 = (ESLconnection *)jarg1; + delete arg1; + +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_socketDescriptor(void * jarg1) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + int result; + + arg1 = (ESLconnection *)jarg1; + result = (int)(arg1)->socketDescriptor(); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_connected(void * jarg1) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + int result; + + arg1 = (ESLconnection *)jarg1; + result = (int)(arg1)->connected(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_getInfo(void * jarg1) { + void * jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + ESLevent *result = 0 ; + + arg1 = (ESLconnection *)jarg1; + result = (ESLevent *)(arg1)->getInfo(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_send(void * jarg1, char * jarg2) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + int result; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + result = (int)(arg1)->send((char const *)arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_sendRecv(void * jarg1, char * jarg2) { + void * jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + ESLevent *result = 0 ; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + result = (ESLevent *)(arg1)->sendRecv((char const *)arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_api(void * jarg1, char * jarg2, char * jarg3) { + void * jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) NULL ; + ESLevent *result = 0 ; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + result = (ESLevent *)(arg1)->api((char const *)arg2,(char const *)arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_bgapi(void * jarg1, char * jarg2, char * jarg3) { + void * jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) NULL ; + ESLevent *result = 0 ; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + result = (ESLevent *)(arg1)->bgapi((char const *)arg2,(char const *)arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_sendEvent(void * jarg1, void * jarg2) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + ESLevent *arg2 = (ESLevent *) 0 ; + int result; + + arg1 = (ESLconnection *)jarg1; + arg2 = (ESLevent *)jarg2; + result = (int)(arg1)->sendEvent(arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_recvEvent(void * jarg1) { + void * jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + ESLevent *result = 0 ; + + arg1 = (ESLconnection *)jarg1; + result = (ESLevent *)(arg1)->recvEvent(); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_recvEventTimed(void * jarg1, int jarg2) { + void * jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + int arg2 ; + ESLevent *result = 0 ; + + arg1 = (ESLconnection *)jarg1; + arg2 = (int)jarg2; + result = (ESLevent *)(arg1)->recvEventTimed(arg2); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_filter(void * jarg1, char * jarg2, char * jarg3) { + void * jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + ESLevent *result = 0 ; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + result = (ESLevent *)(arg1)->filter((char const *)arg2,(char const *)arg3); + jresult = (void *)result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_events(void * jarg1, char * jarg2, char * jarg3) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int result; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + result = (int)(arg1)->events((char const *)arg2,(char const *)arg3); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_execute(void * jarg1, char * jarg2, char * jarg3, char * jarg4) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) NULL ; + char *arg4 = (char *) NULL ; + int result; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + arg4 = (char *)jarg4; + result = (int)(arg1)->execute((char const *)arg2,(char const *)arg3,(char const *)arg4); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_executeAsync(void * jarg1, char * jarg2, char * jarg3, char * jarg4) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) NULL ; + char *arg4 = (char *) NULL ; + int result; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + arg3 = (char *)jarg3; + arg4 = (char *)jarg4; + result = (int)(arg1)->executeAsync((char const *)arg2,(char const *)arg3,(char const *)arg4); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_setAsyncExecute(void * jarg1, char * jarg2) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + int result; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + result = (int)(arg1)->setAsyncExecute((char const *)arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_setEventLock(void * jarg1, char * jarg2) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + char *arg2 = (char *) 0 ; + int result; + + arg1 = (ESLconnection *)jarg1; + arg2 = (char *)jarg2; + result = (int)(arg1)->setEventLock((char const *)arg2); + jresult = result; + return jresult; +} + + +SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_disconnect(void * jarg1) { + int jresult ; + ESLconnection *arg1 = (ESLconnection *) 0 ; + int result; + + arg1 = (ESLconnection *)jarg1; + result = (int)(arg1)->disconnect(); + jresult = result; + return jresult; +} + + +SWIGEXPORT void SWIGSTDCALL CSharp_eslSetLogLevel(int jarg1) { + int arg1 ; + + arg1 = (int)jarg1; + eslSetLogLevel(arg1); +} + + +#ifdef __cplusplus +} +#endif +