ESL-81 --resolve

libs/esl/managed/ESL.2010.vcxproj

@@ -184,7 +184,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\src\esl_oop.cpp" />
-    <ClCompile Include="esl_wrap.cpp" />
+    <ClCompile Include="esl_wrap.2010.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\src\include\esl_oop.h" />

libs/esl/managed/ESL.2010.vcxproj.filters

@@ -18,7 +18,7 @@
     <ClCompile Include="..\src\esl_oop.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="esl_wrap.cpp">
+    <ClCompile Include="esl_wrap.2010.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>

libs/esl/managed/ESL.2012.vcxproj

@@ -188,7 +188,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\src\esl_oop.cpp" />
-    <ClCompile Include="esl_wrap.cpp" />
+    <ClCompile Include="esl_wrap.2010.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\src\include\esl_oop.h" />

libs/esl/managed/ESL.2012.vcxproj.filters

@@ -18,7 +18,7 @@
     <ClCompile Include="..\src\esl_oop.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="esl_wrap.cpp">
+    <ClCompile Include="esl_wrap.2010.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>

libs/esl/managed/ESLPINVOKE.2010.cs

+/* ----------------------------------------------------------------------------
+ * 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.
+ * ----------------------------------------------------------------------------- */
+
+
+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();
+
+
+  static ESLPINVOKE() {
+  }
+
+
+  [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_SerializedString_set")]
+  public static extern void ESLevent_SerializedString_set(HandleRef jarg1, string jarg2);
+
+  [DllImport("ESL", EntryPoint="CSharp_ESLevent_SerializedString_get")]
+  public static extern string ESLevent_SerializedString_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, int jarg3);
+
+  [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_pushHeader")]
+  public static extern bool ESLevent_pushHeader(HandleRef jarg1, string jarg2, string jarg3);
+
+  [DllImport("ESL", EntryPoint="CSharp_ESLevent_unshiftHeader")]
+  public static extern bool ESLevent_unshiftHeader(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, int jarg2, string jarg3, string jarg4);
+
+  [DllImport("ESL", EntryPoint="CSharp_new_ESLconnection__SWIG_1")]
+  public static extern IntPtr new_ESLconnection__SWIG_1(string jarg1, int jarg2, string jarg3);
+
+  [DllImport("ESL", EntryPoint="CSharp_new_ESLconnection__SWIG_2")]
+  public static extern IntPtr new_ESLconnection__SWIG_2(string jarg1, string jarg2, string jarg3, string jarg4);
+
+  [DllImport("ESL", EntryPoint="CSharp_new_ESLconnection__SWIG_3")]
+  public static extern IntPtr new_ESLconnection__SWIG_3(string jarg1, string jarg2, string jarg3);
+
+  [DllImport("ESL", EntryPoint="CSharp_new_ESLconnection__SWIG_4")]
+  public static extern IntPtr new_ESLconnection__SWIG_4(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, string jarg4);
+
+  [DllImport("ESL", EntryPoint="CSharp_ESLconnection_SendEvent")]
+  public static extern IntPtr ESLconnection_SendEvent(HandleRef jarg1, HandleRef jarg2);
+
+  [DllImport("ESL", EntryPoint="CSharp_ESLconnection_sendMSG")]
+  public static extern int ESLconnection_sendMSG(HandleRef jarg1, HandleRef jarg2, string jarg3);
+
+  [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 IntPtr ESLconnection_Execute(HandleRef jarg1, string jarg2, string jarg3, string jarg4);
+
+  [DllImport("ESL", EntryPoint="CSharp_ESLconnection_ExecuteAsync")]
+  public static extern IntPtr 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);
+}

libs/esl/managed/ESLconnection.2010.cs

