VALUE msgpack_buffer_all_as_string_array(msgpack_buffer_t* b)
{
if(b->head == &b->tail) {
VALUE s = msgpack_buffer_all_as_string(b);
VALUE ary = rb_ary_new3(1, s);
return ary;
}
/* TODO optimize ary construction */
VALUE ary = rb_ary_new();
VALUE s = _msgpack_buffer_head_chunk_as_string(b);
rb_ary_push(ary, s);
msgpack_buffer_chunk_t* c = b->head->next;
while(true) {
s = _msgpack_buffer_chunk_as_string(c);
rb_ary_push(ary, s);
if(c == &b->tail) {
return ary;
}
c = c->next;
}
return ary;
}
static VALUE Buffer_read(int argc, VALUE* argv, VALUE self)
{
VALUE out = Qnil;
unsigned long n = -1;
bool all = false;
switch(argc) {
case 2:
out = argv[1];
/* pass through */
case 1:
n = FIX2ULONG(argv[0]);
break;
case 0:
all = true;
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
}
BUFFER(self, b);
if(out != Qnil) {
CHECK_STRING_TYPE(out);
}
if(all) {
return read_all(b, out);
}
if(n == 0) {
/* do nothing */
MAKE_EMPTY_STRING(out);
return out;
}
#ifndef DISABLE_BUFFER_READ_TO_S_OPTIMIZE
if(!msgpack_buffer_has_io(b) && out == Qnil &&
msgpack_buffer_all_readable_size(b) <= n) {
/* same as to_s && clear; optimize */
VALUE str = msgpack_buffer_all_as_string(b);
msgpack_buffer_clear(b);
if(RSTRING_LEN(str) == 0) {
return Qnil;
} else {
return str;
}
}
#endif
MAKE_EMPTY_STRING(out);
read_until_eof(b, out, n);
if(RSTRING_LEN(out) == 0) {
return Qnil;
} else {
return out;
}
}
VALUE MessagePack_pack(int argc, VALUE* argv)
{
VALUE v;
if (argc < 0 || argc > 3) {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", argc);
}
v = argv[0];
VALUE self = MessagePack_Factory_packer(argc - 1, argv + 1, cMessagePack_DefaultFactory);
PACKER(self, pk);
msgpack_packer_write_value(pk, v);
VALUE retval;
if(msgpack_buffer_has_io(PACKER_BUFFER_(pk))) {
msgpack_buffer_flush(PACKER_BUFFER_(pk));
retval = Qnil;
} else {
retval = msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
}
msgpack_buffer_clear(PACKER_BUFFER_(pk)); /* to free rmem before GC */
#ifdef RB_GC_GUARD
/* This prevents compilers from optimizing out the `self` variable
* from stack. Otherwise GC free()s it. */
RB_GC_GUARD(self);
#endif
return retval;
}
mrb_value
MessagePack_pack_v(mrb_state *mrb, int argc, mrb_value* argv)
{
//mrb_value *argv;
//int argc; /* Number of arguments */
/* TODO options */
mrb_value v;
mrb_value io = mrb_nil_value();
//mrb_get_args(mrb, "*", &argv, &argc);
switch (argc) {
case 2:
io = argv[1];
/* Pass-through */
case 1:
v = argv[0];
break;
default:
mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 1..2)", mrb_fixnum_value(argc));
}
mrb_value self = Packer_alloc(mrb, cMessagePack_Packer);
PACKER(mrb, self, pk);
//msgpack_packer_reset(s_packer);
//msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
if (!mrb_nil_p(io)) {
MessagePack_Buffer_initialize(mrb, PACKER_BUFFER_(pk), io, mrb_nil_value());
}
msgpack_packer_write_value(mrb, pk, v);
mrb_value retval;
if (!mrb_nil_p(io)) {
msgpack_buffer_flush(mrb, PACKER_BUFFER_(pk));
retval = mrb_nil_value();
} else {
retval = msgpack_buffer_all_as_string(mrb, PACKER_BUFFER_(pk));
}
//msgpack_buffer_clear(mrb, PACKER_BUFFER_(pk)); /* to free rmem before GC */
#ifdef RB_GC_GUARD
/* This prevents compilers from optimizing out the `self` variable
* from stack. Otherwise GC free()s it. */
RB_GC_GUARD(self);
#endif
return retval;
}
static inline VALUE read_all(msgpack_buffer_t* b, VALUE out)
{
#ifndef DISABLE_BUFFER_READ_TO_S_OPTIMIZE
if(out == Qnil && !msgpack_buffer_has_io(b)) {
/* same as to_s && clear; optimize */
VALUE str = msgpack_buffer_all_as_string(b);
msgpack_buffer_clear(b);
return str;
}
#endif
MAKE_EMPTY_STRING(out);
read_until_eof(b, out, 0);
return out;
}
VALUE MessagePack_pack(int argc, VALUE* argv)
{
// TODO options
VALUE v;
VALUE io = Qnil;
switch(argc) {
case 2:
io = argv[1];
/* pass-through */
case 1:
v = argv[0];
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
}
VALUE self = Packer_alloc(cMessagePack_Packer);
PACKER(self, pk);
//msgpack_packer_reset(s_packer);
//msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
if(io != Qnil) {
MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, Qnil);
}
msgpack_packer_write_value(pk, v);
VALUE retval;
if(io != Qnil) {
msgpack_buffer_flush(PACKER_BUFFER_(pk));
retval = Qnil;
} else {
retval = msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
}
msgpack_buffer_clear(PACKER_BUFFER_(pk)); /* to free rmem before GC */
#ifdef RB_GC_GUARD
/* This prevents compilers from optimizing out the `self` variable
* from stack. Otherwise GC free()s it. */
RB_GC_GUARD(self);
#endif
return retval;
}
VALUE MessagePack_pack(int argc, VALUE* argv)
{
// TODO options
VALUE v;
VALUE io = Qnil;
switch(argc) {
case 2:
io = argv[1];
/* pass-through */
case 1:
v = argv[0];
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..2)", argc);
}
VALUE self = Packer_alloc(cMessagePack_Packer);
PACKER(self, pk);
//msgpack_packer_reset(s_packer);
//msgpack_buffer_reset_io(PACKER_BUFFER_(s_packer));
if(io != Qnil) {
MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, Qnil);
}
msgpack_packer_write_value(pk, v);
VALUE retval;
if(io != Qnil) {
msgpack_buffer_flush(PACKER_BUFFER_(pk));
retval = Qnil;
} else {
retval = msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
}
msgpack_buffer_clear(PACKER_BUFFER_(pk)); /* to free rmem before GC */
return retval;
}
static VALUE Packer_to_str(VALUE self)
{
PACKER(self, pk);
return msgpack_buffer_all_as_string(PACKER_BUFFER_(pk));
}
static mrb_value
Packer_to_str(mrb_state *mrb, mrb_value self)
{
PACKER(mrb, self, pk);
return msgpack_buffer_all_as_string(mrb, PACKER_BUFFER_(pk));
}
static VALUE Buffer_to_str(VALUE self)
{
BUFFER(self, b);
return msgpack_buffer_all_as_string(b);
}
