class BinData::Primitive


Primitive objects accept all the parameters that BinData::BasePrimitive do.
== Parameters
“0x%x” % u24.value #=> 0x123456
u24.read(“x12x34x56”)
u24 = Uint24be.new
end
end
self.byte3 = v & 0xff
self.byte2 = (v >> 8) & 0xff
self.byte1 = (v >> 16) & 0xff
v = 0xffffff if v > 0xffffff
v = 0 if v < 0
def set(v)
end
(self.byte1 << 16) | (self.byte2 << 8) | self.byte3
def get
uint8 :byte3
uint8 :byte2
uint8 :byte1
class Uint24be < BinData::Primitive
# Unsigned 24 bit big endian integer
ps.value #=> “abc”
ps.read(“003abcde”)
ps.to_binary_s #=> “005hello”
ps = PascalString.new(:initial_value => “hello”)
end
end
self.data = v
def set(v)
end
self.data
def get
string :data, :read_length => :len
uint8 :len, :value => lambda { data.length }
class PascalString < BinData::Primitive
require ‘bindata’
and the #value of the object.
#get and #set method to extract / convert the data between the fields
To define a new data type, set fields as if for Record and add a
For new data types that contain multiple values see BinData::Record.
The data type must contain a primitive value only, i.e numbers or strings.
A Primitive is a declarative way to define a new BinData data type.

def append_field(type, name, params) 

def append_field(type, name, params)
  ensure_valid_name(name)
  fields.add_field(type, name, params)
rescue TypeError
  raise TypeError, "unknown type '#{type}' for #{self}", caller(2)
end

def debug_name_of(child) 

def debug_name_of(child)
  debug_name + "-internal-"
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_valid_name(name) 

def ensure_valid_name(name)
  if fields.field_names.include?(name)
    raise SyntaxError, "duplicate field '#{name}' in #{self}", caller(3)
  end
  if self.instance_methods.include?(name)
    raise NameError.new("", name),
          "field '#{name}' shadows an existing method", caller(3)
  end
end

def fields 

def fields
  unless defined? @fields
    sanitizer = Sanitizer.new
    @fields = sanitizer.create_sanitized_fields(endian)
  end
  @fields
end

def get

internal struct.
Extracts the value for this data object from the fields of the 
def get
  raise NotImplementedError
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)
  @struct = BinData::Struct.new(get_parameter(:struct_params), self)
end

def method_missing(symbol, *args) 

def method_missing(symbol, *args)
  name, params = args
  type = symbol
  name = name.to_s
  params ||= {}
  append_field(type, name, params)
end

def method_missing(symbol, *args, &block) 

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

def offset_of(child) 

def offset_of(child)
  offset
end

def read_and_return_value(io) 

def read_and_return_value(io)
  @struct.read(io)
  get
end

def sanitize_parameters!(params, sanitizer) 

def sanitize_parameters!(params, sanitizer)
  struct_params = {}
  struct_params[:fields] = fields
  struct_params[:endian] = endian unless endian.nil?
  
  params[:struct_params] = struct_params
end

def sensible_default 

def sensible_default
  get
end

def set(v)

Sets the fields of the internal struct to represent +v+. 
def set(v)
  raise NotImplementedError
end

def value_to_binary_string(val) 

def value_to_binary_string(val)
  set(val)
  @struct.to_binary_s
end