+/* ----------------------------------------------------------------------------
+ * 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.
+ * ----------------------------------------------------------------------------- */
+
+
+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) {
+        if (swigCMemOwn) {
+          swigCMemOwn = false;
+          ESLPINVOKE.delete_ESLconnection(swigCPtr);
+        }
+        swigCPtr = new HandleRef(null, IntPtr.Zero);
+      }
+      GC.SuppressFinalize(this);
+    }
+  }
+
+  public ESLconnection(string host, int port, string user, string password) : this(ESLPINVOKE.new_ESLconnection__SWIG_0(host, port, user, password), true) {
+  }
+
+  public ESLconnection(string host, int port, string password) : this(ESLPINVOKE.new_ESLconnection__SWIG_1(host, port, password), true) {
+  }
+
+  public ESLconnection(string host, string port, string user, string password) : this(ESLPINVOKE.new_ESLconnection__SWIG_2(host, port, user, password), true) {
+  }
+
+  public ESLconnection(string host, string port, string password) : this(ESLPINVOKE.new_ESLconnection__SWIG_3(host, port, password), true) {
+  }
+
+  public ESLconnection(int socket) : this(ESLPINVOKE.new_ESLconnection__SWIG_4(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, string job_uuid) {
+    IntPtr cPtr = ESLPINVOKE.ESLconnection_Bgapi(swigCPtr, cmd, arg, job_uuid);
+    ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true);
+    return ret;
+  }
+
+  public ESLevent SendEvent(ESLevent send_me) {
+    IntPtr cPtr = ESLPINVOKE.ESLconnection_SendEvent(swigCPtr, ESLevent.getCPtr(send_me));
+    ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true);
+    return ret;
+  }
+
+  public int sendMSG(ESLevent send_me, string uuid) {
+    int ret = ESLPINVOKE.ESLconnection_sendMSG(swigCPtr, ESLevent.getCPtr(send_me), uuid);
+    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 ESLevent Execute(string app, string arg, string uuid) {
+    IntPtr cPtr = ESLPINVOKE.ESLconnection_Execute(swigCPtr, app, arg, uuid);
+    ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true);
+    return ret;
+  }
+
+  public ESLevent ExecuteAsync(string app, string arg, string uuid) {
+    IntPtr cPtr = ESLPINVOKE.ESLconnection_ExecuteAsync(swigCPtr, app, arg, uuid);
+    ESLevent ret = (cPtr == IntPtr.Zero) ? null : new ESLevent(cPtr, true);
+    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;
+  }
+
+}

libs/esl/managed/ESLevent.2010.cs

+/* ----------------------------------------------------------------------------
+ * 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.
+ * ----------------------------------------------------------------------------- */
+
+
+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) {
+        if (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 SerializedString {
+    set {
+      ESLPINVOKE.ESLevent_SerializedString_set(swigCPtr, value);
+    } 
+    get {
+      string ret = ESLPINVOKE.ESLevent_SerializedString_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, int idx) {
+    string ret = ESLPINVOKE.ESLevent_GetHeader(swigCPtr, header_name, idx);
+    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 pushHeader(string header_name, string value) {
+    bool ret = ESLPINVOKE.ESLevent_pushHeader(swigCPtr, header_name, value);
+    return ret;
+  }
+
+  public bool unshiftHeader(string header_name, string value) {
+    bool ret = ESLPINVOKE.ESLevent_unshiftHeader(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;
+  }
+
+}

libs/esl/managed/ManagedEsl.2010.csproj

@@ -57,13 +57,13 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ESL.cs" />
-    <Compile Include="ESLconnection.cs" />
-    <Compile Include="ESLevent.cs" />
-    <Compile Include="ESLPINVOKE.cs" />
+    <Compile Include="ESL.2010.cs" />
+    <Compile Include="ESLconnection.2010.cs" />
+    <Compile Include="ESLevent.2010.cs" />
+    <Compile Include="ESLPINVOKE.2010.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SWIGTYPE_p_esl_event_t.cs" />
-    <Compile Include="SWIGTYPE_p_esl_priority_t.cs" />
+    <Compile Include="SWIGTYPE_p_esl_event_t.2010.cs" />
+    <Compile Include="SWIGTYPE_p_esl_priority_t.2010.cs" />
   </ItemGroup>
   <ItemGroup>
     <BootstrapperPackage Include="Microsoft.Net.Client.3.5">

libs/esl/managed/ManagedEsl.2012.csproj

@@ -57,13 +57,13 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ESL.cs" />
-    <Compile Include="ESLconnection.cs" />
-    <Compile Include="ESLevent.cs" />
-    <Compile Include="ESLPINVOKE.cs" />
+    <Compile Include="ESL.2010.cs" />
+    <Compile Include="ESLconnection.2010.cs" />
+    <Compile Include="ESLevent.2010.cs" />
+    <Compile Include="ESLPINVOKE.2010.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SWIGTYPE_p_esl_event_t.cs" />
-    <Compile Include="SWIGTYPE_p_esl_priority_t.cs" />
+    <Compile Include="SWIGTYPE_p_esl_event_t.2010.cs" />
+    <Compile Include="SWIGTYPE_p_esl_priority_t.2010.cs" />
   </ItemGroup>
   <ItemGroup>
     <BootstrapperPackage Include="Microsoft.Net.Client.3.5">

libs/esl/managed/SWIGTYPE_p_esl_event_t.2010.cs

+/* ----------------------------------------------------------------------------
+ * 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.
+ * ----------------------------------------------------------------------------- */
+
+
+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;
+  }
+}

libs/esl/managed/SWIGTYPE_p_esl_priority_t.2010.cs

+/* ----------------------------------------------------------------------------
+ * 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.
+ * ----------------------------------------------------------------------------- */
+
+
+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;
+  }
+}

libs/esl/managed/esl.2010.cs

+/* ----------------------------------------------------------------------------
+ * 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.
+ * ----------------------------------------------------------------------------- */
+
+
+using System;
+using System.Runtime.InteropServices;
+
+public class ESL {
+  public static void eslSetLogLevel(int level) {
+    ESLPINVOKE.eslSetLogLevel(level);
+  }
+
+}

