static int
psutil_sunos_clear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->error);
return 0;
}
static int pykadmin_clear(PyObject *module) {
Py_CLEAR(GETSTATE(module)->error);
return 0;
}
static int
psutil_sunos_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(GETSTATE(m)->error);
return 0;
}
PyObject *
PyInit__cairo(void)
{
if (PyType_Ready(&PycairoContext_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoFontFace_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoToyFontFace_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoFontOptions_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoMatrix_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoPath_Type) < 0)
return NULL;
PycairoPathiter_Type.tp_iter=&PyObject_SelfIter;
if (PyType_Ready(&PycairoPathiter_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoPattern_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoSolidPattern_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoSurfacePattern_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoGradient_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoLinearGradient_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoRadialGradient_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoRectangleInt_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoRegion_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoScaledFont_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoSurface_Type) < 0)
return NULL;
#ifdef CAIRO_HAS_IMAGE_SURFACE
if (PyType_Ready(&PycairoImageSurface_Type) < 0)
return NULL;
#endif
#ifdef CAIRO_HAS_PDF_SURFACE
if (PyType_Ready(&PycairoPDFSurface_Type) < 0)
return NULL;
#endif
#ifdef CAIRO_HAS_PS_SURFACE
if (PyType_Ready(&PycairoPSSurface_Type) < 0)
return NULL;
#endif
#ifdef CAIRO_HAS_RECORDING_SURFACE
if (PyType_Ready(&PycairoRecordingSurface_Type) < 0)
return NULL;
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
if (PyType_Ready(&PycairoSVGSurface_Type) < 0)
return NULL;
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
if (PyType_Ready(&PycairoWin32Surface_Type) < 0)
return NULL;
if (PyType_Ready(&PycairoWin32PrintingSurface_Type) < 0)
return NULL;
#endif
#ifdef CAIRO_HAS_XCB_SURFACE
if (PyType_Ready(&PycairoXCBSurface_Type) < 0)
return NULL;
#endif
#ifdef CAIRO_HAS_XLIB_SURFACE
if (PyType_Ready(&PycairoXlibSurface_Type) < 0)
return NULL;
#endif
PyObject *m = PyModule_Create(&cairomodule);
if (m==NULL)
return NULL;
GETSTATE(m)->ErrorObject = PyErr_NewException("cairo.Error", NULL, NULL);
if (GETSTATE(m)->ErrorObject == NULL) {
Py_DECREF(m);
return NULL;
}
PyModule_AddStringConstant(m, "version", VERSION);
PyModule_AddObject(m, "version_info",
Py_BuildValue("(iii)",
PYCAIRO_VERSION_MAJOR,
PYCAIRO_VERSION_MINOR,
PYCAIRO_VERSION_MICRO
));
Py_INCREF(&PycairoContext_Type);
PyModule_AddObject(m, "Context", (PyObject *)&PycairoContext_Type);
Py_INCREF(&PycairoFontFace_Type);
PyModule_AddObject(m, "FontFace",(PyObject *)&PycairoFontFace_Type);
Py_INCREF(&PycairoToyFontFace_Type);
PyModule_AddObject(m, "ToyFontFace",(PyObject *)&PycairoToyFontFace_Type);
Py_INCREF(&PycairoFontOptions_Type);
PyModule_AddObject(m, "FontOptions",(PyObject *)&PycairoFontOptions_Type);
Py_INCREF(&PycairoMatrix_Type);
PyModule_AddObject(m, "Matrix", (PyObject *)&PycairoMatrix_Type);
Py_INCREF(&PycairoPath_Type);
/* Don't add Path object since it is not accessed directly as 'cairo.Path'
* PyModule_AddObject(m, "Path", (PyObject *)&PycairoPath_Type);
*/
Py_INCREF(&PycairoPattern_Type);
PyModule_AddObject(m, "Pattern", (PyObject *)&PycairoPattern_Type);
Py_INCREF(&PycairoSolidPattern_Type);
PyModule_AddObject(m, "SolidPattern",
(PyObject *)&PycairoSolidPattern_Type);
Py_INCREF(&PycairoSurfacePattern_Type);
PyModule_AddObject(m, "SurfacePattern",
(PyObject *)&PycairoSurfacePattern_Type);
Py_INCREF(&PycairoGradient_Type);
PyModule_AddObject(m, "Gradient", (PyObject *)&PycairoGradient_Type);
Py_INCREF(&PycairoLinearGradient_Type);
PyModule_AddObject(m, "LinearGradient",
(PyObject *)&PycairoLinearGradient_Type);
Py_INCREF(&PycairoRadialGradient_Type);
PyModule_AddObject(m, "RadialGradient",
(PyObject *)&PycairoRadialGradient_Type);
Py_INCREF(&PycairoRectangleInt_Type);
PyModule_AddObject(m, "RectangleInt", (PyObject *)&PycairoRectangleInt_Type);
Py_INCREF(&PycairoRegion_Type);
PyModule_AddObject(m, "Region", (PyObject *)&PycairoRegion_Type);
Py_INCREF(&PycairoScaledFont_Type);
PyModule_AddObject(m, "ScaledFont", (PyObject *)&PycairoScaledFont_Type);
Py_INCREF(&PycairoSurface_Type);
PyModule_AddObject(m, "Surface", (PyObject *)&PycairoSurface_Type);
#ifdef CAIRO_HAS_IMAGE_SURFACE
Py_INCREF(&PycairoImageSurface_Type);
PyModule_AddObject(m, "ImageSurface",
(PyObject *)&PycairoImageSurface_Type);
#endif
#ifdef CAIRO_HAS_PDF_SURFACE
Py_INCREF(&PycairoPDFSurface_Type);
PyModule_AddObject(m, "PDFSurface", (PyObject *)&PycairoPDFSurface_Type);
#endif
#ifdef CAIRO_HAS_PS_SURFACE
Py_INCREF(&PycairoPSSurface_Type);
PyModule_AddObject(m, "PSSurface", (PyObject *)&PycairoPSSurface_Type);
#endif
#ifdef CAIRO_HAS_RECORDING_SURFACE
Py_INCREF(&PycairoRecordingSurface_Type);
PyModule_AddObject(m, "RecordingSurface",
(PyObject *)&PycairoRecordingSurface_Type);
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
Py_INCREF(&PycairoSVGSurface_Type);
PyModule_AddObject(m, "SVGSurface", (PyObject *)&PycairoSVGSurface_Type);
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
Py_INCREF(&PycairoWin32Surface_Type);
PyModule_AddObject(m, "Win32Surface",
(PyObject *)&PycairoWin32Surface_Type);
Py_INCREF(&PycairoWin32PrintingSurface_Type);
PyModule_AddObject(m, "Win32PrintingSurface",
(PyObject *)&PycairoWin32PrintingSurface_Type);
#endif
#ifdef CAIRO_HAS_XCB_SURFACE
Py_INCREF(&PycairoXCBSurface_Type);
PyModule_AddObject(m, "XCBSurface",
(PyObject *)&PycairoXCBSurface_Type);
#endif
#ifdef CAIRO_HAS_XLIB_SURFACE
Py_INCREF(&PycairoXlibSurface_Type);
PyModule_AddObject(m, "XlibSurface",
(PyObject *)&PycairoXlibSurface_Type);
#endif
/* constants */
#if CAIRO_HAS_ATSUI_FONT
PyModule_AddIntConstant(m, "HAS_ATSUI_FONT", 1);
#else
PyModule_AddIntConstant(m, "HAS_ATSUI_FONT", 0);
#endif
#if CAIRO_HAS_FT_FONT
PyModule_AddIntConstant(m, "HAS_FT_FONT", 1);
#else
PyModule_AddIntConstant(m, "HAS_FT_FONT", 0);
#endif
#if CAIRO_HAS_GLITZ_SURFACE
PyModule_AddIntConstant(m, "HAS_GLITZ_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_GLITZ_SURFACE", 0);
#endif
#if CAIRO_HAS_IMAGE_SURFACE
PyModule_AddIntConstant(m, "HAS_IMAGE_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_IMAGE_SURFACE", 0);
#endif
#if CAIRO_HAS_PDF_SURFACE
PyModule_AddIntConstant(m, "HAS_PDF_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_PDF_SURFACE", 0);
#endif
#if CAIRO_HAS_PNG_FUNCTIONS
PyModule_AddIntConstant(m, "HAS_PNG_FUNCTIONS", 1);
#else
PyModule_AddIntConstant(m, "HAS_PNG_FUNCTIONS", 0);
#endif
#if CAIRO_HAS_PS_SURFACE
PyModule_AddIntConstant(m, "HAS_PS_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_PS_SURFACE", 0);
#endif
#if CAIRO_HAS_RECORDING_SURFACE
PyModule_AddIntConstant(m, "HAS_RECORDING_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_RECORDING_SURFACE", 0);
#endif
#if CAIRO_HAS_SVG_SURFACE
PyModule_AddIntConstant(m, "HAS_SVG_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_SVG_SURFACE", 0);
#endif
#if CAIRO_HAS_USER_FONT
PyModule_AddIntConstant(m, "HAS_USER_FONT", 1);
#else
PyModule_AddIntConstant(m, "HAS_USER_FONT", 0);
#endif
#if CAIRO_HAS_QUARTZ_SURFACE
PyModule_AddIntConstant(m, "HAS_QUARTZ_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_QUARTZ_SURFACE", 0);
#endif
#if CAIRO_HAS_WIN32_FONT
PyModule_AddIntConstant(m, "HAS_WIN32_FONT", 1);
#else
PyModule_AddIntConstant(m, "HAS_WIN32_FONT", 0);
#endif
#if CAIRO_HAS_WIN32_SURFACE
PyModule_AddIntConstant(m, "HAS_WIN32_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_WIN32_SURFACE", 0);
#endif
#if CAIRO_HAS_XCB_SURFACE
PyModule_AddIntConstant(m, "HAS_XCB_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_XCB_SURFACE", 0);
#endif
#if CAIRO_HAS_XLIB_SURFACE
PyModule_AddIntConstant(m, "HAS_XLIB_SURFACE", 1);
#else
PyModule_AddIntConstant(m, "HAS_XLIB_SURFACE", 0);
#endif
#define CONSTANT(x) PyModule_AddIntConstant(m, #x, CAIRO_##x)
CONSTANT(ANTIALIAS_DEFAULT);
CONSTANT(ANTIALIAS_NONE);
CONSTANT(ANTIALIAS_GRAY);
CONSTANT(ANTIALIAS_SUBPIXEL);
CONSTANT(CONTENT_COLOR);
CONSTANT(CONTENT_ALPHA);
CONSTANT(CONTENT_COLOR_ALPHA);
CONSTANT(EXTEND_NONE);
CONSTANT(EXTEND_REPEAT);
CONSTANT(EXTEND_REFLECT);
CONSTANT(EXTEND_PAD);
CONSTANT(FILL_RULE_WINDING);
CONSTANT(FILL_RULE_EVEN_ODD);
CONSTANT(FILTER_FAST);
CONSTANT(FILTER_GOOD);
CONSTANT(FILTER_BEST);
CONSTANT(FILTER_NEAREST);
CONSTANT(FILTER_BILINEAR);
CONSTANT(FILTER_GAUSSIAN);
CONSTANT(FONT_WEIGHT_NORMAL);
CONSTANT(FONT_WEIGHT_BOLD);
CONSTANT(FONT_SLANT_NORMAL);
CONSTANT(FONT_SLANT_ITALIC);
CONSTANT(FONT_SLANT_OBLIQUE);
CONSTANT(FORMAT_ARGB32);
CONSTANT(FORMAT_RGB24);
CONSTANT(FORMAT_A8);
CONSTANT(FORMAT_A1);
CONSTANT(FORMAT_RGB16_565);
CONSTANT(HINT_METRICS_DEFAULT);
CONSTANT(HINT_METRICS_OFF);
CONSTANT(HINT_METRICS_ON);
CONSTANT(HINT_STYLE_DEFAULT);
CONSTANT(HINT_STYLE_NONE);
CONSTANT(HINT_STYLE_SLIGHT);
CONSTANT(HINT_STYLE_MEDIUM);
CONSTANT(HINT_STYLE_FULL);
CONSTANT(LINE_CAP_BUTT);
CONSTANT(LINE_CAP_ROUND);
CONSTANT(LINE_CAP_SQUARE);
CONSTANT(LINE_JOIN_MITER);
CONSTANT(LINE_JOIN_ROUND);
CONSTANT(LINE_JOIN_BEVEL);
CONSTANT(OPERATOR_CLEAR);
CONSTANT(OPERATOR_SOURCE);
CONSTANT(OPERATOR_OVER);
CONSTANT(OPERATOR_IN);
CONSTANT(OPERATOR_OUT);
CONSTANT(OPERATOR_ATOP);
CONSTANT(OPERATOR_DEST);
CONSTANT(OPERATOR_DEST_OVER);
CONSTANT(OPERATOR_DEST_IN);
CONSTANT(OPERATOR_DEST_OUT);
CONSTANT(OPERATOR_DEST_ATOP);
CONSTANT(OPERATOR_XOR);
CONSTANT(OPERATOR_ADD);
CONSTANT(OPERATOR_SATURATE);
CONSTANT(OPERATOR_MULTIPLY);
CONSTANT(OPERATOR_SCREEN);
CONSTANT(OPERATOR_OVERLAY);
CONSTANT(OPERATOR_DARKEN);
CONSTANT(OPERATOR_LIGHTEN);
CONSTANT(OPERATOR_COLOR_DODGE);
CONSTANT(OPERATOR_COLOR_BURN);
CONSTANT(OPERATOR_HARD_LIGHT);
CONSTANT(OPERATOR_SOFT_LIGHT);
CONSTANT(OPERATOR_DIFFERENCE);
CONSTANT(OPERATOR_EXCLUSION);
CONSTANT(OPERATOR_HSL_HUE);
CONSTANT(OPERATOR_HSL_SATURATION);
CONSTANT(OPERATOR_HSL_COLOR);
CONSTANT(OPERATOR_HSL_LUMINOSITY);
CONSTANT(PATH_MOVE_TO);
CONSTANT(PATH_LINE_TO);
CONSTANT(PATH_CURVE_TO);
CONSTANT(PATH_CLOSE_PATH);
#ifdef CAIRO_HAS_PDF_SURFACE
CONSTANT(PDF_VERSION_1_4);
CONSTANT(PDF_VERSION_1_5);
#endif
#ifdef CAIRO_HAS_PS_SURFACE
CONSTANT(PS_LEVEL_2);
CONSTANT(PS_LEVEL_3);
#endif
CONSTANT(REGION_OVERLAP_IN);
CONSTANT(REGION_OVERLAP_OUT);
CONSTANT(REGION_OVERLAP_PART);
#ifdef CAIRO_HAS_SVG_SURFACE
CONSTANT(SVG_VERSION_1_1);
CONSTANT(SVG_VERSION_1_2);
#endif
CONSTANT(SUBPIXEL_ORDER_DEFAULT);
CONSTANT(SUBPIXEL_ORDER_RGB);
CONSTANT(SUBPIXEL_ORDER_BGR);
CONSTANT(SUBPIXEL_ORDER_VRGB);
CONSTANT(SUBPIXEL_ORDER_VBGR);
#undef CONSTANT
/* Create a Capsule containing the CAPI pointer */
PyObject *T = PyCapsule_New((void *)(&CAPI), "cairo.CAPI", 0);
if (T != NULL) {
PyModule_AddObject(m, "CAPI", T);
}
return m;
}
static int pykadmin_traverse(PyObject *module, visitproc visit, void *arg) {
Py_VISIT(GETSTATE(module)->error);
return 0;
}
static int RTIMUClear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->error);
return 0;
}
static int
cairo_clear(PyObject *m)
{
Py_CLEAR(GETSTATE(m)->ErrorObject);
return 0;
}
/* add a lastError message on the end of the buffer.
* returns 0 on failure */
static int add_last_error(PyObject* self, buffer_t buffer,
int request_id, char* ns, int nslen, PyObject* args) {
struct module_state *state = GETSTATE(self);
int message_start;
int document_start;
int message_length;
int document_length;
PyObject* key;
PyObject* value;
Py_ssize_t pos = 0;
PyObject* one;
char *p = strchr(ns, '.');
/* Length of the database portion of ns. */
nslen = p ? (p - ns) : nslen;
message_start = buffer_save_space(buffer, 4);
if (message_start == -1) {
PyErr_NoMemory();
return 0;
}
if (!buffer_write_bytes(buffer, (const char*)&request_id, 4) ||
!buffer_write_bytes(buffer,
"\x00\x00\x00\x00" /* responseTo */
"\xd4\x07\x00\x00" /* opcode */
"\x00\x00\x00\x00", /* options */
12) ||
!buffer_write_bytes(buffer,
ns, nslen) || /* database */
!buffer_write_bytes(buffer,
".$cmd\x00" /* collection name */
"\x00\x00\x00\x00" /* skip */
"\xFF\xFF\xFF\xFF", /* limit (-1) */
14)) {
return 0;
}
/* save space for length */
document_start = buffer_save_space(buffer, 4);
if (document_start == -1) {
PyErr_NoMemory();
return 0;
}
/* getlasterror: 1 */
one = PyLong_FromLong(1);
if (!write_pair(state->_cbson, buffer, "getlasterror", 12, one, 0, 4, 1)) {
Py_DECREF(one);
return 0;
}
Py_DECREF(one);
/* getlasterror options */
while (PyDict_Next(args, &pos, &key, &value)) {
if (!decode_and_write_pair(state->_cbson, buffer, key, value, 0, 4, 0)) {
return 0;
}
}
/* EOD */
if (!buffer_write_bytes(buffer, "\x00", 1)) {
return 0;
}
message_length = buffer_get_position(buffer) - message_start;
document_length = buffer_get_position(buffer) - document_start;
memcpy(buffer_get_buffer(buffer) + message_start, &message_length, 4);
memcpy(buffer_get_buffer(buffer) + document_start, &document_length, 4);
return 1;
}
static int lorun_ext_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(GETSTATE(m)->error);
return 0;
}
static int _cmessage_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(GETSTATE(m)->_cbson);
return 0;
}
static int _cmessage_clear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->_cbson);
return 0;
}
static PyObject* _cbson_query_message(PyObject* self, PyObject* args) {
/* NOTE just using a random number as the request_id */
struct module_state *state = GETSTATE(self);
int request_id = rand();
unsigned int options;
char* collection_name = NULL;
int collection_name_length;
int begin, cur_size, max_size = 0;
int num_to_skip;
int num_to_return;
PyObject* query;
PyObject* field_selector = Py_None;
unsigned char uuid_subtype = 3;
buffer_t buffer;
int length_location, message_length;
PyObject* result;
if (!PyArg_ParseTuple(args, "Iet#iiO|Ob",
&options,
"utf-8",
&collection_name,
&collection_name_length,
&num_to_skip, &num_to_return,
&query, &field_selector, &uuid_subtype)) {
return NULL;
}
buffer = buffer_new();
if (!buffer) {
PyErr_NoMemory();
PyMem_Free(collection_name);
return NULL;
}
// save space for message length
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
PyMem_Free(collection_name);
PyErr_NoMemory();
return NULL;
}
if (!buffer_write_bytes(buffer, (const char*)&request_id, 4) ||
!buffer_write_bytes(buffer, "\x00\x00\x00\x00\xd4\x07\x00\x00", 8) ||
!buffer_write_bytes(buffer, (const char*)&options, 4) ||
!buffer_write_bytes(buffer, collection_name,
collection_name_length + 1) ||
!buffer_write_bytes(buffer, (const char*)&num_to_skip, 4) ||
!buffer_write_bytes(buffer, (const char*)&num_to_return, 4)) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
begin = buffer_get_position(buffer);
if (!write_dict(state->_cbson, buffer, query, 0, uuid_subtype, 1)) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
max_size = buffer_get_position(buffer) - begin;
if (field_selector != Py_None) {
begin = buffer_get_position(buffer);
if (!write_dict(state->_cbson, buffer, field_selector, 0, uuid_subtype, 1)) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
cur_size = buffer_get_position(buffer) - begin;
max_size = (cur_size > max_size) ? cur_size : max_size;
}
PyMem_Free(collection_name);
message_length = buffer_get_position(buffer) - length_location;
memcpy(buffer_get_buffer(buffer) + length_location, &message_length, 4);
/* objectify buffer */
result = Py_BuildValue("i" BYTES_FORMAT_STRING "i", request_id,
buffer_get_buffer(buffer),
buffer_get_position(buffer),
max_size);
buffer_free(buffer);
return result;
}
static PyObject* _cbson_update_message(PyObject* self, PyObject* args) {
/* NOTE just using a random number as the request_id */
struct module_state *state = GETSTATE(self);
int request_id = rand();
char* collection_name = NULL;
int collection_name_length;
int before, cur_size, max_size = 0;
PyObject* doc;
PyObject* spec;
unsigned char multi;
unsigned char upsert;
unsigned char safe;
unsigned char check_keys;
unsigned char uuid_subtype;
PyObject* last_error_args;
int options;
buffer_t buffer;
int length_location, message_length;
PyObject* result;
if (!PyArg_ParseTuple(args, "et#bbOObObb",
"utf-8",
&collection_name,
&collection_name_length,
&upsert, &multi, &spec, &doc, &safe,
&last_error_args, &check_keys, &uuid_subtype)) {
return NULL;
}
options = 0;
if (upsert) {
options += 1;
}
if (multi) {
options += 2;
}
buffer = buffer_new();
if (!buffer) {
PyErr_NoMemory();
PyMem_Free(collection_name);
return NULL;
}
// save space for message length
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
PyMem_Free(collection_name);
PyErr_NoMemory();
return NULL;
}
if (!buffer_write_bytes(buffer, (const char*)&request_id, 4) ||
!buffer_write_bytes(buffer,
"\x00\x00\x00\x00"
"\xd1\x07\x00\x00"
"\x00\x00\x00\x00",
12) ||
!buffer_write_bytes(buffer,
collection_name,
collection_name_length + 1) ||
!buffer_write_bytes(buffer, (const char*)&options, 4)) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
before = buffer_get_position(buffer);
if (!write_dict(state->_cbson, buffer, spec, 0, uuid_subtype, 1)) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
max_size = buffer_get_position(buffer) - before;
before = buffer_get_position(buffer);
if (!write_dict(state->_cbson, buffer, doc, check_keys, uuid_subtype, 1)) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
cur_size = buffer_get_position(buffer) - before;
max_size = (cur_size > max_size) ? cur_size : max_size;
message_length = buffer_get_position(buffer) - length_location;
memcpy(buffer_get_buffer(buffer) + length_location, &message_length, 4);
if (safe) {
if (!add_last_error(self, buffer, request_id, collection_name,
collection_name_length, last_error_args)) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
}
PyMem_Free(collection_name);
/* objectify buffer */
result = Py_BuildValue("i" BYTES_FORMAT_STRING "i", request_id,
buffer_get_buffer(buffer),
buffer_get_position(buffer),
max_size);
buffer_free(buffer);
return result;
}
static PyObject* _cbson_insert_message(PyObject* self, PyObject* args) {
/* NOTE just using a random number as the request_id */
struct module_state *state = GETSTATE(self);
int request_id = rand();
char* collection_name = NULL;
int collection_name_length;
PyObject* docs;
PyObject* doc;
PyObject* iterator;
int before, cur_size, max_size = 0;
int options = 0;
unsigned char check_keys;
unsigned char safe;
unsigned char continue_on_error;
unsigned char uuid_subtype;
PyObject* last_error_args;
buffer_t buffer;
int length_location, message_length;
PyObject* result;
if (!PyArg_ParseTuple(args, "et#ObbObb",
"utf-8",
&collection_name,
&collection_name_length,
&docs, &check_keys, &safe,
&last_error_args,
&continue_on_error, &uuid_subtype)) {
return NULL;
}
if (continue_on_error) {
options += 1;
}
buffer = buffer_new();
if (!buffer) {
PyErr_NoMemory();
PyMem_Free(collection_name);
return NULL;
}
// save space for message length
length_location = buffer_save_space(buffer, 4);
if (length_location == -1) {
PyMem_Free(collection_name);
PyErr_NoMemory();
return NULL;
}
if (!buffer_write_bytes(buffer, (const char*)&request_id, 4) ||
!buffer_write_bytes(buffer,
"\x00\x00\x00\x00"
"\xd2\x07\x00\x00",
8) ||
!buffer_write_bytes(buffer, (const char*)&options, 4) ||
!buffer_write_bytes(buffer,
collection_name,
collection_name_length + 1)) {
PyMem_Free(collection_name);
buffer_free(buffer);
return NULL;
}
iterator = PyObject_GetIter(docs);
if (iterator == NULL) {
PyObject* InvalidOperation = _error("InvalidOperation");
PyErr_SetString(InvalidOperation, "input is not iterable");
Py_DECREF(InvalidOperation);
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
while ((doc = PyIter_Next(iterator)) != NULL) {
before = buffer_get_position(buffer);
if (!write_dict(state->_cbson, buffer, doc, check_keys, uuid_subtype, 1)) {
Py_DECREF(doc);
Py_DECREF(iterator);
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
Py_DECREF(doc);
cur_size = buffer_get_position(buffer) - before;
max_size = (cur_size > max_size) ? cur_size : max_size;
}
Py_DECREF(iterator);
if (PyErr_Occurred()) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
if (!max_size) {
PyObject* InvalidOperation = _error("InvalidOperation");
PyErr_SetString(InvalidOperation, "cannot do an empty bulk insert");
Py_DECREF(InvalidOperation);
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
message_length = buffer_get_position(buffer) - length_location;
memcpy(buffer_get_buffer(buffer) + length_location, &message_length, 4);
if (safe) {
if (!add_last_error(self, buffer, request_id, collection_name,
collection_name_length, last_error_args)) {
buffer_free(buffer);
PyMem_Free(collection_name);
return NULL;
}
}
PyMem_Free(collection_name);
/* objectify buffer */
result = Py_BuildValue("i" BYTES_FORMAT_STRING "i", request_id,
buffer_get_buffer(buffer),
buffer_get_position(buffer),
max_size);
buffer_free(buffer);
return result;
}
static int normalize_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(GETSTATE(m)->error);
return 0;
}
static int lorun_ext_clear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->error);
return 0;
}
static int normalize_clear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->error);
return 0;
}
static int alsaseq_clear(PyObject *m) {
Py_CLEAR(GETSTATE(m)->error);
return 0;
}
