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

◆ 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 第 283 行定义.

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

◆ cyber_delete_PyNode()

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

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

443 {
444 PyObject *pyobj_node = nullptr;
445 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyNode"),
446 &pyobj_node)) {
447 Py_INCREF(Py_None);
448 return Py_None;
449 }
450
451 PyNode *node = reinterpret_cast<PyNode *>(
452 PyCapsule_GetPointer(pyobj_node, "apollo_cyber_pynode"));
453 delete node;
454 Py_INCREF(Py_None);
455 return Py_None;
456}

◆ cyber_delete_PyReader()

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

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

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

◆ cyber_delete_PyService()

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

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

349 {
350 PyObject *pyobj_service = nullptr;
351 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyService"),
352 &pyobj_service)) {
353 Py_INCREF(Py_None);
354 return Py_None;
355 }
356
357 PyService *service = reinterpret_cast<PyService *>(
358 PyCapsule_GetPointer(pyobj_service, "apollo_cyber_pyservice"));
359 delete service;
360 Py_INCREF(Py_None);
361 return Py_None;
362}

◆ cyber_delete_PyWriter()

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

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

125 {
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}

◆ cyber_new_PyClient()

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

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

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

◆ cyber_new_PyNode()

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

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

431 {
432 char *node_name = nullptr;
433 if (!PyArg_ParseTuple(args, const_cast<char *>("s:new_PyNode"), &node_name)) {
434 Py_INCREF(Py_None);
435 return Py_None;
436 }
437
438 PyNode *node = new PyNode((std::string const &)node_name);
439 PyObject *pyobj_node = PyCapsule_New(node, "apollo_cyber_pynode", nullptr);
440 return pyobj_node;
441}

◆ cyber_new_PyReader()

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

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

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

◆ cyber_new_PyService()

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

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

324 {
325 char *channel_name = nullptr;
326 char *data_type = nullptr;
327 PyObject *node_pyobj = nullptr;
328 if (!PyArg_ParseTuple(args, const_cast<char *>("ssO:new_PyService"),
329 &channel_name, &data_type, &node_pyobj)) {
330 Py_INCREF(Py_None);
331 return Py_None;
332 }
333
334 Node *node = reinterpret_cast<Node *>(
335 PyCapsule_GetPointer(node_pyobj, "apollo_cyber_pynode"));
336 if (!node) {
337 AERROR << "node is null";
338 Py_INCREF(Py_None);
339 return Py_None;
340 }
341
342 PyService *service = new PyService((std::string const &)*channel_name,
343 (std::string const &)*data_type, node);
344 PyObject *pyobj_service =
345 PyCapsule_New(service, "apollo_cyber_pyservice", nullptr);
346 return pyobj_service;
347}

◆ cyber_new_PyWriter()

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

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

97 {
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}

◆ cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata()

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

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

635 {
636 char *msgtype = nullptr;
637 char *rawdata = nullptr;
638 Py_ssize_t len = 0;
639 if (!PyArg_ParseTuple(
640 args,
641 const_cast<char *>(
642 "ss#:cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata"),
643 &msgtype, &rawdata, &len)) {
644 AERROR
645 << "cyber_PyChannelUtils_get_debugstring_by_msgtype_rawmsgdata failed!";
646 return PYOBJECT_NULL_STRING;
647 }
648 std::string raw_data(rawdata, len);
649 const std::string debug_string =
650 PyChannelUtils::get_debugstring_by_msgtype_rawmsgdata(msgtype, raw_data);
651 return C_STR_TO_PY_BYTES(debug_string);
652}

◆ cyber_PyChannelUtils_get_msg_type()

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

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

