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

浏览源代码.

宏定义

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

函数

template<typename T >
T PyObjectToPtr (PyObject *pyobj, const std::string &type_ptr)
 
PyObject * cyber_new_PyRecordReader (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyRecordReader (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordReader_ReadMessage (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordReader_GetMessageNumber (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordReader_GetMessageType (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordReader_GetProtoDesc (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordReader_GetHeaderString (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordReader_Reset (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordReader_GetChannelList (PyObject *self, PyObject *args)
 
PyObject * cyber_new_PyRecordWriter (PyObject *self, PyObject *args)
 
PyObject * cyber_delete_PyRecordWriter (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_Open (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_Close (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_WriteChannel (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_WriteMessage (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_SetSizeOfFileSegmentation (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_SetIntervalOfFileSegmentation (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_GetMessageNumber (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_GetMessageType (PyObject *self, PyObject *args)
 
PyObject * cyber_PyRecordWriter_GetProtoDesc (PyObject *self, PyObject *args)
 
PyMODINIT_FUNC PyInit__cyber_record_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_record.cc 第 28 行定义.

31 {
32 T obj_ptr = (T)PyCapsule_GetPointer(pyobj, type_ptr.c_str());
33 if (obj_ptr == nullptr) {
34 AERROR << "PyObjectToPtr failed,type->" << type_ptr << "pyobj: " << pyobj;
35 }
36 return obj_ptr;
37}
38
39PyObject *cyber_new_PyRecordReader(PyObject *self, PyObject *args) {
40 char *filepath = nullptr;
41 Py_ssize_t len = 0;
42 if (!PyArg_ParseTuple(args, const_cast<char *>("s#:new_PyRecordReader"),
43 &filepath, &len)) {
44 AERROR << "cyber_new_PyRecordReader parsetuple failed!";
45 Py_INCREF(Py_None);
46 return Py_None;
47 }
48
49 PyRecordReader *reader = new PyRecordReader(std::string(filepath, len));
50 return PyCapsule_New(reader, "apollo_cyber_record_pyrecordfilereader",
51 nullptr);
52}
53
54PyObject *cyber_delete_PyRecordReader(PyObject *self, PyObject *args) {
55 PyObject *pyobj_rec_reader = nullptr;
56 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyRecordReader"),
57 &pyobj_rec_reader)) {
58 Py_INCREF(Py_None);
59 return Py_None;
60 }
61
62 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
63 pyobj_rec_reader, "apollo_cyber_record_pyrecordfilereader"));
64 if (nullptr == reader) {
65 AERROR << "delete_PyRecordReader:reader ptr is null!";
66 Py_INCREF(Py_None);
67 return Py_None;
68 }
69 delete reader;
70 Py_INCREF(Py_None);
71 return Py_None;
72}
73
74PyObject *cyber_PyRecordReader_ReadMessage(PyObject *self, PyObject *args) {
75 PyObject *pyobj_reader = nullptr;
76 uint64_t begin_time = 0;
77 uint64_t end_time = std::numeric_limits<uint64_t>::max();
78 if (!PyArg_ParseTuple(args,
79 const_cast<char *>("OKK:PyRecordReader_ReadMessage"),
80 &pyobj_reader, &begin_time, &end_time)) {
81 return nullptr;
82 }
83
84 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
85 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
86 if (nullptr == reader) {
87 AERROR << "PyRecordReader_ReadMessage ptr is null!";
88 return nullptr;
89 }
90
91 const auto result = reader->ReadMessage(begin_time, end_time);
92 PyObject *pyobj_bag_message = PyDict_New();
93
94 PyObject *bld_name = Py_BuildValue("s", result.channel_name.c_str());
95 PyDict_SetItemString(pyobj_bag_message, "channel_name", bld_name);
96 Py_DECREF(bld_name);
97
98 PyObject *bld_data =
99 Py_BuildValue("y#", result.data.c_str(), result.data.length());
100
101 ACHECK(bld_data) << "Py_BuildValue returns NULL.";
102 PyDict_SetItemString(pyobj_bag_message, "data", bld_data);
103 Py_DECREF(bld_data);
104
105 PyObject *bld_type = Py_BuildValue("s", result.data_type.c_str());
106 PyDict_SetItemString(pyobj_bag_message, "data_type", bld_type);
107 Py_DECREF(bld_type);
108
109 PyObject *bld_time = Py_BuildValue("s", "timestamp");
110 PyObject *bld_rtime = Py_BuildValue("K", result.timestamp);
111 PyDict_SetItem(pyobj_bag_message, bld_time, bld_rtime);
112 Py_DECREF(bld_time);
113 Py_DECREF(bld_rtime);
114
115 PyObject *bld_end = Py_BuildValue("s", "end");
116 PyDict_SetItem(pyobj_bag_message, bld_end, result.end ? Py_True : Py_False);
117 Py_DECREF(bld_end);
118
119 return pyobj_bag_message;
120}
121
122PyObject *cyber_PyRecordReader_GetMessageNumber(PyObject *self,
123 PyObject *args) {
124 PyObject *pyobj_reader = nullptr;
125 char *channel_name = nullptr;
126 if (!PyArg_ParseTuple(
127 args, const_cast<char *>("Os:PyRecordReader_GetMessageNumber"),
128 &pyobj_reader, &channel_name)) {
129 AERROR << "PyRecordReader_GetMessageNumber:PyRecordReader failed!";
130 return PyLong_FromUnsignedLongLong(0);
131 }
132
133 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
134 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
135 if (nullptr == reader) {
136 AERROR << "PyRecordReader_GetMessageNumber ptr is null!";
137 return PyLong_FromUnsignedLongLong(0);
138 }
139
140 uint64_t num = reader->GetMessageNumber(channel_name);
141 return PyLong_FromUnsignedLongLong(num);
142}
143
144PyObject *cyber_PyRecordReader_GetMessageType(PyObject *self, PyObject *args) {
145 PyObject *pyobj_reader = nullptr;
146 char *channel_name = nullptr;
147 if (!PyArg_ParseTuple(
148 args, const_cast<char *>("Os:cyber_PyRecordReader_GetMessageType"),
149 &pyobj_reader, &channel_name)) {
150 AERROR << "PyRecordReader_GetMessageType:PyRecordReader failed!";
151 return PYOBJECT_NULL_STRING;
152 }
153
154 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
155 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
156 if (nullptr == reader) {
157 AERROR << "PyRecordReader_GetMessageType ptr is null!";
158 return PYOBJECT_NULL_STRING;
159 }
160
161 const std::string msg_type = reader->GetMessageType(channel_name);
162 return C_STR_TO_PY_BYTES(msg_type);
163}
164
165PyObject *cyber_PyRecordReader_GetProtoDesc(PyObject *self, PyObject *args) {
166 PyObject *pyobj_reader = nullptr;
167 char *channel_name = nullptr;
168 if (!PyArg_ParseTuple(args,
169 const_cast<char *>("Os:PyRecordReader_GetProtoDesc"),
170 &pyobj_reader, &channel_name)) {
171 AERROR << "PyRecordReader_GetProtoDesc failed!";
172 return PYOBJECT_NULL_STRING;
173 }
174
175 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
176 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
177 if (nullptr == reader) {
178 AERROR << "PyRecordReader_GetProtoDesc ptr is null!";
179 return PYOBJECT_NULL_STRING;
180 }
181
182 const std::string pb_desc = reader->GetProtoDesc(channel_name);
183 return C_STR_TO_PY_BYTES(pb_desc);
184}
185
186PyObject *cyber_PyRecordReader_GetHeaderString(PyObject *self, PyObject *args) {
187 PyObject *pyobj_reader = nullptr;
188 if (!PyArg_ParseTuple(
189 args, const_cast<char *>("O:cyber_PyRecordReader_GetHeaderString"),
190 &pyobj_reader)) {
191 return PYOBJECT_NULL_STRING;
192 }
193
194 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
195 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
196 if (nullptr == reader) {
197 AERROR << "PyRecordReader_GetHeaderString ptr is null!";
198 return PYOBJECT_NULL_STRING;
199 }
200
201 const std::string header_string = reader->GetHeaderString();
202 return C_STR_TO_PY_BYTES(header_string);
203}
204
205PyObject *cyber_PyRecordReader_Reset(PyObject *self, PyObject *args) {
206 PyObject *pyobj_reader = nullptr;
207 if (!PyArg_ParseTuple(args,
208 const_cast<char *>("O:cyber_PyRecordReader_Reset"),
209 &pyobj_reader)) {
210 AERROR << "cyber_PyRecordReader_Reset:PyArg_ParseTuple failed!";
211 Py_INCREF(Py_None);
212 return Py_None;
213 }
214
215 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
216 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
217 if (nullptr == reader) {
218 AERROR << "PyRecordReader_Reset reader is null!";
219 Py_INCREF(Py_None);
220 return Py_None;
221 }
222
223 reader->Reset();
224 Py_INCREF(Py_None);
225 return Py_None;
226}
227
228PyObject *cyber_PyRecordReader_GetChannelList(PyObject *self, PyObject *args) {
229 PyObject *pyobj_reader = nullptr;
230 if (!PyArg_ParseTuple(
231 args, const_cast<char *>("O:cyber_PyRecordReader_GetChannelList"),
232 &pyobj_reader)) {
233 AERROR << "cyber_PyRecordReader_GetChannelList:PyArg_ParseTuple failed!";
234 Py_INCREF(Py_None);
235 return Py_None;
236 }
237
238 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
239 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
240 if (nullptr == reader) {
241 AERROR << "PyRecordReader_GetChannelList reader is null!";
242 Py_INCREF(Py_None);
243 return Py_None;
244 }
245
246 std::set<std::string> channel_list = reader->GetChannelList();
247 PyObject *pyobj_list = PyList_New(channel_list.size());
248 size_t pos = 0;
249 for (const std::string &channel : channel_list) {
250 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", channel.c_str()));
251 pos++;
252 }
253
254 return pyobj_list;
255}
256
257PyObject *cyber_new_PyRecordWriter(PyObject *self, PyObject *args) {
258 PyRecordWriter *writer = new PyRecordWriter();
259 return PyCapsule_New(writer, "apollo_cyber_record_pyrecordfilewriter",
260 nullptr);
261}
262
263PyObject *cyber_delete_PyRecordWriter(PyObject *self, PyObject *args) {
264 PyObject *pyobj_rec_writer = nullptr;
265 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyRecordWriter"),
266 &pyobj_rec_writer)) {
267 Py_INCREF(Py_None);
268 return Py_None;
269 }
270
271 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
272 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
273 if (nullptr == writer) {
274 AERROR << "delete_PyRecordWriter:writer is null!";
275 Py_INCREF(Py_None);
276 return Py_None;
277 }
278 delete writer;
279 Py_INCREF(Py_None);
280 return Py_None;
281}
282
283PyObject *cyber_PyRecordWriter_Open(PyObject *self, PyObject *args) {
284 PyObject *pyobj_rec_writer = nullptr;
285 char *path = nullptr;
286 Py_ssize_t len = 0;
287 if (!PyArg_ParseTuple(args,
288 const_cast<char *>("Os#:cyber_PyRecordWriter_Open"),
289 &pyobj_rec_writer, &path, &len)) {
290 AERROR << "cyber_PyRecordWriter_Open:PyArg_ParseTuple failed!";
291 Py_RETURN_FALSE;
292 }
293
294 PyRecordWriter *writer = PyObjectToPtr<PyRecordWriter *>(
295 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
296
297 if (nullptr == writer) {
298 AERROR << "PyRecordWriter_Open:writer is null!";
299 Py_RETURN_FALSE;
300 }
301
302 std::string path_str(path, len);
303 if (!writer->Open(path_str)) {
304 Py_RETURN_FALSE;
305 }
306 Py_RETURN_TRUE;
307}
308
309PyObject *cyber_PyRecordWriter_Close(PyObject *self, PyObject *args) {
310 PyObject *pyobj_rec_writer = nullptr;
311 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyRecordWriter"),
312 &pyobj_rec_writer)) {
313 Py_INCREF(Py_None);
314 return Py_None;
315 }
316
317 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
318 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
319 if (nullptr == writer) {
320 AERROR << "cyber_PyRecordWriter_Close: writer is null!";
321 Py_INCREF(Py_None);
322 return Py_None;
323 }
324 writer->Close();
325 Py_INCREF(Py_None);
326 return Py_None;
327}
328
329PyObject *cyber_PyRecordWriter_WriteChannel(PyObject *self, PyObject *args) {
330 PyObject *pyobj_rec_writer = nullptr;
331 char *channel = nullptr;
332 char *type = nullptr;
333 char *proto_desc = nullptr;
334 Py_ssize_t len = 0;
335 if (!PyArg_ParseTuple(
336 args, const_cast<char *>("Osss#:cyber_PyRecordWriter_WriteChannel"),
337 &pyobj_rec_writer, &channel, &type, &proto_desc, &len)) {
338 AERROR << "cyber_PyRecordWriter_WriteChannel parsetuple failed!";
339 Py_RETURN_FALSE;
340 }
341
342 auto *writer = PyObjectToPtr<PyRecordWriter *>(
343 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
344
345 if (nullptr == writer) {
346 AERROR << "cyber_PyRecordWriter_WriteChannel:writer ptr is null!";
347 Py_RETURN_FALSE;
348 }
349
350 std::string proto_desc_str(proto_desc, len);
351 if (!writer->WriteChannel(channel, type, proto_desc_str)) {
352 Py_RETURN_FALSE;
353 }
354 Py_RETURN_TRUE;
355}
356
357PyObject *cyber_PyRecordWriter_WriteMessage(PyObject *self, PyObject *args) {
358 PyObject *pyobj_rec_writer = nullptr;
359 char *channel_name = nullptr;
360 char *rawmessage = nullptr;
361 Py_ssize_t len = 0;
362 uint64_t time = 0;
363 char *proto_desc = nullptr;
364 Py_ssize_t len_desc = 0;
365
366 if (!PyArg_ParseTuple(
367 args, const_cast<char *>("Oss#Ks#:cyber_PyRecordWriter_WriteMessage"),
368 &pyobj_rec_writer, &channel_name, &rawmessage, &len, &time,
369 &proto_desc, &len_desc)) {
370 AERROR << "cyber_PyRecordWriter_WriteMessage parsetuple failed!";
371 Py_RETURN_FALSE;
372 }
373
374 auto *writer = PyObjectToPtr<PyRecordWriter *>(
375 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
376
377 if (nullptr == writer) {
378 AERROR << "cyber_PyRecordWriter_WriteMessage:writer ptr is null!";
379 Py_RETURN_FALSE;
380 }
381
382 std::string rawmessage_str(rawmessage, len);
383 std::string desc_str(proto_desc, len_desc);
384 if (!writer->WriteMessage(channel_name, rawmessage_str, time, desc_str)) {
385 AERROR << "cyber_PyRecordWriter_WriteMessage:WriteMessage failed!";
386 Py_RETURN_FALSE;
387 }
388 Py_RETURN_TRUE;
389}
390
391PyObject *cyber_PyRecordWriter_SetSizeOfFileSegmentation(PyObject *self,
392 PyObject *args) {
393 PyObject *pyobj_rec_writer = nullptr;
394 uint64_t size_kilobytes = 0;
395
396 if (!PyArg_ParseTuple(
397 args,
398 const_cast<char *>(
399 "OK:cyber_PyRecordWriter_SetSizeOfFileSegmentation"),
400 &pyobj_rec_writer, &size_kilobytes)) {
401 AERROR
402 << "cyber_PyRecordWriter_SetSizeOfFileSegmentation parsetuple failed!";
403 Py_RETURN_FALSE;
404 }
405
406 auto *writer = PyObjectToPtr<PyRecordWriter *>(
407 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
408
409 if (nullptr == writer) {
410 AERROR
411 << "cyber_PyRecordWriter_SetSizeOfFileSegmentation:writer ptr is null!";
412 Py_RETURN_FALSE;
413 }
414
415 if (!writer->SetSizeOfFileSegmentation(size_kilobytes)) {
416 AERROR << "cyber_PyRecordWriter_SetSizeOfFileSegmentation failed!";
417 Py_RETURN_FALSE;
418 }
419 Py_RETURN_TRUE;
420}
421
422PyObject *cyber_PyRecordWriter_SetIntervalOfFileSegmentation(PyObject *self,
423 PyObject *args) {
424 PyObject *pyobj_rec_writer = nullptr;
425 uint64_t time_sec = 0;
426
427 if (!PyArg_ParseTuple(
428 args,
429 const_cast<char *>(
430 "OK:cyber_PyRecordWriter_SetIntervalOfFileSegmentation"),
431 &pyobj_rec_writer, &time_sec)) {
432 AERROR << "cyber_PyRecordWriter_SetIntervalOfFileSegmentation parsetuple "
433 "failed!";
434 Py_RETURN_FALSE;
435 }
436
437 auto *writer = PyObjectToPtr<PyRecordWriter *>(
438 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
439
440 if (nullptr == writer) {
441 AERROR << "cyber_PyRecordWriter_SetIntervalOfFileSegmentation:writer ptr "
442 "is null!";
443 Py_RETURN_FALSE;
444 }
445
446 if (!writer->SetIntervalOfFileSegmentation(time_sec)) {
447 AERROR << "cyber_PyRecordWriter_SetIntervalOfFileSegmentation failed!";
448 Py_RETURN_FALSE;
449 }
450 Py_RETURN_TRUE;
451}
452
453PyObject *cyber_PyRecordWriter_GetMessageNumber(PyObject *self,
454 PyObject *args) {
455 PyObject *pyobj_rec_writer = nullptr;
456 char *channel_name = nullptr;
457 if (!PyArg_ParseTuple(
458 args, const_cast<char *>("Os:PyRecordWriter_GetMessageNumber"),
459 &pyobj_rec_writer, &channel_name)) {
460 AERROR << "PyRecordWriter_GetMessageNumber:PyRecordWriter_GetMessageNumber "
461 "failed!";
462 return PyLong_FromUnsignedLongLong(0);
463 }
464
465 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
466 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
467 if (nullptr == writer) {
468 AERROR << "PyRecordWriter_GetMessageNumber ptr is null!";
469 return PyLong_FromUnsignedLongLong(0);
470 }
471
472 uint64_t num = writer->GetMessageNumber(channel_name);
473 return PyLong_FromUnsignedLongLong(num);
474}
475
476PyObject *cyber_PyRecordWriter_GetMessageType(PyObject *self, PyObject *args) {
477 PyObject *pyobj_rec_writer = nullptr;
478 char *channel_name = nullptr;
479 if (!PyArg_ParseTuple(args,
480 const_cast<char *>("Os:PyRecordWriter_GetMessageType"),
481 &pyobj_rec_writer, &channel_name)) {
482 AERROR << "PyRecordWriter_GetMessageType failed!";
483 return PYOBJECT_NULL_STRING;
484 }
485
486 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
487 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
488 if (nullptr == writer) {
489 AERROR << "PyRecordWriter_GetMessageType ptr is null!";
490 return PYOBJECT_NULL_STRING;
491 }
492
493 std::string msg_type = writer->GetMessageType(channel_name);
494 return C_STR_TO_PY_BYTES(msg_type);
495}
496
497PyObject *cyber_PyRecordWriter_GetProtoDesc(PyObject *self, PyObject *args) {
498 PyObject *pyobj_rec_writer = nullptr;
499 char *channel_name = nullptr;
500 if (!PyArg_ParseTuple(args,
501 const_cast<char *>("Os:PyRecordWriter_GetProtoDesc"),
502 &pyobj_rec_writer, &channel_name)) {
503 AERROR << "PyRecordWriter_GetProtoDesc failed!";
504 return PYOBJECT_NULL_STRING;
505 }
506
507 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
508 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
509 if (nullptr == writer) {
510 AERROR << "PyRecordWriter_GetProtoDesc ptr is null!";
511 return PYOBJECT_NULL_STRING;
512 }
513
514 const std::string proto_desc_str = writer->GetProtoDesc(channel_name);
515 return C_STR_TO_PY_BYTES(proto_desc_str);
516}
517
518static PyMethodDef _cyber_record_methods[] = {
519 // PyRecordReader fun
520 {"new_PyRecordReader", cyber_new_PyRecordReader, METH_VARARGS, ""},
521 {"delete_PyRecordReader", cyber_delete_PyRecordReader, METH_VARARGS, ""},
522 {"PyRecordReader_ReadMessage", cyber_PyRecordReader_ReadMessage,
523 METH_VARARGS, ""},
524 {"PyRecordReader_GetMessageNumber", cyber_PyRecordReader_GetMessageNumber,
525 METH_VARARGS, ""},
526 {"PyRecordReader_GetMessageType", cyber_PyRecordReader_GetMessageType,
527 METH_VARARGS, ""},
528 {"PyRecordReader_GetProtoDesc", cyber_PyRecordReader_GetProtoDesc,
529 METH_VARARGS, ""},
530 {"PyRecordReader_GetHeaderString", cyber_PyRecordReader_GetHeaderString,
531 METH_VARARGS, ""},
532 {"PyRecordReader_Reset", cyber_PyRecordReader_Reset, METH_VARARGS, ""},
533 {"PyRecordReader_GetChannelList", cyber_PyRecordReader_GetChannelList,
534 METH_VARARGS, ""},
535
536 // PyRecordWriter fun
537 {"new_PyRecordWriter", cyber_new_PyRecordWriter, METH_VARARGS, ""},
538 {"delete_PyRecordWriter", cyber_delete_PyRecordWriter, METH_VARARGS, ""},
539 {"PyRecordWriter_Open", cyber_PyRecordWriter_Open, METH_VARARGS, ""},
540 {"PyRecordWriter_Close", cyber_PyRecordWriter_Close, METH_VARARGS, ""},
541 {"PyRecordWriter_WriteChannel", cyber_PyRecordWriter_WriteChannel,
542 METH_VARARGS, ""},
543 {"PyRecordWriter_WriteMessage", cyber_PyRecordWriter_WriteMessage,
544 METH_VARARGS, ""},
545 {"PyRecordWriter_SetSizeOfFileSegmentation",
546 cyber_PyRecordWriter_SetSizeOfFileSegmentation, METH_VARARGS, ""},
547 {"PyRecordWriter_SetIntervalOfFileSegmentation",
548 cyber_PyRecordWriter_SetIntervalOfFileSegmentation, METH_VARARGS, ""},
549 {"PyRecordWriter_GetMessageNumber", cyber_PyRecordWriter_GetMessageNumber,
550 METH_VARARGS, ""},
551 {"PyRecordWriter_GetMessageType", cyber_PyRecordWriter_GetMessageType,
552 METH_VARARGS, ""},
553 {"PyRecordWriter_GetProtoDesc", cyber_PyRecordWriter_GetProtoDesc,
554 METH_VARARGS, ""},
555
556 {nullptr, nullptr, 0, nullptr} /* sentinel */
557};
558
560PyMODINIT_FUNC PyInit__cyber_record_wrapper(void) {
561 static struct PyModuleDef module_def = {
562 PyModuleDef_HEAD_INIT,
563 "_cyber_record_wrapper", // Module name.
564 "CyberRecord module", // Module doc.
565 -1, // Module size.
566 _cyber_record_methods, // Module methods.
567 nullptr,
568 nullptr,
569 nullptr,
570 nullptr,
571 };
572
573 AINFO << "init _cyber_record_wrapper";
574 return PyModule_Create(&module_def);
575}
apollo::cyber::record::PyRecordReader::GetProtoDesc
std::string GetProtoDesc(const std::string &channel_name)
Definition py_record.h:83
apollo::cyber::record::PyRecordReader::GetMessageType
std::string GetMessageType(const std::string &channel_name)
Definition py_record.h:79
apollo::cyber::record::PyRecordReader::GetChannelList
std::set< std::string > GetChannelList() const
Definition py_record.h:95
apollo::cyber::record::PyRecordReader::ReadMessage
BagMessage ReadMessage(uint64_t begin_time=0, uint64_t end_time=std::numeric_limits< uint64_t >::max())
Definition py_record.h:56
apollo::cyber::record::PyRecordReader::GetMessageNumber
uint64_t GetMessageNumber(const std::string &channel_name)
Definition py_record.h:75
apollo::cyber::record::PyRecordWriter::WriteChannel
bool WriteChannel(const std::string &channel_str, const std::string &type, const std::string &proto_desc)
Definition py_record.h:109
apollo::cyber::record::PyRecordWriter::GetProtoDesc
const std::string & GetProtoDesc(const std::string &channel_name) const
Definition py_record.h:138
apollo::cyber::record::PyRecordWriter::WriteMessage
bool WriteMessage(const std::string &channel_name, const std::string &rawmessage, uint64_t time, const std::string &proto_desc="")
Definition py_record.h:114
apollo::cyber::record::PyRecordWriter::GetMessageNumber
uint64_t GetMessageNumber(const std::string &channel_name) const
Definition py_record.h:130
apollo::cyber::record::PyRecordWriter::Open
bool Open(const std::string &path)
Definition py_record.h:105
apollo::cyber::record::PyRecordWriter::SetSizeOfFileSegmentation
bool SetSizeOfFileSegmentation(uint64_t size_kilobytes)
Definition py_record.h:122
apollo::cyber::record::PyRecordWriter::GetMessageType
const std::string & GetMessageType(const std::string &channel_name) const
Definition py_record.h:134
apollo::cyber::record::PyRecordWriter::SetIntervalOfFileSegmentation
bool SetIntervalOfFileSegmentation(uint64_t time_sec)
Definition py_record.h:126
ACHECK
#define ACHECK(cond)
Definition log.h:80
AERROR
#define AERROR
Definition log.h:44
AINFO
#define AINFO
Definition log.h:42
cyber_PyRecordWriter_WriteChannel
PyObject * cyber_PyRecordWriter_WriteChannel(PyObject *self, PyObject *args)
Definition py_record.cc:330
cyber_PyRecordWriter_Open
PyObject * cyber_PyRecordWriter_Open(PyObject *self, PyObject *args)
Definition py_record.cc:284
cyber_PyRecordWriter_GetMessageNumber
PyObject * cyber_PyRecordWriter_GetMessageNumber(PyObject *self, PyObject *args)
Definition py_record.cc:454
cyber_PyRecordReader_GetHeaderString
PyObject * cyber_PyRecordReader_GetHeaderString(PyObject *self, PyObject *args)
Definition py_record.cc:187
cyber_PyRecordWriter_WriteMessage
PyObject * cyber_PyRecordWriter_WriteMessage(PyObject *self, PyObject *args)
Definition py_record.cc:358
PYOBJECT_NULL_STRING
#define PYOBJECT_NULL_STRING
Definition py_record.cc:27
cyber_PyRecordReader_GetMessageType
PyObject * cyber_PyRecordReader_GetMessageType(PyObject *self, PyObject *args)
Definition py_record.cc:145
cyber_PyRecordWriter_Close
PyObject * cyber_PyRecordWriter_Close(PyObject *self, PyObject *args)
Definition py_record.cc:310
cyber_new_PyRecordReader
PyObject * cyber_new_PyRecordReader(PyObject *self, PyObject *args)
Definition py_record.cc:40
cyber_PyRecordWriter_SetIntervalOfFileSegmentation
PyObject * cyber_PyRecordWriter_SetIntervalOfFileSegmentation(PyObject *self, PyObject *args)
Definition py_record.cc:423
C_STR_TO_PY_BYTES
#define C_STR_TO_PY_BYTES(cstr)
Definition py_record.cc:28
cyber_delete_PyRecordWriter
PyObject * cyber_delete_PyRecordWriter(PyObject *self, PyObject *args)
Definition py_record.cc:264
cyber_PyRecordWriter_SetSizeOfFileSegmentation
PyObject * cyber_PyRecordWriter_SetSizeOfFileSegmentation(PyObject *self, PyObject *args)
Definition py_record.cc:392
cyber_PyRecordReader_Reset
PyObject * cyber_PyRecordReader_Reset(PyObject *self, PyObject *args)
Definition py_record.cc:206
cyber_PyRecordReader_GetProtoDesc
PyObject * cyber_PyRecordReader_GetProtoDesc(PyObject *self, PyObject *args)
Definition py_record.cc:166
cyber_new_PyRecordWriter
PyObject * cyber_new_PyRecordWriter(PyObject *self, PyObject *args)
Definition py_record.cc:258
cyber_PyRecordReader_ReadMessage
PyObject * cyber_PyRecordReader_ReadMessage(PyObject *self, PyObject *args)
Definition py_record.cc:75
cyber_PyRecordWriter_GetProtoDesc
PyObject * cyber_PyRecordWriter_GetProtoDesc(PyObject *self, PyObject *args)
Definition py_record.cc:498
cyber_PyRecordReader_GetMessageNumber
PyObject * cyber_PyRecordReader_GetMessageNumber(PyObject *self, PyObject *args)
Definition py_record.cc:123
cyber_delete_PyRecordReader
PyObject * cyber_delete_PyRecordReader(PyObject *self, PyObject *args)
Definition py_record.cc:55
cyber_PyRecordWriter_GetMessageType
PyObject * cyber_PyRecordWriter_GetMessageType(PyObject *self, PyObject *args)
Definition py_record.cc:477
PyInit__cyber_record_wrapper
PyMODINIT_FUNC PyInit__cyber_record_wrapper(void)
Init function of this module
Definition py_record.cc:561
cyber_PyRecordReader_GetChannelList
PyObject * cyber_PyRecordReader_GetChannelList(PyObject *self, PyObject *args)
Definition py_record.cc:229

◆ PYOBJECT_NULL_STRING

#define PYOBJECT_NULL_STRING   PyBytes_FromStringAndSize("", 0)

在文件 py_record.cc 第 27 行定义.

函数说明

◆ cyber_delete_PyRecordReader()

PyObject * cyber_delete_PyRecordReader ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 55 行定义.

55 {
56 PyObject *pyobj_rec_reader = nullptr;
57 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyRecordReader"),
58 &pyobj_rec_reader)) {
59 Py_INCREF(Py_None);
60 return Py_None;
61 }
62
63 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
64 pyobj_rec_reader, "apollo_cyber_record_pyrecordfilereader"));
65 if (nullptr == reader) {
66 AERROR << "delete_PyRecordReader:reader ptr is null!";
67 Py_INCREF(Py_None);
68 return Py_None;
69 }
70 delete reader;
71 Py_INCREF(Py_None);
72 return Py_None;
73}

◆ cyber_delete_PyRecordWriter()

PyObject * cyber_delete_PyRecordWriter ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 264 行定义.

264 {
265 PyObject *pyobj_rec_writer = nullptr;
266 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyRecordWriter"),
267 &pyobj_rec_writer)) {
268 Py_INCREF(Py_None);
269 return Py_None;
270 }
271
272 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
273 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
274 if (nullptr == writer) {
275 AERROR << "delete_PyRecordWriter:writer is null!";
276 Py_INCREF(Py_None);
277 return Py_None;
278 }
279 delete writer;
280 Py_INCREF(Py_None);
281 return Py_None;
282}

◆ cyber_new_PyRecordReader()

PyObject * cyber_new_PyRecordReader ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 40 行定义.

40 {
41 char *filepath = nullptr;
42 Py_ssize_t len = 0;
43 if (!PyArg_ParseTuple(args, const_cast<char *>("s#:new_PyRecordReader"),
44 &filepath, &len)) {
45 AERROR << "cyber_new_PyRecordReader parsetuple failed!";
46 Py_INCREF(Py_None);
47 return Py_None;
48 }
49
50 PyRecordReader *reader = new PyRecordReader(std::string(filepath, len));
51 return PyCapsule_New(reader, "apollo_cyber_record_pyrecordfilereader",
52 nullptr);
53}

◆ cyber_new_PyRecordWriter()

PyObject * cyber_new_PyRecordWriter ( PyObject *  self,
PyObject *  args 
)

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

258 {
259 PyRecordWriter *writer = new PyRecordWriter();
260 return PyCapsule_New(writer, "apollo_cyber_record_pyrecordfilewriter",
261 nullptr);
262}

◆ cyber_PyRecordReader_GetChannelList()

PyObject * cyber_PyRecordReader_GetChannelList ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 229 行定义.

229 {
230 PyObject *pyobj_reader = nullptr;
231 if (!PyArg_ParseTuple(
232 args, const_cast<char *>("O:cyber_PyRecordReader_GetChannelList"),
233 &pyobj_reader)) {
234 AERROR << "cyber_PyRecordReader_GetChannelList:PyArg_ParseTuple failed!";
235 Py_INCREF(Py_None);
236 return Py_None;
237 }
238
239 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
240 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
241 if (nullptr == reader) {
242 AERROR << "PyRecordReader_GetChannelList reader is null!";
243 Py_INCREF(Py_None);
244 return Py_None;
245 }
246
247 std::set<std::string> channel_list = reader->GetChannelList();
248 PyObject *pyobj_list = PyList_New(channel_list.size());
249 size_t pos = 0;
250 for (const std::string &channel : channel_list) {
251 PyList_SetItem(pyobj_list, pos, Py_BuildValue("s", channel.c_str()));
252 pos++;
253 }
254
255 return pyobj_list;
256}

◆ cyber_PyRecordReader_GetHeaderString()

PyObject * cyber_PyRecordReader_GetHeaderString ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 187 行定义.

187 {
188 PyObject *pyobj_reader = nullptr;
189 if (!PyArg_ParseTuple(
190 args, const_cast<char *>("O:cyber_PyRecordReader_GetHeaderString"),
191 &pyobj_reader)) {
192 return PYOBJECT_NULL_STRING;
193 }
194
195 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
196 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
197 if (nullptr == reader) {
198 AERROR << "PyRecordReader_GetHeaderString ptr is null!";
199 return PYOBJECT_NULL_STRING;
200 }
201
202 const std::string header_string = reader->GetHeaderString();
203 return C_STR_TO_PY_BYTES(header_string);
204}

◆ cyber_PyRecordReader_GetMessageNumber()

PyObject * cyber_PyRecordReader_GetMessageNumber ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 123 行定义.

124 {
125 PyObject *pyobj_reader = nullptr;
126 char *channel_name = nullptr;
127 if (!PyArg_ParseTuple(
128 args, const_cast<char *>("Os:PyRecordReader_GetMessageNumber"),
129 &pyobj_reader, &channel_name)) {
130 AERROR << "PyRecordReader_GetMessageNumber:PyRecordReader failed!";
131 return PyLong_FromUnsignedLongLong(0);
132 }
133
134 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
135 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
136 if (nullptr == reader) {
137 AERROR << "PyRecordReader_GetMessageNumber ptr is null!";
138 return PyLong_FromUnsignedLongLong(0);
139 }
140
141 uint64_t num = reader->GetMessageNumber(channel_name);
142 return PyLong_FromUnsignedLongLong(num);
143}

◆ cyber_PyRecordReader_GetMessageType()

PyObject * cyber_PyRecordReader_GetMessageType ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 145 行定义.

145 {
146 PyObject *pyobj_reader = nullptr;
147 char *channel_name = nullptr;
148 if (!PyArg_ParseTuple(
149 args, const_cast<char *>("Os:cyber_PyRecordReader_GetMessageType"),
150 &pyobj_reader, &channel_name)) {
151 AERROR << "PyRecordReader_GetMessageType:PyRecordReader failed!";
152 return PYOBJECT_NULL_STRING;
153 }
154
155 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
156 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
157 if (nullptr == reader) {
158 AERROR << "PyRecordReader_GetMessageType ptr is null!";
159 return PYOBJECT_NULL_STRING;
160 }
161
162 const std::string msg_type = reader->GetMessageType(channel_name);
163 return C_STR_TO_PY_BYTES(msg_type);
164}

◆ cyber_PyRecordReader_GetProtoDesc()

PyObject * cyber_PyRecordReader_GetProtoDesc ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 166 行定义.

166 {
167 PyObject *pyobj_reader = nullptr;
168 char *channel_name = nullptr;
169 if (!PyArg_ParseTuple(args,
170 const_cast<char *>("Os:PyRecordReader_GetProtoDesc"),
171 &pyobj_reader, &channel_name)) {
172 AERROR << "PyRecordReader_GetProtoDesc failed!";
173 return PYOBJECT_NULL_STRING;
174 }
175
176 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
177 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
178 if (nullptr == reader) {
179 AERROR << "PyRecordReader_GetProtoDesc ptr is null!";
180 return PYOBJECT_NULL_STRING;
181 }
182
183 const std::string pb_desc = reader->GetProtoDesc(channel_name);
184 return C_STR_TO_PY_BYTES(pb_desc);
185}

◆ cyber_PyRecordReader_ReadMessage()

PyObject * cyber_PyRecordReader_ReadMessage ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 75 行定义.

75 {
76 PyObject *pyobj_reader = nullptr;
77 uint64_t begin_time = 0;
78 uint64_t end_time = std::numeric_limits<uint64_t>::max();
79 if (!PyArg_ParseTuple(args,
80 const_cast<char *>("OKK:PyRecordReader_ReadMessage"),
81 &pyobj_reader, &begin_time, &end_time)) {
82 return nullptr;
83 }
84
85 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
86 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
87 if (nullptr == reader) {
88 AERROR << "PyRecordReader_ReadMessage ptr is null!";
89 return nullptr;
90 }
91
92 const auto result = reader->ReadMessage(begin_time, end_time);
93 PyObject *pyobj_bag_message = PyDict_New();
94
95 PyObject *bld_name = Py_BuildValue("s", result.channel_name.c_str());
96 PyDict_SetItemString(pyobj_bag_message, "channel_name", bld_name);
97 Py_DECREF(bld_name);
98
99 PyObject *bld_data =
100 Py_BuildValue("y#", result.data.c_str(), result.data.length());
101
102 ACHECK(bld_data) << "Py_BuildValue returns NULL.";
103 PyDict_SetItemString(pyobj_bag_message, "data", bld_data);
104 Py_DECREF(bld_data);
105
106 PyObject *bld_type = Py_BuildValue("s", result.data_type.c_str());
107 PyDict_SetItemString(pyobj_bag_message, "data_type", bld_type);
108 Py_DECREF(bld_type);
109
110 PyObject *bld_time = Py_BuildValue("s", "timestamp");
111 PyObject *bld_rtime = Py_BuildValue("K", result.timestamp);
112 PyDict_SetItem(pyobj_bag_message, bld_time, bld_rtime);
113 Py_DECREF(bld_time);
114 Py_DECREF(bld_rtime);
115
116 PyObject *bld_end = Py_BuildValue("s", "end");
117 PyDict_SetItem(pyobj_bag_message, bld_end, result.end ? Py_True : Py_False);
118 Py_DECREF(bld_end);
119
120 return pyobj_bag_message;
121}

◆ cyber_PyRecordReader_Reset()

PyObject * cyber_PyRecordReader_Reset ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 206 行定义.

206 {
207 PyObject *pyobj_reader = nullptr;
208 if (!PyArg_ParseTuple(args,
209 const_cast<char *>("O:cyber_PyRecordReader_Reset"),
210 &pyobj_reader)) {
211 AERROR << "cyber_PyRecordReader_Reset:PyArg_ParseTuple failed!";
212 Py_INCREF(Py_None);
213 return Py_None;
214 }
215
216 auto *reader = reinterpret_cast<PyRecordReader *>(PyCapsule_GetPointer(
217 pyobj_reader, "apollo_cyber_record_pyrecordfilereader"));
218 if (nullptr == reader) {
219 AERROR << "PyRecordReader_Reset reader is null!";
220 Py_INCREF(Py_None);
221 return Py_None;
222 }
223
224 reader->Reset();
225 Py_INCREF(Py_None);
226 return Py_None;
227}

◆ cyber_PyRecordWriter_Close()

PyObject * cyber_PyRecordWriter_Close ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 310 行定义.

310 {
311 PyObject *pyobj_rec_writer = nullptr;
312 if (!PyArg_ParseTuple(args, const_cast<char *>("O:delete_PyRecordWriter"),
313 &pyobj_rec_writer)) {
314 Py_INCREF(Py_None);
315 return Py_None;
316 }
317
318 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
319 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
320 if (nullptr == writer) {
321 AERROR << "cyber_PyRecordWriter_Close: writer is null!";
322 Py_INCREF(Py_None);
323 return Py_None;
324 }
325 writer->Close();
326 Py_INCREF(Py_None);
327 return Py_None;
328}

◆ cyber_PyRecordWriter_GetMessageNumber()

PyObject * cyber_PyRecordWriter_GetMessageNumber ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 454 行定义.

455 {
456 PyObject *pyobj_rec_writer = nullptr;
457 char *channel_name = nullptr;
458 if (!PyArg_ParseTuple(
459 args, const_cast<char *>("Os:PyRecordWriter_GetMessageNumber"),
460 &pyobj_rec_writer, &channel_name)) {
461 AERROR << "PyRecordWriter_GetMessageNumber:PyRecordWriter_GetMessageNumber "
462 "failed!";
463 return PyLong_FromUnsignedLongLong(0);
464 }
465
466 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
467 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
468 if (nullptr == writer) {
469 AERROR << "PyRecordWriter_GetMessageNumber ptr is null!";
470 return PyLong_FromUnsignedLongLong(0);
471 }
472
473 uint64_t num = writer->GetMessageNumber(channel_name);
474 return PyLong_FromUnsignedLongLong(num);
475}

◆ cyber_PyRecordWriter_GetMessageType()

PyObject * cyber_PyRecordWriter_GetMessageType ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 477 行定义.

477 {
478 PyObject *pyobj_rec_writer = nullptr;
479 char *channel_name = nullptr;
480 if (!PyArg_ParseTuple(args,
481 const_cast<char *>("Os:PyRecordWriter_GetMessageType"),
482 &pyobj_rec_writer, &channel_name)) {
483 AERROR << "PyRecordWriter_GetMessageType failed!";
484 return PYOBJECT_NULL_STRING;
485 }
486
487 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
488 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
489 if (nullptr == writer) {
490 AERROR << "PyRecordWriter_GetMessageType ptr is null!";
491 return PYOBJECT_NULL_STRING;
492 }
493
494 std::string msg_type = writer->GetMessageType(channel_name);
495 return C_STR_TO_PY_BYTES(msg_type);
496}

◆ cyber_PyRecordWriter_GetProtoDesc()

PyObject * cyber_PyRecordWriter_GetProtoDesc ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 498 行定义.

498 {
499 PyObject *pyobj_rec_writer = nullptr;
500 char *channel_name = nullptr;
501 if (!PyArg_ParseTuple(args,
502 const_cast<char *>("Os:PyRecordWriter_GetProtoDesc"),
503 &pyobj_rec_writer, &channel_name)) {
504 AERROR << "PyRecordWriter_GetProtoDesc failed!";
505 return PYOBJECT_NULL_STRING;
506 }
507
508 auto *writer = reinterpret_cast<PyRecordWriter *>(PyCapsule_GetPointer(
509 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter"));
510 if (nullptr == writer) {
511 AERROR << "PyRecordWriter_GetProtoDesc ptr is null!";
512 return PYOBJECT_NULL_STRING;
513 }
514
515 const std::string proto_desc_str = writer->GetProtoDesc(channel_name);
516 return C_STR_TO_PY_BYTES(proto_desc_str);
517}

◆ cyber_PyRecordWriter_Open()

PyObject * cyber_PyRecordWriter_Open ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 284 行定义.

284 {
285 PyObject *pyobj_rec_writer = nullptr;
286 char *path = nullptr;
287 Py_ssize_t len = 0;
288 if (!PyArg_ParseTuple(args,
289 const_cast<char *>("Os#:cyber_PyRecordWriter_Open"),
290 &pyobj_rec_writer, &path, &len)) {
291 AERROR << "cyber_PyRecordWriter_Open:PyArg_ParseTuple failed!";
292 Py_RETURN_FALSE;
293 }
294
295 PyRecordWriter *writer = PyObjectToPtr<PyRecordWriter *>(
296 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
297
298 if (nullptr == writer) {
299 AERROR << "PyRecordWriter_Open:writer is null!";
300 Py_RETURN_FALSE;
301 }
302
303 std::string path_str(path, len);
304 if (!writer->Open(path_str)) {
305 Py_RETURN_FALSE;
306 }
307 Py_RETURN_TRUE;
308}

◆ cyber_PyRecordWriter_SetIntervalOfFileSegmentation()

PyObject * cyber_PyRecordWriter_SetIntervalOfFileSegmentation ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 423 行定义.

424 {
425 PyObject *pyobj_rec_writer = nullptr;
426 uint64_t time_sec = 0;
427
428 if (!PyArg_ParseTuple(
429 args,
430 const_cast<char *>(
431 "OK:cyber_PyRecordWriter_SetIntervalOfFileSegmentation"),
432 &pyobj_rec_writer, &time_sec)) {
433 AERROR << "cyber_PyRecordWriter_SetIntervalOfFileSegmentation parsetuple "
434 "failed!";
435 Py_RETURN_FALSE;
436 }
437
438 auto *writer = PyObjectToPtr<PyRecordWriter *>(
439 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
440
441 if (nullptr == writer) {
442 AERROR << "cyber_PyRecordWriter_SetIntervalOfFileSegmentation:writer ptr "
443 "is null!";
444 Py_RETURN_FALSE;
445 }
446
447 if (!writer->SetIntervalOfFileSegmentation(time_sec)) {
448 AERROR << "cyber_PyRecordWriter_SetIntervalOfFileSegmentation failed!";
449 Py_RETURN_FALSE;
450 }
451 Py_RETURN_TRUE;
452}

◆ cyber_PyRecordWriter_SetSizeOfFileSegmentation()

PyObject * cyber_PyRecordWriter_SetSizeOfFileSegmentation ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 392 行定义.

393 {
394 PyObject *pyobj_rec_writer = nullptr;
395 uint64_t size_kilobytes = 0;
396
397 if (!PyArg_ParseTuple(
398 args,
399 const_cast<char *>(
400 "OK:cyber_PyRecordWriter_SetSizeOfFileSegmentation"),
401 &pyobj_rec_writer, &size_kilobytes)) {
402 AERROR
403 << "cyber_PyRecordWriter_SetSizeOfFileSegmentation parsetuple failed!";
404 Py_RETURN_FALSE;
405 }
406
407 auto *writer = PyObjectToPtr<PyRecordWriter *>(
408 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
409
410 if (nullptr == writer) {
411 AERROR
412 << "cyber_PyRecordWriter_SetSizeOfFileSegmentation:writer ptr is null!";
413 Py_RETURN_FALSE;
414 }
415
416 if (!writer->SetSizeOfFileSegmentation(size_kilobytes)) {
417 AERROR << "cyber_PyRecordWriter_SetSizeOfFileSegmentation failed!";
418 Py_RETURN_FALSE;
419 }
420 Py_RETURN_TRUE;
421}

◆ cyber_PyRecordWriter_WriteChannel()

PyObject * cyber_PyRecordWriter_WriteChannel ( PyObject *  self,
PyObject *  args 
)

在文件 py_record.cc 第 330 行定义.

330 {
331 PyObject *pyobj_rec_writer = nullptr;
332 char *channel = nullptr;
333 char *type = nullptr;
334 char *proto_desc = nullptr;
335 Py_ssize_t len = 0;
336 if (!PyArg_ParseTuple(
337 args, const_cast<char *>("Osss#:cyber_PyRecordWriter_WriteChannel"),
338 &pyobj_rec_writer, &channel, &type, &proto_desc, &len)) {
339 AERROR << "cyber_PyRecordWriter_WriteChannel parsetuple failed!";
340 Py_RETURN_FALSE;
341 }
342
343 auto *writer = PyObjectToPtr<PyRecordWriter *>(
344 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
345
346 if (nullptr == writer) {
347 AERROR << "cyber_PyRecordWriter_WriteChannel:writer ptr is null!";
348 Py_RETURN_FALSE;
349 }
350
351 std::string proto_desc_str(proto_desc, len);
352 if (!writer->WriteChannel(channel, type, proto_desc_str)) {
353 Py_RETURN_FALSE;
354 }
355 Py_RETURN_TRUE;
356}

◆ cyber_PyRecordWriter_WriteMessage()

PyObject * cyber_PyRecordWriter_WriteMessage ( PyObject *  self,
PyObject *  args 
)

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

358 {
359 PyObject *pyobj_rec_writer = nullptr;
360 char *channel_name = nullptr;
361 char *rawmessage = nullptr;
362 Py_ssize_t len = 0;
363 uint64_t time = 0;
364 char *proto_desc = nullptr;
365 Py_ssize_t len_desc = 0;
366
367 if (!PyArg_ParseTuple(
368 args, const_cast<char *>("Oss#Ks#:cyber_PyRecordWriter_WriteMessage"),
369 &pyobj_rec_writer, &channel_name, &rawmessage, &len, &time,
370 &proto_desc, &len_desc)) {
371 AERROR << "cyber_PyRecordWriter_WriteMessage parsetuple failed!";
372 Py_RETURN_FALSE;
373 }
374
375 auto *writer = PyObjectToPtr<PyRecordWriter *>(
376 pyobj_rec_writer, "apollo_cyber_record_pyrecordfilewriter");
377
378 if (nullptr == writer) {
379 AERROR << "cyber_PyRecordWriter_WriteMessage:writer ptr is null!";
380 Py_RETURN_FALSE;
381 }
382
383 std::string rawmessage_str(rawmessage, len);
384 std::string desc_str(proto_desc, len_desc);
385 if (!writer->WriteMessage(channel_name, rawmessage_str, time, desc_str)) {
386 AERROR << "cyber_PyRecordWriter_WriteMessage:WriteMessage failed!";
387 Py_RETURN_FALSE;
388 }
389 Py_RETURN_TRUE;
390}

◆ PyInit__cyber_record_wrapper()

PyMODINIT_FUNC PyInit__cyber_record_wrapper ( void  )

Init function of this module

在文件 py_record.cc 第 561 行定义.

561 {
562 static struct PyModuleDef module_def = {
563 PyModuleDef_HEAD_INIT,
564 "_cyber_record_wrapper", // Module name.
565 "CyberRecord module", // Module doc.
566 -1, // Module size.
567 _cyber_record_methods, // Module methods.
568 nullptr,
569 nullptr,
570 nullptr,
571 nullptr,
572 };
573
574 AINFO << "init _cyber_record_wrapper";
575 return PyModule_Create(&module_def);
576}

◆ PyObjectToPtr()

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

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

32 {
33 T obj_ptr = (T)PyCapsule_GetPointer(pyobj, type_ptr.c_str());
34 if (obj_ptr == nullptr) {
35 AERROR << "PyObjectToPtr failed,type->" << type_ptr << "pyobj: " << pyobj;
36 }
37 return obj_ptr;
38}