diff --git a/wrap/DOCS.md b/wrap/DOCS.md index 8b0df86c3..ecb6ee985 100644 --- a/wrap/DOCS.md +++ b/wrap/DOCS.md @@ -15,8 +15,8 @@ The python wrapper supports keyword arguments for functions/methods. Hence, the - Eigen types: `Matrix`, `Vector`. - C/C++ basic types: `string`, `bool`, `size_t`, `int`, `double`, `char`, `unsigned char`. - `void` - - Any class with which be copied with `boost::make_shared()`. - - `boost::shared_ptr` of any object type. + - Any class with which be copied with `std::make_shared()`. + - `std::shared_ptr` of any object type. - Constructors - Overloads are supported, but arguments of different types *have* to have different names. @@ -37,8 +37,8 @@ The python wrapper supports keyword arguments for functions/methods. Hence, the - Eigen types: `Matrix`, `Vector`. - Eigen types and classes as an optionally const reference. - C/C++ basic types: `string`, `bool`, `size_t`, `size_t`, `double`, `char`, `unsigned char`. - - Any class with which be copied with `boost::make_shared()` (except Eigen). - - `boost::shared_ptr` of any object type (except Eigen). + - Any class with which be copied with `std::make_shared()` (except Eigen). + - `std::shared_ptr` of any object type (except Eigen). - Properties or Variables - You can specify class variables in the interface file as long as they are in the `public` scope, e.g. @@ -142,7 +142,7 @@ The python wrapper supports keyword arguments for functions/methods. Hence, the - Signature of clone function - `clone()` will be called virtually, so must appear at least at the top of the inheritance tree ```cpp - virtual boost::shared_ptr clone() const; + virtual std::shared_ptr clone() const; ``` - Templates diff --git a/wrap/README.md b/wrap/README.md index a04a2ef2d..1dfdda14e 100644 --- a/wrap/README.md +++ b/wrap/README.md @@ -40,7 +40,7 @@ pybind_wrap(${PROJECT_NAME}_py # target ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.tpl # the wrapping template file ${PROJECT_NAME} # libs "${PROJECT_NAME}" # dependencies - ON # use boost + ON # use boost serialization ) ``` diff --git a/wrap/cmake/MatlabWrap.cmake b/wrap/cmake/MatlabWrap.cmake index eaffcc059..c45d8c050 100644 --- a/wrap/cmake/MatlabWrap.cmake +++ b/wrap/cmake/MatlabWrap.cmake @@ -63,11 +63,11 @@ endmacro() # Consistent and user-friendly wrap function function(matlab_wrap interfaceHeader moduleName linkLibraries - extraIncludeDirs extraMexFlags ignore_classes) + extraIncludeDirs extraMexFlags ignore_classes use_boost_serialization) find_and_configure_matlab() wrap_and_install_library("${interfaceHeader}" "${moduleName}" "${linkLibraries}" "${extraIncludeDirs}" "${extraMexFlags}" - "${ignore_classes}") + "${ignore_classes}" "${use_boost_serialization}") endfunction() # Wrapping function. Builds a mex module from the provided @@ -86,16 +86,18 @@ endfunction() # extraMexFlags: Any *additional* flags to pass to the compiler when building # the wrap code. Normally, leave this empty. # ignore_classes: List of classes to ignore in the wrapping. +# use_boost_serialization: Flag indicating whether to provide Boost-based serialization. function(wrap_and_install_library interfaceHeader moduleName linkLibraries - extraIncludeDirs extraMexFlags ignore_classes) + extraIncludeDirs extraMexFlags ignore_classes use_boost_serialization) wrap_library_internal("${interfaceHeader}" "${moduleName}" "${linkLibraries}" - "${extraIncludeDirs}" "${mexFlags}") + "${extraIncludeDirs}" "${extraMexFlags}" "${ignore_classes}" + "${use_boost_serialization}") install_wrapped_library_internal("${moduleName}") endfunction() # Internal function that wraps a library and compiles the wrapper function(wrap_library_internal interfaceHeader moduleName linkLibraries extraIncludeDirs - extraMexFlags) + extraMexFlags ignore_classes use_boost_serialization) if(UNIX AND NOT APPLE) if(CMAKE_SIZEOF_VOID_P EQUAL 8) set(mexModuleExt mexa64) @@ -146,30 +148,6 @@ function(wrap_library_internal interfaceHeader moduleName linkLibraries extraInc endif() endforeach() - # CHRIS: Temporary fix. On my system the get_target_property above returned - # Not-found for gtsam module This needs to be fixed!! - if(UNIX AND NOT APPLE) - list( - APPEND - automaticDependencies - ${Boost_SERIALIZATION_LIBRARY_RELEASE} - ${Boost_FILESYSTEM_LIBRARY_RELEASE} - ${Boost_SYSTEM_LIBRARY_RELEASE} - ${Boost_THREAD_LIBRARY_RELEASE} - ${Boost_DATE_TIME_LIBRARY_RELEASE}) - # Only present in Boost >= 1.48.0 - if(Boost_TIMER_LIBRARY_RELEASE) - list(APPEND automaticDependencies ${Boost_TIMER_LIBRARY_RELEASE} - ${Boost_CHRONO_LIBRARY_RELEASE}) - if(WRAP_MEX_BUILD_STATIC_MODULE) - # list(APPEND automaticDependencies -Wl,--no-as-needed -lrt) - endif() - endif() - endif() - - # message("AUTOMATIC DEPENDENCIES: ${automaticDependencies}") CHRIS: End - # temporary fix - # Separate dependencies set(correctedOtherLibraries "") set(otherLibraryTargets "") @@ -249,6 +227,13 @@ function(wrap_library_internal interfaceHeader moduleName linkLibraries extraInc set(GTWRAP_PATH_SEPARATOR ";") endif() + # Set boost serialization flag for the python script call below. + if(use_boost_serialization) + set(_BOOST_SERIALIZATION "--use-boost-serialization") + else(use_boost_serialization) + set(_BOOST_SERIALIZATION "") + endif(use_boost_serialization) + add_custom_command( OUTPUT ${generated_cpp_file} DEPENDS ${interfaceHeader} ${module_library_target} ${otherLibraryTargets} @@ -258,7 +243,7 @@ function(wrap_library_internal interfaceHeader moduleName linkLibraries extraInc "PYTHONPATH=${GTWRAP_PACKAGE_DIR}${GTWRAP_PATH_SEPARATOR}$ENV{PYTHONPATH}" ${PYTHON_EXECUTABLE} ${MATLAB_WRAP_SCRIPT} --src "${interfaceHeader}" --module_name ${moduleName} --out ${generated_files_path} - --top_module_namespaces ${moduleName} --ignore ${ignore_classes} + --top_module_namespaces ${moduleName} --ignore ${ignore_classes} ${_BOOST_SERIALIZATION} VERBATIM WORKING_DIRECTORY ${generated_files_path}) diff --git a/wrap/cmake/PybindWrap.cmake b/wrap/cmake/PybindWrap.cmake index 2008bf2dd..dd579bd5e 100644 --- a/wrap/cmake/PybindWrap.cmake +++ b/wrap/cmake/PybindWrap.cmake @@ -29,7 +29,7 @@ set(PYBIND11_PYTHON_VERSION ${WRAP_PYTHON_VERSION}) # module_template: The template file (.tpl) from which to generate the Pybind11 module. # libs: Libraries to link with. # dependencies: Dependencies which need to be built before the wrapper. -# use_boost (optional): Flag indicating whether to include Boost. +# use_boost_serialization (optional): Flag indicating whether to include Boost. function( pybind_wrap target @@ -42,12 +42,12 @@ function( libs dependencies) set(ExtraMacroArgs ${ARGN}) - list(GET ExtraMacroArgs 0 USE_BOOST) - if(USE_BOOST) - set(_WRAP_BOOST_ARG "--use-boost") - else(USE_BOOST) + list(GET ExtraMacroArgs 0 USE_BOOST_SERIALIZATION) + if(USE_BOOST_SERIALIZATION) + set(_WRAP_BOOST_ARG "--use-boost-serialization") + else(USE_BOOST_SERIALIZATION) set(_WRAP_BOOST_ARG "") - endif(USE_BOOST) + endif(USE_BOOST_SERIALIZATION) if(UNIX) set(GTWRAP_PATH_SEPARATOR ":") diff --git a/wrap/gtwrap/interface_parser/function.py b/wrap/gtwrap/interface_parser/function.py index 9e68c6ece..b3f5d3227 100644 --- a/wrap/gtwrap/interface_parser/function.py +++ b/wrap/gtwrap/interface_parser/function.py @@ -94,9 +94,9 @@ class ArgumentList: """Return a list of the names of all the arguments.""" return self.args_list - def to_cpp(self, use_boost: bool) -> List[str]: + def to_cpp(self) -> List[str]: """Generate the C++ code for wrapping.""" - return [arg.ctype.to_cpp(use_boost) for arg in self.args_list] + return [arg.ctype.to_cpp() for arg in self.args_list] class ReturnType: @@ -135,7 +135,7 @@ class ReturnType: return "{}{}".format( self.type1, (', ' + self.type2.__repr__()) if self.type2 else '') - def to_cpp(self, use_boost: bool) -> str: + def to_cpp(self) -> str: """ Generate the C++ code for wrapping. @@ -144,10 +144,9 @@ class ReturnType: """ if self.type2: return "std::pair<{type1},{type2}>".format( - type1=self.type1.to_cpp(use_boost), - type2=self.type2.to_cpp(use_boost)) + type1=self.type1.to_cpp(), type2=self.type2.to_cpp()) else: - return self.type1.to_cpp(use_boost) + return self.type1.to_cpp() class GlobalFunction: diff --git a/wrap/gtwrap/interface_parser/type.py b/wrap/gtwrap/interface_parser/type.py index 7aacf0b81..deb2e2256 100644 --- a/wrap/gtwrap/interface_parser/type.py +++ b/wrap/gtwrap/interface_parser/type.py @@ -14,8 +14,8 @@ Author: Duy Nguyen Ta, Fan Jiang, Matthew Sklar, Varun Agrawal, and Frank Dellae from typing import List, Sequence, Union -from pyparsing import (Forward, Optional, Or, ParseResults, # type: ignore - delimitedList) +from pyparsing import ParseResults # type: ignore +from pyparsing import Forward, Optional, Or, delimitedList from .tokens import (BASIS_TYPES, CONST, IDENT, LOPBRACK, RAW_POINTER, REF, ROPBRACK, SHARED_POINTER) @@ -217,21 +217,17 @@ class Type: is_const="const " if self.is_const else "", is_ptr_or_ref=" " + is_ptr_or_ref if is_ptr_or_ref else "") - def to_cpp(self, use_boost: bool) -> str: + def to_cpp(self) -> str: """ Generate the C++ code for wrapping. Treat all pointers as "const shared_ptr&" Treat Matrix and Vector as "const Matrix&" and "const Vector&" resp. - - Args: - use_boost: Flag indicating whether to use boost::shared_ptr or std::shared_ptr. """ - shared_ptr_ns = "boost" if use_boost else "std" if self.is_shared_ptr: - typename = "{ns}::shared_ptr<{typename}>".format( - ns=shared_ptr_ns, typename=self.typename.to_cpp()) + typename = "std::shared_ptr<{typename}>".format( + typename=self.typename.to_cpp()) elif self.is_ptr: typename = "{typename}*".format(typename=self.typename.to_cpp()) elif self.is_ref or self.typename.name in ["Matrix", "Vector"]: @@ -250,6 +246,7 @@ class Type: """Convenience method to get the typename of this type.""" return self.typename.name + class TemplatedType: """ Parser rule for data types which are templated. @@ -295,25 +292,19 @@ class TemplatedType: return "TemplatedType({typename.namespaces}::{typename.name})".format( typename=self.typename) - def to_cpp(self, use_boost: bool): + def to_cpp(self): """ Generate the C++ code for wrapping. - - Args: - use_boost: Flag indicating whether to use boost::shared_ptr or std::shared_ptr. """ # Use Type.to_cpp to do the heavy lifting for the template parameters. - template_args = ", ".join( - [t.to_cpp(use_boost) for t in self.template_params]) + template_args = ", ".join([t.to_cpp() for t in self.template_params]) typename = "{typename}<{template_args}>".format( typename=self.typename.qualified_name(), template_args=template_args) - shared_ptr_ns = "boost" if use_boost else "std" if self.is_shared_ptr: - typename = "{ns}::shared_ptr<{typename}>".format(ns=shared_ptr_ns, - typename=typename) + typename = f"std::shared_ptr<{typename}>" elif self.is_ptr: typename = "{typename}*".format(typename=typename) elif self.is_ref or self.typename.name in ["Matrix", "Vector"]: diff --git a/wrap/gtwrap/matlab_wrapper/templates.py b/wrap/gtwrap/matlab_wrapper/templates.py index 3d1306dca..7783c8e9c 100644 --- a/wrap/gtwrap/matlab_wrapper/templates.py +++ b/wrap/gtwrap/matlab_wrapper/templates.py @@ -10,7 +10,7 @@ class WrapperTemplate: """) typdef_collectors = textwrap.dedent('''\ - typedef std::set*> Collector_{class_name}; + typedef std::set*> Collector_{class_name}; static Collector_{class_name} collector_{class_name}; ''') @@ -77,10 +77,10 @@ class WrapperTemplate: collector_function_upcast_from_void = textwrap.dedent('''\ void {class_name}_upcastFromVoid_{id}(int nargout, mxArray *out[], int nargin, const mxArray *in[]) {{ mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr<{cpp_name}> Shared; - boost::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); + typedef std::shared_ptr<{cpp_name}> Shared; + std::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); - Shared *self = new Shared(boost::static_pointer_cast<{cpp_name}>(*asVoid)); + Shared *self = new Shared(std::static_pointer_cast<{cpp_name}>(*asVoid)); *reinterpret_cast(mxGetData(out[0])) = self; }}\n ''') @@ -102,7 +102,7 @@ class WrapperTemplate: ''') collector_function_serialize = textwrap.indent(textwrap.dedent("""\ - typedef boost::shared_ptr<{full_name}> Shared; + typedef std::shared_ptr<{full_name}> Shared; checkArguments("string_serialize",nargout,nargin-1,0); Shared obj = unwrap_shared_ptr<{full_name}>(in[0], "ptr_{namespace}{class_name}"); ostringstream out_archive_stream; @@ -113,7 +113,7 @@ class WrapperTemplate: prefix=' ') collector_function_deserialize = textwrap.indent(textwrap.dedent("""\ - typedef boost::shared_ptr<{full_name}> Shared; + typedef std::shared_ptr<{full_name}> Shared; checkArguments("{namespace}{class_name}.string_deserialize",nargout,nargin,1); string serialized = unwrap< string >(in[0]); istringstream in_archive_stream(serialized); @@ -143,7 +143,7 @@ class WrapperTemplate: collector_function_shared_return = textwrap.indent(textwrap.dedent('''\ {{ - boost::shared_ptr<{name}> shared({shared_obj}); + std::shared_ptr<{name}> shared({shared_obj}); out[{id}] = wrap_shared_ptr(shared,"{name}"); }}{new_line}'''), prefix=' ') diff --git a/wrap/gtwrap/matlab_wrapper/wrapper.py b/wrap/gtwrap/matlab_wrapper/wrapper.py index 4c84da84e..0f156a6de 100755 --- a/wrap/gtwrap/matlab_wrapper/wrapper.py +++ b/wrap/gtwrap/matlab_wrapper/wrapper.py @@ -33,13 +33,15 @@ class MatlabWrapper(CheckMixin, FormatMixin): def __init__(self, module_name, top_module_namespace='', - ignore_classes=()): + ignore_classes=(), + use_boost_serialization=False): super().__init__() self.module_name = module_name self.top_module_namespace = top_module_namespace self.ignore_classes = ignore_classes self.verbose = False + self.use_boost_serialization = use_boost_serialization # Map the data type to its Matlab class. # Found in Argument.cpp in old wrapper @@ -358,8 +360,7 @@ class MatlabWrapper(CheckMixin, FormatMixin): elif (self.is_shared_ptr(arg.ctype) or self.can_be_pointer(arg.ctype)) and \ arg.ctype.typename.name not in self.ignore_namespace: - arg_type = "{std_boost}::shared_ptr<{ctype_sep}>".format( - std_boost='boost' if constructor else 'boost', + arg_type = "std::shared_ptr<{ctype_sep}>".format( ctype_sep=ctype_sep) unwrap = 'unwrap_shared_ptr< {ctype_sep} >(in[{id}], "ptr_{ctype}");'.format( ctype_sep=ctype_sep, ctype=ctype_camel, id=arg_id) @@ -762,13 +763,12 @@ class MatlabWrapper(CheckMixin, FormatMixin): {varargout} = {wrapper}({num}, this); this.{name} = {varargout}; end - """.format( - name=propty.name, - varargout='varargout{1}', - wrapper=self._wrapper_name(), - num=self._update_wrapper_id( - (namespace_name, inst_class, propty.name, propty), - function_name=function_name)) + """.format(name=propty.name, + varargout='varargout{1}', + wrapper=self._wrapper_name(), + num=self._update_wrapper_id( + (namespace_name, inst_class, propty.name, propty), + function_name=function_name)) properties.append(getter) # Setter doesn't need varargin since it needs just one input. @@ -778,12 +778,11 @@ class MatlabWrapper(CheckMixin, FormatMixin): obj.{name} = value; {wrapper}({num}, this, value); end - """.format( - name=propty.name, - wrapper=self._wrapper_name(), - num=self._update_wrapper_id( - (namespace_name, inst_class, propty.name, propty), - function_name=function_name)) + """.format(name=propty.name, + wrapper=self._wrapper_name(), + num=self._update_wrapper_id( + (namespace_name, inst_class, propty.name, propty), + function_name=function_name)) properties.append(setter) return properties @@ -860,9 +859,11 @@ class MatlabWrapper(CheckMixin, FormatMixin): continue if method_name == 'serialize': - serialize[0] = True - method_text += self.wrap_class_serialize_method( - namespace_name, inst_class) + if self.use_boost_serialization: + serialize[0] = True + method_text += self.wrap_class_serialize_method( + namespace_name, inst_class) + else: # Generate method code method_text += textwrap.indent(textwrap.dedent("""\ @@ -998,7 +999,7 @@ class MatlabWrapper(CheckMixin, FormatMixin): """), prefix=" ") - if serialize: + if serialize and self.use_boost_serialization: method_text += WrapperTemplate.matlab_deserialize.format( class_name=namespace_name + '.' + instantiated_class.name, wrapper=self._wrapper_name(), @@ -1192,7 +1193,7 @@ class MatlabWrapper(CheckMixin, FormatMixin): shared_obj = 'pairResult.' + pair_value if not (return_type.is_shared_ptr or return_type.is_ptr): - shared_obj = 'boost::make_shared<{name}>({shared_obj})' \ + shared_obj = 'std::make_shared<{name}>({shared_obj})' \ .format(name=self._format_type_name(return_type.typename), shared_obj='pairResult.' + pair_value) @@ -1230,7 +1231,18 @@ class MatlabWrapper(CheckMixin, FormatMixin): obj=obj, method_name_sep=sep_method_name('.')) else: method_name_sep_dot = sep_method_name('.') - shared_obj_template = 'boost::make_shared<{method_name_sep_col}>({obj}),' \ + + # Specialize for std::optional so we access the underlying member + #TODO(Varun) How do we handle std::optional as a Mex type? + if isinstance(ctype, parser.TemplatedType) and \ + "std::optional" == str(ctype.typename)[:13]: + obj = f"*{obj}" + type_name = ctype.template_params[0].typename + method_name_sep_dot = ".".join( + type_name.namespaces) + f".{type_name.name}" + + + shared_obj_template = 'std::make_shared<{method_name_sep_col}>({obj}),' \ '"{method_name_sep_dot}"' shared_obj = shared_obj_template \ .format(method_name_sep_col=sep_method_name(), @@ -1351,7 +1363,7 @@ class MatlabWrapper(CheckMixin, FormatMixin): if collector_func[2] == 'collectorInsertAndMakeBase': body += textwrap.indent(textwrap.dedent('''\ mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr<{class_name_sep}> Shared;\n + typedef std::shared_ptr<{class_name_sep}> Shared;\n Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_{class_name}.insert(self); ''').format(class_name_sep=class_name_separated, @@ -1360,7 +1372,7 @@ class MatlabWrapper(CheckMixin, FormatMixin): if collector_func[1].parent_class: body += textwrap.indent(textwrap.dedent(''' - typedef boost::shared_ptr<{}> SharedBase; + typedef std::shared_ptr<{}> SharedBase; out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[0])) = new SharedBase(*self); ''').format(collector_func[1].parent_class), @@ -1373,7 +1385,7 @@ class MatlabWrapper(CheckMixin, FormatMixin): if collector_func[1].parent_class: base += textwrap.indent(textwrap.dedent(''' - typedef boost::shared_ptr<{}> SharedBase; + typedef std::shared_ptr<{}> SharedBase; out[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[1])) = new SharedBase(*self); ''').format(collector_func[1].parent_class), @@ -1381,7 +1393,7 @@ class MatlabWrapper(CheckMixin, FormatMixin): body += textwrap.dedent('''\ mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr<{class_name_sep}> Shared;\n + typedef std::shared_ptr<{class_name_sep}> Shared;\n {body_args} Shared *self = new Shared(new {class_name_sep}({params})); collector_{class_name}.insert(self); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); @@ -1394,7 +1406,7 @@ class MatlabWrapper(CheckMixin, FormatMixin): elif collector_func[2] == 'deconstructor': body += textwrap.indent(textwrap.dedent('''\ - typedef boost::shared_ptr<{class_name_sep}> Shared; + typedef std::shared_ptr<{class_name_sep}> Shared; checkArguments("delete_{class_name}",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_{class_name}::iterator item; @@ -1408,16 +1420,18 @@ class MatlabWrapper(CheckMixin, FormatMixin): prefix=' ') elif extra == 'serialize': - body += self.wrap_collector_function_serialize( - collector_func[1].name, - full_name=collector_func[1].to_cpp(), - namespace=collector_func[0]) + if self.use_boost_serialization: + body += self.wrap_collector_function_serialize( + collector_func[1].name, + full_name=collector_func[1].to_cpp(), + namespace=collector_func[0]) elif extra == 'deserialize': - body += self.wrap_collector_function_deserialize( - collector_func[1].name, - full_name=collector_func[1].to_cpp(), - namespace=collector_func[0]) + if self.use_boost_serialization: + body += self.wrap_collector_function_deserialize( + collector_func[1].name, + full_name=collector_func[1].to_cpp(), + namespace=collector_func[0]) elif is_method or is_static_method: method_name = '' @@ -1610,7 +1624,8 @@ class MatlabWrapper(CheckMixin, FormatMixin): class_name_sep=cls.name)) # Get the Boost exports for serialization - if cls.original.namespaces() and self._has_serialization(cls): + if self.use_boost_serialization and \ + cls.original.namespaces() and self._has_serialization(cls): boost_class_export_guid += 'BOOST_CLASS_EXPORT_GUID({}, "{}");\n'.format( class_name_sep, class_name) @@ -1648,12 +1663,19 @@ class MatlabWrapper(CheckMixin, FormatMixin): # Generate the header includes includes_list = sorted(self.includes, key=lambda include: include.header) + + # If boost serialization is enabled, include serialization headers + if self.use_boost_serialization: + boost_headers = WrapperTemplate.boost_headers + else: + boost_headers = "" + includes = textwrap.dedent("""\ {wrapper_file_headers} {boost_headers} {includes_list} """).format(wrapper_file_headers=self.wrapper_file_headers.strip(), - boost_headers=WrapperTemplate.boost_headers, + boost_headers=boost_headers, includes_list='\n'.join(map(str, includes_list))) preamble = self.generate_preamble() diff --git a/wrap/gtwrap/pybind_wrapper.py b/wrap/gtwrap/pybind_wrapper.py index 31d8d4444..78730a909 100755 --- a/wrap/gtwrap/pybind_wrapper.py +++ b/wrap/gtwrap/pybind_wrapper.py @@ -10,7 +10,7 @@ Code generator for wrapping a C++ module with Pybind11 Author: Duy Nguyen Ta, Fan Jiang, Matthew Sklar, Varun Agrawal, and Frank Dellaert """ -# pylint: disable=too-many-arguments, too-many-instance-attributes, no-self-use, no-else-return, too-many-arguments, unused-format-string-argument, line-too-long +# pylint: disable=too-many-arguments, too-many-instance-attributes, no-self-use, no-else-return, too-many-arguments, unused-format-string-argument, line-too-long, consider-using-f-string import re from pathlib import Path @@ -24,15 +24,16 @@ class PybindWrapper: """ Class to generate binding code for Pybind11 specifically. """ + def __init__(self, module_name, top_module_namespaces='', - use_boost=False, + use_boost_serialization=False, ignore_classes=(), module_template=""): self.module_name = module_name self.top_module_namespaces = top_module_namespaces - self.use_boost = use_boost + self.use_boost_serialization = use_boost_serialization self.ignore_classes = ignore_classes self._serializing_classes = [] self.module_template = module_template @@ -71,7 +72,7 @@ class PybindWrapper: def _method_args_signature(self, args): """Generate the argument types and names as per the method signature.""" - cpp_types = args.to_cpp(self.use_boost) + cpp_types = args.to_cpp() names = args.names() types_names = [ "{} {}".format(ctype, name) @@ -84,12 +85,11 @@ class PybindWrapper: """Wrap the constructors.""" res = "" for ctor in my_class.ctors: - res += ( - self.method_indent + '.def(py::init<{args_cpp_types}>()' - '{py_args_names})'.format( - args_cpp_types=", ".join(ctor.args.to_cpp(self.use_boost)), - py_args_names=self._py_args_names(ctor.args), - )) + res += (self.method_indent + '.def(py::init<{args_cpp_types}>()' + '{py_args_names})'.format( + args_cpp_types=", ".join(ctor.args.to_cpp()), + py_args_names=self._py_args_names(ctor.args), + )) return res def _wrap_serialization(self, cpp_class): @@ -178,7 +178,10 @@ class PybindWrapper: # Special handling for the serialize/serializable method if cpp_method in ["serialize", "serializable"]: - return self._wrap_serialization(cpp_class) + if self.use_boost_serialization: + return self._wrap_serialization(cpp_class) + else: + return "" # Special handling of ipython specific methods # https://ipython.readthedocs.io/en/stable/config/integrating.html @@ -246,7 +249,7 @@ class PybindWrapper: # To avoid type confusion for insert if method.name == 'insert' and cpp_class == 'gtsam::Values': name_list = method.args.names() - type_list = method.args.to_cpp(self.use_boost) + type_list = method.args.to_cpp() # inserting non-wrapped value types if type_list[0].strip() == 'size_t': method_suffix = '_' + name_list[1].strip() @@ -372,10 +375,9 @@ class PybindWrapper: instance_name = instantiated_class.name.lower() class_declaration = ( '\n py::class_<{cpp_class}, {class_parent}' - '{shared_ptr_type}::shared_ptr<{cpp_class}>> ' + 'std::shared_ptr<{cpp_class}>> ' '{instance_name}({module_var}, "{class_name}");' '\n {instance_name}').format( - shared_ptr_type=('boost' if self.use_boost else 'std'), cpp_class=cpp_class, class_name=instantiated_class.name, class_parent=class_parent, @@ -386,9 +388,8 @@ class PybindWrapper: else: class_declaration = ( '\n py::class_<{cpp_class}, {class_parent}' - '{shared_ptr_type}::shared_ptr<{cpp_class}>>({module_var}, "{class_name}")' - ).format(shared_ptr_type=('boost' if self.use_boost else 'std'), - cpp_class=cpp_class, + 'std::shared_ptr<{cpp_class}>>({module_var}, "{class_name}")' + ).format(cpp_class=cpp_class, class_name=instantiated_class.name, class_parent=class_parent, module_var=module_var) @@ -418,13 +419,11 @@ class PybindWrapper: if cpp_class in self.ignore_classes: return "" - res = ( - '\n py::class_<{cpp_class}, ' - '{shared_ptr_type}::shared_ptr<{cpp_class}>>({module_var}, "{class_name}");' - ).format(shared_ptr_type=('boost' if self.use_boost else 'std'), - cpp_class=cpp_class, - class_name=instantiated_decl.name, - module_var=module_var) + res = ('\n py::class_<{cpp_class}, ' + 'std::shared_ptr<{cpp_class}>>({module_var}, "{class_name}");' + ).format(cpp_class=cpp_class, + class_name=instantiated_decl.name, + module_var=module_var) return res def wrap_stl_class(self, stl_class): @@ -434,27 +433,25 @@ class PybindWrapper: if cpp_class in self.ignore_classes: return "" - return ( - '\n py::class_<{cpp_class}, {class_parent}' - '{shared_ptr_type}::shared_ptr<{cpp_class}>>({module_var}, "{class_name}")' - '{wrapped_ctors}' - '{wrapped_methods}' - '{wrapped_static_methods}' - '{wrapped_properties};\n'.format( - shared_ptr_type=('boost' if self.use_boost else 'std'), - cpp_class=cpp_class, - class_name=stl_class.name, - class_parent=str(stl_class.parent_class) + - (', ' if stl_class.parent_class else ''), - module_var=module_var, - wrapped_ctors=self.wrap_ctors(stl_class), - wrapped_methods=self.wrap_methods(stl_class.methods, - cpp_class), - wrapped_static_methods=self.wrap_methods( - stl_class.static_methods, cpp_class), - wrapped_properties=self.wrap_properties( - stl_class.properties, cpp_class), - )) + return ('\n py::class_<{cpp_class}, {class_parent}' + 'std::shared_ptr<{cpp_class}>>({module_var}, "{class_name}")' + '{wrapped_ctors}' + '{wrapped_methods}' + '{wrapped_static_methods}' + '{wrapped_properties};\n'.format( + cpp_class=cpp_class, + class_name=stl_class.name, + class_parent=str(stl_class.parent_class) + + (', ' if stl_class.parent_class else ''), + module_var=module_var, + wrapped_ctors=self.wrap_ctors(stl_class), + wrapped_methods=self.wrap_methods(stl_class.methods, + cpp_class), + wrapped_static_methods=self.wrap_methods( + stl_class.static_methods, cpp_class), + wrapped_properties=self.wrap_properties( + stl_class.properties, cpp_class), + )) def wrap_functions(self, functions, @@ -609,6 +606,7 @@ class PybindWrapper: prefix='\n' + ' ' * 4 + module_var, suffix=';', ) + return wrapped, includes def wrap_file(self, content, module_name=None, submodules=None): @@ -627,26 +625,27 @@ class PybindWrapper: wrapped_namespace, includes = self.wrap_namespace(module) - # Export classes for serialization. - boost_class_export = "" - for cpp_class in self._serializing_classes: - new_name = cpp_class - # The boost's macro doesn't like commas, so we have to typedef. - if ',' in cpp_class: - new_name = re.sub("[,:<> ]", "", cpp_class) - boost_class_export += "typedef {cpp_class} {new_name};\n".format( # noqa - cpp_class=cpp_class, new_name=new_name) + if self.use_boost_serialization: + includes += "#include " - boost_class_export += "BOOST_CLASS_EXPORT({new_name})\n".format( - new_name=new_name, ) + # Export classes for serialization. + boost_class_export = "" + for cpp_class in self._serializing_classes: + new_name = cpp_class + # The boost's macro doesn't like commas, so we have to typedef. + if ',' in cpp_class: + new_name = re.sub("[,:<> ]", "", cpp_class) + boost_class_export += "typedef {cpp_class} {new_name};\n".format( # noqa + cpp_class=cpp_class, new_name=new_name) + + boost_class_export += "BOOST_CLASS_EXPORT({new_name})\n".format( + new_name=new_name, ) + else: + boost_class_export = "" # Reset the serializing classes list self._serializing_classes = [] - holder_type = "PYBIND11_DECLARE_HOLDER_TYPE(TYPE_PLACEHOLDER_DONOTUSE, " \ - "{shared_ptr_type}::shared_ptr);" - include_boost = "#include " if self.use_boost else "" - submodules_init = [] if submodules is not None: @@ -661,13 +660,9 @@ class PybindWrapper: submodules = [] return self.module_template.format( - include_boost=include_boost, module_def=module_def, module_name=module_name, includes=includes, - holder_type=holder_type.format( - shared_ptr_type=('boost' if self.use_boost else 'std')) - if self.use_boost else "", wrapped_namespace=wrapped_namespace, boost_class_export=boost_class_export, submodules="\n".join(submodules), @@ -690,13 +685,13 @@ class PybindWrapper: module_name = Path(source).stem # Read in the complete interface (.i) file - with open(source, "r") as f: + with open(source, "r", encoding="UTF-8") as f: content = f.read() # Wrap the read-in content cc_content = self.wrap_file(content, module_name=module_name) # Generate the C++ code which Pybind11 will use. - with open(filename.replace(".i", ".cpp"), "w") as f: + with open(filename.replace(".i", ".cpp"), "w", encoding="UTF-8") as f: f.write(cc_content) def wrap(self, sources, main_module_name): @@ -716,12 +711,12 @@ class PybindWrapper: module_name = Path(source).stem submodules.append(module_name) - with open(main_module, "r") as f: + with open(main_module, "r", encoding="UTF-8") as f: content = f.read() cc_content = self.wrap_file(content, module_name=self.module_name, submodules=submodules) # Generate the C++ code which Pybind11 will use. - with open(main_module_name, "w") as f: + with open(main_module_name, "w", encoding="UTF-8") as f: f.write(cc_content) diff --git a/wrap/matlab.h b/wrap/matlab.h index 5c38ac808..b8fe53ac4 100644 --- a/wrap/matlab.h +++ b/wrap/matlab.h @@ -37,10 +37,6 @@ extern "C" { #include } -#include -#include -#include - #include #include #include @@ -49,7 +45,6 @@ extern "C" { #include using namespace std; -using namespace boost; // not usual, but for conciseness of generated code // start GTSAM Specifics ///////////////////////////////////////////////// // to enable Matrix and Vector constructor for SharedGaussian: @@ -66,15 +61,15 @@ using namespace boost; // not usual, but for conciseness of generated code // "Unique" key to signal calling the matlab object constructor with a raw pointer // to a shared pointer of the same C++ object type as the MATLAB type. // Also present in utilities.h -static const boost::uint64_t ptr_constructor_key = - (boost::uint64_t('G') << 56) | - (boost::uint64_t('T') << 48) | - (boost::uint64_t('S') << 40) | - (boost::uint64_t('A') << 32) | - (boost::uint64_t('M') << 24) | - (boost::uint64_t('p') << 16) | - (boost::uint64_t('t') << 8) | - (boost::uint64_t('r')); +static const std::uint64_t ptr_constructor_key = + (std::uint64_t('G') << 56) | + (std::uint64_t('T') << 48) | + (std::uint64_t('S') << 40) | + (std::uint64_t('A') << 32) | + (std::uint64_t('M') << 24) | + (std::uint64_t('p') << 16) | + (std::uint64_t('t') << 8) | + (std::uint64_t('r')); //***************************************************************************** // Utilities @@ -262,9 +257,9 @@ template T myGetScalar(const mxArray* array) { switch (mxGetClassID(array)) { case mxINT64_CLASS: - return (T) *(boost::int64_t*) mxGetData(array); + return (T) *(std::int64_t*) mxGetData(array); case mxUINT64_CLASS: - return (T) *(boost::uint64_t*) mxGetData(array); + return (T) *(std::uint64_t*) mxGetData(array); default: // hope for the best! return (T) mxGetScalar(array); @@ -402,7 +397,7 @@ mxArray* create_object(const std::string& classname, void *pointer, bool isVirtu int nargin = 2; // First input argument is pointer constructor key input[0] = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL); - *reinterpret_cast(mxGetData(input[0])) = ptr_constructor_key; + *reinterpret_cast(mxGetData(input[0])) = ptr_constructor_key; // Second input argument is the pointer input[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(input[1])) = pointer; @@ -453,28 +448,28 @@ mxArray* create_object(const std::string& classname, void *pointer, bool isVirtu class to matlab. */ template -mxArray* wrap_shared_ptr(boost::shared_ptr< Class > shared_ptr, const std::string& matlabName, bool isVirtual) { +mxArray* wrap_shared_ptr(std::shared_ptr< Class > shared_ptr, const std::string& matlabName, bool isVirtual) { // Create actual class object from out pointer mxArray* result; if(isVirtual) { - boost::shared_ptr void_ptr(shared_ptr); + std::shared_ptr void_ptr(shared_ptr); result = create_object(matlabName, &void_ptr, isVirtual, typeid(*shared_ptr).name()); } else { - boost::shared_ptr *heapPtr = new boost::shared_ptr(shared_ptr); + std::shared_ptr *heapPtr = new std::shared_ptr(shared_ptr); result = create_object(matlabName, heapPtr, isVirtual, ""); } return result; } template -boost::shared_ptr unwrap_shared_ptr(const mxArray* obj, const string& propertyName) { +std::shared_ptr unwrap_shared_ptr(const mxArray* obj, const string& propertyName) { mxArray* mxh = mxGetProperty(obj,0, propertyName.c_str()); if (mxGetClassID(mxh) != mxUINT32OR64_CLASS || mxIsComplex(mxh) || mxGetM(mxh) != 1 || mxGetN(mxh) != 1) error( "Parameter is not an Shared type."); - boost::shared_ptr* spp = *reinterpret_cast**> (mxGetData(mxh)); + std::shared_ptr* spp = *reinterpret_cast**> (mxGetData(mxh)); return *spp; } diff --git a/wrap/scripts/matlab_wrap.py b/wrap/scripts/matlab_wrap.py index 0f6664a63..3275667f5 100644 --- a/wrap/scripts/matlab_wrap.py +++ b/wrap/scripts/matlab_wrap.py @@ -43,16 +43,24 @@ if __name__ == "__main__": type=str, help="A space-separated list of classes to ignore. " "Class names must include their full namespaces.") + arg_parser.add_argument( + "--use-boost-serialization", + action="store_true", + help="Allow boost based serialization methods", + ) args = arg_parser.parse_args() top_module_namespaces = args.top_module_namespaces.split("::") if top_module_namespaces[0]: top_module_namespaces = [''] + top_module_namespaces - print("[MatlabWrapper] Ignoring classes: {}".format(args.ignore), file=sys.stderr) - wrapper = MatlabWrapper(module_name=args.module_name, - top_module_namespace=top_module_namespaces, - ignore_classes=args.ignore) + print(f"[MatlabWrapper] Ignoring classes: {args.ignore}", file=sys.stderr) + + wrapper = MatlabWrapper( + module_name=args.module_name, + top_module_namespace=top_module_namespaces, + ignore_classes=args.ignore, + use_boost_serialization=args.use_boost_serialization) sources = args.src.split(';') cc_content = wrapper.wrap(sources, path=args.out) diff --git a/wrap/scripts/pybind_wrap.py b/wrap/scripts/pybind_wrap.py index 577060243..8785ed7b5 100644 --- a/wrap/scripts/pybind_wrap.py +++ b/wrap/scripts/pybind_wrap.py @@ -34,9 +34,9 @@ def main(): help="Name of the output pybind .cc file(s)", ) arg_parser.add_argument( - "--use-boost", + "--use-boost-serialization", action="store_true", - help="using boost's shared_ptr instead of std's", + help="Allow boost based serialization methods", ) arg_parser.add_argument( "--top_module_namespaces", @@ -70,12 +70,12 @@ def main(): if top_module_namespaces[0]: top_module_namespaces = [''] + top_module_namespaces - with open(args.template, "r") as f: + with open(args.template, "r", encoding="UTF-8") as f: template_content = f.read() wrapper = PybindWrapper( module_name=args.module_name, - use_boost=args.use_boost, + use_boost_serialization=args.use_boost_serialization, top_module_namespaces=top_module_namespaces, ignore_classes=args.ignore, module_template=template_content, diff --git a/wrap/templates/pybind_wrapper.tpl.example b/wrap/templates/pybind_wrapper.tpl.example index 485aa8d00..3e251f4ae 100644 --- a/wrap/templates/pybind_wrapper.tpl.example +++ b/wrap/templates/pybind_wrapper.tpl.example @@ -1,5 +1,3 @@ -{include_boost} - #include #include #include @@ -10,12 +8,9 @@ #include "gtsam/base/utilities.h" // for RedirectCout. {includes} -#include {boost_class_export} -{holder_type} - #include "python/preamble.h" using namespace std; diff --git a/wrap/tests/expected/matlab/class_wrapper.cpp b/wrap/tests/expected/matlab/class_wrapper.cpp index 7cbdd7068..c4be52018 100644 --- a/wrap/tests/expected/matlab/class_wrapper.cpp +++ b/wrap/tests/expected/matlab/class_wrapper.cpp @@ -1,10 +1,6 @@ #include #include -#include -#include -#include - #include typedef Fun FunDouble; @@ -15,27 +11,27 @@ typedef MultipleTemplates MultipleTemplatesIntDouble; typedef MultipleTemplates MultipleTemplatesIntFloat; typedef MyFactor MyFactorPosePoint2; -typedef std::set*> Collector_FunRange; +typedef std::set*> Collector_FunRange; static Collector_FunRange collector_FunRange; -typedef std::set*> Collector_FunDouble; +typedef std::set*> Collector_FunDouble; static Collector_FunDouble collector_FunDouble; -typedef std::set*> Collector_Test; +typedef std::set*> Collector_Test; static Collector_Test collector_Test; -typedef std::set*> Collector_PrimitiveRefDouble; +typedef std::set*> Collector_PrimitiveRefDouble; static Collector_PrimitiveRefDouble collector_PrimitiveRefDouble; -typedef std::set*> Collector_MyVector3; +typedef std::set*> Collector_MyVector3; static Collector_MyVector3 collector_MyVector3; -typedef std::set*> Collector_MyVector12; +typedef std::set*> Collector_MyVector12; static Collector_MyVector12 collector_MyVector12; -typedef std::set*> Collector_MultipleTemplatesIntDouble; +typedef std::set*> Collector_MultipleTemplatesIntDouble; static Collector_MultipleTemplatesIntDouble collector_MultipleTemplatesIntDouble; -typedef std::set*> Collector_MultipleTemplatesIntFloat; +typedef std::set*> Collector_MultipleTemplatesIntFloat; static Collector_MultipleTemplatesIntFloat collector_MultipleTemplatesIntFloat; -typedef std::set*> Collector_ForwardKinematics; +typedef std::set*> Collector_ForwardKinematics; static Collector_ForwardKinematics collector_ForwardKinematics; -typedef std::set*> Collector_TemplatedConstructor; +typedef std::set*> Collector_TemplatedConstructor; static Collector_TemplatedConstructor collector_TemplatedConstructor; -typedef std::set*> Collector_MyFactorPosePoint2; +typedef std::set*> Collector_MyFactorPosePoint2; static Collector_MyFactorPosePoint2 collector_MyFactorPosePoint2; @@ -155,7 +151,7 @@ void _class_RTTIRegister() { void FunRange_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_FunRange.insert(self); @@ -164,7 +160,7 @@ void FunRange_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int narg void FunRange_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new FunRange()); collector_FunRange.insert(self); @@ -174,7 +170,7 @@ void FunRange_constructor_1(int nargout, mxArray *out[], int nargin, const mxArr void FunRange_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_FunRange",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_FunRange::iterator item; @@ -190,19 +186,19 @@ void FunRange_range_3(int nargout, mxArray *out[], int nargin, const mxArray *in checkArguments("range",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_FunRange"); double d = unwrap< double >(in[1]); - out[0] = wrap_shared_ptr(boost::make_shared(obj->range(d)),"FunRange", false); + out[0] = wrap_shared_ptr(std::make_shared(obj->range(d)),"FunRange", false); } void FunRange_create_4(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("FunRange.create",nargout,nargin,0); - out[0] = wrap_shared_ptr(boost::make_shared(FunRange::create()),"FunRange", false); + out[0] = wrap_shared_ptr(std::make_shared(FunRange::create()),"FunRange", false); } void FunDouble_collectorInsertAndMakeBase_5(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_FunDouble.insert(self); @@ -210,7 +206,7 @@ void FunDouble_collectorInsertAndMakeBase_5(int nargout, mxArray *out[], int nar void FunDouble_deconstructor_6(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_FunDouble",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_FunDouble::iterator item; @@ -228,14 +224,14 @@ void FunDouble_multiTemplatedMethod_7(int nargout, mxArray *out[], int nargin, c double d = unwrap< double >(in[1]); string t = unwrap< string >(in[2]); size_t u = unwrap< size_t >(in[3]); - out[0] = wrap_shared_ptr(boost::make_shared>(obj->multiTemplatedMethod(d,t,u)),"Fun", false); + out[0] = wrap_shared_ptr(std::make_shared>(obj->multiTemplatedMethod(d,t,u)),"Fun", false); } void FunDouble_sets_8(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("sets",nargout,nargin-1,0); auto obj = unwrap_shared_ptr>(in[0], "ptr_FunDouble"); - out[0] = wrap_shared_ptr(boost::make_shared::double>>(obj->sets()),"std.mapdoubledouble", false); + out[0] = wrap_shared_ptr(std::make_shared::double>>(obj->sets()),"std.mapdoubledouble", false); } void FunDouble_templatedMethod_9(int nargout, mxArray *out[], int nargin, const mxArray *in[]) @@ -244,13 +240,13 @@ void FunDouble_templatedMethod_9(int nargout, mxArray *out[], int nargin, const auto obj = unwrap_shared_ptr>(in[0], "ptr_FunDouble"); double d = unwrap< double >(in[1]); string t = unwrap< string >(in[2]); - out[0] = wrap_shared_ptr(boost::make_shared>(obj->templatedMethod(d,t)),"Fun", false); + out[0] = wrap_shared_ptr(std::make_shared>(obj->templatedMethod(d,t)),"Fun", false); } void FunDouble_staticMethodWithThis_10(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("Fun.staticMethodWithThis",nargout,nargin,0); - out[0] = wrap_shared_ptr(boost::make_shared>(Fun::staticMethodWithThis()),"Fundouble", false); + out[0] = wrap_shared_ptr(std::make_shared>(Fun::staticMethodWithThis()),"Fundouble", false); } void FunDouble_templatedStaticMethodInt_11(int nargout, mxArray *out[], int nargin, const mxArray *in[]) @@ -263,7 +259,7 @@ void FunDouble_templatedStaticMethodInt_11(int nargout, mxArray *out[], int narg void Test_collectorInsertAndMakeBase_12(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_Test.insert(self); @@ -272,7 +268,7 @@ void Test_collectorInsertAndMakeBase_12(int nargout, mxArray *out[], int nargin, void Test_constructor_13(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new Test()); collector_Test.insert(self); @@ -283,7 +279,7 @@ void Test_constructor_13(int nargout, mxArray *out[], int nargin, const mxArray void Test_constructor_14(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; double a = unwrap< double >(in[0]); Matrix b = unwrap< Matrix >(in[1]); @@ -295,7 +291,7 @@ void Test_constructor_14(int nargout, mxArray *out[], int nargin, const mxArray void Test_deconstructor_15(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_Test",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_Test::iterator item; @@ -319,7 +315,7 @@ void Test_create_MixedPtrs_17(int nargout, mxArray *out[], int nargin, const mxA checkArguments("create_MixedPtrs",nargout,nargin-1,0); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); auto pairResult = obj->create_MixedPtrs(); - out[0] = wrap_shared_ptr(boost::make_shared(pairResult.first),"Test", false); + out[0] = wrap_shared_ptr(std::make_shared(pairResult.first),"Test", false); out[1] = wrap_shared_ptr(pairResult.second,"Test", false); } @@ -336,7 +332,7 @@ void Test_get_container_19(int nargout, mxArray *out[], int nargin, const mxArra { checkArguments("get_container",nargout,nargin-1,0); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); - out[0] = wrap_shared_ptr(boost::make_shared>(obj->get_container()),"std.vectorTest", false); + out[0] = wrap_shared_ptr(std::make_shared>(obj->get_container()),"std.vectorTest", false); } void Test_lambda_20(int nargout, mxArray *out[], int nargin, const mxArray *in[]) @@ -374,7 +370,7 @@ void Test_return_Point2Ptr_24(int nargout, mxArray *out[], int nargin, const mxA auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); bool value = unwrap< bool >(in[1]); { - boost::shared_ptr shared(obj->return_Point2Ptr(value)); + std::shared_ptr shared(obj->return_Point2Ptr(value)); out[0] = wrap_shared_ptr(shared,"Point2"); } } @@ -383,15 +379,15 @@ void Test_return_Test_25(int nargout, mxArray *out[], int nargin, const mxArray { checkArguments("return_Test",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); - boost::shared_ptr value = unwrap_shared_ptr< Test >(in[1], "ptr_Test"); - out[0] = wrap_shared_ptr(boost::make_shared(obj->return_Test(value)),"Test", false); + std::shared_ptr value = unwrap_shared_ptr< Test >(in[1], "ptr_Test"); + out[0] = wrap_shared_ptr(std::make_shared(obj->return_Test(value)),"Test", false); } void Test_return_TestPtr_26(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("return_TestPtr",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); - boost::shared_ptr value = unwrap_shared_ptr< Test >(in[1], "ptr_Test"); + std::shared_ptr value = unwrap_shared_ptr< Test >(in[1], "ptr_Test"); out[0] = wrap_shared_ptr(obj->return_TestPtr(value),"Test", false); } @@ -468,8 +464,8 @@ void Test_return_ptrs_35(int nargout, mxArray *out[], int nargin, const mxArray { checkArguments("return_ptrs",nargout,nargin-1,2); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); - boost::shared_ptr p1 = unwrap_shared_ptr< Test >(in[1], "ptr_Test"); - boost::shared_ptr p2 = unwrap_shared_ptr< Test >(in[2], "ptr_Test"); + std::shared_ptr p1 = unwrap_shared_ptr< Test >(in[1], "ptr_Test"); + std::shared_ptr p2 = unwrap_shared_ptr< Test >(in[2], "ptr_Test"); auto pairResult = obj->return_ptrs(p1,p2); out[0] = wrap_shared_ptr(pairResult.first,"Test", false); out[1] = wrap_shared_ptr(pairResult.second,"Test", false); @@ -511,7 +507,7 @@ void Test_set_container_40(int nargout, mxArray *out[], int nargin, const mxArra { checkArguments("set_container",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); - boost::shared_ptr> container = unwrap_shared_ptr< std::vector >(in[1], "ptr_stdvectorTest"); + std::shared_ptr> container = unwrap_shared_ptr< std::vector >(in[1], "ptr_stdvectorTest"); obj->set_container(*container); } @@ -519,7 +515,7 @@ void Test_set_container_41(int nargout, mxArray *out[], int nargin, const mxArra { checkArguments("set_container",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); - boost::shared_ptr> container = unwrap_shared_ptr< std::vector >(in[1], "ptr_stdvectorTest"); + std::shared_ptr> container = unwrap_shared_ptr< std::vector >(in[1], "ptr_stdvectorTest"); obj->set_container(*container); } @@ -527,7 +523,7 @@ void Test_set_container_42(int nargout, mxArray *out[], int nargin, const mxArra { checkArguments("set_container",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); - boost::shared_ptr> container = unwrap_shared_ptr< std::vector >(in[1], "ptr_stdvectorTest"); + std::shared_ptr> container = unwrap_shared_ptr< std::vector >(in[1], "ptr_stdvectorTest"); obj->set_container(*container); } @@ -542,7 +538,7 @@ void Test_set_model_ptr_44(int nargout, mxArray *out[], int nargin, const mxArra { checkArguments("model_ptr",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_Test"); - boost::shared_ptr model_ptr = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[1], "ptr_gtsamnoiseModelBase"); + std::shared_ptr model_ptr = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[1], "ptr_gtsamnoiseModelBase"); obj->model_ptr = *model_ptr; } @@ -579,7 +575,7 @@ void Test_set_name_48(int nargout, mxArray *out[], int nargin, const mxArray *in void PrimitiveRefDouble_collectorInsertAndMakeBase_49(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_PrimitiveRefDouble.insert(self); @@ -588,7 +584,7 @@ void PrimitiveRefDouble_collectorInsertAndMakeBase_49(int nargout, mxArray *out[ void PrimitiveRefDouble_constructor_50(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = new Shared(new PrimitiveRef()); collector_PrimitiveRefDouble.insert(self); @@ -598,7 +594,7 @@ void PrimitiveRefDouble_constructor_50(int nargout, mxArray *out[], int nargin, void PrimitiveRefDouble_deconstructor_51(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_PrimitiveRefDouble",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_PrimitiveRefDouble::iterator item; @@ -613,13 +609,13 @@ void PrimitiveRefDouble_Brutal_52(int nargout, mxArray *out[], int nargin, const { checkArguments("PrimitiveRef.Brutal",nargout,nargin,1); double t = unwrap< double >(in[0]); - out[0] = wrap_shared_ptr(boost::make_shared>(PrimitiveRef::Brutal(t)),"PrimitiveRefdouble", false); + out[0] = wrap_shared_ptr(std::make_shared>(PrimitiveRef::Brutal(t)),"PrimitiveRefdouble", false); } void MyVector3_collectorInsertAndMakeBase_53(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MyVector3.insert(self); @@ -628,7 +624,7 @@ void MyVector3_collectorInsertAndMakeBase_53(int nargout, mxArray *out[], int na void MyVector3_constructor_54(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = new Shared(new MyVector<3>()); collector_MyVector3.insert(self); @@ -638,7 +634,7 @@ void MyVector3_constructor_54(int nargout, mxArray *out[], int nargin, const mxA void MyVector3_deconstructor_55(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_MyVector3",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MyVector3::iterator item; @@ -652,7 +648,7 @@ void MyVector3_deconstructor_55(int nargout, mxArray *out[], int nargin, const m void MyVector12_collectorInsertAndMakeBase_56(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MyVector12.insert(self); @@ -661,7 +657,7 @@ void MyVector12_collectorInsertAndMakeBase_56(int nargout, mxArray *out[], int n void MyVector12_constructor_57(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = new Shared(new MyVector<12>()); collector_MyVector12.insert(self); @@ -671,7 +667,7 @@ void MyVector12_constructor_57(int nargout, mxArray *out[], int nargin, const mx void MyVector12_deconstructor_58(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_MyVector12",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MyVector12::iterator item; @@ -685,7 +681,7 @@ void MyVector12_deconstructor_58(int nargout, mxArray *out[], int nargin, const void MultipleTemplatesIntDouble_collectorInsertAndMakeBase_59(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MultipleTemplatesIntDouble.insert(self); @@ -693,7 +689,7 @@ void MultipleTemplatesIntDouble_collectorInsertAndMakeBase_59(int nargout, mxArr void MultipleTemplatesIntDouble_deconstructor_60(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_MultipleTemplatesIntDouble",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MultipleTemplatesIntDouble::iterator item; @@ -707,7 +703,7 @@ void MultipleTemplatesIntDouble_deconstructor_60(int nargout, mxArray *out[], in void MultipleTemplatesIntFloat_collectorInsertAndMakeBase_61(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MultipleTemplatesIntFloat.insert(self); @@ -715,7 +711,7 @@ void MultipleTemplatesIntFloat_collectorInsertAndMakeBase_61(int nargout, mxArra void MultipleTemplatesIntFloat_deconstructor_62(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_MultipleTemplatesIntFloat",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MultipleTemplatesIntFloat::iterator item; @@ -729,7 +725,7 @@ void MultipleTemplatesIntFloat_deconstructor_62(int nargout, mxArray *out[], int void ForwardKinematics_collectorInsertAndMakeBase_63(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ForwardKinematics.insert(self); @@ -738,7 +734,7 @@ void ForwardKinematics_collectorInsertAndMakeBase_63(int nargout, mxArray *out[] void ForwardKinematics_constructor_64(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; gtdynamics::Robot& robot = *unwrap_shared_ptr< gtdynamics::Robot >(in[0], "ptr_gtdynamicsRobot"); string& start_link_name = *unwrap_shared_ptr< string >(in[1], "ptr_string"); @@ -754,7 +750,7 @@ void ForwardKinematics_constructor_64(int nargout, mxArray *out[], int nargin, c void ForwardKinematics_constructor_65(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; gtdynamics::Robot& robot = *unwrap_shared_ptr< gtdynamics::Robot >(in[0], "ptr_gtdynamicsRobot"); string& start_link_name = *unwrap_shared_ptr< string >(in[1], "ptr_string"); @@ -768,7 +764,7 @@ void ForwardKinematics_constructor_65(int nargout, mxArray *out[], int nargin, c void ForwardKinematics_deconstructor_66(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_ForwardKinematics",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ForwardKinematics::iterator item; @@ -782,7 +778,7 @@ void ForwardKinematics_deconstructor_66(int nargout, mxArray *out[], int nargin, void TemplatedConstructor_collectorInsertAndMakeBase_67(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_TemplatedConstructor.insert(self); @@ -791,7 +787,7 @@ void TemplatedConstructor_collectorInsertAndMakeBase_67(int nargout, mxArray *ou void TemplatedConstructor_constructor_68(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new TemplatedConstructor()); collector_TemplatedConstructor.insert(self); @@ -802,7 +798,7 @@ void TemplatedConstructor_constructor_68(int nargout, mxArray *out[], int nargin void TemplatedConstructor_constructor_69(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; string& arg = *unwrap_shared_ptr< string >(in[0], "ptr_string"); Shared *self = new Shared(new TemplatedConstructor(arg)); @@ -814,7 +810,7 @@ void TemplatedConstructor_constructor_69(int nargout, mxArray *out[], int nargin void TemplatedConstructor_constructor_70(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; int arg = unwrap< int >(in[0]); Shared *self = new Shared(new TemplatedConstructor(arg)); @@ -826,7 +822,7 @@ void TemplatedConstructor_constructor_70(int nargout, mxArray *out[], int nargin void TemplatedConstructor_constructor_71(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; double arg = unwrap< double >(in[0]); Shared *self = new Shared(new TemplatedConstructor(arg)); @@ -837,7 +833,7 @@ void TemplatedConstructor_constructor_71(int nargout, mxArray *out[], int nargin void TemplatedConstructor_deconstructor_72(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_TemplatedConstructor",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_TemplatedConstructor::iterator item; @@ -851,7 +847,7 @@ void TemplatedConstructor_deconstructor_72(int nargout, mxArray *out[], int narg void MyFactorPosePoint2_collectorInsertAndMakeBase_73(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MyFactorPosePoint2.insert(self); @@ -860,12 +856,12 @@ void MyFactorPosePoint2_collectorInsertAndMakeBase_73(int nargout, mxArray *out[ void MyFactorPosePoint2_constructor_74(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; size_t key1 = unwrap< size_t >(in[0]); size_t key2 = unwrap< size_t >(in[1]); double measured = unwrap< double >(in[2]); - boost::shared_ptr noiseModel = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[3], "ptr_gtsamnoiseModelBase"); + std::shared_ptr noiseModel = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[3], "ptr_gtsamnoiseModelBase"); Shared *self = new Shared(new MyFactor(key1,key2,measured,noiseModel)); collector_MyFactorPosePoint2.insert(self); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); @@ -874,7 +870,7 @@ void MyFactorPosePoint2_constructor_74(int nargout, mxArray *out[], int nargin, void MyFactorPosePoint2_deconstructor_75(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_MyFactorPosePoint2",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MyFactorPosePoint2::iterator item; diff --git a/wrap/tests/expected/matlab/functions_wrapper.cpp b/wrap/tests/expected/matlab/functions_wrapper.cpp index 61286d84f..7c6a70e4a 100644 --- a/wrap/tests/expected/matlab/functions_wrapper.cpp +++ b/wrap/tests/expected/matlab/functions_wrapper.cpp @@ -1,10 +1,6 @@ #include #include -#include -#include -#include - @@ -62,7 +58,7 @@ void load2D_0(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("load2D",nargout,nargin,5); string filename = unwrap< string >(in[0]); - boost::shared_ptr model = unwrap_shared_ptr< Test >(in[1], "ptr_Test"); + std::shared_ptr model = unwrap_shared_ptr< Test >(in[1], "ptr_Test"); int maxID = unwrap< int >(in[2]); bool addNoise = unwrap< bool >(in[3]); bool smart = unwrap< bool >(in[4]); @@ -74,7 +70,7 @@ void load2D_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("load2D",nargout,nargin,5); string filename = unwrap< string >(in[0]); - boost::shared_ptr model = unwrap_shared_ptr< gtsam::noiseModel::Diagonal >(in[1], "ptr_gtsamnoiseModelDiagonal"); + std::shared_ptr model = unwrap_shared_ptr< gtsam::noiseModel::Diagonal >(in[1], "ptr_gtsamnoiseModelDiagonal"); int maxID = unwrap< int >(in[2]); bool addNoise = unwrap< bool >(in[3]); bool smart = unwrap< bool >(in[4]); diff --git a/wrap/tests/expected/matlab/geometry_wrapper.cpp b/wrap/tests/expected/matlab/geometry_wrapper.cpp index 4a3ad1d68..4df17c692 100644 --- a/wrap/tests/expected/matlab/geometry_wrapper.cpp +++ b/wrap/tests/expected/matlab/geometry_wrapper.cpp @@ -12,9 +12,9 @@ BOOST_CLASS_EXPORT_GUID(gtsam::Point2, "gtsamPoint2"); BOOST_CLASS_EXPORT_GUID(gtsam::Point3, "gtsamPoint3"); -typedef std::set*> Collector_gtsamPoint2; +typedef std::set*> Collector_gtsamPoint2; static Collector_gtsamPoint2 collector_gtsamPoint2; -typedef std::set*> Collector_gtsamPoint3; +typedef std::set*> Collector_gtsamPoint3; static Collector_gtsamPoint3 collector_gtsamPoint3; @@ -80,7 +80,7 @@ void _geometry_RTTIRegister() { void gtsamPoint2_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamPoint2.insert(self); @@ -89,7 +89,7 @@ void gtsamPoint2_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int n void gtsamPoint2_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new gtsam::Point2()); collector_gtsamPoint2.insert(self); @@ -100,7 +100,7 @@ void gtsamPoint2_constructor_1(int nargout, mxArray *out[], int nargin, const mx void gtsamPoint2_constructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; double x = unwrap< double >(in[0]); double y = unwrap< double >(in[1]); @@ -112,7 +112,7 @@ void gtsamPoint2_constructor_2(int nargout, mxArray *out[], int nargin, const mx void gtsamPoint2_deconstructor_3(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_gtsamPoint2",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamPoint2::iterator item; @@ -135,7 +135,7 @@ void gtsamPoint2_argChar_5(int nargout, mxArray *out[], int nargin, const mxArra { checkArguments("argChar",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_gtsamPoint2"); - boost::shared_ptr a = unwrap_shared_ptr< char >(in[1], "ptr_char"); + std::shared_ptr a = unwrap_shared_ptr< char >(in[1], "ptr_char"); obj->argChar(a); } @@ -159,7 +159,7 @@ void gtsamPoint2_argChar_8(int nargout, mxArray *out[], int nargin, const mxArra { checkArguments("argChar",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_gtsamPoint2"); - boost::shared_ptr a = unwrap_shared_ptr< char >(in[1], "ptr_char"); + std::shared_ptr a = unwrap_shared_ptr< char >(in[1], "ptr_char"); obj->argChar(a); } @@ -214,7 +214,7 @@ void gtsamPoint2_vectorConfusion_15(int nargout, mxArray *out[], int nargin, con { checkArguments("vectorConfusion",nargout,nargin-1,0); auto obj = unwrap_shared_ptr(in[0], "ptr_gtsamPoint2"); - out[0] = wrap_shared_ptr(boost::make_shared(obj->vectorConfusion()),"VectorNotEigen", false); + out[0] = wrap_shared_ptr(std::make_shared(obj->vectorConfusion()),"VectorNotEigen", false); } void gtsamPoint2_x_16(int nargout, mxArray *out[], int nargin, const mxArray *in[]) @@ -234,7 +234,7 @@ void gtsamPoint2_y_17(int nargout, mxArray *out[], int nargin, const mxArray *in void gtsamPoint3_collectorInsertAndMakeBase_18(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamPoint3.insert(self); @@ -243,7 +243,7 @@ void gtsamPoint3_collectorInsertAndMakeBase_18(int nargout, mxArray *out[], int void gtsamPoint3_constructor_19(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; double x = unwrap< double >(in[0]); double y = unwrap< double >(in[1]); @@ -256,7 +256,7 @@ void gtsamPoint3_constructor_19(int nargout, mxArray *out[], int nargin, const m void gtsamPoint3_deconstructor_20(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_gtsamPoint3",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamPoint3::iterator item; @@ -276,7 +276,7 @@ void gtsamPoint3_norm_21(int nargout, mxArray *out[], int nargin, const mxArray void gtsamPoint3_string_serialize_22(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("string_serialize",nargout,nargin-1,0); Shared obj = unwrap_shared_ptr(in[0], "ptr_gtsamPoint3"); ostringstream out_archive_stream; @@ -299,7 +299,7 @@ void gtsamPoint3_staticFunction_24(int nargout, mxArray *out[], int nargin, cons void gtsamPoint3_string_deserialize_25(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("gtsamPoint3.string_deserialize",nargout,nargin,1); string serialized = unwrap< string >(in[0]); istringstream in_archive_stream(serialized); diff --git a/wrap/tests/expected/matlab/inheritance_wrapper.cpp b/wrap/tests/expected/matlab/inheritance_wrapper.cpp index b882b1d01..5081ad860 100644 --- a/wrap/tests/expected/matlab/inheritance_wrapper.cpp +++ b/wrap/tests/expected/matlab/inheritance_wrapper.cpp @@ -1,10 +1,6 @@ #include #include -#include -#include -#include - typedef MyTemplate MyTemplatePoint2; @@ -12,17 +8,17 @@ typedef MyTemplate MyTemplateMatrix; typedef MyTemplate MyTemplateA; typedef ParentHasTemplate ParentHasTemplateDouble; -typedef std::set*> Collector_MyBase; +typedef std::set*> Collector_MyBase; static Collector_MyBase collector_MyBase; -typedef std::set*> Collector_MyTemplatePoint2; +typedef std::set*> Collector_MyTemplatePoint2; static Collector_MyTemplatePoint2 collector_MyTemplatePoint2; -typedef std::set*> Collector_MyTemplateMatrix; +typedef std::set*> Collector_MyTemplateMatrix; static Collector_MyTemplateMatrix collector_MyTemplateMatrix; -typedef std::set*> Collector_MyTemplateA; +typedef std::set*> Collector_MyTemplateA; static Collector_MyTemplateA collector_MyTemplateA; -typedef std::set*> Collector_ForwardKinematicsFactor; +typedef std::set*> Collector_ForwardKinematicsFactor; static Collector_ForwardKinematicsFactor collector_ForwardKinematicsFactor; -typedef std::set*> Collector_ParentHasTemplateDouble; +typedef std::set*> Collector_ParentHasTemplateDouble; static Collector_ParentHasTemplateDouble collector_ParentHasTemplateDouble; @@ -118,7 +114,7 @@ void _inheritance_RTTIRegister() { void MyBase_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MyBase.insert(self); @@ -126,16 +122,16 @@ void MyBase_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin void MyBase_upcastFromVoid_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; - boost::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); + typedef std::shared_ptr Shared; + std::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); - Shared *self = new Shared(boost::static_pointer_cast(*asVoid)); + Shared *self = new Shared(std::static_pointer_cast(*asVoid)); *reinterpret_cast(mxGetData(out[0])) = self; } void MyBase_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_MyBase",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MyBase::iterator item; @@ -149,43 +145,43 @@ void MyBase_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArr void MyTemplatePoint2_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MyTemplatePoint2.insert(self); - typedef boost::shared_ptr SharedBase; + typedef std::shared_ptr SharedBase; out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[0])) = new SharedBase(*self); } void MyTemplatePoint2_upcastFromVoid_4(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; - boost::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); + typedef std::shared_ptr> Shared; + std::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); - Shared *self = new Shared(boost::static_pointer_cast>(*asVoid)); + Shared *self = new Shared(std::static_pointer_cast>(*asVoid)); *reinterpret_cast(mxGetData(out[0])) = self; } void MyTemplatePoint2_constructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = new Shared(new MyTemplate()); collector_MyTemplatePoint2.insert(self); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast (mxGetData(out[0])) = self; - typedef boost::shared_ptr SharedBase; + typedef std::shared_ptr SharedBase; out[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[1])) = new SharedBase(*self); } void MyTemplatePoint2_deconstructor_6(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_MyTemplatePoint2",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MyTemplatePoint2::iterator item; @@ -219,7 +215,7 @@ void MyTemplatePoint2_create_MixedPtrs_9(int nargout, mxArray *out[], int nargin auto pairResult = obj->create_MixedPtrs(); out[0] = wrap< Point2 >(pairResult.first); { - boost::shared_ptr shared(pairResult.second); + std::shared_ptr shared(pairResult.second); out[1] = wrap_shared_ptr(shared,"Point2"); } } @@ -230,11 +226,11 @@ void MyTemplatePoint2_create_ptrs_10(int nargout, mxArray *out[], int nargin, co auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplatePoint2"); auto pairResult = obj->create_ptrs(); { - boost::shared_ptr shared(pairResult.first); + std::shared_ptr shared(pairResult.first); out[0] = wrap_shared_ptr(shared,"Point2"); } { - boost::shared_ptr shared(pairResult.second); + std::shared_ptr shared(pairResult.second); out[1] = wrap_shared_ptr(shared,"Point2"); } } @@ -253,7 +249,7 @@ void MyTemplatePoint2_return_Tptr_12(int nargout, mxArray *out[], int nargin, co auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplatePoint2"); Point2 value = unwrap< Point2 >(in[1]); { - boost::shared_ptr shared(obj->return_Tptr(value)); + std::shared_ptr shared(obj->return_Tptr(value)); out[0] = wrap_shared_ptr(shared,"Point2"); } } @@ -266,11 +262,11 @@ void MyTemplatePoint2_return_ptrs_13(int nargout, mxArray *out[], int nargin, co Point2 p2 = unwrap< Point2 >(in[2]); auto pairResult = obj->return_ptrs(p1,p2); { - boost::shared_ptr shared(pairResult.first); + std::shared_ptr shared(pairResult.first); out[0] = wrap_shared_ptr(shared,"Point2"); } { - boost::shared_ptr shared(pairResult.second); + std::shared_ptr shared(pairResult.second); out[1] = wrap_shared_ptr(shared,"Point2"); } } @@ -311,49 +307,49 @@ void MyTemplatePoint2_Level_18(int nargout, mxArray *out[], int nargin, const mx { checkArguments("MyTemplate.Level",nargout,nargin,1); Point2 K = unwrap< Point2 >(in[0]); - out[0] = wrap_shared_ptr(boost::make_shared>(MyTemplate::Level(K)),"MyTemplatePoint2", false); + out[0] = wrap_shared_ptr(std::make_shared>(MyTemplate::Level(K)),"MyTemplatePoint2", false); } void MyTemplateMatrix_collectorInsertAndMakeBase_19(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MyTemplateMatrix.insert(self); - typedef boost::shared_ptr SharedBase; + typedef std::shared_ptr SharedBase; out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[0])) = new SharedBase(*self); } void MyTemplateMatrix_upcastFromVoid_20(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; - boost::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); + typedef std::shared_ptr> Shared; + std::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); - Shared *self = new Shared(boost::static_pointer_cast>(*asVoid)); + Shared *self = new Shared(std::static_pointer_cast>(*asVoid)); *reinterpret_cast(mxGetData(out[0])) = self; } void MyTemplateMatrix_constructor_21(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = new Shared(new MyTemplate()); collector_MyTemplateMatrix.insert(self); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast (mxGetData(out[0])) = self; - typedef boost::shared_ptr SharedBase; + typedef std::shared_ptr SharedBase; out[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[1])) = new SharedBase(*self); } void MyTemplateMatrix_deconstructor_22(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_MyTemplateMatrix",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MyTemplateMatrix::iterator item; @@ -387,7 +383,7 @@ void MyTemplateMatrix_create_MixedPtrs_25(int nargout, mxArray *out[], int nargi auto pairResult = obj->create_MixedPtrs(); out[0] = wrap< Matrix >(pairResult.first); { - boost::shared_ptr shared(pairResult.second); + std::shared_ptr shared(pairResult.second); out[1] = wrap_shared_ptr(shared,"Matrix"); } } @@ -398,11 +394,11 @@ void MyTemplateMatrix_create_ptrs_26(int nargout, mxArray *out[], int nargin, co auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplateMatrix"); auto pairResult = obj->create_ptrs(); { - boost::shared_ptr shared(pairResult.first); + std::shared_ptr shared(pairResult.first); out[0] = wrap_shared_ptr(shared,"Matrix"); } { - boost::shared_ptr shared(pairResult.second); + std::shared_ptr shared(pairResult.second); out[1] = wrap_shared_ptr(shared,"Matrix"); } } @@ -421,7 +417,7 @@ void MyTemplateMatrix_return_Tptr_28(int nargout, mxArray *out[], int nargin, co auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplateMatrix"); Matrix value = unwrap< Matrix >(in[1]); { - boost::shared_ptr shared(obj->return_Tptr(value)); + std::shared_ptr shared(obj->return_Tptr(value)); out[0] = wrap_shared_ptr(shared,"Matrix"); } } @@ -434,11 +430,11 @@ void MyTemplateMatrix_return_ptrs_29(int nargout, mxArray *out[], int nargin, co Matrix p2 = unwrap< Matrix >(in[2]); auto pairResult = obj->return_ptrs(p1,p2); { - boost::shared_ptr shared(pairResult.first); + std::shared_ptr shared(pairResult.first); out[0] = wrap_shared_ptr(shared,"Matrix"); } { - boost::shared_ptr shared(pairResult.second); + std::shared_ptr shared(pairResult.second); out[1] = wrap_shared_ptr(shared,"Matrix"); } } @@ -479,49 +475,49 @@ void MyTemplateMatrix_Level_34(int nargout, mxArray *out[], int nargin, const mx { checkArguments("MyTemplate.Level",nargout,nargin,1); Matrix K = unwrap< Matrix >(in[0]); - out[0] = wrap_shared_ptr(boost::make_shared>(MyTemplate::Level(K)),"MyTemplateMatrix", false); + out[0] = wrap_shared_ptr(std::make_shared>(MyTemplate::Level(K)),"MyTemplateMatrix", false); } void MyTemplateA_collectorInsertAndMakeBase_35(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_MyTemplateA.insert(self); - typedef boost::shared_ptr SharedBase; + typedef std::shared_ptr SharedBase; out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[0])) = new SharedBase(*self); } void MyTemplateA_upcastFromVoid_36(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; - boost::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); + typedef std::shared_ptr> Shared; + std::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); - Shared *self = new Shared(boost::static_pointer_cast>(*asVoid)); + Shared *self = new Shared(std::static_pointer_cast>(*asVoid)); *reinterpret_cast(mxGetData(out[0])) = self; } void MyTemplateA_constructor_37(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = new Shared(new MyTemplate()); collector_MyTemplateA.insert(self); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast (mxGetData(out[0])) = self; - typedef boost::shared_ptr SharedBase; + typedef std::shared_ptr SharedBase; out[1] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[1])) = new SharedBase(*self); } void MyTemplateA_deconstructor_38(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_MyTemplateA",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_MyTemplateA::iterator item; @@ -544,7 +540,7 @@ void MyTemplateA_accept_Tptr_40(int nargout, mxArray *out[], int nargin, const m { checkArguments("accept_Tptr",nargout,nargin-1,1); auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplateA"); - boost::shared_ptr value = unwrap_shared_ptr< A >(in[1], "ptr_A"); + std::shared_ptr value = unwrap_shared_ptr< A >(in[1], "ptr_A"); obj->accept_Tptr(value); } @@ -553,7 +549,7 @@ void MyTemplateA_create_MixedPtrs_41(int nargout, mxArray *out[], int nargin, co checkArguments("create_MixedPtrs",nargout,nargin-1,0); auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplateA"); auto pairResult = obj->create_MixedPtrs(); - out[0] = wrap_shared_ptr(boost::make_shared(pairResult.first),"A", false); + out[0] = wrap_shared_ptr(std::make_shared(pairResult.first),"A", false); out[1] = wrap_shared_ptr(pairResult.second,"A", false); } @@ -571,14 +567,14 @@ void MyTemplateA_return_T_43(int nargout, mxArray *out[], int nargin, const mxAr checkArguments("return_T",nargout,nargin-1,1); auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplateA"); A* value = unwrap_ptr< A >(in[1], "ptr_A"); - out[0] = wrap_shared_ptr(boost::make_shared(obj->return_T(value)),"A", false); + out[0] = wrap_shared_ptr(std::make_shared(obj->return_T(value)),"A", false); } void MyTemplateA_return_Tptr_44(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("return_Tptr",nargout,nargin-1,1); auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplateA"); - boost::shared_ptr value = unwrap_shared_ptr< A >(in[1], "ptr_A"); + std::shared_ptr value = unwrap_shared_ptr< A >(in[1], "ptr_A"); out[0] = wrap_shared_ptr(obj->return_Tptr(value),"A", false); } @@ -586,8 +582,8 @@ void MyTemplateA_return_ptrs_45(int nargout, mxArray *out[], int nargin, const m { checkArguments("return_ptrs",nargout,nargin-1,2); auto obj = unwrap_shared_ptr>(in[0], "ptr_MyTemplateA"); - boost::shared_ptr p1 = unwrap_shared_ptr< A >(in[1], "ptr_A"); - boost::shared_ptr p2 = unwrap_shared_ptr< A >(in[2], "ptr_A"); + std::shared_ptr p1 = unwrap_shared_ptr< A >(in[1], "ptr_A"); + std::shared_ptr p2 = unwrap_shared_ptr< A >(in[2], "ptr_A"); auto pairResult = obj->return_ptrs(p1,p2); out[0] = wrap_shared_ptr(pairResult.first,"A", false); out[1] = wrap_shared_ptr(pairResult.second,"A", false); @@ -629,34 +625,34 @@ void MyTemplateA_Level_50(int nargout, mxArray *out[], int nargin, const mxArray { checkArguments("MyTemplate.Level",nargout,nargin,1); A& K = *unwrap_shared_ptr< A >(in[0], "ptr_A"); - out[0] = wrap_shared_ptr(boost::make_shared>(MyTemplate::Level(K)),"MyTemplateA", false); + out[0] = wrap_shared_ptr(std::make_shared>(MyTemplate::Level(K)),"MyTemplateA", false); } void ForwardKinematicsFactor_collectorInsertAndMakeBase_51(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ForwardKinematicsFactor.insert(self); - typedef boost::shared_ptr> SharedBase; + typedef std::shared_ptr> SharedBase; out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[0])) = new SharedBase(*self); } void ForwardKinematicsFactor_upcastFromVoid_52(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; - boost::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); + typedef std::shared_ptr Shared; + std::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); - Shared *self = new Shared(boost::static_pointer_cast(*asVoid)); + Shared *self = new Shared(std::static_pointer_cast(*asVoid)); *reinterpret_cast(mxGetData(out[0])) = self; } void ForwardKinematicsFactor_deconstructor_53(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_ForwardKinematicsFactor",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ForwardKinematicsFactor::iterator item; @@ -670,28 +666,28 @@ void ForwardKinematicsFactor_deconstructor_53(int nargout, mxArray *out[], int n void ParentHasTemplateDouble_collectorInsertAndMakeBase_54(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ParentHasTemplateDouble.insert(self); - typedef boost::shared_ptr> SharedBase; + typedef std::shared_ptr> SharedBase; out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); *reinterpret_cast(mxGetData(out[0])) = new SharedBase(*self); } void ParentHasTemplateDouble_upcastFromVoid_55(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; - boost::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); + typedef std::shared_ptr> Shared; + std::shared_ptr *asVoid = *reinterpret_cast**> (mxGetData(in[0])); out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL); - Shared *self = new Shared(boost::static_pointer_cast>(*asVoid)); + Shared *self = new Shared(std::static_pointer_cast>(*asVoid)); *reinterpret_cast(mxGetData(out[0])) = self; } void ParentHasTemplateDouble_deconstructor_56(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_ParentHasTemplateDouble",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ParentHasTemplateDouble::iterator item; diff --git a/wrap/tests/expected/matlab/multiple_files_wrapper.cpp b/wrap/tests/expected/matlab/multiple_files_wrapper.cpp index 864ae75d6..9a9aa58a6 100644 --- a/wrap/tests/expected/matlab/multiple_files_wrapper.cpp +++ b/wrap/tests/expected/matlab/multiple_files_wrapper.cpp @@ -1,19 +1,15 @@ #include #include -#include -#include -#include - -typedef std::set*> Collector_gtsamClass1; +typedef std::set*> Collector_gtsamClass1; static Collector_gtsamClass1 collector_gtsamClass1; -typedef std::set*> Collector_gtsamClass2; +typedef std::set*> Collector_gtsamClass2; static Collector_gtsamClass2 collector_gtsamClass2; -typedef std::set*> Collector_gtsamClassA; +typedef std::set*> Collector_gtsamClassA; static Collector_gtsamClassA collector_gtsamClassA; @@ -85,7 +81,7 @@ void _multiple_files_RTTIRegister() { void gtsamClass1_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamClass1.insert(self); @@ -94,7 +90,7 @@ void gtsamClass1_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int n void gtsamClass1_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new gtsam::Class1()); collector_gtsamClass1.insert(self); @@ -104,7 +100,7 @@ void gtsamClass1_constructor_1(int nargout, mxArray *out[], int nargin, const mx void gtsamClass1_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_gtsamClass1",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamClass1::iterator item; @@ -118,7 +114,7 @@ void gtsamClass1_deconstructor_2(int nargout, mxArray *out[], int nargin, const void gtsamClass2_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamClass2.insert(self); @@ -127,7 +123,7 @@ void gtsamClass2_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int n void gtsamClass2_constructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new gtsam::Class2()); collector_gtsamClass2.insert(self); @@ -137,7 +133,7 @@ void gtsamClass2_constructor_4(int nargout, mxArray *out[], int nargin, const mx void gtsamClass2_deconstructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_gtsamClass2",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamClass2::iterator item; @@ -151,7 +147,7 @@ void gtsamClass2_deconstructor_5(int nargout, mxArray *out[], int nargin, const void gtsamClassA_collectorInsertAndMakeBase_6(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamClassA.insert(self); @@ -160,7 +156,7 @@ void gtsamClassA_collectorInsertAndMakeBase_6(int nargout, mxArray *out[], int n void gtsamClassA_constructor_7(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new gtsam::ClassA()); collector_gtsamClassA.insert(self); @@ -170,7 +166,7 @@ void gtsamClassA_constructor_7(int nargout, mxArray *out[], int nargin, const mx void gtsamClassA_deconstructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_gtsamClassA",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamClassA::iterator item; diff --git a/wrap/tests/expected/matlab/namespaces_wrapper.cpp b/wrap/tests/expected/matlab/namespaces_wrapper.cpp index b2fe3eed6..7df0b9fea 100644 --- a/wrap/tests/expected/matlab/namespaces_wrapper.cpp +++ b/wrap/tests/expected/matlab/namespaces_wrapper.cpp @@ -1,10 +1,6 @@ #include #include -#include -#include -#include - #include #include #include @@ -14,19 +10,19 @@ -typedef std::set*> Collector_ns1ClassA; +typedef std::set*> Collector_ns1ClassA; static Collector_ns1ClassA collector_ns1ClassA; -typedef std::set*> Collector_ns1ClassB; +typedef std::set*> Collector_ns1ClassB; static Collector_ns1ClassB collector_ns1ClassB; -typedef std::set*> Collector_ns2ClassA; +typedef std::set*> Collector_ns2ClassA; static Collector_ns2ClassA collector_ns2ClassA; -typedef std::set*> Collector_ns2ns3ClassB; +typedef std::set*> Collector_ns2ns3ClassB; static Collector_ns2ns3ClassB collector_ns2ns3ClassB; -typedef std::set*> Collector_ns2ClassC; +typedef std::set*> Collector_ns2ClassC; static Collector_ns2ClassC collector_ns2ClassC; -typedef std::set*> Collector_ClassD; +typedef std::set*> Collector_ClassD; static Collector_ClassD collector_ClassD; -typedef std::set*> Collector_gtsamValues; +typedef std::set*> Collector_gtsamValues; static Collector_gtsamValues collector_gtsamValues; @@ -122,7 +118,7 @@ void _namespaces_RTTIRegister() { void ns1ClassA_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ns1ClassA.insert(self); @@ -131,7 +127,7 @@ void ns1ClassA_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nar void ns1ClassA_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new ns1::ClassA()); collector_ns1ClassA.insert(self); @@ -141,7 +137,7 @@ void ns1ClassA_constructor_1(int nargout, mxArray *out[], int nargin, const mxAr void ns1ClassA_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_ns1ClassA",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ns1ClassA::iterator item; @@ -155,7 +151,7 @@ void ns1ClassA_deconstructor_2(int nargout, mxArray *out[], int nargin, const mx void ns1ClassB_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ns1ClassB.insert(self); @@ -164,7 +160,7 @@ void ns1ClassB_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nar void ns1ClassB_constructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new ns1::ClassB()); collector_ns1ClassB.insert(self); @@ -174,7 +170,7 @@ void ns1ClassB_constructor_4(int nargout, mxArray *out[], int nargin, const mxAr void ns1ClassB_deconstructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_ns1ClassB",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ns1ClassB::iterator item; @@ -193,7 +189,7 @@ void aGlobalFunction_6(int nargout, mxArray *out[], int nargin, const mxArray *i void ns2ClassA_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ns2ClassA.insert(self); @@ -202,7 +198,7 @@ void ns2ClassA_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nar void ns2ClassA_constructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new ns2::ClassA()); collector_ns2ClassA.insert(self); @@ -212,7 +208,7 @@ void ns2ClassA_constructor_8(int nargout, mxArray *out[], int nargin, const mxAr void ns2ClassA_deconstructor_9(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_ns2ClassA",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ns2ClassA::iterator item; @@ -243,7 +239,7 @@ void ns2ClassA_nsReturn_12(int nargout, mxArray *out[], int nargin, const mxArra checkArguments("nsReturn",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_ns2ClassA"); double q = unwrap< double >(in[1]); - out[0] = wrap_shared_ptr(boost::make_shared(obj->nsReturn(q)),"ns2.ns3.ClassB", false); + out[0] = wrap_shared_ptr(std::make_shared(obj->nsReturn(q)),"ns2.ns3.ClassB", false); } void ns2ClassA_afunction_13(int nargout, mxArray *out[], int nargin, const mxArray *in[]) @@ -255,7 +251,7 @@ void ns2ClassA_afunction_13(int nargout, mxArray *out[], int nargin, const mxArr void ns2ns3ClassB_collectorInsertAndMakeBase_14(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ns2ns3ClassB.insert(self); @@ -264,7 +260,7 @@ void ns2ns3ClassB_collectorInsertAndMakeBase_14(int nargout, mxArray *out[], int void ns2ns3ClassB_constructor_15(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new ns2::ns3::ClassB()); collector_ns2ns3ClassB.insert(self); @@ -274,7 +270,7 @@ void ns2ns3ClassB_constructor_15(int nargout, mxArray *out[], int nargin, const void ns2ns3ClassB_deconstructor_16(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_ns2ns3ClassB",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ns2ns3ClassB::iterator item; @@ -288,7 +284,7 @@ void ns2ns3ClassB_deconstructor_16(int nargout, mxArray *out[], int nargin, cons void ns2ClassC_collectorInsertAndMakeBase_17(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ns2ClassC.insert(self); @@ -297,7 +293,7 @@ void ns2ClassC_collectorInsertAndMakeBase_17(int nargout, mxArray *out[], int na void ns2ClassC_constructor_18(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new ns2::ClassC()); collector_ns2ClassC.insert(self); @@ -307,7 +303,7 @@ void ns2ClassC_constructor_18(int nargout, mxArray *out[], int nargin, const mxA void ns2ClassC_deconstructor_19(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_ns2ClassC",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ns2ClassC::iterator item; @@ -327,19 +323,19 @@ void overloadedGlobalFunction_21(int nargout, mxArray *out[], int nargin, const { checkArguments("overloadedGlobalFunction",nargout,nargin,1); ns1::ClassA& a = *unwrap_shared_ptr< ns1::ClassA >(in[0], "ptr_ns1ClassA"); - out[0] = wrap_shared_ptr(boost::make_shared(ns2::overloadedGlobalFunction(a)),"ns1.ClassA", false); + out[0] = wrap_shared_ptr(std::make_shared(ns2::overloadedGlobalFunction(a)),"ns1.ClassA", false); } void overloadedGlobalFunction_22(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("overloadedGlobalFunction",nargout,nargin,2); ns1::ClassA& a = *unwrap_shared_ptr< ns1::ClassA >(in[0], "ptr_ns1ClassA"); double b = unwrap< double >(in[1]); - out[0] = wrap_shared_ptr(boost::make_shared(ns2::overloadedGlobalFunction(a,b)),"ns1.ClassA", false); + out[0] = wrap_shared_ptr(std::make_shared(ns2::overloadedGlobalFunction(a,b)),"ns1.ClassA", false); } void ClassD_collectorInsertAndMakeBase_23(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ClassD.insert(self); @@ -348,7 +344,7 @@ void ClassD_collectorInsertAndMakeBase_23(int nargout, mxArray *out[], int nargi void ClassD_constructor_24(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new ClassD()); collector_ClassD.insert(self); @@ -358,7 +354,7 @@ void ClassD_constructor_24(int nargout, mxArray *out[], int nargin, const mxArra void ClassD_deconstructor_25(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_ClassD",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ClassD::iterator item; @@ -372,7 +368,7 @@ void ClassD_deconstructor_25(int nargout, mxArray *out[], int nargin, const mxAr void gtsamValues_collectorInsertAndMakeBase_26(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamValues.insert(self); @@ -381,7 +377,7 @@ void gtsamValues_collectorInsertAndMakeBase_26(int nargout, mxArray *out[], int void gtsamValues_constructor_27(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new gtsam::Values()); collector_gtsamValues.insert(self); @@ -392,7 +388,7 @@ void gtsamValues_constructor_27(int nargout, mxArray *out[], int nargin, const m void gtsamValues_constructor_28(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; gtsam::Values& other = *unwrap_shared_ptr< gtsam::Values >(in[0], "ptr_gtsamValues"); Shared *self = new Shared(new gtsam::Values(other)); @@ -403,7 +399,7 @@ void gtsamValues_constructor_28(int nargout, mxArray *out[], int nargin, const m void gtsamValues_deconstructor_29(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_gtsamValues",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamValues::iterator item; diff --git a/wrap/tests/expected/matlab/special_cases_wrapper.cpp b/wrap/tests/expected/matlab/special_cases_wrapper.cpp index 1c228e637..0669b442e 100644 --- a/wrap/tests/expected/matlab/special_cases_wrapper.cpp +++ b/wrap/tests/expected/matlab/special_cases_wrapper.cpp @@ -1,22 +1,18 @@ #include #include -#include -#include -#include - #include typedef gtsam::PinholeCamera PinholeCameraCal3Bundler; typedef gtsam::GeneralSFMFactor, gtsam::Point3> GeneralSFMFactorCal3Bundler; -typedef std::set*> Collector_gtsamNonlinearFactorGraph; +typedef std::set*> Collector_gtsamNonlinearFactorGraph; static Collector_gtsamNonlinearFactorGraph collector_gtsamNonlinearFactorGraph; -typedef std::set*> Collector_gtsamSfmTrack; +typedef std::set*> Collector_gtsamSfmTrack; static Collector_gtsamSfmTrack collector_gtsamSfmTrack; -typedef std::set*> Collector_gtsamPinholeCameraCal3Bundler; +typedef std::set*> Collector_gtsamPinholeCameraCal3Bundler; static Collector_gtsamPinholeCameraCal3Bundler collector_gtsamPinholeCameraCal3Bundler; -typedef std::set*> Collector_gtsamGeneralSFMFactorCal3Bundler; +typedef std::set*> Collector_gtsamGeneralSFMFactorCal3Bundler; static Collector_gtsamGeneralSFMFactorCal3Bundler collector_gtsamGeneralSFMFactorCal3Bundler; @@ -94,7 +90,7 @@ void _special_cases_RTTIRegister() { void gtsamNonlinearFactorGraph_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamNonlinearFactorGraph.insert(self); @@ -102,7 +98,7 @@ void gtsamNonlinearFactorGraph_collectorInsertAndMakeBase_0(int nargout, mxArray void gtsamNonlinearFactorGraph_deconstructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_gtsamNonlinearFactorGraph",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamNonlinearFactorGraph::iterator item; @@ -119,14 +115,14 @@ void gtsamNonlinearFactorGraph_addPrior_2(int nargout, mxArray *out[], int nargi auto obj = unwrap_shared_ptr(in[0], "ptr_gtsamNonlinearFactorGraph"); size_t key = unwrap< size_t >(in[1]); gtsam::PinholeCamera& prior = *unwrap_shared_ptr< gtsam::PinholeCamera >(in[2], "ptr_gtsamPinholeCameraCal3Bundler"); - boost::shared_ptr noiseModel = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[3], "ptr_gtsamnoiseModelBase"); + std::shared_ptr noiseModel = unwrap_shared_ptr< gtsam::noiseModel::Base >(in[3], "ptr_gtsamnoiseModelBase"); obj->addPrior>(key,prior,noiseModel); } void gtsamSfmTrack_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamSfmTrack.insert(self); @@ -134,7 +130,7 @@ void gtsamSfmTrack_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int void gtsamSfmTrack_deconstructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_gtsamSfmTrack",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamSfmTrack::iterator item; @@ -149,21 +145,21 @@ void gtsamSfmTrack_get_measurements_5(int nargout, mxArray *out[], int nargin, c { checkArguments("measurements",nargout,nargin-1,0); auto obj = unwrap_shared_ptr(in[0], "ptr_gtsamSfmTrack"); - out[0] = wrap_shared_ptr(boost::make_shared>>(obj->measurements),"std.vectorpairsize_tPoint2", false); + out[0] = wrap_shared_ptr(std::make_shared>>(obj->measurements),"std.vectorpairsize_tPoint2", false); } void gtsamSfmTrack_set_measurements_6(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("measurements",nargout,nargin-1,1); auto obj = unwrap_shared_ptr(in[0], "ptr_gtsamSfmTrack"); - boost::shared_ptr>> measurements = unwrap_shared_ptr< std::vector> >(in[1], "ptr_stdvectorpairsize_tPoint2"); + std::shared_ptr>> measurements = unwrap_shared_ptr< std::vector> >(in[1], "ptr_stdvectorpairsize_tPoint2"); obj->measurements = *measurements; } void gtsamPinholeCameraCal3Bundler_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamPinholeCameraCal3Bundler.insert(self); @@ -171,7 +167,7 @@ void gtsamPinholeCameraCal3Bundler_collectorInsertAndMakeBase_7(int nargout, mxA void gtsamPinholeCameraCal3Bundler_deconstructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_gtsamPinholeCameraCal3Bundler",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamPinholeCameraCal3Bundler::iterator item; @@ -185,7 +181,7 @@ void gtsamPinholeCameraCal3Bundler_deconstructor_8(int nargout, mxArray *out[], void gtsamGeneralSFMFactorCal3Bundler_collectorInsertAndMakeBase_9(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr, gtsam::Point3>> Shared; + typedef std::shared_ptr, gtsam::Point3>> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_gtsamGeneralSFMFactorCal3Bundler.insert(self); @@ -193,7 +189,7 @@ void gtsamGeneralSFMFactorCal3Bundler_collectorInsertAndMakeBase_9(int nargout, void gtsamGeneralSFMFactorCal3Bundler_deconstructor_10(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr, gtsam::Point3>> Shared; + typedef std::shared_ptr, gtsam::Point3>> Shared; checkArguments("delete_gtsamGeneralSFMFactorCal3Bundler",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_gtsamGeneralSFMFactorCal3Bundler::iterator item; @@ -208,14 +204,14 @@ void gtsamGeneralSFMFactorCal3Bundler_get_verbosity_11(int nargout, mxArray *out { checkArguments("verbosity",nargout,nargin-1,0); auto obj = unwrap_shared_ptr, gtsam::Point3>>(in[0], "ptr_gtsamGeneralSFMFactorCal3Bundler"); - out[0] = wrap_shared_ptr(boost::make_shared, gtsam::Point3>::Verbosity>(obj->verbosity),"gtsam.GeneralSFMFactor, gtsam::Point3>.Verbosity", false); + out[0] = wrap_shared_ptr(std::make_shared, gtsam::Point3>::Verbosity>(obj->verbosity),"gtsam.GeneralSFMFactor, gtsam::Point3>.Verbosity", false); } void gtsamGeneralSFMFactorCal3Bundler_set_verbosity_12(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { checkArguments("verbosity",nargout,nargin-1,1); auto obj = unwrap_shared_ptr, gtsam::Point3>>(in[0], "ptr_gtsamGeneralSFMFactorCal3Bundler"); - boost::shared_ptr, gtsam::Point3>::Verbosity> verbosity = unwrap_shared_ptr< gtsam::GeneralSFMFactor, gtsam::Point3>::Verbosity >(in[1], "ptr_gtsamGeneralSFMFactor, gtsam::Point3>Verbosity"); + std::shared_ptr, gtsam::Point3>::Verbosity> verbosity = unwrap_shared_ptr< gtsam::GeneralSFMFactor, gtsam::Point3>::Verbosity >(in[1], "ptr_gtsamGeneralSFMFactor, gtsam::Point3>Verbosity"); obj->verbosity = *verbosity; } diff --git a/wrap/tests/expected/matlab/template_wrapper.cpp b/wrap/tests/expected/matlab/template_wrapper.cpp index a0b1aaa7e..7f0c399ad 100644 --- a/wrap/tests/expected/matlab/template_wrapper.cpp +++ b/wrap/tests/expected/matlab/template_wrapper.cpp @@ -1,17 +1,13 @@ #include #include -#include -#include -#include - typedef ScopedTemplate ScopedTemplateResult; -typedef std::set*> Collector_TemplatedConstructor; +typedef std::set*> Collector_TemplatedConstructor; static Collector_TemplatedConstructor collector_TemplatedConstructor; -typedef std::set*> Collector_ScopedTemplateResult; +typedef std::set*> Collector_ScopedTemplateResult; static Collector_ScopedTemplateResult collector_ScopedTemplateResult; @@ -77,7 +73,7 @@ void _template_RTTIRegister() { void TemplatedConstructor_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_TemplatedConstructor.insert(self); @@ -86,7 +82,7 @@ void TemplatedConstructor_collectorInsertAndMakeBase_0(int nargout, mxArray *out void TemplatedConstructor_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; Shared *self = new Shared(new TemplatedConstructor()); collector_TemplatedConstructor.insert(self); @@ -97,7 +93,7 @@ void TemplatedConstructor_constructor_1(int nargout, mxArray *out[], int nargin, void TemplatedConstructor_constructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; string& arg = *unwrap_shared_ptr< string >(in[0], "ptr_string"); Shared *self = new Shared(new TemplatedConstructor(arg)); @@ -109,7 +105,7 @@ void TemplatedConstructor_constructor_2(int nargout, mxArray *out[], int nargin, void TemplatedConstructor_constructor_3(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; int arg = unwrap< int >(in[0]); Shared *self = new Shared(new TemplatedConstructor(arg)); @@ -121,7 +117,7 @@ void TemplatedConstructor_constructor_3(int nargout, mxArray *out[], int nargin, void TemplatedConstructor_constructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; double arg = unwrap< double >(in[0]); Shared *self = new Shared(new TemplatedConstructor(arg)); @@ -132,7 +128,7 @@ void TemplatedConstructor_constructor_4(int nargout, mxArray *out[], int nargin, void TemplatedConstructor_deconstructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr Shared; + typedef std::shared_ptr Shared; checkArguments("delete_TemplatedConstructor",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_TemplatedConstructor::iterator item; @@ -146,7 +142,7 @@ void TemplatedConstructor_deconstructor_5(int nargout, mxArray *out[], int nargi void ScopedTemplateResult_collectorInsertAndMakeBase_6(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Shared *self = *reinterpret_cast (mxGetData(in[0])); collector_ScopedTemplateResult.insert(self); @@ -155,7 +151,7 @@ void ScopedTemplateResult_collectorInsertAndMakeBase_6(int nargout, mxArray *out void ScopedTemplateResult_constructor_7(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { mexAtExit(&_deleteAllObjects); - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; Result::Value& arg = *unwrap_shared_ptr< Result::Value >(in[0], "ptr_Result::Value"); Shared *self = new Shared(new ScopedTemplate(arg)); @@ -166,7 +162,7 @@ void ScopedTemplateResult_constructor_7(int nargout, mxArray *out[], int nargin, void ScopedTemplateResult_deconstructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[]) { - typedef boost::shared_ptr> Shared; + typedef std::shared_ptr> Shared; checkArguments("delete_ScopedTemplateResult",nargout,nargin,1); Shared *self = *reinterpret_cast(mxGetData(in[0])); Collector_ScopedTemplateResult::iterator item; diff --git a/wrap/tests/expected/python/class_pybind.cpp b/wrap/tests/expected/python/class_pybind.cpp index 92ab8b1e7..86d69c2e0 100644 --- a/wrap/tests/expected/python/class_pybind.cpp +++ b/wrap/tests/expected/python/class_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -8,10 +6,6 @@ #include "folder/path/to/Test.h" -#include "wrap/serialization.h" -#include - - diff --git a/wrap/tests/expected/python/enum_pybind.cpp b/wrap/tests/expected/python/enum_pybind.cpp index 73b74bd86..2fa804ac9 100644 --- a/wrap/tests/expected/python/enum_pybind.cpp +++ b/wrap/tests/expected/python/enum_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -7,10 +5,6 @@ #include "gtsam/nonlinear/utilities.h" // for RedirectCout. -#include "wrap/serialization.h" -#include - - diff --git a/wrap/tests/expected/python/functions_pybind.cpp b/wrap/tests/expected/python/functions_pybind.cpp index 56ab66bf5..b0490dcdc 100644 --- a/wrap/tests/expected/python/functions_pybind.cpp +++ b/wrap/tests/expected/python/functions_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -7,10 +5,6 @@ #include "gtsam/nonlinear/utilities.h" // for RedirectCout. -#include "wrap/serialization.h" -#include - - diff --git a/wrap/tests/expected/python/geometry_pybind.cpp b/wrap/tests/expected/python/geometry_pybind.cpp index 64ba5485d..eb85c8209 100644 --- a/wrap/tests/expected/python/geometry_pybind.cpp +++ b/wrap/tests/expected/python/geometry_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -8,16 +6,12 @@ #include "gtsam/geometry/Point2.h" #include "gtsam/geometry/Point3.h" - -#include "wrap/serialization.h" #include BOOST_CLASS_EXPORT(gtsam::Point2) BOOST_CLASS_EXPORT(gtsam::Point3) - - using namespace std; namespace py = pybind11; diff --git a/wrap/tests/expected/python/inheritance_pybind.cpp b/wrap/tests/expected/python/inheritance_pybind.cpp index 3aa3b918a..cf1dbe44c 100644 --- a/wrap/tests/expected/python/inheritance_pybind.cpp +++ b/wrap/tests/expected/python/inheritance_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -7,10 +5,6 @@ #include "gtsam/nonlinear/utilities.h" // for RedirectCout. -#include "wrap/serialization.h" -#include - - diff --git a/wrap/tests/expected/python/namespaces_pybind.cpp b/wrap/tests/expected/python/namespaces_pybind.cpp index 53e9d186a..ab8418bc9 100644 --- a/wrap/tests/expected/python/namespaces_pybind.cpp +++ b/wrap/tests/expected/python/namespaces_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -13,10 +11,6 @@ #include "path/to/ns3.h" #include "gtsam/nonlinear/Values.h" -#include "wrap/serialization.h" -#include - - diff --git a/wrap/tests/expected/python/operator_pybind.cpp b/wrap/tests/expected/python/operator_pybind.cpp index 536d4f7da..028362a58 100644 --- a/wrap/tests/expected/python/operator_pybind.cpp +++ b/wrap/tests/expected/python/operator_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -8,10 +6,6 @@ #include "gtsam/geometry/Pose3.h" -#include "wrap/serialization.h" -#include - - diff --git a/wrap/tests/expected/python/special_cases_pybind.cpp b/wrap/tests/expected/python/special_cases_pybind.cpp index e19b2eb95..15db647a0 100644 --- a/wrap/tests/expected/python/special_cases_pybind.cpp +++ b/wrap/tests/expected/python/special_cases_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -8,10 +6,6 @@ #include "gtsam/geometry/Cal3Bundler.h" -#include "wrap/serialization.h" -#include - - diff --git a/wrap/tests/expected/python/templates_pybind.cpp b/wrap/tests/expected/python/templates_pybind.cpp index 4d13d3731..4a23b1e00 100644 --- a/wrap/tests/expected/python/templates_pybind.cpp +++ b/wrap/tests/expected/python/templates_pybind.cpp @@ -1,5 +1,3 @@ - - #include #include #include @@ -7,10 +5,6 @@ #include "gtsam/nonlinear/utilities.h" // for RedirectCout. -#include "wrap/serialization.h" -#include - - diff --git a/wrap/tests/fixtures/class.i b/wrap/tests/fixtures/class.i index 573d1f686..766f55329 100644 --- a/wrap/tests/fixtures/class.i +++ b/wrap/tests/fixtures/class.i @@ -3,6 +3,8 @@ class FunRange { This range(double d); static This create(); + + void serialize() const; }; template diff --git a/wrap/tests/pybind_wrapper.tpl b/wrap/tests/pybind_wrapper.tpl index b23f5bee7..debc45784 100644 --- a/wrap/tests/pybind_wrapper.tpl +++ b/wrap/tests/pybind_wrapper.tpl @@ -1,5 +1,3 @@ -{include_boost} - #include #include #include @@ -7,13 +5,9 @@ #include "gtsam/nonlinear/utilities.h" // for RedirectCout. {includes} -#include "wrap/serialization.h" -#include {boost_class_export} -{holder_type} - using namespace std; namespace py = pybind11; diff --git a/wrap/tests/test_interface_parser.py b/wrap/tests/test_interface_parser.py index ae941bf96..19462a51a 100644 --- a/wrap/tests/test_interface_parser.py +++ b/wrap/tests/test_interface_parser.py @@ -25,12 +25,12 @@ from gtwrap.interface_parser import (ArgumentList, Class, Constructor, Enum, StaticMethod, TemplatedType, Type, TypedefTemplateInstantiation, Typename, Variable) - from gtwrap.template_instantiator.classes import InstantiatedClass class TestInterfaceParser(unittest.TestCase): """Test driver for all classes in interface_parser.py.""" + def test_typename(self): """Test parsing of Typename.""" typename = Typename.rule.parseString("size_t")[0] @@ -89,10 +89,7 @@ class TestInterfaceParser(unittest.TestCase): self.assertEqual("Pose3", t.typename.name) self.assertEqual(["gtsam"], t.typename.namespaces) self.assertTrue(t.is_shared_ptr) - self.assertEqual("std::shared_ptr", - t.to_cpp(use_boost=False)) - self.assertEqual("boost::shared_ptr", - t.to_cpp(use_boost=True)) + self.assertEqual("std::shared_ptr", t.to_cpp()) # Check raw pointer t = Type.rule.parseString("gtsam::Pose3@ x")[0] @@ -176,11 +173,9 @@ class TestInterfaceParser(unittest.TestCase): args_list = args.list() self.assertEqual(2, len(args_list)) self.assertEqual("std::pair", - args_list[0].ctype.to_cpp(False)) + args_list[0].ctype.to_cpp()) self.assertEqual("vector>", - args_list[1].ctype.to_cpp(False)) - self.assertEqual("vector>", - args_list[1].ctype.to_cpp(True)) + args_list[1].ctype.to_cpp()) def test_default_arguments(self): """Tests any expression that is a valid default argument""" @@ -503,7 +498,8 @@ class TestInterfaceParser(unittest.TestCase): ret = Class.rule.parseString( "class ForwardKinematicsFactor : gtsam::BetweenFactor {};" )[0] - ret = InstantiatedClass(ret, []) # Needed to correctly parse parent class + ret = InstantiatedClass(ret, + []) # Needed to correctly parse parent class self.assertEqual("ForwardKinematicsFactor", ret.name) self.assertEqual("BetweenFactor", ret.parent_class.name) self.assertEqual(["gtsam"], ret.parent_class.namespaces) diff --git a/wrap/tests/test_matlab_wrapper.py b/wrap/tests/test_matlab_wrapper.py index 43fedf7aa..17b2dd11d 100644 --- a/wrap/tests/test_matlab_wrapper.py +++ b/wrap/tests/test_matlab_wrapper.py @@ -20,6 +20,7 @@ class TestWrap(unittest.TestCase): """ Test the Matlab wrapper """ + def setUp(self) -> None: super().setUp() @@ -36,7 +37,7 @@ class TestWrap(unittest.TestCase): template_file = osp.join(self.TEST_DIR, "..", "gtwrap", "matlab_wrapper", "matlab_wrapper.tpl") if not osp.exists(template_file): - with open(template_file, 'w') as tpl: + with open(template_file, 'w', encoding="UTF-8") as tpl: tpl.write("#include \n#include \n") # Create the `actual/matlab` directory @@ -51,8 +52,8 @@ class TestWrap(unittest.TestCase): success = filecmp.cmp(actual, expected) if not success: - os.system("diff {} {}".format(actual, expected)) - self.assertTrue(success, "Mismatch for file {0}".format(file)) + os.system(f"diff {actual} {expected}") + self.assertTrue(success, f"Mismatch for file {file}") def test_geometry(self): """ @@ -63,11 +64,10 @@ class TestWrap(unittest.TestCase): file = osp.join(self.INTERFACE_DIR, 'geometry.i') # Create MATLAB wrapper instance - wrapper = MatlabWrapper( - module_name='geometry', - top_module_namespace=['gtsam'], - ignore_classes=[''], - ) + wrapper = MatlabWrapper(module_name='geometry', + top_module_namespace=['gtsam'], + ignore_classes=[''], + use_boost_serialization=True) wrapper.wrap([file], path=self.MATLAB_ACTUAL_DIR) diff --git a/wrap/tests/test_pybind_wrapper.py b/wrap/tests/test_pybind_wrapper.py index b47b4aca1..6a196f4ac 100644 --- a/wrap/tests/test_pybind_wrapper.py +++ b/wrap/tests/test_pybind_wrapper.py @@ -31,20 +31,25 @@ class TestWrap(unittest.TestCase): # Create the `actual/python` directory os.makedirs(PYTHON_ACTUAL_DIR, exist_ok=True) - def wrap_content(self, sources, module_name, output_dir): + def wrap_content(self, + sources, + module_name, + output_dir, + use_boost_serialization=False): """ Common function to wrap content in `sources`. """ - with open(osp.join(self.TEST_DIR, - "pybind_wrapper.tpl")) as template_file: + with open(osp.join(self.TEST_DIR, "pybind_wrapper.tpl"), + encoding="UTF-8") as template_file: module_template = template_file.read() # Create Pybind wrapper instance - wrapper = PybindWrapper(module_name=module_name, - use_boost=False, - top_module_namespaces=[''], - ignore_classes=[''], - module_template=module_template) + wrapper = PybindWrapper( + module_name=module_name, + top_module_namespaces=[''], + ignore_classes=[''], + module_template=module_template, + use_boost_serialization=use_boost_serialization) output = osp.join(self.TEST_DIR, output_dir, module_name + ".cpp") @@ -64,8 +69,8 @@ class TestWrap(unittest.TestCase): success = filecmp.cmp(actual, expected) if not success: - os.system("diff {} {}".format(actual, expected)) - self.assertTrue(success, "Mismatch for file {0}".format(file)) + os.system(f"diff {actual} {expected}") + self.assertTrue(success, f"Mismatch for file {file}") def test_geometry(self): """ @@ -74,8 +79,10 @@ class TestWrap(unittest.TestCase): geometry_py --out output/geometry_py.cc """ source = osp.join(self.INTERFACE_DIR, 'geometry.i') - output = self.wrap_content([source], 'geometry_py', - self.PYTHON_ACTUAL_DIR) + output = self.wrap_content([source], + 'geometry_py', + self.PYTHON_ACTUAL_DIR, + use_boost_serialization=True) self.compare_and_diff('geometry_pybind.cpp', output)