adds AmDynInvoke pointer to the supported payloads in AmArg.

core/AmArg.cpp

@@ -37,6 +37,7 @@ const char* AmArg::t2str(int type) {
   case AmArg::Double:  return "Double";
   case AmArg::CStr:    return "CStr";
   case AmArg::AObject: return "AObject";
+  case AmArg::ADynInv: return "ADynInv";
   case AmArg::Blob:    return "Blob";
   case AmArg::Array:   return "Array";
   case AmArg::Struct:  return "Struct";
@@ -62,6 +63,7 @@ AmArg& AmArg::operator=(const AmArg& v) {
     case Double: { v_double = v.v_double; } break;
     case CStr:   { v_cstr = strdup(v.v_cstr); } break;
     case AObject:{ v_obj = v.v_obj; } break;
+    case ADynInv:{ v_inv = v.v_inv; } break;
     case Array:  { v_array = new ValueArray(*v.v_array); } break;
     case Struct: { v_struct = new ValueStruct(*v.v_struct); } break;
     case Blob:   {  v_blob = new ArgBlob(*v.v_blob); } break;
@@ -306,6 +308,7 @@ bool operator==(const AmArg& lhs, const AmArg& rhs) {
   case AmArg::Double: { return lhs.v_double == rhs.v_double; } break;
   case AmArg::CStr:   { return !strcmp(lhs.v_cstr,rhs.v_cstr); } break;
   case AmArg::AObject:{ return lhs.v_obj == rhs.v_obj; } break;
+  case AmArg::ADynInv:{ return lhs.v_inv == rhs.v_inv; } break;
   case AmArg::Array:  { return lhs.v_array == rhs.v_array;  } break;
   case AmArg::Struct: { return lhs.v_struct == rhs.v_struct;  } break;
   case AmArg::Blob:   {  return (lhs.v_blob->len == rhs.v_blob->len) &&  
@@ -363,6 +366,7 @@ void AmArg::assertArrayFmt(const char* format) const {
       case 'f': assertArgDouble(get(i)); got+='f'; break;
       case 's': assertArgCStr(get(i)); got+='s'; break;
       case 'o': assertArgAObject(get(i)); got+='o'; break;
+      case 'd': assertArgADynInv(get(i)); got+='d'; break;
       case 'a': assertArgArray(get(i)); got+='a'; break;
       case 'b': assertArgBlob(get(i)); got+='b'; break;
       case 'u': assertArgStruct(get(i)); got+='u'; break;
@@ -415,6 +419,10 @@ string AmArg::print(const AmArg &a) {
       return double2str(a.asDouble());
     case CStr:
       return "'" + string(a.asCStr()) + "'";
+    case AObject:
+      return "<Object>";
+    case ADynInv:
+      return "<DynInv>";
     case Array:
       s = "[";
       for (size_t i = 0; i < a.size(); i ++)

core/AmArg.h

@@ -49,11 +49,13 @@ class ArgObject {
   virtual ~ArgObject() { }
 };
 
-struct ArgBlob {  char* data;
+struct ArgBlob {  
+
+  char* data;
   int   len;
   
-ArgBlob() 
-: data(NULL),len(0)
+  ArgBlob() 
+  : data(NULL),len(0)
   {  
   }
 
@@ -74,6 +76,8 @@ ArgBlob()
   ~ArgBlob() { if (data) free(data); }
 };
 
+class AmDynInvoke;
+
 /** \brief variable type argument for DynInvoke APIs */
 class AmArg
 : public ArgObject
@@ -87,7 +91,8 @@ class AmArg
     Bool,
     Double,
     CStr,
-    AObject,		// for passing pointers to objects not owned by AmArg
+    AObject, // pointer to an object not owned by AmArg
+    ADynInv, // pointer to a AmDynInvoke (useful for call backs)
     Blob,
     
     Array,
@@ -116,6 +121,7 @@ class AmArg
     double         v_double;
     const char*    v_cstr;
     ArgObject*     v_obj;
+    AmDynInvoke*   v_inv;
     ArgBlob*       v_blob;
     ValueArray*    v_array;
     ValueStruct*   v_struct;
@@ -169,6 +175,11 @@ class AmArg
     v_obj(v) 
    { }
 
+  AmArg(AmDynInvoke* v) 
+    : type(ADynInv),
+    v_inv(v) 
+   { }
+
   // convenience constructors
   AmArg(vector<std::string>& v);
   AmArg(const vector<int>& v );
@@ -196,6 +207,7 @@ class AmArg
 #define isArgBool(a) (AmArg::Bool == a.getType())
 #define isArgCStr(a) (AmArg::CStr == a.getType())
 #define isArgAObject(a) (AmArg::AObject == a.getType())
+#define isArgADynInv(a) (AmArg::ADynInv == a.getType())
 #define isArgBlob(a) (AmArg::Blob == a.getType())
 
 #define _THROW_TYPE_MISMATCH(exp,got) \
@@ -222,6 +234,9 @@ class AmArg
 #define assertArgAObject(a)			\
   if (!isArgAObject(a))				\
 	_THROW_TYPE_MISMATCH(AObject,a);
+#define assertArgADynInv(a)			\
+  if (!isArgADynInv(a))				\
+	_THROW_TYPE_MISMATCH(ADynInv,a);
 #define assertArgBlob(a)			\
   if (!isArgBlob(a))				\
 	_THROW_TYPE_MISMATCH(Blob,a);
@@ -240,6 +255,7 @@ class AmArg
   double      asDouble() const { return v_double; }
   const char* asCStr()   const { return v_cstr; }
   ArgObject*  asObject() const { return v_obj; }
+  AmDynInvoke* asDynInv() const { return v_inv; }
   ArgBlob*    asBlob()   const { return v_blob; }
   ValueStruct* asStruct() const { return v_struct; }
 
@@ -304,6 +320,7 @@ class AmArg
    *   f  - double
    *   s  - cstr
    *   o  - object
+   *   d  - dyninvoke
    *   b  - blob
    *   a  - array
    *   u  - struct