class JSON::Ext::Generator::State - RDoc Documentation

# class JSON::Ext::Generator::State

### Public Class Methods

from_state(opts) click to toggle source

Creates a `State` object from opts, which ought to be `Hash` to create a new `State` instance configured by opts, something else to create an unconfigured instance. If opts is a `State` object, it is just returned.

    static VALUE cState_from_state_s(VALUE self, VALUE opts)
    {
        if (rb_obj_is_kind_of(opts, self)) {
            return opts;
        } else if (rb_obj_is_kind_of(opts, rb_cHash)) {
            return rb_funcall(self, i_new, 1, opts);
        } else {
            return rb_class_new_instance(0, NULL, cState);
        }
    }

new(opts = {}) click to toggle source

Instantiates a new `State` object, configured by opts.

opts can have the following keys:

- indent: a string used to indent levels (default: ”),

- space: a string that is put after, a : or , delimiter (default: ”),

- space_before: a string that is put before a : pair delimiter (default: ”),

- object_nl: a string that is put at the end of a `JSON` object (default: ”),

- array_nl: a string that is put at the end of a `JSON` array (default: ”),

- allow_nan: true if NaN, Infinity, and -Infinity should be generated, otherwise an exception is thrown, if these values are encountered. This options defaults to false.

- ascii_only: true if only ASCII characters should be generated. This option defaults to false.

- buffer_initial_length: sets the initial length of the generator’s internal buffer.

    static VALUE cState_initialize(int argc, VALUE *argv, VALUE self)
    {
        VALUE opts;
        GET_STATE(self);
        state->max_nesting = 100;
        state->buffer_initial_length = FBUFFER_INITIAL_LENGTH_DEFAULT;
        rb_scan_args(argc, argv, "01", &opts);
        if (!NIL_P(opts)) cState_configure(self, opts);
        return self;
    }

### Public Instance Methods

[](name) click to toggle source

Returns the value returned by method `name`.

    static VALUE cState_aref(VALUE self, VALUE name)
    {
        name = rb_funcall(name, i_to_s, 0);
        if (RTEST(rb_funcall(self, i_respond_to_p, 1, name))) {
            return rb_funcall(self, i_send, 1, name);
        } else {
            return rb_attr_get(self, rb_intern_str(rb_str_concat(rb_str_new2("@"), name)));
        }
    }

[]=(name, value) click to toggle source

Sets the attribute name to value.

    static VALUE cState_aset(VALUE self, VALUE name, VALUE value)
    {
        VALUE name_writer;

        name = rb_funcall(name, i_to_s, 0);
        name_writer = rb_str_cat2(rb_str_dup(name), "=");
        if (RTEST(rb_funcall(self, i_respond_to_p, 1, name_writer))) {
            return rb_funcall(self, i_send, 2, name_writer, value);
        } else {
            rb_ivar_set(self, rb_intern_str(rb_str_concat(rb_str_new2("@"), name)), value);
        }
        return Qnil;
    }

allow_nan? click to toggle source

Returns true, if NaN, Infinity, and -Infinity should be generated, otherwise returns false.

    static VALUE cState_allow_nan_p(VALUE self)
    {
        GET_STATE(self);
        return state->allow_nan ? Qtrue : Qfalse;
    }

array_nl() click to toggle source

This string is put at the end of a line that holds a `JSON` array.

    static VALUE cState_array_nl(VALUE self)
    {
        GET_STATE(self);
        return state->array_nl ? rb_str_new(state->array_nl, state->array_nl_len) : rb_str_new2("");
    }

array_nl=(array_nl) click to toggle source

This string is put at the end of a line that holds a `JSON` array.

    static VALUE cState_array_nl_set(VALUE self, VALUE array_nl)
    {
        unsigned long len;
        GET_STATE(self);
        Check_Type(array_nl, T_STRING);
        len = RSTRING_LEN(array_nl);
        if (len == 0) {
            if (state->array_nl) {
                ruby_xfree(state->array_nl);
                state->array_nl = NULL;
            }
        } else {
            if (state->array_nl) ruby_xfree(state->array_nl);
            state->array_nl = fstrndup(RSTRING_PTR(array_nl), len);
            state->array_nl_len = len;
        }
        return Qnil;
    }

ascii_only? click to toggle source

Returns true, if only ASCII characters should be generated. Otherwise returns false.

    static VALUE cState_ascii_only_p(VALUE self)
    {
        GET_STATE(self);
        return state->ascii_only ? Qtrue : Qfalse;
    }

buffer_initial_length click to toggle source

This integer returns the current initial length of the buffer.

    static VALUE cState_buffer_initial_length(VALUE self)
    {
        GET_STATE(self);
        return LONG2FIX(state->buffer_initial_length);
    }