618 {
619 char *channel_name = nullptr;
620 Py_ssize_t len = 0;
621 unsigned char sleep_s = 0;
622 if (!PyArg_ParseTuple(
623 args, const_cast<char *>("s#B:cyber_PyChannelUtils_get_msg_type"),
624 &channel_name, &len, &sleep_s)) {
625 AERROR << "cyber_PyChannelUtils_get_msg_type failed!";
626 return PYOBJECT_NULL_STRING;
627 }
628 std::string channel(channel_name, len);
629 const std::string msg_type =
630 PyChannelUtils::get_msgtype_by_channelname(channel, sleep_s);
631 return C_STR_TO_PY_BYTES(msg_type);
632}

◆ cyber_PyClient_send_request()

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

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

298 {
299 PyObject *pyobj_client = nullptr;
300 char *data = nullptr;
301 Py_ssize_t len = 0;
302 if (!PyArg_ParseTuple(args, const_cast<char *>("Os#:PyClient_send_request"),
303 &pyobj_client, &data, &len)) {
304 AERROR << "cyber_PyClient_send_request:PyArg_ParseTuple failed!";
305 return PYOBJECT_NULL_STRING;
306 }
307
308 PyClient *client =
309 PyObjectToPtr<PyClient *>(pyobj_client, "apollo_cyber_pyclient");
310
311 if (nullptr == client) {
312 AERROR << "cyber_PyClient_send_request:client ptr is null!";
313 return PYOBJECT_NULL_STRING;
314 }
315
316 std::string data_str(data, len);
317 ADEBUG << "c++:PyClient_send_request data->[ " << data_str << "]";
318 const std::string response_str =
319 client->send_request((std::string const &)data_str);
320 ADEBUG << "c++:response data->[ " << response_str << "]";
321 return C_STR_TO_PY_BYTES(response_str);
322}

◆ cyber_PyNode_create_client()

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

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

520 {
521 char *channel_name = nullptr;
522 char *type_name = nullptr;
523 PyObject *pyobj_node = nullptr;
524
525 if (!PyArg_ParseTuple(args, const_cast<char *>("Oss:PyNode_create_client"),
526 &pyobj_node, &channel_name, &type_name)) {
527 AERROR << "PyNode_create_client:PyArg_ParseTuple failed!";
528 Py_INCREF(Py_None);
529 return Py_None;
530 }
531
532 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
533 if (nullptr == node) {
534 AERROR << "PyNode_create_client:node ptr is null!";
535 Py_INCREF(Py_None);
536 return Py_None;
537 }
538
539 PyClient *client = reinterpret_cast<PyClient *>((node->create_client(
540 (std::string const &)channel_name, (std::string const &)type_name)));
541 PyObject *pyobj_client =
542 PyCapsule_New(client, "apollo_cyber_pyclient", nullptr);
543
544 return pyobj_client;
545}

◆ cyber_PyNode_create_reader()

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

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

492 {
493 char *channel_name = nullptr;
494 char *type_name = nullptr;
495 PyObject *pyobj_node = nullptr;
496
497 if (!PyArg_ParseTuple(args, const_cast<char *>("Oss:PyNode_create_reader"),
498 &pyobj_node, &channel_name, &type_name)) {
499 AERROR << "PyNode_create_reader:PyArg_ParseTuple failed!";
500 Py_INCREF(Py_None);
501 return Py_None;
502 }
503
504 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
505 if (nullptr == node) {
506 AERROR << "PyNode_create_reader:node ptr is null!";
507 Py_INCREF(Py_None);
508 return Py_None;
509 }
510
511 PyReader *reader = reinterpret_cast<PyReader *>((node->create_reader(
512 (std::string const &)channel_name, (std::string const &)type_name)));
513 ACHECK(reader) << "PyReader is NULL!";
514
515 PyObject *pyobj_reader =
516 PyCapsule_New(reader, "apollo_cyber_pyreader", nullptr);
517 return pyobj_reader;
518}

◆ cyber_PyNode_create_service()

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

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

