142 lines
3.7 KiB
C++
142 lines
3.7 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 <string>
|
|
#include <vector>
|
|
|
|
namespace wrap {
|
|
|
|
/**
|
|
* Class to encapuslate a qualified name, i.e., with (nested) namespaces
|
|
*/
|
|
struct Qualified {
|
|
|
|
std::vector<std::string> namespaces; ///< Stack of namespaces
|
|
std::string name; ///< type name
|
|
|
|
Qualified(const std::string& name_ = "") :
|
|
name(name_) {
|
|
}
|
|
|
|
bool empty() const {
|
|
return namespaces.empty() && name.empty();
|
|
}
|
|
|
|
void clear() {
|
|
namespaces.clear();
|
|
name.clear();
|
|
}
|
|
|
|
bool operator!=(const Qualified& other) const {
|
|
return other.name != name || other.namespaces != namespaces;
|
|
}
|
|
|
|
/// Return a qualified string using given delimiter
|
|
std::string qualifiedName(const std::string& delimiter = "") const {
|
|
std::string result;
|
|
for (std::size_t i = 0; 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;
|
|
}
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const Qualified& q) {
|
|
os << q.qualifiedName("::");
|
|
return os;
|
|
}
|
|
|
|
};
|
|
|
|
} // \namespace wrap
|
|
|
|
#include <boost/spirit/include/classic_core.hpp>
|
|
#include <boost/spirit/include/classic_push_back_actor.hpp>
|
|
#include <boost/spirit/include/classic_clear_actor.hpp>
|
|
#include <boost/spirit/include/classic_assign_actor.hpp>
|
|
|
|
namespace classic = BOOST_SPIRIT_CLASSIC_NS;
|
|
|
|
// http://boost-spirit.com/distrib/spirit_1_8_2/libs/spirit/doc/grammar.html
|
|
struct type_grammar: public classic::grammar<type_grammar> {
|
|
|
|
wrap::Qualified& result_; ///< successful parse will be placed in here
|
|
|
|
/// Construct type grammar and specify where result is placed
|
|
type_grammar(wrap::Qualified& result) :
|
|
result_(result) {
|
|
}
|
|
|
|
/// Definition of type grammar
|
|
template<typename ScannerT>
|
|
struct definition {
|
|
|
|
typedef classic::rule<ScannerT> Rule;
|
|
|
|
Rule void_p, basisType_p, eigenType_p, keywords_p, stlType_p, className_p,
|
|
namepsace_p, namespace_del_p, class_p, type_p;
|
|
|
|
definition(type_grammar const& self) {
|
|
|
|
using namespace classic;
|
|
|
|
void_p = str_p("void")[assign_a(self.result_.name)];
|
|
|
|
basisType_p = (str_p("string") | "bool" | "size_t" | "int" | "double"
|
|
| "char" | "unsigned char")[assign_a(self.result_.name)];
|
|
|
|
eigenType_p = (str_p("Vector") | "Matrix")[assign_a(self.result_.name)];
|
|
|
|
keywords_p = (str_p("const") | "static" | "namespace" | "void"
|
|
| basisType_p);
|
|
|
|
stlType_p = (str_p("vector") | "list");
|
|
|
|
className_p = (lexeme_d[upper_p >> *(alnum_p | '_')] - eigenType_p
|
|
- keywords_p) | stlType_p;
|
|
|
|
namepsace_p = lexeme_d[lower_p >> *(alnum_p | '_')] - keywords_p;
|
|
|
|
namespace_del_p = namepsace_p[push_back_a(self.result_.namespaces)]
|
|
>> str_p("::");
|
|
|
|
class_p = *namespace_del_p >> className_p[assign_a(self.result_.name)];
|
|
|
|
type_p = eps_p[clear_a(self.result_)] //
|
|
>> void_p | basisType_p | eigenType_p | class_p;
|
|
}
|
|
|
|
Rule const& start() const {
|
|
return type_p;
|
|
}
|
|
|
|
};
|
|
};
|
|
|
|
|