void
grn_output_bool(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type, char value)
{
put_delimiter(ctx, outbuf, output_type);
switch (output_type) {
case GRN_CONTENT_JSON:
GRN_TEXT_PUTS(ctx, outbuf, value ? "true" : "false");
break;
case GRN_CONTENT_TSV:
GRN_TEXT_PUTS(ctx, outbuf, value ? "true" : "false");
break;
case GRN_CONTENT_XML:
GRN_TEXT_PUTS(ctx, outbuf, "<BOOL>");
GRN_TEXT_PUTS(ctx, outbuf, value ? "true" : "false");
GRN_TEXT_PUTS(ctx, outbuf, "</BOOL>");
break;
case GRN_CONTENT_MSGPACK :
#ifdef HAVE_MESSAGE_PACK
if (value) {
msgpack_pack_true(&ctx->impl->msgpacker);
} else {
msgpack_pack_false(&ctx->impl->msgpacker);
}
#endif
break;
case GRN_CONTENT_NONE:
break;
}
INCR_LENGTH;
}
std::string encodeRequest(const Request &r) {
std::shared_ptr<msgpack_sbuffer> buffer{msgpack_sbuffer_new(), &msgpack_sbuffer_free};
std::shared_ptr<msgpack_packer> pk{msgpack_packer_new(buffer.get(), msgpack_sbuffer_write), &msgpack_packer_free};
msgpack_pack_map(pk.get(), 5);
msgpack_pack_raw(pk.get(), 4);
msgpack_pack_raw_body(pk.get(), "func", 4);
msgpack_pack_raw(pk.get(), r.func.size());
msgpack_pack_raw_body(pk.get(), r.func.data(), r.func.size());
msgpack_pack_raw(pk.get(), 6);
msgpack_pack_raw_body(pk.get(), "metric", 6);
msgpack_pack_raw(pk.get(), r.metric.size());
msgpack_pack_raw_body(pk.get(), r.metric.data(), r.metric.size());
msgpack_pack_raw(pk.get(), 9);
msgpack_pack_raw_body(pk.get(), "timestamp", 9);
msgpack_pack_uint64(pk.get(), r.timestamp);
msgpack_pack_raw(pk.get(), 5);
msgpack_pack_raw_body(pk.get(), "value", 5);
switch(r.value.type()) {
case Value::Type::Nil:
msgpack_pack_nil(pk.get());
break;
case Value::Type::Boolean:
if(r.value.as<bool>())
msgpack_pack_true(pk.get());
else
msgpack_pack_false(pk.get());
break;
case Value::Type::Numeric:
msgpack_pack_double(pk.get(), r.value.as<double>());
break;
case Value::Type::String:
{
std::string b = r.value.as<std::string>();
msgpack_pack_raw(pk.get(), b.size());
msgpack_pack_raw_body(pk.get(), b.data(), b.size());
}
break;
case Value::Type::Table:
{
// Hack
std::string b = r.value.as<std::string>();
if(b.empty())
msgpack_pack_nil(pk.get());
else
msgpack_sbuffer_write(reinterpret_cast<void *>(buffer.get()), b.data(), b.size());
}
break;
}
msgpack_pack_raw(pk.get(), 5);
msgpack_pack_raw_body(pk.get(), "state", 5);
if(r.state.empty())
msgpack_pack_nil(pk.get());
else
msgpack_sbuffer_write(reinterpret_cast<void *>(buffer.get()), r.state.data(), r.state.size());
return std::string(buffer->data, buffer->size);
}
void msgpack_pack_boolean(msgpack_packer *pk, bool value)
{
if (value)
msgpack_pack_true(pk);
else
msgpack_pack_false(pk);
}
void
paxos_instance_pack(struct yakyak *yy, struct paxos_instance *inst)
{
msgpack_pack_array(yy->pk, 3);
paxos_header_pack(yy, &inst->pi_hdr);
inst->pi_committed ? msgpack_pack_true(yy->pk) : msgpack_pack_false(yy->pk);
paxos_value_pack(yy, &inst->pi_val);
}
/**
* Serialise a valud into the msgpack stream
*/
void MsgpackIODevice::send(bool b)
{
if ( b ) {
msgpack_pack_true(&m_pk);
} else {
msgpack_pack_false(&m_pk);
}
}
void msgpack_rpc_from_boolean(Boolean result, msgpack_packer *res)
{
if (result) {
msgpack_pack_true(res);
} else {
msgpack_pack_false(res);
}
}
int msgpack_pack_bool(msgpack_packer* pk, BOOL b)
{
if (b)
msgpack_pack_true(pk);
else
msgpack_pack_false(pk);
return 0;
}
int failed_packfn(msgpack_packer * pk, void *msg)
{
size_t msg_length = strlen((char *) msg);
msgpack_pack_array(pk, 2);
msgpack_pack_false(pk);
msgpack_pack_raw(pk, msg_length);
msgpack_pack_raw_body(pk, msg, msg_length);
return (0);
}
int yar_pack_push_bool(yar_packager *packager, int val) /* {{{ */ {
msgpack_packer *pk = packager->pk;
if (val == 0) {
if (msgpack_pack_false(pk) < 0) {
return 0;
}
} else {
if (msgpack_pack_true(pk) < 0) {
return 0;
}
}
return 1;
}
int main(void)
{
unlink(filename);
FILE *f = fopen(filename, "w");
msgpack_packer pk;
msgpack_packer_init(&pk, f, msgpack_fbuffer_write);
msgpack_pack_array(&pk, 3);
msgpack_pack_nil(&pk);
msgpack_pack_true(&pk);
msgpack_pack_false(&pk);
fclose(f);
return 0;
}
int LogInLog_to_msgpack(msgpack_packer *pk, LogInLog *arg) {
msgpack_pack_array(pk, 13);
UserInfo_to_msgpack(pk, &arg->user);
msgpack_pack_int(pk, arg->site);
msgpack_pack_int(pk, arg->num);
msgpack_pack_array(pk, arg->sites_size);
for (int _i = 0; _i < arg->sites_size; ++_i) {
msgpack_pack_int(pk, arg->sites[_i]);
}
msgpack_pack_map(pk, arg->sites2_size);
for (int _i = 0; _i < arg->sites2_size; ++_i) {
if (arg->sites2_keys[_i]) {
size_t _l = strlen(arg->sites2_keys[_i]);
msgpack_pack_raw(pk, _l);
msgpack_pack_raw_body(pk, arg->sites2_keys[_i], _l);
} else {
msgpack_pack_nil(pk);
}
msgpack_pack_int(pk, arg->sites2_vals[_i]);
}
if (arg->s1) {
size_t _l = strlen(arg->s1);
msgpack_pack_raw(pk, _l);
msgpack_pack_raw_body(pk, arg->s1, _l);
} else {
msgpack_pack_nil(pk);
}
arg->b1 ? msgpack_pack_true(pk) : msgpack_pack_false(pk);
msgpack_pack_raw(pk, arg->r1_size);
msgpack_pack_raw_body(pk, arg->r1, arg->r1_size);
msgpack_pack_double(pk, arg->d1);
msgpack_pack_int(pk, arg->i2);
my_type_x_to_msgpack(pk, &arg->my1);
msgpack_pack_array(pk, arg->user_list_size);
for (int _i = 0; _i < arg->user_list_size; ++_i) {
UserInfo_to_msgpack(pk, &arg->user_list[_i]);
}
msgpack_pack_map(pk, arg->user_map_size);
for (int _i = 0; _i < arg->user_map_size; ++_i) {
UserInfo_to_msgpack(pk, &arg->user_map_keys[_i]);
UserInfo_to_msgpack(pk, &arg->user_map_vals[_i]);
}
return 0;
}
void prepare(msgpack_sbuffer* sbuf) {
msgpack_packer pk;
msgpack_packer_init(&pk, sbuf, msgpack_sbuffer_write);
/* 1st object */
msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1);
msgpack_pack_true(&pk);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "example", 7);
/* 2nd object */
msgpack_pack_str(&pk, 6);
msgpack_pack_str_body(&pk, "second", 6);
/* 3rd object */
msgpack_pack_array(&pk, 2);
msgpack_pack_int(&pk, 42);
msgpack_pack_false(&pk);
}
void receiver_init(receiver *r) {
msgpack_packer pk;
msgpack_sbuffer_init(&r->sbuf);
msgpack_packer_init(&pk, &r->sbuf, msgpack_sbuffer_write);
/* 1st object */
msgpack_pack_array(&pk, 3);
msgpack_pack_int(&pk, 1);
msgpack_pack_true(&pk);
msgpack_pack_str(&pk, 7);
msgpack_pack_str_body(&pk, "example", 7);
/* 2nd object */
msgpack_pack_str(&pk, 6);
msgpack_pack_str_body(&pk, "second", 6);
/* 3rd object */
msgpack_pack_array(&pk, 2);
msgpack_pack_int(&pk, 42);
msgpack_pack_false(&pk);
r->rest = r->sbuf.size;
}
static inline void
pack_scalar(msgpack_packer *pk, const JsonValueScalar scalar)
{
switch (scalar.token_type) {
case JSON_TOKEN_STRING:
pack_string(pk, scalar.token);
break;
case JSON_TOKEN_NUMBER:
pack_number(pk, scalar.token);
break;
case JSON_TOKEN_TRUE:
msgpack_pack_true(pk);
break;
case JSON_TOKEN_FALSE:
msgpack_pack_false(pk);
break;
case JSON_TOKEN_NULL:
msgpack_pack_nil(pk);
break;
default:
/* TODO: parse error */
break;
}
}
int msgpack_pack_false_wrap(msgpack_packer* pk)
{
return msgpack_pack_false(pk);
}
int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
{
switch(d.type) {
case MSGPACK_OBJECT_NIL:
return msgpack_pack_nil(pk);
case MSGPACK_OBJECT_BOOLEAN:
if(d.via.boolean) {
return msgpack_pack_true(pk);
} else {
return msgpack_pack_false(pk);
}
case MSGPACK_OBJECT_POSITIVE_INTEGER:
return msgpack_pack_uint64(pk, d.via.u64);
case MSGPACK_OBJECT_NEGATIVE_INTEGER:
return msgpack_pack_int64(pk, d.via.i64);
case MSGPACK_OBJECT_DOUBLE:
return msgpack_pack_double(pk, d.via.dec);
case MSGPACK_OBJECT_RAW:
{
int ret = msgpack_pack_raw(pk, d.via.raw.size);
if(ret < 0) { return ret; }
return msgpack_pack_raw_body(pk, d.via.raw.ptr, d.via.raw.size);
}
case MSGPACK_OBJECT_ARRAY:
{
int ret = msgpack_pack_array(pk, d.via.array.size);
if(ret < 0) { return ret; }
msgpack_object* o = d.via.array.ptr;
msgpack_object* const oend = d.via.array.ptr + d.via.array.size;
for(; o != oend; ++o) {
ret = msgpack_pack_object(pk, *o);
if(ret < 0) { return ret; }
}
return 0;
}
case MSGPACK_OBJECT_MAP:
{
int ret = msgpack_pack_map(pk, d.via.map.size);
if(ret < 0) { return ret; }
msgpack_object_kv* kv = d.via.map.ptr;
msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size;
for(; kv != kvend; ++kv) {
ret = msgpack_pack_object(pk, kv->key);
if(ret < 0) { return ret; }
ret = msgpack_pack_object(pk, kv->val);
if(ret < 0) { return ret; }
}
return 0;
}
default:
return -1;
}
}
/*
* Document-method: FalseClass#to_msgpack
*
* call-seq:
* false.to_msgpack(out = '') -> String
*
* Serializes false into raw bytes.
*/
static VALUE MessagePack_FalseClass_to_msgpack(int argc, VALUE *argv, VALUE self)
{
ARG_BUFFER(out, argc, argv);
msgpack_pack_false(out);
return out;
}
static void
msgpack_wrap_redis_reply(const struct cmd *cmd, struct msg_out *out, const redisReply *r) {
unsigned int i;
msgpack_packer* pk = msgpack_packer_new(out, on_msgpack_write);
/* copy verb, as jansson only takes a char* but not its length. */
char *verb = "";
size_t verb_sz = 0;
if(cmd->count) {
verb_sz = cmd->argv_len[0];
verb = cmd->argv[0];
}
/* Create map object */
msgpack_pack_map(pk, 1);
/* The single element is the verb */
msgpack_pack_raw(pk, verb_sz);
msgpack_pack_raw_body(pk, verb, verb_sz);
switch(r->type) {
case REDIS_REPLY_STATUS:
case REDIS_REPLY_ERROR:
msgpack_pack_array(pk, 2);
/* first element: book */
if(r->type == REDIS_REPLY_ERROR)
msgpack_pack_false(pk);
else
msgpack_pack_true(pk);
/* second element: message */
msgpack_pack_raw(pk, r->len);
msgpack_pack_raw_body(pk, r->str, r->len);
break;
case REDIS_REPLY_STRING:
if(verb_sz ==4 && strncasecmp(verb, "INFO", 4) == 0) {
msg_info_reply(pk, r->str, r->len);
} else {
msgpack_pack_raw(pk, r->len);
msgpack_pack_raw_body(pk, r->str, r->len);
}
break;
case REDIS_REPLY_INTEGER:
msgpack_pack_int(pk, r->integer);
break;
case REDIS_REPLY_ARRAY:
if(verb_sz == 7 && strncasecmp(verb, "HGETALL", 7) == 0) {
msg_hgetall_reply(pk, r);
break;
}
msgpack_pack_array(pk, r->elements);
for(i = 0; i < r->elements; ++i) {
redisReply *e = r->element[i];
switch(e->type) {
case REDIS_REPLY_STRING:
msgpack_pack_raw(pk, e->len);
msgpack_pack_raw_body(pk, e->str, e->len);
break;
case REDIS_REPLY_INTEGER:
msgpack_pack_int(pk, e->integer);
break;
default:
msgpack_pack_nil(pk);
break;
}
}
break;
default:
msgpack_pack_nil(pk);
break;
}
msgpack_packer_free(pk);
}
/* It parse a JSON string and convert it to MessagePack format */
char *flb_pack_json(char *js, size_t len, int *size)
{
int i;
int flen;
int arr_size;
char *p;
char *buf;
jsmntok_t *t;
jsmntok_t *tokens;
msgpack_packer pck;
msgpack_sbuffer sbuf;
if (!js) {
return NULL;
}
tokens = json_tokenise(js, len, &arr_size);
if (!tokens) {
return NULL;
}
flb_debug("JSON to pack: '%s'", js);
/* initialize buffers */
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pck, &sbuf, msgpack_sbuffer_write);
for (i = 0; i < arr_size ; i++) {
t = &tokens[i];
if (t->start == -1 || t->end == -1 || (t->start == 0 && t->end == 0)) {
break;
}
flen = (t->end - t->start);
switch (t->type) {
case JSMN_OBJECT:
flb_debug("json_pack: token=%i is OBJECT (size=%i)", i, t->size);
msgpack_pack_map(&pck, t->size);
break;
case JSMN_ARRAY:
flb_debug("json_pack: token=%i is ARRAY (size=%i)", i, t->size);
msgpack_pack_array(&pck, t->size);
break;
case JSMN_STRING:
flb_debug("json_pack: token=%i is STRING (len=%i)\n", i, flen);
msgpack_pack_bin(&pck, flen);
msgpack_pack_bin_body(&pck, js + t->start, flen);
break;
case JSMN_PRIMITIVE:
p = js + t->start;
if (strncmp(p, "false", 5) == 0) {
flb_debug("json_pack: token=%i is FALSE", i);
msgpack_pack_false(&pck);
}
else if (strncmp(p, "true", 4) == 0) {
flb_debug("json_pack: token=%i is TRUE", i);
msgpack_pack_true(&pck);
}
else if (strncmp(p, "null", 4) == 0) {
flb_debug("json_pack: token=%i is NULL", i);
msgpack_pack_nil(&pck);
}
else {
flb_debug("json_pack: token=%i is INT64", i);
msgpack_pack_int64(&pck, atol(p));
}
break;
}
}
/* dump data back to a new buffer */
*size = sbuf.size;
buf = malloc(sbuf.size);
memcpy(buf, sbuf.data, sbuf.size);
msgpack_sbuffer_destroy(&sbuf);
free(tokens);
return buf;
}
static void msgpack_bool(CTX ctx, void *pkp, int b)
{
kpackAPI_t *pk = (kpackAPI_t *)pkp;
(b) ? msgpack_pack_true(pk->pk) : msgpack_pack_false(pk->pk);
}
void ANetworkController::ReceivedGetBehaviors() {
msgpack_sbuffer sbuf;
msgpack_sbuffer_init(&sbuf);
/* serialize values into the buffer using msgpack_sbuffer_write callback function. */
msgpack_packer pk;
msgpack_packer_init(&pk, &sbuf, msgpack_sbuffer_write);
msgpack_pack_array(&pk, 2);
msgpack_pack_uint16(&pk, EPacketType::PT_GetBehaviors);
TArray<ABehaviours*> BehaviorsList;
for (TActorIterator<ABehaviours> ObjIt(GetWorld()); ObjIt; ++ObjIt) {
ABehaviours* Behaviors = *ObjIt;
BehaviorsList.Add(Behaviors);
}
int32 BehaviorsListNum = BehaviorsList.Num();
msgpack_pack_array(&pk, BehaviorsListNum);
for (int i = 0; i < BehaviorsListNum; i++) {
ABehaviours* Behaviors = BehaviorsList[i];
msgpack_pack_map(&pk, 4);
msgpack_pack_str(&pk, 13);
msgpack_pack_str_body(&pk, "FlockingState", 13);
msgpack_pack_uint8(&pk, (uint8)Behaviors->FlockingState);
msgpack_pack_str(&pk, 13);
msgpack_pack_str_body(&pk, "ThrottleGains", 13);
Pack(&pk, Behaviors->ThrottleGains);
msgpack_pack_str(&pk, 13);
msgpack_pack_str_body(&pk, "SteeringGains", 13);
Pack(&pk, Behaviors->SteeringGains);
int32 BehaviorsNum = Behaviors->Behaviours.Num();
msgpack_pack_str(&pk, 9);
msgpack_pack_str_body(&pk, "Behaviors", 9);
msgpack_pack_array(&pk, BehaviorsNum);
for (int j = 0; j < BehaviorsNum; j++) {
UBehaviour* Behavior = Behaviors->Behaviours[j];
TArray<UProperty*> Properties;
for (TFieldIterator<UProperty> PropIt(Behavior->GetClass()); PropIt; ++PropIt) {
UProperty* Property = *PropIt;
if (Cast<UNumericProperty>(Property) || Cast<UBoolProperty>(Property)) {
Properties.Add(Property);
}
}
msgpack_pack_map(&pk, Properties.Num() + 1);
msgpack_pack_str(&pk, 4);
msgpack_pack_str_body(&pk, "Name", 4);
FString Name = Behavior->GetClass()->GetName();
msgpack_pack_str(&pk, Name.Len());
msgpack_pack_str_body(&pk, TCHAR_TO_UTF8(*Name), Name.Len());
for (auto PropIt(Properties.CreateIterator()); PropIt; ++PropIt) {
UProperty* Property = *PropIt;
const void* Value = Property->ContainerPtrToValuePtr<uint8>(Behavior);
FString Name = Property->GetName();
msgpack_pack_str(&pk, Name.Len());
msgpack_pack_str_body(&pk, TCHAR_TO_UTF8(*Name), Name.Len());
if (UNumericProperty *NumericProperty = Cast<UNumericProperty>(Property)) {
if (NumericProperty->IsFloatingPoint()) {
msgpack_pack_double(&pk, NumericProperty->GetFloatingPointPropertyValue(Value));
}
else if (NumericProperty->IsInteger()) {
msgpack_pack_int(&pk, NumericProperty->GetSignedIntPropertyValue(Value));
}
}
else if (UBoolProperty *BoolProperty = Cast<UBoolProperty>(Property)) {
if (BoolProperty->GetPropertyValue(Value)) {
msgpack_pack_true(&pk);
}
else {
msgpack_pack_false(&pk);
}
}
}
}
}
int32 BytesSent;
TcpSocket->Send((uint8*)sbuf.data, sbuf.size, BytesSent);
msgpack_sbuffer_destroy(&sbuf);
}
static inline void
rbtrace__send_event(int nargs, const char *name, ...)
{
if (!rbtracer.attached_pid ||
!rbtracer.sbuf ||
!rbtracer.msgpacker ||
rbtracer.mqo_fd == -1)
return;
int n;
msgpack_sbuffer_clear(rbtracer.sbuf);
msgpack_packer *pk = rbtracer.msgpacker;
msgpack_pack_array(pk, nargs+1);
msgpack_pack_raw(pk, strlen(name));
msgpack_pack_raw_body(pk, name, strlen(name));
if (nargs > 0) {
int type;
int sint;
uint32_t uint;
uint64_t uint64;
unsigned long ulong;
char *str;
va_list ap;
va_start(ap, name);
for (n=0; n<nargs; n++) {
type = va_arg(ap, int);
switch (type) {
case 'b': // boolean
if (va_arg(ap, int))
msgpack_pack_true(pk);
else
msgpack_pack_false(pk);
break;
case 'd': // signed int
sint = va_arg(ap, int);
msgpack_pack_int(pk, sint);
break;
case 'u': // unsigned int
uint = va_arg(ap, uint32_t);
msgpack_pack_uint32(pk, uint);
break;
case 'l': // unsigned long (VALUE/ID)
ulong = va_arg(ap, unsigned long);
msgpack_pack_unsigned_long(pk, ulong);
break;
case 't': // uint64 (timestamps)
uint64 = va_arg(ap, uint64_t);
msgpack_pack_uint64(pk, uint64);
break;
case 'n': // current timestamp
msgpack_pack_uint64(pk, timeofday_usec());
break;
case 's': // string
str = va_arg(ap, char *);
if (!str)
str = (char *)"";
msgpack_pack_raw(pk, strlen(str));
msgpack_pack_raw_body(pk, str, strlen(str));
break;
default:
fprintf(stderr, "unknown type (%d) passed to rbtrace__send_event for %s\n", (int)type, name);
}
}
int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
{
switch(d.type) {
case MSGPACK_OBJECT_NIL:
return msgpack_pack_nil(pk);
case MSGPACK_OBJECT_BOOLEAN:
if(d.via.boolean) {
return msgpack_pack_true(pk);
} else {
return msgpack_pack_false(pk);
}
case MSGPACK_OBJECT_POSITIVE_INTEGER:
return msgpack_pack_uint64(pk, d.via.u64);
case MSGPACK_OBJECT_NEGATIVE_INTEGER:
return msgpack_pack_int64(pk, d.via.i64);
case MSGPACK_OBJECT_FLOAT32:
return msgpack_pack_float(pk, (float)d.via.f64);
case MSGPACK_OBJECT_FLOAT64:
return msgpack_pack_double(pk, d.via.f64);
case MSGPACK_OBJECT_STR:
{
int ret = msgpack_pack_str(pk, d.via.str.size);
if(ret < 0) { return ret; }
return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size);
}
case MSGPACK_OBJECT_BIN:
{
int ret = msgpack_pack_bin(pk, d.via.bin.size);
if(ret < 0) { return ret; }
return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size);
}
case MSGPACK_OBJECT_EXT:
{
int ret = msgpack_pack_ext(pk, d.via.ext.size, d.via.ext.type);
if(ret < 0) { return ret; }
return msgpack_pack_ext_body(pk, d.via.ext.ptr, d.via.ext.size);
}
case MSGPACK_OBJECT_ARRAY:
{
int ret = msgpack_pack_array(pk, d.via.array.size);
if(ret < 0) {
return ret;
}
else {
msgpack_object* o = d.via.array.ptr;
msgpack_object* const oend = d.via.array.ptr + d.via.array.size;
for(; o != oend; ++o) {
ret = msgpack_pack_object(pk, *o);
if(ret < 0) { return ret; }
}
return 0;
}
}
case MSGPACK_OBJECT_MAP:
{
int ret = msgpack_pack_map(pk, d.via.map.size);
if(ret < 0) {
return ret;
}
else {
msgpack_object_kv* kv = d.via.map.ptr;
msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size;
for(; kv != kvend; ++kv) {
ret = msgpack_pack_object(pk, kv->key);
if(ret < 0) { return ret; }
ret = msgpack_pack_object(pk, kv->val);
if(ret < 0) { return ret; }
}
return 0;
}
}
default:
return -1;
}
}
/* Receive a tokenized JSON message and convert it to MsgPack */
static char *tokens_to_msgpack(char *js,
jsmntok_t *tokens, int arr_size, int *out_size)
{
int i;
int flen;
char *p;
char *buf;
jsmntok_t *t;
msgpack_packer pck;
msgpack_sbuffer sbuf;
/* initialize buffers */
msgpack_sbuffer_init(&sbuf);
msgpack_packer_init(&pck, &sbuf, msgpack_sbuffer_write);
for (i = 0; i < arr_size ; i++) {
t = &tokens[i];
if (t->start == -1 || t->end == -1 || (t->start == 0 && t->end == 0)) {
break;
}
flen = (t->end - t->start);
switch (t->type) {
case JSMN_OBJECT:
msgpack_pack_map(&pck, t->size);
break;
case JSMN_ARRAY:
msgpack_pack_array(&pck, t->size);
break;
case JSMN_STRING:
msgpack_pack_bin(&pck, flen);
msgpack_pack_bin_body(&pck, js + t->start, flen);
break;
case JSMN_PRIMITIVE:
p = js + t->start;
if (*p == 'f') {
msgpack_pack_false(&pck);
}
else if (*p == 't') {
msgpack_pack_true(&pck);
}
else if (*p == 'n') {
msgpack_pack_nil(&pck);
}
else {
if (is_float(p, flen)) {
msgpack_pack_double(&pck, atof(p));
}
else {
msgpack_pack_int64(&pck, atol(p));
}
}
break;
case JSMN_UNDEFINED:
msgpack_sbuffer_destroy(&sbuf);
return NULL;
}
}
/* dump data back to a new buffer */
*out_size = sbuf.size;
buf = malloc(sbuf.size);
memcpy(buf, sbuf.data, sbuf.size);
msgpack_sbuffer_destroy(&sbuf);
return buf;
}