547 {
548 char *channel_name = nullptr;
549 char *type_name = nullptr;
550 PyObject *pyobj_node = nullptr;
551
552 if (!PyArg_ParseTuple(args,
553 const_cast<char *>("Oss:cyber_PyNode_create_service"),
554 &pyobj_node, &channel_name, &type_name)) {
555 AERROR << "cyber_PyNode_create_service:PyArg_ParseTuple failed!";
556 Py_INCREF(Py_None);
557 return Py_None;
558 }
559
560 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
561 if (nullptr == node) {
562 AERROR << "cyber_PyNode_create_service:node ptr is null!";
563 Py_INCREF(Py_None);
564 return Py_None;
565 }
566
567 PyService *service = reinterpret_cast<PyService *>((node->create_service(
568 (std::string const &)channel_name, (std::string const &)type_name)));
569 PyObject *pyobj_service =
570 PyCapsule_New(service, "apollo_cyber_pyservice", nullptr);
571 return pyobj_service;
572}

◆ cyber_PyNode_create_writer()

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

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

458 {
459 PyObject *pyobj_node = nullptr;
460 char *channel_name = nullptr;
461 char *type_name = nullptr;
462 uint32_t qos_depth = 1;
463
464 if (!PyArg_ParseTuple(args, const_cast<char *>("OssI:PyNode_create_writer"),
465 &pyobj_node, &channel_name, &type_name, &qos_depth)) {
466 AERROR << "cyber_PyNode_create_writer:PyArg_ParseTuple failed!";
467 Py_INCREF(Py_None);
468 return Py_None;
469 }
470
471 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
472 if (nullptr == node) {
473 AERROR << "cyber_PyNode_create_writer:node ptr is null!";
474 Py_INCREF(Py_None);
475 return Py_None;
476 }
477
478 PyWriter *writer = reinterpret_cast<PyWriter *>(
479 (node->create_writer((std::string const &)channel_name,
480 (std::string const &)type_name, qos_depth)));
481
482 if (nullptr == writer) {
483 AERROR << "cyber_PyNode_create_writer:writer is null!";
484 Py_INCREF(Py_None);
485 return Py_None;
486 }
487 PyObject *pyobj_writer =
488 PyCapsule_New(writer, "apollo_cyber_pywriter", nullptr);
489 return pyobj_writer;
490}

◆ cyber_PyNode_register_message()

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

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

595 {
596 PyObject *pyobj_node = nullptr;
597 char *desc = nullptr;
598 int len = 0;
599 if (!PyArg_ParseTuple(args,
600 const_cast<char *>("Os#:cyber_PyNode_register_message"),
601 &pyobj_node, &desc, &len)) {
602 AERROR << "cyber_PyNode_register_message: failed!";
603 Py_INCREF(Py_None);
604 return Py_None;
605 }
606 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
607 if (nullptr == node) {
608 AERROR << "cyber_PyNode_register_message:node ptr is null! desc->" << desc;
609 Py_INCREF(Py_None);
610 return Py_None;
611 }
612 std::string desc_str(desc, len);
613 node->register_message((std::string const &)desc_str);
614 Py_INCREF(Py_None);
615 return Py_None;
616}

◆ cyber_PyNode_shutdown()

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

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

574 {
575 PyObject *pyobj_node = nullptr;
576
577 if (!PyArg_ParseTuple(args, const_cast<char *>("O:PyNode_shutdown"),
578 &pyobj_node)) {
579 AERROR << "cyber_PyNode_shutdown:PyNode_shutdown failed!";
580 Py_INCREF(Py_None);
581 return Py_None;
582 }
583
584 PyNode *node = PyObjectToPtr<PyNode *>(pyobj_node, "apollo_cyber_pynode");
585 if (nullptr == node) {
586 AERROR << "cyber_PyNode_shutdown:node ptr is null!";
587 Py_INCREF(Py_None);
588 return Py_None;
589 }
590 node->shutdown();
591 Py_INCREF(Py_None);
592 return Py_None;
593}

◆ cyber_PyNodeUtils_get_active_nodes()

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

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

