From 7a4748d3dcb008889dffbdbb027aafb2db250a23 Mon Sep 17 00:00:00 2001 From: dellaert Date: Fri, 14 Nov 2014 16:43:53 +0100 Subject: [PATCH] Simplified method/function hierarchy drastically, and renamed bottom addOverload to initializeOrCheck to reflect what it does. Also, gratuitous re-ordering of addOverload arguments. --- wrap/Argument.h | 8 -- wrap/Class.cpp | 8 +- wrap/Constructor.h | 18 ++-- wrap/FullyOverloadedFunction.h | 133 +++++++++++++++++++++++ wrap/Function.cpp | 43 +++----- wrap/Function.h | 186 ++------------------------------- wrap/GlobalFunction.cpp | 23 ++-- wrap/GlobalFunction.h | 22 ++-- wrap/Method.cpp | 22 ++-- wrap/Method.h | 18 +--- wrap/Module.cpp | 9 +- wrap/OverloadedFunction.h | 126 ++++++++++++++++++++++ wrap/StaticMethod.cpp | 8 -- wrap/StaticMethod.h | 16 +-- wrap/tests/testMethod.cpp | 9 +- 15 files changed, 341 insertions(+), 308 deletions(-) create mode 100644 wrap/FullyOverloadedFunction.h create mode 100644 wrap/OverloadedFunction.h diff --git a/wrap/Argument.h b/wrap/Argument.h index 02f104418..3d8d7288f 100644 --- a/wrap/Argument.h +++ b/wrap/Argument.h @@ -122,13 +122,5 @@ struct ArgumentList: public std::vector { }; -template -inline void verifyArguments(const std::vector& validArgs, - const std::map& vt) { - typedef typename std::map::value_type NamedMethod; - BOOST_FOREACH(const NamedMethod& namedMethod, vt) - namedMethod.second.verifyArguments(validArgs); -} - } // \namespace wrap diff --git a/wrap/Class.cpp b/wrap/Class.cpp index 3a3432eb3..9c759bb62 100644 --- a/wrap/Class.cpp +++ b/wrap/Class.cpp @@ -286,13 +286,13 @@ void Class::addMethod(bool verbose, bool is_const, Str methodName, // Now stick in new overload stack with expandedMethodName key // but note we use the same, unexpanded methodName in overload string expandedMethodName = methodName + instName.name; - methods[expandedMethodName].addOverload(verbose, is_const, methodName, - expandedArgs, expandedRetVal, instName); + methods[expandedMethodName].addOverload(methodName, expandedArgs, + expandedRetVal, is_const, instName, verbose); } } else // just add overload - methods[methodName].addOverload(verbose, is_const, methodName, argumentList, - returnValue); + methods[methodName].addOverload(methodName, argumentList, returnValue, + is_const, Qualified(), verbose); } /* ************************************************************************* */ diff --git a/wrap/Constructor.h b/wrap/Constructor.h index adfcb8472..870f1a15e 100644 --- a/wrap/Constructor.h +++ b/wrap/Constructor.h @@ -18,7 +18,7 @@ #pragma once -#include "Function.h" +#include "OverloadedFunction.h" #include #include @@ -26,21 +26,17 @@ namespace wrap { // Constructor class -struct Constructor: public ArgumentOverloads { +struct Constructor: public OverloadedFunction { /// Constructor creates an empty class - Constructor(bool verbose = false) : - verbose_(verbose) { + Constructor(bool verbose = false) { + verbose_ = verbose; } - // Then the instance variables are set directly by the Module constructor - std::string name; - bool verbose_; - Constructor expandTemplate(const TemplateSubstitution& ts) const { Constructor inst = *this; inst.argLists_ = expandArgumentListsTemplate(ts); - inst.name = ts.expandedClassName(); + inst.name_ = ts.expandedClassName(); return inst; } @@ -56,7 +52,7 @@ struct Constructor: public ArgumentOverloads { proxyFile.oss << "%\n%-------Constructors-------\n"; for (size_t i = 0; i < nrOverloads(); i++) { proxyFile.oss << "%"; - argumentList(i).emit_prototype(proxyFile, name); + argumentList(i).emit_prototype(proxyFile, name_); proxyFile.oss << "\n"; } } @@ -80,7 +76,7 @@ struct Constructor: public ArgumentOverloads { friend std::ostream& operator<<(std::ostream& os, const Constructor& m) { for (size_t i = 0; i < m.nrOverloads(); i++) - os << m.name << m.argLists_[i]; + os << m.name_ << m.argLists_[i]; return os; } diff --git a/wrap/FullyOverloadedFunction.h b/wrap/FullyOverloadedFunction.h new file mode 100644 index 000000000..ac22ec3a8 --- /dev/null +++ b/wrap/FullyOverloadedFunction.h @@ -0,0 +1,133 @@ +/* ---------------------------------------------------------------------------- + + * 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 FullyOverloadedFunction.h + * @brief Function that can be fully overloaded: arguments and return values + * @author Frank Dellaert + * @date Nov 13, 2014 + **/ + +#pragma once + +#include "OverloadedFunction.h" + +namespace wrap { + +/** + * Signature Overload (including return value) + */ +class SignatureOverloads: public ArgumentOverloads { + +protected: + + std::vector returnVals_; + +public: + + const ReturnValue& returnValue(size_t i) const { + return returnVals_.at(i); + } + + void push_back(const ArgumentList& args, const ReturnValue& retVal) { + argLists_.push_back(args); + returnVals_.push_back(retVal); + } + + void verifyReturnTypes(const std::vector& validtypes, + const std::string& s) const { + BOOST_FOREACH(const ReturnValue& retval, returnVals_) { + retval.type1.verify(validtypes, s); + if (retval.isPair) + retval.type2.verify(validtypes, s); + } + } + + // TODO use transform ? + std::vector expandReturnValuesTemplate( + const TemplateSubstitution& ts) const { + std::vector result; + BOOST_FOREACH(const ReturnValue& retVal, returnVals_) { + ReturnValue instRetVal = retVal.expandTemplate(ts); + result.push_back(instRetVal); + } + return result; + } + + /// Expand templates, imperative ! + void expandTemplate(const TemplateSubstitution& ts) { + // substitute template in arguments + argLists_ = expandArgumentListsTemplate(ts); + // do the same for return types + returnVals_ = expandReturnValuesTemplate(ts); + } + + // emit a list of comments, one for each overload + void usage_fragment(FileWriter& proxyFile, const std::string& name) const { + unsigned int argLCount = 0; + BOOST_FOREACH(ArgumentList argList, argLists_) { + argList.emit_prototype(proxyFile, name); + if (argLCount != nrOverloads() - 1) + proxyFile.oss << ", "; + else + proxyFile.oss << " : returns " << returnValue(0).return_type(false) + << std::endl; + argLCount++; + } + } + + // emit a list of comments, one for each overload + void comment_fragment(FileWriter& proxyFile, const std::string& name) const { + size_t i = 0; + BOOST_FOREACH(ArgumentList argList, argLists_) { + proxyFile.oss << "%"; + argList.emit_prototype(proxyFile, name); + proxyFile.oss << " : returns " << returnVals_[i++].return_type(false) + << std::endl; + } + } + + friend std::ostream& operator<<(std::ostream& os, + const SignatureOverloads& overloads) { + for (size_t i = 0; i < overloads.nrOverloads(); i++) + os << overloads.returnVals_[i] << overloads.argLists_[i] << std::endl; + return os; + } + +}; + +class FullyOverloadedFunction: public Function, public SignatureOverloads { + +public: + + bool addOverload(const std::string& name, const ArgumentList& args, + const ReturnValue& retVal, const Qualified& instName = Qualified(), + bool verbose = false) { + bool first = initializeOrCheck(name, instName, verbose); + SignatureOverloads::push_back(args, retVal); + return first; + } + +}; + +// Templated checking functions +// TODO: do this via polymorphism, use transform ? + +template +inline void verifyReturnTypes(const std::vector& validTypes, + const std::map& vt) { + typedef typename std::map::value_type NamedMethod; + BOOST_FOREACH(const NamedMethod& namedMethod, vt) + namedMethod.second.verifyReturnTypes(validTypes); +} + +} // \namespace wrap + diff --git a/wrap/Function.cpp b/wrap/Function.cpp index ab3958c62..6faa70fb9 100644 --- a/wrap/Function.cpp +++ b/wrap/Function.cpp @@ -29,38 +29,29 @@ using namespace std; using namespace wrap; /* ************************************************************************* */ -void Function::addOverload(bool verbose, const std::string& name, - const Qualified& instName) { +bool Function::initializeOrCheck(const std::string& name, + const Qualified& instName, bool verbose) { + + if (name.empty()) + throw std::runtime_error( + "Function::initializeOrCheck called with empty name"); // Check if this overload is give to the correct method - if (name_.empty()) + if (name_.empty()) { name_ = name; - else if (name_ != name) - throw std::runtime_error( - "Function::addOverload: tried to add overload with name " + name - + " instead of expected " + name_); - - // Check if this overload is give to the correct method - if (templateArgValue_.empty()) templateArgValue_ = instName; - else if (templateArgValue_ != instName) - throw std::runtime_error( - "Function::addOverload: tried to add overload with template argument " - + instName.qualifiedName(":") + " instead of expected " - + templateArgValue_.qualifiedName(":")); + verbose_ = verbose; + return true; + } else { + if (name_ != name || templateArgValue_ != instName || verbose_ != verbose) + throw std::runtime_error( + "Function::initializeOrCheck called with different arguments: with name " + + name + " instead of expected " + name_ + + ", or with template argument " + instName.qualifiedName(":") + + " instead of expected " + templateArgValue_.qualifiedName(":")); - verbose_ = verbose; -} - -/* ************************************************************************* */ -vector ArgumentOverloads::expandArgumentListsTemplate( - const TemplateSubstitution& ts) const { - vector result; - BOOST_FOREACH(const ArgumentList& argList, argLists_) { - ArgumentList instArgList = argList.expandTemplate(ts); - result.push_back(instArgList); + return false; } - return result; } /* ************************************************************************* */ diff --git a/wrap/Function.h b/wrap/Function.h index 1d40fcbea..49a26bd8d 100644 --- a/wrap/Function.h +++ b/wrap/Function.h @@ -19,11 +19,6 @@ #pragma once #include "Argument.h" -#include "ReturnValue.h" -#include "TypeAttributesTable.h" - -#include -#include namespace wrap { @@ -32,20 +27,18 @@ class Function { protected: - bool verbose_; std::string name_; ///< name of method Qualified templateArgValue_; ///< value of template argument if applicable + bool verbose_; public: - /// Constructor creates empty object - Function(bool verbose = true) : - verbose_(verbose) { - } - - Function(const std::string& name, bool verbose = true) : - verbose_(verbose), name_(name) { - } + /** + * @brief first time, fill in instance variables, otherwise check if same + * @return true if first time, false thereafter + */ + bool initializeOrCheck(const std::string& name, const Qualified& instName = + Qualified(), bool verbose = false); std::string name() const { return name_; @@ -57,172 +50,7 @@ public: else return name_ + templateArgValue_.name; } - - // The first time this function is called, it initializes the class members - // with those in rhs, but in subsequent calls it adds additional argument - // lists as function overloads. - void addOverload(bool verbose, const std::string& name, - const Qualified& instName = Qualified()); }; -/** - * ArgumentList Overloads - */ -class ArgumentOverloads { - -protected: - - std::vector argLists_; - -public: - - size_t nrOverloads() const { - return argLists_.size(); - } - - const ArgumentList& argumentList(size_t i) const { - return argLists_.at(i); - } - - void addOverload(const ArgumentList& args) { - argLists_.push_back(args); - } - - std::vector expandArgumentListsTemplate( - const TemplateSubstitution& ts) const; - - /// Expand templates, imperative ! - virtual void ExpandTemplate(const TemplateSubstitution& ts) { - argLists_ = expandArgumentListsTemplate(ts); - } - - void verifyArguments(const std::vector& validArgs, - const std::string s) const { - BOOST_FOREACH(const ArgumentList& argList, argLists_) { - BOOST_FOREACH(Argument arg, argList) { - std::string fullType = arg.type.qualifiedName("::"); - if (find(validArgs.begin(), validArgs.end(), fullType) - == validArgs.end()) - throw DependencyMissing(fullType, "checking argument of " + s); - } - } - } - - friend std::ostream& operator<<(std::ostream& os, - const ArgumentOverloads& overloads) { - BOOST_FOREACH(const ArgumentList& argList, overloads.argLists_) - os << argList << std::endl; - return os; - } - -}; - -/** - * Signature Overload (including return value) - */ -class SignatureOverloads: public ArgumentOverloads { - -protected: - - std::vector returnVals_; - -public: - - const ReturnValue& returnValue(size_t i) const { - return returnVals_.at(i); - } - - void addOverload(const ArgumentList& args, const ReturnValue& retVal) { - argLists_.push_back(args); - returnVals_.push_back(retVal); - } - - void verifyReturnTypes(const std::vector& validtypes, - const std::string& s) const { - BOOST_FOREACH(const ReturnValue& retval, returnVals_) { - retval.type1.verify(validtypes, s); - if (retval.isPair) - retval.type2.verify(validtypes, s); - } - } - - // TODO use transform ? - std::vector expandReturnValuesTemplate( - const TemplateSubstitution& ts) const { - std::vector result; - BOOST_FOREACH(const ReturnValue& retVal, returnVals_) { - ReturnValue instRetVal = retVal.expandTemplate(ts); - result.push_back(instRetVal); - } - return result; - } - - /// Expand templates, imperative ! - void expandTemplate(const TemplateSubstitution& ts) { - // substitute template in arguments - argLists_ = expandArgumentListsTemplate(ts); - // do the same for return types - returnVals_ = expandReturnValuesTemplate(ts); - } - - // emit a list of comments, one for each overload - void usage_fragment(FileWriter& proxyFile, const std::string& name) const { - unsigned int argLCount = 0; - BOOST_FOREACH(ArgumentList argList, argLists_) { - argList.emit_prototype(proxyFile, name); - if (argLCount != nrOverloads() - 1) - proxyFile.oss << ", "; - else - proxyFile.oss << " : returns " << returnValue(0).return_type(false) - << std::endl; - argLCount++; - } - } - - // emit a list of comments, one for each overload - void comment_fragment(FileWriter& proxyFile, const std::string& name) const { - size_t i = 0; - BOOST_FOREACH(ArgumentList argList, argLists_) { - proxyFile.oss << "%"; - argList.emit_prototype(proxyFile, name); - proxyFile.oss << " : returns " << returnVals_[i++].return_type(false) - << std::endl; - } - } - - friend std::ostream& operator<<(std::ostream& os, - const SignatureOverloads& overloads) { - for (size_t i = 0; i < overloads.nrOverloads(); i++) - os << overloads.returnVals_[i] << overloads.argLists_[i] << std::endl; - return os; - } - -}; - -// Templated checking functions -// TODO: do this via polymorphism ? - -// TODO use transform -template -static std::map expandMethodTemplate( - const std::map& methods, const TemplateSubstitution& ts) { - std::map result; - typedef std::pair NamedMethod; - BOOST_FOREACH(NamedMethod namedMethod, methods) { - F instMethod = namedMethod.second; - instMethod.expandTemplate(ts); - namedMethod.second = instMethod; - result.insert(namedMethod); - } - return result; -} -template -inline void verifyReturnTypes(const std::vector& validTypes, - const std::map& vt) { - typedef typename std::map::value_type NamedMethod; - BOOST_FOREACH(const NamedMethod& namedMethod, vt) - namedMethod.second.verifyReturnTypes(validTypes); -} - } // \namespace wrap diff --git a/wrap/GlobalFunction.cpp b/wrap/GlobalFunction.cpp index 1f9d6518e..916189632 100644 --- a/wrap/GlobalFunction.cpp +++ b/wrap/GlobalFunction.cpp @@ -16,18 +16,18 @@ namespace wrap { using namespace std; /* ************************************************************************* */ -void GlobalFunction::addOverload(bool verbose, const Qualified& overload, +void GlobalFunction::addOverload(const Qualified& overload, const ArgumentList& args, const ReturnValue& retVal, - const Qualified& instName) { - Function::addOverload(verbose, overload.name, instName); - SignatureOverloads::addOverload(args, retVal); + const Qualified& instName, bool verbose) { + string name(overload.name); + FullyOverloadedFunction::addOverload(name, args, retVal, instName, verbose); overloads.push_back(overload); } /* ************************************************************************* */ -void GlobalFunction::matlab_proxy(const std::string& toolboxPath, - const std::string& wrapperName, const TypeAttributesTable& typeAttributes, - FileWriter& file, std::vector& functionNames) const { +void GlobalFunction::matlab_proxy(const string& toolboxPath, + const string& wrapperName, const TypeAttributesTable& typeAttributes, + FileWriter& file, vector& functionNames) const { // cluster overloads with same namespace // create new GlobalFunction structures around namespaces - same namespaces and names are overloads @@ -40,8 +40,7 @@ void GlobalFunction::matlab_proxy(const std::string& toolboxPath, string str_ns = qualifiedName("", overload.namespaces); const ReturnValue& ret = returnValue(i); const ArgumentList& args = argumentList(i); - grouped_functions[str_ns].addOverload(verbose_, overload, args, ret, - templateArgValue_); + grouped_functions[str_ns].addOverload(overload, args, ret); } size_t lastcheck = grouped_functions.size(); @@ -54,9 +53,9 @@ void GlobalFunction::matlab_proxy(const std::string& toolboxPath, } /* ************************************************************************* */ -void GlobalFunction::generateSingleFunction(const std::string& toolboxPath, - const std::string& wrapperName, const TypeAttributesTable& typeAttributes, - FileWriter& file, std::vector& functionNames) const { +void GlobalFunction::generateSingleFunction(const string& toolboxPath, + const string& wrapperName, const TypeAttributesTable& typeAttributes, + FileWriter& file, vector& functionNames) const { // create the folder for the namespace const Qualified& overload1 = overloads.front(); diff --git a/wrap/GlobalFunction.h b/wrap/GlobalFunction.h index 18bb91995..a086e8154 100644 --- a/wrap/GlobalFunction.h +++ b/wrap/GlobalFunction.h @@ -9,23 +9,18 @@ #pragma once -#include "Function.h" +#include "FullyOverloadedFunction.h" namespace wrap { -struct GlobalFunction: public Function, public SignatureOverloads { +struct GlobalFunction: public FullyOverloadedFunction { std::vector overloads; ///< Stack of qualified names - // Constructor only used in Module - GlobalFunction(bool verbose = true) : - Function(verbose) { - } - - // Used to reconstruct - GlobalFunction(const std::string& name, bool verbose = true) : - Function(name,verbose) { - } + // adds an overloaded version of this function, + void addOverload(const Qualified& overload, const ArgumentList& args, + const ReturnValue& retVal, const Qualified& instName = Qualified(), + bool verbose = false); void verifyArguments(const std::vector& validArgs) const { SignatureOverloads::verifyArguments(validArgs, name_); @@ -35,11 +30,6 @@ struct GlobalFunction: public Function, public SignatureOverloads { SignatureOverloads::verifyReturnTypes(validtypes, name_); } - // adds an overloaded version of this function, - void addOverload(bool verbose, const Qualified& overload, - const ArgumentList& args, const ReturnValue& retVal, - const Qualified& instName = Qualified()); - // codegen function called from Module to build the cpp and matlab versions of the function void matlab_proxy(const std::string& toolboxPath, const std::string& wrapperName, const TypeAttributesTable& typeAttributes, diff --git a/wrap/Method.cpp b/wrap/Method.cpp index a7072c9e7..49d90378d 100644 --- a/wrap/Method.cpp +++ b/wrap/Method.cpp @@ -29,17 +29,25 @@ using namespace std; using namespace wrap; /* ************************************************************************* */ -void Method::addOverload(bool verbose, bool is_const, Str name, - const ArgumentList& args, const ReturnValue& retVal, - const Qualified& instName) { - - StaticMethod::addOverload(verbose, name, args, retVal, instName); - is_const_ = is_const; +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); + if (first) + is_const_ = is_const; + else if (is_const && !is_const_) + throw std::runtime_error( + "Method::addOverload now designated as const whereas before it was not"); + else if (!is_const && is_const_) + throw std::runtime_error( + "Method::addOverload now designated as non-const whereas before it was"); + return first; } /* ************************************************************************* */ void Method::proxy_header(FileWriter& proxyFile) const { - proxyFile.oss << " function varargout = " << matlabName() << "(this, varargin)\n"; + proxyFile.oss << " function varargout = " << matlabName() + << "(this, varargin)\n"; } /* ************************************************************************* */ diff --git a/wrap/Method.h b/wrap/Method.h index 13847700d..db9e6bb9f 100644 --- a/wrap/Method.h +++ b/wrap/Method.h @@ -31,14 +31,9 @@ public: typedef const std::string& Str; - /// Constructor creates empty object - Method(bool verbose = true) : - StaticMethod(verbose), is_const_(false) { - } - - Method(const std::string& name, bool verbose = true) : - StaticMethod(name,verbose), is_const_(false) { - } + bool addOverload(Str name, const ArgumentList& args, + const ReturnValue& retVal, bool is_const, const Qualified& instName = + Qualified(), bool verbose = false); virtual bool isStatic() const { return false; @@ -48,13 +43,6 @@ public: return is_const_; } - // The first time this function is called, it initializes the class members - // with those in rhs, but in subsequent calls it adds additional argument - // lists as function overloads. - void addOverload(bool verbose, bool is_const, Str name, - const ArgumentList& args, const ReturnValue& retVal, - const Qualified& instName = Qualified()); - friend std::ostream& operator<<(std::ostream& os, const Method& m) { for (size_t i = 0; i < m.nrOverloads(); i++) os << m.returnVals_[i] << " " << m.name_ << m.argLists_[i]; diff --git a/wrap/Module.cpp b/wrap/Module.cpp index 2fc8f92bc..2f35f0bbf 100644 --- a/wrap/Module.cpp +++ b/wrap/Module.cpp @@ -217,7 +217,7 @@ void Module::parseMarkup(const std::string& data) { Constructor constructor0(verbose), constructor(verbose); Rule constructor_p = (className_p >> '(' >> argumentList_p >> ')' >> ';' >> !comments_p) - [bl::bind(&Constructor::addOverload, bl::var(constructor), bl::var(args))] + [bl::bind(&Constructor::push_back, bl::var(constructor), bl::var(args))] [clear_a(args)]; vector namespaces_return; /// namespace for current return type @@ -274,7 +274,7 @@ void Module::parseMarkup(const std::string& data) { '(' >> argumentList_p >> ')' >> ';' >> *comments_p) [bl::bind(&StaticMethod::addOverload, bl::var(cls.static_methods)[bl::var(methodName)], - verbose, bl::var(methodName), bl::var(args), bl::var(retVal), Qualified())] + bl::var(methodName), bl::var(args), bl::var(retVal), Qualified(),verbose)] [assign_a(retVal,retVal0)] [clear_a(args)]; @@ -295,7 +295,8 @@ void Module::parseMarkup(const std::string& data) { >> ((':' >> classParent_p >> '{') | '{') >> *(functions_p | comments_p) >> str_p("};")) - [assign_a(constructor.name, cls.name)] + [bl::bind(&Constructor::initializeOrCheck, bl::var(constructor), + bl::var(cls.name), Qualified(), verbose)] [assign_a(cls.constructor, constructor)] [assign_a(cls.namespaces, namespaces)] [assign_a(cls.deconstructor.name,cls.name)] @@ -313,7 +314,7 @@ void Module::parseMarkup(const std::string& data) { [assign_a(globalFunction.namespaces,namespaces)] [bl::bind(&GlobalFunction::addOverload, bl::var(global_functions)[bl::var(globalFunction.name)], - verbose, bl::var(globalFunction), bl::var(args), bl::var(retVal), Qualified())] + bl::var(globalFunction), bl::var(args), bl::var(retVal), Qualified(),verbose)] [assign_a(retVal,retVal0)] [clear_a(globalFunction)] [clear_a(args)]; diff --git a/wrap/OverloadedFunction.h b/wrap/OverloadedFunction.h new file mode 100644 index 000000000..47c418748 --- /dev/null +++ b/wrap/OverloadedFunction.h @@ -0,0 +1,126 @@ +/* ---------------------------------------------------------------------------- + + * 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 OverloadedFunction.h + * @brief Function that can overload its arguments only + * @author Frank Dellaert + * @date Nov 13, 2014 + **/ + +#pragma once + +#include "Function.h" +#include "Argument.h" + +namespace wrap { + +/** + * ArgumentList Overloads + */ +class ArgumentOverloads { + +protected: + + std::vector argLists_; + +public: + + size_t nrOverloads() const { + return argLists_.size(); + } + + const ArgumentList& argumentList(size_t i) const { + return argLists_.at(i); + } + + void push_back(const ArgumentList& args) { + argLists_.push_back(args); + } + + std::vector expandArgumentListsTemplate( + const TemplateSubstitution& ts) const { + std::vector result; + BOOST_FOREACH(const ArgumentList& argList, argLists_) { + ArgumentList instArgList = argList.expandTemplate(ts); + result.push_back(instArgList); + } + return result; + } + + /// Expand templates, imperative ! + virtual void ExpandTemplate(const TemplateSubstitution& ts) { + argLists_ = expandArgumentListsTemplate(ts); + } + + void verifyArguments(const std::vector& validArgs, + const std::string s) const { + BOOST_FOREACH(const ArgumentList& argList, argLists_) { + BOOST_FOREACH(Argument arg, argList) { + std::string fullType = arg.type.qualifiedName("::"); + if (find(validArgs.begin(), validArgs.end(), fullType) + == validArgs.end()) + throw DependencyMissing(fullType, "checking argument of " + s); + } + } + } + + friend std::ostream& operator<<(std::ostream& os, + const ArgumentOverloads& overloads) { + BOOST_FOREACH(const ArgumentList& argList, overloads.argLists_) + os << argList << std::endl; + return os; + } + +}; + +class OverloadedFunction: public Function, public ArgumentOverloads { + +public: + + bool addOverload(const std::string& name, const ArgumentList& args, + const Qualified& instName = Qualified(), bool verbose = false) { + bool first = initializeOrCheck(name, instName, verbose); + ArgumentOverloads::push_back(args); + return first; + } + +private: + +}; + +// Templated checking functions +// TODO: do this via polymorphism, use transform ? + +template +static std::map expandMethodTemplate( + const std::map& methods, const TemplateSubstitution& ts) { + std::map result; + typedef std::pair NamedMethod; + BOOST_FOREACH(NamedMethod namedMethod, methods) { + F instMethod = namedMethod.second; + instMethod.expandTemplate(ts); + namedMethod.second = instMethod; + result.insert(namedMethod); + } + return result; +} + +template +inline void verifyArguments(const std::vector& validArgs, + const std::map& vt) { + typedef typename std::map::value_type NamedMethod; + BOOST_FOREACH(const NamedMethod& namedMethod, vt) + namedMethod.second.verifyArguments(validArgs); +} + +} // \namespace wrap + diff --git a/wrap/StaticMethod.cpp b/wrap/StaticMethod.cpp index d3bd75628..83cf621b4 100644 --- a/wrap/StaticMethod.cpp +++ b/wrap/StaticMethod.cpp @@ -29,14 +29,6 @@ using namespace std; using namespace wrap; -/* ************************************************************************* */ -void StaticMethod::addOverload(bool verbose, Str name, const ArgumentList& args, - const ReturnValue& retVal, const Qualified& instName) { - - Function::addOverload(verbose, name, instName); - SignatureOverloads::addOverload(args, retVal); -} - /* ************************************************************************* */ void StaticMethod::proxy_header(FileWriter& proxyFile) const { string upperName = matlabName(); diff --git a/wrap/StaticMethod.h b/wrap/StaticMethod.h index 4a6fedbfc..06f98092f 100644 --- a/wrap/StaticMethod.h +++ b/wrap/StaticMethod.h @@ -19,31 +19,19 @@ #pragma once -#include "Function.h" +#include "FullyOverloadedFunction.h" namespace wrap { /// StaticMethod class -struct StaticMethod: public Function, public SignatureOverloads { +struct StaticMethod: public FullyOverloadedFunction { typedef const std::string& Str; - /// Constructor creates empty object - StaticMethod(bool verbosity = true) : - Function(verbosity) { - } - - StaticMethod(const std::string& name, bool verbose = true) : - Function(name,verbose) { - } - virtual bool isStatic() const { return true; } - void addOverload(bool verbose, Str name, const ArgumentList& args, - const ReturnValue& retVal, const Qualified& instName); - // emit a list of comments, one for each overload void comment_fragment(FileWriter& proxyFile) const { SignatureOverloads::comment_fragment(proxyFile, matlabName()); diff --git a/wrap/tests/testMethod.cpp b/wrap/tests/testMethod.cpp index 4067f3d85..8050f0d3c 100644 --- a/wrap/tests/testMethod.cpp +++ b/wrap/tests/testMethod.cpp @@ -32,12 +32,13 @@ TEST( Method, Constructor ) { /* ************************************************************************* */ // addOverload TEST( Method, addOverload ) { - Method method("myName"); - bool verbose = true, is_const = true; + Method method; + method.initializeOrCheck("myName"); + bool is_const = true; ArgumentList args; const ReturnValue retVal(ReturnType("return_type")); - method.addOverload(verbose, is_const, "myName", args, retVal); - EXPECT_LONGS_EQUAL(1,method.nrOverloads()); + method.addOverload("myName", args, retVal, is_const); + EXPECT_LONGS_EQUAL(1, method.nrOverloads()); } /* ************************************************************************* */