gtsam/wrap/GlobalFunction.cpp

/**
 * @file GlobalFunction.cpp
 *
 * @date Jul 22, 2012
 * @author Alex Cunningham
 */

#include "GlobalFunction.h"
#include "utilities.h"

#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>

namespace wrap {

using namespace std;

/* ************************************************************************* */
void GlobalFunction::addOverload(bool verbose, const std::string& name,
    const ArgumentList& args, const ReturnValue& retVal, const StrVec& ns_stack) {
  this->verbose_ = verbose;
  this->name = name;
  this->argLists.push_back(args);
  this->returnVals.push_back(retVal);
  this->namespaces.push_back(ns_stack);
}

/* ************************************************************************* */
void GlobalFunction::matlab_proxy(const std::string& toolboxPath, const std::string& wrapperName,
    const TypeAttributesTable& typeAttributes,  FileWriter& wrapperFile,
    std::vector<std::string>& functionNames) const {

  // cluster overloads with same namespace
  // create new GlobalFunction structures around namespaces - same namespaces and names are overloads
  // map of namespace to global function
  typedef map<string, GlobalFunction> GlobalFunctionMap;
  GlobalFunctionMap grouped_functions;
  for (size_t i=0; i<namespaces.size(); ++i) {
    StrVec ns = namespaces.at(i);
    string str_ns = qualifiedName("", ns, "");
    ReturnValue ret = returnVals.at(i);
    ArgumentList args = argLists.at(i);

    if (!grouped_functions.count(str_ns))
      grouped_functions[str_ns] = GlobalFunction(name, verbose_);

    grouped_functions[str_ns].argLists.push_back(args);
    grouped_functions[str_ns].returnVals.push_back(ret);
    grouped_functions[str_ns].namespaces.push_back(ns);
  }

  size_t lastcheck = grouped_functions.size();
  BOOST_FOREACH(const GlobalFunctionMap::value_type& p, grouped_functions) {
    p.second.generateSingleFunction(toolboxPath, wrapperName, typeAttributes,  wrapperFile, functionNames);
    if (--lastcheck != 0)
      wrapperFile.oss << endl;
  }
}

/* ************************************************************************* */
void GlobalFunction::generateSingleFunction(const std::string& toolboxPath, const std::string& wrapperName,
    const TypeAttributesTable& typeAttributes,  FileWriter& wrapperFile,
    std::vector<std::string>& functionNames) const {

  // create the folder for the namespace
  const StrVec& ns = namespaces.front();
  createNamespaceStructure(ns, toolboxPath);

  // open destination mfunctionFileName
  string mfunctionFileName = toolboxPath;
  if(!ns.empty())
    mfunctionFileName += "/+" + wrap::qualifiedName("/+", ns);
  mfunctionFileName += "/" + name + ".m";
  FileWriter mfunctionFile(mfunctionFileName, verbose_, "%");

  // get the name of actual matlab object
  const string
    matlabQualName = qualifiedName(".", ns, name),
    matlabUniqueName = qualifiedName("", ns, name),
    cppName = qualifiedName("::", ns, name);

  mfunctionFile.oss << "function varargout = " << name << "(varargin)\n";

  for(size_t overload = 0; overload < argLists.size(); ++overload) {
    const ArgumentList& args = argLists[overload];
    const ReturnValue& returnVal = returnVals[overload];
    size_t nrArgs = args.size();

    const int id = functionNames.size();

    // Output proxy matlab code

    // check for number of arguments...
    mfunctionFile.oss << (overload==0?"":"else") << "if length(varargin) == " << nrArgs;
    if (nrArgs>0) mfunctionFile.oss << " && ";
    // ...and their types
    bool first = true;
    for(size_t i=0;i<nrArgs;i++) {
      if (!first) mfunctionFile.oss << " && ";
      mfunctionFile.oss << "isa(varargin{" << i+1 << "},'" << args[i].matlabClass(".") << "')";
      first=false;
    }
    mfunctionFile.oss << "\n";

    // output call to C++ wrapper
    string output;
    if(returnVal.isPair)
      output = "[ varargout{1} varargout{2} ] = ";
    else if(returnVal.category1 == ReturnValue::VOID)
      output = "";
    else
      output = "varargout{1} = ";
    mfunctionFile.oss << "    " << output << wrapperName << "(" << id << ", varargin{:});\n";

    // Output C++ wrapper code

    const string wrapFunctionName = matlabUniqueName + "_" + boost::lexical_cast<string>(id);

    // call
    wrapperFile.oss << "void " << wrapFunctionName << "(int nargout, mxArray *out[], int nargin, const mxArray *in[])\n";
    // start
    wrapperFile.oss << "{\n";

    returnVal.wrapTypeUnwrap(wrapperFile);

    // check arguments
    // NOTE: for static functions, there is no object passed
    wrapperFile.oss << "  checkArguments(\"" << matlabUniqueName << "\",nargout,nargin," << args.size() << ");\n";

    // unwrap arguments, see Argument.cpp
    args.matlab_unwrap(wrapperFile,0); // We start at 0 because there is no self object

    // call method with default type and wrap result
    if (returnVal.type1!="void")
      returnVal.wrap_result(cppName+"("+args.names()+")", wrapperFile, typeAttributes);
    else
      wrapperFile.oss << cppName+"("+args.names()+");\n";

    // finish
    wrapperFile.oss << "}\n";

    // Add to function list
    functionNames.push_back(wrapFunctionName);
  }

  mfunctionFile.oss << "else\n";
  mfunctionFile.oss << "    error('Arguments do not match any overload of function " <<  matlabQualName << "');" << endl;
  mfunctionFile.oss << "end" << endl;

  // Close file
  mfunctionFile.emit(true);
}

/* ************************************************************************* */


} // \namespace wrap