Text archives Help

---

Author: bigler
Date: Fri Feb 22 09:53:20 2008
New Revision: 2108

Modified:
   trunk/Core/Util/Callback.h
   trunk/Core/Util/genCallbacks.py
Log:
Core/Util/Callback.h

  Updates with changes to genCallbacks.py

Core/Util/genCallbacks.py

  Refactored some code.

  Started the CallbackHelpers.h file.


Modified: trunk/Core/Util/Callback.h
==============================================================================
--- trunk/Core/Util/Callback.h  (original)
+++ trunk/Core/Util/Callback.h  Fri Feb 22 09:53:20 2008
@@ -28,84 +28,84 @@
     //////////////////////////////
     // Global functions or static class member functions
 
-    // 0 call time args --- 0 creating time args
+    // 0 call time args --- 0 creation time args
     static
     CallbackBase_0Data*
     create(void (*pmf)()) {
       return new Callback_Static_0Data_0Arg(pmf);
     }
 
-    // 0 call time args --- 1 creating time args
+    // 0 call time args --- 1 creation time args
     template<typename Arg1> static
     CallbackBase_0Data*
     create(void (*pmf)(Arg1), Arg1 arg1) {
       return new Callback_Static_0Data_1Arg<Arg1>(pmf, arg1);
     }
 
-    // 0 call time args --- 2 creating time args
+    // 0 call time args --- 2 creation time args
     template<typename Arg1, typename Arg2> static
     CallbackBase_0Data*
     create(void (*pmf)(Arg1, Arg2), Arg1 arg1, Arg2 arg2) {
       return new Callback_Static_0Data_2Arg<Arg1, Arg2>(pmf, arg1, arg2);
     }
 
-    // 0 call time args --- 5 creating time args
+    // 0 call time args --- 5 creation time args
     template<typename Arg1, typename Arg2, typename Arg3, typename Arg4, 
typename Arg5> static
     CallbackBase_0Data*
     create(void (*pmf)(Arg1, Arg2, Arg3, Arg4, Arg5), Arg1 arg1, Arg2 arg2, 
Arg3 arg3, Arg4 arg4, Arg5 arg5) {
       return new Callback_Static_0Data_5Arg<Arg1, Arg2, Arg3, Arg4, 
Arg5>(pmf, arg1, arg2, arg3, arg4, arg5);
     }
 
-    // 1 call time args --- 0 creating time args
+    // 1 call time args --- 0 creation time args
     template<typename Data1> static
     CallbackBase_1Data<Data1>*
     create(void (*pmf)(Data1)) {
       return new Callback_Static_1Data_0Arg<Data1>(pmf);
     }
 
-    // 1 call time args --- 1 creating time args
+    // 1 call time args --- 1 creation time args
     template<typename Data1, typename Arg1> static
     CallbackBase_1Data<Data1>*
     create(void (*pmf)(Data1, Arg1), Arg1 arg1) {
       return new Callback_Static_1Data_1Arg<Data1, Arg1>(pmf, arg1);
     }
 
-    // 1 call time args --- 2 creating time args
+    // 1 call time args --- 2 creation time args
     template<typename Data1, typename Arg1, typename Arg2> static
     CallbackBase_1Data<Data1>*
     create(void (*pmf)(Data1, Arg1, Arg2), Arg1 arg1, Arg2 arg2) {
       return new Callback_Static_1Data_2Arg<Data1, Arg1, Arg2>(pmf, arg1, 
arg2);
     }
 
-    // 2 call time args --- 0 creating time args
+    // 2 call time args --- 0 creation time args
     template<typename Data1, typename Data2> static
     CallbackBase_2Data<Data1, Data2>*
     create(void (*pmf)(Data1, Data2)) {
       return new Callback_Static_2Data_0Arg<Data1, Data2>(pmf);
     }
 
-    // 2 call time args --- 2 creating time args
+    // 2 call time args --- 2 creation time args
     template<typename Data1, typename Data2, typename Arg1, typename Arg2> 
static
     CallbackBase_2Data<Data1, Data2>*
     create(void (*pmf)(Data1, Data2, Arg1, Arg2), Arg1 arg1, Arg2 arg2) {
       return new Callback_Static_2Data_2Arg<Data1, Data2, Arg1, Arg2>(pmf, 
arg1, arg2);
     }
 
-    // 3 call time args --- 1 creating time args
+    // 3 call time args --- 1 creation time args
     template<typename Data1, typename Data2, typename Data3, typename Arg1> 
