bson_type bson_find(bson_iterator* it, const bson* obj, const char* name){ bson_iterator_init(it, obj->data); while(bson_iterator_next(it)){ if (strcmp(name, bson_iterator_key(it)) == 0) break; } return bson_iterator_type(it); }
double bson_iterator_double( const bson_iterator * i ){ switch (bson_iterator_type(i)){ case bson_int: return bson_iterator_int_raw(i); case bson_long: return bson_iterator_long_raw(i); case bson_double: return bson_iterator_double_raw(i); default: return 0; } }
const char * bson_iterator_code( const bson_iterator * i ){ switch (bson_iterator_type(i)){ case bson_string: case bson_code: return bson_iterator_value(i) + 4; case bson_codewscope: return bson_iterator_value(i) + 8; default: return NULL; } }
void MongodbClient::ReadData(KeyedArchive* archive, void* bsonObj) { if((!archive) || (!bsonObj)) return; bson_iterator it; bson_iterator_init(&it, (bson*)bsonObj); while (bson_iterator_next(&it)) { String key = String(bson_iterator_key(&it)); bson_type type = bson_iterator_type(&it); if(key == "_id") continue; // ignore _id switch (type) { case BSON_STRING: archive->SetString(key, String(bson_iterator_string(&it))); break; case BSON_INT: archive->SetInt32(key, bson_iterator_int(&it)); break; case BSON_LONG: archive->SetInt32(key, (int32)bson_iterator_long(&it)); break; case BSON_DOUBLE: archive->SetFloat(key, (float32)bson_iterator_double(&it)); break; case BSON_OBJECT: { bson sub; bson_iterator_subobject(&it, &sub); KeyedArchive* subArchive = new KeyedArchive(); ReadData(subArchive, &sub); archive->SetArchive(key, subArchive); SafeRelease(subArchive); break; } case BSON_OID: //TODO: add 12-bytes array //bson_append_oid(object, key, bson_iterator_oid(&it)); break; default: DVASSERT(false); Logger::Error("[MongodbUpdateObject::ReadData] Not implemented type: %d", type); break; } } }
MONGO_EXPORT const char *bson_iterator_string( const bson_iterator *i ) { switch ( bson_iterator_type( i ) ) { case BSON_STRING: case BSON_SYMBOL: return bson_iterator_value( i ) + 4; default: return ""; } }
void bson_iterator_code_scope(const bson_iterator * i, bson * scope){ if (bson_iterator_type(i) == bson_codewscope){ int code_len; bson_little_endian32(&code_len, bson_iterator_value(i)+4); bson_init(scope, (void*)(bson_iterator_value(i)+8+code_len), 0); }else{ bson_empty(scope); } }
void bson_iterator_code_scope( const bson_iterator *i, bson *scope ) { if ( bson_iterator_type( i ) == BSON_CODEWSCOPE ) { int code_len; bson_little_endian32( &code_len, bson_iterator_value( i )+4 ); bson_init_data( scope, ( void * )( bson_iterator_value( i )+8+code_len ) ); } else { bson_empty( scope ); } }
gridfs_offset gridfile_get_contentlength( gridfile *gfile ) { bson_iterator it; bson_find( &it, gfile->meta, "length" ); if( bson_iterator_type( &it ) == BSON_INT ) return ( gridfs_offset )bson_iterator_int( &it ); else return ( gridfs_offset )bson_iterator_long( &it ); }
MONGO_EXPORT bson_type bson_find( bson_iterator *it, const bson *obj, const char *name ) { check_mongo_object( (void*)obj ); check_mongo_object( it ); bson_iterator_init( it, (bson *)obj ); while( bson_iterator_next( it ) ) { if ( strcmp( name, bson_iterator_key( it ) ) == 0 ) break; } return bson_iterator_type( it ); }
MONGO_EXPORT const char *bson_iterator_string( const bson_iterator *i ) { check_mongo_object( (void*)i ); switch ( bson_iterator_type( i ) ) { case BSON_STRING: case BSON_SYMBOL: return bson_iterator_value( i ) + 4; default: return ""; } }
static void bson_decode_tree(lua_State* L, bson_iterator* b,int set_t){ const char *key; while(bson_iterator_next(b)) { bson_type t = bson_iterator_type(b); if(t == 0) { lua_pushnil(L); break; } key = bson_iterator_key(b); if(set_t) { lua_pushstring(L,key); } LOG_MSG("type %d,key %s",t,key); switch(t) { case BSON_DOUBLE: lua_pushnumber(L,bson_iterator_double(b)); break; case BSON_STRING: lua_pushstring(L,bson_iterator_string(b)); break; case BSON_BOOL: lua_pushboolean(L,bson_iterator_bool( b ) ? true : false ); break; case BSON_NULL: lua_pushnil(L); break; case BSON_INT: lua_pushinteger(L,bson_iterator_int(b)); break; case BSON_OBJECT: bson_iterator t; bson_iterator_subiterator(b,&t); bson_decode_tree(L,&t); lua_settable(L,-3); break; case BSON_ARRAY: lua_newtable(L); bson_iterator s; bson_iterator_subiterator(b,&s); bson_decode_tree(L,&s,1); break; default: break; } if(set_t) { lua_settable(L,-3); } } }
bson_bool_t bson_iterator_bool( const bson_iterator * i ){ switch (bson_iterator_type(i)){ case bson_bool: return bson_iterator_bool_raw(i); case bson_int: return bson_iterator_int_raw(i) != 0; case bson_long: return bson_iterator_long_raw(i) != 0; case bson_double: return bson_iterator_double_raw(i) != 0; case bson_eoo: case bson_null: return 0; default: return 1; } }
const char *bson_iterator_code( const bson_iterator *i ) { switch ( bson_iterator_type( i ) ) { case BSON_STRING: case BSON_CODE: return bson_iterator_value( i ) + 4; case BSON_CODEWSCOPE: return bson_iterator_value( i ) + 8; default: return NULL; } }
MONGO_EXPORT const char *bson_iterator_code( const bson_iterator *i ) { check_mongo_object( (void*)i ); switch ( bson_iterator_type( i ) ) { case BSON_STRING: case BSON_CODE: return bson_iterator_value( i ) + 4; case BSON_CODEWSCOPE: return bson_iterator_value( i ) + 8; default: return NULL; } }
int64_t bson_iterator_long( const bson_iterator *i ) { switch ( bson_iterator_type( i ) ) { case BSON_INT: return bson_iterator_int_raw( i ); case BSON_LONG: return bson_iterator_long_raw( i ); case BSON_DOUBLE: return bson_iterator_double_raw( i ); default: return 0; } }
int test_bson_iterator( void ) { bson b[1]; bson_iterator i[1]; bson_iterator_init( i, bson_empty( b ) ); bson_iterator_next( i ); bson_iterator_type( i ); bson_find( i, bson_empty( b ), "foo" ); return 0; }
void MongodbObject::EnableForEdit() { bson *newObject = new bson(); bson_init(newObject); bson_iterator it; bson_iterator_init(&it, objectData->object); while (bson_iterator_next(&it)) { const char * key = bson_iterator_key(&it); bson_type type = bson_iterator_type(&it); switch (type) { case BSON_STRING: bson_append_string(newObject, key, bson_iterator_string(&it)); break; case BSON_INT: bson_append_int(newObject, key, bson_iterator_int(&it)); break; case BSON_LONG: bson_append_long(newObject, key, bson_iterator_long(&it)); break; case BSON_DOUBLE: bson_append_double(newObject, key, bson_iterator_double(&it)); break; case BSON_OBJECT: bson sub; bson_iterator_subobject(&it, &sub); bson_append_bson(newObject, key, &sub); break; case BSON_OID: bson_append_oid(newObject, key, bson_iterator_oid(&it)); break; default: break; } } bson_destroy(objectData->object); SafeDelete(objectData->object); objectData->object = newObject; }
void json_from_bson_array(yajl_gen *g, bson_iterator *it) { yajl_gen_array_open( *g ); while( bson_iterator_next( it ) ) { bson_type t = bson_iterator_type( it ); json_from_bson_type( t, g, it ); } yajl_gen_array_close( *g ); }
MONGO_EXPORT int64_t bson_iterator_long( const bson_iterator *i ) { check_mongo_object( (void*)i ); switch ( bson_iterator_type( i ) ) { case BSON_INT: return bson_iterator_int_raw( i ); case BSON_LONG: return bson_iterator_long_raw( i ); case BSON_DOUBLE: return (int64_t) bson_iterator_double_raw( i ); default: return 0; } }
MONGO_EXPORT void bson_iterator_code_scope_init( const bson_iterator *i, bson *scope, bson_bool_t copyData ) { if ( bson_iterator_type( i ) == BSON_CODEWSCOPE ) { int codeLen = bson_finished_data_size( bson_iterator_value( i )+4 ); const char * scopeData = bson_iterator_value( i )+8+codeLen; if( copyData ) bson_init_finished_data_with_copy( scope, scopeData ); else bson_init_finished_data( scope, (char *)scopeData, 0 ); } else { bson_init_empty( scope ); } }
bson_type bson_iterator_next( bson_iterator * i ){ int ds; if ( i->first ){ i->first = 0; return (bson_type)(*i->cur); } switch ( bson_iterator_type(i) ){ case bson_eoo: return bson_eoo; /* don't advance */ case bson_undefined: case bson_null: ds = 0; break; case bson_bool: ds = 1; break; case bson_int: ds = 4; break; case bson_long: case bson_double: case bson_timestamp: case bson_date: ds = 8; break; case bson_oid: ds = 12; break; case bson_string: case bson_symbol: case bson_code: ds = 4 + bson_iterator_int_raw(i); break; case bson_bindata: ds = 5 + bson_iterator_int_raw(i); break; case bson_object: case bson_array: case bson_codewscope: ds = bson_iterator_int_raw(i); break; case bson_dbref: ds = 4+12 + bson_iterator_int_raw(i); break; case bson_regex: { const char * s = bson_iterator_value(i); const char * p = s; p += strlen(p)+1; p += strlen(p)+1; ds = p-s; break; } default: { char msg[] = "unknown type: 000000000000"; bson_numstr(msg+14, (unsigned)(i->cur[0])); bson_fatal_msg(0, msg); return 0; } } i->cur += 1 + strlen( i->cur + 1 ) + 1 + ds; return (bson_type)(*i->cur); }
MONGO_EXPORT void bson_iterator_code_scope( const bson_iterator *i, bson *scope ) { check_mongo_object( (void*)scope ); check_mongo_object( (void*)i ); if ( bson_iterator_type( i ) == BSON_CODEWSCOPE ) { int code_len; bson_little_endian32( &code_len, bson_iterator_value( i )+4 ); bson_init_data( scope, ( void * )( bson_iterator_value( i )+8+code_len ) ); _bson_reset( scope ); scope->finished = 1; } else { bson_empty( scope ); } }
bool FindField(bson_iterator *itIn, bson_iterator *itOut, const String &fieldname, bool recursive) { bool found = false; while(!found && bson_iterator_next(itIn)) { String itKey = String(bson_iterator_key(itIn)); if(fieldname == itKey) { *itOut = *itIn; found = true; } else if( (recursive && (BSON_OBJECT == bson_iterator_type(itIn))) || (recursive && (BSON_ARRAY == bson_iterator_type(itIn)))) { bson_iterator subIt; bson_iterator_subiterator(itIn, &subIt); found = FindField(&subIt, itOut, fieldname, recursive); } } return found; }
void InitWith(bson *obj) { bson_iterator it; bson_iterator_init(&it, obj); while (bson_iterator_next(&it)) { const char * key = bson_iterator_key(&it); bson_type type = bson_iterator_type(&it); switch (type) { case BSON_STRING: bson_append_string(object, key, bson_iterator_string(&it)); break; case BSON_INT: bson_append_int(object, key, bson_iterator_int(&it)); break; case BSON_LONG: bson_append_long(object, key, bson_iterator_long(&it)); break; case BSON_DOUBLE: bson_append_double(object, key, bson_iterator_double(&it)); break; case BSON_OBJECT: { bson sub; bson_iterator_subobject(&it, &sub); bson_append_bson(object, key, &sub); break; } case BSON_OID: bson_append_oid(object, key, bson_iterator_oid(&it)); break; default: DVASSERT(false); Logger::Error("[MongodbObjectInternalData::InitWith] Not implemented type: %d", type); break; } } }
INT32 bson2csv( CHAR delChar, CHAR delField, CHAR *pbson, CHAR **ppBuffer, INT32 *pCSVSize, BOOLEAN includeBinary, BOOLEAN includeRegex ) { INT32 rc = SDB_OK ; BOOLEAN isFirst = TRUE ; bson_type fieldType ; bson_iterator it ; bson_iterator_from_buffer( &it, pbson ) ; while ( bson_iterator_next( &it ) ) { fieldType = bson_iterator_type( &it ) ; if ( BSON_EOO == fieldType ) { break ; } if ( isFirst ) { isFirst = FALSE ; } else { rc = _appendString( delChar, &delField, 1, ppBuffer, pCSVSize ) ; if ( rc ) { goto error ; } } if ( BSON_UNDEFINED == fieldType ) { continue ; } rc = _appendValue( delChar, &it, ppBuffer, pCSVSize, includeBinary, includeRegex ) ; if ( rc ) { goto error ; } } done: return rc ; error: goto done ; }
int _iterator_getComplex(bson_iterator* iter, struct Rcomplex* z) { bson_iterator sub; if (bson_iterator_type(iter) != BSON_OBJECT) return 0; bson_iterator_subiterator(iter, &sub); if (bson_iterator_next(&sub) != BSON_DOUBLE || strcmp(bson_iterator_key(&sub), "r") != 0) return 0; z->r = bson_iterator_double(&sub); if (bson_iterator_next(&sub) != BSON_DOUBLE || strcmp(bson_iterator_key(&sub), "i") != 0) return 0; z->i = bson_iterator_double(&sub); if (bson_iterator_next(&sub) != BSON_EOO) return 0; return 1; }
void json_from_bson_object(yajl_gen *g, bson_iterator *it) { yajl_gen_map_open( *g ); while( bson_iterator_next( it ) ) { bson_type t = bson_iterator_type( it ); const char* key = bson_iterator_key( it ); yajl_gen_string( *g, (const unsigned char*)key, strlen(key) ); json_from_bson_type( t, g, it ); } yajl_gen_map_close( *g ); }
bson_bool_t bson_iterator_bool( const bson_iterator *i ) { switch ( bson_iterator_type( i ) ) { case BSON_BOOL: return bson_iterator_bool_raw( i ); case BSON_INT: return bson_iterator_int_raw( i ) != 0; case BSON_LONG: return bson_iterator_long_raw( i ) != 0; case BSON_DOUBLE: return bson_iterator_double_raw( i ) != 0; case BSON_EOO: case BSON_NULL: return 0; default: return 1; } }
MONGO_EXPORT bson_bool_t bson_iterator_bool( const bson_iterator *i ) { check_mongo_object( (void*)i ); switch ( bson_iterator_type( i ) ) { case BSON_BOOL: return bson_iterator_bool_raw( i ); case BSON_INT: return bson_iterator_int_raw( i ) != 0; case BSON_LONG: return bson_iterator_long_raw( i ) != 0; case BSON_DOUBLE: return bson_iterator_double_raw( i ) != 0; case BSON_EOO: case BSON_NULL: return 0; default: return 1; } }
bool bson_cmp( const bson *a, const bson *b ) { assert( a ); assert( b ); bson_iterator *a_it, *b_it; bool equal; size_t a_keys_count, b_keys_count; equal = true; a_it = malloc( sizeof( bson_iterator ) ); b_it = malloc( sizeof( bson_iterator ) ); bson_iterator_init( a_it, a ); bson_iterator_init( b_it, b ); a_keys_count = bson_keypars_count( a ); b_keys_count = bson_keypars_count( b ); if( a_keys_count == b_keys_count ) { while( bson_iterator_next( a_it ) ) { bson_type a_key_type = bson_iterator_type( a_it ); const char *a_key = bson_iterator_key( a_it ); bson_type b_key_type = bson_find( b_it, b, a_key ); if( b_key_type == BSON_EOO || a_key_type != b_key_type || !bson_values_are_equal( a_key_type, a_it, b_it ) ) { equal = false; break; } } } else { equal = false; } free( a_it ); free( b_it ); return equal; }