add array manipulation to the wraper code

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 ;

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) {
+  public String getHeader(String header_name, int idx) {
-    return eslJNI.ESLevent_getHeader(swigCPtr, this, header_name);
+    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);
   }

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_);

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}, 

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);
 

libs/esl/managed/ESLevent.cs

@@ -89,8 +89,8 @@ public class ESLevent : IDisposable {
     return ret;
   }
 
-  public string GetHeader(string header_name) {
+  public string GetHeader(string header_name, int idx) {
-    string ret = ESLPINVOKE.ESLevent_GetHeader(swigCPtr, header_name);
+    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;

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 ;

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;

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)) {
+    if ((items < 2) || (items > 3)) {
-      SWIG_croak("Usage: ESLevent_getHeader(self,header_name);");
+      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},

libs/esl/php/ESL.php

@@ -76,8 +76,8 @@ class ESLevent {
 		return $r;
 	}
 
-	function getHeader($header_name) {
+	function getHeader($header_name,$idx=-1) {
-		return ESLevent_getHeader($this->_cPtr,$header_name);
+		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);
 	}

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) {
+  arg_count = ZEND_NUM_ARGS();
-    WRONG_PARAM_COUNT;
+  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)

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);

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)

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},

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);

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);

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);