/* * call-seq: * MessageClass.decode_json(data) => message * * Decodes the given data (as a string containing bytes in protocol buffers wire * format) under the interpretration given by this message class's definition * and returns a message object with the corresponding field values. */ VALUE Message_decode_json(VALUE klass, VALUE data) { VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned); Descriptor* desc = ruby_to_Descriptor(descriptor); VALUE msgklass = Descriptor_msgclass(descriptor); VALUE msg_rb; MessageHeader* msg; if (TYPE(data) != T_STRING) { rb_raise(rb_eArgError, "Expected string for JSON data."); } // TODO(cfallin): Check and respect string encoding. If not UTF-8, we need to // convert, because string handlers pass data directly to message string // fields. msg_rb = rb_class_new_instance(0, NULL, msgklass); TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg); { stackenv se; upb_sink sink; upb_json_parser* parser; stackenv_init(&se, "Error occurred during parsing: %s"); upb_sink_reset(&sink, get_fill_handlers(desc), msg); parser = upb_json_parser_create(&se.env, &sink); upb_bufsrc_putbuf(RSTRING_PTR(data), RSTRING_LEN(data), upb_json_parser_input(parser)); stackenv_uninit(&se); } return msg_rb; }
/* * call-seq: * MessageClass.decode(data) => message * * Decodes the given data (as a string containing bytes in protocol buffers wire * format) under the interpretration given by this message class's definition * and returns a message object with the corresponding field values. */ VALUE Message_decode(VALUE klass, VALUE data) { VALUE descriptor = rb_ivar_get(klass, descriptor_instancevar_interned); Descriptor* desc = ruby_to_Descriptor(descriptor); VALUE msgklass = Descriptor_msgclass(descriptor); VALUE msg_rb; MessageHeader* msg; if (TYPE(data) != T_STRING) { rb_raise(rb_eArgError, "Expected string for binary protobuf data."); } msg_rb = rb_class_new_instance(0, NULL, msgklass); TypedData_Get_Struct(msg_rb, MessageHeader, &Message_type, msg); { const upb_pbdecodermethod* method = msgdef_decodermethod(desc); const upb_handlers* h = upb_pbdecodermethod_desthandlers(method); stackenv se; upb_sink sink; upb_pbdecoder* decoder; stackenv_init(&se, "Error occurred during parsing: %s"); upb_sink_reset(&sink, h, msg); decoder = upb_pbdecoder_create(&se.env, method, &sink); upb_bufsrc_putbuf(RSTRING_PTR(data), RSTRING_LEN(data), upb_pbdecoder_input(decoder)); stackenv_uninit(&se); } return msg_rb; }
void upb_descreader_init(upb_descreader *r, const upb_handlers *handlers, upb_status *status) { UPB_UNUSED(status); upb_deflist_init(&r->defs); upb_sink_reset(upb_descreader_input(r), handlers, r); r->stack_len = 0; r->name = NULL; r->default_string = NULL; }
upb_textprinter *upb_textprinter_create(upb_env *env, const upb_handlers *h, upb_bytessink *output) { upb_textprinter *p = upb_env_malloc(env, sizeof(upb_textprinter)); if (!p) return NULL; p->output_ = output; upb_sink_reset(&p->input_, h, p); textprinter_reset(p, false); return p; }
upb_pb_encoder *upb_pb_encoder_create(upb_env *env, const upb_handlers *h, upb_bytessink *output) { const size_t initial_bufsize = 256; const size_t initial_segbufsize = 16; // TODO(haberman): make this configurable. const size_t stack_size = 64; #ifndef NDEBUG const size_t size_before = upb_env_bytesallocated(env); #endif upb_pb_encoder *e = upb_env_malloc(env, sizeof(upb_pb_encoder)); if (!e) return NULL; e->buf = upb_env_malloc(env, initial_bufsize); e->segbuf = upb_env_malloc(env, initial_segbufsize * sizeof(*e->segbuf)); e->stack = upb_env_malloc(env, stack_size * sizeof(*e->stack)); if (!e->buf || !e->segbuf || !e->stack) { return NULL; } e->limit = e->buf + initial_bufsize; e->seglimit = e->segbuf + initial_segbufsize; e->stacklimit = e->stack + stack_size; upb_pb_encoder_reset(e); upb_sink_reset(&e->input_, h, e); e->env = env; e->output_ = output; e->subc = output->closure; e->ptr = e->buf; // If this fails, increase the value in encoder.h. assert(upb_env_bytesallocated(env) - size_before <= UPB_PB_ENCODER_SIZE); return e; }