libs/esl/managed/esl_wrap.2010.cpp

+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 2.0.1
+ * 
+ * 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. 
+ * ----------------------------------------------------------------------------- */
+
+#define SWIGCSHARP
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> 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 SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# 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 <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+
+/* 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 ((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 ((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_SerializedString_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_SerializedString_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 ;
+  esl_priority_t *argp2 ;
+  bool result;
+  
+  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, int jarg3) {
+  char * jresult ;
+  ESLevent *arg1 = (ESLevent *) 0 ;
+  char *arg2 = (char *) 0 ;
+  int arg3 = (int) -1 ;
+  char *result = 0 ;
+  
+  arg1 = (ESLevent *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (int)jarg3; 
+  result = (char *)(arg1)->getHeader((char const *)arg2,arg3);
+  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_pushHeader(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)->pushHeader((char const *)arg2,(char const *)arg3);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_unshiftHeader(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)->unshiftHeader((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, int jarg2, char * jarg3, char * jarg4) {
+  void * jresult ;
+  char *arg1 = (char *) 0 ;
+  int arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  ESLconnection *result = 0 ;
+  
+  arg1 = (char *)jarg1; 
+  arg2 = (int)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  result = (ESLconnection *)new ESLconnection((char const *)arg1,arg2,(char const *)arg3,(char const *)arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESLconnection__SWIG_1(char * jarg1, int jarg2, char * jarg3) {
+  void * jresult ;
+  char *arg1 = (char *) 0 ;
+  int arg2 ;
+  char *arg3 = (char *) 0 ;
+  ESLconnection *result = 0 ;
+  
+  arg1 = (char *)jarg1; 
+  arg2 = (int)jarg2; 
+  arg3 = (char *)jarg3; 
+  result = (ESLconnection *)new ESLconnection((char const *)arg1,arg2,(char const *)arg3);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESLconnection__SWIG_2(char * jarg1, char * jarg2, char * jarg3, char * jarg4) {
+  void * jresult ;
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  ESLconnection *result = 0 ;
+  
+  arg1 = (char *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  result = (ESLconnection *)new ESLconnection((char const *)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_new_ESLconnection__SWIG_3(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_4(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, char * jarg4) {
+  void * jresult ;
+  ESLconnection *arg1 = (ESLconnection *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
+  char *arg4 = (char *) NULL ;
+  ESLevent *result = 0 ;
+  
+  arg1 = (ESLconnection *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  result = (ESLevent *)(arg1)->bgapi((char const *)arg2,(char const *)arg3,(char const *)arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_SendEvent(void * jarg1, void * jarg2) {
+  void * jresult ;
+  ESLconnection *arg1 = (ESLconnection *) 0 ;
+  ESLevent *arg2 = (ESLevent *) 0 ;
+  ESLevent *result = 0 ;
+  
+  arg1 = (ESLconnection *)jarg1; 
+  arg2 = (ESLevent *)jarg2; 
+  result = (ESLevent *)(arg1)->sendEvent(arg2);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_ESLconnection_sendMSG(void * jarg1, void * jarg2, char * jarg3) {
+  int jresult ;
+  ESLconnection *arg1 = (ESLconnection *) 0 ;
+  ESLevent *arg2 = (ESLevent *) 0 ;
+  char *arg3 = (char *) NULL ;
+  int result;
+  
+  arg1 = (ESLconnection *)jarg1; 
+  arg2 = (ESLevent *)jarg2; 
+  arg3 = (char *)jarg3; 
+  result = (int)(arg1)->sendMSG(arg2,(char const *)arg3);
+  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 void * SWIGSTDCALL CSharp_ESLconnection_Execute(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
+  void * jresult ;
+  ESLconnection *arg1 = (ESLconnection *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
+  char *arg4 = (char *) NULL ;
+  ESLevent *result = 0 ;
+  
+  arg1 = (ESLconnection *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  result = (ESLevent *)(arg1)->execute((char const *)arg2,(char const *)arg3,(char const *)arg4);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_ESLconnection_ExecuteAsync(void * jarg1, char * jarg2, char * jarg3, char * jarg4) {
+  void * jresult ;
+  ESLconnection *arg1 = (ESLconnection *) 0 ;
+  char *arg2 = (char *) 0 ;
+  char *arg3 = (char *) NULL ;
+  char *arg4 = (char *) NULL ;
+  ESLevent *result = 0 ;
+  
+  arg1 = (ESLconnection *)jarg1; 
+  arg2 = (char *)jarg2; 
+  arg3 = (char *)jarg3; 
+  arg4 = (char *)jarg4; 
+  result = (ESLevent *)(arg1)->executeAsync((char const *)arg2,(char const *)arg3,(char const *)arg4);
+  jresult = (void *)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
+