static void
decodeObjects (
co_eBO bo
)
{
pwr_tStatus lsts;
gdb_sClass *cp;
pool_sQlink *cl;
gdb_sObject *op;
pool_sQlink *ol;
for (
cl = pool_Qsucc(&lsts, gdbroot->pool, &gdbroot->db->class_lh);
cl != &gdbroot->db->class_lh;
cl = pool_Qsucc(&lsts, gdbroot->pool, cl)
) {
cp = pool_Qitem(cl, gdb_sClass, class_ll);
for (
ol = pool_Qsucc(&lsts, gdbroot->pool, &cp->cid_lh);
ol != &cp->cid_lh;
ol = pool_Qsucc(&lsts, gdbroot->pool, ol)
) {
op = pool_Qitem(ol, gdb_sObject, u.n.cid_ll);
if (op->u.n.flags.b.bodyDecoded) continue;
decodeObject(&lsts, op, cp, bo);
}
}
}
v8::Local<v8::Object> decodeObject(const char *buffer)
{
bson_iterator it;
bson_iterator_from_buffer(&it, buffer);
return decodeObject(&it, false);
}
v8::Local<v8::Object> decodeObject(const bson *bb)
{
bson_iterator it;
bson_iterator_from_buffer(&it, bson_data(bb));
return decodeObject(&it, false);
}
result_t encoding_base::bsonDecode(Buffer_base *data,
v8::Local<v8::Object> &retVal)
{
std::string strBuf;
data->toString(strBuf);
retVal = decodeObject(strBuf.c_str());
return 0;
}
result_t MongoDB::bsonHandler(bson *command, v8::Local<v8::Object> &retVal)
{
bson out;
result_t hr = cc__runCommand(command, out);
if (hr < 0)
return hr;
retVal = decodeObject(holder(), &out);
bson_destroy(&out);
bson_destroy(command);
return 0;
}
result_t MongoCursor::next(v8::Local<v8::Object> &retVal)
{
bool has;
result_t hr = hasNext(has);
if (hr < 0)
return hr;
if (!has)
return CALL_RETURN_NULL;
retVal = decodeObject(mongo_cursor_bson(m_cursor));
m_state = CUR_NONE;
return 0;
}
int ObjectFactory::decodeObject( const char* data,
int* idx,
Object* obj )
{
std::string id;
Object::Type type;
PropList props;
if( decodeObject(data, idx, &id, &type, &props) ){
return -EINVAL;
}
*obj = Object(id, type, props);
return 0;
}
QPpsAttributeMap QPpsObjectPrivate::decode(const QByteArray &rawData, bool *ok)
{
QPpsAttributeMap attributeMap;
pps_decoder_t decoder;
QByteArray mutableData(rawData);
pps_decoder_error_t error = pps_decoder_initialize(&decoder, mutableData.data());
if (error == PPS_DECODER_OK) {
// no need to check ok in this case
attributeMap = decodeObject(&decoder, ok);
} else {
qWarning() << "QPpsObjectPrivate::decode: pps_decoder_initialize failed";
*ok = false;
}
pps_decoder_cleanup(&decoder);
return attributeMap;
}
pwr_tBoolean
ivol_RebuildVolume (
pwr_tStatus *status,
ivol_sVolume *lv,
const co_mFormat *format
)
{
gdb_sVolume *vp = lv->vp;
ivol_sObject *iop;
lst_sEntry *iol;
pool_sQlink *ol;
gdb_sObject *op;
pwr_dStatus(sts, status, GDH__SUCCESS);
gdb_AssumeExcled;
gdb_AssumeLocked;
#if 0
// if (!vp->modified) continue;
#endif
for (
ol = pool_Qsucc(sts, gdbroot->pool, &vp->l.obj_lh);
ol != &vp->l.obj_lh;
) {
op = pool_Qitem(ol, gdb_sObject, l.obj_ll);
ol = pool_Qsucc(sts, gdbroot->pool, ol);
if (op->u.n.flags.b.swapDelete && !op->u.n.flags.b.systemCreated) {
vol_SetAlarmLevel(sts, op, 0);/* !!! TODO Remeber to take care of move also in dvol delete and move */
vol_SetBlockLevel(sts, op, 0);/* !!! TODO Remeber to take care of move also in dvol delete and move */
}
}
/* Unlink all modified objects. */
for (iop = lst_Succ(NULL, &lv->upd_lh, &iol); iop != NULL; iop = lst_Succ(NULL, iol, &iol)) {
if (!(iop->flags.m & gdb_mChange_head)) continue;
vol_UnlinkObject(sts, vp, iop->op, iop->unlink.m);
updateObject(lv, iop);
}
for (iop = lst_Succ(NULL, &lv->upd_io_lh, &iol); iop != NULL; iop = lst_Succ(NULL, iol, &iol)) {
if (!(iop->flags.m & gdb_mChange_head)) continue;
vol_UnlinkObject(sts, vp, iop->op, iop->unlink.m);
updateObject(lv, iop);
}
for (iop = lst_Succ(NULL, &lv->cre_lh, &iol); iop != NULL; iop = lst_Succ(NULL, iol, &iol)) {
vol_LinkObject(sts, vp, iop->op, vol_mLink_loOidTab);
}
for (
ol = pool_Qsucc(sts, gdbroot->pool, &vp->l.obj_lh);
ol != &vp->l.obj_lh;
) {
op = pool_Qitem(ol, gdb_sObject, l.obj_ll);
ol = pool_Qsucc(sts, gdbroot->pool, ol);
if (op->u.n.flags.b.swapDelete && !op->u.n.flags.b.systemCreated) {
vol_UnlinkObject(sts, vp, op, vol_mLink_swapDelete);
}
}
/* Relink all new and modified objects. */
for (iop = lst_Succ(NULL, &lv->upd_lh, &iol); iop != NULL; iop = lst_Succ(NULL, iol, &iol)) {
if (!(iop->flags.m & gdb_mChange_head)) continue;
vol_LinkObject(sts, vp, iop->op, iop->link.m);
}
for (iop = lst_Succ(NULL, &lv->upd_io_lh, &iol); iop != NULL; iop = lst_Succ(NULL, iol, &iol)) {
if (!(iop->flags.m & gdb_mChange_head)) continue;
vol_LinkObject(sts, vp, iop->op, iop->link.m);
}
convFctn = dvms_GetFctns(format);
for (iop = lst_Succ(NULL, &lv->cre_lh, &iol); iop != NULL; iop = lst_Succ(NULL, iol, &iol)) {
vol_LinkObject(sts, vp, iop->op, vol_mLink_swapBuild);
if (convFctn != NULL)
decodeObject(NULL, iop->op, iop->cp, format->b.bo);
}
convFctn = NULL;
#if 0
san_DeleteVolumeServers(sts, vp);
#endif
return YES;
}
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;
}
}