703 {
704 unsigned char sleep_s = 0;
705 if (!PyArg_ParseTuple(
706 args, const_cast<char *>("B:cyber_PyNodeUtils_get_active_nodes"),
707 &sleep_s)) {
708 AERROR << "cyber_PyNodeUtils_get_active_nodes failed!";
709 Py_INCREF(Py_None);
710 return Py_None;
711 }
712
713 std::vector<std::string> nodes_name =
714 apollo::cyber::PyNodeUtils::get_active_nodes(sleep_s);
715 PyObject *pyobj_list = PyList_New(nodes_name.size());
716 size_t pos = 0;
717 for (const std::string &name : nodes_name) {
718 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", name.c_str()));
719 pos++;
720 }
721
722 return pyobj_list;
723}

◆ cyber_PyNodeUtils_get_node_attr()

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

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

725 {
726 char *node_name = nullptr;
727 Py_ssize_t len = 0;
728 unsigned char sleep_s = 0;
729 if (!PyArg_ParseTuple(
730 args, const_cast<char *>("s#B:cyber_PyNodeUtils_get_node_attr"),
731 &node_name, &len, &sleep_s)) {
732 AERROR << "cyber_PyNodeUtils_get_node_attr failed!";
733 Py_INCREF(Py_None);
734 return Py_None;
735 }
736 std::string name(node_name, len);
737 const std::string node_attr =
738 apollo::cyber::PyNodeUtils::get_node_attr(name, sleep_s);
739 return C_STR_TO_PY_BYTES(node_attr);
740}

◆ cyber_PyNodeUtils_get_readersofnode()

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

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

742 {
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_readersofnode"),
748 &node_name, &len, &sleep_s)) {
749 AERROR << "cyber_PyNodeUtils_get_readersofnode failed!";
750 Py_INCREF(Py_None);
751 return Py_None;
752 }
753 std::string name(node_name, len);
754 std::vector<std::string> readers_channel =
755 apollo::cyber::PyNodeUtils::get_readersofnode(name, sleep_s);
756 PyObject *pyobj_list = PyList_New(readers_channel.size());
757 size_t pos = 0;
758 for (const std::string &channel : readers_channel) {
759 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", channel.c_str()));
760 pos++;
761 }
762
763 return pyobj_list;
764}

◆ cyber_PyNodeUtils_get_writersofnode()

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

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

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

◆ cyber_PyReader_read()

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

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

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

◆ cyber_PyReader_register_func()

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

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

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

◆ cyber_PyService_read()

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

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

388 {
389 PyObject *pyobj_service = nullptr;
390 if (!PyArg_ParseTuple(args, const_cast<char *>("O:cyber_PyService_read"),
391 &pyobj_service)) {
392 AERROR << "cyber_PyService_read:PyArg_ParseTuple failed!";
393 return PYOBJECT_NULL_STRING;
394 }
395 PyService *service =
396 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
397 if (nullptr == service) {
398 AERROR << "cyber_PyService_read:service ptr is null!";
399 return PYOBJECT_NULL_STRING;
400 }
401
402 const std::string reader_ret = service->read();
403 ADEBUG << "c++:PyService_read -> " << reader_ret;
404 return C_STR_TO_PY_BYTES(reader_ret);
405}

◆ cyber_PyService_register_func()

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

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

364 {
365 PyObject *pyobj_regist_fun = nullptr;
366 PyObject *pyobj_service = nullptr;
367
368 int (*callback_fun)(char const *) = (int (*)(char const *))0;
369
370 if (!PyArg_ParseTuple(args, const_cast<char *>("OO:PyService_register_func"),
371 &pyobj_service, &pyobj_regist_fun)) {
372 Py_INCREF(Py_None);
373 return Py_None;
374 }
375
376 PyService *service =
377 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
378 callback_fun = (int (*)(const char *i))PyInt_AsLong(pyobj_regist_fun);
379 if (service) {
380 AINFO << "service regist fun";
381 service->register_func(callback_fun);
382 }
383
384 Py_INCREF(Py_None);
385 return Py_None;
386}

◆ cyber_PyService_write()

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

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