buffer_initial_length=(length) click to toggle source

This sets the initial length of the buffer to `length`, if `length` > 0, otherwise its value isn’t changed.

    static VALUE cState_buffer_initial_length_set(VALUE self, VALUE buffer_initial_length)
    {
        long initial_length;
        GET_STATE(self);
        Check_Type(buffer_initial_length, T_FIXNUM);
        initial_length = FIX2LONG(buffer_initial_length);
        if (initial_length > 0) {
            state->buffer_initial_length = initial_length;
        }
        return Qnil;
    }

check_circular? click to toggle source

Returns true, if circular data structures should be checked, otherwise returns false.

    static VALUE cState_check_circular_p(VALUE self)
    {
        GET_STATE(self);
        return state->max_nesting ? Qtrue : Qfalse;
    }

configure(opts) click to toggle source

Configure this `State` instance with the `Hash` opts, and return itself.

    static VALUE cState_configure(VALUE self, VALUE opts)
    {
        VALUE tmp;
        GET_STATE(self);
        tmp = rb_check_convert_type(opts, T_HASH, "Hash", "to_hash");
        if (NIL_P(tmp)) tmp = rb_convert_type(opts, T_HASH, "Hash", "to_h");
        opts = tmp;
        tmp = rb_hash_aref(opts, ID2SYM(i_indent));
        if (RTEST(tmp)) {
            unsigned long len;
            Check_Type(tmp, T_STRING);
            len = RSTRING_LEN(tmp);
            state->indent = fstrndup(RSTRING_PTR(tmp), len + 1);
            state->indent_len = len;
        }
        tmp = rb_hash_aref(opts, ID2SYM(i_space));
        if (RTEST(tmp)) {
            unsigned long len;
            Check_Type(tmp, T_STRING);
            len = RSTRING_LEN(tmp);
            state->space = fstrndup(RSTRING_PTR(tmp), len + 1);
            state->space_len = len;
        }
        tmp = rb_hash_aref(opts, ID2SYM(i_space_before));
        if (RTEST(tmp)) {
            unsigned long len;
            Check_Type(tmp, T_STRING);
            len = RSTRING_LEN(tmp);
            state->space_before = fstrndup(RSTRING_PTR(tmp), len + 1);
            state->space_before_len = len;
        }
        tmp = rb_hash_aref(opts, ID2SYM(i_array_nl));
        if (RTEST(tmp)) {
            unsigned long len;
            Check_Type(tmp, T_STRING);
            len = RSTRING_LEN(tmp);
            state->array_nl = fstrndup(RSTRING_PTR(tmp), len + 1);
            state->array_nl_len = len;
        }
        tmp = rb_hash_aref(opts, ID2SYM(i_object_nl));
        if (RTEST(tmp)) {
            unsigned long len;
            Check_Type(tmp, T_STRING);
            len = RSTRING_LEN(tmp);
            state->object_nl = fstrndup(RSTRING_PTR(tmp), len + 1);
            state->object_nl_len = len;
        }
        tmp = ID2SYM(i_max_nesting);
        state->max_nesting = 100;
        if (option_given_p(opts, tmp)) {
            VALUE max_nesting = rb_hash_aref(opts, tmp);
            if (RTEST(max_nesting)) {
                Check_Type(max_nesting, T_FIXNUM);
                state->max_nesting = FIX2LONG(max_nesting);
            } else {
                state->max_nesting = 0;
            }
        }
        tmp = ID2SYM(i_depth);
        state->depth = 0;
        if (option_given_p(opts, tmp)) {
            VALUE depth = rb_hash_aref(opts, tmp);
            if (RTEST(depth)) {
                Check_Type(depth, T_FIXNUM);
                state->depth = FIX2LONG(depth);
            } else {
                state->depth = 0;
            }
        }
        tmp = ID2SYM(i_buffer_initial_length);
        if (option_given_p(opts, tmp)) {
            VALUE buffer_initial_length = rb_hash_aref(opts, tmp);
            if (RTEST(buffer_initial_length)) {
                long initial_length;
                Check_Type(buffer_initial_length, T_FIXNUM);
                initial_length = FIX2LONG(buffer_initial_length);
                if (initial_length > 0) state->buffer_initial_length = initial_length;
            }
        }
        tmp = rb_hash_aref(opts, ID2SYM(i_allow_nan));
        state->allow_nan = RTEST(tmp);
        tmp = rb_hash_aref(opts, ID2SYM(i_ascii_only));
        state->ascii_only = RTEST(tmp);
        tmp = rb_hash_aref(opts, ID2SYM(i_escape_slash));
        state->escape_slash = RTEST(tmp);
        return self;
    }

