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;
}