407 {
408 PyObject *pyobj_service = nullptr;
409 char *data = nullptr;
410 Py_ssize_t len = 0;
411 if (!PyArg_ParseTuple(args, const_cast<char *>("Os#:cyber_PyService_write"),
412 &pyobj_service, &data, &len)) {
413 AERROR << "cyber_PyService_write:PyArg_ParseTuple failed!";
414 return PyInt_FromLong(1);
415 }
416
417 PyService *service =
418 PyObjectToPtr<PyService *>(pyobj_service, "apollo_cyber_pyservice");
419
420 if (nullptr == service) {
421 AERROR << "cyber_PyService_write:writer ptr is null!";
422 return PyInt_FromLong(1);
423 }
424
425 std::string data_str(data, len);
426 ADEBUG << "c++:PyService_write data->[ " << data_str << "]";
427 int ret = service->write((std::string const &)data_str);
428 return PyInt_FromLong(ret);
429}

◆ cyber_PyServiceUtils_get_active_services()

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

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

791 {
792 unsigned char sleep_s = 0;
793 if (!PyArg_ParseTuple(
794 args,
795 const_cast<char *>("B:cyber_PyServiceUtils_get_active_services"),
796 &sleep_s)) {
797 AERROR << "cyber_PyServiceUtils_get_active_services failed!";
798 Py_INCREF(Py_None);
799 return Py_None;
800 }
801
802 std::vector<std::string> services_name =
803 PyServiceUtils::get_active_services(sleep_s);
804 PyObject *pyobj_list = PyList_New(services_name.size());
805 size_t pos = 0;
806 for (const std::string &name : services_name) {
807 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", name.c_str()));
808 pos++;
809 }
810
811 return pyobj_list;
812}

◆ cyber_PyServiceUtils_get_service_attr()

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

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

815 {
816 char *srv_name = nullptr;
817 Py_ssize_t len = 0;
818 unsigned char sleep_s = 0;
819 if (!PyArg_ParseTuple(
820 args, const_cast<char *>("s#B:cyber_PyServiceUtils_get_service_attr"),
821 &srv_name, &len, &sleep_s)) {
822 AERROR << "cyber_PyServiceUtils_get_service_attr failed!";
823 Py_INCREF(Py_None);
824 return Py_None;
825 }
826 std::string name(srv_name, len);
827 const std::string srv_attr = PyServiceUtils::get_service_attr(name, sleep_s);
828 return C_STR_TO_PY_BYTES(srv_attr);
829}

◆ cyber_PyWriter_write()

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

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

140 {
141 PyObject *pyobj_writer = nullptr;
142 char *data = nullptr;
143 Py_ssize_t len = 0;
144 if (!PyArg_ParseTuple(args, const_cast<char *>("Os#:cyber_PyWriter_write"),
145 &pyobj_writer, &data, &len)) {
146 AERROR << "cyber_PyWriter_write:cyber_PyWriter_write failed!";
147 return PyInt_FromLong(1);
148 }
149
150 PyWriter *writer =
151 PyObjectToPtr<PyWriter *>(pyobj_writer, "apollo_cyber_pywriter");
152
153 if (nullptr == writer) {
154 AERROR << "cyber_PyWriter_write:writer ptr is null!";
155 return PyInt_FromLong(1);
156 }
157
158 std::string data_str(data, len);
159 int ret = writer->write(data_str);
160 return PyInt_FromLong(ret);
161}

◆ PyInit__cyber_wrapper()

PyMODINIT_FUNC PyInit__cyber_wrapper ( void  )

Init function of this module

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

903 {
904 static struct PyModuleDef module_def = {
905 PyModuleDef_HEAD_INIT,
906 "_cyber_wrapper", // Module name.
907 "Cyber module", // Module doc.
908 -1, // Module size.
909 _cyber_methods, // Module methods.
910 nullptr,
911 nullptr,
912 nullptr,
913 nullptr,
914 };
915
916 return PyModule_Create(&module_def);
917}

◆ 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 << "pyobj: " << pyobj;
93 }
94 return obj_ptr;
95}