namespaces_wrapper.cpp
Go to the documentation of this file.
1 #include <gtwrap/matlab.h>
2 #include <map>
3 
5 #include <path/to/ns1.h>
6 #include <path/to/ns1/ClassB.h>
7 #include <path/to/ns2.h>
8 #include <path/to/ns2/ClassA.h>
9 #include <path/to/ns3.h>
10 
11 
12 
13 typedef std::set<std::shared_ptr<ns1::ClassA>*> Collector_ns1ClassA;
15 typedef std::set<std::shared_ptr<ns1::ClassB>*> Collector_ns1ClassB;
17 typedef std::set<std::shared_ptr<ns2::ClassA>*> Collector_ns2ClassA;
19 typedef std::set<std::shared_ptr<ns2::ns3::ClassB>*> Collector_ns2ns3ClassB;
21 typedef std::set<std::shared_ptr<ns2::ClassC>*> Collector_ns2ClassC;
23 typedef std::set<std::shared_ptr<ClassD>*> Collector_ClassD;
25 typedef std::set<std::shared_ptr<gtsam::Values>*> Collector_gtsamValues;
27 
28 
30 {
31  mstream mout;
32  std::streambuf *outbuf = std::cout.rdbuf(&mout);
33 
34  bool anyDeleted = false;
35  { for(Collector_ns1ClassA::iterator iter = collector_ns1ClassA.begin();
36  iter != collector_ns1ClassA.end(); ) {
37  delete *iter;
38  collector_ns1ClassA.erase(iter++);
39  anyDeleted = true;
40  } }
41  { for(Collector_ns1ClassB::iterator iter = collector_ns1ClassB.begin();
42  iter != collector_ns1ClassB.end(); ) {
43  delete *iter;
44  collector_ns1ClassB.erase(iter++);
45  anyDeleted = true;
46  } }
47  { for(Collector_ns2ClassA::iterator iter = collector_ns2ClassA.begin();
48  iter != collector_ns2ClassA.end(); ) {
49  delete *iter;
50  collector_ns2ClassA.erase(iter++);
51  anyDeleted = true;
52  } }
53  { for(Collector_ns2ns3ClassB::iterator iter = collector_ns2ns3ClassB.begin();
54  iter != collector_ns2ns3ClassB.end(); ) {
55  delete *iter;
57  anyDeleted = true;
58  } }
59  { for(Collector_ns2ClassC::iterator iter = collector_ns2ClassC.begin();
60  iter != collector_ns2ClassC.end(); ) {
61  delete *iter;
62  collector_ns2ClassC.erase(iter++);
63  anyDeleted = true;
64  } }
65  { for(Collector_ClassD::iterator iter = collector_ClassD.begin();
66  iter != collector_ClassD.end(); ) {
67  delete *iter;
68  collector_ClassD.erase(iter++);
69  anyDeleted = true;
70  } }
71  { for(Collector_gtsamValues::iterator iter = collector_gtsamValues.begin();
72  iter != collector_gtsamValues.end(); ) {
73  delete *iter;
74  collector_gtsamValues.erase(iter++);
75  anyDeleted = true;
76  } }
77 
78  if(anyDeleted)
79  cout <<
80  "WARNING: Wrap modules with variables in the workspace have been reloaded due to\n"
81  "calling destructors, call 'clear all' again if you plan to now recompile a wrap\n"
82  "module, so that your recompiled module is used instead of the old one." << endl;
83  std::cout.rdbuf(outbuf);
84 }
85 
87  const mxArray *alreadyCreated = mexGetVariablePtr("global", "gtsam_namespaces_rttiRegistry_created");
88  if(!alreadyCreated) {
89  std::map<std::string, std::string> types;
90 
91 
92 
93  mxArray *registry = mexGetVariable("global", "gtsamwrap_rttiRegistry");
94  if(!registry)
95  registry = mxCreateStructMatrix(1, 1, 0, NULL);
96  typedef std::pair<std::string, std::string> StringPair;
97  for(const StringPair& rtti_matlab: types) {
98  int fieldId = mxAddField(registry, rtti_matlab.first.c_str());
99  if(fieldId < 0) {
100  mexErrMsgTxt("gtsam wrap: Error indexing RTTI types, inheritance will not work correctly");
101  }
102  mxArray *matlabName = mxCreateString(rtti_matlab.second.c_str());
103  mxSetFieldByNumber(registry, 0, fieldId, matlabName);
104  }
105  if(mexPutVariable("global", "gtsamwrap_rttiRegistry", registry) != 0) {
106  mexErrMsgTxt("gtsam wrap: Error indexing RTTI types, inheritance will not work correctly");
107  }
108  mxDestroyArray(registry);
109 
110  mxArray *newAlreadyCreated = mxCreateNumericMatrix(0, 0, mxINT8_CLASS, mxREAL);
111  if(mexPutVariable("global", "gtsam_namespaces_rttiRegistry_created", newAlreadyCreated) != 0) {
112  mexErrMsgTxt("gtsam wrap: Error indexing RTTI types, inheritance will not work correctly");
113  }
114  mxDestroyArray(newAlreadyCreated);
115  }
116 }
117 
118 void ns1ClassA_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
119 {
120  mexAtExit(&_deleteAllObjects);
121  typedef std::shared_ptr<ns1::ClassA> Shared;
122 
123  Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
124  collector_ns1ClassA.insert(self);
125 }
126 
127 void ns1ClassA_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
128 {
129  mexAtExit(&_deleteAllObjects);
130  typedef std::shared_ptr<ns1::ClassA> Shared;
131 
132  Shared *self = new Shared(new ns1::ClassA());
133  collector_ns1ClassA.insert(self);
134  out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
135  *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
136 }
137 
138 void ns1ClassA_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
139 {
140  typedef std::shared_ptr<ns1::ClassA> Shared;
141  checkArguments("delete_ns1ClassA",nargout,nargin,1);
142  Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
143  Collector_ns1ClassA::iterator item;
144  item = collector_ns1ClassA.find(self);
145  if(item != collector_ns1ClassA.end()) {
146  collector_ns1ClassA.erase(item);
147  }
148  delete self;
149 }
150 
151 void ns1ClassB_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
152 {
153  mexAtExit(&_deleteAllObjects);
154  typedef std::shared_ptr<ns1::ClassB> Shared;
155 
156  Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
157  collector_ns1ClassB.insert(self);
158 }
159 
160 void ns1ClassB_constructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
161 {
162  mexAtExit(&_deleteAllObjects);
163  typedef std::shared_ptr<ns1::ClassB> Shared;
164 
165  Shared *self = new Shared(new ns1::ClassB());
166  collector_ns1ClassB.insert(self);
167  out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
168  *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
169 }
170 
171 void ns1ClassB_deconstructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[])
172 {
173  typedef std::shared_ptr<ns1::ClassB> Shared;
174  checkArguments("delete_ns1ClassB",nargout,nargin,1);
175  Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
176  Collector_ns1ClassB::iterator item;
177  item = collector_ns1ClassB.find(self);
178  if(item != collector_ns1ClassB.end()) {
179  collector_ns1ClassB.erase(item);
180  }
181  delete self;
182 }
183 
184 void aGlobalFunction_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
185 {
186  checkArguments("aGlobalFunction",nargout,nargin,0);
187  out[0] = wrap< Vector >(ns1::aGlobalFunction());
188 }
189 void ns2ClassA_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nargin, const mxArray *in[])
190 {
191  mexAtExit(&_deleteAllObjects);
192  typedef std::shared_ptr<ns2::ClassA> Shared;
193 
194  Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
195  collector_ns2ClassA.insert(self);
196 }
197 
198 void ns2ClassA_constructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
199 {
200  mexAtExit(&_deleteAllObjects);
201  typedef std::shared_ptr<ns2::ClassA> Shared;
202 
203  Shared *self = new Shared(new ns2::ClassA());
204  collector_ns2ClassA.insert(self);
205  out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
206  *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
207 }
208 
209 void ns2ClassA_deconstructor_9(int nargout, mxArray *out[], int nargin, const mxArray *in[])
210 {
211  typedef std::shared_ptr<ns2::ClassA> Shared;
212  checkArguments("delete_ns2ClassA",nargout,nargin,1);
213  Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
214  Collector_ns2ClassA::iterator item;
215  item = collector_ns2ClassA.find(self);
216  if(item != collector_ns2ClassA.end()) {
217  collector_ns2ClassA.erase(item);
218  }
219  delete self;
220 }
221 
222 void ns2ClassA_memberFunction_10(int nargout, mxArray *out[], int nargin, const mxArray *in[])
223 {
224  checkArguments("memberFunction",nargout,nargin-1,0);
225  auto obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
226  out[0] = wrap< double >(obj->memberFunction());
227 }
228 
229 void ns2ClassA_nsArg_11(int nargout, mxArray *out[], int nargin, const mxArray *in[])
230 {
231  checkArguments("nsArg",nargout,nargin-1,1);
232  auto obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
233  ns1::ClassB& arg = *unwrap_shared_ptr< ns1::ClassB >(in[1], "ptr_ns1ClassB");
234  out[0] = wrap< int >(obj->nsArg(arg));
235 }
236 
237 void ns2ClassA_nsReturn_12(int nargout, mxArray *out[], int nargin, const mxArray *in[])
238 {
239  checkArguments("nsReturn",nargout,nargin-1,1);
240  auto obj = unwrap_shared_ptr<ns2::ClassA>(in[0], "ptr_ns2ClassA");
241  double q = unwrap< double >(in[1]);
242  out[0] = wrap_shared_ptr(std::make_shared<ns2::ns3::ClassB>(obj->nsReturn(q)),"ns2.ns3.ClassB", false);
243 }
244 
245 void ns2ClassA_afunction_13(int nargout, mxArray *out[], int nargin, const mxArray *in[])
246 {
247  checkArguments("ns2::ClassA.afunction",nargout,nargin,0);
248  out[0] = wrap< double >(ns2::ClassA::afunction());
249 }
250 
251 void ns2ns3ClassB_collectorInsertAndMakeBase_14(int nargout, mxArray *out[], int nargin, const mxArray *in[])
252 {
253  mexAtExit(&_deleteAllObjects);
254  typedef std::shared_ptr<ns2::ns3::ClassB> Shared;
255 
256  Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
257  collector_ns2ns3ClassB.insert(self);
258 }
259 
260 void ns2ns3ClassB_constructor_15(int nargout, mxArray *out[], int nargin, const mxArray *in[])
261 {
262  mexAtExit(&_deleteAllObjects);
263  typedef std::shared_ptr<ns2::ns3::ClassB> Shared;
264 
265  Shared *self = new Shared(new ns2::ns3::ClassB());
266  collector_ns2ns3ClassB.insert(self);
267  out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
268  *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
269 }
270 
271 void ns2ns3ClassB_deconstructor_16(int nargout, mxArray *out[], int nargin, const mxArray *in[])
272 {
273  typedef std::shared_ptr<ns2::ns3::ClassB> Shared;
274  checkArguments("delete_ns2ns3ClassB",nargout,nargin,1);
275  Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
276  Collector_ns2ns3ClassB::iterator item;
277  item = collector_ns2ns3ClassB.find(self);
278  if(item != collector_ns2ns3ClassB.end()) {
279  collector_ns2ns3ClassB.erase(item);
280  }
281  delete self;
282 }
283 
284 void ns2ClassC_collectorInsertAndMakeBase_17(int nargout, mxArray *out[], int nargin, const mxArray *in[])
285 {
286  mexAtExit(&_deleteAllObjects);
287  typedef std::shared_ptr<ns2::ClassC> Shared;
288 
289  Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
290  collector_ns2ClassC.insert(self);
291 }
292 
293 void ns2ClassC_constructor_18(int nargout, mxArray *out[], int nargin, const mxArray *in[])
294 {
295  mexAtExit(&_deleteAllObjects);
296  typedef std::shared_ptr<ns2::ClassC> Shared;
297 
298  Shared *self = new Shared(new ns2::ClassC());
299  collector_ns2ClassC.insert(self);
300  out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
301  *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
302 }
303 
304 void ns2ClassC_deconstructor_19(int nargout, mxArray *out[], int nargin, const mxArray *in[])
305 {
306  typedef std::shared_ptr<ns2::ClassC> Shared;
307  checkArguments("delete_ns2ClassC",nargout,nargin,1);
308  Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
309  Collector_ns2ClassC::iterator item;
310  item = collector_ns2ClassC.find(self);
311  if(item != collector_ns2ClassC.end()) {
312  collector_ns2ClassC.erase(item);
313  }
314  delete self;
315 }
316 
317 void aGlobalFunction_20(int nargout, mxArray *out[], int nargin, const mxArray *in[])
318 {
319  checkArguments("aGlobalFunction",nargout,nargin,0);
320  out[0] = wrap< Vector >(ns2::aGlobalFunction());
321 }
322 void overloadedGlobalFunction_21(int nargout, mxArray *out[], int nargin, const mxArray *in[])
323 {
324  checkArguments("overloadedGlobalFunction",nargout,nargin,1);
325  ns1::ClassA& a = *unwrap_shared_ptr< ns1::ClassA >(in[0], "ptr_ns1ClassA");
326  out[0] = wrap_shared_ptr(std::make_shared<ns1::ClassA>(ns2::overloadedGlobalFunction(a)),"ns1.ClassA", false);
327 }
328 void overloadedGlobalFunction_22(int nargout, mxArray *out[], int nargin, const mxArray *in[])
329 {
330  checkArguments("overloadedGlobalFunction",nargout,nargin,2);
331  ns1::ClassA& a = *unwrap_shared_ptr< ns1::ClassA >(in[0], "ptr_ns1ClassA");
332  double b = unwrap< double >(in[1]);
333  out[0] = wrap_shared_ptr(std::make_shared<ns1::ClassA>(ns2::overloadedGlobalFunction(a,b)),"ns1.ClassA", false);
334 }
335 void ClassD_collectorInsertAndMakeBase_23(int nargout, mxArray *out[], int nargin, const mxArray *in[])
336 {
337  mexAtExit(&_deleteAllObjects);
338  typedef std::shared_ptr<ClassD> Shared;
339 
340  Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
341  collector_ClassD.insert(self);
342 }
343 
344 void ClassD_constructor_24(int nargout, mxArray *out[], int nargin, const mxArray *in[])
345 {
346  mexAtExit(&_deleteAllObjects);
347  typedef std::shared_ptr<ClassD> Shared;
348 
349  Shared *self = new Shared(new ClassD());
350  collector_ClassD.insert(self);
351  out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
352  *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
353 }
354 
355 void ClassD_deconstructor_25(int nargout, mxArray *out[], int nargin, const mxArray *in[])
356 {
357  typedef std::shared_ptr<ClassD> Shared;
358  checkArguments("delete_ClassD",nargout,nargin,1);
359  Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
360  Collector_ClassD::iterator item;
361  item = collector_ClassD.find(self);
362  if(item != collector_ClassD.end()) {
363  collector_ClassD.erase(item);
364  }
365  delete self;
366 }
367 
368 void gtsamValues_collectorInsertAndMakeBase_26(int nargout, mxArray *out[], int nargin, const mxArray *in[])
369 {
370  mexAtExit(&_deleteAllObjects);
371  typedef std::shared_ptr<gtsam::Values> Shared;
372 
373  Shared *self = *reinterpret_cast<Shared**> (mxGetData(in[0]));
374  collector_gtsamValues.insert(self);
375 }
376 
377 void gtsamValues_constructor_27(int nargout, mxArray *out[], int nargin, const mxArray *in[])
378 {
379  mexAtExit(&_deleteAllObjects);
380  typedef std::shared_ptr<gtsam::Values> Shared;
381 
382  Shared *self = new Shared(new gtsam::Values());
383  collector_gtsamValues.insert(self);
384  out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
385  *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
386 }
387 
388 void gtsamValues_constructor_28(int nargout, mxArray *out[], int nargin, const mxArray *in[])
389 {
390  mexAtExit(&_deleteAllObjects);
391  typedef std::shared_ptr<gtsam::Values> Shared;
392 
393  gtsam::Values& other = *unwrap_shared_ptr< gtsam::Values >(in[0], "ptr_gtsamValues");
394  Shared *self = new Shared(new gtsam::Values(other));
395  collector_gtsamValues.insert(self);
396  out[0] = mxCreateNumericMatrix(1, 1, mxUINT32OR64_CLASS, mxREAL);
397  *reinterpret_cast<Shared**> (mxGetData(out[0])) = self;
398 }
399 
400 void gtsamValues_deconstructor_29(int nargout, mxArray *out[], int nargin, const mxArray *in[])
401 {
402  typedef std::shared_ptr<gtsam::Values> Shared;
403  checkArguments("delete_gtsamValues",nargout,nargin,1);
404  Shared *self = *reinterpret_cast<Shared**>(mxGetData(in[0]));
405  Collector_gtsamValues::iterator item;
406  item = collector_gtsamValues.find(self);
407  if(item != collector_gtsamValues.end()) {
408  collector_gtsamValues.erase(item);
409  }
410  delete self;
411 }
412 
413 void gtsamValues_insert_30(int nargout, mxArray *out[], int nargin, const mxArray *in[])
414 {
415  checkArguments("insert",nargout,nargin-1,2);
416  auto obj = unwrap_shared_ptr<gtsam::Values>(in[0], "ptr_gtsamValues");
417  size_t j = unwrap< size_t >(in[1]);
418  Vector vector = unwrap< Vector >(in[2]);
419  obj->insert(j,vector);
420 }
421 
422 void gtsamValues_insert_31(int nargout, mxArray *out[], int nargin, const mxArray *in[])
423 {
424  checkArguments("insert",nargout,nargin-1,2);
425  auto obj = unwrap_shared_ptr<gtsam::Values>(in[0], "ptr_gtsamValues");
426  size_t j = unwrap< size_t >(in[1]);
427  Matrix matrix = unwrap< Matrix >(in[2]);
428  obj->insert(j,matrix);
429 }
430 
431 
432 void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
433 {
434  mstream mout;
435  std::streambuf *outbuf = std::cout.rdbuf(&mout);
436 
438 
439  int id = unwrap<int>(in[0]);
440 
441  try {
442  switch(id) {
443  case 0:
444  ns1ClassA_collectorInsertAndMakeBase_0(nargout, out, nargin-1, in+1);
445  break;
446  case 1:
447  ns1ClassA_constructor_1(nargout, out, nargin-1, in+1);
448  break;
449  case 2:
450  ns1ClassA_deconstructor_2(nargout, out, nargin-1, in+1);
451  break;
452  case 3:
453  ns1ClassB_collectorInsertAndMakeBase_3(nargout, out, nargin-1, in+1);
454  break;
455  case 4:
456  ns1ClassB_constructor_4(nargout, out, nargin-1, in+1);
457  break;
458  case 5:
459  ns1ClassB_deconstructor_5(nargout, out, nargin-1, in+1);
460  break;
461  case 6:
462  aGlobalFunction_6(nargout, out, nargin-1, in+1);
463  break;
464  case 7:
465  ns2ClassA_collectorInsertAndMakeBase_7(nargout, out, nargin-1, in+1);
466  break;
467  case 8:
468  ns2ClassA_constructor_8(nargout, out, nargin-1, in+1);
469  break;
470  case 9:
471  ns2ClassA_deconstructor_9(nargout, out, nargin-1, in+1);
472  break;
473  case 10:
474  ns2ClassA_memberFunction_10(nargout, out, nargin-1, in+1);
475  break;
476  case 11:
477  ns2ClassA_nsArg_11(nargout, out, nargin-1, in+1);
478  break;
479  case 12:
480  ns2ClassA_nsReturn_12(nargout, out, nargin-1, in+1);
481  break;
482  case 13:
483  ns2ClassA_afunction_13(nargout, out, nargin-1, in+1);
484  break;
485  case 14:
486  ns2ns3ClassB_collectorInsertAndMakeBase_14(nargout, out, nargin-1, in+1);
487  break;
488  case 15:
489  ns2ns3ClassB_constructor_15(nargout, out, nargin-1, in+1);
490  break;
491  case 16:
492  ns2ns3ClassB_deconstructor_16(nargout, out, nargin-1, in+1);
493  break;
494  case 17:
495  ns2ClassC_collectorInsertAndMakeBase_17(nargout, out, nargin-1, in+1);
496  break;
497  case 18:
498  ns2ClassC_constructor_18(nargout, out, nargin-1, in+1);
499  break;
500  case 19:
501  ns2ClassC_deconstructor_19(nargout, out, nargin-1, in+1);
502  break;
503  case 20:
504  aGlobalFunction_20(nargout, out, nargin-1, in+1);
505  break;
506  case 21:
507  overloadedGlobalFunction_21(nargout, out, nargin-1, in+1);
508  break;
509  case 22:
510  overloadedGlobalFunction_22(nargout, out, nargin-1, in+1);
511  break;
512  case 23:
513  ClassD_collectorInsertAndMakeBase_23(nargout, out, nargin-1, in+1);
514  break;
515  case 24:
516  ClassD_constructor_24(nargout, out, nargin-1, in+1);
517  break;
518  case 25:
519  ClassD_deconstructor_25(nargout, out, nargin-1, in+1);
520  break;
521  case 26:
522  gtsamValues_collectorInsertAndMakeBase_26(nargout, out, nargin-1, in+1);
523  break;
524  case 27:
525  gtsamValues_constructor_27(nargout, out, nargin-1, in+1);
526  break;
527  case 28:
528  gtsamValues_constructor_28(nargout, out, nargin-1, in+1);
529  break;
530  case 29:
531  gtsamValues_deconstructor_29(nargout, out, nargin-1, in+1);
532  break;
533  case 30:
534  gtsamValues_insert_30(nargout, out, nargin-1, in+1);
535  break;
536  case 31:
537  gtsamValues_insert_31(nargout, out, nargin-1, in+1);
538  break;
539  }
540  } catch(const std::exception& e) {
541  mexErrMsgTxt(("Exception from gtsam:\n" + std::string(e.what()) + "\n").c_str());
542  }
543 
544  std::cout.rdbuf(outbuf);
545 }
void ns1ClassA_collectorInsertAndMakeBase_0(int nargout, mxArray *out[], int nargin, const mxArray *in[])
int unwrap< int >(const mxArray *array)
Definition: matlab.h:328
void _deleteAllObjects()
void ClassD_deconstructor_25(int nargout, mxArray *out[], int nargin, const mxArray *in[])
mxArray * wrap_shared_ptr(std::shared_ptr< Class > shared_ptr, const std::string &matlabName, bool isVirtual)
Definition: matlab.h:487
Scalar * b
Definition: benchVecAdd.cpp:17
void gtsamValues_collectorInsertAndMakeBase_26(int nargout, mxArray *out[], int nargin, const mxArray *in[])
A non-templated config holding any types of Manifold-group elements.
std::ofstream out("Result.txt")
void checkArguments(const string &name, int nargout, int nargin, int expected)
Definition: matlab.h:113
void gtsamValues_insert_30(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns2ClassC_deconstructor_19(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns2ClassA_constructor_8(int nargout, mxArray *out[], int nargin, const mxArray *in[])
iterator iter(handle obj)
Definition: pytypes.h:2273
void ns2ClassC_constructor_18(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void overloadedGlobalFunction_21(int nargout, mxArray *out[], int nargin, const mxArray *in[])
size_t unwrap< size_t >(const mxArray *array)
Definition: matlab.h:335
Definition: cast.h:1238
void gtsamValues_deconstructor_29(int nargout, mxArray *out[], int nargin, const mxArray *in[])
static Collector_ClassD collector_ClassD
void ns2ClassA_deconstructor_9(int nargout, mxArray *out[], int nargin, const mxArray *in[])
std::set< std::shared_ptr< ns2::ns3::ClassB > * > Collector_ns2ns3ClassB
std::set< std::shared_ptr< gtsam::Values > * > Collector_gtsamValues
static Collector_ns1ClassB collector_ns1ClassB
void ClassD_collectorInsertAndMakeBase_23(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns2ns3ClassB_deconstructor_16(int nargout, mxArray *out[], int nargin, const mxArray *in[])
std::set< std::shared_ptr< ns1::ClassB > * > Collector_ns1ClassB
void gtsamValues_constructor_27(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns1ClassB_collectorInsertAndMakeBase_3(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void aGlobalFunction_20(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void gtsamValues_insert_31(int nargout, mxArray *out[], int nargin, const mxArray *in[])
double unwrap< double >(const mxArray *array)
Definition: matlab.h:342
void ns2ClassC_collectorInsertAndMakeBase_17(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void overloadedGlobalFunction_22(int nargout, mxArray *out[], int nargin, const mxArray *in[])
static Collector_ns1ClassA collector_ns1ClassA
Array< double, 1, 3 > e(1./3., 0.5, 2.)
void ns1ClassB_constructor_4(int nargout, mxArray *out[], int nargin, const mxArray *in[])
std::set< std::shared_ptr< ClassD > * > Collector_ClassD
EIGEN_DEVICE_FUNC const Scalar & q
void gtsamValues_constructor_28(int nargout, mxArray *out[], int nargin, const mxArray *in[])
#define NULL
Definition: ccolamd.c:609
void ns2ClassA_collectorInsertAndMakeBase_7(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns2ns3ClassB_collectorInsertAndMakeBase_14(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void mexFunction(int nargout, mxArray *out[], int nargin, const mxArray *in[])
mxArray * wrap< int >(const int &value)
Definition: matlab.h:172
mxArray * wrap< double >(const double &value)
Definition: matlab.h:180
void ClassD_constructor_24(int nargout, mxArray *out[], int nargin, const mxArray *in[])
#define mxUINT32OR64_CLASS
Definition: matlab.h:58
void ns2ClassA_nsArg_11(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns1ClassA_constructor_1(int nargout, mxArray *out[], int nargin, const mxArray *in[])
static Collector_ns2ClassA collector_ns2ClassA
void ns1ClassA_deconstructor_2(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns1ClassB_deconstructor_5(int nargout, mxArray *out[], int nargin, const mxArray *in[])
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor > Matrix
std::set< std::shared_ptr< ns2::ClassA > * > Collector_ns2ClassA
std::set< std::shared_ptr< ns1::ClassA > * > Collector_ns1ClassA
Map< Matrix< T, Dynamic, Dynamic, ColMajor >, 0, OuterStride<> > matrix(T *data, int rows, int cols, int stride)
std::set< std::shared_ptr< ns2::ClassC > * > Collector_ns2ClassC
Eigen::Matrix< double, Eigen::Dynamic, 1 > Vector
void ns2ClassA_afunction_13(int nargout, mxArray *out[], int nargin, const mxArray *in[])
static Collector_ns2ClassC collector_ns2ClassC
Definition: matlab.h:95
static Collector_ns2ns3ClassB collector_ns2ns3ClassB
static Collector_gtsamValues collector_gtsamValues
std::ptrdiff_t j
void ns2ns3ClassB_constructor_15(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void aGlobalFunction_6(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns2ClassA_nsReturn_12(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void ns2ClassA_memberFunction_10(int nargout, mxArray *out[], int nargin, const mxArray *in[])
void _namespaces_RTTIRegister()


gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:34:56