Also aliased as: merge
depth click to toggle source

This integer returns the current depth of data structure nesting.

    static VALUE cState_depth(VALUE self)
    {
        GET_STATE(self);
        return LONG2FIX(state->depth);
    }

depth=(depth) click to toggle source

This sets the maximum level of data structure nesting in the generated `JSON` to the integer depth, `max_nesting` = 0 if no maximum should be checked.

    static VALUE cState_depth_set(VALUE self, VALUE depth)
    {
        GET_STATE(self);
        Check_Type(depth, T_FIXNUM);
        state->depth = FIX2LONG(depth);
        return Qnil;
    }

escape_slash click to toggle source

If this boolean is true, the forward slashes will be escaped in the json output.

    static VALUE cState_escape_slash(VALUE self)
    {
        GET_STATE(self);
        return state->escape_slash ? Qtrue : Qfalse;
    }

Also aliased as: escape_slash?
escape_slash=(depth) click to toggle source

This sets whether or not the forward slashes will be escaped in the json output.

    static VALUE cState_escape_slash_set(VALUE self, VALUE enable)
    {
        GET_STATE(self);
        state->escape_slash = RTEST(enable);
        return Qnil;
    }

escape_slash?()

If this boolean is true, the forward slashes will be escaped in the json output.

Alias for: escape_slash
generate(obj) click to toggle source

Generates a valid `JSON` document from object `obj` and returns the result. If no valid `JSON` document can be created this method raises a `GeneratorError` exception.

    static VALUE cState_generate(VALUE self, VALUE obj)
    {
        VALUE result = cState_partial_generate(self, obj);
        GET_STATE(self);
        (void)state;
        return result;
    }

indent() click to toggle source

Returns the string that is used to indent levels in the `JSON` text.

    static VALUE cState_indent(VALUE self)
    {
        GET_STATE(self);
        return state->indent ? rb_str_new(state->indent, state->indent_len) : rb_str_new2("");
    }

indent=(indent) click to toggle source

Sets the string that is used to indent levels in the `JSON` text.

    static VALUE cState_indent_set(VALUE self, VALUE indent)
    {
        unsigned long len;
        GET_STATE(self);
        Check_Type(indent, T_STRING);
        len = RSTRING_LEN(indent);
        if (len == 0) {
            if (state->indent) {
                ruby_xfree(state->indent);
                state->indent = NULL;
                state->indent_len = 0;
            }
        } else {
            if (state->indent) ruby_xfree(state->indent);
            state->indent = fstrndup(RSTRING_PTR(indent), len);
            state->indent_len = len;
        }
        return Qnil;
    }

initialize_copy(orig) click to toggle source

Initializes this object from orig if it can be duplicated/cloned and returns it.

    static VALUE cState_init_copy(VALUE obj, VALUE orig)
    {
        JSON_Generator_State *objState, *origState;

        if (obj == orig) return obj;
        GET_STATE_TO(obj, objState);
        GET_STATE_TO(orig, origState);
        if (!objState) rb_raise(rb_eArgError, "unallocated JSON::State");

        MEMCPY(objState, origState, JSON_Generator_State, 1);
        objState->indent = fstrndup(origState->indent, origState->indent_len);
        objState->space = fstrndup(origState->space, origState->space_len);
        objState->space_before = fstrndup(origState->space_before, origState->space_before_len);
        objState->object_nl = fstrndup(origState->object_nl, origState->object_nl_len);
        objState->array_nl = fstrndup(origState->array_nl, origState->array_nl_len);
        if (origState->array_delim) objState->array_delim = fbuffer_dup(origState->array_delim);
        if (origState->object_delim) objState->object_delim = fbuffer_dup(origState->object_delim);
        if (origState->object_delim2) objState->object_delim2 = fbuffer_dup(origState->object_delim2);
        return obj;
    }

max_nesting click to toggle source

This integer returns the maximum level of data structure nesting in the generated `JSON`, `max_nesting` = 0 if no maximum is checked.

    static VALUE cState_max_nesting(VALUE self)
    {
        GET_STATE(self);
        return LONG2FIX(state->max_nesting);
    }

max_nesting=(depth) click to toggle source

This sets the maximum level of data structure nesting in the generated `JSON` to the integer depth, `max_nesting` = 0 if no maximum should be checked.

    static VALUE cState_max_nesting_set(VALUE self, VALUE depth)
    {
        GET_STATE(self);
        Check_Type(depth, T_FIXNUM);
        return state->max_nesting = FIX2LONG(depth);
    }

merge(p1)

Configure this `State` instance with the `Hash` opts, and return itself.

