static void
test_bson_oid_init_from_string (void)
{
bson_context_t context;
bson_oid_t oid;
char str[25];
int i;
bson_context_init(&context, BSON_CONTEXT_NONE);
/*
* Test successfully parsed oids.
*/
for (i = 0; gTestOids[i]; i++) {
bson_oid_init_from_string(&oid, gTestOids[i]);
bson_oid_to_string(&oid, str);
assert(!strcmp(str, gTestOids[i]));
}
/*
* Test the failures.
*/
for (i = 0; gTestOidsFail[i]; i++) {
bson_oid_init_from_string(&oid, gTestOidsFail[i]);
bson_oid_to_string(&oid, str);
assert(strcmp(str, gTestOidsFail[i]));
}
}
static void
test_bson_oid_init_from_string (void)
{
bson_context_t *context;
bson_oid_t oid;
char str[25];
int i;
context = bson_context_new (BSON_CONTEXT_NONE);
/*
* Test successfully parsed oids.
*/
for (i = 0; gTestOids[i]; i++) {
bson_oid_init_from_string (&oid, gTestOids[i]);
bson_oid_to_string (&oid, str);
BSON_ASSERT (!strcmp (str, gTestOids[i]));
}
/*
* Test successfully parsed oids (case-insensitive).
*/
for (i = 0; gTestOidsCase[i]; i++) {
char oid_lower[25];
int j;
bson_oid_init_from_string (&oid, gTestOidsCase[i]);
bson_oid_to_string (&oid, str);
BSON_ASSERT (!bson_strcasecmp (str, gTestOidsCase[i]));
for (j = 0; gTestOidsCase[i][j]; j++) {
oid_lower[j] = tolower (gTestOidsCase[i][j]);
}
oid_lower[24] = '\0';
BSON_ASSERT (!strcmp (str, oid_lower));
}
/*
* Test that sizeof(str) works (len of 25 with \0 instead of 24).
*/
BSON_ASSERT (bson_oid_is_valid ("ffffffffffffffffffffffff", 24));
bson_oid_init_from_string (&oid, "ffffffffffffffffffffffff");
bson_oid_to_string (&oid, str);
BSON_ASSERT (bson_oid_is_valid (str, sizeof str));
/*
* Test the failures.
*/
for (i = 0; gTestOidsFail[i]; i++) {
bson_oid_init_from_string (&oid, gTestOidsFail[i]);
bson_oid_to_string (&oid, str);
BSON_ASSERT (strcmp (str, gTestOidsFail[i]));
}
bson_context_destroy (context);
}
void f_mg_get_oid(){
char id[25];
bson_oid_t oid;
bson_oid_gen( &oid );
bson_oid_to_string(&oid,id);
copy_and_push_string(id);
}
std::string collection::insert(nlohmann::json::object_t const& document) throw(std::runtime_error)
{
bson_oid_t oid;
std::shared_ptr<bson> bson_doc = convert_to_bson(document);
if(document.find("_id") != document.end()) {
std::string const &id = document.find("_id")->second;
if(!ejdbisvalidoidstr(id.c_str())) {
throw ejdb_exception(JBEINVALIDBSONPK);
}
bson_oid_from_string(&oid, id.c_str());
std::shared_ptr<bson> bson_oid(bson_create(), bson_del);
bson_init(bson_oid.get());
bson_append_oid(bson_oid.get(), "_id", &oid);
bson_finish(bson_oid.get());
std::shared_ptr<bson> bson_doc_with_oid(bson_create(), bson_del);
bson_init(bson_doc_with_oid.get());
bson_merge(bson_oid.get(), bson_doc.get(), true, bson_doc_with_oid.get());
bson_finish(bson_doc_with_oid.get());
bson_doc.swap(bson_doc_with_oid);
}
if(!ejdbsavebson(_coll.get(), bson_doc.get(), &oid)) {
throw_last_ejdb_exception();
}
std::string id(24, '\0');
bson_oid_to_string(&oid, &id[0]);
document_added(id, document);
return id;
}
void bson_print_raw( const char * data , int depth ){
bson_iterator i;
const char * key;
int temp;
char oidhex[25];
bson_iterator_init( &i , data );
while ( bson_iterator_next( &i ) ){
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
key = bson_iterator_key( &i );
for ( temp=0; temp<=depth; temp++ )
printf( "\t" );
printf( "%s : %d \t " , key , t );
switch ( t ){
case bson_int: printf( "%d" , bson_iterator_int( &i ) ); break;
case bson_double: printf( "%f" , bson_iterator_double( &i ) ); break;
case bson_bool: printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" ); break;
case bson_string: printf( "%s" , bson_iterator_string( &i ) ); break;
case bson_null: printf( "null" ); break;
case bson_oid: bson_oid_to_string(bson_iterator_oid(&i), oidhex); printf( "%s" , oidhex ); break;
case bson_object:
case bson_array:
printf( "\n" );
bson_print_raw( bson_iterator_value( &i ) , depth + 1 );
break;
default:
fprintf( stderr , "can't print type : %d\n" , t );
}
printf( "\n" );
}
}
std::string oid::to_string() const {
bson_oid_t oid;
std::memcpy(oid.bytes, _bytes, sizeof(oid.bytes));
char str[25];
bson_oid_to_string(&oid, str);
return std::string(str);
}
void MongodbObject::SetUniqueObjectName()
{
char tmp[128];
bson_oid_t oid;
bson_oid_gen(&oid);
bson_oid_to_string(&oid, tmp);
SetObjectName(tmp);
}
void bsonToMongoId(bson_iter_t* iter, Array* output) {
const bson_oid_t* oid = bson_iter_oid(iter);
char id[25];
bson_oid_to_string(oid, id);
bsonToObject(iter, output,
&s_MongoId,
make_packed_array(String(id))
);
}
std::ostream& operator<<(std::ostream& out, const oid& rhs) {
bson_oid_t oid;
std::memcpy(oid.bytes, rhs._bytes, sizeof(oid.bytes));
char str[25];
bson_oid_to_string(&oid, str);
out << str;
return out;
}
//------------------------------------------------------------------------------
int main( int argc, char * argv[] ){
mongo conn;
if( mongo_client( &conn , TEST_SERVER, TEST_PORT ) != MONGO_OK ) {
std::cout << "failed to connect\n";
return EXIT_FAILURE;
}
mongo_cursor cursor;
mongo_cursor_init( &cursor, &conn, "test.test" );
char hex_oid[25];
while( mongo_cursor_next( &cursor ) == MONGO_OK ) {
std::cout << "row:\n";
bson_iterator it;
bson_iterator_init( &it, mongo_cursor_bson( &cursor ) );
while( bson_iterator_next( &it ) ) {
std::cout << " " << bson_iterator_key( &it ) << " = ";
switch( bson_iterator_type( &it ) ) {
case BSON_DOUBLE:
std::cout << "(double) " << bson_iterator_double( &it ) << std::endl;
break;
case BSON_INT:
std::cout << "(int) " << bson_iterator_int( &it ) << std::endl;
break;
case BSON_STRING:
std::cout << "(string) \"" << bson_iterator_string( &it ) << "\"\n";
break;
case BSON_OID:
bson_oid_to_string( bson_iterator_oid( &it ), hex_oid );
std::cout << "(oid) \"" << hex_oid << "\"\n";
break;
case BSON_OBJECT:
std::cout << "(subobject) {...}\n";
break;
case BSON_ARRAY:
std::cout << "(array) [...]\n";
break;
case BSON_TIMESTAMP:
std::cout << "(timestamp) [...]\n";
break;
default:
std::cout << "(type " << bson_iterator_type( &it ) << std::endl;
break;
}
}
std::cout << std::endl;
}
mongo_disconnect( &conn );
return EXIT_SUCCESS;
}
I32 __app_guid(lua_State* ls)
{
bson_oid_t oid;
CHAR stroid[25];
LUA_STACK;
LUA_WATCH(ls);
bson_oid_init(&oid, NULL);
bson_oid_to_string(&oid, stroid);
lua_pushstring(ls, stroid);
LUA_WATCH(ls);
return 1;
}
static String oidAsString(MongoDBBsonObjectIDData* data)
{
String s;
char *data_s;
s = String(24, ReserveString);
data_s = s.bufferSlice().data();
bson_oid_to_string(&data->m_oid, data_s);
s.setSize(24);
return s;
}
static bool
cbson_loads_visit_oid (const bson_iter_t *iter,
const char *key,
const bson_oid_t *oid,
void *output)
{
char id[25];
bson_oid_to_string(oid, id);
ObjectData * data = create_object(&s_MongoId,
make_packed_array(String(id)));
((Array *) output)->add(String(key), data);
return false;
}
static Variant HHVM_METHOD(MongoCollection, insert, Variant a, Array options) {
mongoc_collection_t *collection;
bson_t doc;
bson_error_t error;
collection = get_collection(this_);
Array& doc_array = a.toArrRef();
if (!doc_array.exists(String("_id"))) {
const StaticString s_MongoId("MongoId");
char id[25];
bson_oid_t oid;
bson_oid_init(&oid, NULL);
bson_oid_to_string(&oid, id);
ObjectData * data = create_object(&s_MongoId, make_packed_array(String(id)));
doc_array.add(String("_id"), data);
}
encodeToBSON(doc_array, &doc);
int w_flag = MONGOC_WRITE_CONCERN_W_DEFAULT;
//如果传递了参数
mongoc_write_concern_t *write_concern;
write_concern = mongoc_write_concern_new();
mongoc_write_concern_set_w(write_concern, w_flag);
bool ret = mongoc_collection_insert(collection, MONGOC_INSERT_NONE, &doc, write_concern, &error);
if (!ret) {
mongoThrow<MongoCursorException>((const char *) error.message);
}
mongoc_collection_destroy(collection);
bson_destroy(&doc);
return ret;
/*
bool mongoc_collection_insert (mongoc_collection_t *collection,
mongoc_insert_flags_t flags,
const bson_t *document,
const mongoc_write_concern_t *write_concern,
bson_error_t *error);
*/
}
static bool
cbson_loads_visit_dbpointer (const bson_iter_t *iter,
const char *key,
size_t v_collection_len,
const char *v_collection,
const bson_oid_t *v_oid,
void *output)
{
char id[25];
bson_oid_to_string(v_oid, id);
ObjectData * data = create_object(&s_MongoDBRef,
make_packed_array(
String(v_collection, v_collection_len, CopyString),
String(id)));
((Array *)output)->add(String(key), data);
return false;
//TODO: Finish this
}
SEXP ConvertValue(bson_iter_t* iter){
if(BSON_ITER_HOLDS_INT32(iter)){
return ScalarInteger(bson_iter_int32(iter));
} else if(BSON_ITER_HOLDS_NULL(iter)){
return R_NilValue;
} else if(BSON_ITER_HOLDS_BOOL(iter)){
return ScalarLogical(bson_iter_bool(iter));
} else if(BSON_ITER_HOLDS_DOUBLE(iter)){
return ScalarReal(bson_iter_double(iter));
} else if(BSON_ITER_HOLDS_INT64(iter)){
return ScalarReal((double) bson_iter_int64(iter));
} else if(BSON_ITER_HOLDS_UTF8(iter)){
return mkStringUTF8(bson_iter_utf8(iter, NULL));
} else if(BSON_ITER_HOLDS_CODE(iter)){
return mkStringUTF8(bson_iter_code(iter, NULL));
} else if(BSON_ITER_HOLDS_BINARY(iter)){
return ConvertBinary(iter);
} else if(BSON_ITER_HOLDS_DATE_TIME(iter)){
return ConvertDate(iter);
} else if(BSON_ITER_HOLDS_OID(iter)){
const bson_oid_t *val = bson_iter_oid(iter);
char str[25];
bson_oid_to_string(val, str);
return mkString(str);
} else if(BSON_ITER_HOLDS_ARRAY(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertArray(&child1, &child2);
} else if(BSON_ITER_HOLDS_DOCUMENT(iter)){
bson_iter_t child1;
bson_iter_t child2;
bson_iter_recurse (iter, &child1);
bson_iter_recurse (iter, &child2);
return ConvertObject(&child1, &child2);
} else {
stop("Unimplemented BSON type %d\n", bson_iter_type(iter));
}
}
void to_json(char *buf, const char * data, int depth){
int array_count = 0;
int object_count = 0;
bson_iterator i;
const char * key;
char oidhex[25];
bson_iterator_init( &i , data );
sprintf(buf+strlen(buf),"{");
while ( bson_iterator_next( &i ) ){
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
key = bson_iterator_key( &i );
if(object_count > 0){sprintf(buf+strlen(buf),",");}
else{object_count=1;}
sprintf(buf+strlen(buf), "\"%s\":" , key );
switch ( t ){
case bson_int:
sprintf(buf+strlen(buf), "%d" , bson_iterator_int( &i ) );
break;
case bson_double:
sprintf(buf+strlen(buf), "%f" , bson_iterator_double( &i ) );
break;
case bson_bool:
sprintf(buf+strlen(buf), "%s" , bson_iterator_bool( &i ) ? "true" : "false" );
break;
case bson_string:
sprintf(buf+strlen(buf), "\"%s\"" , bson_iterator_string( &i ) );
break;
case bson_null:
sprintf( buf+strlen(buf),"null" );
break;
case bson_oid:
bson_oid_to_string(bson_iterator_oid(&i), oidhex);
sprintf(buf+strlen(buf), "%s" , oidhex );
break;
case bson_object:
to_json(buf, bson_iterator_value( &i ) , depth + 1 );
break;
case bson_array:
sprintf(buf+strlen(buf), "[" );
bson_iterator j;
bson_iterator_init( &j , bson_iterator_value(&i) );
array_count =0;
while( bson_iterator_next(&j)){
if(array_count > 0){sprintf(buf+strlen(buf),",");}
else{array_count=1;}
to_json(buf, bson_iterator_value( &j ) , depth + 1 );
}
sprintf(buf+strlen(buf), "]" );
break;
default:
fprintf( stderr , "can't print type : %d\n" , t );
}
}
sprintf(buf+strlen(buf),"}");
}
INT32 _appendValue( CHAR delChar, bson_iterator *pIt,
CHAR **ppBuffer, INT32 *pCSVSize,
BOOLEAN includeBinary,
BOOLEAN includeRegex )
{
INT32 rc = SDB_OK ;
bson_type type = bson_iterator_type( pIt ) ;
INT32 tempSize = 0 ;
INT32 base64Size = 0 ;
INT32 binType = 0 ;
CHAR temp[128] = { 0 } ;
const CHAR *pTemp = NULL ;
CHAR *pBase64 = NULL ;
bson_timestamp_t ts;
time_t timer ;
struct tm psr;
if ( type == BSON_DOUBLE || type == BSON_BOOL ||
type == BSON_NULL || type == BSON_INT ||
type == BSON_LONG )
{
rc = _appendNonString( delChar, pIt, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else
{
rc = _appendString( delChar, &delChar, 1, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
if ( type == BSON_TIMESTAMP )
{
ts = bson_iterator_timestamp( pIt ) ;
timer = (time_t)ts.t;
local_time( &timer, &psr ) ;
tempSize = ossSnprintf ( temp, 64,
"%04d-%02d-%02d-%02d.%02d.%02d.%06d",
psr.tm_year + 1900,
psr.tm_mon + 1,
psr.tm_mday,
psr.tm_hour,
psr.tm_min,
psr.tm_sec,
ts.i ) ;
rc = _appendString( delChar, temp, tempSize, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else if ( type == BSON_DATE )
{
timer = bson_iterator_date( pIt ) / 1000 ;
local_time( &timer, &psr ) ;
tempSize = ossSnprintf ( temp, 64, "%04d-%02d-%02d",
psr.tm_year + 1900,
psr.tm_mon + 1,
psr.tm_mday ) ;
rc = _appendString( delChar, temp, tempSize, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else if ( type == BSON_UNDEFINED )
{
rc = _appendString( delChar, CSV_STR_UNDEFINED,
CSV_STR_UNDEFINED_SIZE,
ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else if ( type == BSON_MINKEY )
{
rc = _appendString( delChar, CSV_STR_MINKEY,
CSV_STR_MINKEY_SIZE, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else if ( type == BSON_MAXKEY )
{
rc = _appendString( delChar, CSV_STR_MAXKEY,
CSV_STR_MAXKEY_SIZE, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else if ( type == BSON_CODE )
{
pTemp = bson_iterator_code( pIt ) ;
rc = _appendString( delChar, pTemp, ossStrlen( pTemp ),
ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else if ( type == BSON_STRING || type == BSON_SYMBOL )
{
pTemp = bson_iterator_string( pIt ) ;
rc = _appendString( delChar, pTemp, ossStrlen( pTemp ),
ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else if ( type == BSON_BINDATA )
{
if( TRUE == includeBinary )
{
rc = _appendString( delChar, CSV_STR_LEFTBRACKET, 1, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
binType = (INT32)bson_iterator_bin_type( pIt ) ;
tempSize = ossSnprintf ( temp, 64, "%d", binType ) ;
rc = _appendString( delChar, &temp, tempSize, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
rc = _appendString( delChar, CSV_STR_RIGHTBRACKET, 1, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
pTemp = bson_iterator_bin_data( pIt ) ;
tempSize = bson_iterator_bin_len ( pIt ) ;
base64Size = getEnBase64Size ( tempSize ) ;
pBase64 = (CHAR *)SDB_OSS_MALLOC( base64Size ) ;
if( NULL == pBase64 )
{
rc = SDB_OOM ;
goto error ;
}
ossMemset( pBase64, 0, base64Size ) ;
if ( !base64Encode( pTemp, tempSize, pBase64, base64Size ) )
{
rc = SDB_OOM ;
goto error ;
}
rc = _appendString( delChar, pBase64, base64Size - 1,
ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else if ( type == BSON_REGEX )
{
if( TRUE == includeRegex )
{
rc = _appendString( delChar, CSV_STR_BACKSLASH, 1,
ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
pTemp = bson_iterator_regex( pIt ) ;
rc = _appendString( delChar, pTemp, ossStrlen( pTemp ),
ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
if( TRUE == includeRegex )
{
rc = _appendString( delChar, CSV_STR_BACKSLASH, 1,
ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
pTemp = bson_iterator_regex_opts( pIt ) ;
rc = _appendString( delChar, pTemp, ossStrlen( pTemp ),
ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
}
else if ( type == BSON_OID )
{
bson_oid_to_string( bson_iterator_oid( pIt ), temp ) ;
rc = _appendString( delChar, temp, 24, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
else
{
rc = _appendObj( delChar, pIt, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
rc = _appendString( delChar, &delChar, 1, ppBuffer, pCSVSize ) ;
if ( rc )
{
goto error ;
}
}
done:
SAFE_OSS_FREE( pBase64 ) ;
return rc ;
error:
goto done ;
}
int main(){
mongo_connection conn[1];
mongo_connection_options opts;
bson_buffer bb;
bson b;
mongo_cursor * cursor;
int i;
char hex_oid[25];
const char * col = "c.simple";
const char * ns = "test.c.simple";
INIT_SOCKETS_FOR_WINDOWS;
strncpy(opts.host, TEST_SERVER, 255);
opts.host[254] = '\0';
opts.port = 27017;
if (mongo_connect( conn , &opts )){
printf("failed to connect\n");
exit(1);
}
/* if the collection doesn't exist dropping it will fail */
if (!mongo_cmd_drop_collection(conn, "test", col, NULL)
&& mongo_find_one(conn, ns, bson_empty(&b), bson_empty(&b), NULL)){
printf("failed to drop collection\n");
exit(1);
}
for(i=0; i< 5; i++){
bson_buffer_init( & bb );
bson_append_new_oid( &bb, "_id" );
bson_append_double( &bb , "a" , 17 );
bson_append_int( &bb , "b" , 17 );
bson_append_string( &bb , "c" , "17" );
{
bson_buffer * sub = bson_append_start_object( &bb , "d" );
bson_append_int( sub, "i", 71 );
bson_append_finish_object(sub);
}
{
bson_buffer * arr = bson_append_start_array( &bb , "e" );
bson_append_int( arr, "0", 71 );
bson_append_string( arr, "1", "71" );
bson_append_finish_object(arr);
}
bson_from_buffer(&b, &bb);
mongo_insert( conn , ns , &b );
bson_destroy(&b);
}
cursor = mongo_find( conn , ns , bson_empty(&b) , 0 , 0 , 0 , 0 );
while (mongo_cursor_next(cursor)){
bson_iterator it;
bson_iterator_init(&it, cursor->current.data);
while(bson_iterator_next(&it)){
fprintf(stderr, " %s: ", bson_iterator_key(&it));
switch(bson_iterator_type(&it)){
case bson_double:
fprintf(stderr, "(double) %e\n", bson_iterator_double(&it));
break;
case bson_int:
fprintf(stderr, "(int) %d\n", bson_iterator_int(&it));
break;
case bson_string:
fprintf(stderr, "(string) \"%s\"\n", bson_iterator_string(&it));
break;
case bson_oid:
bson_oid_to_string(bson_iterator_oid(&it), hex_oid);
fprintf(stderr, "(oid) \"%s\"\n", hex_oid);
break;
case bson_object:
fprintf(stderr, "(subobject) {...}\n");
break;
case bson_array:
fprintf(stderr, "(array) [...]\n");
break;
default:
fprintf(stderr, "(type %d)\n", bson_iterator_type(&it));
break;
}
}
fprintf(stderr, "\n");
}
mongo_cursor_destroy(cursor);
mongo_cmd_drop_db(conn, "test");
mongo_destroy( conn );
return 0;
}
static char *
bson_to_json_recurse(StringInfo buf, const char *data, bool is_object)
{
bson_iterator i;
const char *key;
char oidhex[25];
char *str;
bool first = true;
bson_iterator_from_buffer(&i, data);
while (bson_iterator_next(&i))
{
bson_type t = bson_iterator_type(&i);
if (t == 0)
break;
if (!first)
appendStringInfoChar(buf, ',');
first = false;
if (is_object)
{
key = bson_iterator_key(&i);
appendStringInfo(buf, "\"%s\"", key);
appendStringInfoChar(buf, ':');
}
switch (t)
{
case BSON_DOUBLE:
appendStringInfo(buf, "%f", bson_iterator_double(&i));
break;
case BSON_STRING:
str = quote_string(bson_iterator_string(&i));
appendStringInfoString(buf, str);
break;
case BSON_OID:
bson_oid_to_string(bson_iterator_oid(&i), oidhex);
str = quote_string(oidhex);
appendStringInfoString(buf, str);
break;
case BSON_BOOL:
appendStringInfoString(buf, bson_iterator_bool(&i) ? "true" : "false");
break;
case BSON_INT:
appendStringInfo(buf, "%d", bson_iterator_int(&i));
break;
case BSON_LONG:
appendStringInfo(buf, "%lld", (uint64_t) bson_iterator_long(&i));
break;
case BSON_NULL:
appendStringInfoString(buf, "null");
break;
case BSON_OBJECT:
appendStringInfoChar(buf, '{');
bson_to_json_recurse(buf, bson_iterator_value(&i), true);
appendStringInfoChar(buf, '}');
break;
case BSON_ARRAY:
appendStringInfoChar(buf, '[');
bson_to_json_recurse(buf, bson_iterator_value(&i), false);
appendStringInfoChar(buf, ']');
break;
case BSON_DATE:
case BSON_TIMESTAMP:
case BSON_SYMBOL:
case BSON_BINDATA:
case BSON_UNDEFINED:
case BSON_REGEX:
case BSON_CODE:
case BSON_CODEWSCOPE:
ereport(ERROR,
(errmsg("unsupported bson type: %d", t)));
break;
default:
elog(ERROR, "unknown bson type: %d", t);
break;
}
}
return buf->data;
}
void lua_push_bson_value(lua_State *L, bson_iterator *it) {
bson_type bt = bson_iterator_type(it);
switch (bt) {
case BSON_OID:
{
char xoid[25];
bson_oid_to_string(bson_iterator_oid(it), xoid);
lua_pushstring(L, xoid);
break;
}
case BSON_STRING:
case BSON_SYMBOL:
lua_pushstring(L, bson_iterator_string(it));
break;
case BSON_NULL:
case BSON_UNDEFINED:
lua_push_bsontype_table(L, bt);
break;
case BSON_INT:
lua_pushinteger(L, bson_iterator_int(it));
break;
case BSON_LONG:
case BSON_DOUBLE:
lua_pushnumber(L, (lua_Number) bson_iterator_double(it));
break;
case BSON_BOOL:
lua_pushboolean(L, bson_iterator_bool(it));
break;
case BSON_OBJECT:
case BSON_ARRAY:
{
bson_iterator nit;
bson_iterator_subiterator(it, &nit);
if (bt == BSON_OBJECT) {
lua_push_bson_table(L, &nit);
} else {
lua_push_bson_array(L, &nit);
}
break;
}
case BSON_DATE:
{
lua_push_bsontype_table(L, bt);
lua_pushnumber(L, bson_iterator_date(it));
lua_rawseti(L, -2, 1);
break;
}
case BSON_BINDATA:
{
lua_push_bsontype_table(L, bt);
lua_pushlstring(L, bson_iterator_bin_data(it), bson_iterator_bin_len(it));
break;
}
case BSON_REGEX:
{
const char *re = bson_iterator_regex(it);
const char *ro = bson_iterator_regex_opts(it);
lua_push_bsontype_table(L, bt);
lua_pushstring(L, re);
lua_rawseti(L, -2, 1);
lua_pushstring(L, ro);
lua_rawseti(L, -2, 2);
break;
}
default:
break;
}
}
static void bson_print_xstr(TCXSTR* xstr, const char *data, int depth) {
bson_iterator i;
const char *key;
int temp;
bson_timestamp_t ts;
char oidhex[25];
bson scope;
bson_iterator_from_buffer(&i, data);
while (bson_iterator_next(&i)) {
bson_type t = bson_iterator_type(&i);
if (t == 0)
break;
key = bson_iterator_key(&i);
for (temp = 0; temp <= depth; temp++) {
tcxstrprintf(xstr, ".");
}
tcxstrprintf(xstr, "%s(%d)=", key, t);
switch (t) {
case BSON_DOUBLE:
tcxstrprintf(xstr, "%f", bson_iterator_double(&i));
break;
case BSON_STRING:
tcxstrprintf(xstr, "%s", bson_iterator_string(&i));
break;
case BSON_SYMBOL:
tcxstrprintf(xstr, "SYMBOL: %s", bson_iterator_string(&i));
break;
case BSON_OID:
bson_oid_to_string(bson_iterator_oid(&i), oidhex);
tcxstrprintf(xstr, "%s", oidhex);
break;
case BSON_BOOL:
tcxstrprintf(xstr, "%s", bson_iterator_bool(&i) ? "true" : "false");
break;
case BSON_DATE:
tcxstrprintf(xstr, "%lld", (uint64_t) bson_iterator_long(&i));
break;
case BSON_BINDATA:
tcxstrprintf(xstr, "BSON_BINDATA");
break;
case BSON_UNDEFINED:
tcxstrprintf(xstr, "BSON_UNDEFINED");
break;
case BSON_NULL:
tcxstrprintf(xstr, "BSON_NULL");
break;
case BSON_REGEX:
tcxstrprintf(xstr, "BSON_REGEX: %s", bson_iterator_regex(&i));
break;
case BSON_CODE:
tcxstrprintf(xstr, "BSON_CODE: %s", bson_iterator_code(&i));
break;
case BSON_CODEWSCOPE:
tcxstrprintf(xstr, "BSON_CODE_W_SCOPE: %s", bson_iterator_code(&i));
/* bson_init( &scope ); */ /* review - stepped on by bson_iterator_code_scope? */
bson_iterator_code_scope(&i, &scope);
tcxstrprintf(xstr, "\n SCOPE: ");
bson_print_xstr(xstr, scope.data, 0);
/* bson_destroy( &scope ); */ /* review - causes free error */
break;
case BSON_INT:
tcxstrprintf(xstr, "%d", bson_iterator_int(&i));
break;
case BSON_LONG:
tcxstrprintf(xstr, "%lld", (uint64_t) bson_iterator_long(&i));
break;
case BSON_TIMESTAMP:
ts = bson_iterator_timestamp(&i);
tcxstrprintf(xstr, "i: %d, t: %d", ts.i, ts.t);
break;
case BSON_OBJECT:
case BSON_ARRAY:
tcxstrprintf(xstr, "\n");
bson_print_xstr(xstr, bson_iterator_value(&i), depth + 1);
break;
default:
fprintf(stderr, "can't print type : %d\n", t);
}
tcxstrprintf(xstr, "\n");
}
}
char* Namespace::bson_to_json(char* val, const char *data, int depth,
bool isObject, int bsonSize, int &jsonSize, int &cursor)
{
char *object;
int bufSize;
char keybuf[512];
char buf[512];
int c = 0;
bson_iterator i;
const char *key;
int temp;
bson_timestamp_t ts;
char oidhex[25];
bson scope;
bson_iterator_from_buffer(&i, data);
//bson_iterator_init(&i, data);
if (isObject)
{
memcpy(&val[cursor], "{", 1);
cursor += 1;
}
else
{
memcpy(&val[cursor], "[", 1);
cursor += 1;
}
while (bson_iterator_next(&i) && i.progress < bsonSize)
{
if (c > 0)
{
memcpy(&val[cursor], ",", 1);
cursor += 1;
}
c++;
bson_type t = bson_iterator_type(&i);
if (t == 0)
{
break;
}
key = bson_iterator_key(&i);
if (key[0] != '\0')
{
sprintf(keybuf, "\"%s\":", key);
key = &keybuf[0];
}
switch (t)
{
case BSON_DOUBLE:
sprintf(buf, "%s%f", key, bson_iterator_double(&i));
bufSize = strlen(buf);
memcpy(&val[cursor], buf, bufSize);
cursor += bufSize;
break;
case BSON_STRING:
sprintf(buf, "%s\"%s\"", key, bson_iterator_string(&i));
bufSize = strlen(buf);
memcpy(&val[cursor], buf, bufSize);
cursor += bufSize;
break;
case BSON_OID:
bson_oid_to_string(bson_iterator_oid(&i), oidhex);
sprintf(buf, "%s\"%s\"", key, oidhex);
bufSize = strlen(buf);
memcpy(&val[cursor], buf, bufSize);
cursor += bufSize;
break;
case BSON_BOOL:
sprintf(buf, "%s%s", key,
bson_iterator_bool(&i) ? "true" : "false");
bufSize = strlen(buf);
memcpy(&val[cursor], buf, bufSize);
cursor += bufSize;
break;
case BSON_NULL:
sprintf(buf, "%snull", key);
bufSize = strlen(buf);
memcpy(&val[cursor], buf, bufSize);
cursor += bufSize;
break;
case BSON_INT:
sprintf(buf, "%s%d", key, bson_iterator_int(&i));
bufSize = strlen(buf);
memcpy(&val[cursor], buf, bufSize);
cursor += bufSize;
break;
case BSON_OBJECT:
sprintf(buf, "%s\0", key);
memcpy(&val[cursor], buf, strlen(buf));
cursor += strlen(buf);
object = bson_to_json(val, bson_iterator_value(&i), depth + 1, true,
bsonSize - cursor, jsonSize, cursor);
break;
case BSON_ARRAY:
sprintf(buf, "%s", key);
bufSize = strlen(buf);
memcpy(&val[cursor], buf, bufSize);
cursor += bufSize;
object = bson_to_json(val, bson_iterator_value(&i), depth + 1,
false, bsonSize - cursor, jsonSize, cursor);
break;
default:
LOGE("can't print type");
FORCE_LOG_INT("type: ", t);
memcpy(&val[cursor], "}", 1);
cursor += 1;
jsonSize = cursor;
return val;
}
}
if (isObject)
{
memcpy(&val[cursor], "}", 1);
cursor += 1;
memcpy(&val[cursor], "\0", 1);
}
else
{
memcpy(&val[cursor], "]", 1);
cursor += 1;
}
jsonSize = cursor;
return val;
}
int
mongotcl_bsontoarray_raw (Tcl_Interp *interp, char *arrayName, char *typeArrayName, const char *data , int depth) {
bson_iterator i;
const char *key;
bson_timestamp_t ts;
char oidhex[25];
Tcl_Obj *obj;
char *type;
if (data == NULL) {
return TCL_OK;
}
bson_iterator_from_buffer(&i, data);
while (bson_iterator_next (&i)) {
bson_type t = bson_iterator_type (&i);
if (t == 0) {
break;
}
key = bson_iterator_key (&i);
switch (t) {
case BSON_DOUBLE: {
obj = Tcl_NewDoubleObj (bson_iterator_double (&i));
type = "double";
break;
}
case BSON_SYMBOL: {
obj = Tcl_NewStringObj (bson_iterator_string (&i), -1);
type = "symbol";
break;
}
case BSON_STRING: {
obj = Tcl_NewStringObj (bson_iterator_string (&i), -1);
type = "string";
break;
}
case BSON_OID: {
bson_oid_to_string( bson_iterator_oid( &i ), oidhex );
obj = Tcl_NewStringObj (oidhex, -1);
type = "oid";
break;
}
case BSON_BOOL: {
obj = Tcl_NewBooleanObj (bson_iterator_bool (&i));
type = "bool";
break;
}
case BSON_DATE: {
obj = Tcl_NewLongObj ((long) bson_iterator_date(&i));
type = "date";
break;
}
case BSON_BINDATA: {
unsigned char *bindata = (unsigned char *)bson_iterator_bin_data (&i);
int binlen = bson_iterator_bin_len (&i);
obj = Tcl_NewByteArrayObj (bindata, binlen);
type = "bin";
break;
}
case BSON_UNDEFINED: {
obj = Tcl_NewObj ();
type = "undefined";
break;
}
case BSON_NULL: {
obj = Tcl_NewObj ();
type = "null";
break;
}
case BSON_REGEX: {
obj = Tcl_NewStringObj (bson_iterator_regex (&i), -1);
type = "regex";
break;
}
case BSON_CODE: {
obj = Tcl_NewStringObj (bson_iterator_code (&i), -1);
type = "code";
break;
}
case BSON_CODEWSCOPE: {
// bson_printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) );
/* bson_init( &scope ); */ /* review - stepped on by bson_iterator_code_scope? */
// bson_iterator_code_scope( &i, &scope );
// bson_printf( "\n\t SCOPE: " );
// bson_print( &scope );
/* bson_destroy( &scope ); */ /* review - causes free error */
break;
}
case BSON_INT: {
obj = Tcl_NewIntObj (bson_iterator_int (&i));
type = "int";
break;
}
case BSON_LONG: {
obj = Tcl_NewLongObj ((uint64_t)bson_iterator_long (&i));
type = "long";
break;
}
case BSON_TIMESTAMP: {
char string[64];
ts = bson_iterator_timestamp (&i);
snprintf(string, sizeof(string), "%d:%d", ts.i, ts.t);
obj = Tcl_NewStringObj (bson_iterator_string (&i), -1);
type = "timestamp";
break;
}
case BSON_ARRAY: {
obj = Tcl_NewObj();
obj = mongotcl_bsontolist_raw (interp, obj, bson_iterator_value (&i), depth + 1);
type = "array";
break;
}
case BSON_OBJECT: {
Tcl_Obj *subList = Tcl_NewObj ();
obj = mongotcl_bsontolist_raw (interp, subList, bson_iterator_value (&i), depth + 1);
type = "object";
break;
}
default: {
obj = Tcl_NewIntObj (t);
type = "unknown";
break;
}
}
if (Tcl_SetVar2Ex (interp, arrayName, key, obj, TCL_LEAVE_ERR_MSG) == NULL) {
return TCL_ERROR;
}
if (typeArrayName != NULL) {
if (Tcl_SetVar2Ex (interp, typeArrayName, key, Tcl_NewStringObj (type, -1), TCL_LEAVE_ERR_MSG) == NULL) {
return TCL_ERROR;
}
}
}
return TCL_OK;
}
QVariantMap TBson::fromBson(const TBsonObject *obj)
{
QVariantMap ret;
bson_iter_t it;
const bson_t *bson = (const bson_t *)obj;
bson_iter_init(&it, bson);
while (bson_iter_next(&it)) {
bson_type_t t = bson_iter_type(&it);
QString key(bson_iter_key(&it));
switch (t) {
case BSON_TYPE_EOD:
return ret;
break;
case BSON_TYPE_DOUBLE:
ret[key] = bson_iter_double(&it);
break;
case BSON_TYPE_UTF8:
ret[key] = QString::fromUtf8(bson_iter_utf8(&it, nullptr));
break;
case BSON_TYPE_ARRAY: {
const uint8_t *docbuf = nullptr;
uint32_t doclen = 0;
bson_t sub[1];
bson_iter_array(&it, &doclen, &docbuf);
if (bson_init_static(sub, docbuf, doclen)) {
ret[key] = fromBson(sub).values();
}
break; }
case BSON_TYPE_DOCUMENT: {
const uint8_t *docbuf = nullptr;
uint32_t doclen = 0;
bson_t sub[1];
bson_iter_document(&it, &doclen, &docbuf);
if (bson_init_static(sub, docbuf, doclen)) {
ret[key] = fromBson(sub);
}
break; }
case BSON_TYPE_BINARY: {
const uint8_t *binary = nullptr;
bson_subtype_t subtype = BSON_SUBTYPE_BINARY;
uint32_t len = 0;
bson_iter_binary(&it, &subtype, &len, &binary);
if (binary) {
ret[key] = QByteArray((char *)binary, len);
}
break; }
case BSON_TYPE_UNDEFINED:
ret[key] = QVariant();
break;
case BSON_TYPE_OID: {
char oidhex[25];
bson_oid_to_string(bson_iter_oid(&it), oidhex);
ret[key] = QString(oidhex);
break; }
case BSON_TYPE_BOOL:
ret[key] = (bool)bson_iter_bool(&it);
break;
case BSON_TYPE_DATE_TIME: {
#if QT_VERSION >= 0x040700
QDateTime date;
date.setMSecsSinceEpoch(bson_iter_date_time(&it));
#else
qint64 val = bson_iter_date_time(&it);
qint64 days = val / 86400000; // 24*60*60*1000
int msecs = val % 86400000;
QDate dt = QDate(1970, 1, 1).addDays(days);
QTime tm = QTime(0, 0, 0).addMSecs(msecs);
QDateTime date(dt, tm, Qt::UTC);
#endif
ret[key] = date;
break; }
case BSON_TYPE_NULL:
ret[key] = QVariant();
break;
case BSON_TYPE_REGEX:
ret[key] = QRegExp(QLatin1String(bson_iter_regex(&it, nullptr)));
break;
case BSON_TYPE_CODE:
ret[key] = QString(bson_iter_code(&it, nullptr));
break;
case BSON_TYPE_SYMBOL:
ret[key] = QString(bson_iter_symbol(&it, nullptr));
break;
case BSON_TYPE_INT32:
ret[key] = bson_iter_int32(&it);
break;
case BSON_TYPE_INT64:
ret[key] = (qint64)bson_iter_int64(&it);
break;
case BSON_TYPE_CODEWSCOPE: // FALL THROUGH
case BSON_TYPE_TIMESTAMP: // FALL THROUGH (internal use)
// do nothing
break;
default:
tError("fromBson() unknown type: %d", t);
break;
}
//tSystemDebug("fromBson : t:%d key:%s = %s", t, qPrintable(key), qPrintable(ret[key].toString()));
}
return ret;
}
void bson_print_raw( const char *data , int depth ) {
bson_iterator i;
const char *key;
int temp;
bson_timestamp_t ts;
char oidhex[25];
bson scope;
bson_iterator_from_buffer( &i, data );
while ( bson_iterator_next( &i ) ) {
bson_type t = bson_iterator_type( &i );
if ( t == 0 )
break;
key = bson_iterator_key( &i );
for ( temp=0; temp<=depth; temp++ )
printf( "\t" );
bson_printf( "%s : %d \t " , key , t );
switch ( t ) {
case BSON_DOUBLE:
printf( "%f" , bson_iterator_double( &i ) );
break;
case BSON_STRING:
printf( "%s" , bson_iterator_string( &i ) );
break;
case BSON_SYMBOL:
printf( "SYMBOL: %s" , bson_iterator_string( &i ) );
break;
case BSON_OID:
bson_oid_to_string( bson_iterator_oid( &i ), oidhex );
printf( "%s" , oidhex );
break;
case BSON_BOOL:
printf( "%s" , bson_iterator_bool( &i ) ? "true" : "false" );
break;
case BSON_DATE:
printf( "%ld" , ( long int )bson_iterator_date( &i ) );
break;
case BSON_BINDATA:
printf( "BSON_BINDATA" );
break;
case BSON_UNDEFINED:
printf( "BSON_UNDEFINED" );
break;
case BSON_NULL:
printf( "BSON_NULL" );
break;
case BSON_REGEX:
printf( "BSON_REGEX: %s", bson_iterator_regex( &i ) );
break;
case BSON_CODE:
printf( "BSON_CODE: %s", bson_iterator_code( &i ) );
break;
case BSON_CODEWSCOPE:
printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) );
bson_init( &scope );
bson_iterator_code_scope( &i, &scope );
printf( "\n\t SCOPE: " );
bson_print( &scope );
break;
case BSON_INT:
printf( "%d" , bson_iterator_int( &i ) );
break;
case BSON_LONG:
printf( "%lld" , ( long long int )bson_iterator_long( &i ) );
break;
case BSON_TIMESTAMP:
ts = bson_iterator_timestamp( &i );
printf( "i: %d, t: %d", ts.i, ts.t );
break;
case BSON_OBJECT:
case BSON_ARRAY:
printf( "\n" );
bson_print_raw( bson_iterator_value( &i ) , depth + 1 );
break;
default:
bson_errprintf( "can't print type : %d\n" , t );
}
printf( "\n" );
}
}
INLINE void bson_to_v P2(bson_iterator *, i, svalue_t *, v){
int temp;
const char *cp;
char oidhex[25];
bson scope;
bson_type t;
bson_timestamp_t ts;
t = bson_iterator_type( i );
switch ( t ) {
case BSON_DOUBLE:
v->type = T_REAL;
v->u.real = bson_iterator_double( i );
break;
case BSON_STRING:
cp = bson_iterator_string( i );
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy(cp,"bson_to_v:1");
break;
case BSON_SYMBOL:
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy("SYMBOL","bson_to_v:2");
break;
case BSON_OID:
bson_oid_to_string( bson_iterator_oid( i ), oidhex );
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy(oidhex,"bson_to_v:3");
break;
case BSON_BOOL:
v->type = T_NUMBER;
v->u.number = ( long )bson_iterator_bool( i );
break;
case BSON_DATE:
v->type = T_NUMBER;
v->u.number = ( long )bson_iterator_date( i );
break;
case BSON_BINDATA:
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy("BSON_BINDATA","bson_to_v:4");
break;
case BSON_UNDEFINED:
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy("BSON_UNDEFINED","bson_to_v:5");
break;
case BSON_NULL:
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy("BSON_NULL","bson_to_v:6");
break;
case BSON_REGEX:
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy("BSON_REGEX","bson_to_v:7");
break;
case BSON_CODE:
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy("BSON_CODE","bson_to_v:8");
break;
case BSON_CODEWSCOPE:
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy("BSON_CODEWSCOPE","bson_to_v:9");
break;
case BSON_INT:
v->type = T_NUMBER;
v->u.number = ( long )bson_iterator_int( i );
break;
case BSON_LONG:
v->type = T_NUMBER;
v->u.number = ( long )bson_iterator_long( i );
break;
case BSON_TIMESTAMP:
ts = bson_iterator_timestamp( i );
v->type = T_NUMBER;
v->u.number = ( long )ts.t;
break;
case BSON_OBJECT:
bson_to_mapping( bson_iterator_value( i ) , v);
break;
case BSON_ARRAY:
bson_to_array( bson_iterator_value( i ) , v);
break;
default:
v->type = T_STRING;
v->subtype = STRING_MALLOC;
v->u.string = string_copy("UNKOWN_TYPE","bson_to_v:10");
break;
}
}
EXPORT const char* mongo_bson_oid_to_string(void* oid) {
static char s[25];
bson_oid_to_string((bson_oid_t*) oid, s);
return s;
}
Tcl_Obj *
mongotcl_bsontolist_raw (Tcl_Interp *interp, Tcl_Obj *listObj, const char *data , int depth) {
bson_iterator i;
const char *key;
bson_timestamp_t ts;
char oidhex[25];
bson scope;
if (data == NULL) {
return listObj;
}
bson_iterator_from_buffer(&i, data);
while (bson_iterator_next (&i)) {
bson_type t = bson_iterator_type (&i);
if (t == 0) {
break;
}
key = bson_iterator_key (&i);
switch (t) {
case BSON_DOUBLE: {
append_list_type_object (interp, listObj, "double", key, Tcl_NewDoubleObj (bson_iterator_double (&i)));
break;
}
case BSON_STRING: {
append_list_type_object (interp, listObj, "string", key, Tcl_NewStringObj (bson_iterator_string (&i), -1));
break;
}
case BSON_SYMBOL: {
append_list_type_object (interp, listObj, "symbol", key, Tcl_NewStringObj (bson_iterator_string (&i), -1));
break;
}
case BSON_OID: {
bson_oid_to_string( bson_iterator_oid( &i ), oidhex );
append_list_type_object (interp, listObj, "oid", key, Tcl_NewStringObj (oidhex, -1));
break;
}
case BSON_BOOL: {
append_list_type_object (interp, listObj, "bool", key, Tcl_NewBooleanObj (bson_iterator_bool (&i)));
break;
}
case BSON_DATE: {
append_list_type_object (interp, listObj, "date", key, Tcl_NewLongObj ((long) bson_iterator_date(&i)));
break;
}
case BSON_BINDATA: {
unsigned char *bindata = (unsigned char *)bson_iterator_bin_data (&i);
int binlen = bson_iterator_bin_len (&i);
append_list_type_object (interp, listObj, "bin", key, Tcl_NewByteArrayObj (bindata, binlen));
break;
}
case BSON_UNDEFINED: {
append_list_type_object (interp, listObj, "undefined", key, Tcl_NewObj ());
break;
}
case BSON_NULL: {
append_list_type_object (interp, listObj, "null", key, Tcl_NewObj ());
break;
}
case BSON_REGEX: {
append_list_type_object (interp, listObj, "regex", key, Tcl_NewStringObj (bson_iterator_regex (&i), -1));
break;
}
case BSON_CODE: {
append_list_type_object (interp, listObj, "code", key, Tcl_NewStringObj (bson_iterator_code (&i), -1));
break;
}
case BSON_CODEWSCOPE: {
bson_printf( "BSON_CODE_W_SCOPE: %s", bson_iterator_code( &i ) );
/* bson_init( &scope ); */ /* review - stepped on by bson_iterator_code_scope? */
bson_iterator_code_scope( &i, &scope );
bson_printf( "\n\t SCOPE: " );
bson_print( &scope );
/* bson_destroy( &scope ); */ /* review - causes free error */
break;
}
case BSON_INT: {
append_list_type_object (interp, listObj, "int", key, Tcl_NewIntObj (bson_iterator_int (&i)));
break;
}
case BSON_LONG: {
append_list_type_object (interp, listObj, "long", key, Tcl_NewLongObj ((uint64_t)bson_iterator_long (&i)));
break;
}
case BSON_TIMESTAMP: {
char string[64];
ts = bson_iterator_timestamp (&i);
snprintf(string, sizeof(string), "%d:%d", ts.i, ts.t);
append_list_type_object (interp, listObj, "timestamp", key, Tcl_NewStringObj (bson_iterator_string (&i), -1));
break;
}
case BSON_ARRAY: {
Tcl_Obj *subList = Tcl_NewObj ();
subList = mongotcl_bsontolist_raw (interp, subList, bson_iterator_value (&i), depth + 1);
append_list_type_object (interp, listObj, "array", key, subList);
break;
}
case BSON_OBJECT: {
Tcl_Obj *subList = Tcl_NewObj ();
subList = mongotcl_bsontolist_raw (interp, subList, bson_iterator_value (&i), depth + 1);
append_list_type_object (interp, listObj, "object", key, subList);
break;
}
default: {
append_list_type_object (interp, listObj, "unknown", key, Tcl_NewIntObj (t));
break;
}
}
}
return listObj;
}