Method and StaticMethod now inherit from MethodBase - much better

wrap/Method.cpp

@@ -32,7 +32,7 @@ using namespace wrap;
 bool Method::addOverload(Str name, const ArgumentList& args,
     const ReturnValue& retVal, bool is_const, const Qualified& instName,
     bool verbose) {
-  bool first = StaticMethod::addOverload(name, args, retVal, instName, verbose);
+  bool first = MethodBase::addOverload(name, args, retVal, instName, verbose);
   if (first)
     is_const_ = is_const;
   else if (is_const && !is_const_)

wrap/Method.h

@@ -18,12 +18,12 @@
 
 #pragma once
 
-#include "StaticMethod.h"
+#include "MethodBase.h"
 
 namespace wrap {
 
 /// Method class
-class Method: public StaticMethod {
+class Method: public MethodBase {
 
   bool is_const_;
 

wrap/MethodBase.cpp

@@ -0,0 +1,145 @@
+/* ----------------------------------------------------------------------------
+
+ * GTSAM Copyright 2010, Georgia Tech Research Corporation, 
+ * Atlanta, Georgia 30332-0415
+ * All Rights Reserved
+ * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
+
+ * See LICENSE for the license information
+
+ * -------------------------------------------------------------------------- */
+
+/**
+ * @file MethodBase.ccp
+ * @author Frank Dellaert
+ * @author Andrew Melim
+ * @author Richard Roberts
+ **/
+
+#include "Method.h"
+#include "utilities.h"
+
+#include <boost/foreach.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
+
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+using namespace wrap;
+
+/* ************************************************************************* */
+void MethodBase::proxy_wrapper_fragments(FileWriter& proxyFile,
+    FileWriter& wrapperFile, Str cppClassName, Str matlabQualName,
+    Str matlabUniqueName, Str wrapperName,
+    const TypeAttributesTable& typeAttributes,
+    vector<string>& functionNames) const {
+
+  // emit header, e.g., function varargout = templatedMethod(this, varargin)
+  proxy_header(proxyFile);
+
+  // Emit comments for documentation
+  string up_name = boost::to_upper_copy(matlabName());
+  proxyFile.oss << "      % " << up_name << " usage: ";
+  usage_fragment(proxyFile, matlabName());
+
+  // Emit URL to Doxygen page
+  proxyFile.oss << "      % "
+      << "Doxygen can be found at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html"
+      << endl;
+
+  // Handle special case of single overload with all numeric arguments
+  if (nrOverloads() == 1 && argumentList(0).allScalar()) {
+    // Output proxy matlab code
+    // TODO: document why is it OK to not check arguments in this case
+    proxyFile.oss << "      ";
+    const int id = (int) functionNames.size();
+    argumentList(0).emit_call(proxyFile, returnValue(0), wrapperName, id,
+        isStatic());
+
+    // Output C++ wrapper code
+    const string wrapFunctionName = wrapper_fragment(wrapperFile, cppClassName,
+        matlabUniqueName, 0, id, typeAttributes, templateArgValue_);
+
+    // Add to function list
+    functionNames.push_back(wrapFunctionName);
+  } else {
+    // Check arguments for all overloads
+    for (size_t i = 0; i < nrOverloads(); ++i) {
+
+      // Output proxy matlab code
+      proxyFile.oss << "      " << (i == 0 ? "" : "else");
+      const int id = (int) functionNames.size();
+      argumentList(i).emit_conditional_call(proxyFile, returnValue(i),
+          wrapperName, id, isStatic());
+
+      // Output C++ wrapper code
+      const string wrapFunctionName = wrapper_fragment(wrapperFile,
+          cppClassName, matlabUniqueName, i, id, typeAttributes,
+          templateArgValue_);
+
+      // Add to function list
+      functionNames.push_back(wrapFunctionName);
+    }
+    proxyFile.oss << "      else\n";
+    proxyFile.oss
+        << "        error('Arguments do not match any overload of function "
+        << matlabQualName << "." << name_ << "');" << endl;
+    proxyFile.oss << "      end\n";
+  }
+
+  proxyFile.oss << "    end\n";
+}
+
+/* ************************************************************************* */
+string MethodBase::wrapper_fragment(FileWriter& wrapperFile, Str cppClassName,
+    Str matlabUniqueName, int overload, int id,
+    const TypeAttributesTable& typeAttributes,
+    const Qualified& instName) const {
+
+  // generate code
+
+  const string wrapFunctionName = matlabUniqueName + "_" + name_ + "_"
+      + boost::lexical_cast<string>(id);
+
+  const ArgumentList& args = argumentList(overload);
+  const ReturnValue& returnVal = returnValue(overload);
+
+  // call
+  wrapperFile.oss << "void " << wrapFunctionName
+      << "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n";
+  // start
+  wrapperFile.oss << "{\n";
+
+  returnVal.wrapTypeUnwrap(wrapperFile);
+
+  wrapperFile.oss << "  typedef boost::shared_ptr<" << cppClassName
+      << "> Shared;" << endl;
+
+  // get call
+  // for static methods: cppClassName::staticMethod<TemplateVal>
+  // for instance methods: obj->instanceMethod<TemplateVal>
+  string expanded = wrapper_call(wrapperFile, cppClassName, matlabUniqueName,
+      args, returnVal, typeAttributes, instName);
+
+  expanded += ("(" + args.names() + ")");
+  if (returnVal.type1.name != "void")
+    returnVal.wrap_result(expanded, wrapperFile, typeAttributes);
+  else
+    wrapperFile.oss << "  " + expanded + ";\n";
+
+  // finish
+  wrapperFile.oss << "}\n";
+
+  return wrapFunctionName;
+}
+
+/* ************************************************************************* */
+void MethodBase::python_wrapper(FileWriter& wrapperFile,
+    Str className) const {
+  wrapperFile.oss << "  .def(\"" << name_ << "\", &" << className << "::" << name_
+      << ");\n";
+}
+
+/* ************************************************************************* */

wrap/MethodBase.h

@@ -0,0 +1,72 @@
+/* ----------------------------------------------------------------------------
+
+ * GTSAM Copyright 2010, Georgia Tech Research Corporation, 
+ * Atlanta, Georgia 30332-0415
+ * All Rights Reserved
+ * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
+
+ * See LICENSE for the license information
+
+ * -------------------------------------------------------------------------- */
+
+/**
+ * @file MethodBase.h
+ * @brief describes and generates code for static methods
+ * @author Frank Dellaert
+ * @author Alex Cunningham
+ * @author Richard Roberts
+ **/
+
+#pragma once
+
+#include "FullyOverloadedFunction.h"
+
+namespace wrap {
+
+/// MethodBase class
+struct MethodBase: public FullyOverloadedFunction {
+
+  typedef const std::string& Str;
+
+  virtual bool isStatic() const = 0;
+
+  // emit a list of comments, one for each overload
+  void comment_fragment(FileWriter& proxyFile) const {
+    SignatureOverloads::comment_fragment(proxyFile, matlabName());
+  }
+
+  void verifyArguments(const std::vector<std::string>& validArgs) const {
+    SignatureOverloads::verifyArguments(validArgs, name_);
+  }
+
+  void verifyReturnTypes(const std::vector<std::string>& validtypes) const {
+    SignatureOverloads::verifyReturnTypes(validtypes, name_);
+  }
+
+  // MATLAB code generation
+  // classPath is class directory, e.g., ../matlab/@Point2
+  void proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wrapperFile,
+      Str cppClassName, Str matlabQualName, Str matlabUniqueName,
+      Str wrapperName, const TypeAttributesTable& typeAttributes,
+      std::vector<std::string>& functionNames) const;
+
+  // emit python wrapper
+  void python_wrapper(FileWriter& wrapperFile, Str className) const;
+
+protected:
+
+  virtual void proxy_header(FileWriter& proxyFile) const = 0;
+
+  std::string wrapper_fragment(FileWriter& wrapperFile, Str cppClassName,
+      Str matlabUniqueName, int overload, int id,
+      const TypeAttributesTable& typeAttributes, const Qualified& instName =
+          Qualified()) const; ///< cpp wrapper
+
+  virtual std::string wrapper_call(FileWriter& wrapperFile, Str cppClassName,
+      Str matlabUniqueName, const ArgumentList& args,
+      const ReturnValue& returnVal, const TypeAttributesTable& typeAttributes,
+      const Qualified& instName) const = 0;
+};
+
+} // \namespace wrap
+

wrap/StaticMethod.cpp

@@ -16,7 +16,7 @@
  * @author Richard Roberts
  **/
 
-#include "Method.h"
+#include "StaticMethod.h"
 #include "utilities.h"
 
 #include <boost/foreach.hpp>
@@ -36,112 +36,6 @@ void StaticMethod::proxy_header(FileWriter& proxyFile) const {
   proxyFile.oss << "    function varargout = " << upperName << "(varargin)\n";
 }
 
-/* ************************************************************************* */
-void StaticMethod::proxy_wrapper_fragments(FileWriter& proxyFile,
-    FileWriter& wrapperFile, Str cppClassName, Str matlabQualName,
-    Str matlabUniqueName, Str wrapperName,
-    const TypeAttributesTable& typeAttributes,
-    vector<string>& functionNames) const {
-
-  // emit header, e.g., function varargout = templatedMethod(this, varargin)
-  proxy_header(proxyFile);
-
-  // Emit comments for documentation
-  string up_name = boost::to_upper_copy(matlabName());
-  proxyFile.oss << "      % " << up_name << " usage: ";
-  usage_fragment(proxyFile, matlabName());
-
-  // Emit URL to Doxygen page
-  proxyFile.oss << "      % "
-      << "Doxygen can be found at http://research.cc.gatech.edu/borg/sites/edu.borg/html/index.html"
-      << endl;
-
-  // Handle special case of single overload with all numeric arguments
-  if (nrOverloads() == 1 && argumentList(0).allScalar()) {
-    // Output proxy matlab code
-    // TODO: document why is it OK to not check arguments in this case
-    proxyFile.oss << "      ";
-    const int id = (int) functionNames.size();
-    argumentList(0).emit_call(proxyFile, returnValue(0), wrapperName, id,
-        isStatic());
-
-    // Output C++ wrapper code
-    const string wrapFunctionName = wrapper_fragment(wrapperFile, cppClassName,
-        matlabUniqueName, 0, id, typeAttributes, templateArgValue_);
-
-    // Add to function list
-    functionNames.push_back(wrapFunctionName);
-  } else {
-    // Check arguments for all overloads
-    for (size_t i = 0; i < nrOverloads(); ++i) {
-
-      // Output proxy matlab code
-      proxyFile.oss << "      " << (i == 0 ? "" : "else");
-      const int id = (int) functionNames.size();
-      argumentList(i).emit_conditional_call(proxyFile, returnValue(i),
-          wrapperName, id, isStatic());
-
-      // Output C++ wrapper code
-      const string wrapFunctionName = wrapper_fragment(wrapperFile,
-          cppClassName, matlabUniqueName, i, id, typeAttributes,
-          templateArgValue_);
-
-      // Add to function list
-      functionNames.push_back(wrapFunctionName);
-    }
-    proxyFile.oss << "      else\n";
-    proxyFile.oss
-        << "        error('Arguments do not match any overload of function "
-        << matlabQualName << "." << name_ << "');" << endl;
-    proxyFile.oss << "      end\n";
-  }
-
-  proxyFile.oss << "    end\n";
-}
-
-/* ************************************************************************* */
-string StaticMethod::wrapper_fragment(FileWriter& wrapperFile, Str cppClassName,
-    Str matlabUniqueName, int overload, int id,
-    const TypeAttributesTable& typeAttributes,
-    const Qualified& instName) const {
-
-  // generate code
-
-  const string wrapFunctionName = matlabUniqueName + "_" + name_ + "_"
-      + boost::lexical_cast<string>(id);
-
-  const ArgumentList& args = argumentList(overload);
-  const ReturnValue& returnVal = returnValue(overload);
-
-  // call
-  wrapperFile.oss << "void " << wrapFunctionName
-      << "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n";
-  // start
-  wrapperFile.oss << "{\n";
-
-  returnVal.wrapTypeUnwrap(wrapperFile);
-
-  wrapperFile.oss << "  typedef boost::shared_ptr<" << cppClassName
-      << "> Shared;" << endl;
-
-  // get call
-  // for static methods: cppClassName::staticMethod<TemplateVal>
-  // for instance methods: obj->instanceMethod<TemplateVal>
-  string expanded = wrapper_call(wrapperFile, cppClassName, matlabUniqueName,
-      args, returnVal, typeAttributes, instName);
-
-  expanded += ("(" + args.names() + ")");
-  if (returnVal.type1.name != "void")
-    returnVal.wrap_result(expanded, wrapperFile, typeAttributes);
-  else
-    wrapperFile.oss << "  " + expanded + ";\n";
-
-  // finish
-  wrapperFile.oss << "}\n";
-
-  return wrapFunctionName;
-}
-
 /* ************************************************************************* */
 string StaticMethod::wrapper_call(FileWriter& wrapperFile, Str cppClassName,
     Str matlabUniqueName, const ArgumentList& args,
@@ -165,10 +59,3 @@ string StaticMethod::wrapper_call(FileWriter& wrapperFile, Str cppClassName,
 }
 
 /* ************************************************************************* */
-void StaticMethod::python_wrapper(FileWriter& wrapperFile,
-    Str className) const {
-  wrapperFile.oss << "  .def(\"" << name_ << "\", &" << className << "::" << name_
-      << ");\n";
-}
-
-/* ************************************************************************* */

wrap/StaticMethod.h

@@ -19,12 +19,12 @@
 
 #pragma once
 
-#include "FullyOverloadedFunction.h"
+#include "MethodBase.h"
 
 namespace wrap {
 
 /// StaticMethod class
-struct StaticMethod: public FullyOverloadedFunction {
+struct StaticMethod: public MethodBase {
 
   typedef const std::string& Str;
 
@@ -32,29 +32,6 @@ struct StaticMethod: public FullyOverloadedFunction {
     return true;
   }
 
-  // emit a list of comments, one for each overload
-  void comment_fragment(FileWriter& proxyFile) const {
-    SignatureOverloads::comment_fragment(proxyFile, matlabName());
-  }
-
-  void verifyArguments(const std::vector<std::string>& validArgs) const {
-    SignatureOverloads::verifyArguments(validArgs, name_);
-  }
-
-  void verifyReturnTypes(const std::vector<std::string>& validtypes) const {
-    SignatureOverloads::verifyReturnTypes(validtypes, name_);
-  }
-
-  // MATLAB code generation
-  // classPath is class directory, e.g., ../matlab/@Point2
-  void proxy_wrapper_fragments(FileWriter& proxyFile, FileWriter& wrapperFile,
-      Str cppClassName, Str matlabQualName, Str matlabUniqueName,
-      Str wrapperName, const TypeAttributesTable& typeAttributes,
-      std::vector<std::string>& functionNames) const;
-
-  // emit python wrapper
-  void python_wrapper(FileWriter& wrapperFile, Str className) const;
-
   friend std::ostream& operator<<(std::ostream& os, const StaticMethod& m) {
     for (size_t i = 0; i < m.nrOverloads(); i++)
       os << "static " << m.returnVals_[i] << " " << m.name_ << m.argLists_[i];
@@ -65,11 +42,6 @@ protected:
 
   virtual void proxy_header(FileWriter& proxyFile) const;
 
-  std::string wrapper_fragment(FileWriter& wrapperFile, Str cppClassName,
-      Str matlabUniqueName, int overload, int id,
-      const TypeAttributesTable& typeAttributes, const Qualified& instName =
-          Qualified()) const; ///< cpp wrapper
-
   virtual std::string wrapper_call(FileWriter& wrapperFile, Str cppClassName,
       Str matlabUniqueName, const ArgumentList& args,
       const ReturnValue& returnVal, const TypeAttributesTable& typeAttributes,