static
     CallbackBase_3Data<Data1, Data2, Data3>*
     create(void (*pmf)(Data1, Data2, Data3, Arg1), Arg1 arg1) {
       return new Callback_Static_3Data_1Arg<Data1, Data2, Data3, Arg1>(pmf, 
arg1);
     }
 
-    // 3 call time args --- 2 creating time args
+    // 3 call time args --- 2 creation time args
     template<typename Data1, typename Data2, typename Data3, typename Arg1, 
typename Arg2> static
     CallbackBase_3Data<Data1, Data2, Data3>*
     create(void (*pmf)(Data1, Data2, Data3, Arg1, Arg2), Arg1 arg1, Arg2 
arg2) {
       return new Callback_Static_3Data_2Arg<Data1, Data2, Data3, Arg1, 
Arg2>(pmf, arg1, arg2);
     }
 
-    // 4 call time args --- 2 creating time args
+    // 4 call time args --- 2 creation time args
     template<typename Data1, typename Data2, typename Data3, typename Data4, 
typename Arg1, typename Arg2> static
     CallbackBase_4Data<Data1, Data2, Data3, Data4>*
     create(void (*pmf)(Data1, Data2, Data3, Data4, Arg1, Arg2), Arg1 arg1, 
Arg2 arg2) {

Modified: trunk/Core/Util/genCallbacks.py
==============================================================================
--- trunk/Core/Util/genCallbacks.py     (original)
+++ trunk/Core/Util/genCallbacks.py     Fri Feb 22 09:53:20 2008
@@ -1,5 +1,41 @@
 #!/usr/bin/python
 
+# (fset 'callback-write-wrap
+#    [tab ?s ?e ?l ?f ?. ?w ?r ?i ?t ?e ?( ?\" ?\C-e ?\" ?) ?\C-a ?\C-n])
+
+def pair(t1, t2, seperator=" "):
+    '''
+    Performs a pairwise addition of tuple elements with a separator 
inbetween.
+
+    pair(('a', 'b'), ('c', 'd')) => ('a c', 'b d')
+    '''
+    return map(lambda a,b: "%s%s%s" % (a,seperator,b), t1, t2)
+
+def format(args, begin_seperator = "", prefix = "", seperator = ","):
+    '''
+    Returns a string made up of this expression:
+
+    [begin_seperator][prefix][args[0][[seperator][prefix][args[1]]][...]
+
+    The idea is you can prefix each argument, specify the separator between
+    arguments, and an optional beginning string.  If the tuple is empty, you 
get
+    back "".
+
+    '''
+    result = ""
+    # if value is "" you get "", otherwise you get ("%s " % value)
+    begin_seperator_text = begin_seperator and "%s " % begin_seperator
+    #
+    prefix_text = prefix and "%s " % prefix
+    #
+    seperator_text = seperator and "%s " % seperator
+    #
+    for arg in args[:1]:
+        result += "%s%s%s" % (begin_seperator, prefix_text, arg)
+    for arg in args[1:]:
+        result += "%s%s%s" % (seperator_text, prefix_text, arg)
+    return result
+
 class Function:
     def __init__(self, num_call_time_args = 0, num_creation_time_args = 0):
         self.num_call_time_args = num_call_time_args
@@ -9,73 +45,56 @@
         arg_list = self.typeList()
         if (len(arg_list) == 0):
             return ""
-        return "template<" + self.format(arg_list, prefix="typename") + "> "
+        return "template<" + format(arg_list, prefix="typename") + "> "
 
-    def baseName(self):
+    def baseName(self, withTemplate=False):
         base = "CallbackBase_%dData" % self.num_call_time_args
-        if (self.num_call_time_args > 0):
-            base+= "<" + self.format(self.dataList()) + ">"
+        if (withTemplate and self.num_call_time_args > 0):
+            base+= "<" + format(self.dataList()) + ">"
         return base
 
-    def staticClassName(self):
+    def staticClassName(self, withTemplate=False):
         base = "Callback_Static_%dData_%dArg" % (self.num_call_time_args, 
self.num_creation_time_args)
         type_list = self.typeList()
-        if (len(type_list) > 0):
-            base += "<" + self.format(type_list) + ">"
+        if (withTemplate and len(type_list) > 0):
+            base += "<" + format(type_list) + ">"
         return base
 
-    def className(self, constant=False):
+    def className(self, constant=False, withTemplate=False):
         if (constant):
             constant_text = "_const"
         else:
             constant_text = ""
-        base = "Callback_%dData_%dArg%s<T" % (self.num_call_time_args, 
self.num_creation_time_args, constant_text)
-        type_list = self.typeList()
-        base += self.format(type_list, begin_seperator=", ") + ">"
+        base = "Callback_%dData_%dArg%s" % (self.num_call_time_args, 
self.num_creation_time_args, constant_text)
+        if (withTemplate):
+            type_list = self.typeList()
+            base += "<T" + format(type_list, begin_seperator=", ") + ">"
         return base
 
     def typeList(self):
         return self.dataList() + self.argList()
 
-    def dataList(self):
+    def dataList(self, prefix="Data"):
         list = []
         for arg in range(1, self.num_call_time_args+1):
-            list.append("Data%d" % arg)
+            list.append("%s%d" % (prefix, arg))
         return tuple(list)
 
-    def argList(self):
+    def argList(self, prefix="Arg"):
         list = []
         for arg in range(1, self.num_creation_time_args+1):
-            list.append("Arg%d" % arg)
+            list.append("%s%d" %(prefix,arg))
         return tuple(list)
 
     def functionArgList(self):
-        result = ""
-        for arg in range(1, self.num_creation_time_args+1):
-            result += ", Arg%d arg%d" % (arg, arg)
-        return result
+        return format(pair(self.argList(prefix="Arg"), 
self.argList(prefix="arg")),
+                           begin_seperator=", ")
 
     def functionCallCreateList(self):
-        result = ""
-        for arg in range(1, self.num_creation_time_args+1):
-            result += ", arg%d" % arg
-        return result
-
-    def format(self, args, begin_seperator = "", prefix = "", seperator = 
","):
-        result = ""
-        # if value is "" you get "", otherwise you get ("%s " % value)
-        begin_seperator_text = begin_seperator and "%s " % begin_seperator
-        #
-        prefix_text = prefix and "%s " % prefix
-        #
-        seperator_text = seperator and "%s " % seperator
-        #
-        for arg in args[:1]:
-            result += "%s%s%s" % (begin_seperator, prefix_text, arg)
-        for arg in args[1:]:
-            result += "%s%s%s" % (seperator_text, prefix_text, arg)
-        return result
+        return format(self.argList(prefix="arg"), begin_seperator=", ")
 
+    def callArgList(self):
+        return format(pair(self.dataList(prefix="Data"), 
self.dataList(prefix="data")))
 
 class SourceFile:
     def __init__(self, filename):
@@ -160,12 +179,12 @@
         for function in functions:
             num_call_time_args = function.num_call_time_args
             num_creation_time_args = function.num_creation_time_args
-            self.write("// %d call time args --- %d creating time args" % 
(num_call_time_args, num_creation_time_args))
+            self.write("// %d call time args --- %d creation time args" % 
(num_call_time_args, num_creation_time_args))
             self.write(function.templateParameter() + "static")
-            self.write(function.baseName() + "*")
-            self.write("create(void (*pmf)(" + 
function.format(function.typeList()) + ")" + function.functionArgList() + ") 
{")
+            self.write(function.baseName(withTemplate=True) + "*")
+            self.write("create(void (*pmf)(" + format(function.typeList()) + 
")" + function.functionArgList() + ") {")
             self.indent()
-            self.write("return new " + function.staticClassName() + "(pmf" + 
function.functionCallCreateList() + ");")
+            self.write("return new " + 
function.staticClassName(withTemplate=True) + "(pmf" + 
function.functionCallCreateList() + ");")
             self.unindent()
             self.write("}")
             self.write("")
@@ -184,17 +203,116 @@
             if (constant):
                 self.write("#ifndef SWIG // For now these const versions 
won't compile in swig", indent_ammount=0)
             self.write("// %d call time args --- %d creating time args" % 
(num_call_time_args, num_creation_time_args))
-            self.write("template<class T" + 
function.format(function.typeList(), begin_seperator=", ", prefix="typename") 
+ "> static")
-            self.write(function.baseName() + "*")
-            self.write("create(T* ptr, void (T::*pmf)(" + 
function.format(function.typeList()) + ")" + constant_text + 
function.functionArgList() + ") {")
+            self.write("template<class T" + format(function.typeList(), 
begin_seperator=", ", prefix="typename") + "> static")
+            self.write(function.baseName(withTemplate=True) + "*")
+            self.write("create(T* ptr, void (T::*pmf)(" + 
format(function.typeList()) + ")" + constant_text + 
function.functionArgList() + ") {")
             self.indent()
-            self.write("return new " + function.className(constant) + "(ptr, 
pmf" + function.functionCallCreateList() + ");")
+            self.write("return new " + function.className(constant, 
withTemplate=True) + "(ptr, pmf" + function.functionCallCreateList() + ");")
             self.unindent()
             self.write("}")
             if (constant):
                 self.write("#endif // #ifndef SWIG", indent_ammount=0)
             self.write("")
 
+class CallbackHelpersH (SourceFile):
+    def __init__(self, filename = "test-CallbackHelpers.h"):
+        SourceFile.__init__(self, filename)
+        self.writtenClasses = []
+
+    def writeStart(self):
+        self.write("")
+        self.write("#ifndef Manta_Interface_CallbackHelpers_h")
+        self.write("#define Manta_Interface_CallbackHelpers_h")
+        self.write("")
+        self.write("#include <Core/Util/CallbackHandle.h>")
+        self.write("")
+        self.write("// You should not use these directly - use 
Callback::create instead")
+        self.write("namespace Manta {")
+        self.indent()
+
+    def writeBaseClasses(self, functions):
+        self.write("/" * 30)
+        self.write("// Base classes that can be used by both the static and 
non-static")
+        self.write("// Callback classes.")
+        self.write("//")
+        self.write("")
+
+        for function in functions:
+            class_name = function.baseName(withTemplate=False)
+            if (class_name in self.writtenClasses):
+                # Already processed this one
+                continue
+            else:
+                # Add it to our list
+                self.writtenClasses.append(class_name)
+            self.write("// %d call time args" % function.num_call_time_args)
+            data_list = function.dataList()
+            if (len(data_list) > 0):
+                self.write("template<%s>" % format(data_list, 
prefix="typename"))
+            self.write("class %s : public CallbackHandle {" % class_name)
+            self.write("public:")
+            self.indent()
+            self.write("%s()" % class_name)
+            self.write("{")
+            self.write("}")
+            self.write("virtual ~%s()" % class_name)
+            self.write("{")
+            self.write("}")
+            self.write("virtual void call(%s) = 0;" % function.callArgList())
+            self.unindent()
+            self.write("private:")
+            self.indent()
+            self.write("%s(const %s&);" % (class_name, class_name))
+            self.write("%s& operator=(const %s&);" % (class_name, 
class_name))
+            self.unindent()
+            self.write("};")
+            self.write("")
+
+    def writeGlobalStaticFunctions(self, functions):
+        self.write("/" * 30)
+        self.write("// Global functions or static class member functions")
+        self.write("//")
+        self.write("")
+
+        for function in functions:
+            class_name = function.staticClassName(withTemplate=False)
+            if (class_name in self.writtenClasses):
+                # Already processed this one
+                continue
+            else:
+                # Add it to our list
+                self.writtenClasses.append(class_name)
+            self.write("// %d call time args --- %d creating time args" % 
(function.num_call_time_args, function.num_creation_time_args))
+            self.write("%s" % function.templateParameter() )
+            self.write("class %s : public %s {" % (class_name, 
function.baseName(withTemplate=True)))
+            self.write("public:")
+            self.indent()
+            self.write("%s(void (*pmf)(%s)%s)" % (class_name, 
format(function.typeList()), function.functionArgList()))
+            self.indent()
+            self.write(": pmf(pmf)%s" % "member_var_initialization" )
+            self.unindent()
+            self.write("{")
+            self.write("}")
+            self.write("virtual ~%s()" % class_name)
+            self.write("{")
+            self.write("}")
+            self.write("virtual void call(%s)" % function.callArgList())
+            self.write("{")
+            self.indent()
+            self.write("pmf(%s);" % format( function.dataList(prefix="data") 
+ function.argList(prefix="arg") ))
+            self.unindent()
+            self.write("}")
+            self.unindent()
+            self.write("private:")
+            self.indent()
+            self.write("void (*pmf)(%s);" % format(function.typeList()))
+            self.write("// member variables")
+            self.unindent()
+            self.write("};")
+            self.write("")
+            
+
+
 
 def addFunctions(functions, num_call_time_args, creation_time_arg_sizes):
     for T in creation_time_arg_sizes:
@@ -229,6 +347,10 @@
     callbackH.writeClassMemberFunctions(const_member_functions, 
constant=True)
     callbackH.writeEnd()
 
+    callbackHelpersH = CallbackHelpersH()
+    callbackHelpersH.writeStart()
+    callbackHelpersH.writeBaseClasses(static_functions + member_functions + 
const_member_functions)
+    callbackHelpersH.writeGlobalStaticFunctions(static_functions)
 
 if __name__ == "__main__":
     main()

---

• [Manta] r2108 - trunk/Core/Util, James Bigler, 02/22/2008

---

Archive powered by MHonArc 2.6.16.