int
iter_bson(const bson_t *bson, ERL_NIF_TERM *out, decode_state *ds)
{
vec_term_t vec;
bson_iter_t iter;
int ret = 0;
vec_init(&vec);
ds->vec = &vec;
if(!bson_iter_init(&iter, bson)) {
goto finish;
}
if(bson_iter_visit_all(&iter, &decode_visitors, ds) ||
iter.err_off) {
goto finish;
}
if(!make_document(ds->env, ds->vec, out, ds->return_maps)) {
goto finish;
}
ret = 1;
finish:
vec_deinit(&vec);
ds->vec = NULL;
return ret;
}
static PyObject *
cbson_loads (PyObject *self,
PyObject *args)
{
const bson_uint8_t *buffer;
bson_uint32_t buffer_length;
bson_reader_t reader;
bson_iter_t iter;
const bson_t *b;
bson_bool_t eof = FALSE;
PyObject *ret = NULL;
PyObject *dict;
if (!PyArg_ParseTuple(args, "s#", &buffer, &buffer_length)) {
return NULL;
}
ret = PyList_New(0);
bson_reader_init_from_data(&reader, buffer, buffer_length);
if (!(b = bson_reader_read(&reader, &eof))) {
PyErr_SetString(PyExc_ValueError, "Failed to parse buffer.");
goto failure;
}
do {
if (!bson_iter_init(&iter, b)) {
bson_reader_destroy(&reader);
goto failure;
}
dict = PyDict_New();
bson_iter_visit_all(&iter, &gLoadsVisitors, &dict);
if (dict) {
PyList_Append(ret, dict);
Py_DECREF(dict);
}
} while ((b = bson_reader_read(&reader, &eof)));
bson_reader_destroy(&reader);
if (!eof) {
PyErr_SetString(PyExc_ValueError, "Buffer contained invalid BSON.");
goto failure;
}
return ret;
failure:
Py_XDECREF(ret);
return NULL;
}
static void
bson_metrics (const bson_t *bson,
size_t *length,
void *data)
{
bson_metrics_state_t *state = data;
++state->doc_count;
bson_iter_t iter;
if (bson_iter_init (&iter, bson)) {
bson_iter_visit_all (&iter, &bson_metrics_visitors, data);
}
}
Array
cbson_loads (const bson_t * bson)
{
bson_iter_t iter;
Array ret = Array();
if (!bson_iter_init(&iter, bson))
{
mongoThrow<MongoException>("Failed to initialize BSON iterator");
}
bson_iter_visit_all(&iter, &gLoadsVisitors, &ret);
return ret;
}
static bool
bson_metrics_visit_array (const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data)
{
bson_metrics_state_t *state = data;
bson_iter_t child;
if (state->depth >= MAX_RECURSION) {
fprintf (stderr, "Invalid document, max recursion reached.\n");
return true;
}
if (bson_iter_init (&child, v_array)) {
state->depth++;
bson_iter_visit_all (&child, &bson_metrics_visitors, data);
state->depth--;
}
return false;
}
static bool
decode_visit_array(const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data)
{
decode_state *ds = data;
decode_state cs;
vec_term_t vec;
bson_iter_t child;
ERL_NIF_TERM out;
LOG("visit array: %s \r\n", key);
if(ds->depth >= MAX_DEPTHS) {
return true;
}
init_child_state(ds, &cs);
cs.keys = false;
cs.depth = ds->depth + 1;
if(!bson_iter_init(&child, v_array)) {
return true;
}
vec_init(&vec);
cs.vec = &vec;
if(bson_iter_visit_all(&child, &decode_visitors, &cs) ||
child.err_off) {
vec_deinit(&vec);
return true;
}
out = enif_make_list_from_array(cs.env, cs.vec->data, cs.vec->length);
vec_deinit(&vec);
vec_push(ds->vec, out);
return false;
}
static bson_bool_t
cbson_loads_visit_array (const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data)
{
bson_iter_t child;
PyObject **ret = data;
PyObject *obj;
bson_return_val_if_fail(iter, TRUE);
bson_return_val_if_fail(key, TRUE);
bson_return_val_if_fail(v_array, TRUE);
if (bson_iter_init(&child, v_array)) {
obj = PyList_New(0);
if (!bson_iter_visit_all(&child, &gLoadsVisitors, &obj)) {
cbson_loads_set_item(*ret, key, obj);
}
Py_XDECREF(obj);
}
return FALSE;
}
static bool
cbson_loads_visit_array (const bson_iter_t *iter,
const char *key,
const bson_t *v_array,
void *data)
{
bson_iter_t child;
Array * ret = (Array *) data;
Array obj;
bson_return_val_if_fail(iter, true);
bson_return_val_if_fail(key, true);
bson_return_val_if_fail(v_array, true);
if (bson_iter_init(&child, v_array))
{
obj = Array();
if (!bson_iter_visit_all(&child, &gLoadsVisitors, &obj))
{
ret->add(String(key), obj);
}
}
return false;
}
