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 

def _do_num_bytes
  wrapped.do_num_bytes
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 #:nodoc:

:nodoc: 
def clear #:nodoc:
  wrapped.clear
end

def clear? #:nodoc:

:nodoc: 
def clear? #:nodoc:
  wrapped.clear?
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}' in #{self}", 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) #:nodoc:

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

def method_missing(symbol, *args, &block) #:nodoc:

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

def respond_to?(symbol, include_private = false) #:nodoc:

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

def sanitize_parameters!(params, sanitizer) #:nodoc:

:nodoc: 
def sanitize_parameters!(params, sanitizer) #:nodoc:
  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