323 lines
8.6 KiB
C++
323 lines
8.6 KiB
C++
/* ----------------------------------------------------------------------------
|
|
|
|
* 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 Qualified.h
|
|
* @brief Qualified name
|
|
* @author Frank Dellaert
|
|
* @date Nov 11, 2014
|
|
**/
|
|
|
|
#pragma once
|
|
|
|
#include <wrap/spirit.h>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <iostream>
|
|
|
|
namespace wrap {
|
|
|
|
/**
|
|
* Class to encapuslate a qualified name, i.e., with (nested) namespaces
|
|
*/
|
|
class Qualified {
|
|
|
|
//protected:
|
|
public:
|
|
|
|
std::vector<std::string> namespaces_; ///< Stack of namespaces
|
|
std::string name_; ///< type name
|
|
|
|
friend struct TypeGrammar;
|
|
friend class TemplateSubstitution;
|
|
|
|
public:
|
|
|
|
/// the different categories
|
|
typedef enum {
|
|
CLASS = 1, EIGEN = 2, BASIS = 3, VOID = 4
|
|
} Category;
|
|
Category category;
|
|
|
|
Qualified() :
|
|
category(VOID) {
|
|
}
|
|
|
|
Qualified(const std::string& n, Category c = CLASS) :
|
|
name_(n), category(c) {
|
|
}
|
|
|
|
Qualified(const std::string& ns1, const std::string& ns2,
|
|
const std::string& n, Category c = CLASS) :
|
|
name_(n), category(c) {
|
|
namespaces_.push_back(ns1);
|
|
namespaces_.push_back(ns2);
|
|
}
|
|
|
|
Qualified(const std::string& ns1, const std::string& n, Category c = CLASS) :
|
|
name_(n), category(c) {
|
|
namespaces_.push_back(ns1);
|
|
}
|
|
|
|
Qualified(std::vector<std::string> ns, const std::string& name) :
|
|
namespaces_(ns), name_(name), category(CLASS) {
|
|
}
|
|
|
|
std::string name() const {
|
|
return name_;
|
|
}
|
|
|
|
std::vector<std::string> namespaces() const {
|
|
return namespaces_;
|
|
}
|
|
|
|
// Qualified is 'abused' as template argument name as well
|
|
// this function checks whether *this matches with templateArg
|
|
bool match(const std::string& templateArg) const {
|
|
return (name_ == templateArg && namespaces_.empty()); //TODO && category == CLASS);
|
|
}
|
|
|
|
void rename(const Qualified& q) {
|
|
namespaces_ = q.namespaces_;
|
|
name_ = q.name_;
|
|
category = q.category;
|
|
}
|
|
|
|
void expand(const std::string& expansion) {
|
|
name_ += expansion;
|
|
}
|
|
|
|
bool operator==(const Qualified& other) const {
|
|
return namespaces_ == other.namespaces_ && name_ == other.name_
|
|
&& category == other.category;
|
|
}
|
|
|
|
bool empty() const {
|
|
return namespaces_.empty() && name_.empty();
|
|
}
|
|
|
|
virtual void clear() {
|
|
namespaces_.clear();
|
|
name_.clear();
|
|
category = VOID;
|
|
}
|
|
|
|
bool isScalar() const {
|
|
return (name() == "bool" || name() == "char"
|
|
|| name() == "unsigned char" || name() == "int"
|
|
|| name() == "size_t" || name() == "double");
|
|
}
|
|
|
|
bool isString() const {
|
|
return name() == "string";
|
|
}
|
|
|
|
bool isEigen() const {
|
|
return name() == "Vector" || name() == "Matrix";
|
|
}
|
|
|
|
bool isNonBasicType() const {
|
|
return !isString() && !isScalar() && !isEigen();
|
|
}
|
|
|
|
public:
|
|
|
|
static Qualified MakeClass(std::vector<std::string> namespaces,
|
|
const std::string& name) {
|
|
return Qualified(namespaces, name);
|
|
}
|
|
|
|
static Qualified MakeEigen(const std::string& name) {
|
|
return Qualified(name, EIGEN);
|
|
}
|
|
|
|
static Qualified MakeBasis(const std::string& name) {
|
|
return Qualified(name, BASIS);
|
|
}
|
|
|
|
static Qualified MakeVoid() {
|
|
return Qualified("void", VOID);
|
|
}
|
|
|
|
/// Return a qualified namespace using given delimiter
|
|
std::string qualifiedNamespaces(const std::string& delimiter = "") const {
|
|
std::string result;
|
|
for (std::size_t i = 0; i < namespaces_.size(); ++i)
|
|
result += (namespaces_[i] + ((i<namespaces_.size()-1)?delimiter:""));
|
|
return result;
|
|
}
|
|
|
|
/// Return a qualified string using given delimiter
|
|
std::string qualifiedName(const std::string& delimiter = "", size_t fromLevel = 0) const {
|
|
std::string result;
|
|
for (std::size_t i = fromLevel; i < namespaces_.size(); ++i)
|
|
result += (namespaces_[i] + delimiter);
|
|
result += name_;
|
|
return result;
|
|
}
|
|
|
|
/// Return a matlab file name, i.e. "toolboxPath/+ns1/+ns2/name.m"
|
|
std::string matlabName(const std::string& toolboxPath) const {
|
|
std::string result = toolboxPath;
|
|
for (std::size_t i = 0; i < namespaces_.size(); ++i)
|
|
result += ("/+" + namespaces_[i]);
|
|
result += "/" + name_ + ".m";
|
|
return result;
|
|
}
|
|
|
|
/// the Cython class in pxd
|
|
std::string cythonClassName() const {
|
|
return qualifiedName("_", 1);
|
|
}
|
|
|
|
/// the Python class in pyx
|
|
std::string pythonClassName() const {
|
|
return cythonClassName();
|
|
}
|
|
|
|
/// return the Cython class in pxd corresponding to a Python class in pyx
|
|
std::string pyxCythonClass() const {
|
|
if (isNonBasicType())
|
|
if (namespaces_.size() > 0)
|
|
return namespaces_[0] + "." + cythonClassName();
|
|
else {
|
|
std::cerr << "Class without namespace: " << cythonClassName() << std::endl;
|
|
throw std::runtime_error("Error: User type without namespace!!");
|
|
}
|
|
else if (isEigen()) {
|
|
return name_ + "Xd";
|
|
} else
|
|
return name_;
|
|
}
|
|
|
|
/// the internal Cython shared obj in a Python class wrappper
|
|
std::string pyxCythonObj() const {
|
|
return "gt" + cythonClassName() + "_";
|
|
}
|
|
|
|
std::string pyxSharedCythonClass() const {
|
|
return "shared_ptr[" + pyxCythonClass() + "]";
|
|
}
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const Qualified& q) {
|
|
os << q.qualifiedName("::");
|
|
return os;
|
|
}
|
|
|
|
};
|
|
|
|
/* ************************************************************************* */
|
|
// http://boost-spirit.com/distrib/spirit_1_8_2/libs/spirit/doc/grammar.html
|
|
struct TypeGrammar: classic::grammar<TypeGrammar> {
|
|
|
|
wrap::Qualified& result_; ///< successful parse will be placed in here
|
|
|
|
/// Construct type grammar and specify where result is placed
|
|
TypeGrammar(wrap::Qualified& result) :
|
|
result_(result) {
|
|
}
|
|
|
|
/// Definition of type grammar
|
|
template<typename ScannerT>
|
|
struct definition: BasicRules<ScannerT> {
|
|
|
|
typedef classic::rule<ScannerT> Rule;
|
|
|
|
Rule void_p, basisType_p, eigenType_p, namespace_del_p, class_p, type_p;
|
|
|
|
definition(TypeGrammar const& self) {
|
|
|
|
using namespace wrap;
|
|
using namespace classic;
|
|
typedef BasicRules<ScannerT> Basic;
|
|
|
|
// HACK: use const values instead of using enums themselves - somehow this doesn't result in values getting assigned to gibberish
|
|
static const Qualified::Category EIGEN = Qualified::EIGEN;
|
|
static const Qualified::Category BASIS = Qualified::BASIS;
|
|
static const Qualified::Category CLASS = Qualified::CLASS;
|
|
static const Qualified::Category VOID = Qualified::VOID;
|
|
|
|
void_p = str_p("void") //
|
|
[assign_a(self.result_.name_)] //
|
|
[assign_a(self.result_.category, VOID)];
|
|
|
|
basisType_p = Basic::basisType_p //
|
|
[assign_a(self.result_.name_)] //
|
|
[assign_a(self.result_.category, BASIS)];
|
|
|
|
eigenType_p = Basic::eigenType_p //
|
|
[assign_a(self.result_.name_)] //
|
|
[assign_a(self.result_.category, EIGEN)];
|
|
|
|
namespace_del_p = Basic::namespace_p //
|
|
[push_back_a(self.result_.namespaces_)] >> str_p("::");
|
|
|
|
class_p = *namespace_del_p >> Basic::className_p //
|
|
[assign_a(self.result_.name_)] //
|
|
[assign_a(self.result_.category, CLASS)];
|
|
|
|
type_p = void_p | basisType_p | class_p | eigenType_p;
|
|
}
|
|
|
|
Rule const& start() const {
|
|
return type_p;
|
|
}
|
|
|
|
};
|
|
};
|
|
// type_grammar
|
|
|
|
/* ************************************************************************* */
|
|
// http://boost-spirit.com/distrib/spirit_1_8_2/libs/spirit/doc/grammar.html
|
|
template<char OPEN, char CLOSE>
|
|
struct TypeListGrammar: public classic::grammar<TypeListGrammar<OPEN, CLOSE> > {
|
|
|
|
typedef std::vector<wrap::Qualified> TypeList;
|
|
TypeList& result_; ///< successful parse will be placed in here
|
|
|
|
/// Construct type grammar and specify where result is placed
|
|
TypeListGrammar(TypeList& result) :
|
|
result_(result) {
|
|
}
|
|
|
|
/// Definition of type grammar
|
|
template<typename ScannerT>
|
|
struct definition {
|
|
|
|
wrap::Qualified type; ///< temporary for use during parsing
|
|
TypeGrammar type_g; ///< Individual Type grammars
|
|
|
|
classic::rule<ScannerT> type_p, typeList_p;
|
|
|
|
definition(TypeListGrammar const& self) :
|
|
type_g(type) {
|
|
using namespace classic;
|
|
|
|
type_p = type_g[push_back_a(self.result_, type)][clear_a(type)];
|
|
|
|
typeList_p = OPEN >> !type_p >> *(',' >> type_p) >> CLOSE;
|
|
}
|
|
|
|
classic::rule<ScannerT> const& start() const {
|
|
return typeList_p;
|
|
}
|
|
|
|
};
|
|
};
|
|
// TypeListGrammar
|
|
|
|
/* ************************************************************************* */
|
|
// Needed for other parsers in Argument.h and ReturnType.h
|
|
static const bool T = true;
|
|
|
|
} // \namespace wrap
|
|
|