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 mrb_value
Packer_write_to(mrb_state *mrb, mrb_value self)
{
PACKER(mrb, self, pk);
size_t sz = msgpack_buffer_flush_to_io(mrb, PACKER_BUFFER_(pk), io, s_write, TRUE);
return mrb_fixnum_value(sz);
}
static mrb_value Packer_size(mrb_state *mrb, mrb_value self)
{
PACKER(mrb, self, pk);
size_t size = msgpack_buffer_all_readable_size(PACKER_BUFFER_(pk));
//return SIZET2NUM(size);
return mrb_fixnum_value(size);
}
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;
}
static VALUE Packer_empty_p(VALUE self)
{
PACKER(self, pk);
if(msgpack_buffer_top_readable_size(PACKER_BUFFER_(pk)) == 0) {
return Qtrue;
} else {
return Qfalse;
}
}
static mrb_value Packer_empty_p(mrb_state *mrb, mrb_value self)
{
PACKER(mrb, self, pk);
if (msgpack_buffer_top_readable_size(PACKER_BUFFER_(pk)) == 0) {
return mrb_true_value();
} else {
return mrb_false_value();
}
}
static VALUE Packer_alloc(VALUE klass)
{
msgpack_packer_t* pk = ALLOC_N(msgpack_packer_t, 1);
msgpack_packer_init(pk);
VALUE self = Data_Wrap_Struct(klass, msgpack_packer_mark, Packer_free, pk);
msgpack_packer_set_to_msgpack_method(pk, s_to_msgpack, self);
pk->buffer_ref = MessagePack_Buffer_wrap(PACKER_BUFFER_(pk), self);
return self;
}
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 mrb_value Packer_alloc(mrb_state* mrb, struct RClass *klass)
{
mrb_value klass_value;
mrb_value data;
msgpack_packer_t* pk = (msgpack_packer_t *)mrb_malloc(mrb, sizeof(msgpack_packer_t));
msgpack_packer_init(mrb, pk);
data = mrb_obj_value(Data_Wrap_Struct(mrb, klass, &mrb_data_type_msgpack_packer_t, (void *)pk));
klass_value = mrb_obj_value(klass);
mrb_iv_set(mrb, klass_value, sym_pack_data, data);
pk->buffer_ref = MessagePack_Buffer_wrap(mrb, PACKER_BUFFER_(pk), data);
return klass_value;
}
VALUE MessagePack_Packer_initialize(int argc, VALUE* argv, VALUE self)
{
VALUE io = Qnil;
VALUE options = Qnil;
if(argc == 0 || (argc == 1 && argv[0] == Qnil)) {
/* Qnil */
} else if(argc == 1) {
VALUE v = argv[0];
if(rb_type(v) == T_HASH) {
options = v;
} else {
io = v;
}
} else if(argc == 2) {
io = argv[0];
options = argv[1];
if(rb_type(options) != T_HASH) {
rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(options));
}
} else {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..2)", argc);
}
PACKER(self, pk);
MessagePack_Buffer_set_options(PACKER_BUFFER_(pk), io, options);
if(options != Qnil) {
VALUE v;
v = rb_hash_aref(options, ID2SYM(rb_intern("compatibility_mode")));
msgpack_packer_set_compat(pk, RTEST(v));
}
return self;
}
static mrb_value
Packer_initialize(mrb_state* mrb, mrb_value self)
{
mrb_value io = mrb_nil_value();
mrb_value options = mrb_nil_value();
mrb_value *argv;
int argc; /* Number of arguments */
mrb_get_args(mrb, "*", &argv, &argc);
if (argc == 0 || (argc == 1 && mrb_obj_eq(mrb, argv[0], mrb_nil_value()))) {
/* mrb_nil_value() */
} else if (argc == 1) {
puts("hash");
mrb_value v = argv[0];
if (mrb_type(v) == MRB_TT_HASH) {
options = v;
} else {
io = v;
}
} else if (argc == 2) {
io = argv[0];
options = argv[1];
if (mrb_type(options) != MRB_TT_HASH) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "expected Hash but found %S.", mrb_str_new_cstr(mrb, "classname"));
}
} else {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 0..1)", mrb_fixnum_value(argc));
}
self = Packer_alloc(mrb, mrb_class_ptr(self));
PACKER(mrb, self, pk);
if (!mrb_nil_p(io) || !mrb_nil_p(options)) {
MessagePack_Buffer_initialize(mrb, PACKER_BUFFER_(pk), io, options);
}
// TODO options
return self;
}
static VALUE Packer_initialize(int argc, VALUE* argv, VALUE self)
{
VALUE io = Qnil;
VALUE options = Qnil;
if(argc == 0 || (argc == 1 && argv[0] == Qnil)) {
/* Qnil */
} else if(argc == 1) {
VALUE v = argv[0];
if(rb_type(v) == T_HASH) {
options = v;
} else {
io = v;
}
} else if(argc == 2) {
io = argv[0];
options = argv[1];
if(rb_type(options) != T_HASH) {
rb_raise(rb_eArgError, "expected Hash but found %s.", rb_obj_classname(io));
}
} else {
rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc);
}
PACKER(self, pk);
if(io != Qnil || options != Qnil) {
MessagePack_Buffer_initialize(PACKER_BUFFER_(pk), io, options);
}
// TODO options
return self;
}
static mrb_value Packer_clear(mrb_state *mrb, mrb_value self)
{
PACKER(mrb, self, pk);
msgpack_buffer_clear(mrb, PACKER_BUFFER_(pk));
return mrb_nil_value();
}
void msgpack_packer_reset(msgpack_packer_t* pk)
{
msgpack_buffer_clear(PACKER_BUFFER_(pk));
pk->buffer_ref = Qnil;
}
static VALUE Packer_write_to(VALUE self, VALUE io)
{
PACKER(self, pk);
size_t sz = msgpack_buffer_flush_to_io(PACKER_BUFFER_(pk), io, s_write, true);
return ULONG2NUM(sz);
}
void msgpack_packer_destroy(msgpack_packer_t* pk)
{
msgpack_buffer_destroy(PACKER_BUFFER_(pk));
}
static mrb_value
Packer_to_a(mrb_state *mrb, mrb_value self)
{
PACKER(mrb, self, pk);
return msgpack_buffer_all_as_string_array(mrb, PACKER_BUFFER_(pk));
}
static VALUE Packer_to_a(VALUE self)
{
PACKER(self, pk);
return msgpack_buffer_all_as_string_array(PACKER_BUFFER_(pk));
}
static VALUE Packer_size(VALUE self)
{
PACKER(self, pk);
size_t size = msgpack_buffer_all_readable_size(PACKER_BUFFER_(pk));
return SIZET2NUM(size);
}
static VALUE Packer_clear(VALUE self)
{
PACKER(self, pk);
msgpack_buffer_clear(PACKER_BUFFER_(pk));
return Qnil;
}
static VALUE Packer_flush(VALUE self)
{
PACKER(self, pk);
msgpack_buffer_flush(PACKER_BUFFER_(pk));
return self;
}
static mrb_value Packer_flush(mrb_state* mrb, mrb_value self)
{
PACKER(mrb, self, pk);
msgpack_buffer_flush(mrb, PACKER_BUFFER_(pk));
return self;
}
void msgpack_packer_init(msgpack_packer_t* pk)
{
memset(pk, 0, sizeof(msgpack_packer_t));
msgpack_buffer_init(PACKER_BUFFER_(pk));
}
