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

浏览源代码.

宏定义

#define PyInt_AsLong   PyLong_AsLong
 
#define PyInt_FromLong   PyLong_FromLong
 
#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_PyWriter (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyWriter (PyObject *self, PyObject *args)
 
PyObject * cyber_PyWriter_write (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyReader (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyReader (PyObject *self, PyObject *args)
 
PyObject * cyber_PyReader_read (PyObject *self, PyObject *args)
 
PyObject * cyber_PyReader_register_func (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyClient (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyClient (PyObject *self, PyObject *args)
 
PyObject * cyber_PyClient_send_request (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyService (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyService (PyObject *self, PyObject *args)
 
PyObject * cyber_PyService_register_func (PyObject *self, PyObject *args)
 
PyObject * cyber_PyService_read (PyObject *self, PyObject *args)
 
PyObject * cyber_PyService_write (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyNode (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyNode (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNode_create_writer (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNode_create_reader (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNode_create_client (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNode_create_service (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNode_shutdown (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNode_register_message (PyObject *self, PyObject *args)
 
PyObject * cyber_PyChannelUtils_get_msg_type (PyObject *self, PyObject *args)
 
PyObject * cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNodeUtils_get_active_nodes (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNodeUtils_get_node_attr (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNodeUtils_get_readersofnode (PyObject *self, PyObject *args)
 
PyObject * cyber_PyNodeUtils_get_writersofnode (PyObject *self, PyObject *args)
 
PyObject * cyber_PyServiceUtils_get_active_services (PyObject *self, PyObject *args)
 
PyObject * cyber_PyServiceUtils_get_service_attr (PyObject *self, PyObject *args)
 
PyMODINIT_FUNC PyInit__cyber_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_cyber.cc 第 36 行定义.

40 {
41 char *data = nullptr;
42 Py_ssize_t len = 0;
43 if (!PyArg_ParseTuple(args, const_cast<char *>("s#:cyber_py_init"), &data,
44 &len)) {
45 AERROR << "cyber_py_init:PyArg_ParseTuple failed!";
46 Py_RETURN_FALSE;
47 }
48 std::string module_name(data, len);
49 bool is_init = apollo::cyber::py_init(module_name);
50 if (is_init) {
51 Py_RETURN_TRUE;
52 } else {
53 Py_RETURN_FALSE;
54 }
55}
56
57static PyObject *cyber_py_ok(PyObject *self, PyObject *args) {
58 bool is_ok = apollo::cyber::py_ok();
59 if (is_ok) {
60 Py_RETURN_TRUE;
61 } else {
62 Py_RETURN_FALSE;
63 }
64}
65
66static PyObject *cyber_py_shutdown(PyObject *self, PyObject *args) {
67 apollo::cyber::py_shutdown();
68 Py_INCREF(Py_None);
69 return Py_None;
70}
71
72static PyObject *cyber_py_is_shutdown(PyObject *self, PyObject *args) {
73 bool is_shutdown = apollo::cyber::py_is_shutdown();
74 if (is_shutdown) {
75 Py_RETURN_TRUE;
76 } else {
77 Py_RETURN_FALSE;
78 }
79}
80
81static PyObject *cyber_py_waitforshutdown(PyObject *self, PyObject *args) {
82 apollo::cyber::py_waitforshutdown();
83 Py_INCREF(Py_None);
84 return Py_None;
85}
86
87template <typename T>
88T PyObjectToPtr(PyObject *pyobj, const std::string &type_ptr) {
89 T obj_ptr = (T)PyCapsule_GetPointer(pyobj, type_ptr.c_str());
90 if (obj_ptr == nullptr) {
91 AERROR << "PyObjectToPtr failed,type->" << type_ptr << " "
92 << "pyobj: " << pyobj;
93 }
94 return obj_ptr;
95}
96
97PyObject *cyber_new_PyWriter(PyObject *self, PyObject *args) {
98 char *channel_name = nullptr;
99 char *data_type = nullptr;
100 uint32_t qos_depth = 1;
101
102 PyObject *node_pyobj = nullptr;
103 if (!PyArg_ParseTuple(args, const_cast<char *>("ssIO:new_PyWriter"),
104 &channel_name, &data_type, &qos_depth, &node_pyobj)) {
105 Py_INCREF(Py_None);
106 return Py_None;
107 }
108
109 Node *node = reinterpret_cast<Node *>(
110 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
111 if (nullptr == node) {
112 AERROR << "node is null";
113 Py_INCREF(Py_None);
114 return Py_None;
115 }
116
117 PyWriter *writer =
118 new PyWriter((std::string const &)*channel_name,
119 (std::string const &)*data_type, qos_depth, node);
120 PyObject *pyobj_writer =
121 PyCapsule_New(writer, "apollo_cyber_pywriter", nullptr);
122 return pyobj_writer;
123}
124
125PyObject *cyber_delete_PyWriter(PyObject *self, PyObject *args) {
126 PyObject *writer_py = nullptr;
127 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyWriter"),
128 &writer_py)) {
129 Py_INCREF(Py_None);
130 return Py_None;
131 }
132
133 PyWriter *writer = reinterpret_cast<PyWriter *>(
134 PyCapsule_GetPointer(writer_py, "apollo_cyber_pywriter"));
135 delete writer;
136 Py_INCREF(Py_None);
137 return Py_None;
138}
139
140PyObject *cyber_PyWriter_write(PyObject *self, PyObject *args) {
141 PyObject *pyobj_writer = nullptr;
142 Py_buffer buffer;
143 // Py_ssize_t len = 0;
144 if (!PyArg_ParseTuple(args, const_cast<char *>("Oy*:cyber_PyWriter_write"),
145 &pyobj_writer, &buffer)) {
146 AERROR << "cyber_PyWriter_write:cyber_PyWriter_write failed!";
147 PyBuffer_Release(&buffer);
148 return PyInt_FromLong(1);
149 }
150
151 PyWriter *writer =
152 PyObjectToPtr<PyWriter *>(pyobj_writer, "apollo_cyber_pywriter");
153
154 if (nullptr == writer) {
155 AERROR << "cyber_PyWriter_write:writer ptr is null!";
156 PyBuffer_Release(&buffer);
157 return PyInt_FromLong(1);
158 }
159
160 std::string data_str(
161 const_cast<const char *>(static_cast<char *>(buffer.buf)), buffer.len);
162 int ret = writer->write(data_str);
163 PyBuffer_Release(&buffer);
164 return PyInt_FromLong(ret);
165}
166
167PyObject *cyber_new_PyReader(PyObject *self, PyObject *args) {
168 char *channel_name = nullptr;
169 char *data_type = nullptr;
170 PyObject *node_pyobj = nullptr;
171 if (!PyArg_ParseTuple(args, const_cast<char *>("ssO:new_PyReader"),
172 &channel_name, &data_type, &node_pyobj)) {
173 Py_INCREF(Py_None);
174 return Py_None;
175 }
176
177 Node *node = reinterpret_cast<Node *>(
178 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
179 if (!node) {
180 AERROR << "node is null";
181 Py_INCREF(Py_None);
182 return Py_None;
183 }
184
185 PyReader *reader = new PyReader((std::string const &)*channel_name,
186 (std::string const &)*data_type, node);
187 PyObject *pyobj_reader =
188 PyCapsule_New(reader, "apollo_cyber_pyreader", nullptr);
189 return pyobj_reader;
190}
191
192PyObject *cyber_delete_PyReader(PyObject *self, PyObject *args) {
193 PyObject *reader_py = nullptr;
194 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyReader"),
195 &reader_py)) {
196 Py_INCREF(Py_None);
197 return Py_None;
198 }
199
200 PyReader *reader = reinterpret_cast<PyReader *>(
201 PyCapsule_GetPointer(reader_py, "apollo_cyber_pyreader"));
202 delete reader;
203 Py_INCREF(Py_None);
204 return Py_None;
205}
206
207PyObject *cyber_PyReader_read(PyObject *self, PyObject *args) {
208 PyObject *pyobj_reader = nullptr;
209 PyObject *pyobj_iswait = nullptr;
210
211 if (!PyArg_ParseTuple(args, const_cast<char *>("OO:cyber_PyReader_read"),
212 &pyobj_reader, &pyobj_iswait)) {
213 AERROR << "cyber_PyReader_read:PyArg_ParseTuple failed!";
214 Py_INCREF(Py_None);
215 return Py_None;
216 }
217 PyReader *reader =
218 PyObjectToPtr<PyReader *>(pyobj_reader, "apollo_cyber_pyreader");
219 if (nullptr == reader) {
220 AERROR << "cyber_PyReader_read:PyReader ptr is null!";
221 Py_INCREF(Py_None);
222 return Py_None;
223 }
224
225 int r = PyObject_IsTrue(pyobj_iswait);
226 if (r == -1) {
227 AERROR << "cyber_PyReader_read:pyobj_iswait is error!";
228 Py_INCREF(Py_None);
229 return Py_None;
230 }
231
232 bool wait = (r == 1);
233
234 const std::string reader_ret = reader->read(wait);
235 return C_STR_TO_PY_BYTES(reader_ret);
236}
237
238PyObject *cyber_PyReader_register_func(PyObject *self, PyObject *args) {
239 PyObject *pyobj_regist_fun = nullptr;
240 PyObject *pyobj_reader = nullptr;
241
242 int (*callback_fun)(char const *) = (int (*)(char const *))0;
243
244 if (!PyArg_ParseTuple(args, const_cast<char *>("OO:PyReader_register_func"),
245 &pyobj_reader, &pyobj_regist_fun)) {
246 Py_INCREF(Py_None);
247 return Py_None;
248 }
249
250 PyReader *reader =
251 PyObjectToPtr<PyReader *>(pyobj_reader, "apollo_cyber_pyreader");
252 callback_fun = (int (*)(const char *i))PyInt_AsLong(pyobj_regist_fun);
253 if (reader) {
254 AINFO << "reader regist fun";
255 reader->register_func(callback_fun);
256 }
257
258 Py_INCREF(Py_None);
259 return Py_None;
260}
261
262PyObject *cyber_new_PyClient(PyObject *self, PyObject *args) {
263 char *channel_name = nullptr;
264 char *data_type = nullptr;
265 PyObject *node_pyobj = nullptr;
266 if (!PyArg_ParseTuple(args, const_cast<char *>("ssO:new_PyClient"),
267 &channel_name, &data_type, &node_pyobj)) {
268 Py_INCREF(Py_None);
269 return Py_None;
270 }
271
272 Node *node = reinterpret_cast<Node *>(
273 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
274 if (!node) {
275 AERROR << "node is null";
276 Py_INCREF(Py_None);
277 return Py_None;
278 }
279
280 PyClient *client = new PyClient((std::string const &)*channel_name,
281 (std::string const &)*data_type, node);
282 PyObject *pyobj_client =
283 PyCapsule_New(client, "apollo_cyber_pyclient", nullptr);
284 return pyobj_client;
285}
286
287PyObject *cyber_delete_PyClient(PyObject *self, PyObject *args) {
288 PyObject *client_py = nullptr;
289 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyClient"),
290 &client_py)) {
291 Py_INCREF(Py_None);
292 return Py_None;
293 }
294
295 PyClient *client = reinterpret_cast<PyClient *>(
296 PyCapsule_GetPointer(client_py, "apollo_cyber_pyclient"));
297 delete client;
298 Py_INCREF(Py_None);
299 return Py_None;
300}
301
302PyObject *cyber_PyClient_send_request(PyObject *self, PyObject *args) {
303 PyObject *pyobj_client = nullptr;
304 Py_buffer buffer;
305 // Py_ssize_t len = 0;
306 if (!PyArg_ParseTuple(args, const_cast<char *>("Oy*:PyClient_send_request"),
307 &pyobj_client, &buffer)) {
308 AERROR << "cyber_PyClient_send_request:PyArg_ParseTuple failed!";
309 PyBuffer_Release(&buffer);
310 return PYOBJECT_NULL_STRING;
311 }
312
313 PyClient *client =
314 PyObjectToPtr<PyClient *>(pyobj_client, "apollo_cyber_pyclient");
315
316 if (nullptr == client) {
317 AERROR << "cyber_PyClient_send_request:client ptr is null!";
318 PyBuffer_Release(&buffer);
319 return PYOBJECT_NULL_STRING;
320 }
321
322 std::string data_str(
323 const_cast<const char *>(static_cast<char *>(buffer.buf)), buffer.len);
324 ADEBUG << "c++:PyClient_send_request data->[ " << data_str << "]";
325 const std::string response_str =
326 client->send_request((std::string const &)data_str);
327 ADEBUG << "c++:response data->[ " << response_str << "]";
328 PyBuffer_Release(&buffer);
329 return C_STR_TO_PY_BYTES(response_str);
330}
331
332PyObject *cyber_new_PyService(PyObject *self, PyObject *args) {
333 char *channel_name = nullptr;
334 char *data_type = nullptr;
335 PyObject *node_pyobj = nullptr;
336 if (!PyArg_ParseTuple(args, const_cast<char *>("ssO:new_PyService"),
337 &channel_name, &data_type, &node_pyobj)) {
338 Py_INCREF(Py_None);
339 return Py_None;
340 }
341
342 Node *node = reinterpret_cast<Node *>(
343 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
344 if (!node) {
345 AERROR << "node is null";
346 Py_INCREF(Py_None);
347 return Py_None;
348 }
349
350 PyService *service = new PyService((std::string const &)*channel_name,
351 (std::string const &)*data_type, node);
352 PyObject *pyobj_service =
353 PyCapsule_New(service, "apollo_cyber_pyservice", nullptr);
354 return pyobj_service;
355}
356
357PyObject *cyber_delete_PyService(PyObject *self, PyObject *args) {
358 PyObject *pyobj_service = nullptr;
359 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyService"),
360 &pyobj_service)) {
361 Py_INCREF(Py_None);
362 return Py_None;
363 }
364
365 PyService *service = reinterpret_cast<PyService *>(
366 PyCapsule_GetPointer(pyobj_service, "apollo_cyber_pyservice"));
367 delete service;
368 Py_INCREF(Py_None);
369 return Py_None;
370}
371
372PyObject *cyber_PyService_register_func(PyObject *self, PyObject *args) {
373 PyObject *pyobj_regist_fun = nullptr;
374 PyObject *pyobj_service = nullptr;
375
376 int (*callback_fun)(char const *) = (int (*)(char const *))0;
377
378 if (!PyArg_ParseTuple(args, const_cast<char *>("OO:PyService_register_func"),
379 &pyobj_service, &pyobj_regist_fun)) {
380 Py_INCREF(Py_None);
381 return Py_None;
382 }
383
384 PyService *service =
385 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
386 callback_fun = (int (*)(const char *i))PyInt_AsLong(pyobj_regist_fun);
387 if (service) {
388 AINFO << "service regist fun";
389 service->register_func(callback_fun);
390 }
391
392 Py_INCREF(Py_None);
393 return Py_None;
394}
395
396PyObject *cyber_PyService_read(PyObject *self, PyObject *args) {
397 PyObject *pyobj_service = nullptr;
398 if (!PyArg_ParseTuple(args, const_cast<char *>("O:cyber_PyService_read"),
399 &pyobj_service)) {
400 AERROR << "cyber_PyService_read:PyArg_ParseTuple failed!";
401 return PYOBJECT_NULL_STRING;
402 }
403 PyService *service =
404 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
405 if (nullptr == service) {
406 AERROR << "cyber_PyService_read:service ptr is null!";
407 return PYOBJECT_NULL_STRING;
408 }
409
410 const std::string reader_ret = service->read();
411 ADEBUG << "c++:PyService_read -> " << reader_ret;
412 return C_STR_TO_PY_BYTES(reader_ret);
413}
414
415PyObject *cyber_PyService_write(PyObject *self, PyObject *args) {
416 PyObject *pyobj_service = nullptr;
417 Py_buffer buffer;
418 // Py_ssize_t len = 0;
419 if (!PyArg_ParseTuple(args, const_cast<char *>("Oy*:cyber_PyService_write"),
420 &pyobj_service, &buffer)) {
421 AERROR << "cyber_PyService_write:PyArg_ParseTuple failed!";
422 PyBuffer_Release(&buffer);
423 return PyInt_FromLong(1);
424 }
425
426 PyService *service =
427 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
428
429 if (nullptr == service) {
430 AERROR << "cyber_PyService_write:writer ptr is null!";
431 PyBuffer_Release(&buffer);
432 return PyInt_FromLong(1);
433 }
434
435 std::string data_str(
436 const_cast<const char *>(static_cast<char *>(buffer.buf)), buffer.len);
437 ADEBUG << "c++:PyService_write data->[ " << data_str << "]";
438 int ret = service->write((std::string const &)data_str);
439 PyBuffer_Release(&buffer);
440 return PyInt_FromLong(ret);
441}
442
443PyObject *cyber_new_PyNode(PyObject *self, PyObject *args) {
444 char *node_name = nullptr;
445 if (!PyArg_ParseTuple(args, const_cast<char *>("s:new_PyNode"), &node_name)) {
446 Py_INCREF(Py_None);
447 return Py_None;
448 }
449
450 PyNode *node = new PyNode((std::string const &)node_name);
451 PyObject *pyobj_node = PyCapsule_New(node, "apollo_cyber_pynode", nullptr);
452 return pyobj_node;
453}
454
455PyObject *cyber_delete_PyNode(PyObject *self, PyObject *args) {
456 PyObject *pyobj_node = nullptr;
457 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyNode"),
458 &pyobj_node)) {
459 Py_INCREF(Py_None);
460 return Py_None;
461 }
462
463 PyNode *node = reinterpret_cast<PyNode *>(
464 PyCapsule_GetPointer(pyobj_node, "apollo_cyber_pynode"));
465 delete node;
466 Py_INCREF(Py_None);
467 return Py_None;
468}
469
470PyObject *cyber_PyNode_create_writer(PyObject *self, PyObject *args) {
471 PyObject *pyobj_node = nullptr;
472 char *channel_name = nullptr;
473 char *type_name = nullptr;
474 uint32_t qos_depth = 1;
475
476 if (!PyArg_ParseTuple(args, const_cast<char *>("OssI:PyNode_create_writer"),
477 &pyobj_node, &channel_name, &type_name, &qos_depth)) {
478 AERROR << "cyber_PyNode_create_writer:PyArg_ParseTuple failed!";
479 Py_INCREF(Py_None);
480 return Py_None;
481 }
482
483 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
484 if (nullptr == node) {
485 AERROR << "cyber_PyNode_create_writer:node ptr is null!";
486 Py_INCREF(Py_None);
487 return Py_None;
488 }
489
490 PyWriter *writer = reinterpret_cast<PyWriter *>(
491 (node->create_writer((std::string const &)channel_name,
492 (std::string const &)type_name, qos_depth)));
493
494 if (nullptr == writer) {
495 AERROR << "cyber_PyNode_create_writer:writer is null!";
496 Py_INCREF(Py_None);
497 return Py_None;
498 }
499 PyObject *pyobj_writer =
500 PyCapsule_New(writer, "apollo_cyber_pywriter", nullptr);
501 return pyobj_writer;
502}
503
504PyObject *cyber_PyNode_create_reader(PyObject *self, PyObject *args) {
505 char *channel_name = nullptr;
506 char *type_name = nullptr;
507 PyObject *pyobj_node = nullptr;
508
509 if (!PyArg_ParseTuple(args, const_cast<char *>("Oss:PyNode_create_reader"),
510 &pyobj_node, &channel_name, &type_name)) {
511 AERROR << "PyNode_create_reader:PyArg_ParseTuple failed!";
512 Py_INCREF(Py_None);
513 return Py_None;
514 }
515
516 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
517 if (nullptr == node) {
518 AERROR << "PyNode_create_reader:node ptr is null!";
519 Py_INCREF(Py_None);
520 return Py_None;
521 }
522
523 PyReader *reader = reinterpret_cast<PyReader *>((node->create_reader(
524 (std::string const &)channel_name, (std::string const &)type_name)));
525 ACHECK(reader) << "PyReader is NULL!";
526
527 PyObject *pyobj_reader =
528 PyCapsule_New(reader, "apollo_cyber_pyreader", nullptr);
529 return pyobj_reader;
530}
531
532PyObject *cyber_PyNode_create_client(PyObject *self, PyObject *args) {
533 char *channel_name = nullptr;
534 char *type_name = nullptr;
535 PyObject *pyobj_node = nullptr;
536
537 if (!PyArg_ParseTuple(args, const_cast<char *>("Oss:PyNode_create_client"),
538 &pyobj_node, &channel_name, &type_name)) {
539 AERROR << "PyNode_create_client:PyArg_ParseTuple failed!";
540 Py_INCREF(Py_None);
541 return Py_None;
542 }
543
544 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
545 if (nullptr == node) {
546 AERROR << "PyNode_create_client:node ptr is null!";
547 Py_INCREF(Py_None);
548 return Py_None;
549 }
550
551 PyClient *client = reinterpret_cast<PyClient *>((node->create_client(
552 (std::string const &)channel_name, (std::string const &)type_name)));
553 PyObject *pyobj_client =
554 PyCapsule_New(client, "apollo_cyber_pyclient", nullptr);
555
556 return pyobj_client;
557}
558
559PyObject *cyber_PyNode_create_service(PyObject *self, PyObject *args) {
560 char *channel_name = nullptr;
561 char *type_name = nullptr;
562 PyObject *pyobj_node = nullptr;
563
564 if (!PyArg_ParseTuple(args,
565 const_cast<char *>("Oss:cyber_PyNode_create_service"),
566 &pyobj_node, &channel_name, &type_name)) {
567 AERROR << "cyber_PyNode_create_service:PyArg_ParseTuple failed!";
568 Py_INCREF(Py_None);
569 return Py_None;
570 }
571
572 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
573 if (nullptr == node) {
574 AERROR << "cyber_PyNode_create_service:node ptr is null!";
575 Py_INCREF(Py_None);
576 return Py_None;
577 }
578
579 PyService *service = reinterpret_cast<PyService *>((node->create_service(
580 (std::string const &)channel_name, (std::string const &)type_name)));
581 PyObject *pyobj_service =
582 PyCapsule_New(service, "apollo_cyber_pyservice", nullptr);
583 return pyobj_service;
584}
585
586PyObject *cyber_PyNode_shutdown(PyObject *self, PyObject *args) {
587 PyObject *pyobj_node = nullptr;
588
589 if (!PyArg_ParseTuple(args, const_cast<char *>("O:PyNode_shutdown"),
590 &pyobj_node)) {
591 AERROR << "cyber_PyNode_shutdown:PyNode_shutdown failed!";
592 Py_INCREF(Py_None);
593 return Py_None;
594 }
595
596 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
597 if (nullptr == node) {
598 AERROR << "cyber_PyNode_shutdown:node ptr is null!";
599 Py_INCREF(Py_None);
600 return Py_None;
601 }
602 node->shutdown();
603 Py_INCREF(Py_None);
604 return Py_None;
605}
606
607PyObject *cyber_PyNode_register_message(PyObject *self, PyObject *args) {
608 PyObject *pyobj_node = nullptr;
609 Py_buffer buffer;
610 // int len = 0;
611 if (!PyArg_ParseTuple(args,
612 const_cast<char *>("Oy*:cyber_PyNode_register_message"),
613 &pyobj_node, &buffer)) {
614 AERROR << "cyber_PyNode_register_message: failed!";
615 Py_INCREF(Py_None);
616 PyBuffer_Release(&buffer);
617 return Py_None;
618 }
619 std::string desc_str(
620 const_cast<const char *>(static_cast<char *>(buffer.buf)), buffer.len);
621 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
622 if (nullptr == node) {
623 AERROR << "cyber_PyNode_register_message:node ptr is null! desc->"
624 << desc_str;
625 Py_INCREF(Py_None);
626 PyBuffer_Release(&buffer);
627 return Py_None;
628 }
629 node->register_message((std::string const &)desc_str);
630 Py_INCREF(Py_None);
631 PyBuffer_Release(&buffer);
632 return Py_None;
633}
634
635PyObject *cyber_PyChannelUtils_get_msg_type(PyObject *self, PyObject *args) {
636 char *channel_name = nullptr;
637 Py_ssize_t len = 0;
638 unsigned char sleep_s = 0;
639 if (!PyArg_ParseTuple(
640 args, const_cast<char *>("s#B:cyber_PyChannelUtils_get_msg_type"),
641 &channel_name, &len, &sleep_s)) {
642 AERROR << "cyber_PyChannelUtils_get_msg_type failed!";
643 return PYOBJECT_NULL_STRING;
644 }
645 std::string channel(channel_name, len);
646 const std::string msg_type =
647 PyChannelUtils::get_msgtype_by_channelname(channel, sleep_s);
648 return C_STR_TO_PY_BYTES(msg_type);
649}
650
651PyObject *cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata(
652 PyObject *self, PyObject *args) {
653 char *msgtype = nullptr;
654 char *rawdata = nullptr;
655 Py_ssize_t len = 0;
656 if (!PyArg_ParseTuple(
657 args,
658 const_cast<char *>(
659 "ss#:cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata"),
660 &msgtype, &rawdata, &len)) {
661 AERROR
662 << "cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata failed!";
663 return PYOBJECT_NULL_STRING;
664 }
665 std::string raw_data(rawdata, len);
666 const std::string debug_string =
667 PyChannelUtils::get_debugstring_by_msgtype_rawmsgdata(msgtype, raw_data);
668 return C_STR_TO_PY_BYTES(debug_string);
669}
670
671static PyObject *cyber_PyChannelUtils_get_active_channels(PyObject *self,
672 PyObject *args) {
673 unsigned char sleep_s = 0;
674 if (!PyArg_ParseTuple(
675 args,
676 const_cast<char *>("B:cyber_PyChannelUtils_get_active_channels"),
677 &sleep_s)) {
678 AERROR << "cyber_PyChannelUtils_get_active_channels failed!";
679 Py_INCREF(Py_None);
680 return Py_None;
681 }
682
683 std::vector<std::string> channel_list =
684 PyChannelUtils::get_active_channels(sleep_s);
685 PyObject *pyobj_list = PyList_New(channel_list.size());
686 size_t pos = 0;
687 for (const std::string &channel : channel_list) {
688 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", channel.c_str()));
689 pos++;
690 }
691
692 return pyobj_list;
693}
694
695// return dict value look like:
696// { 'channel1':[atrr1, atrr2, atrr3],
697// 'channel2':[atrr1, atrr2]
698// }
699static PyObject *cyber_PyChannelUtils_get_channels_info(PyObject *self,
700 PyObject *args) {
701 auto channelsinfo = PyChannelUtils::get_channels_info();
702 PyObject *pyobj_channelinfo_dict = PyDict_New();
703 for (auto &channelinfo : channelsinfo) {
704 std::string channel_name = channelinfo.first;
705 PyObject *bld_name = Py_BuildValue("s", channel_name.c_str());
706 std::vector<std::string> &roleAttr_list = channelinfo.second;
707 PyObject *pyobj_list = PyList_New(roleAttr_list.size());
708
709 size_t pos = 0;
710 for (auto &attr : roleAttr_list) {
711 PyList_SetItem(pyobj_list, pos, C_STR_TO_PY_BYTES(attr));
712 pos++;
713 }
714 PyDict_SetItem(pyobj_channelinfo_dict, bld_name, pyobj_list);
715 Py_DECREF(bld_name);
716 }
717 return pyobj_channelinfo_dict;
718}
719
720PyObject *cyber_PyNodeUtils_get_active_nodes(PyObject *self, PyObject *args) {
721 unsigned char sleep_s = 0;
722 if (!PyArg_ParseTuple(
723 args, const_cast<char *>("B:cyber_PyNodeUtils_get_active_nodes"),
724 &sleep_s)) {
725 AERROR << "cyber_PyNodeUtils_get_active_nodes failed!";
726 Py_INCREF(Py_None);
727 return Py_None;
728 }
729
730 std::vector<std::string> nodes_name =
731 apollo::cyber::PyNodeUtils::get_active_nodes(sleep_s);
732 PyObject *pyobj_list = PyList_New(nodes_name.size());
733 size_t pos = 0;
734 for (const std::string &name : nodes_name) {
735 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", name.c_str()));
736 pos++;
737 }
738
739 return pyobj_list;
740}
741
742PyObject *cyber_PyNodeUtils_get_node_attr(PyObject *self, PyObject *args) {
743 char *node_name = nullptr;
744 Py_ssize_t len = 0;
745 unsigned char sleep_s = 0;
746 if (!PyArg_ParseTuple(
747 args, const_cast<char *>("s#B:cyber_PyNodeUtils_get_node_attr"),
748 &node_name, &len, &sleep_s)) {
749 AERROR << "cyber_PyNodeUtils_get_node_attr failed!";
750 Py_INCREF(Py_None);
751 return Py_None;
752 }
753 std::string name(node_name, len);
754 const std::string node_attr =
755 apollo::cyber::PyNodeUtils::get_node_attr(name, sleep_s);
756 return C_STR_TO_PY_BYTES(node_attr);
757}
758
759PyObject *cyber_PyNodeUtils_get_readersofnode(PyObject *self, PyObject *args) {
760 char *node_name = nullptr;
761 Py_ssize_t len = 0;
762 unsigned char sleep_s = 0;
763 if (!PyArg_ParseTuple(
764 args, const_cast<char *>("s#B:cyber_PyNodeUtils_get_readersofnode"),
765 &node_name, &len, &sleep_s)) {
766 AERROR << "cyber_PyNodeUtils_get_readersofnode failed!";
767 Py_INCREF(Py_None);
768 return Py_None;
769 }
770 std::string name(node_name, len);
771 std::vector<std::string> readers_channel =
772 apollo::cyber::PyNodeUtils::get_readersofnode(name, sleep_s);
773 PyObject *pyobj_list = PyList_New(readers_channel.size());
774 size_t pos = 0;
775 for (const std::string &channel : readers_channel) {
776 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", channel.c_str()));
777 pos++;
778 }
779
780 return pyobj_list;
781}
782
783PyObject *cyber_PyNodeUtils_get_writersofnode(PyObject *self, PyObject *args) {
784 char *node_name = nullptr;
785 Py_ssize_t len = 0;
786 unsigned char sleep_s = 0;
787 if (!PyArg_ParseTuple(
788 args, const_cast<char *>("s#B:cyber_PyNodeUtils_get_writersofnode"),
789 &node_name, &len, &sleep_s)) {
790 AERROR << "cyber_PyNodeUtils_get_writersofnode failed!";
791 Py_INCREF(Py_None);
792 return Py_None;
793 }
794 std::string name(node_name, len);
795 std::vector<std::string> writers_channel =
796 apollo::cyber::PyNodeUtils::get_writersofnode(name, sleep_s);
797 PyObject *pyobj_list = PyList_New(writers_channel.size());
798 size_t pos = 0;
799 for (const std::string &channel : writers_channel) {
800 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", channel.c_str()));
801 pos++;
802 }
803
804 return pyobj_list;
805}
806
807PyObject *cyber_PyServiceUtils_get_active_services(PyObject *self,
808 PyObject *args) {
809 unsigned char sleep_s = 0;
810 if (!PyArg_ParseTuple(
811 args,
812 const_cast<char *>("B:cyber_PyServiceUtils_get_active_services"),
813 &sleep_s)) {
814 AERROR << "cyber_PyServiceUtils_get_active_services failed!";
815 Py_INCREF(Py_None);
816 return Py_None;
817 }
818
819 std::vector<std::string> services_name =
820 PyServiceUtils::get_active_services(sleep_s);
821 PyObject *pyobj_list = PyList_New(services_name.size());
822 size_t pos = 0;
823 for (const std::string &name : services_name) {
824 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", name.c_str()));
825 pos++;
826 }
827
828 return pyobj_list;
829}
830
831PyObject *cyber_PyServiceUtils_get_service_attr(PyObject *self,
832 PyObject *args) {
833 char *srv_name = nullptr;
834 Py_ssize_t len = 0;
835 unsigned char sleep_s = 0;
836 if (!PyArg_ParseTuple(
837 args, const_cast<char *>("s#B:cyber_PyServiceUtils_get_service_attr"),
838 &srv_name, &len, &sleep_s)) {
839 AERROR << "cyber_PyServiceUtils_get_service_attr failed!";
840 Py_INCREF(Py_None);
841 return Py_None;
842 }
843 std::string name(srv_name, len);
844 const std::string srv_attr = PyServiceUtils::get_service_attr(name, sleep_s);
845 return C_STR_TO_PY_BYTES(srv_attr);
846}
847
851static PyMethodDef _cyber_methods[] = {
852 // PyInit fun
853 {"py_init", cyber_py_init, METH_VARARGS, ""},
854 {"py_ok", cyber_py_ok, METH_NOARGS, ""},
855 {"py_shutdown", cyber_py_shutdown, METH_NOARGS, ""},
856 {"py_is_shutdown", cyber_py_is_shutdown, METH_NOARGS, ""},
857 {"py_waitforshutdown", cyber_py_waitforshutdown, METH_NOARGS, ""},
858
859 // PyWriter fun
860 {"new_PyWriter", cyber_new_PyWriter, METH_VARARGS, ""},
861 {"delete_PyWriter", cyber_delete_PyWriter, METH_VARARGS, ""},
862 {"PyWriter_write", cyber_PyWriter_write, METH_VARARGS, ""},
863
864 // PyReader fun
865 {"new_PyReader", cyber_new_PyReader, METH_VARARGS, ""},
866 {"delete_PyReader", cyber_delete_PyReader, METH_VARARGS, ""},
867 {"PyReader_register_func", cyber_PyReader_register_func, METH_VARARGS, ""},
868 {"PyReader_read", cyber_PyReader_read, METH_VARARGS, ""},
869
870 // PyClient fun
871 {"new_PyClient", cyber_new_PyClient, METH_VARARGS, ""},
872 {"delete_PyClient", cyber_delete_PyClient, METH_VARARGS, ""},
873 {"PyClient_send_request", cyber_PyClient_send_request, METH_VARARGS, ""},
874 // PyService fun
875 {"new_PyService", cyber_new_PyService, METH_VARARGS, ""},
876 {"delete_PyService", cyber_delete_PyService, METH_VARARGS, ""},
877 {"PyService_register_func", cyber_PyService_register_func, METH_VARARGS,
878 ""},
879 {"PyService_read", cyber_PyService_read, METH_VARARGS, ""},
880 {"PyService_write", cyber_PyService_write, METH_VARARGS, ""},
881 // PyNode fun
882 {"new_PyNode", cyber_new_PyNode, METH_VARARGS, ""},
883 {"delete_PyNode", cyber_delete_PyNode, METH_VARARGS, ""},
884 {"PyNode_shutdown", cyber_PyNode_shutdown, METH_VARARGS, ""},
885 {"PyNode_create_writer", cyber_PyNode_create_writer, METH_VARARGS, ""},
886 {"PyNode_register_message", cyber_PyNode_register_message, METH_VARARGS,
887 ""},
888 {"PyNode_create_reader", cyber_PyNode_create_reader, METH_VARARGS, ""},
889 {"PyNode_create_client", cyber_PyNode_create_client, METH_VARARGS, ""},
890 {"PyNode_create_service", cyber_PyNode_create_service, METH_VARARGS, ""},
891
892 {"PyChannelUtils_get_msg_type", cyber_PyChannelUtils_get_msg_type,
893 METH_VARARGS, ""},
894 {"PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata",
895 cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata, METH_VARARGS,
896 ""},
897 {"PyChannelUtils_get_active_channels",
898 cyber_PyChannelUtils_get_active_channels, METH_VARARGS, ""},
899 {"PyChannelUtils_get_channels_info", cyber_PyChannelUtils_get_channels_info,
900 METH_VARARGS, ""},
901
902 {"PyNodeUtils_get_active_nodes", cyber_PyNodeUtils_get_active_nodes,
903 METH_VARARGS, ""},
904 {"PyNodeUtils_get_node_attr", cyber_PyNodeUtils_get_node_attr, METH_VARARGS,
905 ""},
906 {"PyNodeUtils_get_readersofnode", cyber_PyNodeUtils_get_readersofnode,
907 METH_VARARGS, ""},
908 {"PyNodeUtils_get_writersofnode", cyber_PyNodeUtils_get_writersofnode,
909 METH_VARARGS, ""},
910
911 {"PyServiceUtils_get_active_services",
912 cyber_PyServiceUtils_get_active_services, METH_VARARGS, ""},
913 {"PyServiceUtils_get_service_attr", cyber_PyServiceUtils_get_service_attr,
914 METH_VARARGS, ""},
915
916 {nullptr, nullptr, 0, nullptr} /* sentinel */
917};
918
920PyMODINIT_FUNC PyInit__cyber_wrapper(void) {
921 static struct PyModuleDef module_def = {
922 PyModuleDef_HEAD_INIT,
923 "_cyber_wrapper", // Module name.
924 "Cyber module", // Module doc.
925 -1, // Module size.
926 _cyber_methods, // Module methods.
927 nullptr,
928 nullptr,
929 nullptr,
930 nullptr,
931 };
932
933 return PyModule_Create(&module_def);
934}
apollo::cyber::Node
Node is the fundamental building block of Cyber RT.
Definition node.h:44
apollo::cyber::PyChannelUtils::get_channels_info
static std::unordered_map< std::string, std::vector< std::string > > get_channels_info(uint8_t sleep_s=2)
Definition py_cyber.h:397
apollo::cyber::PyChannelUtils::get_msgtype_by_channelname
static std::string get_msgtype_by_channelname(const std::string &channel_name, uint8_t sleep_s=0)
Definition py_cyber.h:373
apollo::cyber::PyChannelUtils::get_debugstring_by_msgtype_rawmsgdata
static std::string get_debugstring_by_msgtype_rawmsgdata(const std::string &msg_type, const std::string &rawmsgdata)
Definition py_cyber.h:344
apollo::cyber::PyChannelUtils::get_active_channels
static std::vector< std::string > get_active_channels(uint8_t sleep_s=2)
Definition py_cyber.h:387
apollo::cyber::PyClient::send_request
std::string send_request(std::string request)
Definition py_cyber.h:264
apollo::cyber::PyNodeUtils::get_readersofnode
static std::vector< std::string > get_readersofnode(const std::string &node_name, uint8_t sleep_s=2)
Definition py_cyber.h:471
apollo::cyber::PyNodeUtils::get_writersofnode
static std::vector< std::string > get_writersofnode(const std::string &node_name, uint8_t sleep_s=2)
Definition py_cyber.h:493
apollo::cyber::PyNodeUtils::get_node_attr
static std::string get_node_attr(const std::string &node_name, uint8_t sleep_s=2)
Definition py_cyber.h:449
apollo::cyber::PyNodeUtils::get_active_nodes
static std::vector< std::string > get_active_nodes(uint8_t sleep_s=2)
Definition py_cyber.h:428
apollo::cyber::PyNode::create_reader
PyReader * create_reader(const std::string &channel, const std::string &type)
Definition py_cyber.h:310
apollo::cyber::PyNode::create_service
PyService * create_service(const std::string &service, const std::string &type)
Definition py_cyber.h:317
apollo::cyber::PyNode::create_writer
PyWriter * create_writer(const std::string &channel, const std::string &type, uint32_t qos_depth=1)
Definition py_cyber.h:297
apollo::cyber::PyNode::create_client
PyClient * create_client(const std::string &service, const std::string &type)
Definition py_cyber.h:325
apollo::cyber::PyNode::register_message
void register_message(const std::string &desc)
Definition py_cyber.h:306
apollo::cyber::PyReader::read
std::string read(bool wait=false)
Definition py_cyber.h:131
apollo::cyber::PyReader::register_func
void register_func(int(*func)(const char *))
Definition py_cyber.h:129
apollo::cyber::PyServiceUtils::get_active_services
static std::vector< std::string > get_active_services(uint8_t sleep_s=2)
Definition py_cyber.h:518
apollo::cyber::PyServiceUtils::get_service_attr
static std::string get_service_attr(const std::string &service_name, uint8_t sleep_s=2)
Definition py_cyber.h:539
apollo::cyber::PyService::register_func
void register_func(int(*func)(const char *))
Definition py_cyber.h:206
apollo::cyber::PyService::write
int write(const std::string &data)
Definition py_cyber.h:217
apollo::cyber::PyWriter::write
int write(const std::string &data)
Definition py_cyber.h:95
data_type
int data_type
Definition cyber_benchmark_writer.cc:39
ACHECK
#define ACHECK(cond)
Definition log.h:80
ADEBUG
#define ADEBUG
Definition log.h:41
AERROR
#define AERROR
Definition log.h:44
AINFO
#define AINFO
Definition log.h:42
apollo::cyber::py_is_shutdown
bool py_is_shutdown()
Definition py_cyber.h:67
apollo::cyber::py_shutdown
void py_shutdown()
Definition py_cyber.h:65
apollo::cyber::py_waitforshutdown
void py_waitforshutdown()
Definition py_cyber.h:69
apollo::cyber::py_init
bool py_init(const std::string &module_name)
Definition py_cyber.h:47
apollo::cyber::py_ok
bool py_ok()
Definition py_cyber.h:63
cyber_PyChannelUtils_get_msg_type
PyObject * cyber_PyChannelUtils_get_msg_type(PyObject *self, PyObject *args)
Definition py_cyber.cc:636
cyber_PyReader_read
PyObject * cyber_PyReader_read(PyObject *self, PyObject *args)
Definition py_cyber.cc:208
cyber_PyNodeUtils_get_node_attr
PyObject * cyber_PyNodeUtils_get_node_attr(PyObject *self, PyObject *args)
Definition py_cyber.cc:743
cyber_delete_PyReader
PyObject * cyber_delete_PyReader(PyObject *self, PyObject *args)
Definition py_cyber.cc:193
cyber_PyServiceUtils_get_active_services
PyObject * cyber_PyServiceUtils_get_active_services(PyObject *self, PyObject *args)
Definition py_cyber.cc:808
cyber_PyNode_create_client
PyObject * cyber_PyNode_create_client(PyObject *self, PyObject *args)
Definition py_cyber.cc:533
PYOBJECT_NULL_STRING
#define PYOBJECT_NULL_STRING
Definition py_cyber.cc:35
cyber_PyNodeUtils_get_active_nodes
PyObject * cyber_PyNodeUtils_get_active_nodes(PyObject *self, PyObject *args)
Definition py_cyber.cc:721
cyber_delete_PyClient
PyObject * cyber_delete_PyClient(PyObject *self, PyObject *args)
Definition py_cyber.cc:288
cyber_delete_PyWriter
PyObject * cyber_delete_PyWriter(PyObject *self, PyObject *args)
Definition py_cyber.cc:126
PyInt_AsLong
#define PyInt_AsLong
Definition py_cyber.cc:33
PyInt_FromLong
#define PyInt_FromLong
Definition py_cyber.cc:34
PyInit__cyber_wrapper
PyMODINIT_FUNC PyInit__cyber_wrapper(void)
Init function of this module
Definition py_cyber.cc:921
cyber_new_PyWriter
PyObject * cyber_new_PyWriter(PyObject *self, PyObject *args)
Definition py_cyber.cc:98
cyber_new_PyClient
PyObject * cyber_new_PyClient(PyObject *self, PyObject *args)
Definition py_cyber.cc:263
cyber_PyService_register_func
PyObject * cyber_PyService_register_func(PyObject *self, PyObject *args)
Definition py_cyber.cc:373
cyber_PyWriter_write
PyObject * cyber_PyWriter_write(PyObject *self, PyObject *args)
Definition py_cyber.cc:141
cyber_PyNodeUtils_get_writersofnode
PyObject * cyber_PyNodeUtils_get_writersofnode(PyObject *self, PyObject *args)
Definition py_cyber.cc:784
cyber_PyNode_create_service
PyObject * cyber_PyNode_create_service(PyObject *self, PyObject *args)
Definition py_cyber.cc:560
PyObjectToPtr
T PyObjectToPtr(PyObject *pyobj, const std::string &type_ptr)
Definition py_cyber.cc:89
cyber_delete_PyNode
PyObject * cyber_delete_PyNode(PyObject *self, PyObject *args)
Definition py_cyber.cc:456
C_STR_TO_PY_BYTES
#define C_STR_TO_PY_BYTES(cstr)
Definition py_cyber.cc:36
cyber_PyService_write
PyObject * cyber_PyService_write(PyObject *self, PyObject *args)
Definition py_cyber.cc:416
cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata
PyObject * cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata(PyObject *self, PyObject *args)
Definition py_cyber.cc:652
cyber_new_PyReader
PyObject * cyber_new_PyReader(PyObject *self, PyObject *args)
Definition py_cyber.cc:168
cyber_new_PyNode
PyObject * cyber_new_PyNode(PyObject *self, PyObject *args)
Definition py_cyber.cc:444
cyber_PyReader_register_func
PyObject * cyber_PyReader_register_func(PyObject *self, PyObject *args)
Definition py_cyber.cc:239
cyber_PyClient_send_request
PyObject * cyber_PyClient_send_request(PyObject *self, PyObject *args)
Definition py_cyber.cc:303
cyber_new_PyService
PyObject * cyber_new_PyService(PyObject *self, PyObject *args)
Definition py_cyber.cc:333
cyber_PyNodeUtils_get_readersofnode
PyObject * cyber_PyNodeUtils_get_readersofnode(PyObject *self, PyObject *args)
Definition py_cyber.cc:760
cyber_PyNode_shutdown
PyObject * cyber_PyNode_shutdown(PyObject *self, PyObject *args)
Definition py_cyber.cc:587
cyber_PyService_read
PyObject * cyber_PyService_read(PyObject *self, PyObject *args)
Definition py_cyber.cc:397
cyber_PyNode_create_writer
PyObject * cyber_PyNode_create_writer(PyObject *self, PyObject *args)
Definition py_cyber.cc:471
cyber_PyServiceUtils_get_service_attr
PyObject * cyber_PyServiceUtils_get_service_attr(PyObject *self, PyObject *args)
Definition py_cyber.cc:832
cyber_delete_PyService
PyObject * cyber_delete_PyService(PyObject *self, PyObject *args)
Definition py_cyber.cc:358
cyber_PyNode_register_message
PyObject * cyber_PyNode_register_message(PyObject *self, PyObject *args)
Definition py_cyber.cc:608
cyber_PyNode_create_reader
PyObject * cyber_PyNode_create_reader(PyObject *self, PyObject *args)
Definition py_cyber.cc:505

◆ PyInt_AsLong

#define PyInt_AsLong   PyLong_AsLong

在文件 py_cyber.cc 第 33 行定义.

◆ PyInt_FromLong

#define PyInt_FromLong   PyLong_FromLong

在文件 py_cyber.cc 第 34 行定义.

◆ PYOBJECT_NULL_STRING

#define PYOBJECT_NULL_STRING   PyBytes_FromStringAndSize("", 0)

在文件 py_cyber.cc 第 35 行定义.

函数说明

◆ cyber_delete_PyClient()

PyObject * cyber_delete_PyClient ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 288 行定义.

288 {
289 PyObject *client_py = nullptr;
290 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyClient"),
291 &client_py)) {
292 Py_INCREF(Py_None);
293 return Py_None;
294 }
295
296 PyClient *client = reinterpret_cast<PyClient *>(
297 PyCapsule_GetPointer(client_py, "apollo_cyber_pyclient"));
298 delete client;
299 Py_INCREF(Py_None);
300 return Py_None;
301}

◆ cyber_delete_PyNode()

PyObject * cyber_delete_PyNode ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 456 行定义.

456 {
457 PyObject *pyobj_node = nullptr;
458 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyNode"),
459 &pyobj_node)) {
460 Py_INCREF(Py_None);
461 return Py_None;
462 }
463
464 PyNode *node = reinterpret_cast<PyNode *>(
465 PyCapsule_GetPointer(pyobj_node, "apollo_cyber_pynode"));
466 delete node;
467 Py_INCREF(Py_None);
468 return Py_None;
469}

◆ cyber_delete_PyReader()

PyObject * cyber_delete_PyReader ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 193 行定义.

193 {
194 PyObject *reader_py = nullptr;
195 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyReader"),
196 &reader_py)) {
197 Py_INCREF(Py_None);
198 return Py_None;
199 }
200
201 PyReader *reader = reinterpret_cast<PyReader *>(
202 PyCapsule_GetPointer(reader_py, "apollo_cyber_pyreader"));
203 delete reader;
204 Py_INCREF(Py_None);
205 return Py_None;
206}

◆ cyber_delete_PyService()

PyObject * cyber_delete_PyService ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 358 行定义.

358 {
359 PyObject *pyobj_service = nullptr;
360 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyService"),
361 &pyobj_service)) {
362 Py_INCREF(Py_None);
363 return Py_None;
364 }
365
366 PyService *service = reinterpret_cast<PyService *>(
367 PyCapsule_GetPointer(pyobj_service, "apollo_cyber_pyservice"));
368 delete service;
369 Py_INCREF(Py_None);
370 return Py_None;
371}

◆ cyber_delete_PyWriter()

PyObject * cyber_delete_PyWriter ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 126 行定义.

126 {
127 PyObject *writer_py = nullptr;
128 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyWriter"),
129 &writer_py)) {
130 Py_INCREF(Py_None);
131 return Py_None;
132 }
133
134 PyWriter *writer = reinterpret_cast<PyWriter *>(
135 PyCapsule_GetPointer(writer_py, "apollo_cyber_pywriter"));
136 delete writer;
137 Py_INCREF(Py_None);
138 return Py_None;
139}

