Class: Hikari::Buffer

Inherits:

Object

• Object
• Hikari::Buffer

Defined in:

ext/hikari_buffer/buffer.c

Instance Method Summary

• #capacity ⇒ Object
• #clear ⇒ Object
• #cursor ⇒ Object
• #initialize(*args) ⇒ Object constructor
• #peek_bool ⇒ Object
• #read_bool ⇒ Object
• #read_bytes(len) ⇒ Object
• #read_string ⇒ Object
• #remaining ⇒ Object
• #rewind ⇒ Object
• #seek(pos) ⇒ Object
• #size ⇒ Object
• #skip(len) ⇒ Object
• #tell ⇒ Object
• #write_bool(val) ⇒ Object
• #write_bytes ⇒ Object
• #write_string(str) ⇒ Object

Constructor Details

#initialize(*args) ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 98

static VALUE
buffer_initialize(int argc, VALUE *argv, VALUE self)
{

    Buffer *buffer = get_buffer_struct(self);
    size_t capacity = BUFFER_INITIAL_CAPACITY;
    if (argc > 1)
        rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 0 or 1)", argc);
    if (argc == 1)
        capacity = NUM2SIZET(argv[0]);
    if (capacity == 0)
        rb_raise(rb_eArgError, "capacity must be greater than 0");
    buffer->capacity = capacity;
    buffer->size = 0;
    buffer->cursor = 0;
    buffer->data = ALLOC_N(uint8_t, capacity);
    return Qnil;
}

Instance Method Details

#capacity ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 134

static VALUE
buffer_capacity(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);

    return SIZET2NUM(buffer->capacity);
}

#clear ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 158

static VALUE
buffer_clear(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);

    buffer->size = 0;
    buffer->cursor = 0;

    return self;
}

#cursor ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 150

static VALUE
buffer_cursor(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);

    return SIZET2NUM(buffer->cursor);
}

#peek_bool ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 363

static VALUE
buffer_peek_bool(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);
    uint8_t value;
    buffer_peek(
        buffer,
        &value,
        sizeof(value));
    return value ? Qtrue : Qfalse;
}

#read_bool ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 352

static VALUE
buffer_read_bool(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);
    uint8_t value;
    buffer_read(
        buffer,
        &value,
        sizeof(value));
    return value ? Qtrue : Qfalse;
}

#read_bytes(len) ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 270

static VALUE
buffer_read_bytes(VALUE self, VALUE len)
{
    Buffer *buffer = get_buffer_struct(self);
    size_t length = NUM2SIZET(len);

    VALUE str = rb_str_new(NULL, length);
    buffer_read(
        buffer,
        RSTRING_PTR(str),
        length);
    return str;
}

#read_string ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 314

static VALUE
buffer_read_string(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);

    uint32_t length = 0;

    buffer_read(
        buffer,
        &length,
        sizeof(length));

    VALUE str = rb_str_new(NULL, length);
    rb_enc_associate(
        str,
        rb_utf8_encoding());

    buffer_read(
        buffer,
        RSTRING_PTR(str),
        length);

    return str;
}

#remaining ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 184

static VALUE
buffer_remaining(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);

    return SIZET2NUM(buffer->size - buffer->cursor);
}

#rewind ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 168

static VALUE
buffer_rewind(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);

    buffer->cursor = 0;

    return self;
}

#seek(pos) ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 191

static VALUE
buffer_seek(VALUE self, VALUE pos)
{
    Buffer *buffer = get_buffer_struct(self);
    size_t position = NUM2SIZET(pos);
    if (position > buffer->size)
    {
        rb_raise(
            rb_eRangeError,
            "seek position %zu exceeds buffer size %zu",
            position,
            buffer->size);
    }
    buffer->cursor = position;
    return self;
}

#size ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 142

static VALUE
buffer_size(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);

    return SIZET2NUM(buffer->size);
}

#skip(len) ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 207

static VALUE
buffer_skip(VALUE self, VALUE len)
{
    Buffer *buffer = get_buffer_struct(self);

    size_t length = NUM2SIZET(len);

    buffer_check_read_bounds(buffer, length);

    buffer->cursor += length;

    return self;
}

#tell ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 177

static VALUE
buffer_tell(VALUE self)
{
    Buffer *buffer = get_buffer_struct(self);

    return SIZET2NUM(buffer->cursor);
}

#write_bool(val) ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 339

static VALUE
buffer_write_bool(VALUE self, VALUE val)
{
    if (val != Qtrue && val != Qfalse)
        rb_raise(rb_eTypeError, "expected a boolean value");
    Buffer *buffer = get_buffer_struct(self);
    uint8_t value = (val == Qtrue);
    buffer_write(
        buffer,
        &value,
        sizeof(value));
    return self;
}

#write_bytes ⇒ Object

#write_string(str) ⇒ Object

# File 'ext/hikari_buffer/buffer.c', line 284

static VALUE
buffer_write_string(VALUE self, VALUE str)
{
    Buffer *buffer = get_buffer_struct(self);

    Check_Type(str, T_STRING);

    size_t len = RSTRING_LEN(str);

    if (len > UINT32_MAX)
    {
        rb_raise(
            rb_eRangeError,
            "string is too large");
    }

    uint32_t length = (uint32_t)len;

    buffer_write(
        buffer,
        &length,
        sizeof(length));

    buffer_write(
        buffer,
        RSTRING_PTR(str),
        len);

    return self;
}