class BinData::Wrapper

arr.snapshot #=> [3, 3, 3, 3 ,3]
arr = Uint8Array.new(:initial_length => 5, :initial_element_value => 3)
arr.snapshot #=> [0, 0]
arr = Uint8Array.new
end
:initial_length => 2
array :type => [:uint8, {:initial_value => :initial_element_value}],
default_parameter :initial_element_value => 0
class Uint8Array < BinData::Wrapper
require ‘bindata’
provide default parameters.
A Wrapper allows the creation of new BinData types that

def _assign(val)

def _assign(val)
  wrapped.assign(val)
end

def _do_num_bytes(deprecated)

def _do_num_bytes(deprecated)
  wrapped.do_num_bytes(deprecated)
end

def _do_read(io)

def _do_read(io)
  wrapped.do_read(io)
end

def _do_write(io)

def _do_write(io)
  wrapped.do_write(io)
end

def _done_read

def _done_read
  wrapped.done_read
end

def _snapshot

def _snapshot
  wrapped.snapshot
end

def clear

def clear
  wrapped.clear
end

def clear?

def clear?
  wrapped.clear?
end

def debug_name_of(child)

def debug_name_of(child)
  debug_name
end

def endian(endian = nil)

def endian(endian = nil)
  @endian ||= nil
  if [:little, :big].include?(endian)
    @endian = endian
  elsif endian != nil
    raise ArgumentError, "unknown value for endian '#{endian}'", caller(1)
  end
  @endian
end

def ensure_type_exists(type)

def ensure_type_exists(type)
  unless RegisteredClasses.is_registered?(type, endian)
    raise TypeError, "unknown type '#{type}' for #{self}", caller(3)
  end
end

def inherited(subclass) #:nodoc:

:nodoc:

def inherited(subclass) #:nodoc:
  # Register the names of all subclasses of this class.
  register(subclass.name, subclass)
end

def initialize(params = {}, parent = nil)

def initialize(params = {}, parent = nil)
  super(params, parent)
  prototype = get_parameter(:wrapped)
  @wrapped = prototype.instantiate(self)
end

def method_missing(symbol, *args)

def method_missing(symbol, *args)
  type = symbol
  params = args.length == 0 ? {} : args[0]
  set_wrapped(type, params)
end

def method_missing(symbol, *args, &block)

def method_missing(symbol, *args, &block)
  wrapped.__send__(symbol, *args, &block)
end

def offset_of(child)

def offset_of(child)
  offset
end

def respond_to?(symbol, include_private = false)

def respond_to?(symbol, include_private = false)
  super || wrapped.respond_to?(symbol, include_private)
end

def sanitize_parameters!(params, sanitizer)

def sanitize_parameters!(params, sanitizer)
  raise "Nothing to wrap" unless defined? @wrapped
  wrapped_type, wrapped_params = @wrapped
  wrapped_params = wrapped_params.dup
  params.move_unknown_parameters_to(wrapped_params)
  params[:wrapped] = sanitizer.create_sanitized_object_prototype(wrapped_type, wrapped_params, endian)
end

def set_wrapped(type, params)

def set_wrapped(type, params)
  ensure_type_exists(type)
  if defined? @wrapped
    raise SyntaxError, "#{self} can only wrap one type", caller(2)
  end
  @wrapped = [type, params]
end

def wrapped

def wrapped
  @wrapped
end

Modules

Classes