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" );
}
}
int main(int argc, char *argv[])
{
bson_buffer bb;
bson b;
bson_iterator it, it2, it3;
bson_oid_t oid;
bson_buffer_init(&bb);
bson_append_double(&bb, "d", 3.14);
bson_append_string(&bb, "s", "hello");
{
bson_buffer *obj = bson_append_start_object(&bb, "o");
bson_buffer *arr = bson_append_start_array(obj, "a");
bson_append_binary(arr, "0", 8, "w\0rld", 5);
bson_append_finish_object(arr);
bson_append_finish_object(obj);
}
bson_append_undefined(&bb, "u");
bson_oid_from_string(&oid, "010203040506070809101112");
ASSERT(!memcmp(oid.bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12));
bson_append_oid(&bb, "oid", &oid);
bson_append_bool(&bb, "b", 1);
bson_append_date(&bb, "date", 0x0102030405060708ULL);
bson_append_null(&bb, "n");
bson_append_regex(&bb, "r", "^asdf", "imx");
/* no dbref test (deprecated) */
bson_append_code(&bb, "c", "function(){}");
bson_append_symbol(&bb, "symbol", "SYMBOL");
{
bson_buffer scope_buf;
bson scope;
bson_buffer_init(&scope_buf);
bson_append_int(&scope_buf, "i", 123);
bson_from_buffer(&scope, &scope_buf);
bson_append_code_w_scope(&bb, "cws", "function(){return i}", &scope);
bson_destroy(&scope);
}
/* no timestamp test (internal) */
bson_append_long(&bb, "l", 0x1122334455667788ULL);
bson_from_buffer(&b, &bb);
bson_iterator_init(&it, b.data);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_double);
ASSERT(bson_iterator_type(&it) == bson_double);
ASSERT(!strcmp(bson_iterator_key(&it), "d"));
ASSERT(bson_iterator_double(&it) == 3.14);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_string);
ASSERT(bson_iterator_type(&it) == bson_string);
ASSERT(!strcmp(bson_iterator_key(&it), "s"));
ASSERT(!strcmp(bson_iterator_string(&it), "hello"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_object);
ASSERT(bson_iterator_type(&it) == bson_object);
ASSERT(!strcmp(bson_iterator_key(&it), "o"));
bson_iterator_subiterator(&it, &it2);
ASSERT(bson_iterator_more(&it2));
ASSERT(bson_iterator_next(&it2) == bson_array);
ASSERT(bson_iterator_type(&it2) == bson_array);
ASSERT(!strcmp(bson_iterator_key(&it2), "a"));
bson_iterator_subiterator(&it2, &it3);
ASSERT(bson_iterator_more(&it3));
ASSERT(bson_iterator_next(&it3) == bson_bindata);
ASSERT(bson_iterator_type(&it3) == bson_bindata);
ASSERT(!strcmp(bson_iterator_key(&it3), "0"));
ASSERT(bson_iterator_bin_type(&it3) == 8);
ASSERT(bson_iterator_bin_len(&it3) == 5);
ASSERT(!memcmp(bson_iterator_bin_data(&it3), "w\0rld", 5));
ASSERT(bson_iterator_more(&it3));
ASSERT(bson_iterator_next(&it3) == bson_eoo);
ASSERT(bson_iterator_type(&it3) == bson_eoo);
ASSERT(!bson_iterator_more(&it3));
ASSERT(bson_iterator_more(&it2));
ASSERT(bson_iterator_next(&it2) == bson_eoo);
ASSERT(bson_iterator_type(&it2) == bson_eoo);
ASSERT(!bson_iterator_more(&it2));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_undefined);
ASSERT(bson_iterator_type(&it) == bson_undefined);
ASSERT(!strcmp(bson_iterator_key(&it), "u"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_oid);
ASSERT(bson_iterator_type(&it) == bson_oid);
ASSERT(!strcmp(bson_iterator_key(&it), "oid"));
ASSERT(!memcmp(bson_iterator_oid(&it)->bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12));
ASSERT(bson_iterator_oid(&it)->ints[0] == oid.ints[0]);
ASSERT(bson_iterator_oid(&it)->ints[1] == oid.ints[1]);
ASSERT(bson_iterator_oid(&it)->ints[2] == oid.ints[2]);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_bool);
ASSERT(bson_iterator_type(&it) == bson_bool);
ASSERT(!strcmp(bson_iterator_key(&it), "b"));
ASSERT(bson_iterator_bool(&it) == 1);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_date);
ASSERT(bson_iterator_type(&it) == bson_date);
ASSERT(!strcmp(bson_iterator_key(&it), "date"));
ASSERT(bson_iterator_date(&it) == 0x0102030405060708ULL);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_null);
ASSERT(bson_iterator_type(&it) == bson_null);
ASSERT(!strcmp(bson_iterator_key(&it), "n"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_regex);
ASSERT(bson_iterator_type(&it) == bson_regex);
ASSERT(!strcmp(bson_iterator_key(&it), "r"));
ASSERT(!strcmp(bson_iterator_regex(&it), "^asdf"));
ASSERT(!strcmp(bson_iterator_regex_opts(&it), "imx"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_code);
ASSERT(bson_iterator_type(&it) == bson_code);
ASSERT(!strcmp(bson_iterator_key(&it), "c"));
ASSERT(!strcmp(bson_iterator_string(&it), "function(){}"));
ASSERT(!strcmp(bson_iterator_code(&it), "function(){}"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_symbol);
ASSERT(bson_iterator_type(&it) == bson_symbol);
ASSERT(!strcmp(bson_iterator_key(&it), "symbol"));
ASSERT(!strcmp(bson_iterator_string(&it), "SYMBOL"));
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_codewscope);
ASSERT(bson_iterator_type(&it) == bson_codewscope);
ASSERT(!strcmp(bson_iterator_key(&it), "cws"));
ASSERT(!strcmp(bson_iterator_code(&it), "function(){return i}"));
{
bson scope;
bson_iterator_code_scope(&it, &scope);
bson_iterator_init(&it2, scope.data);
ASSERT(bson_iterator_more(&it2));
ASSERT(bson_iterator_next(&it2) == bson_int);
ASSERT(bson_iterator_type(&it2) == bson_int);
ASSERT(!strcmp(bson_iterator_key(&it2), "i"));
ASSERT(bson_iterator_int(&it2) == 123);
ASSERT(bson_iterator_more(&it2));
ASSERT(bson_iterator_next(&it2) == bson_eoo);
ASSERT(bson_iterator_type(&it2) == bson_eoo);
ASSERT(!bson_iterator_more(&it2));
}
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_long);
ASSERT(bson_iterator_type(&it) == bson_long);
ASSERT(!strcmp(bson_iterator_key(&it), "l"));
ASSERT(bson_iterator_long(&it) == 0x1122334455667788ULL);
ASSERT(bson_iterator_more(&it));
ASSERT(bson_iterator_next(&it) == bson_eoo);
ASSERT(bson_iterator_type(&it) == bson_eoo);
ASSERT(!bson_iterator_more(&it));
return 0;
}
int test_bson_generic( void ) {
bson_iterator it, it2, it3;
bson_oid_t oid;
bson_timestamp_t ts;
bson_timestamp_t ts_result;
bson b[1];
bson copy[1];
bson scope[1];
ts.i = 1;
ts.t = 2;
bson_init( b );
bson_append_double( b, "d", 3.14 );
bson_append_string( b, "s", "hello" );
bson_append_string_n( b, "s_n", "goodbye cruel world", 7 );
{
bson_append_start_object( b, "o" );
bson_append_start_array( b, "a" );
bson_append_binary( b, "0", 8, "w\0rld", 5 );
bson_append_finish_object( b );
bson_append_finish_object( b );
}
bson_append_undefined( b, "u" );
bson_oid_from_string( &oid, "010203040506070809101112" );
ASSERT( !memcmp( oid.bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12 ) );
bson_append_oid( b, "oid", &oid );
bson_append_bool( b, "b", 1 );
bson_append_date( b, "date", 0x0102030405060708 );
bson_append_null( b, "n" );
bson_append_regex( b, "r", "^asdf", "imx" );
/* no dbref test (deprecated) */
bson_append_code( b, "c", "function(){}" );
bson_append_code_n( b, "c_n", "function(){}garbage", 12 );
bson_append_symbol( b, "symbol", "symbol" );
bson_append_symbol_n( b, "symbol_n", "symbol and garbage", 6 );
{
bson_init( scope );
bson_append_int( scope, "i", 123 );
bson_finish( scope );
bson_append_code_w_scope( b, "cws", "function(){return i}", scope );
bson_destroy( scope );
}
bson_append_timestamp( b, "timestamp", &ts );
bson_append_long( b, "l", 0x1122334455667788 );
/* Ensure that we can't copy a non-finished object. */
ASSERT( bson_copy( copy, b ) == BSON_ERROR );
bson_finish( b );
ASSERT( b->err == BSON_VALID );
/* Test append after finish. */
ASSERT( bson_append_string( b, "foo", "bar" ) == BSON_ERROR );
ASSERT( b->err & BSON_ALREADY_FINISHED );
ASSERT( bson_copy( copy, b ) == BSON_OK );
ASSERT( 1 == copy->finished );
ASSERT( 0 == copy->err );
bson_destroy( copy );
bson_print( b );
bson_iterator_init( &it, b );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( bson_iterator_type( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_STRING );
ASSERT( bson_iterator_type( &it ) == BSON_STRING );
ASSERT( !strcmp( bson_iterator_key( &it ), "s" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "hello" ) );
ASSERT( strcmp( bson_iterator_string( &it ), "" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_STRING );
ASSERT( bson_iterator_type( &it ) == BSON_STRING );
ASSERT( !strcmp( bson_iterator_key( &it ), "s_n" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "goodbye" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_OBJECT );
ASSERT( bson_iterator_type( &it ) == BSON_OBJECT );
ASSERT( !strcmp( bson_iterator_key( &it ), "o" ) );
bson_iterator_subiterator( &it, &it2 );
ASSERT( bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_next( &it2 ) == BSON_ARRAY );
ASSERT( bson_iterator_type( &it2 ) == BSON_ARRAY );
ASSERT( !strcmp( bson_iterator_key( &it2 ), "a" ) );
bson_iterator_subiterator( &it2, &it3 );
ASSERT( bson_iterator_more( &it3 ) );
ASSERT( bson_iterator_next( &it3 ) == BSON_BINDATA );
ASSERT( bson_iterator_type( &it3 ) == BSON_BINDATA );
ASSERT( !strcmp( bson_iterator_key( &it3 ), "0" ) );
ASSERT( bson_iterator_bin_type( &it3 ) == 8 );
ASSERT( bson_iterator_bin_len( &it3 ) == 5 );
ASSERT( !memcmp( bson_iterator_bin_data( &it3 ), "w\0rld", 5 ) );
ASSERT( bson_iterator_more( &it3 ) );
ASSERT( bson_iterator_next( &it3 ) == BSON_EOO );
ASSERT( bson_iterator_type( &it3 ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it3 ) );
ASSERT( bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_next( &it2 ) == BSON_EOO );
ASSERT( bson_iterator_type( &it2 ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_UNDEFINED );
ASSERT( bson_iterator_type( &it ) == BSON_UNDEFINED );
ASSERT( !strcmp( bson_iterator_key( &it ), "u" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_OID );
ASSERT( bson_iterator_type( &it ) == BSON_OID );
ASSERT( !strcmp( bson_iterator_key( &it ), "oid" ) );
ASSERT( !memcmp( bson_iterator_oid( &it )->bytes, "\x001\x002\x003\x004\x005\x006\x007\x008\x009\x010\x011\x012", 12 ) );
ASSERT( bson_iterator_oid( &it )->ints[0] == oid.ints[0] );
ASSERT( bson_iterator_oid( &it )->ints[1] == oid.ints[1] );
ASSERT( bson_iterator_oid( &it )->ints[2] == oid.ints[2] );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_BOOL );
ASSERT( bson_iterator_type( &it ) == BSON_BOOL );
ASSERT( !strcmp( bson_iterator_key( &it ), "b" ) );
ASSERT( bson_iterator_bool( &it ) == 1 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DATE );
ASSERT( bson_iterator_type( &it ) == BSON_DATE );
ASSERT( !strcmp( bson_iterator_key( &it ), "date" ) );
ASSERT( bson_iterator_date( &it ) == 0x0102030405060708 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_NULL );
ASSERT( bson_iterator_type( &it ) == BSON_NULL );
ASSERT( !strcmp( bson_iterator_key( &it ), "n" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_REGEX );
ASSERT( bson_iterator_type( &it ) == BSON_REGEX );
ASSERT( !strcmp( bson_iterator_key( &it ), "r" ) );
ASSERT( !strcmp( bson_iterator_regex( &it ), "^asdf" ) );
ASSERT( !strcmp( bson_iterator_regex_opts( &it ), "imx" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_CODE );
ASSERT( bson_iterator_type( &it ) == BSON_CODE );
ASSERT( !strcmp( bson_iterator_code(&it), "function(){}") );
ASSERT( !strcmp( bson_iterator_key( &it ), "c" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_CODE );
ASSERT( bson_iterator_type( &it ) == BSON_CODE );
ASSERT( !strcmp( bson_iterator_key( &it ), "c_n" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "" ) );
ASSERT( !strcmp( bson_iterator_code( &it ), "function(){}" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_SYMBOL );
ASSERT( bson_iterator_type( &it ) == BSON_SYMBOL );
ASSERT( !strcmp( bson_iterator_key( &it ), "symbol" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "symbol" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_SYMBOL );
ASSERT( bson_iterator_type( &it ) == BSON_SYMBOL );
ASSERT( !strcmp( bson_iterator_key( &it ), "symbol_n" ) );
ASSERT( !strcmp( bson_iterator_string( &it ), "symbol" ) );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_CODEWSCOPE );
ASSERT( bson_iterator_type( &it ) == BSON_CODEWSCOPE );
ASSERT( !strcmp( bson_iterator_key( &it ), "cws" ) );
ASSERT( !strcmp( bson_iterator_code( &it ), "function(){return i}" ) );
{
bson scope;
bson_iterator_code_scope( &it, &scope );
bson_iterator_init( &it2, &scope );
ASSERT( bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_next( &it2 ) == BSON_INT );
ASSERT( bson_iterator_type( &it2 ) == BSON_INT );
ASSERT( !strcmp( bson_iterator_key( &it2 ), "i" ) );
ASSERT( bson_iterator_int( &it2 ) == 123 );
ASSERT( bson_iterator_more( &it2 ) );
ASSERT( bson_iterator_next( &it2 ) == BSON_EOO );
ASSERT( bson_iterator_type( &it2 ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it2 ) );
}
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_TIMESTAMP );
ASSERT( bson_iterator_type( &it ) == BSON_TIMESTAMP );
ASSERT( !strcmp( bson_iterator_key( &it ), "timestamp" ) );
ts_result = bson_iterator_timestamp( &it );
ASSERT( ts_result.i == 1 );
ASSERT( ts_result.t == 2 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_LONG );
ASSERT( bson_iterator_type( &it ) == BSON_LONG );
ASSERT( !strcmp( bson_iterator_key( &it ), "l" ) );
ASSERT( bson_iterator_long( &it ) == 0x1122334455667788 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_EOO );
ASSERT( bson_iterator_type( &it ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it ) );
bson_destroy( b );
{
bson bsrc[1];
bson_init( bsrc );
bson_append_double( bsrc, "d", 3.14 );
bson_finish( bsrc );
ASSERT( bsrc->err == BSON_VALID );
bson_init( b );
bson_append_double( b, "", 3.14 ); /* test empty name (in general) */
bson_iterator_init( &it, bsrc );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( bson_iterator_type( &it ) == BSON_DOUBLE );
bson_append_element( b, "d", &it );
bson_append_element( b, 0, &it ); /* test null */
bson_append_element( b, "", &it ); /* test empty name */
bson_finish( b );
ASSERT( b->err == BSON_VALID );
/* bson_print( b ); */
bson_iterator_init( &it, b );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "d" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_DOUBLE );
ASSERT( !strcmp( bson_iterator_key( &it ), "" ) );
ASSERT( bson_iterator_double( &it ) == 3.14 );
ASSERT( bson_iterator_more( &it ) );
ASSERT( bson_iterator_next( &it ) == BSON_EOO );
ASSERT( !bson_iterator_more( &it ) );
bson_destroy( bsrc );
bson_destroy( b );
}
return 0;
}
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");
}
}
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;
}
}
EXPORT const char* mongo_bson_iterator_regex(struct bson_iterator_* i) {
return bson_iterator_regex((bson_iterator*) i);
}
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;
}
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;
}
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 ;
}
void decodeValue(v8::Local<v8::Object> obj, bson_iterator *it)
{
bson_type type = bson_iterator_type(it);
const char *key = bson_iterator_key(it);
switch (type)
{
case BSON_NULL:
obj->Set(v8::String::NewFromUtf8(isolate, key), v8::Null(isolate));
break;
case BSON_STRING:
obj->Set(v8::String::NewFromUtf8(isolate, key),
v8::String::NewFromUtf8(isolate, bson_iterator_string(it)));
break;
case BSON_BOOL:
obj->Set(v8::String::NewFromUtf8(isolate, key),
bson_iterator_bool(it) ? v8::True(isolate) : v8::False(isolate));
break;
case BSON_INT:
obj->Set(v8::String::NewFromUtf8(isolate, key), v8::Number::New(isolate, bson_iterator_int(it)));
break;
case BSON_LONG:
{
int64_t num = bson_iterator_long(it);
if (num >= -2147483648ll && num <= 2147483647ll)
{
obj->Set(v8::String::NewFromUtf8(isolate, key),
v8::Number::New(isolate, (double) num));
}
else
{
obj_ptr<Int64> int64 = new Int64(num);
obj->Set(v8::String::NewFromUtf8(isolate, key), int64->wrap());
}
break;
}
case BSON_DOUBLE:
obj->Set(v8::String::NewFromUtf8(isolate, key),
v8::Number::New(isolate, bson_iterator_double(it)));
break;
case BSON_DATE:
obj->Set(v8::String::NewFromUtf8(isolate, key),
v8::Date::New(isolate, (double) bson_iterator_date(it)));
break;
case BSON_BINDATA:
{
obj_ptr<Buffer_base> buf = new Buffer(
std::string(bson_iterator_bin_data(it),
bson_iterator_bin_len(it)));
obj->Set(v8::String::NewFromUtf8(isolate, key), buf->wrap());
break;
}
case BSON_OID:
{
obj_ptr<MongoID> oid = new MongoID(bson_iterator_oid(it));
obj->Set(v8::String::NewFromUtf8(isolate, key), oid->wrap());
break;
}
case BSON_REGEX:
{
v8::RegExp::Flags flgs = v8::RegExp::kNone;
const char *opts = bson_iterator_regex_opts(it);
char ch;
while ((ch = *opts++) != 0)
if (ch == 'm')
flgs = (v8::RegExp::Flags) (flgs | v8::RegExp::kMultiline);
else if (ch == 'g')
flgs = (v8::RegExp::Flags) (flgs | v8::RegExp::kGlobal);
else if (ch == 'i')
flgs = (v8::RegExp::Flags) (flgs | v8::RegExp::kIgnoreCase);
obj->Set(v8::String::NewFromUtf8(isolate, key),
v8::RegExp::New(v8::String::NewFromUtf8(isolate, bson_iterator_regex(it)),
flgs));
break;
}
case BSON_OBJECT:
case BSON_ARRAY:
{
bson_iterator it1;
bson_iterator_subiterator(it, &it1);
obj->Set(v8::String::NewFromUtf8(isolate, key), decodeObject(&it1, type == BSON_ARRAY));
break;
}
default:
printf("unknown type: %d\n", type);
break;
}
}
