class BinData::Primitive


Primitive objects accept all the parameters that BinData::BasePrimitive do.
== Parameters
“0x%x” % u24 #=> 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 #=> “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: -> { 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 assign(val) 

def assign(val)
  super(val)
  set(_value)
  @value = get
end

def debug_name_of(child) # :nodoc:

:nodoc: 
def debug_name_of(child) # :nodoc:
  debug_name + "-internal-"
end

def do_num_bytes 

def do_num_bytes
  set(_value)
  @struct.do_num_bytes
end

def do_write(io) 

def do_write(io)
  set(_value)
  @struct.do_write(io)
end

def get

internal struct.
Extracts the value for this data object from the fields of the 
def get
  raise NotImplementedError
end

def initialize_instance 

def initialize_instance
  super
  @struct = BinData::Struct.new(get_parameter(:struct_params), self)
end

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

:nodoc: 
def method_missing(symbol, *args, &block) # :nodoc:
  if @struct.respond_to?(symbol)
    @struct.__send__(symbol, *args, &block)
  else
    super
  end
end

def read_and_return_value(io) 

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

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

:nodoc: 
def respond_to?(symbol, include_private = false) # :nodoc:
  @struct.respond_to?(symbol, include_private) || super
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