Class: BinData::Struct

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

Overview

A Struct is an ordered collection of named data objects.

require 'bindata'

class Tuple < BinData::Record
  int8  :x
  int8  :y
  int8  :z
end

obj = BinData::Struct.new(:hide => :a,
                          :fields => [ [:int32le, :a],
                                       [:int16le, :b],
                                       [:tuple, :s] ])
obj.field_names   =># ["b", "s"]

Parameters

Parameters may be provided at initialisation to control the behaviour of an object. These params are:

:fields

An array specifying the fields for this struct. Each element of the array is of the form [type, name, params]. Type is a symbol representing a registered type. Name is the name of this field. Params is an optional hash of parameters to pass to this field when instantiating it. If name is “” or nil, then that field is anonymous and behaves as a hidden field.

:hide

A list of the names of fields that are to be hidden from the outside world. Hidden fields don’t appear in #snapshot or #field_names but are still accessible by name.

:endian

Either :little or :big. This specifies the default endian of any numerics in this struct, or in any nested data objects.

Field Parameters

Fields may have have extra parameters as listed below:

:onlyif

Used to indicate a data object is optional. if false, this object will not be included in any calls to #read, #write, #num_bytes or #snapshot.

Direct Known Subclasses

Record

Defined Under Namespace

Modules: OrderedHash Classes: Snapshot

Constant Summary collapse

RESERVED =

These reserved words may not be used as field names

Hash[*
                 (Hash.instance_methods +
%w{alias and begin break case class def defined do else elsif
   end ensure false for if in module next nil not or redo
   rescue retry return self super then true undef unless until
   when while yield} +
%w{array element index value} ).collect { |name| name.to_sym }.
uniq.collect { |key| [key, true]

Instance Attribute Summary

Attributes inherited from Base

#parent

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#==, #=~, arg_extractor, bindata_name, #debug_name, #eval_parameter, #get_parameter, #has_parameter?, #initialize_with_warning, #inspect, #lazy_evaluator, #new, #num_bytes, #offset, #pretty_print, #read, read, register_subclasses, #rel_offset, #safe_respond_to?, #to_binary_s, #to_s, unregister_self, #write

Methods included from AcceptedParametersPlugin

#accepted_parameters, #default_parameters, #mandatory_parameters, #mutually_exclusive_parameters, #optional_parameters

Methods included from RegisterNamePlugin

included

Methods included from CheckOrAdjustOffsetPlugin

included

Methods included from Framework

included

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

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

:nodoc:



186
187
188
189
190
191
192
193
 
# File 'lib/bindata/struct.rb', line 186

def method_missing(symbol, *args, &block) #:nodoc:
  obj = find_obj_for_name(symbol)
  if obj
    invoke_field(obj, symbol, args)
  else
    super
  end
end

Class Method Details

.sanitize_parameters!(params) ⇒ Object

:nodoc:



71
72
73
74
75
 
# File 'lib/bindata/struct.rb', line 71

def sanitize_parameters!(params) #:nodoc:
  sanitize_endian(params)
  sanitize_fields(params)
  sanitize_hide(params)
end

Instance Method Details

#[](key) ⇒ Object 



221
222
223
 
# File 'lib/bindata/struct.rb', line 221

def [](key)
  find_obj_for_name(key)
end

#[]=(key, value) ⇒ Object 



225
226
227
228
229
230
 
# File 'lib/bindata/struct.rb', line 225

def []=(key, value)
  obj = find_obj_for_name(key)
  if obj
    obj.assign(value)
  end
end

#assign(val) ⇒ Object 



156
157
158
159
 
# File 'lib/bindata/struct.rb', line 156

def assign(val)
  clear
  assign_fields(val)
end

#clear ⇒ Object

:nodoc:



148
149
150
 
# File 'lib/bindata/struct.rb', line 148

def clear #:nodoc:
  @field_objs.each { |f| f.clear unless f.nil? }
end

#clear? ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


152
153
154
 
# File 'lib/bindata/struct.rb', line 152

def clear? #:nodoc:
  @field_objs.all? { |f| f.nil? or f.clear? }
end

#debug_name_of(child) ⇒ Object

:nodoc:



195
196
197
198
 
# File 'lib/bindata/struct.rb', line 195

def debug_name_of(child) #:nodoc:
  field_name = @field_names[find_index_of(child)]
  "#{debug_name}.#{field_name}"
end

#do_num_bytes ⇒ Object

:nodoc:



216
217
218
219
 
# File 'lib/bindata/struct.rb', line 216

def do_num_bytes #:nodoc:
  instantiate_all_objs
  sum_num_bytes_for_all_fields
end

#do_read(io) ⇒ Object

:nodoc:



206
207
208
209
 
# File 'lib/bindata/struct.rb', line 206

def do_read(io) #:nodoc:
  instantiate_all_objs
  @field_objs.each { |f| f.do_read(io) if include_obj(f) }
end

#do_write(io) ⇒ Object

:nodoc



211
212
213
214
 
# File 'lib/bindata/struct.rb', line 211

def do_write(io) #:nodoc
  instantiate_all_objs
  @field_objs.each { |f| f.do_write(io) if include_obj(f) }
end

#each_pair ⇒ Object 



236
237
238
239
240
 
# File 'lib/bindata/struct.rb', line 236

def each_pair
  @field_names.compact.each do |name|
    yield [name, find_obj_for_name(name)]
  end
end

#field_names(include_hidden = false) ⇒ Object

Returns a list of the names of all fields accessible through this object. include_hidden specifies whether to include hidden names in the listing.



173
174
175
176
177
178
179
180
 
# File 'lib/bindata/struct.rb', line 173

def field_names(include_hidden = false)
  if include_hidden
    @field_names.compact
  else
    hidden = get_parameter(:hide) || []
    @field_names.compact - hidden
  end.collect { |x| x.to_s }
end

#has_key?(key) ⇒ Boolean

Returns:

  • (Boolean) 


232
233
234
 
# File 'lib/bindata/struct.rb', line 232

def has_key?(key)
  @field_names.index(base_field_name(key))
end

#initialize_instance ⇒ Object 



144
145
146
 
# File 'lib/bindata/struct.rb', line 144

def initialize_instance
  @field_objs  = []
end

#initialize_shared_instance ⇒ Object 



139
140
141
142
 
# File 'lib/bindata/struct.rb', line 139

def initialize_shared_instance
  @field_names = get_parameter(:fields).field_names.freeze
  super
end

#offset_of(child) ⇒ Object

:nodoc:



200
201
202
203
204
 
# File 'lib/bindata/struct.rb', line 200

def offset_of(child) #:nodoc:
  instantiate_all_objs
  sum = sum_num_bytes_below_index(find_index_of(child))
  child.do_num_bytes.is_a?(Integer) ? sum.ceil : sum.floor
end

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

:nodoc:

Returns:

  • (Boolean) 


182
183
184
 
# File 'lib/bindata/struct.rb', line 182

def respond_to?(symbol, include_private = false) #:nodoc:
  @field_names.include?(base_field_name(symbol)) || super
end

#snapshot ⇒ Object 



161
162
163
164
165
166
167
168
 
# File 'lib/bindata/struct.rb', line 161

def snapshot
  snapshot = Snapshot.new
  field_names.each do |name|
    obj = find_obj_for_name(name)
    snapshot[name] = obj.snapshot if include_obj(obj)
  end
  snapshot
end