mirror of
https://gitee.com/mirrors_PX4/PX4-Autopilot.git
synced 2026-04-14 10:07:39 +08:00
Import of the Mongo C-BSON library with light modifications for PX4.
From https://github.com/mongodb/mongo-c-driver.git at 8ae2c57e95a3939850a77fb9329c129b2bcfcd1a
This commit is contained in:
px4dev
parent
2c85075221
commit
a9dc84231e
427
apps/systemlib/bson/bcon.c
Normal file
427
apps/systemlib/bson/bcon.c
Normal file
@ -0,0 +1,427 @@
|
||||
/* bcon.c */
|
||||
|
||||
/* Copyright 2009-2012 10gen Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
#include <assert.h>
|
||||
#include "bcon.h"
|
||||
|
||||
/* PX4 */
|
||||
#include <debug.h>
|
||||
#define assert(_x) ASSERT(_x)
|
||||
|
||||
#ifndef NOT_REACHED
|
||||
#define NOT_REACHED 0
|
||||
#endif
|
||||
|
||||
#define ARRAY_INDEX_BUFFER_SIZE 9
|
||||
|
||||
char *bcon_errstr[] = {
|
||||
"OK",
|
||||
"ERROR",
|
||||
"bcon document or nesting incomplete",
|
||||
"bson finish error"
|
||||
};
|
||||
|
||||
int bcon_error(bson *b, const bcon *bc, size_t i, bcon_error_t err) {
|
||||
b->err = err;
|
||||
b->errstr = bcon_errstr[err];
|
||||
return BCON_ERROR;
|
||||
}
|
||||
|
||||
bcon_error_t bson_append_bcon_array(bson *b, const bcon *bc);
|
||||
|
||||
bcon_token_t bcon_token(char *s) {
|
||||
if (s == 0) return Token_EOD;
|
||||
switch (s[0]) {
|
||||
case ':': if (s[1] != '\0' && s[2] != '\0' && s[3] != '\0' && s[4] == '\0' &&
|
||||
s[3] == ':' && (s[1] == '_' || s[1] == 'P' || s[1] == 'R'))
|
||||
return Token_Typespec; break;
|
||||
case '{': if (s[1] == '\0') return Token_OpenBrace; break;
|
||||
case '}': if (s[1] == '\0') return Token_CloseBrace; break;
|
||||
case '[': if (s[1] == '\0') return Token_OpenBracket; break;
|
||||
case ']': if (s[1] == '\0') return Token_CloseBracket; break;
|
||||
case '.': if (s[1] == '\0') return Token_End; break;
|
||||
}
|
||||
return Token_Default;
|
||||
}
|
||||
|
||||
bcon_error_t bson_bcon_key_value(bson *b, const char *key, const char *typespec, const bcon bci) {
|
||||
bcon_error_t ret = BCON_OK;
|
||||
bson_oid_t oid;
|
||||
char ptype = typespec ? typespec[1] : '_';
|
||||
char utype = typespec ? typespec[2] : '_';
|
||||
switch (ptype) {
|
||||
case '_': /* kv(b, key, utype, bci) */
|
||||
switch (utype) {
|
||||
case '_': /* fall through */
|
||||
case 's': bson_append_string( b, key, bci.s ); break; /* common case */
|
||||
case 'f': bson_append_double( b, key, bci.f ); break;
|
||||
case 'D':
|
||||
bson_append_start_object( b, key );
|
||||
ret = bson_append_bcon( b, bci.D );
|
||||
bson_append_finish_object( b );
|
||||
break;
|
||||
case 'A':
|
||||
bson_append_start_array( b, key );
|
||||
ret = bson_append_bcon_array( b, bci.A );
|
||||
bson_append_finish_array( b );
|
||||
break;
|
||||
case 'o': if (*bci.o == '\0') bson_oid_gen( &oid ); else bson_oid_from_string( &oid, bci.o ); bson_append_oid( b, key, &oid ); break;
|
||||
case 'b': bson_append_bool( b, key, bci.b ); break;
|
||||
case 't': bson_append_time_t( b, key, bci.t ); break;
|
||||
case 'v': bson_append_null( b, key ); break; /* void */
|
||||
case 'x': bson_append_symbol( b, key, bci.x ); break;
|
||||
case 'i': bson_append_int( b, key, bci.i ); break;
|
||||
case 'l': bson_append_long( b, key, bci.l ); break;
|
||||
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
|
||||
}
|
||||
break;
|
||||
case 'R': /* krv(b, key, utype, bci) */
|
||||
switch (utype) {
|
||||
case 'f': bson_append_double( b, key, *bci.Rf ); break;
|
||||
case 's': bson_append_string( b, key, bci.Rs ); break;
|
||||
case 'D':
|
||||
bson_append_start_object( b, key );
|
||||
ret = bson_append_bcon( b, bci.RD );
|
||||
bson_append_finish_object( b );
|
||||
break;
|
||||
case 'A':
|
||||
bson_append_start_array( b, key );
|
||||
ret = bson_append_bcon_array( b, bci.RA );
|
||||
bson_append_finish_array( b );
|
||||
break;
|
||||
case 'o': if (*bci.o == '\0') bson_oid_gen( &oid ); else bson_oid_from_string( &oid, bci.o ); bson_append_oid( b, key, &oid ); break;
|
||||
case 'b': bson_append_bool( b, key, *bci.Rb ); break;
|
||||
case 't': bson_append_time_t( b, key, *bci.Rt ); break;
|
||||
case 'x': bson_append_symbol( b, key, bci.Rx ); break;
|
||||
case 'i': bson_append_int( b, key, *bci.Ri ); break;
|
||||
case 'l': bson_append_long( b, key, *bci.Rl ); break;
|
||||
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
|
||||
}
|
||||
break;
|
||||
case 'P': /* kpv(b, key, utype, bci) */
|
||||
if (*bci.Pv != 0) {
|
||||
switch (utype) {
|
||||
case 'f': bson_append_double( b, key, **bci.Pf ); break;
|
||||
case 's': bson_append_string( b, key, *bci.Ps ); break;
|
||||
case 'D':
|
||||
bson_append_start_object( b, key );
|
||||
ret = bson_append_bcon( b, *bci.PD );
|
||||
bson_append_finish_object( b );
|
||||
break;
|
||||
case 'A':
|
||||
bson_append_start_array( b, key );
|
||||
ret = bson_append_bcon_array( b, *bci.PA );
|
||||
bson_append_finish_array( b );
|
||||
break;
|
||||
case 'o': if (**bci.Po == '\0') bson_oid_gen( &oid );
|
||||
else bson_oid_from_string( &oid, *bci.Po );
|
||||
bson_append_oid( b, key, &oid );
|
||||
break;
|
||||
case 'b': bson_append_bool( b, key, **bci.Pb ); break;
|
||||
case 't': bson_append_time_t( b, key, **bci.Pt ); break;
|
||||
case 'x': if (*bci.Px != 0) bson_append_symbol( b, key, *bci.Px ); break;
|
||||
case 'i': bson_append_int( b, key, **bci.Pi ); break;
|
||||
case 'l': bson_append_long( b, key, **bci.Pl ); break;
|
||||
default: printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED); break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
printf("\nptype:'%c' utype:'%c'\n", ptype, utype); assert(NOT_REACHED);
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
typedef enum bcon_state_t {
|
||||
State_Element, State_DocSpecValue, State_DocValue,
|
||||
State_ArraySpecValue, State_ArrayValue
|
||||
} bcon_state_t;
|
||||
|
||||
#define DOC_STACK_SIZE 128
|
||||
#define ARRAY_INDEX_STACK_SIZE 128
|
||||
|
||||
#define DOC_PUSH_STATE(return_state) ( doc_stack[doc_stack_pointer++] = (return_state) )
|
||||
#define DOC_POP_STATE ( state = doc_stack[--doc_stack_pointer] )
|
||||
#define ARRAY_PUSH_RESET_INDEX_STATE(return_state) ( array_index_stack[array_index_stack_pointer++] = array_index, array_index = 0, DOC_PUSH_STATE(return_state) )
|
||||
#define ARRAY_POP_INDEX_STATE ( array_index = array_index_stack[--array_index_stack_pointer], DOC_POP_STATE )
|
||||
|
||||
#define ARRAY_KEY_STRING(l) (bson_numstr(array_index_buffer, (int)(l)), array_index_buffer)
|
||||
|
||||
/*
|
||||
* simplified FSM to parse BCON structure, uses stacks for sub-documents and sub-arrays
|
||||
*/
|
||||
bcon_error_t bson_append_bcon_with_state(bson *b, const bcon *bc, bcon_state_t start_state) {
|
||||
bcon_error_t ret = BCON_OK;
|
||||
bcon_state_t state = start_state;
|
||||
char *key = 0;
|
||||
char *typespec = 0;
|
||||
unsigned char doc_stack[DOC_STACK_SIZE];
|
||||
size_t doc_stack_pointer = 0;
|
||||
size_t array_index = 0;
|
||||
unsigned int array_index_stack[ARRAY_INDEX_STACK_SIZE];
|
||||
size_t array_index_stack_pointer = 0;
|
||||
char array_index_buffer[ARRAY_INDEX_BUFFER_SIZE]; /* max BSON size */
|
||||
int end_of_data;
|
||||
const bcon *bcp;
|
||||
for (end_of_data = 0, bcp = bc; ret == BCON_OK && !end_of_data; bcp++) {
|
||||
bcon bci = *bcp;
|
||||
char *s = bci.s;
|
||||
switch (state) {
|
||||
case State_Element:
|
||||
switch (bcon_token(s)) {
|
||||
case Token_CloseBrace:
|
||||
bson_append_finish_object( b );
|
||||
DOC_POP_STATE; /* state = ...; */
|
||||
break;
|
||||
case Token_End:
|
||||
end_of_data = 1;
|
||||
break;
|
||||
default:
|
||||
key = s;
|
||||
state = State_DocSpecValue;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case State_DocSpecValue:
|
||||
switch (bcon_token(s)) {
|
||||
case Token_Typespec:
|
||||
typespec = s;
|
||||
state = State_DocValue;
|
||||
break;
|
||||
case Token_OpenBrace:
|
||||
bson_append_start_object( b, key );
|
||||
DOC_PUSH_STATE(State_Element);
|
||||
state = State_Element;
|
||||
break;
|
||||
case Token_OpenBracket:
|
||||
bson_append_start_array( b, key );
|
||||
ARRAY_PUSH_RESET_INDEX_STATE(State_Element);
|
||||
state = State_ArraySpecValue;
|
||||
break;
|
||||
case Token_End:
|
||||
end_of_data = 1;
|
||||
break;
|
||||
default:
|
||||
ret = bson_bcon_key_value(b, key, typespec, bci);
|
||||
state = State_Element;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case State_DocValue:
|
||||
ret = bson_bcon_key_value(b, key, typespec, bci);
|
||||
state = State_Element;
|
||||
typespec = 0;
|
||||
break;
|
||||
case State_ArraySpecValue:
|
||||
switch (bcon_token(s)) {
|
||||
case Token_Typespec:
|
||||
typespec = s;
|
||||
state = State_ArrayValue;
|
||||
break;
|
||||
case Token_OpenBrace:
|
||||
key = ARRAY_KEY_STRING(array_index++);
|
||||
bson_append_start_object( b, key );
|
||||
DOC_PUSH_STATE(State_ArraySpecValue);
|
||||
state = State_Element;
|
||||
break;
|
||||
case Token_OpenBracket:
|
||||
key = ARRAY_KEY_STRING(array_index++);
|
||||
bson_append_start_array( b, key );
|
||||
ARRAY_PUSH_RESET_INDEX_STATE(State_ArraySpecValue);
|
||||
/* state = State_ArraySpecValue; */
|
||||
break;
|
||||
case Token_CloseBracket:
|
||||
bson_append_finish_array( b );
|
||||
ARRAY_POP_INDEX_STATE; /* state = ...; */
|
||||
break;
|
||||
case Token_End:
|
||||
end_of_data = 1;
|
||||
break;
|
||||
default:
|
||||
key = ARRAY_KEY_STRING(array_index++);
|
||||
ret = bson_bcon_key_value(b, key, typespec, bci);
|
||||
/* state = State_ArraySpecValue; */
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case State_ArrayValue:
|
||||
key = ARRAY_KEY_STRING(array_index++);
|
||||
ret = bson_bcon_key_value(b, key, typespec, bci);
|
||||
state = State_ArraySpecValue;
|
||||
typespec = 0;
|
||||
break;
|
||||
default: assert(NOT_REACHED); break;
|
||||
}
|
||||
}
|
||||
return state == start_state ? BCON_OK : BCON_DOCUMENT_INCOMPLETE;
|
||||
}
|
||||
|
||||
bcon_error_t bson_append_bcon(bson *b, const bcon *bc) {
|
||||
return bson_append_bcon_with_state(b, bc, State_Element);
|
||||
}
|
||||
|
||||
bcon_error_t bson_append_bcon_array(bson *b, const bcon *bc) {
|
||||
return bson_append_bcon_with_state(b, bc, State_ArraySpecValue);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate BSON from BCON
|
||||
* @param b a BSON object
|
||||
* @param bc a BCON object
|
||||
* match with bson_destroy
|
||||
*/
|
||||
bcon_error_t bson_from_bcon(bson *b, const bcon *bc) {
|
||||
bcon_error_t ret = BSON_OK;
|
||||
bson_init( b );
|
||||
ret = bson_append_bcon_with_state( b, bc, State_Element );
|
||||
if (ret != BCON_OK) return ret;
|
||||
ret = bson_finish( b );
|
||||
return ( ret == BSON_OK ? BCON_OK : BCON_BSON_ERROR );
|
||||
}
|
||||
|
||||
void bcon_print(const bcon *bc) { /* prints internal representation, not JSON */
|
||||
char *typespec = 0;
|
||||
char *delim = "";
|
||||
int end_of_data;
|
||||
bcon *bcp;
|
||||
putchar('{');
|
||||
for (end_of_data = 0, bcp = (bcon*)bc; !end_of_data; bcp++) {
|
||||
bcon bci = *bcp;
|
||||
char *typespec_next = 0;
|
||||
if (typespec) {
|
||||
switch (typespec[1]) {
|
||||
case '_':
|
||||
switch (typespec[2]) {
|
||||
case 'f': printf("%s%f", delim, bci.f); break;
|
||||
case 's': printf("%s\"%s\"", delim, bci.s); break;
|
||||
case 'D': printf("%sPD(0x%lx,..)", delim, (unsigned long)bci.D); break;
|
||||
case 'A': printf("%sPA(0x%lx,....)", delim, (unsigned long)bci.A); break;
|
||||
case 'o': printf("%s\"%s\"", delim, bci.o); break;
|
||||
case 'b': printf("%s%d", delim, bci.b); break;
|
||||
case 't': printf("%s%ld", delim, (long)bci.t); break;
|
||||
case 'v': printf("%s\"%s\"", delim, bci.v); break;
|
||||
case 'x': printf("%s\"%s\"", delim, bci.x); break;
|
||||
case 'i': printf("%s%d", delim, bci.i); break;
|
||||
case 'l': printf("%s%ld", delim, bci.l); break;
|
||||
default: printf("\ntypespec:\"%s\"\n", typespec); assert(NOT_REACHED); break;
|
||||
}
|
||||
break;
|
||||
case 'R':
|
||||
switch (typespec[2]) {
|
||||
case 'f': printf("%sRf(0x%lx,%f)", delim, (unsigned long)bci.Rf, *bci.Rf); break;
|
||||
case 's': printf("%sRs(0x%lx,\"%s\")", delim, (unsigned long)bci.Rs, bci.Rs); break;
|
||||
case 'D': printf("%sRD(0x%lx,..)", delim, (unsigned long)bci.RD); break;
|
||||
case 'A': printf("%sRA(0x%lx,....)", delim, (unsigned long)bci.RA); break;
|
||||
case 'o': printf("%sRo(0x%lx,\"%s\")", delim, (unsigned long)bci.Ro, bci.Ro); break;
|
||||
case 'b': printf("%sRb(0x%lx,%d)", delim, (unsigned long)bci.Rb, *bci.Rb); break;
|
||||
case 't': printf("%sRt(0x%lx,%ld)", delim, (unsigned long)bci.Rt, (long)*bci.Rt); break;
|
||||
case 'x': printf("%sRx(0x%lx,\"%s\")", delim, (unsigned long)bci.Rx, bci.Rx); break;
|
||||
case 'i': printf("%sRi(0x%lx,%d)", delim, (unsigned long)bci.Ri, *bci.Ri); break;
|
||||
case 'l': printf("%sRl(0x%lx,%ld)", delim, (unsigned long)bci.Rl, *bci.Rl); break;
|
||||
default: printf("\ntypespec:\"%s\"\n", typespec); assert(NOT_REACHED); break;
|
||||
}
|
||||
break;
|
||||
case 'P':
|
||||
switch (typespec[2]) {
|
||||
case 'f': printf("%sPf(0x%lx,0x%lx,%f)", delim, (unsigned long)bci.Pf, (unsigned long)(bci.Pf ? *bci.Pf : 0), bci.Pf && *bci.Pf ? **bci.Pf : 0.0); break;
|
||||
case 's': printf("%sPs(0x%lx,0x%lx,\"%s\")", delim, (unsigned long)bci.Ps, (unsigned long)(bci.Ps ? *bci.Ps : 0), bci.Ps && *bci.Ps ? *bci.Ps : ""); break;
|
||||
case 'D': printf("%sPD(0x%lx,0x%lx,..)", delim, (unsigned long)bci.PD, (unsigned long)(bci.PD ? *bci.PD : 0)); break;
|
||||
case 'A': printf("%sPA(0x%lx,0x%lx,....)", delim, (unsigned long)bci.PA, (unsigned long)(bci.PA ? *bci.PA : 0)); break;
|
||||
case 'o': printf("%sPo(0x%lx,0x%lx,\"%s\")", delim, (unsigned long)bci.Po, (unsigned long)(bci.Po ? *bci.Po : 0), bci.Po && *bci.Po ? *bci.Po : ""); break;
|
||||
case 'b': printf("%sPb(0x%lx,0x%lx,%d)", delim, (unsigned long)bci.Pb, (unsigned long)(bci.Pb ? *bci.Pb : 0), bci.Pb && *bci.Pb ? **bci.Pb : 0); break;
|
||||
case 't': printf("%sPt(0x%lx,0x%lx,%ld)", delim, (unsigned long)bci.Pt, (unsigned long)(bci.Pt ? *bci.Pt : 0), bci.Pt && *bci.Pt ? (long)**bci.Pt : 0); break;
|
||||
case 'x': printf("%sPx(0x%lx,0x%lx,\"%s\")", delim, (unsigned long)bci.Px, (unsigned long)(bci.Px ? *bci.Px : 0), bci.Px && *bci.Px ? *bci.Px : ""); break;
|
||||
case 'i': printf("%sPi(0x%lx,0x%lx,%d)", delim, (unsigned long)bci.Pi, (unsigned long)(bci.Pi ? *bci.Pi : 0), bci.Pi && *bci.Pi ? **bci.Pi : 0); break;
|
||||
case 'l': printf("%sPl(0x%lx,0x%lx,%ld)", delim, (unsigned long)bci.Pl, (unsigned long)(bci.Pl ? *bci.Pl : 0), bci.Pl && *bci.Pl ? **bci.Pl : 0); break;
|
||||
|
||||
default: printf("\ntypespec:\"%s\"\n", typespec); assert(NOT_REACHED); break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
printf("\ntypespec:\"%s\"\n", typespec); assert(NOT_REACHED);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else {
|
||||
char *s = bci.s;
|
||||
switch (s[0]) {
|
||||
case '.':
|
||||
end_of_data = (s[1] == '\0');
|
||||
break;
|
||||
case ':':
|
||||
typespec_next = bcon_token(s) == Token_Typespec ? s : 0;
|
||||
break;
|
||||
}
|
||||
printf("%s\"%s\"", delim, s);
|
||||
}
|
||||
typespec = typespec_next;
|
||||
delim = ",";
|
||||
}
|
||||
putchar('}');
|
||||
}
|
||||
|
||||
/* TODO - incomplete */
|
||||
void bcon_json_print(bcon *bc, int n) {
|
||||
int t = 0;
|
||||
int key_value_count = 0;
|
||||
char *s;
|
||||
int end_of_data;
|
||||
bcon *bcp;
|
||||
putchar('{');
|
||||
for (end_of_data = 0, bcp = bc; !end_of_data; bcp++) {
|
||||
bcon bci = *bcp;
|
||||
switch (t) {
|
||||
case 'l':
|
||||
if (key_value_count & 0x1) putchar(':');
|
||||
printf("%ld", bci.l);
|
||||
t = 0;
|
||||
key_value_count++;
|
||||
break;
|
||||
case 's': /* fall through */
|
||||
default:
|
||||
s = bci.s;
|
||||
switch (*s) {
|
||||
case ':':
|
||||
++s;
|
||||
t = *++s;
|
||||
break;
|
||||
case '{':
|
||||
if (key_value_count & 0x1) putchar(':');
|
||||
putchar(*s);
|
||||
key_value_count = 0;
|
||||
break;
|
||||
case '}':
|
||||
putchar(*s);
|
||||
key_value_count = 2;
|
||||
break;
|
||||
default:
|
||||
if (key_value_count & 0x1) putchar(':');
|
||||
else if (key_value_count > 1) putchar(',');
|
||||
printf("\"%s\"", s);
|
||||
t = 0;
|
||||
key_value_count++;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
putchar('}');
|
||||
}
|
||||
420
apps/systemlib/bson/bcon.h
Normal file
420
apps/systemlib/bson/bcon.h
Normal file
@ -0,0 +1,420 @@
|
||||
/**
|
||||
* @file bcon.h
|
||||
* @brief BCON (BSON C Object Notation) Declarations
|
||||
*/
|
||||
|
||||
/* Copyright 2009-2012 10gen Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef BCON_H_
|
||||
#define BCON_H_
|
||||
|
||||
#include "bson.h"
|
||||
|
||||
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
||||
|
||||
MONGO_EXTERN_C_START
|
||||
|
||||
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
|
||||
|
||||
/**
|
||||
* BCON - BSON C Object Notation.
|
||||
*
|
||||
* Overview
|
||||
* --------
|
||||
* BCON provides for JSON-like (or BSON-like) initializers in C.
|
||||
* Without this, BSON must be constructed by procedural coding via explicit function calls.
|
||||
* With this, you now have concise, readable, and maintainable data-driven definition of BSON documents.
|
||||
* Here are a couple of introductory examples.
|
||||
*
|
||||
* bcon hello[] = { "hello", "world", "." };
|
||||
* bcon pi[] = { "pi", BF(3.14159), BEND };
|
||||
*
|
||||
* BCON is an array of bcon union elements with the default type of char* cstring.
|
||||
* A BCON document must be terminated with a char* cstring containing a single dot, i.e., ".", or the macro equivalent BEND.
|
||||
*
|
||||
* Cstring literals in double quotes are used for keys as well as for string values.
|
||||
* There is no explicit colon (':') separator between key and value, just a comma,
|
||||
* however it must be explicit or C will quietly concatenate the key and value strings for you.
|
||||
* Readability may be improved by using multiple lines with a key-value pair per line.
|
||||
*
|
||||
* Macros are used to enclose specific types, and an internal type-specifier string prefixes a typed value.
|
||||
* Macros are also used to specify interpolation of values from references (or pointers to references) of specified types.
|
||||
*
|
||||
* Sub-documents are framed by "{" "}" string literals, and sub-arrays are framed by "[" "]" literals.
|
||||
*
|
||||
* All of this is needed because C arrays and initializers are mono-typed unlike dict/array types in modern languages.
|
||||
* BCON attempts to be readable and JSON-like within the context and restrictions of the C language.
|
||||
*
|
||||
* Specification
|
||||
* -------------
|
||||
* This specification parallels the BSON specification ( http://bsonspec.org/#/specification ).
|
||||
* The specific types and their corresponding macros are documented in the bcon (union bcon) structure.
|
||||
* The base values use two-character macros starting with "B" for the simple initialization using static values.
|
||||
*
|
||||
* Examples
|
||||
* --------
|
||||
*
|
||||
* bcon goodbye[] = { "hello", "world", "goodbye", "world", "." };
|
||||
* bcon awesome[] = { "BSON", "[", "awesome", BF(5.05), BI(1986), "]", "." };
|
||||
* bcon contact_info[] = {
|
||||
* "firstName", "John",
|
||||
* "lastName" , "Smith",
|
||||
* "age" , BI(25),
|
||||
* "address" ,
|
||||
* "{",
|
||||
* "streetAddress", "21 2nd Street",
|
||||
* "city" , "New York",
|
||||
* "state" , "NY",
|
||||
* "postalCode" , "10021",
|
||||
* "}",
|
||||
* "phoneNumber",
|
||||
* "[",
|
||||
* "{",
|
||||
* "type" , "home",
|
||||
* "number", "212 555-1234",
|
||||
* "}",
|
||||
* "{",
|
||||
* "type" , "fax",
|
||||
* "number", "646 555-4567",
|
||||
* "}",
|
||||
* "]",
|
||||
* BEND
|
||||
* };
|
||||
*
|
||||
* Comparison
|
||||
* ----------
|
||||
*
|
||||
* JSON:
|
||||
* { "BSON" : [ "awesome", 5.05, 1986 ] }
|
||||
*
|
||||
* BCON:
|
||||
* bcon awesome[] = { "BSON", "[", "awesome", BF(5.05), BI(1986), "]", BEND };
|
||||
*
|
||||
* C driver calls:
|
||||
* bson_init( b );
|
||||
* bson_append_start_array( b, "BSON" );
|
||||
* bson_append_string( b, "0", "awesome" );
|
||||
* bson_append_double( b, "1", 5.05 );
|
||||
* bson_append_int( b, "2", 1986 );
|
||||
* bson_append_finish_array( b );
|
||||
* ret = bson_finish( b );
|
||||
* bson_print( b );
|
||||
* bson_destroy( b );
|
||||
*
|
||||
* Peformance
|
||||
* ----------
|
||||
* With compiler optimization -O3, BCON costs about 1.1 to 1.2 times as much
|
||||
* as the equivalent bson function calls required to explicitly construct the document.
|
||||
* This is significantly less than the cost of parsing JSON and constructing BSON,
|
||||
* and BCON allows value interpolation via pointers.
|
||||
*
|
||||
* Reference Interpolation
|
||||
* -----------------------
|
||||
* Reference interpolation uses three-character macros starting with "BR" for simple dynamic values.
|
||||
* You can change the referenced content and the new values will be interpolated when you generate BSON from BCON.
|
||||
*
|
||||
* bson b[1];
|
||||
* char name[] = "pi";
|
||||
* double value = 3.14159;
|
||||
* bcon bc[] = { "name", BRS(name), "value", BRF(&value), BEND };
|
||||
* bson_from_bcon( b, bc ); // generates { name: "pi", "value", 3.14159 }
|
||||
* strcpy(name, "e");
|
||||
* value = 2.71828;
|
||||
* bson_from_bcon( b, bc ); // generates { name: "pi", "value", 3.14159 }
|
||||
*
|
||||
* Please remember that in C, the array type is anomalous in that an identifier is (already) a reference,
|
||||
* therefore there is no ampersand '&' preceding the identifier for reference interpolation.
|
||||
* This applies to BRS(cstring), BRD(doc), BRA(array), BRO(oid), and BRX(symbol).
|
||||
* An ampersand '&' is needed for value types BRF(&double), BRB(&boolean), BRT(&time), BRI(&int), and BRL(&long).
|
||||
* For completeness, BRS, BRD, BRA, BRO, and BRX are defined even though BS, BD, BA, BO, and BX are equivalent.
|
||||
*
|
||||
* Pointer Interpolation
|
||||
* ---------------------
|
||||
* Pointer(-to-reference) interpolation uses three-character macros starting with "BP" for _conditional_ dynamic values.
|
||||
* You can change the pointer content and the new values will be interpolated when you generate BSON from BCON.
|
||||
* If you set the pointer to null, the element will skipped and not inserted into the generated BSON document.
|
||||
*
|
||||
* bson b[1];
|
||||
* char name[] = "pi";
|
||||
* char new_name[] = "log(0)";
|
||||
* char **pname = (char**)&name;
|
||||
* double value = 3.14159;
|
||||
* double *pvalue = &value;
|
||||
* bcon bc[] = { "name", BPS(&pname), "value", BPF(&pvalue), BEND };
|
||||
* bson_from_bcon( b, bc ); // generates { name: "pi", "value", 3.14159 }
|
||||
* pname = (char**)&new_name;
|
||||
* pvalue = 0;
|
||||
* bson_from_bcon( b, bc ); // generates { name: "log(0)" }
|
||||
*
|
||||
* Pointer interpolation necessarily adds an extra level of indirection and complexity.
|
||||
* All macro pointer arguments are preceded by '&'.
|
||||
* Underlying pointer types are double-indirect (**) for array types and single-indirect (*) for value types.
|
||||
* Char name[] is used above to highlight that the array reference is not assignable (in contrast to char *array).
|
||||
* Please note the (char**)& cast-address sequence required to silence the "incompatible-pointer-types" warning.
|
||||
*
|
||||
* Additional Notes
|
||||
* ----------------
|
||||
* Use the BS macro or the ":_s:" type specifier for string to allow string values that collide with type specifiers, braces, or square brackets.
|
||||
*
|
||||
* bson b[1];
|
||||
* bcon bc[] = { "spec", BS(":_s:"), BEND };
|
||||
* bson_from_bcon( b, bc ); // generates { spec: ":_s:" }
|
||||
*
|
||||
* BCON does not yet support the following BSON types.
|
||||
*
|
||||
* 05 e_name binary Binary data
|
||||
* 06 e_name undefined - deprecated
|
||||
* 0B e_name cstring cstring Regular expression
|
||||
* 0C e_name string (byte*12) DBPointer - Deprecated
|
||||
* 0D e_name string JavaScript code
|
||||
* 0F e_name code_w_s JavaScript code w/ scope
|
||||
* 11 e_name int64 Timestamp
|
||||
* FF e_name Min key
|
||||
* 7F e_name Max key
|
||||
*
|
||||
*/
|
||||
|
||||
typedef union bcon {
|
||||
char *s; /**< 02 e_name string Macro BS(v) - UTF-8 string */ /* must be first to be default */
|
||||
char *Rs; /**< 02 e_name string Macro BRS(v) - UTF-8 string reference interpolation */
|
||||
char **Ps; /**< 02 e_name string Macro BPS(v) - UTF-8 string pointer interpolation */
|
||||
double f; /**< 01 e_name double Macro BF(v) - Floating point */
|
||||
double *Rf; /**< 01 e_name double Macro BRF(v) - Floating point reference interpolation */
|
||||
double **Pf; /**< 01 e_name double Macro BPF(v) - Floating point pointer interpolation */
|
||||
union bcon *D; /**< 03 e_name document Macro BD(v) - Embedded document interpolation */
|
||||
union bcon *RD; /**< 03 e_name document Macro BRD(v) - Embedded document reference interpolation */
|
||||
union bcon **PD; /**< 03 e_name document Macro BPD(v) - Embedded document pointer interpolation */
|
||||
union bcon *A; /**< 04 e_name document Macro BA(v) - Array interpolation */
|
||||
union bcon *RA; /**< 04 e_name document Macro BRA(v) - Array reference interpolation */
|
||||
union bcon **PA; /**< 04 e_name document Macro BPA(v) - Array pointer interpolation */
|
||||
char *o; /**< 07 e_name (byte*12) Macro BO(v) - ObjectId */
|
||||
char *Ro; /**< 07 e_name (byte*12) Macro BRO(v) - ObjectId reference interpolation */
|
||||
char **Po; /**< 07 e_name (byte*12) Macro BPO(v) - ObjectId pointer interpolation */
|
||||
bson_bool_t b; /**< 08 e_name 00 Macro BB(v) - Boolean "false"
|
||||
08 e_name 01 Macro BB(v) - Boolean "true" */
|
||||
bson_bool_t *Rb; /**< 08 e_name 01 Macro BRB(v) - Boolean reference interpolation */
|
||||
bson_bool_t **Pb;/**< 08 e_name 01 Macro BPB(v) - Boolean pointer interpolation */
|
||||
time_t t; /**< 09 e_name int64 Macro BT(v) - UTC datetime */
|
||||
time_t *Rt; /**< 09 e_name int64 Macro BRT(v) - UTC datetime reference interpolation */
|
||||
time_t **Pt; /**< 09 e_name int64 Macro BPT(v) - UTC datetime pointer interpolation */
|
||||
char *v; /**< 0A e_name Macro BNULL - Null value */
|
||||
char *x; /**< 0E e_name string Macro BX(v) - Symbol */
|
||||
char *Rx; /**< 0E e_name string Macro BRX(v) - Symbol reference interpolation */
|
||||
char **Px; /**< 0E e_name string Macro BPX(v) - Symbol pointer interpolation */
|
||||
int i; /**< 10 e_name int32 Macro BI(v) - 32-bit Integer */
|
||||
int *Ri; /**< 10 e_name int32 Macro BRI(v) - 32-bit Integer reference interpolation */
|
||||
int **Pi; /**< 10 e_name int32 Macro BPI(v) - 32-bit Integer pointer interpolation */
|
||||
long l; /**< 12 e_name int64 Macro BL(v) - 64-bit Integer */
|
||||
long *Rl; /**< 12 e_name int64 Macro BRL(v) - 64-bit Integer reference interpolation */
|
||||
long **Pl; /**< 12 e_name int64 Macro BPL(v) - 64-bit Integer pointer interpolation */
|
||||
void **Pv; /* generic pointer internal */
|
||||
/* "{" "}" */ /* 03 e_name document Embedded document */
|
||||
/* "[" "]" */ /* 04 e_name document Array */
|
||||
/* 05 e_name binary Binary data */
|
||||
/* 06 e_name undefined - deprecated */
|
||||
/* 0B e_name cstring cstring Regular expression */
|
||||
/* 0C e_name string (byte*12) DBPointer - Deprecated */
|
||||
/* 0D e_name string JavaScript code */
|
||||
/* 0F e_name code_w_s JavaScript code w/ scope */
|
||||
/* 11 e_name int64 Timestamp */
|
||||
/* FF e_name Min key */
|
||||
/* 7F e_name Max key */
|
||||
} bcon;
|
||||
|
||||
/** BCON document terminator */
|
||||
#define BEND "."
|
||||
|
||||
/** BCON internal 01 double Floating point type-specifier */
|
||||
#define BTF ":_f:"
|
||||
/** BCON internal 02 char* string type-specifier */
|
||||
#define BTS ":_s:"
|
||||
/** BCON internal 03 union bcon* Embedded document interpolation type-specifier */
|
||||
#define BTD ":_D:"
|
||||
/** BCON internal 04 union bcon* Array interpolation type-specifier */
|
||||
#define BTA ":_A:"
|
||||
/** BCON internal 07 char* ObjectId type-specifier */
|
||||
#define BTO ":_o:"
|
||||
/** BCON internal 08 int Boolean type-specifier */
|
||||
#define BTB ":_b:"
|
||||
/** BCON internal 09 int64 UTC datetime type-specifier */
|
||||
#define BTT ":_t:"
|
||||
/** BCON internal 0A Null type-specifier */
|
||||
#define BTN ":_v:"
|
||||
/** BCON internal 0E char* Symbol type-specifier */
|
||||
#define BTX ":_x:"
|
||||
/** BCON internal 10 int32 64-bit Integer type-specifier */
|
||||
#define BTI ":_i:"
|
||||
/** BCON internal 12 int64 64-bit Integer type-specifier */
|
||||
#define BTL ":_l:"
|
||||
|
||||
/** BCON internal 01 double* Floating point reference interpolation type-specifier */
|
||||
#define BTRF ":Rf:"
|
||||
/** BCON internal 02 char* string reference interpolation type-specifier */
|
||||
#define BTRS ":Rs:"
|
||||
/** BCON internal 03 union bcon* Embedded document reference interpolation type-specifier */
|
||||
#define BTRD ":RD:"
|
||||
/** BCON internal 04 union bcon* Array reference interpolation type-specifier */
|
||||
#define BTRA ":RA:"
|
||||
/** BCON internal 07 char* ObjectId reference interpolation type-specifier */
|
||||
#define BTRO ":Ro:"
|
||||
/** BCON internal 08 int* Boolean reference interpolation type-specifier */
|
||||
#define BTRB ":Rb:"
|
||||
/** BCON internal 09 int64* UTC datetime reference interpolation type-specifier */
|
||||
#define BTRT ":Rt:"
|
||||
/** BCON internal 0E char* Symbol reference interpolation type-specifier */
|
||||
#define BTRX ":Rx:"
|
||||
/** BCON internal 10 int32* 23-bit Integer reference interpolation type-specifier */
|
||||
#define BTRI ":Ri:"
|
||||
/** BCON internal 12 int64* 64-bit Integer reference interpolation type-specifier */
|
||||
#define BTRL ":Rl:"
|
||||
|
||||
/** BCON internal 01 double** Floating point pointer interpolation type-specifier */
|
||||
#define BTPF ":Pf:"
|
||||
/** BCON internal 02 char** string pointer interpolation type-specifier */
|
||||
#define BTPS ":Ps:"
|
||||
/** BCON internal 03 union bcon** Embedded document pointer interpolation type-specifier */
|
||||
#define BTPD ":PD:"
|
||||
/** BCON internal 04 union bcon** Array pointer interpolation type-specifier */
|
||||
#define BTPA ":PA:"
|
||||
/** BCON internal 07 char** ObjectId pointer interpolation type-specifier */
|
||||
#define BTPO ":Po:"
|
||||
/** BCON internal 08 int** Boolean pointer interpolation type-specifier */
|
||||
#define BTPB ":Pb:"
|
||||
/** BCON internal 09 int64** UTC datetime pointer interpolation type-specifier */
|
||||
#define BTPT ":Pt:"
|
||||
/** BCON internal 0E char** Symbol pointer interpolation type-specifier */
|
||||
#define BTPX ":Px:"
|
||||
/** BCON internal 10 int32** 23-bit Integer pointer interpolation type-specifier */
|
||||
#define BTPI ":Pi:"
|
||||
/** BCON internal 12 int64** 64-bit Integer pointer interpolation type-specifier */
|
||||
#define BTPL ":Pl:"
|
||||
|
||||
/** BCON 01 double Floating point value */
|
||||
#define BF(v) BTF, { .f = (v) }
|
||||
/** BCON 02 char* string value */
|
||||
#define BS(v) BTS, { .s = (v) }
|
||||
/** BCON 03 union bcon* Embedded document interpolation value */
|
||||
#define BD(v) BTD, { .D = (v) }
|
||||
/** BCON 04 union bcon* Array interpolation value */
|
||||
#define BA(v) BTA, { .A = (v) }
|
||||
/** BCON 07 char* ObjectId value */
|
||||
#define BO(v) BTO, { .o = (v) }
|
||||
/** BCON 08 int Boolean value */
|
||||
#define BB(v) BTB, { .b = (v) }
|
||||
/** BCON 09 int64 UTC datetime value */
|
||||
#define BT(v) BTT, { .t = (v) }
|
||||
/** BCON 0A Null value */
|
||||
#define BNULL BTN, { .v = ("") }
|
||||
/** BCON 0E char* Symbol value */
|
||||
#define BX(v) BTX, { .x = (v) }
|
||||
/** BCON 10 int32 32-bit Integer value */
|
||||
#define BI(v) BTI, { .i = (v) }
|
||||
/** BCON 12 int64 64-bit Integer value */
|
||||
#define BL(v) BTL, { .l = (v) }
|
||||
|
||||
/** BCON 01 double* Floating point interpolation value */
|
||||
#define BRF(v) BTRF, { .Rf = (v) }
|
||||
/** BCON 02 char* string interpolation value */
|
||||
#define BRS(v) BTRS, { .Rs = (v) }
|
||||
/** BCON 03 union bcon* Embedded document interpolation value */
|
||||
#define BRD(v) BTRD, { .RD = (v) }
|
||||
/** BCON 04 union bcon* Array interpolation value */
|
||||
#define BRA(v) BTRA, { .RA = (v) }
|
||||
/** BCON 07 char* ObjectId interpolation value */
|
||||
#define BRO(v) BTRO, { .Ro = (v) }
|
||||
/** BCON 08 int* Boolean interpolation value */
|
||||
#define BRB(v) BTRB, { .Rb = (v) }
|
||||
/** BCON 09 int64* UTC datetime value */
|
||||
#define BRT(v) BTRT, { .Rt = (v) }
|
||||
/** BCON 0E char* Symbol interpolation value */
|
||||
#define BRX(v) BTRX, { .Rx = (v) }
|
||||
/** BCON 10 int32* 32-bit Integer interpolation value */
|
||||
#define BRI(v) BTRI, { .Ri = (v) }
|
||||
/** BCON 12 int64* 64-bit Integer interpolation value */
|
||||
#define BRL(v) BTRL, { .Rl = (v) }
|
||||
|
||||
/** BCON 01 double** Floating point interpolation value */
|
||||
#define BPF(v) BTPF, { .Pf = (v) }
|
||||
/** BCON 02 char** string interpolation value */
|
||||
#define BPS(v) BTPS, { .Ps = ((char**)v) }
|
||||
/** BCON 03 union bcon** Embedded document interpolation value */
|
||||
#define BPD(v) BTPD, { .PD = ((union bcon **)v) }
|
||||
/** BCON 04 union bcon** Array interpolation value */
|
||||
#define BPA(v) BTPA, { .PA = ((union bcon **)v) }
|
||||
/** BCON 07 char** ObjectId interpolation value */
|
||||
#define BPO(v) BTPO, { .Po = ((char**)v) }
|
||||
/** BCON 08 int** Boolean interpolation value */
|
||||
#define BPB(v) BTPB, { .Pb = (v) }
|
||||
/** BCON 09 int64** UTC datetime value */
|
||||
#define BPT(v) BTPT, { .Pt = (v) }
|
||||
/** BCON 0E char** Symbol interpolation value */
|
||||
#define BPX(v) BTPX, { .Px = ((char**)v) }
|
||||
/** BCON 10 int32** 32-bit Integer interpolation value */
|
||||
#define BPI(v) BTPI, { .Pi = (v) }
|
||||
/** BCON 12 int64** 64-bit Integer interpolation value */
|
||||
#define BPL(v) BTPL, { .Pl = (v) }
|
||||
|
||||
/*
|
||||
* References on codes used for types
|
||||
* http://en.wikipedia.org/wiki/Name_mangling
|
||||
* http://www.agner.org/optimize/calling_conventions.pdf (page 25)
|
||||
*/
|
||||
|
||||
typedef enum bcon_error_t {
|
||||
BCON_OK = 0, /**< OK return code */
|
||||
BCON_ERROR, /**< ERROR return code */
|
||||
BCON_DOCUMENT_INCOMPLETE, /**< bcon document or nesting incomplete */
|
||||
BCON_BSON_ERROR /**< bson finish error */
|
||||
} bcon_error_t;
|
||||
|
||||
extern char *bcon_errstr[]; /**< bcon_error_t text messages */
|
||||
|
||||
/**
|
||||
* Append a BCON object to a BSON object.
|
||||
*
|
||||
* @param b a BSON object
|
||||
* @param bc a BCON object
|
||||
*/
|
||||
MONGO_EXPORT bcon_error_t bson_append_bcon(bson *b, const bcon *bc);
|
||||
|
||||
/**
|
||||
* Generate a BSON object from a BCON object.
|
||||
*
|
||||
* @param b a BSON object
|
||||
* @param bc a BCON object
|
||||
*/
|
||||
MONGO_EXPORT bcon_error_t bson_from_bcon( bson *b, const bcon *bc );
|
||||
|
||||
/**
|
||||
* Print a string representation of a BCON object.
|
||||
*
|
||||
* @param bc the BCON object to print.
|
||||
*/
|
||||
MONGO_EXPORT void bcon_print( const bcon *bc );
|
||||
|
||||
#ifndef DOXYGEN_SHOULD_SKIP_THIS
|
||||
|
||||
MONGO_EXTERN_C_END
|
||||
|
||||
typedef enum bcon_token_t {
|
||||
Token_Default, Token_End, Token_Typespec,
|
||||
Token_OpenBrace, Token_CloseBrace, Token_OpenBracket, Token_CloseBracket,
|
||||
Token_EOD
|
||||
} bcon_token_t;
|
||||
|
||||
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
|
||||
|
||||
#endif
|
||||
1049
apps/systemlib/bson/bson.c
Normal file
1049
apps/systemlib/bson/bson.c
Normal file
File diff suppressed because it is too large
Load Diff
1044
apps/systemlib/bson/bson.h
Normal file
1044
apps/systemlib/bson/bson.h
Normal file
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user