From ffa0a07198dd38cb049080994cd3af7a3faf5908 Mon Sep 17 00:00:00 2001 From: Anthony Minessale Date: Thu, 26 May 2011 12:18:18 -0500 Subject: [PATCH] add array manipulation to the wraper code --- libs/esl/java/esl_wrap.cpp | 64 ++++++++- .../esl/java/org/freeswitch/esl/ESLevent.java | 12 +- libs/esl/java/org/freeswitch/esl/eslJNI.java | 4 +- libs/esl/lua/esl_wrap.cpp | 73 ++++++++++- libs/esl/managed/ESLPINVOKE.cs | 8 +- libs/esl/managed/ESLevent.cs | 14 +- libs/esl/managed/esl_wrap.cpp | 38 +++++- libs/esl/perl/ESL.pm | 2 + libs/esl/perl/esl_wrap.cpp | 120 ++++++++++++++++- libs/esl/php/ESL.php | 12 +- libs/esl/php/esl_wrap.cpp | 102 ++++++++++++++- libs/esl/php/php_ESL.h | 2 + libs/esl/python/ESL.py | 2 + libs/esl/python/esl_wrap.cpp | 123 +++++++++++++++++- libs/esl/ruby/esl_wrap.cpp | 108 ++++++++++++++- libs/esl/src/esl_oop.cpp | 30 ++++- libs/esl/src/include/esl_oop.h | 4 +- 17 files changed, 689 insertions(+), 29 deletions(-) diff --git a/libs/esl/java/esl_wrap.cpp b/libs/esl/java/esl_wrap.cpp index 9a764dd030..52c5065d00 100644 --- a/libs/esl/java/esl_wrap.cpp +++ b/libs/esl/java/esl_wrap.cpp @@ -419,10 +419,11 @@ SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1setPriority } -SWIGEXPORT jstring JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1getHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { +SWIGEXPORT jstring JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1getHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { jstring jresult = 0 ; ESLevent *arg1 = (ESLevent *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) -1 ; char *result = 0 ; (void)jenv; @@ -434,7 +435,8 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1getHeader(JN arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); if (!arg2) return 0; } - result = (char *)(arg1)->getHeader((char const *)arg2); + arg3 = (int)jarg3; + result = (char *)(arg1)->getHeader((char const *)arg2,arg3); if(result) jresult = jenv->NewStringUTF((const char *)result); if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); return jresult; @@ -522,6 +524,64 @@ SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1addHeader(J } +SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1pushHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) { + jboolean jresult = 0 ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(ESLevent **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3); + jresult = (jboolean)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1unshiftHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) { + jboolean jresult = 0 ; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(ESLevent **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3); + jresult = (jboolean)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1delHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { jboolean jresult = 0 ; ESLevent *arg1 = (ESLevent *) 0 ; diff --git a/libs/esl/java/org/freeswitch/esl/ESLevent.java b/libs/esl/java/org/freeswitch/esl/ESLevent.java index 5f5b303e8b..d3bbbf88b4 100644 --- a/libs/esl/java/org/freeswitch/esl/ESLevent.java +++ b/libs/esl/java/org/freeswitch/esl/ESLevent.java @@ -78,8 +78,8 @@ public class ESLevent { return eslJNI.ESLevent_setPriority(swigCPtr, this, SWIGTYPE_p_esl_priority_t.getCPtr(priority)); } - public String getHeader(String header_name) { - return eslJNI.ESLevent_getHeader(swigCPtr, this, header_name); + public String getHeader(String header_name, int idx) { + return eslJNI.ESLevent_getHeader(swigCPtr, this, header_name, idx); } public String getBody() { @@ -98,6 +98,14 @@ public class ESLevent { return eslJNI.ESLevent_addHeader(swigCPtr, this, header_name, value); } + public boolean pushHeader(String header_name, String value) { + return eslJNI.ESLevent_pushHeader(swigCPtr, this, header_name, value); + } + + public boolean unshiftHeader(String header_name, String value) { + return eslJNI.ESLevent_unshiftHeader(swigCPtr, this, header_name, value); + } + public boolean delHeader(String header_name) { return eslJNI.ESLevent_delHeader(swigCPtr, this, header_name); } diff --git a/libs/esl/java/org/freeswitch/esl/eslJNI.java b/libs/esl/java/org/freeswitch/esl/eslJNI.java index e6e576f0dc..dfdedff60f 100644 --- a/libs/esl/java/org/freeswitch/esl/eslJNI.java +++ b/libs/esl/java/org/freeswitch/esl/eslJNI.java @@ -21,11 +21,13 @@ class eslJNI { public final static native void delete_ESLevent(long jarg1); public final static native String ESLevent_serialize(long jarg1, ESLevent jarg1_, String jarg2); public final static native boolean ESLevent_setPriority(long jarg1, ESLevent jarg1_, long jarg2); - public final static native String ESLevent_getHeader(long jarg1, ESLevent jarg1_, String jarg2); + public final static native String ESLevent_getHeader(long jarg1, ESLevent jarg1_, String jarg2, int jarg3); public final static native String ESLevent_getBody(long jarg1, ESLevent jarg1_); public final static native String ESLevent_getType(long jarg1, ESLevent jarg1_); public final static native boolean ESLevent_addBody(long jarg1, ESLevent jarg1_, String jarg2); public final static native boolean ESLevent_addHeader(long jarg1, ESLevent jarg1_, String jarg2, String jarg3); + public final static native boolean ESLevent_pushHeader(long jarg1, ESLevent jarg1_, String jarg2, String jarg3); + public final static native boolean ESLevent_unshiftHeader(long jarg1, ESLevent jarg1_, String jarg2, String jarg3); public final static native boolean ESLevent_delHeader(long jarg1, ESLevent jarg1_, String jarg2); public final static native String ESLevent_firstHeader(long jarg1, ESLevent jarg1_); public final static native String ESLevent_nextHeader(long jarg1, ESLevent jarg1_); diff --git a/libs/esl/lua/esl_wrap.cpp b/libs/esl/lua/esl_wrap.cpp index 25fceb7bea..c3ee30811e 100644 --- a/libs/esl/lua/esl_wrap.cpp +++ b/libs/esl/lua/esl_wrap.cpp @@ -1923,18 +1923,23 @@ static int _wrap_ESLevent_getHeader(lua_State* L) { int SWIG_arg = -1; ESLevent *arg1 = (ESLevent *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) -1 ; char *result = 0 ; - SWIG_check_num_args("getHeader",2,2) + SWIG_check_num_args("getHeader",2,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getHeader",1,"ESLevent *"); if(!lua_isstring(L,2)) SWIG_fail_arg("getHeader",2,"char const *"); + if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("getHeader",3,"int"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ESLevent,0))){ SWIG_fail_ptr("ESLevent_getHeader",1,SWIGTYPE_p_ESLevent); } arg2 = (char *)lua_tostring(L, 2); - result = (char *)(arg1)->getHeader((char const *)arg2); + if(lua_gettop(L)>=3){ + arg3 = (int)lua_tonumber(L, 3); + } + result = (char *)(arg1)->getHeader((char const *)arg2,arg3); SWIG_arg=0; lua_pushstring(L,(const char*)result); SWIG_arg++; return SWIG_arg; @@ -2056,6 +2061,68 @@ fail: } +static int _wrap_ESLevent_pushHeader(lua_State* L) { + int SWIG_arg = -1; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + + SWIG_check_num_args("pushHeader",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("pushHeader",1,"ESLevent *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("pushHeader",2,"char const *"); + if(!lua_isstring(L,3)) SWIG_fail_arg("pushHeader",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ESLevent,0))){ + SWIG_fail_ptr("ESLevent_pushHeader",1,SWIGTYPE_p_ESLevent); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3); + SWIG_arg=0; + lua_pushboolean(L,(int)(result==true)); SWIG_arg++; + return SWIG_arg; + + if(0) SWIG_fail; + +fail: + lua_error(L); + return SWIG_arg; +} + + +static int _wrap_ESLevent_unshiftHeader(lua_State* L) { + int SWIG_arg = -1; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + + SWIG_check_num_args("unshiftHeader",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("unshiftHeader",1,"ESLevent *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("unshiftHeader",2,"char const *"); + if(!lua_isstring(L,3)) SWIG_fail_arg("unshiftHeader",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ESLevent,0))){ + SWIG_fail_ptr("ESLevent_unshiftHeader",1,SWIGTYPE_p_ESLevent); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3); + SWIG_arg=0; + lua_pushboolean(L,(int)(result==true)); SWIG_arg++; + return SWIG_arg; + + if(0) SWIG_fail; + +fail: + lua_error(L); + return SWIG_arg; +} + + static int _wrap_ESLevent_delHeader(lua_State* L) { int SWIG_arg = -1; ESLevent *arg1 = (ESLevent *) 0 ; @@ -2146,6 +2213,8 @@ static swig_lua_method swig_ESLevent_methods[] = { {"getType", _wrap_ESLevent_getType}, {"addBody", _wrap_ESLevent_addBody}, {"addHeader", _wrap_ESLevent_addHeader}, + {"pushHeader", _wrap_ESLevent_pushHeader}, + {"unshiftHeader", _wrap_ESLevent_unshiftHeader}, {"delHeader", _wrap_ESLevent_delHeader}, {"firstHeader", _wrap_ESLevent_firstHeader}, {"nextHeader", _wrap_ESLevent_nextHeader}, diff --git a/libs/esl/managed/ESLPINVOKE.cs b/libs/esl/managed/ESLPINVOKE.cs index 1e487895d9..ee15a2b702 100644 --- a/libs/esl/managed/ESLPINVOKE.cs +++ b/libs/esl/managed/ESLPINVOKE.cs @@ -221,7 +221,7 @@ class ESLPINVOKE { 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); + 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); @@ -235,6 +235,12 @@ class ESLPINVOKE { [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); diff --git a/libs/esl/managed/ESLevent.cs b/libs/esl/managed/ESLevent.cs index ab4df67212..65cd24d98c 100644 --- a/libs/esl/managed/ESLevent.cs +++ b/libs/esl/managed/ESLevent.cs @@ -89,8 +89,8 @@ public class ESLevent : IDisposable { return ret; } - public string GetHeader(string header_name) { - string ret = ESLPINVOKE.ESLevent_GetHeader(swigCPtr, header_name); + public string GetHeader(string header_name, int idx) { + string ret = ESLPINVOKE.ESLevent_GetHeader(swigCPtr, header_name, idx); return ret; } @@ -114,6 +114,16 @@ public class ESLevent : IDisposable { 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; diff --git a/libs/esl/managed/esl_wrap.cpp b/libs/esl/managed/esl_wrap.cpp index 4d0e27d261..f07b4b3d3f 100644 --- a/libs/esl/managed/esl_wrap.cpp +++ b/libs/esl/managed/esl_wrap.cpp @@ -436,15 +436,17 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_SetPriority(void * jarg1, vo } -SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_GetHeader(void * jarg1, char * jarg2) { +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; - result = (char *)(arg1)->getHeader((char const *)arg2); + arg3 = (int)jarg3; + result = (char *)(arg1)->getHeader((char const *)arg2,arg3); jresult = SWIG_csharp_string_callback((const char *)result); return jresult; } @@ -504,6 +506,38 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_AddHeader(void * jarg1, char } +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 ; diff --git a/libs/esl/perl/ESL.pm b/libs/esl/perl/ESL.pm index b50ee4a083..b291d002d7 100644 --- a/libs/esl/perl/ESL.pm +++ b/libs/esl/perl/ESL.pm @@ -88,6 +88,8 @@ sub DESTROY { *getType = *ESLc::ESLevent_getType; *addBody = *ESLc::ESLevent_addBody; *addHeader = *ESLc::ESLevent_addHeader; +*pushHeader = *ESLc::ESLevent_pushHeader; +*unshiftHeader = *ESLc::ESLevent_unshiftHeader; *delHeader = *ESLc::ESLevent_delHeader; *firstHeader = *ESLc::ESLevent_firstHeader; *nextHeader = *ESLc::ESLevent_nextHeader; diff --git a/libs/esl/perl/esl_wrap.cpp b/libs/esl/perl/esl_wrap.cpp index ccce4bb6d0..1bc45fa2e1 100644 --- a/libs/esl/perl/esl_wrap.cpp +++ b/libs/esl/perl/esl_wrap.cpp @@ -2285,17 +2285,20 @@ XS(_wrap_ESLevent_getHeader) { { ESLevent *arg1 = (ESLevent *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) -1 ; char *result = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; int argvi = 0; dXSARGS; - if ((items < 2) || (items > 2)) { - SWIG_croak("Usage: ESLevent_getHeader(self,header_name);"); + if ((items < 2) || (items > 3)) { + SWIG_croak("Usage: ESLevent_getHeader(self,header_name,idx);"); } res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); if (!SWIG_IsOK(res1)) { @@ -2307,14 +2310,23 @@ XS(_wrap_ESLevent_getHeader) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_getHeader" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - result = (char *)(arg1)->getHeader((char const *)arg2); + if (items > 2) { + ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ESLevent_getHeader" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } + result = (char *)(arg1)->getHeader((char const *)arg2,arg3); ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ; if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + XSRETURN(argvi); fail: if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + SWIG_croak_null(); } } @@ -2465,6 +2477,106 @@ XS(_wrap_ESLevent_addHeader) { } +XS(_wrap_ESLevent_pushHeader) { + { + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int argvi = 0; + dXSARGS; + + if ((items < 3) || (items > 3)) { + SWIG_croak("Usage: ESLevent_pushHeader(self,header_name,value);"); + } + res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_pushHeader" "', argument " "1"" of type '" "ESLevent *""'"); + } + arg1 = reinterpret_cast< ESLevent * >(argp1); + res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_pushHeader" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ESLevent_pushHeader" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3); + ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ; + + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + XSRETURN(argvi); + fail: + + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + SWIG_croak_null(); + } +} + + +XS(_wrap_ESLevent_unshiftHeader) { + { + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int argvi = 0; + dXSARGS; + + if ((items < 3) || (items > 3)) { + SWIG_croak("Usage: ESLevent_unshiftHeader(self,header_name,value);"); + } + res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_unshiftHeader" "', argument " "1"" of type '" "ESLevent *""'"); + } + arg1 = reinterpret_cast< ESLevent * >(argp1); + res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_unshiftHeader" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ESLevent_unshiftHeader" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3); + ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ; + + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + XSRETURN(argvi); + fail: + + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + SWIG_croak_null(); + } +} + + XS(_wrap_ESLevent_delHeader) { { ESLevent *arg1 = (ESLevent *) 0 ; @@ -3658,6 +3770,8 @@ static swig_command_info swig_commands[] = { {"ESLc::ESLevent_getType", _wrap_ESLevent_getType}, {"ESLc::ESLevent_addBody", _wrap_ESLevent_addBody}, {"ESLc::ESLevent_addHeader", _wrap_ESLevent_addHeader}, +{"ESLc::ESLevent_pushHeader", _wrap_ESLevent_pushHeader}, +{"ESLc::ESLevent_unshiftHeader", _wrap_ESLevent_unshiftHeader}, {"ESLc::ESLevent_delHeader", _wrap_ESLevent_delHeader}, {"ESLc::ESLevent_firstHeader", _wrap_ESLevent_firstHeader}, {"ESLc::ESLevent_nextHeader", _wrap_ESLevent_nextHeader}, diff --git a/libs/esl/php/ESL.php b/libs/esl/php/ESL.php index 70ff62ac0d..0bc8c4e724 100644 --- a/libs/esl/php/ESL.php +++ b/libs/esl/php/ESL.php @@ -76,8 +76,8 @@ class ESLevent { return $r; } - function getHeader($header_name) { - return ESLevent_getHeader($this->_cPtr,$header_name); + function getHeader($header_name,$idx=-1) { + return ESLevent_getHeader($this->_cPtr,$header_name,$idx); } function getBody() { @@ -96,6 +96,14 @@ class ESLevent { return ESLevent_addHeader($this->_cPtr,$header_name,$value); } + function pushHeader($header_name,$value) { + return ESLevent_pushHeader($this->_cPtr,$header_name,$value); + } + + function unshiftHeader($header_name,$value) { + return ESLevent_unshiftHeader($this->_cPtr,$header_name,$value); + } + function delHeader($header_name) { return ESLevent_delHeader($this->_cPtr,$header_name); } diff --git a/libs/esl/php/esl_wrap.cpp b/libs/esl/php/esl_wrap.cpp index c38ea1fa62..9e49c7c080 100644 --- a/libs/esl/php/esl_wrap.cpp +++ b/libs/esl/php/esl_wrap.cpp @@ -1445,13 +1445,16 @@ fail: ZEND_NAMED_FUNCTION(_wrap_ESLevent_getHeader) { ESLevent *arg1 = (ESLevent *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) -1 ; char *result = 0 ; - zval **args[2]; + zval **args[3]; + int arg_count; SWIG_ResetError(); - if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) { - WRONG_PARAM_COUNT; - } + arg_count = ZEND_NUM_ARGS(); + if(arg_count<2 || arg_count>3 || + zend_get_parameters_array_ex(arg_count,args)!=SUCCESS) + WRONG_PARAM_COUNT; { if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_ESLevent, 0) < 0) { @@ -1465,7 +1468,14 @@ ZEND_NAMED_FUNCTION(_wrap_ESLevent_getHeader) { arg2 = (char *) Z_STRVAL_PP(args[1]); /*@SWIG@*/; - result = (char *)(arg1)->getHeader((char const *)arg2); + if(arg_count > 2) { + /*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,7,CONVERT_INT_IN@*/ + convert_to_long_ex(args[2]); + arg3 = (int) Z_LVAL_PP(args[2]); + /*@SWIG@*/; + + } + result = (char *)(arg1)->getHeader((char const *)arg2,arg3); { if(!result) { ZVAL_NULL(return_value); @@ -1612,6 +1622,86 @@ fail: } +ZEND_NAMED_FUNCTION(_wrap_ESLevent_pushHeader) { + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + zval **args[3]; + + SWIG_ResetError(); + if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + { + if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_ESLevent, 0) < 0) { + SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of ESLevent_pushHeader. Expected SWIGTYPE_p_ESLevent"); + } + } + if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL"); + + /*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,26,CONVERT_STRING_IN@*/ + convert_to_string_ex(args[1]); + arg2 = (char *) Z_STRVAL_PP(args[1]); + /*@SWIG@*/; + + + /*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,26,CONVERT_STRING_IN@*/ + convert_to_string_ex(args[2]); + arg3 = (char *) Z_STRVAL_PP(args[2]); + /*@SWIG@*/; + + result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3); + { + ZVAL_BOOL(return_value,(result)?1:0); + } + return; +fail: + zend_error(SWIG_ErrorCode(),SWIG_ErrorMsg()); +} + + +ZEND_NAMED_FUNCTION(_wrap_ESLevent_unshiftHeader) { + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + zval **args[3]; + + SWIG_ResetError(); + if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) { + WRONG_PARAM_COUNT; + } + + { + if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_ESLevent, 0) < 0) { + SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of ESLevent_unshiftHeader. Expected SWIGTYPE_p_ESLevent"); + } + } + if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL"); + + /*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,26,CONVERT_STRING_IN@*/ + convert_to_string_ex(args[1]); + arg2 = (char *) Z_STRVAL_PP(args[1]); + /*@SWIG@*/; + + + /*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,26,CONVERT_STRING_IN@*/ + convert_to_string_ex(args[2]); + arg3 = (char *) Z_STRVAL_PP(args[2]); + /*@SWIG@*/; + + result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3); + { + ZVAL_BOOL(return_value,(result)?1:0); + } + return; +fail: + zend_error(SWIG_ErrorCode(),SWIG_ErrorMsg()); +} + + ZEND_NAMED_FUNCTION(_wrap_ESLevent_delHeader) { ESLevent *arg1 = (ESLevent *) 0 ; char *arg2 = (char *) 0 ; @@ -2547,6 +2637,8 @@ static zend_function_entry ESL_functions[] = { SWIG_ZEND_NAMED_FE(eslevent_gettype,_wrap_ESLevent_getType,NULL) SWIG_ZEND_NAMED_FE(eslevent_addbody,_wrap_ESLevent_addBody,NULL) SWIG_ZEND_NAMED_FE(eslevent_addheader,_wrap_ESLevent_addHeader,NULL) + SWIG_ZEND_NAMED_FE(eslevent_pushheader,_wrap_ESLevent_pushHeader,NULL) + SWIG_ZEND_NAMED_FE(eslevent_unshiftheader,_wrap_ESLevent_unshiftHeader,NULL) SWIG_ZEND_NAMED_FE(eslevent_delheader,_wrap_ESLevent_delHeader,NULL) SWIG_ZEND_NAMED_FE(eslevent_firstheader,_wrap_ESLevent_firstHeader,NULL) SWIG_ZEND_NAMED_FE(eslevent_nextheader,_wrap_ESLevent_nextHeader,NULL) diff --git a/libs/esl/php/php_ESL.h b/libs/esl/php/php_ESL.h index 8c9dede981..eceac5dd70 100644 --- a/libs/esl/php/php_ESL.h +++ b/libs/esl/php/php_ESL.h @@ -46,6 +46,8 @@ ZEND_NAMED_FUNCTION(_wrap_ESLevent_getBody); ZEND_NAMED_FUNCTION(_wrap_ESLevent_getType); ZEND_NAMED_FUNCTION(_wrap_ESLevent_addBody); ZEND_NAMED_FUNCTION(_wrap_ESLevent_addHeader); +ZEND_NAMED_FUNCTION(_wrap_ESLevent_pushHeader); +ZEND_NAMED_FUNCTION(_wrap_ESLevent_unshiftHeader); ZEND_NAMED_FUNCTION(_wrap_ESLevent_delHeader); ZEND_NAMED_FUNCTION(_wrap_ESLevent_firstHeader); ZEND_NAMED_FUNCTION(_wrap_ESLevent_nextHeader); diff --git a/libs/esl/python/ESL.py b/libs/esl/python/ESL.py index 8e52ea303f..6bb4216692 100644 --- a/libs/esl/python/ESL.py +++ b/libs/esl/python/ESL.py @@ -59,6 +59,8 @@ class ESLevent: def getType(*args): return apply(_ESL.ESLevent_getType, args) def addBody(*args): return apply(_ESL.ESLevent_addBody, args) def addHeader(*args): return apply(_ESL.ESLevent_addHeader, args) + def pushHeader(*args): return apply(_ESL.ESLevent_pushHeader, args) + def unshiftHeader(*args): return apply(_ESL.ESLevent_unshiftHeader, args) def delHeader(*args): return apply(_ESL.ESLevent_delHeader, args) def firstHeader(*args): return apply(_ESL.ESLevent_firstHeader, args) def nextHeader(*args): return apply(_ESL.ESLevent_nextHeader, args) diff --git a/libs/esl/python/esl_wrap.cpp b/libs/esl/python/esl_wrap.cpp index 3ef587561c..90f6ed2c79 100644 --- a/libs/esl/python/esl_wrap.cpp +++ b/libs/esl/python/esl_wrap.cpp @@ -3373,17 +3373,21 @@ SWIGINTERN PyObject *_wrap_ESLevent_getHeader(PyObject *SWIGUNUSEDPARM(self), Py PyObject *resultobj = 0; ESLevent *arg1 = (ESLevent *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) -1 ; char *result = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; PyObject * obj0 = 0 ; PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; SWIG_PYTHON_THREAD_BEGIN_BLOCK; - if (!PyArg_ParseTuple(args,(char *)"OO:ESLevent_getHeader",&obj0,&obj1)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"OO|O:ESLevent_getHeader",&obj0,&obj1,&obj2)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_getHeader" "', argument " "1"" of type '" "ESLevent *""'"); @@ -3394,9 +3398,16 @@ SWIGINTERN PyObject *_wrap_ESLevent_getHeader(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_getHeader" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (obj2) { + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ESLevent_getHeader" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { SWIG_PYTHON_THREAD_BEGIN_ALLOW; - result = (char *)(arg1)->getHeader((char const *)arg2); + result = (char *)(arg1)->getHeader((char const *)arg2,arg3); SWIG_PYTHON_THREAD_END_ALLOW; } resultobj = SWIG_FromCharPtr((const char *)result); @@ -3562,6 +3573,112 @@ fail: } +SWIGINTERN PyObject *_wrap_ESLevent_pushHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (!PyArg_ParseTuple(args,(char *)"OOO:ESLevent_pushHeader",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_pushHeader" "', argument " "1"" of type '" "ESLevent *""'"); + } + arg1 = reinterpret_cast< ESLevent * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_pushHeader" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ESLevent_pushHeader" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + SWIG_PYTHON_THREAD_END_BLOCK; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + SWIG_PYTHON_THREAD_END_BLOCK; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ESLevent_unshiftHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (!PyArg_ParseTuple(args,(char *)"OOO:ESLevent_unshiftHeader",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_unshiftHeader" "', argument " "1"" of type '" "ESLevent *""'"); + } + arg1 = reinterpret_cast< ESLevent * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_unshiftHeader" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ESLevent_unshiftHeader" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + SWIG_PYTHON_THREAD_BEGIN_ALLOW; + result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3); + SWIG_PYTHON_THREAD_END_ALLOW; + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + SWIG_PYTHON_THREAD_END_BLOCK; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + SWIG_PYTHON_THREAD_END_BLOCK; + return NULL; +} + + SWIGINTERN PyObject *_wrap_ESLevent_delHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; ESLevent *arg1 = (ESLevent *) 0 ; @@ -4726,6 +4843,8 @@ static PyMethodDef SwigMethods[] = { { (char *)"ESLevent_getType", _wrap_ESLevent_getType, METH_VARARGS, NULL}, { (char *)"ESLevent_addBody", _wrap_ESLevent_addBody, METH_VARARGS, NULL}, { (char *)"ESLevent_addHeader", _wrap_ESLevent_addHeader, METH_VARARGS, NULL}, + { (char *)"ESLevent_pushHeader", _wrap_ESLevent_pushHeader, METH_VARARGS, NULL}, + { (char *)"ESLevent_unshiftHeader", _wrap_ESLevent_unshiftHeader, METH_VARARGS, NULL}, { (char *)"ESLevent_delHeader", _wrap_ESLevent_delHeader, METH_VARARGS, NULL}, { (char *)"ESLevent_firstHeader", _wrap_ESLevent_firstHeader, METH_VARARGS, NULL}, { (char *)"ESLevent_nextHeader", _wrap_ESLevent_nextHeader, METH_VARARGS, NULL}, diff --git a/libs/esl/ruby/esl_wrap.cpp b/libs/esl/ruby/esl_wrap.cpp index 3769b5bc24..5afce64cf9 100644 --- a/libs/esl/ruby/esl_wrap.cpp +++ b/libs/esl/ruby/esl_wrap.cpp @@ -2396,15 +2396,18 @@ SWIGINTERN VALUE _wrap_ESLevent_getHeader(int argc, VALUE *argv, VALUE self) { ESLevent *arg1 = (ESLevent *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) -1 ; char *result = 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; VALUE vresult = Qnil; - if ((argc < 1) || (argc > 1)) { + if ((argc < 1) || (argc > 2)) { rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail; } res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); @@ -2417,7 +2420,14 @@ _wrap_ESLevent_getHeader(int argc, VALUE *argv, VALUE self) { SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","getHeader", 2, argv[0] )); } arg2 = reinterpret_cast< char * >(buf2); - result = (char *)(arg1)->getHeader((char const *)arg2); + if (argc > 1) { + ecode3 = SWIG_AsVal_int(argv[1], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","getHeader", 3, argv[1] )); + } + arg3 = static_cast< int >(val3); + } + result = (char *)(arg1)->getHeader((char const *)arg2,arg3); vresult = SWIG_FromCharPtr((const char *)result); if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return vresult; @@ -2556,6 +2566,98 @@ fail: } +SWIGINTERN VALUE +_wrap_ESLevent_pushHeader(int argc, VALUE *argv, VALUE self) { + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ESLevent *","pushHeader", 1, self )); + } + arg1 = reinterpret_cast< ESLevent * >(argp1); + res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pushHeader", 2, argv[0] )); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pushHeader", 3, argv[1] )); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3); + vresult = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return vresult; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return Qnil; +} + + +SWIGINTERN VALUE +_wrap_ESLevent_unshiftHeader(int argc, VALUE *argv, VALUE self) { + ESLevent *arg1 = (ESLevent *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool result; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) { + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail; + } + res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ESLevent *","unshiftHeader", 1, self )); + } + arg1 = reinterpret_cast< ESLevent * >(argp1); + res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","unshiftHeader", 2, argv[0] )); + } + arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","unshiftHeader", 3, argv[1] )); + } + arg3 = reinterpret_cast< char * >(buf3); + result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3); + vresult = SWIG_From_bool(static_cast< bool >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return vresult; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return Qnil; +} + + SWIGINTERN VALUE _wrap_ESLevent_delHeader(int argc, VALUE *argv, VALUE self) { ESLevent *arg1 = (ESLevent *) 0 ; @@ -3835,6 +3937,8 @@ SWIGEXPORT void Init_ESL(void) { rb_define_method(cESLevent.klass, "getType", VALUEFUNC(_wrap_ESLevent_getType), -1); rb_define_method(cESLevent.klass, "addBody", VALUEFUNC(_wrap_ESLevent_addBody), -1); rb_define_method(cESLevent.klass, "addHeader", VALUEFUNC(_wrap_ESLevent_addHeader), -1); + rb_define_method(cESLevent.klass, "pushHeader", VALUEFUNC(_wrap_ESLevent_pushHeader), -1); + rb_define_method(cESLevent.klass, "unshiftHeader", VALUEFUNC(_wrap_ESLevent_unshiftHeader), -1); rb_define_method(cESLevent.klass, "delHeader", VALUEFUNC(_wrap_ESLevent_delHeader), -1); rb_define_method(cESLevent.klass, "firstHeader", VALUEFUNC(_wrap_ESLevent_firstHeader), -1); rb_define_method(cESLevent.klass, "nextHeader", VALUEFUNC(_wrap_ESLevent_nextHeader), -1); diff --git a/libs/esl/src/esl_oop.cpp b/libs/esl/src/esl_oop.cpp index 8ea3dfa4d3..0c4bbd6f90 100644 --- a/libs/esl/src/esl_oop.cpp +++ b/libs/esl/src/esl_oop.cpp @@ -390,12 +390,12 @@ bool ESLevent::setPriority(esl_priority_t priority) return false; } -const char *ESLevent::getHeader(const char *header_name) +const char *ESLevent::getHeader(const char *header_name, int idx) { this_check(""); if (event) { - return esl_event_get_header(event, header_name); + return esl_event_get_header_idx(event, header_name, idx); } else { esl_log(ESL_LOG_ERROR, "Trying to getHeader an event that does not exist!\n"); } @@ -415,6 +415,32 @@ bool ESLevent::addHeader(const char *header_name, const char *value) return false; } +bool ESLevent::pushHeader(const char *header_name, const char *value) +{ + this_check(false); + + if (event) { + return esl_event_add_header_string(event, ESL_STACK_PUSH, header_name, value) == ESL_SUCCESS ? true : false; + } else { + esl_log(ESL_LOG_ERROR, "Trying to addHeader an event that does not exist!\n"); + } + + return false; +} + +bool ESLevent::unshiftHeader(const char *header_name, const char *value) +{ + this_check(false); + + if (event) { + return esl_event_add_header_string(event, ESL_STACK_UNSHIFT, header_name, value) == ESL_SUCCESS ? true : false; + } else { + esl_log(ESL_LOG_ERROR, "Trying to addHeader an event that does not exist!\n"); + } + + return false; +} + bool ESLevent::delHeader(const char *header_name) { this_check(false); diff --git a/libs/esl/src/include/esl_oop.h b/libs/esl/src/include/esl_oop.h index 3947d0cfb7..947fe453d7 100644 --- a/libs/esl/src/include/esl_oop.h +++ b/libs/esl/src/include/esl_oop.h @@ -56,11 +56,13 @@ class ESLevent { virtual ~ESLevent(); const char *serialize(const char *format = NULL); bool setPriority(esl_priority_t priority = ESL_PRIORITY_NORMAL); - const char *getHeader(const char *header_name); + const char *getHeader(const char *header_name, int idx = -1); char *getBody(void); const char *getType(void); bool addBody(const char *value); bool addHeader(const char *header_name, const char *value); + bool pushHeader(const char *header_name, const char *value); + bool unshiftHeader(const char *header_name, const char *value); bool delHeader(const char *header_name); const char *firstHeader(void); const char *nextHeader(void);