Apollo 11.0
自动驾驶开放平台
宏定义 | 函数
py_parameter.cc 文件参考
#include "cyber/python/internal/py_parameter.h"
#include <set>
#include <string>
#include <Python.h>
#include "cyber/python/internal/py_cyber.h"
py_parameter.cc 的引用(Include)关系图:

浏览源代码.

宏定义

#define PYOBJECT_NULL_STRING   PyBytes_FromStringAndSize("", 0)
 
#define C_STR_TO_PY_BYTES(cstr)    PyBytes_FromStringAndSize(cstr.c_str(), cstr.size())
 

函数

template<typename T >
T PyObjectToPtr (PyObject *pyobj, const std::string &type_ptr)
 
PyObject * cyber_new_PyParameter_noparam (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyParameter (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyParameter_int (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyParameter_double (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyParameter_string (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_type_name (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_descriptor (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_name (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_debug_string (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_as_string (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_as_double (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_as_int64 (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyParameterClient (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyParameterClient (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_clt_set_parameter (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_clt_get_parameter (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_clt_get_parameter_list (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyParameterServer (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyParameterServer (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_srv_set_parameter (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_srv_get_parameter (PyObject *self, PyObject *args)
 
PyObject * cyber_PyParameter_srv_get_parameter_list (PyObject *self, PyObject *args)
 
PyMODINIT_FUNC PyInit__cyber_parameter_wrapper (void)
 Init function of this module
 

宏定义说明

◆ C_STR_TO_PY_BYTES

#define C_STR_TO_PY_BYTES (   cstr)     PyBytes_FromStringAndSize(cstr.c_str(), cstr.size())

在文件 py_parameter.cc 第 32 行定义.

35 {
36 T obj_ptr = (T)PyCapsule_GetPointer(pyobj, type_ptr.c_str());
37 if (obj_ptr == nullptr) {
38 AERROR << "PyObjectToPtr failed,type->" << type_ptr << "pyobj: " << pyobj;
39 }
40 return obj_ptr;
41}
42
43PyObject* cyber_new_PyParameter_noparam(PyObject* self, PyObject* args) {
44 PyParameter* pyparameter = new PyParameter();
45 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
46}
47
48PyObject* cyber_delete_PyParameter(PyObject* self, PyObject* args) {
49 PyObject* pyobj_param = nullptr;
50 if (!PyArg_ParseTuple(args, const_cast<char*>("O:cyber_delete_PyParameter"),
51 &pyobj_param)) {
52 Py_INCREF(Py_None);
53 return Py_None;
54 }
55
56 auto* pyparameter = reinterpret_cast<PyParameter*>(
57 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
58 if (nullptr == pyparameter) {
59 AERROR << "cyber_delete_PyParameter:parameter ptr is null!";
60 Py_INCREF(Py_None);
61 return Py_None;
62 }
63 delete pyparameter;
64 Py_INCREF(Py_None);
65 return Py_None;
66}
67
68PyObject* cyber_new_PyParameter_int(PyObject* self, PyObject* args) {
69 char* name = nullptr;
70 Py_ssize_t len = 0;
71 int64_t int_value = 0;
72 if (!PyArg_ParseTuple(args,
73 const_cast<char*>("s#L:cyber_new_PyParameter_int"),
74 &name, &len, &int_value)) {
75 AERROR << "cyber_new_PyParameter_int parsetuple failed!";
76 Py_INCREF(Py_None);
77 return Py_None;
78 }
79
80 PyParameter* pyparameter = new PyParameter(std::string(name, len), int_value);
81 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
82}
83
84PyObject* cyber_new_PyParameter_double(PyObject* self, PyObject* args) {
85 char* name = nullptr;
86 Py_ssize_t len = 0;
87 double double_value = 0;
88 if (!PyArg_ParseTuple(args,
89 const_cast<char*>("s#d:cyber_new_PyParameter_double"),
90 &name, &len, &double_value)) {
91 AERROR << "cyber_new_PyParameter_double parsetuple failed!";
92 Py_INCREF(Py_None);
93 return Py_None;
94 }
95
96 PyParameter* pyparameter =
97 new PyParameter(std::string(name, len), double_value);
98 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
99}
100
101PyObject* cyber_new_PyParameter_string(PyObject* self, PyObject* args) {
102 char* name = nullptr;
103 char* string_param = nullptr;
104 if (!PyArg_ParseTuple(args,
105 const_cast<char*>("ss:cyber_new_PyParameter_string"),
106 &name, &string_param)) {
107 AERROR << "cyber_new_PyParameter_string parsetuple failed!";
108 Py_INCREF(Py_None);
109 return Py_None;
110 }
111
112 PyParameter* pyparameter =
113 new PyParameter(std::string(name), std::string(string_param));
114 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
115}
116
117PyObject* cyber_PyParameter_type_name(PyObject* self, PyObject* args) {
118 PyObject* pyobj_param = nullptr;
119 if (!PyArg_ParseTuple(args,
120 const_cast<char*>("O:cyber_PyParameter_type_name"),
121 &pyobj_param)) {
122 AERROR << "cyber_PyParameter_type_name failed!";
123 return PYOBJECT_NULL_STRING;
124 }
125
126 auto* param = reinterpret_cast<PyParameter*>(
127 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
128 if (nullptr == param) {
129 AERROR << "cyber_PyParameter_type_name ptr is null!";
130 return PYOBJECT_NULL_STRING;
131 }
132
133 const std::string type = param->type_name();
134 return C_STR_TO_PY_BYTES(type);
135}
136
137PyObject* cyber_PyParameter_descriptor(PyObject* self, PyObject* args) {
138 PyObject* pyobj_param = nullptr;
139 if (!PyArg_ParseTuple(args,
140 const_cast<char*>("O:cyber_PyParameter_descriptor"),
141 &pyobj_param)) {
142 AERROR << "cyber_PyParameter_descriptor failed!";
143 return PYOBJECT_NULL_STRING;
144 }
145
146 auto* param = reinterpret_cast<PyParameter*>(
147 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
148 if (nullptr == param) {
149 AERROR << "cyber_PyParameter_descriptor ptr is null!";
150 return PYOBJECT_NULL_STRING;
151 }
152
153 const std::string desc = param->descriptor();
154 return C_STR_TO_PY_BYTES(desc);
155}
156
157PyObject* cyber_PyParameter_name(PyObject* self, PyObject* args) {
158 PyObject* pyobj_param = nullptr;
159 if (!PyArg_ParseTuple(args, const_cast<char*>("O:cyber_PyParameter_name"),
160 &pyobj_param)) {
161 AERROR << "cyber_PyParameter_name failed!";
162 return PYOBJECT_NULL_STRING;
163 }
164
165 auto* param = reinterpret_cast<PyParameter*>(
166 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
167 if (nullptr == param) {
168 AERROR << "cyber_PyParameter_name ptr is null!";
169 return PYOBJECT_NULL_STRING;
170 }
171
172 const std::string name = param->name();
173 return C_STR_TO_PY_BYTES(name);
174}
175
176PyObject* cyber_PyParameter_debug_string(PyObject* self, PyObject* args) {
177 PyObject* pyobj_param = nullptr;
178 if (!PyArg_ParseTuple(args,
179 const_cast<char*>("O:cyber_PyParameter_debug_string"),
180 &pyobj_param)) {
181 AERROR << "cyber_PyParameter_debug_string failed!";
182 return PYOBJECT_NULL_STRING;
183 }
184
185 auto* param = reinterpret_cast<PyParameter*>(
186 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
187 if (nullptr == param) {
188 AERROR << "cyber_PyParameter_debug_string ptr is null!";
189 return PYOBJECT_NULL_STRING;
190 }
191
192 const std::string debug_string = param->debug_string();
193 return C_STR_TO_PY_BYTES(debug_string);
194}
195
196PyObject* cyber_PyParameter_as_string(PyObject* self, PyObject* args) {
197 PyObject* pyobj_param = nullptr;
198 if (!PyArg_ParseTuple(args,
199 const_cast<char*>("O:cyber_PyParameter_as_string"),
200 &pyobj_param)) {
201 AERROR << "cyber_PyParameter_as_string failed!";
202 return PYOBJECT_NULL_STRING;
203 }
204
205 auto* param = reinterpret_cast<PyParameter*>(
206 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
207 if (nullptr == param) {
208 AERROR << "cyber_PyParameter_as_string ptr is null!";
209 return PYOBJECT_NULL_STRING;
210 }
211
212 std::string debug_string = param->as_string();
213 return C_STR_TO_PY_BYTES(debug_string);
214}
215
216PyObject* cyber_PyParameter_as_double(PyObject* self, PyObject* args) {
217 PyObject* pyobj_param = nullptr;
218 if (!PyArg_ParseTuple(args,
219 const_cast<char*>("O:cyber_PyParameter_as_double"),
220 &pyobj_param)) {
221 AERROR << "cyber_PyParameter_as_double failed!";
222 return PyFloat_FromDouble(0.0);
223 }
224
225 auto* param = reinterpret_cast<PyParameter*>(
226 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
227 if (nullptr == param) {
228 AERROR << "cyber_PyParameter_as_double ptr is null!";
229 return PyFloat_FromDouble(0.0);
230 }
231
232 double dTemp = param->as_double();
233 return PyFloat_FromDouble(dTemp);
234}
235
236PyObject* cyber_PyParameter_as_int64(PyObject* self, PyObject* args) {
237 PyObject* pyobj_param = nullptr;
238 if (!PyArg_ParseTuple(args, const_cast<char*>("O:cyber_PyParameter_as_int64"),
239 &pyobj_param)) {
240 AERROR << "cyber_PyParameter_as_int64 failed!";
241 return PyLong_FromLongLong(0);
242 }
243
244 auto* param = reinterpret_cast<PyParameter*>(
245 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
246 if (nullptr == param) {
247 AERROR << "cyber_PyParameter_as_int64 ptr is null!";
248 return PyLong_FromLongLong(0);
249 }
250
251 int64_t lTemp = param->as_int64();
252 return PyLong_FromLongLong(lTemp);
253}
254
255// PyParameterClient
256PyObject* cyber_new_PyParameterClient(PyObject* self, PyObject* args) {
257 PyObject* pyobj_node = nullptr;
258 char* service_node_name = nullptr;
259 Py_ssize_t len = 0;
260 if (!PyArg_ParseTuple(args,
261 const_cast<char*>("Os#:cyber_new_PyParameterClient"),
262 &pyobj_node, &service_node_name, &len)) {
263 AERROR << "cyber_new_PyParameterClient parsetuple failed!";
264 Py_INCREF(Py_None);
265 return Py_None;
266 }
267
268 PyNode* pynode = PyObjectToPtr<PyNode*>(pyobj_node, "apollo_cyber_pynode");
269 if (nullptr == pynode) {
270 AERROR << "pynode ptr is null!";
271 Py_INCREF(Py_None);
272 return Py_None;
273 }
274
275 auto node = pynode->get_node();
276 if (nullptr == node) {
277 AERROR << "node ptr is null!";
278 Py_INCREF(Py_None);
279 return Py_None;
280 }
281
282 PyParameterClient* pyparameter_clt =
283 new PyParameterClient(node, std::string(service_node_name, len));
284 return PyCapsule_New(pyparameter_clt, "apollo_cybertron_pyparameterclient",
285 nullptr);
286}
287
288PyObject* cyber_delete_PyParameterClient(PyObject* self, PyObject* args) {
289 PyObject* pyobj_param = nullptr;
290 if (!PyArg_ParseTuple(args,
291 const_cast<char*>("O:cyber_delete_PyParameterClient"),
292 &pyobj_param)) {
293 AERROR << "cyber_delete_PyParameterClient parsetuple failed!";
294 Py_INCREF(Py_None);
295 return Py_None;
296 }
297
298 PyParameterClient* pyparameter_clt = reinterpret_cast<PyParameterClient*>(
299 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameterclient"));
300 if (nullptr == pyparameter_clt) {
301 AERROR << "cyber_delete_PyParameterClient:pyparameter_clt ptr is null!";
302 Py_INCREF(Py_None);
303 return Py_None;
304 }
305 delete pyparameter_clt;
306 Py_INCREF(Py_None);
307 return Py_None;
308}
309
310PyObject* cyber_PyParameter_clt_set_parameter(PyObject* self, PyObject* args) {
311 PyObject* pyobj_param_clt = nullptr;
312 PyObject* pyobj_param = nullptr;
313 if (!PyArg_ParseTuple(args,
314 const_cast<char*>("OO:cyber_PyParameter_set_parameter"),
315 &pyobj_param_clt, &pyobj_param)) {
316 AERROR << "cyber_PyParameter_set_parameter parsetuple failed!";
317 Py_RETURN_FALSE;
318 }
319
320 PyParameterClient* pyparam_clt = PyObjectToPtr<PyParameterClient*>(
321 pyobj_param_clt, "apollo_cybertron_pyparameterclient");
322 if (nullptr == pyparam_clt) {
323 AERROR << "pyparam_clt ptr is null!";
324 Py_RETURN_FALSE;
325 }
326
327 PyParameter* pyparam =
328 PyObjectToPtr<PyParameter*>(pyobj_param, "apollo_cybertron_pyparameter");
329 if (nullptr == pyparam) {
330 AERROR << "pyparam ptr is null!";
331 Py_RETURN_FALSE;
332 }
333
334 if (!pyparam_clt->set_parameter(pyparam->get_param())) {
335 Py_RETURN_FALSE;
336 } else {
337 Py_RETURN_TRUE;
338 }
339}
340
341PyObject* cyber_PyParameter_clt_get_parameter(PyObject* self, PyObject* args) {
342 char* name = nullptr;
343 Py_ssize_t len = 0;
344 PyObject* pyobj_param_clt = nullptr;
345 if (!PyArg_ParseTuple(
346 args, const_cast<char*>("Os#:cyber_PyParameter_get_parameter"),
347 &pyobj_param_clt, &name, &len)) {
348 AERROR << "cyber_PyParameter_get_parameter parsetuple failed!";
349 Py_INCREF(Py_None);
350 return Py_None;
351 }
352 PyParameterClient* pyparam_clt = PyObjectToPtr<PyParameterClient*>(
353 pyobj_param_clt, "apollo_cybertron_pyparameterclient");
354 if (nullptr == pyparam_clt) {
355 AERROR << "pyparam_clt ptr is null!";
356 Py_INCREF(Py_None);
357 return Py_None;
358 }
359
360 Parameter* param = new Parameter();
361 std::string str_param = std::string(name, len);
362 if (!pyparam_clt->get_parameter(str_param, param)) {
363 AERROR << "pyparam_clt get_parameter is false!";
364 Py_INCREF(Py_None);
365 return Py_None;
366 }
367
368 PyParameter* pyparameter = new PyParameter(param);
369 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
370}
371
372PyObject* cyber_PyParameter_clt_get_parameter_list(PyObject* self,
373 PyObject* args) {
374 PyObject* pyobj_param_clt = nullptr;
375 if (!PyArg_ParseTuple(
376 args, const_cast<char*>("O:cyber_PyParameter_clt_get_parameter_list"),
377 &pyobj_param_clt)) {
378 AERROR
379 << "cyber_PyParameter_clt_get_parameter_list:PyArg_ParseTuple failed!";
380 Py_INCREF(Py_None);
381 return Py_None;
382 }
383
384 auto* pyparam_clt = reinterpret_cast<PyParameterClient*>(PyCapsule_GetPointer(
385 pyobj_param_clt, "apollo_cybertron_pyparameterclient"));
386 if (nullptr == pyparam_clt) {
387 AERROR << "cyber_PyParameter_clt_get_parameter_list pyparam_clt is null!";
388 Py_INCREF(Py_None);
389 return Py_None;
390 }
391
392 std::vector<Parameter> param_list;
393 pyparam_clt->list_parameters(&param_list);
394
395 PyObject* pyobj_list = PyList_New(param_list.size());
396 size_t pos = 0;
397 for (auto& param : param_list) {
398 Parameter* param_ptr = new Parameter(param);
399 PyParameter* pyparameter = new PyParameter(param_ptr);
400 PyObject* pyobj_param =
401 PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
402 PyList_SetItem(pyobj_list, pos, pyobj_param);
403 pos++;
404 }
405
406 return pyobj_list;
407}
408
409// PyParameterServer
410PyObject* cyber_new_PyParameterServer(PyObject* self, PyObject* args) {
411 PyObject* pyobj_node = nullptr;
412 if (!PyArg_ParseTuple(args,
413 const_cast<char*>("O:cyber_new_PyParameterServer"),
414 &pyobj_node)) {
415 AERROR << "cyber_new_PyParameterServer parsetuple failed!";
416 Py_INCREF(Py_None);
417 return Py_None;
418 }
419
420 PyNode* pynode = PyObjectToPtr<PyNode*>(pyobj_node, "apollo_cyber_pynode");
421 if (nullptr == pynode) {
422 AERROR << "pynode ptr is null!";
423 Py_INCREF(Py_None);
424 return Py_None;
425 }
426
427 auto node = pynode->get_node();
428 if (nullptr == node) {
429 AERROR << "node ptr is null!";
430 Py_INCREF(Py_None);
431 return Py_None;
432 }
433
434 PyParameterServer* pyparameter_srv = new PyParameterServer(node);
435 return PyCapsule_New(pyparameter_srv, "apollo_cybertron_pyparameterserver",
436 nullptr);
437}
438
439PyObject* cyber_delete_PyParameterServer(PyObject* self, PyObject* args) {
440 PyObject* pyobj_param = nullptr;
441 if (!PyArg_ParseTuple(args,
442 const_cast<char*>("O:cyber_delete_PyParameterServer"),
443 &pyobj_param)) {
444 AERROR << "cyber_delete_PyParameterServer parsetuple failed!";
445 Py_INCREF(Py_None);
446 return Py_None;
447 }
448
449 PyParameterServer* pyparameter_srv = reinterpret_cast<PyParameterServer*>(
450 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameterserver"));
451 if (nullptr == pyparameter_srv) {
452 AERROR << "cyber_delete_PyParameterServer:pyparameter_srv ptr is null!";
453 Py_INCREF(Py_None);
454 return Py_None;
455 }
456 delete pyparameter_srv;
457 Py_INCREF(Py_None);
458 return Py_None;
459}
460
461PyObject* cyber_PyParameter_srv_set_parameter(PyObject* self, PyObject* args) {
462 PyObject* pyobj_param_srv = nullptr;
463 PyObject* pyobj_param = nullptr;
464 if (!PyArg_ParseTuple(args,
465 const_cast<char*>("OO:cyber_PyParameter_set_parameter"),
466 &pyobj_param_srv, &pyobj_param)) {
467 AERROR << "cyber_PyParameter_set_parameter parsetuple failed!";
468 Py_INCREF(Py_None);
469 return Py_None;
470 }
471
472 PyParameterServer* pyparam_srv = PyObjectToPtr<PyParameterServer*>(
473 pyobj_param_srv, "apollo_cybertron_pyparameterserver");
474 if (nullptr == pyparam_srv) {
475 AERROR << "pyparam_srv ptr is null!";
476 Py_INCREF(Py_None);
477 return Py_None;
478 }
479
480 PyParameter* pyparam =
481 PyObjectToPtr<PyParameter*>(pyobj_param, "apollo_cybertron_pyparameter");
482 if (nullptr == pyparam) {
483 AERROR << "pyparam ptr is null!";
484 Py_INCREF(Py_None);
485 return Py_None;
486 }
487
488 pyparam_srv->set_parameter(pyparam->get_param());
489 Py_INCREF(Py_None);
490 return Py_None;
491}
492
493PyObject* cyber_PyParameter_srv_get_parameter(PyObject* self, PyObject* args) {
494 char* name = nullptr;
495 Py_ssize_t len = 0;
496 PyObject* pyobj_param_srv = nullptr;
497 if (!PyArg_ParseTuple(
498 args, const_cast<char*>("Os#:cyber_PyParameter_get_parameter"),
499 &pyobj_param_srv, &name, &len)) {
500 AERROR << "cyber_PyParameter_get_parameter parsetuple failed!";
501 Py_INCREF(Py_None);
502 return Py_None;
503 }
504 PyParameterServer* pyparam_srv = PyObjectToPtr<PyParameterServer*>(
505 pyobj_param_srv, "apollo_cybertron_pyparameterserver");
506 if (nullptr == pyparam_srv) {
507 AERROR << "pyparam_srv ptr is null!";
508 Py_INCREF(Py_None);
509 return Py_None;
510 }
511
512 Parameter* param = new Parameter();
513 std::string str_param = std::string(name, len);
514 if (!pyparam_srv->get_parameter(str_param, param)) {
515 AERROR << "pyparam_srv get_parameter is false!";
516 Py_INCREF(Py_None);
517 return Py_None;
518 }
519
520 PyParameter* pyparameter = new PyParameter(param);
521 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
522}
523
524PyObject* cyber_PyParameter_srv_get_parameter_list(PyObject* self,
525 PyObject* args) {
526 PyObject* pyobj_param_srv = nullptr;
527 if (!PyArg_ParseTuple(
528 args, const_cast<char*>("O:cyber_PyParameter_srv_get_parameter_list"),
529 &pyobj_param_srv)) {
530 AERROR
531 << "cyber_PyParameter_srv_get_parameter_list:PyArg_ParseTuple failed!";
532 Py_INCREF(Py_None);
533 return Py_None;
534 }
535
536 auto* pyparam_srv = reinterpret_cast<PyParameterServer*>(PyCapsule_GetPointer(
537 pyobj_param_srv, "apollo_cybertron_pyparameterserver"));
538 if (nullptr == pyparam_srv) {
539 AERROR << "cyber_PyParameter_srv_get_parameter_list pyparam_srv is null!";
540 Py_INCREF(Py_None);
541 return Py_None;
542 }
543
544 std::vector<Parameter> param_list;
545 pyparam_srv->list_parameters(&param_list);
546
547 PyObject* pyobj_list = PyList_New(param_list.size());
548 size_t pos = 0;
549 for (auto& param : param_list) {
550 Parameter* param_ptr = new Parameter(param);
551 PyParameter* pyparameter = new PyParameter(param_ptr);
552 PyObject* pyobj_param =
553 PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
554 PyList_SetItem(pyobj_list, pos, pyobj_param);
555 pos++;
556 }
557
558 return pyobj_list;
559}
560
561static PyMethodDef _cyber_parameter_methods[] = {
562 {"new_PyParameter_noparam", cyber_new_PyParameter_noparam, METH_NOARGS, ""},
563 {"delete_PyParameter", cyber_delete_PyParameter, METH_VARARGS, ""},
564 {"new_PyParameter_int", cyber_new_PyParameter_int, METH_VARARGS, ""},
565 {"new_PyParameter_double", cyber_new_PyParameter_double, METH_VARARGS, ""},
566 {"new_PyParameter_string", cyber_new_PyParameter_string, METH_VARARGS, ""},
567 {"PyParameter_type_name", cyber_PyParameter_type_name, METH_VARARGS, ""},
568 {"PyParameter_descriptor", cyber_PyParameter_descriptor, METH_VARARGS, ""},
569 {"PyParameter_name", cyber_PyParameter_name, METH_VARARGS, ""},
570 {"PyParameter_debug_string", cyber_PyParameter_debug_string, METH_VARARGS,
571 ""},
572 {"PyParameter_as_string", cyber_PyParameter_as_string, METH_VARARGS, ""},
573 {"PyParameter_as_double", cyber_PyParameter_as_double, METH_VARARGS, ""},
574 {"PyParameter_as_int64", cyber_PyParameter_as_int64, METH_VARARGS, ""},
575
576 {"new_PyParameterClient", cyber_new_PyParameterClient, METH_VARARGS, ""},
577 {"delete_PyParameterClient", cyber_delete_PyParameterClient, METH_VARARGS,
578 ""},
579 {"PyParameter_clt_set_parameter", cyber_PyParameter_clt_set_parameter,
580 METH_VARARGS, ""},
581 {"PyParameter_clt_get_parameter", cyber_PyParameter_clt_get_parameter,
582 METH_VARARGS, ""},
583 {"PyParameter_clt_get_parameter_list",
584 cyber_PyParameter_clt_get_parameter_list, METH_VARARGS, ""},
585
586 {"new_PyParameterServer", cyber_new_PyParameterServer, METH_VARARGS, ""},
587 {"delete_PyParameterServer", cyber_delete_PyParameterServer, METH_VARARGS,
588 ""},
589 {"PyParameter_srv_set_parameter", cyber_PyParameter_srv_set_parameter,
590 METH_VARARGS, ""},
591 {"PyParameter_srv_get_parameter", cyber_PyParameter_srv_get_parameter,
592 METH_VARARGS, ""},
593 {"PyParameter_srv_get_parameter_list",
594 cyber_PyParameter_srv_get_parameter_list, METH_VARARGS, ""},
595
596 {nullptr, nullptr, 0, nullptr} /* sentinel */
597};
598
600PyMODINIT_FUNC PyInit__cyber_parameter_wrapper(void) {
601 static struct PyModuleDef module_def = {
602 PyModuleDef_HEAD_INIT,
603 "_cyber_parameter_wrapper", // Module name.
604 "CyberParameter module", // Module doc.
605 -1, // Module size.
606 _cyber_parameter_methods, // Module methods.
607 nullptr,
608 nullptr,
609 nullptr,
610 nullptr,
611 };
612
613 return PyModule_Create(&module_def);
614}
apollo::cyber::Parameter
A Parameter holds an apollo::cyber::proto::Param, It's more human-readable, you can use basic-value t...
Definition parameter.h:42
apollo::cyber::PyNode::get_node
std::shared_ptr< Node > get_node()
Definition py_cyber.h:331
apollo::cyber::PyParameterClient::list_parameters
bool list_parameters(std::vector< Parameter > *parameters)
Definition py_parameter.h:81
apollo::cyber::PyParameterClient::set_parameter
bool set_parameter(const Parameter &parameter)
Definition py_parameter.h:75
apollo::cyber::PyParameterClient::get_parameter
bool get_parameter(const std::string &param_name, Parameter *parameter)
Definition py_parameter.h:78
apollo::cyber::PyParameterServer::get_parameter
bool get_parameter(const std::string &param_name, Parameter *parameter)
Definition py_parameter.h:97
apollo::cyber::PyParameterServer::list_parameters
void list_parameters(std::vector< Parameter > *parameters)
Definition py_parameter.h:100
apollo::cyber::PyParameterServer::set_parameter
void set_parameter(const Parameter &parameter)
Definition py_parameter.h:94
AERROR
#define AERROR
Definition log.h:44
cyber_PyParameter_as_int64
PyObject * cyber_PyParameter_as_int64(PyObject *self, PyObject *args)
Definition py_parameter.cc:237
cyber_new_PyParameter_double
PyObject * cyber_new_PyParameter_double(PyObject *self, PyObject *args)
Definition py_parameter.cc:85
cyber_delete_PyParameterServer
PyObject * cyber_delete_PyParameterServer(PyObject *self, PyObject *args)
Definition py_parameter.cc:440
cyber_delete_PyParameter
PyObject * cyber_delete_PyParameter(PyObject *self, PyObject *args)
Definition py_parameter.cc:49
cyber_PyParameter_as_string
PyObject * cyber_PyParameter_as_string(PyObject *self, PyObject *args)
Definition py_parameter.cc:197
cyber_PyParameter_clt_get_parameter_list
PyObject * cyber_PyParameter_clt_get_parameter_list(PyObject *self, PyObject *args)
Definition py_parameter.cc:373
PYOBJECT_NULL_STRING
#define PYOBJECT_NULL_STRING
Definition py_parameter.cc:31
cyber_PyParameter_name
PyObject * cyber_PyParameter_name(PyObject *self, PyObject *args)
Definition py_parameter.cc:158
cyber_delete_PyParameterClient
PyObject * cyber_delete_PyParameterClient(PyObject *self, PyObject *args)
Definition py_parameter.cc:289
cyber_PyParameter_as_double
PyObject * cyber_PyParameter_as_double(PyObject *self, PyObject *args)
Definition py_parameter.cc:217
PyInit__cyber_parameter_wrapper
PyMODINIT_FUNC PyInit__cyber_parameter_wrapper(void)
Init function of this module
Definition py_parameter.cc:601
cyber_new_PyParameterClient
PyObject * cyber_new_PyParameterClient(PyObject *self, PyObject *args)
Definition py_parameter.cc:257
cyber_new_PyParameter_string
PyObject * cyber_new_PyParameter_string(PyObject *self, PyObject *args)
Definition py_parameter.cc:102
cyber_PyParameter_debug_string
PyObject * cyber_PyParameter_debug_string(PyObject *self, PyObject *args)
Definition py_parameter.cc:177
cyber_PyParameter_srv_get_parameter_list
PyObject * cyber_PyParameter_srv_get_parameter_list(PyObject *self, PyObject *args)
Definition py_parameter.cc:525
C_STR_TO_PY_BYTES
#define C_STR_TO_PY_BYTES(cstr)
Definition py_parameter.cc:32
cyber_PyParameter_type_name
PyObject * cyber_PyParameter_type_name(PyObject *self, PyObject *args)
Definition py_parameter.cc:118
cyber_PyParameter_clt_set_parameter
PyObject * cyber_PyParameter_clt_set_parameter(PyObject *self, PyObject *args)
Definition py_parameter.cc:311
cyber_PyParameter_srv_get_parameter
PyObject * cyber_PyParameter_srv_get_parameter(PyObject *self, PyObject *args)
Definition py_parameter.cc:494
cyber_PyParameter_srv_set_parameter
PyObject * cyber_PyParameter_srv_set_parameter(PyObject *self, PyObject *args)
Definition py_parameter.cc:462
cyber_PyParameter_descriptor
PyObject * cyber_PyParameter_descriptor(PyObject *self, PyObject *args)
Definition py_parameter.cc:138
cyber_PyParameter_clt_get_parameter
PyObject * cyber_PyParameter_clt_get_parameter(PyObject *self, PyObject *args)
Definition py_parameter.cc:342
cyber_new_PyParameter_noparam
PyObject * cyber_new_PyParameter_noparam(PyObject *self, PyObject *args)
Definition py_parameter.cc:44
cyber_new_PyParameter_int
PyObject * cyber_new_PyParameter_int(PyObject *self, PyObject *args)
Definition py_parameter.cc:69
cyber_new_PyParameterServer
PyObject * cyber_new_PyParameterServer(PyObject *self, PyObject *args)
Definition py_parameter.cc:411

◆ PYOBJECT_NULL_STRING

#define PYOBJECT_NULL_STRING   PyBytes_FromStringAndSize("", 0)

在文件 py_parameter.cc 第 31 行定义.

函数说明

◆ cyber_delete_PyParameter()

PyObject * cyber_delete_PyParameter ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 49 行定义.

49 {
50 PyObject* pyobj_param = nullptr;
51 if (!PyArg_ParseTuple(args, const_cast<char*>("O:cyber_delete_PyParameter"),
52 &pyobj_param)) {
53 Py_INCREF(Py_None);
54 return Py_None;
55 }
56
57 auto* pyparameter = reinterpret_cast<PyParameter*>(
58 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
59 if (nullptr == pyparameter) {
60 AERROR << "cyber_delete_PyParameter:parameter ptr is null!";
61 Py_INCREF(Py_None);
62 return Py_None;
63 }
64 delete pyparameter;
65 Py_INCREF(Py_None);
66 return Py_None;
67}

◆ cyber_delete_PyParameterClient()

PyObject * cyber_delete_PyParameterClient ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 289 行定义.

289 {
290 PyObject* pyobj_param = nullptr;
291 if (!PyArg_ParseTuple(args,
292 const_cast<char*>("O:cyber_delete_PyParameterClient"),
293 &pyobj_param)) {
294 AERROR << "cyber_delete_PyParameterClient parsetuple failed!";
295 Py_INCREF(Py_None);
296 return Py_None;
297 }
298
299 PyParameterClient* pyparameter_clt = reinterpret_cast<PyParameterClient*>(
300 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameterclient"));
301 if (nullptr == pyparameter_clt) {
302 AERROR << "cyber_delete_PyParameterClient:pyparameter_clt ptr is null!";
303 Py_INCREF(Py_None);
304 return Py_None;
305 }
306 delete pyparameter_clt;
307 Py_INCREF(Py_None);
308 return Py_None;
309}

◆ cyber_delete_PyParameterServer()

PyObject * cyber_delete_PyParameterServer ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 440 行定义.

440 {
441 PyObject* pyobj_param = nullptr;
442 if (!PyArg_ParseTuple(args,
443 const_cast<char*>("O:cyber_delete_PyParameterServer"),
444 &pyobj_param)) {
445 AERROR << "cyber_delete_PyParameterServer parsetuple failed!";
446 Py_INCREF(Py_None);
447 return Py_None;
448 }
449
450 PyParameterServer* pyparameter_srv = reinterpret_cast<PyParameterServer*>(
451 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameterserver"));
452 if (nullptr == pyparameter_srv) {
453 AERROR << "cyber_delete_PyParameterServer:pyparameter_srv ptr is null!";
454 Py_INCREF(Py_None);
455 return Py_None;
456 }
457 delete pyparameter_srv;
458 Py_INCREF(Py_None);
459 return Py_None;
460}

◆ cyber_new_PyParameter_double()

PyObject * cyber_new_PyParameter_double ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 85 行定义.

85 {
86 char* name = nullptr;
87 Py_ssize_t len = 0;
88 double double_value = 0;
89 if (!PyArg_ParseTuple(args,
90 const_cast<char*>("s#d:cyber_new_PyParameter_double"),
91 &name, &len, &double_value)) {
92 AERROR << "cyber_new_PyParameter_double parsetuple failed!";
93 Py_INCREF(Py_None);
94 return Py_None;
95 }
96
97 PyParameter* pyparameter =
98 new PyParameter(std::string(name, len), double_value);
99 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
100}

◆ cyber_new_PyParameter_int()

PyObject * cyber_new_PyParameter_int ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 69 行定义.

69 {
70 char* name = nullptr;
71 Py_ssize_t len = 0;
72 int64_t int_value = 0;
73 if (!PyArg_ParseTuple(args,
74 const_cast<char*>("s#L:cyber_new_PyParameter_int"),
75 &name, &len, &int_value)) {
76 AERROR << "cyber_new_PyParameter_int parsetuple failed!";
77 Py_INCREF(Py_None);
78 return Py_None;
79 }
80
81 PyParameter* pyparameter = new PyParameter(std::string(name, len), int_value);
82 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
83}

◆ cyber_new_PyParameter_noparam()

PyObject * cyber_new_PyParameter_noparam ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 44 行定义.

44 {
45 PyParameter* pyparameter = new PyParameter();
46 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
47}

◆ cyber_new_PyParameter_string()

PyObject * cyber_new_PyParameter_string ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 102 行定义.

102 {
103 char* name = nullptr;
104 char* string_param = nullptr;
105 if (!PyArg_ParseTuple(args,
106 const_cast<char*>("ss:cyber_new_PyParameter_string"),
107 &name, &string_param)) {
108 AERROR << "cyber_new_PyParameter_string parsetuple failed!";
109 Py_INCREF(Py_None);
110 return Py_None;
111 }
112
113 PyParameter* pyparameter =
114 new PyParameter(std::string(name), std::string(string_param));
115 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
116}

◆ cyber_new_PyParameterClient()

PyObject * cyber_new_PyParameterClient ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 257 行定义.

257 {
258 PyObject* pyobj_node = nullptr;
259 char* service_node_name = nullptr;
260 Py_ssize_t len = 0;
261 if (!PyArg_ParseTuple(args,
262 const_cast<char*>("Os#:cyber_new_PyParameterClient"),
263 &pyobj_node, &service_node_name, &len)) {
264 AERROR << "cyber_new_PyParameterClient parsetuple failed!";
265 Py_INCREF(Py_None);
266 return Py_None;
267 }
268
269 PyNode* pynode = PyObjectToPtr<PyNode*>(pyobj_node, "apollo_cyber_pynode");
270 if (nullptr == pynode) {
271 AERROR << "pynode ptr is null!";
272 Py_INCREF(Py_None);
273 return Py_None;
274 }
275
276 auto node = pynode->get_node();
277 if (nullptr == node) {
278 AERROR << "node ptr is null!";
279 Py_INCREF(Py_None);
280 return Py_None;
281 }
282
283 PyParameterClient* pyparameter_clt =
284 new PyParameterClient(node, std::string(service_node_name, len));
285 return PyCapsule_New(pyparameter_clt, "apollo_cybertron_pyparameterclient",
286 nullptr);
287}

◆ cyber_new_PyParameterServer()

PyObject * cyber_new_PyParameterServer ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 411 行定义.

411 {
412 PyObject* pyobj_node = nullptr;
413 if (!PyArg_ParseTuple(args,
414 const_cast<char*>("O:cyber_new_PyParameterServer"),
415 &pyobj_node)) {
416 AERROR << "cyber_new_PyParameterServer parsetuple failed!";
417 Py_INCREF(Py_None);
418 return Py_None;
419 }
420
421 PyNode* pynode = PyObjectToPtr<PyNode*>(pyobj_node, "apollo_cyber_pynode");
422 if (nullptr == pynode) {
423 AERROR << "pynode ptr is null!";
424 Py_INCREF(Py_None);
425 return Py_None;
426 }
427
428 auto node = pynode->get_node();
429 if (nullptr == node) {
430 AERROR << "node ptr is null!";
431 Py_INCREF(Py_None);
432 return Py_None;
433 }
434
435 PyParameterServer* pyparameter_srv = new PyParameterServer(node);
436 return PyCapsule_New(pyparameter_srv, "apollo_cybertron_pyparameterserver",
437 nullptr);
438}

◆ cyber_PyParameter_as_double()

PyObject * cyber_PyParameter_as_double ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 217 行定义.

217 {
218 PyObject* pyobj_param = nullptr;
219 if (!PyArg_ParseTuple(args,
220 const_cast<char*>("O:cyber_PyParameter_as_double"),
221 &pyobj_param)) {
222 AERROR << "cyber_PyParameter_as_double failed!";
223 return PyFloat_FromDouble(0.0);
224 }
225
226 auto* param = reinterpret_cast<PyParameter*>(
227 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
228 if (nullptr == param) {
229 AERROR << "cyber_PyParameter_as_double ptr is null!";
230 return PyFloat_FromDouble(0.0);
231 }
232
233 double dTemp = param->as_double();
234 return PyFloat_FromDouble(dTemp);
235}

◆ cyber_PyParameter_as_int64()

PyObject * cyber_PyParameter_as_int64 ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 237 行定义.

237 {
238 PyObject* pyobj_param = nullptr;
239 if (!PyArg_ParseTuple(args, const_cast<char*>("O:cyber_PyParameter_as_int64"),
240 &pyobj_param)) {
241 AERROR << "cyber_PyParameter_as_int64 failed!";
242 return PyLong_FromLongLong(0);
243 }
244
245 auto* param = reinterpret_cast<PyParameter*>(
246 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
247 if (nullptr == param) {
248 AERROR << "cyber_PyParameter_as_int64 ptr is null!";
249 return PyLong_FromLongLong(0);
250 }
251
252 int64_t lTemp = param->as_int64();
253 return PyLong_FromLongLong(lTemp);
254}

◆ cyber_PyParameter_as_string()

PyObject * cyber_PyParameter_as_string ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 197 行定义.

197 {
198 PyObject* pyobj_param = nullptr;
199 if (!PyArg_ParseTuple(args,
200 const_cast<char*>("O:cyber_PyParameter_as_string"),
201 &pyobj_param)) {
202 AERROR << "cyber_PyParameter_as_string failed!";
203 return PYOBJECT_NULL_STRING;
204 }
205
206 auto* param = reinterpret_cast<PyParameter*>(
207 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
208 if (nullptr == param) {
209 AERROR << "cyber_PyParameter_as_string ptr is null!";
210 return PYOBJECT_NULL_STRING;
211 }
212
213 std::string debug_string = param->as_string();
214 return C_STR_TO_PY_BYTES(debug_string);
215}

◆ cyber_PyParameter_clt_get_parameter()

PyObject * cyber_PyParameter_clt_get_parameter ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 342 行定义.

342 {
343 char* name = nullptr;
344 Py_ssize_t len = 0;
345 PyObject* pyobj_param_clt = nullptr;
346 if (!PyArg_ParseTuple(
347 args, const_cast<char*>("Os#:cyber_PyParameter_get_parameter"),
348 &pyobj_param_clt, &name, &len)) {
349 AERROR << "cyber_PyParameter_get_parameter parsetuple failed!";
350 Py_INCREF(Py_None);
351 return Py_None;
352 }
353 PyParameterClient* pyparam_clt = PyObjectToPtr<PyParameterClient*>(
354 pyobj_param_clt, "apollo_cybertron_pyparameterclient");
355 if (nullptr == pyparam_clt) {
356 AERROR << "pyparam_clt ptr is null!";
357 Py_INCREF(Py_None);
358 return Py_None;
359 }
360
361 Parameter* param = new Parameter();
362 std::string str_param = std::string(name, len);
363 if (!pyparam_clt->get_parameter(str_param, param)) {
364 AERROR << "pyparam_clt get_parameter is false!";
365 Py_INCREF(Py_None);
366 return Py_None;
367 }
368
369 PyParameter* pyparameter = new PyParameter(param);
370 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
371}

◆ cyber_PyParameter_clt_get_parameter_list()

PyObject * cyber_PyParameter_clt_get_parameter_list ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 373 行定义.

374 {
375 PyObject* pyobj_param_clt = nullptr;
376 if (!PyArg_ParseTuple(
377 args, const_cast<char*>("O:cyber_PyParameter_clt_get_parameter_list"),
378 &pyobj_param_clt)) {
379 AERROR
380 << "cyber_PyParameter_clt_get_parameter_list:PyArg_ParseTuple failed!";
381 Py_INCREF(Py_None);
382 return Py_None;
383 }
384
385 auto* pyparam_clt = reinterpret_cast<PyParameterClient*>(PyCapsule_GetPointer(
386 pyobj_param_clt, "apollo_cybertron_pyparameterclient"));
387 if (nullptr == pyparam_clt) {
388 AERROR << "cyber_PyParameter_clt_get_parameter_list pyparam_clt is null!";
389 Py_INCREF(Py_None);
390 return Py_None;
391 }
392
393 std::vector<Parameter> param_list;
394 pyparam_clt->list_parameters(&param_list);
395
396 PyObject* pyobj_list = PyList_New(param_list.size());
397 size_t pos = 0;
398 for (auto& param : param_list) {
399 Parameter* param_ptr = new Parameter(param);
400 PyParameter* pyparameter = new PyParameter(param_ptr);
401 PyObject* pyobj_param =
402 PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
403 PyList_SetItem(pyobj_list, pos, pyobj_param);
404 pos++;
405 }
406
407 return pyobj_list;
408}

◆ cyber_PyParameter_clt_set_parameter()

PyObject * cyber_PyParameter_clt_set_parameter ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 311 行定义.

311 {
312 PyObject* pyobj_param_clt = nullptr;
313 PyObject* pyobj_param = nullptr;
314 if (!PyArg_ParseTuple(args,
315 const_cast<char*>("OO:cyber_PyParameter_set_parameter"),
316 &pyobj_param_clt, &pyobj_param)) {
317 AERROR << "cyber_PyParameter_set_parameter parsetuple failed!";
318 Py_RETURN_FALSE;
319 }
320
321 PyParameterClient* pyparam_clt = PyObjectToPtr<PyParameterClient*>(
322 pyobj_param_clt, "apollo_cybertron_pyparameterclient");
323 if (nullptr == pyparam_clt) {
324 AERROR << "pyparam_clt ptr is null!";
325 Py_RETURN_FALSE;
326 }
327
328 PyParameter* pyparam =
329 PyObjectToPtr<PyParameter*>(pyobj_param, "apollo_cybertron_pyparameter");
330 if (nullptr == pyparam) {
331 AERROR << "pyparam ptr is null!";
332 Py_RETURN_FALSE;
333 }
334
335 if (!pyparam_clt->set_parameter(pyparam->get_param())) {
336 Py_RETURN_FALSE;
337 } else {
338 Py_RETURN_TRUE;
339 }
340}

◆ cyber_PyParameter_debug_string()

PyObject * cyber_PyParameter_debug_string ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 177 行定义.

177 {
178 PyObject* pyobj_param = nullptr;
179 if (!PyArg_ParseTuple(args,
180 const_cast<char*>("O:cyber_PyParameter_debug_string"),
181 &pyobj_param)) {
182 AERROR << "cyber_PyParameter_debug_string failed!";
183 return PYOBJECT_NULL_STRING;
184 }
185
186 auto* param = reinterpret_cast<PyParameter*>(
187 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
188 if (nullptr == param) {
189 AERROR << "cyber_PyParameter_debug_string ptr is null!";
190 return PYOBJECT_NULL_STRING;
191 }
192
193 const std::string debug_string = param->debug_string();
194 return C_STR_TO_PY_BYTES(debug_string);
195}

◆ cyber_PyParameter_descriptor()

PyObject * cyber_PyParameter_descriptor ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 138 行定义.

138 {
139 PyObject* pyobj_param = nullptr;
140 if (!PyArg_ParseTuple(args,
141 const_cast<char*>("O:cyber_PyParameter_descriptor"),
142 &pyobj_param)) {
143 AERROR << "cyber_PyParameter_descriptor failed!";
144 return PYOBJECT_NULL_STRING;
145 }
146
147 auto* param = reinterpret_cast<PyParameter*>(
148 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
149 if (nullptr == param) {
150 AERROR << "cyber_PyParameter_descriptor ptr is null!";
151 return PYOBJECT_NULL_STRING;
152 }
153
154 const std::string desc = param->descriptor();
155 return C_STR_TO_PY_BYTES(desc);
156}

◆ cyber_PyParameter_name()

PyObject * cyber_PyParameter_name ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 158 行定义.

158 {
159 PyObject* pyobj_param = nullptr;
160 if (!PyArg_ParseTuple(args, const_cast<char*>("O:cyber_PyParameter_name"),
161 &pyobj_param)) {
162 AERROR << "cyber_PyParameter_name failed!";
163 return PYOBJECT_NULL_STRING;
164 }
165
166 auto* param = reinterpret_cast<PyParameter*>(
167 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
168 if (nullptr == param) {
169 AERROR << "cyber_PyParameter_name ptr is null!";
170 return PYOBJECT_NULL_STRING;
171 }
172
173 const std::string name = param->name();
174 return C_STR_TO_PY_BYTES(name);
175}

◆ cyber_PyParameter_srv_get_parameter()

PyObject * cyber_PyParameter_srv_get_parameter ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 494 行定义.

494 {
495 char* name = nullptr;
496 Py_ssize_t len = 0;
497 PyObject* pyobj_param_srv = nullptr;
498 if (!PyArg_ParseTuple(
499 args, const_cast<char*>("Os#:cyber_PyParameter_get_parameter"),
500 &pyobj_param_srv, &name, &len)) {
501 AERROR << "cyber_PyParameter_get_parameter parsetuple failed!";
502 Py_INCREF(Py_None);
503 return Py_None;
504 }
505 PyParameterServer* pyparam_srv = PyObjectToPtr<PyParameterServer*>(
506 pyobj_param_srv, "apollo_cybertron_pyparameterserver");
507 if (nullptr == pyparam_srv) {
508 AERROR << "pyparam_srv ptr is null!";
509 Py_INCREF(Py_None);
510 return Py_None;
511 }
512
513 Parameter* param = new Parameter();
514 std::string str_param = std::string(name, len);
515 if (!pyparam_srv->get_parameter(str_param, param)) {
516 AERROR << "pyparam_srv get_parameter is false!";
517 Py_INCREF(Py_None);
518 return Py_None;
519 }
520
521 PyParameter* pyparameter = new PyParameter(param);
522 return PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
523}

◆ cyber_PyParameter_srv_get_parameter_list()

PyObject * cyber_PyParameter_srv_get_parameter_list ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 525 行定义.

526 {
527 PyObject* pyobj_param_srv = nullptr;
528 if (!PyArg_ParseTuple(
529 args, const_cast<char*>("O:cyber_PyParameter_srv_get_parameter_list"),
530 &pyobj_param_srv)) {
531 AERROR
532 << "cyber_PyParameter_srv_get_parameter_list:PyArg_ParseTuple failed!";
533 Py_INCREF(Py_None);
534 return Py_None;
535 }
536
537 auto* pyparam_srv = reinterpret_cast<PyParameterServer*>(PyCapsule_GetPointer(
538 pyobj_param_srv, "apollo_cybertron_pyparameterserver"));
539 if (nullptr == pyparam_srv) {
540 AERROR << "cyber_PyParameter_srv_get_parameter_list pyparam_srv is null!";
541 Py_INCREF(Py_None);
542 return Py_None;
543 }
544
545 std::vector<Parameter> param_list;
546 pyparam_srv->list_parameters(&param_list);
547
548 PyObject* pyobj_list = PyList_New(param_list.size());
549 size_t pos = 0;
550 for (auto& param : param_list) {
551 Parameter* param_ptr = new Parameter(param);
552 PyParameter* pyparameter = new PyParameter(param_ptr);
553 PyObject* pyobj_param =
554 PyCapsule_New(pyparameter, "apollo_cybertron_pyparameter", nullptr);
555 PyList_SetItem(pyobj_list, pos, pyobj_param);
556 pos++;
557 }
558
559 return pyobj_list;
560}

◆ cyber_PyParameter_srv_set_parameter()

PyObject * cyber_PyParameter_srv_set_parameter ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 462 行定义.

462 {
463 PyObject* pyobj_param_srv = nullptr;
464 PyObject* pyobj_param = nullptr;
465 if (!PyArg_ParseTuple(args,
466 const_cast<char*>("OO:cyber_PyParameter_set_parameter"),
467 &pyobj_param_srv, &pyobj_param)) {
468 AERROR << "cyber_PyParameter_set_parameter parsetuple failed!";
469 Py_INCREF(Py_None);
470 return Py_None;
471 }
472
473 PyParameterServer* pyparam_srv = PyObjectToPtr<PyParameterServer*>(
474 pyobj_param_srv, "apollo_cybertron_pyparameterserver");
475 if (nullptr == pyparam_srv) {
476 AERROR << "pyparam_srv ptr is null!";
477 Py_INCREF(Py_None);
478 return Py_None;
479 }
480
481 PyParameter* pyparam =
482 PyObjectToPtr<PyParameter*>(pyobj_param, "apollo_cybertron_pyparameter");
483 if (nullptr == pyparam) {
484 AERROR << "pyparam ptr is null!";
485 Py_INCREF(Py_None);
486 return Py_None;
487 }
488
489 pyparam_srv->set_parameter(pyparam->get_param());
490 Py_INCREF(Py_None);
491 return Py_None;
492}

◆ cyber_PyParameter_type_name()

PyObject * cyber_PyParameter_type_name ( PyObject *  self,
PyObject *  args 
)

在文件 py_parameter.cc 第 118 行定义.

118 {
119 PyObject* pyobj_param = nullptr;
120 if (!PyArg_ParseTuple(args,
121 const_cast<char*>("O:cyber_PyParameter_type_name"),
122 &pyobj_param)) {
123 AERROR << "cyber_PyParameter_type_name failed!";
124 return PYOBJECT_NULL_STRING;
125 }
126
127 auto* param = reinterpret_cast<PyParameter*>(
128 PyCapsule_GetPointer(pyobj_param, "apollo_cybertron_pyparameter"));
129 if (nullptr == param) {
130 AERROR << "cyber_PyParameter_type_name ptr is null!";
131 return PYOBJECT_NULL_STRING;
132 }
133
134 const std::string type = param->type_name();
135 return C_STR_TO_PY_BYTES(type);
136}

◆ PyInit__cyber_parameter_wrapper()

PyMODINIT_FUNC PyInit__cyber_parameter_wrapper ( void  )

Init function of this module

在文件 py_parameter.cc 第 601 行定义.

601 {
602 static struct PyModuleDef module_def = {
603 PyModuleDef_HEAD_INIT,
604 "_cyber_parameter_wrapper", // Module name.
605 "CyberParameter module", // Module doc.
606 -1, // Module size.
607 _cyber_parameter_methods, // Module methods.
608 nullptr,
609 nullptr,
610 nullptr,
611 nullptr,
612 };
613
614 return PyModule_Create(&module_def);
615}

◆ PyObjectToPtr()

template<typename T >
T PyObjectToPtr ( PyObject *  pyobj,
const std::string &  type_ptr 
)

在文件 py_parameter.cc 第 36 行定义.

36 {
37 T obj_ptr = (T)PyCapsule_GetPointer(pyobj, type_ptr.c_str());
38 if (obj_ptr == nullptr) {
39 AERROR << "PyObjectToPtr failed,type->" << type_ptr << "pyobj: " << pyobj;
40 }
41 return obj_ptr;
42}