Alias for: configure
object_nl() click to toggle source

This string is put at the end of a line that holds a `JSON` object (or `Hash`).

    static VALUE cState_object_nl(VALUE self)
    {
        GET_STATE(self);
        return state->object_nl ? rb_str_new(state->object_nl, state->object_nl_len) : rb_str_new2("");
    }

object_nl=(object_nl) click to toggle source

This string is put at the end of a line that holds a `JSON` object (or `Hash`).

    static VALUE cState_object_nl_set(VALUE self, VALUE object_nl)
    {
        unsigned long len;
        GET_STATE(self);
        Check_Type(object_nl, T_STRING);
        len = RSTRING_LEN(object_nl);
        if (len == 0) {
            if (state->object_nl) {
                ruby_xfree(state->object_nl);
                state->object_nl = NULL;
            }
        } else {
            if (state->object_nl) ruby_xfree(state->object_nl);
            state->object_nl = fstrndup(RSTRING_PTR(object_nl), len);
            state->object_nl_len = len;
        }
        return Qnil;
    }

space() click to toggle source

Returns the string that is used to insert a space between the tokens in a `JSON` string.

    static VALUE cState_space(VALUE self)
    {
        GET_STATE(self);
        return state->space ? rb_str_new(state->space, state->space_len) : rb_str_new2("");
    }

space=(space) click to toggle source

Sets space to the string that is used to insert a space between the tokens in a `JSON` string.

    static VALUE cState_space_set(VALUE self, VALUE space)
    {
        unsigned long len;
        GET_STATE(self);
        Check_Type(space, T_STRING);
        len = RSTRING_LEN(space);
        if (len == 0) {
            if (state->space) {
                ruby_xfree(state->space);
                state->space = NULL;
                state->space_len = 0;
            }
        } else {
            if (state->space) ruby_xfree(state->space);
            state->space = fstrndup(RSTRING_PTR(space), len);
            state->space_len = len;
        }
        return Qnil;
    }

space_before() click to toggle source

Returns the string that is used to insert a space before the ‘:’ in `JSON` objects.

    static VALUE cState_space_before(VALUE self)
    {
        GET_STATE(self);
        return state->space_before ? rb_str_new(state->space_before, state->space_before_len) : rb_str_new2("");
    }

space_before=(space_before) click to toggle source

Sets the string that is used to insert a space before the ‘:’ in `JSON` objects.

    static VALUE cState_space_before_set(VALUE self, VALUE space_before)
    {
        unsigned long len;
        GET_STATE(self);
        Check_Type(space_before, T_STRING);
        len = RSTRING_LEN(space_before);
        if (len == 0) {
            if (state->space_before) {
                ruby_xfree(state->space_before);
                state->space_before = NULL;
                state->space_before_len = 0;
            }
        } else {
            if (state->space_before) ruby_xfree(state->space_before);
            state->space_before = fstrndup(RSTRING_PTR(space_before), len);
            state->space_before_len = len;
        }
        return Qnil;
    }

to_h click to toggle source

Returns the configuration instance variables as a hash, that can be passed to the configure method.

    static VALUE cState_to_h(VALUE self)
    {
        VALUE result = rb_hash_new();
        GET_STATE(self);
        set_state_ivars(result, self);
        rb_hash_aset(result, ID2SYM(i_indent), rb_str_new(state->indent, state->indent_len));
        rb_hash_aset(result, ID2SYM(i_space), rb_str_new(state->space, state->space_len));
        rb_hash_aset(result, ID2SYM(i_space_before), rb_str_new(state->space_before, state->space_before_len));
        rb_hash_aset(result, ID2SYM(i_object_nl), rb_str_new(state->object_nl, state->object_nl_len));
        rb_hash_aset(result, ID2SYM(i_array_nl), rb_str_new(state->array_nl, state->array_nl_len));
        rb_hash_aset(result, ID2SYM(i_allow_nan), state->allow_nan ? Qtrue : Qfalse);
        rb_hash_aset(result, ID2SYM(i_ascii_only), state->ascii_only ? Qtrue : Qfalse);
        rb_hash_aset(result, ID2SYM(i_max_nesting), LONG2FIX(state->max_nesting));
        rb_hash_aset(result, ID2SYM(i_escape_slash), state->escape_slash ? Qtrue : Qfalse);
        rb_hash_aset(result, ID2SYM(i_depth), LONG2FIX(state->depth));
        rb_hash_aset(result, ID2SYM(i_buffer_initial_length), LONG2FIX(state->buffer_initial_length));
        return result;
    }

Also aliased as: to_hash
to_hash()

Returns the configuration instance variables as a hash, that can be passed to the configure method.

Alias for: to_h