Class: BinData::Wrapper

Inherits:
Base
  • Object
show all
Defined in:
lib/bindata/wrapper.rb

Overview

A Wrapper allows the creation of new BinData types that provide default parameters.

require 'bindata'

class Uint8Array < BinData::Wrapper
  default_parameter :initial_element_value => 0
  array :type => [:uint8, {:initial_value => :initial_element_value}],
        :initial_length => 2
end

arr = Uint8Array.new
arr.snapshot #=> [0, 0]

arr = Uint8Array.new(:initial_length => 5, :initial_element_value => 3)
arr.snapshot #=> [3, 3, 3, 3 ,3]

Instance Attribute Summary

Attributes inherited from Base

#parent

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#==, accepted_parameters, #assign, #debug_name, #debug_name_of, default_parameters, #eval_parameter, #get_parameter, #has_parameter?, #inspect, mandatory_parameters, mutually_exclusive_parameters, #num_bytes, #offset, #offset_of, optional_parameters, #pretty_print, #read, read, #rel_offset, #snapshot, #to_binary_s, #to_s, #write

Constructor Details

#initialize(params = {}, parent = nil) ⇒ Wrapper

Returns a new instance of Wrapper.



99
100
101
102
103
104
 
# File 'lib/bindata/wrapper.rb', line 99

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

  prototype = get_parameter(:wrapped)
  @wrapped = prototype.instantiate(self)
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(symbol, *args, &block) ⇒ Object

:nodoc:



118
119
120
 
# File 'lib/bindata/wrapper.rb', line 118

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

Class Method Details

.endian(endian = nil) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
 
# File 'lib/bindata/wrapper.rb', line 30

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

.inherited(subclass) ⇒ Object

:nodoc:



25
26
27
28
 
# File 'lib/bindata/wrapper.rb', line 25

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

.method_missing(symbol, *args) ⇒ Object

:nodoc:



55
56
57
58
59
60
 
# File 'lib/bindata/wrapper.rb', line 55

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

  wrapped(type, params)
end

.sanitize_parameters!(params, sanitizer) ⇒ Object

:nodoc:



62
63
64
65
66
67
68
69
70
71
 
# File 'lib/bindata/wrapper.rb', line 62

def sanitize_parameters!(params, sanitizer) #:nodoc:
  raise "Nothing to wrap" if wrapped.nil?

  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

.wrapped(*args) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/bindata/wrapper.rb', line 41

def wrapped(*args)
  @wrapped ||= default_wrapped
  if args.length == 2
    type, params = *args
    ensure_type_exists(type)

    if wrapped != nil
      raise SyntaxError, "#{self} can only wrap one type", caller(2)
    end
    @wrapped = [type, params]
  end
  @wrapped
end

Instance Method Details

#clear ⇒ Object

:nodoc:



106
107
108
 
# File 'lib/bindata/wrapper.rb', line 106

def clear #:nodoc:
  wrapped.clear
end

#clear? ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


110
111
112
 
# File 'lib/bindata/wrapper.rb', line 110

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

#respond_to?(symbol, include_private = false) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


114
115
116
 
# File 'lib/bindata/wrapper.rb', line 114

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