◆ cyber_new_PyClient()

PyObject * cyber_new_PyClient ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 263 行定义.

263 {
264 char *channel_name = nullptr;
265 char *data_type = nullptr;
266 PyObject *node_pyobj = nullptr;
267 if (!PyArg_ParseTuple(args, const_cast<char *>("ssO:new_PyClient"),
268 &channel_name, &data_type, &node_pyobj)) {
269 Py_INCREF(Py_None);
270 return Py_None;
271 }
272
273 Node *node = reinterpret_cast<Node *>(
274 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
275 if (!node) {
276 AERROR << "node is null";
277 Py_INCREF(Py_None);
278 return Py_None;
279 }
280
281 PyClient *client = new PyClient((std::string const &)*channel_name,
282 (std::string const &)*data_type, node);
283 PyObject *pyobj_client =
284 PyCapsule_New(client, "apollo_cyber_pyclient", nullptr);
285 return pyobj_client;
286}

◆ cyber_new_PyNode()

PyObject * cyber_new_PyNode ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 444 行定义.

444 {
445 char *node_name = nullptr;
446 if (!PyArg_ParseTuple(args, const_cast<char *>("s:new_PyNode"), &node_name)) {
447 Py_INCREF(Py_None);
448 return Py_None;
449 }
450
451 PyNode *node = new PyNode((std::string const &)node_name);
452 PyObject *pyobj_node = PyCapsule_New(node, "apollo_cyber_pynode", nullptr);
453 return pyobj_node;
454}

◆ cyber_new_PyReader()

PyObject * cyber_new_PyReader ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 168 行定义.

168 {
169 char *channel_name = nullptr;
170 char *data_type = nullptr;
171 PyObject *node_pyobj = nullptr;
172 if (!PyArg_ParseTuple(args, const_cast<char *>("ssO:new_PyReader"),
173 &channel_name, &data_type, &node_pyobj)) {
174 Py_INCREF(Py_None);
175 return Py_None;
176 }
177
178 Node *node = reinterpret_cast<Node *>(
179 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
180 if (!node) {
181 AERROR << "node is null";
182 Py_INCREF(Py_None);
183 return Py_None;
184 }
185
186 PyReader *reader = new PyReader((std::string const &)*channel_name,
187 (std::string const &)*data_type, node);
188 PyObject *pyobj_reader =
189 PyCapsule_New(reader, "apollo_cyber_pyreader", nullptr);
190 return pyobj_reader;
191}

◆ cyber_new_PyService()

PyObject * cyber_new_PyService ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 333 行定义.

333 {
334 char *channel_name = nullptr;
335 char *data_type = nullptr;
336 PyObject *node_pyobj = nullptr;
337 if (!PyArg_ParseTuple(args, const_cast<char *>("ssO:new_PyService"),
338 &channel_name, &data_type, &node_pyobj)) {
339 Py_INCREF(Py_None);
340 return Py_None;
341 }
342
343 Node *node = reinterpret_cast<Node *>(
344 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
345 if (!node) {
346 AERROR << "node is null";
347 Py_INCREF(Py_None);
348 return Py_None;
349 }
350
351 PyService *service = new PyService((std::string const &)*channel_name,
352 (std::string const &)*data_type, node);
353 PyObject *pyobj_service =
354 PyCapsule_New(service, "apollo_cyber_pyservice", nullptr);
355 return pyobj_service;
356}

◆ cyber_new_PyWriter()

PyObject * cyber_new_PyWriter ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 98 行定义.

98 {
99 char *channel_name = nullptr;
100 char *data_type = nullptr;
101 uint32_t qos_depth = 1;
102
103 PyObject *node_pyobj = nullptr;
104 if (!PyArg_ParseTuple(args, const_cast<char *>("ssIO:new_PyWriter"),
105 &channel_name, &data_type, &qos_depth, &node_pyobj)) {
106 Py_INCREF(Py_None);
107 return Py_None;
108 }
109
110 Node *node = reinterpret_cast<Node *>(
111 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
112 if (nullptr == node) {
113 AERROR << "node is null";
114 Py_INCREF(Py_None);
115 return Py_None;
116 }
117
118 PyWriter *writer =
119 new PyWriter((std::string const &)*channel_name,
120 (std::string const &)*data_type, qos_depth, node);
121 PyObject *pyobj_writer =
122 PyCapsule_New(writer, "apollo_cyber_pywriter", nullptr);
123 return pyobj_writer;
124}

◆ cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata()

PyObject * cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 652 行定义.

653 {
654 char *msgtype = nullptr;
655 char *rawdata = nullptr;
656 Py_ssize_t len = 0;
657 if (!PyArg_ParseTuple(
658 args,
659 const_cast<char *>(
660 "ss#:cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata"),
661 &msgtype, &rawdata, &len)) {
662 AERROR
663 << "cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata failed!";
664 return PYOBJECT_NULL_STRING;
665 }
666 std::string raw_data(rawdata, len);
667 const std::string debug_string =
668 PyChannelUtils::get_debugstring_by_msgtype_rawmsgdata(msgtype, raw_data);
669 return C_STR_TO_PY_BYTES(debug_string);
670}

◆ cyber_PyChannelUtils_get_msg_type()

PyObject * cyber_PyChannelUtils_get_msg_type ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 636 行定义.

636 {
637 char *channel_name = nullptr;
638 Py_ssize_t len = 0;
639 unsigned char sleep_s = 0;
640 if (!PyArg_ParseTuple(
641 args, const_cast<char *>("s#B:cyber_PyChannelUtils_get_msg_type"),
642 &channel_name, &len, &sleep_s)) {
643 AERROR << "cyber_PyChannelUtils_get_msg_type failed!";
644 return PYOBJECT_NULL_STRING;
645 }
646 std::string channel(channel_name, len);
647 const std::string msg_type =
648 PyChannelUtils::get_msgtype_by_channelname(channel, sleep_s);
649 return C_STR_TO_PY_BYTES(msg_type);
650}

◆ cyber_PyClient_send_request()

PyObject * cyber_PyClient_send_request ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 303 行定义.

303 {
304 PyObject *pyobj_client = nullptr;
305 Py_buffer buffer;
306 // Py_ssize_t len = 0;
307 if (!PyArg_ParseTuple(args, const_cast<char *>("Oy*:PyClient_send_request"),
308 &pyobj_client, &buffer)) {
309 AERROR << "cyber_PyClient_send_request:PyArg_ParseTuple failed!";
310 PyBuffer_Release(&buffer);
311 return PYOBJECT_NULL_STRING;
312 }
313
314 PyClient *client =
315 PyObjectToPtr<PyClient *>(pyobj_client, "apollo_cyber_pyclient");
316
317 if (nullptr == client) {
318 AERROR << "cyber_PyClient_send_request:client ptr is null!";
319 PyBuffer_Release(&buffer);
320 return PYOBJECT_NULL_STRING;
321 }
322
323 std::string data_str(
324 const_cast<const char *>(static_cast<char *>(buffer.buf)), buffer.len);
325 ADEBUG << "c++:PyClient_send_request data->[ " << data_str << "]";
326 const std::string response_str =
327 client->send_request((std::string const &)data_str);
328 ADEBUG << "c++:response data->[ " << response_str << "]";
329 PyBuffer_Release(&buffer);
330 return C_STR_TO_PY_BYTES(response_str);
331}

◆ cyber_PyNode_create_client()

PyObject * cyber_PyNode_create_client ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 533 行定义.

533 {
534 char *channel_name = nullptr;
535 char *type_name = nullptr;
536 PyObject *pyobj_node = nullptr;
537
538 if (!PyArg_ParseTuple(args, const_cast<char *>("Oss:PyNode_create_client"),
539 &pyobj_node, &channel_name, &type_name)) {
540 AERROR << "PyNode_create_client:PyArg_ParseTuple failed!";
541 Py_INCREF(Py_None);
542 return Py_None;
543 }
544
545 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
546 if (nullptr == node) {
547 AERROR << "PyNode_create_client:node ptr is null!";
548 Py_INCREF(Py_None);
549 return Py_None;
550 }
551
552 PyClient *client = reinterpret_cast<PyClient *>((node->create_client(
553 (std::string const &)channel_name, (std::string const &)type_name)));
554 PyObject *pyobj_client =
555 PyCapsule_New(client, "apollo_cyber_pyclient", nullptr);
556
557 return pyobj_client;
558}

◆ cyber_PyNode_create_reader()

PyObject * cyber_PyNode_create_reader ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 505 行定义.

505 {
506 char *channel_name = nullptr;
507 char *type_name = nullptr;
508 PyObject *pyobj_node = nullptr;
509
510 if (!PyArg_ParseTuple(args, const_cast<char *>("Oss:PyNode_create_reader"),
511 &pyobj_node, &channel_name, &type_name)) {
512 AERROR << "PyNode_create_reader:PyArg_ParseTuple failed!";
513 Py_INCREF(Py_None);
514 return Py_None;
515 }
516
517 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
518 if (nullptr == node) {
519 AERROR << "PyNode_create_reader:node ptr is null!";
520 Py_INCREF(Py_None);
521 return Py_None;
522 }
523
524 PyReader *reader = reinterpret_cast<PyReader *>((node->create_reader(
525 (std::string const &)channel_name, (std::string const &)type_name)));
526 ACHECK(reader) << "PyReader is NULL!";
527
528 PyObject *pyobj_reader =
529 PyCapsule_New(reader, "apollo_cyber_pyreader", nullptr);
530 return pyobj_reader;
531}

◆ cyber_PyNode_create_service()

PyObject * cyber_PyNode_create_service ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 560 行定义.

560 {
561 char *channel_name = nullptr;
562 char *type_name = nullptr;
563 PyObject *pyobj_node = nullptr;
564
565 if (!PyArg_ParseTuple(args,
566 const_cast<char *>("Oss:cyber_PyNode_create_service"),
567 &pyobj_node, &channel_name, &type_name)) {
568 AERROR << "cyber_PyNode_create_service:PyArg_ParseTuple failed!";
569 Py_INCREF(Py_None);
570 return Py_None;
571 }
572
573 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
574 if (nullptr == node) {
575 AERROR << "cyber_PyNode_create_service:node ptr is null!";
576 Py_INCREF(Py_None);
577 return Py_None;
578 }
579
580 PyService *service = reinterpret_cast<PyService *>((node->create_service(
581 (std::string const &)channel_name, (std::string const &)type_name)));
582 PyObject *pyobj_service =
583 PyCapsule_New(service, "apollo_cyber_pyservice", nullptr);
584 return pyobj_service;
585}

◆ cyber_PyNode_create_writer()

PyObject * cyber_PyNode_create_writer ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 471 行定义.

471 {
472 PyObject *pyobj_node = nullptr;
473 char *channel_name = nullptr;
474 char *type_name = nullptr;
475 uint32_t qos_depth = 1;
476
477 if (!PyArg_ParseTuple(args, const_cast<char *>("OssI:PyNode_create_writer"),
478 &pyobj_node, &channel_name, &type_name, &qos_depth)) {
479 AERROR << "cyber_PyNode_create_writer:PyArg_ParseTuple failed!";
480 Py_INCREF(Py_None);
481 return Py_None;
482 }
483
484 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
485 if (nullptr == node) {
486 AERROR << "cyber_PyNode_create_writer:node ptr is null!";
487 Py_INCREF(Py_None);
488 return Py_None;
489 }
490
491 PyWriter *writer = reinterpret_cast<PyWriter *>(
492 (node->create_writer((std::string const &)channel_name,
493 (std::string const &)type_name, qos_depth)));
494
495 if (nullptr == writer) {
496 AERROR << "cyber_PyNode_create_writer:writer is null!";
497 Py_INCREF(Py_None);
498 return Py_None;
499 }
500 PyObject *pyobj_writer =
501 PyCapsule_New(writer, "apollo_cyber_pywriter", nullptr);
502 return pyobj_writer;
503}

◆ cyber_PyNode_register_message()

PyObject * cyber_PyNode_register_message ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 608 行定义.

608 {
609 PyObject *pyobj_node = nullptr;
610 Py_buffer buffer;
611 // int len = 0;
612 if (!PyArg_ParseTuple(args,
613 const_cast<char *>("Oy*:cyber_PyNode_register_message"),
614 &pyobj_node, &buffer)) {
615 AERROR << "cyber_PyNode_register_message: failed!";
616 Py_INCREF(Py_None);
617 PyBuffer_Release(&buffer);
618 return Py_None;
619 }
620 std::string desc_str(
621 const_cast<const char *>(static_cast<char *>(buffer.buf)), buffer.len);
622 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
623 if (nullptr == node) {
624 AERROR << "cyber_PyNode_register_message:node ptr is null! desc->"
625 << desc_str;
626 Py_INCREF(Py_None);
627 PyBuffer_Release(&buffer);
628 return Py_None;
629 }
630 node->register_message((std::string const &)desc_str);
631 Py_INCREF(Py_None);
632 PyBuffer_Release(&buffer);
633 return Py_None;
634}

◆ cyber_PyNode_shutdown()

PyObject * cyber_PyNode_shutdown ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 587 行定义.

587 {
588 PyObject *pyobj_node = nullptr;
589
590 if (!PyArg_ParseTuple(args, const_cast<char *>("O:PyNode_shutdown"),
591 &pyobj_node)) {
592 AERROR << "cyber_PyNode_shutdown:PyNode_shutdown failed!";
593 Py_INCREF(Py_None);
594 return Py_None;
595 }
596
597 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
598 if (nullptr == node) {
599 AERROR << "cyber_PyNode_shutdown:node ptr is null!";
600 Py_INCREF(Py_None);
601 return Py_None;
602 }
603 node->shutdown();
604 Py_INCREF(Py_None);
605 return Py_None;
606}

◆ cyber_PyNodeUtils_get_active_nodes()

PyObject * cyber_PyNodeUtils_get_active_nodes ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 721 行定义.

721 {
722 unsigned char sleep_s = 0;
723 if (!PyArg_ParseTuple(
724 args, const_cast<char *>("B:cyber_PyNodeUtils_get_active_nodes"),
725 &sleep_s)) {
726 AERROR << "cyber_PyNodeUtils_get_active_nodes failed!";
727 Py_INCREF(Py_None);
728 return Py_None;
729 }
730
731 std::vector<std::string> nodes_name =
732 apollo::cyber::PyNodeUtils::get_active_nodes(sleep_s);
733 PyObject *pyobj_list = PyList_New(nodes_name.size());
734 size_t pos = 0;
735 for (const std::string &name : nodes_name) {
736 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", name.c_str()));
737 pos++;
738 }
739
740 return pyobj_list;
741}

◆ cyber_PyNodeUtils_get_node_attr()

PyObject * cyber_PyNodeUtils_get_node_attr ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 743 行定义.

743 {
744 char *node_name = nullptr;
745 Py_ssize_t len = 0;
746 unsigned char sleep_s = 0;
747 if (!PyArg_ParseTuple(
748 args, const_cast<char *>("s#B:cyber_PyNodeUtils_get_node_attr"),
749 &node_name, &len, &sleep_s)) {
750 AERROR << "cyber_PyNodeUtils_get_node_attr failed!";
751 Py_INCREF(Py_None);
752 return Py_None;
753 }
754 std::string name(node_name, len);
755 const std::string node_attr =
756 apollo::cyber::PyNodeUtils::get_node_attr(name, sleep_s);
757 return C_STR_TO_PY_BYTES(node_attr);
758}

◆ cyber_PyNodeUtils_get_readersofnode()

PyObject * cyber_PyNodeUtils_get_readersofnode ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 760 行定义.

760 {
761 char *node_name = nullptr;
762 Py_ssize_t len = 0;
763 unsigned char sleep_s = 0;
764 if (!PyArg_ParseTuple(
765 args, const_cast<char *>("s#B:cyber_PyNodeUtils_get_readersofnode"),
766 &node_name, &len, &sleep_s)) {
767 AERROR << "cyber_PyNodeUtils_get_readersofnode failed!";
768 Py_INCREF(Py_None);
769 return Py_None;
770 }
771 std::string name(node_name, len);
772 std::vector<std::string> readers_channel =
773 apollo::cyber::PyNodeUtils::get_readersofnode(name, sleep_s);
774 PyObject *pyobj_list = PyList_New(readers_channel.size());
775 size_t pos = 0;
776 for (const std::string &channel : readers_channel) {
777 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", channel.c_str()));
778 pos++;
779 }
780
781 return pyobj_list;
782}

◆ cyber_PyNodeUtils_get_writersofnode()

PyObject * cyber_PyNodeUtils_get_writersofnode ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 784 行定义.

784 {
785 char *node_name = nullptr;
786 Py_ssize_t len = 0;
787 unsigned char sleep_s = 0;
788 if (!PyArg_ParseTuple(
789 args, const_cast<char *>("s#B:cyber_PyNodeUtils_get_writersofnode"),
790 &node_name, &len, &sleep_s)) {
791 AERROR << "cyber_PyNodeUtils_get_writersofnode failed!";
792 Py_INCREF(Py_None);
793 return Py_None;
794 }
795 std::string name(node_name, len);
796 std::vector<std::string> writers_channel =
797 apollo::cyber::PyNodeUtils::get_writersofnode(name, sleep_s);
798 PyObject *pyobj_list = PyList_New(writers_channel.size());
799 size_t pos = 0;
800 for (const std::string &channel : writers_channel) {
801 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", channel.c_str()));
802 pos++;
803 }
804
805 return pyobj_list;
806}

◆ cyber_PyReader_read()

PyObject * cyber_PyReader_read ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 208 行定义.

208 {
209 PyObject *pyobj_reader = nullptr;
210 PyObject *pyobj_iswait = nullptr;
211
212 if (!PyArg_ParseTuple(args, const_cast<char *>("OO:cyber_PyReader_read"),
213 &pyobj_reader, &pyobj_iswait)) {
214 AERROR << "cyber_PyReader_read:PyArg_ParseTuple failed!";
215 Py_INCREF(Py_None);
216 return Py_None;
217 }
218 PyReader *reader =
219 PyObjectToPtr<PyReader *>(pyobj_reader, "apollo_cyber_pyreader");
220 if (nullptr == reader) {
221 AERROR << "cyber_PyReader_read:PyReader ptr is null!";
222 Py_INCREF(Py_None);
223 return Py_None;
224 }
225
226 int r = PyObject_IsTrue(pyobj_iswait);
227 if (r == -1) {
228 AERROR << "cyber_PyReader_read:pyobj_iswait is error!";
229 Py_INCREF(Py_None);
230 return Py_None;
231 }
232
233 bool wait = (r == 1);
234
235 const std::string reader_ret = reader->read(wait);
236 return C_STR_TO_PY_BYTES(reader_ret);
237}

◆ cyber_PyReader_register_func()

PyObject * cyber_PyReader_register_func ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 239 行定义.

239 {
240 PyObject *pyobj_regist_fun = nullptr;
241 PyObject *pyobj_reader = nullptr;
242
243 int (*callback_fun)(char const *) = (int (*)(char const *))0;
244
245 if (!PyArg_ParseTuple(args, const_cast<char *>("OO:PyReader_register_func"),
246 &pyobj_reader, &pyobj_regist_fun)) {
247 Py_INCREF(Py_None);
248 return Py_None;
249 }
250
251 PyReader *reader =
252 PyObjectToPtr<PyReader *>(pyobj_reader, "apollo_cyber_pyreader");
253 callback_fun = (int (*)(const char *i))PyInt_AsLong(pyobj_regist_fun);
254 if (reader) {
255 AINFO << "reader regist fun";
256 reader->register_func(callback_fun);
257 }
258
259 Py_INCREF(Py_None);
260 return Py_None;
261}

◆ cyber_PyService_read()

PyObject * cyber_PyService_read ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 397 行定义.

397 {
398 PyObject *pyobj_service = nullptr;
399 if (!PyArg_ParseTuple(args, const_cast<char *>("O:cyber_PyService_read"),
400 &pyobj_service)) {
401 AERROR << "cyber_PyService_read:PyArg_ParseTuple failed!";
402 return PYOBJECT_NULL_STRING;
403 }
404 PyService *service =
405 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
406 if (nullptr == service) {
407 AERROR << "cyber_PyService_read:service ptr is null!";
408 return PYOBJECT_NULL_STRING;
409 }
410
411 const std::string reader_ret = service->read();
412 ADEBUG << "c++:PyService_read -> " << reader_ret;
413 return C_STR_TO_PY_BYTES(reader_ret);
414}

◆ cyber_PyService_register_func()

PyObject * cyber_PyService_register_func ( PyObject *  self,
PyObject *  args 
)

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

373 {
374 PyObject *pyobj_regist_fun = nullptr;
375 PyObject *pyobj_service = nullptr;
376
377 int (*callback_fun)(char const *) = (int (*)(char const *))0;
378
379 if (!PyArg_ParseTuple(args, const_cast<char *>("OO:PyService_register_func"),
380 &pyobj_service, &pyobj_regist_fun)) {
381 Py_INCREF(Py_None);
382 return Py_None;
383 }
384
385 PyService *service =
386 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
387 callback_fun = (int (*)(const char *i))PyInt_AsLong(pyobj_regist_fun);
388 if (service) {
389 AINFO << "service regist fun";
390 service->register_func(callback_fun);
391 }
392
393 Py_INCREF(Py_None);
394 return Py_None;
395}

◆ cyber_PyService_write()

PyObject * cyber_PyService_write ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 416 行定义.

416 {
417 PyObject *pyobj_service = nullptr;
418 Py_buffer buffer;
419 // Py_ssize_t len = 0;
420 if (!PyArg_ParseTuple(args, const_cast<char *>("Oy*:cyber_PyService_write"),
421 &pyobj_service, &buffer)) {
422 AERROR << "cyber_PyService_write:PyArg_ParseTuple failed!";
423 PyBuffer_Release(&buffer);
424 return PyInt_FromLong(1);
425 }
426
427 PyService *service =
428 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
429
430 if (nullptr == service) {
431 AERROR << "cyber_PyService_write:writer ptr is null!";
432 PyBuffer_Release(&buffer);
433 return PyInt_FromLong(1);
434 }
435
436 std::string data_str(
437 const_cast<const char *>(static_cast<char *>(buffer.buf)), buffer.len);
438 ADEBUG << "c++:PyService_write data->[ " << data_str << "]";
439 int ret = service->write((std::string const &)data_str);
440 PyBuffer_Release(&buffer);
441 return PyInt_FromLong(ret);
442}

◆ cyber_PyServiceUtils_get_active_services()

PyObject * cyber_PyServiceUtils_get_active_services ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 808 行定义.

809 {
810 unsigned char sleep_s = 0;
811 if (!PyArg_ParseTuple(
812 args,
813 const_cast<char *>("B:cyber_PyServiceUtils_get_active_services"),
814 &sleep_s)) {
815 AERROR << "cyber_PyServiceUtils_get_active_services failed!";
816 Py_INCREF(Py_None);
817 return Py_None;
818 }
819
820 std::vector<std::string> services_name =
821 PyServiceUtils::get_active_services(sleep_s);
822 PyObject *pyobj_list = PyList_New(services_name.size());
823 size_t pos = 0;
824 for (const std::string &name : services_name) {
825 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", name.c_str()));
826 pos++;
827 }
828
829 return pyobj_list;
830}

◆ cyber_PyServiceUtils_get_service_attr()

PyObject * cyber_PyServiceUtils_get_service_attr ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 832 行定义.

833 {
834 char *srv_name = nullptr;
835 Py_ssize_t len = 0;
836 unsigned char sleep_s = 0;
837 if (!PyArg_ParseTuple(
838 args, const_cast<char *>("s#B:cyber_PyServiceUtils_get_service_attr"),
839 &srv_name, &len, &sleep_s)) {
840 AERROR << "cyber_PyServiceUtils_get_service_attr failed!";
841 Py_INCREF(Py_None);
842 return Py_None;
843 }
844 std::string name(srv_name, len);
845 const std::string srv_attr = PyServiceUtils::get_service_attr(name, sleep_s);
846 return C_STR_TO_PY_BYTES(srv_attr);
847}

◆ cyber_PyWriter_write()

PyObject * cyber_PyWriter_write ( PyObject *  self,
PyObject *  args 
)

在文件 py_cyber.cc 第 141 行定义.

141 {
142 PyObject *pyobj_writer = nullptr;
143 Py_buffer buffer;
144 // Py_ssize_t len = 0;
145 if (!PyArg_ParseTuple(args, const_cast<char *>("Oy*:cyber_PyWriter_write"),
146 &pyobj_writer, &buffer)) {
147 AERROR << "cyber_PyWriter_write:cyber_PyWriter_write failed!";
148 PyBuffer_Release(&buffer);
149 return PyInt_FromLong(1);
150 }
151
152 PyWriter *writer =
153 PyObjectToPtr<PyWriter *>(pyobj_writer, "apollo_cyber_pywriter");
154
155 if (nullptr == writer) {
156 AERROR << "cyber_PyWriter_write:writer ptr is null!";
157 PyBuffer_Release(&buffer);
158 return PyInt_FromLong(1);
159 }
160
161 std::string data_str(
162 const_cast<const char *>(static_cast<char *>(buffer.buf)), buffer.len);
163 int ret = writer->write(data_str);
164 PyBuffer_Release(&buffer);
165 return PyInt_FromLong(ret);
166}

◆ PyInit__cyber_wrapper()

PyMODINIT_FUNC PyInit__cyber_wrapper ( void  )

Init function of this module

在文件 py_cyber.cc 第 921 行定义.

921 {
922 static struct PyModuleDef module_def = {
923 PyModuleDef_HEAD_INIT,
924 "_cyber_wrapper", // Module name.
925 "Cyber module", // Module doc.
926 -1, // Module size.
927 _cyber_methods, // Module methods.
928 nullptr,
929 nullptr,
930 nullptr,
931 nullptr,
932 };
933
934 return PyModule_Create(&module_def);
935}

◆ PyObjectToPtr()

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

在文件 py_cyber.cc 第 89 行定义.

89 {
90 T obj_ptr = (T)PyCapsule_GetPointer(pyobj, type_ptr.c_str());
91 if (obj_ptr == nullptr) {
92 AERROR << "PyObjectToPtr failed,type->" << type_ptr << " "
93 << "pyobj: " << pyobj;
94 }
95 return obj_ptr;
96}