# typed: true # DO NOT EDIT MANUALLY # This is an autogenerated file for types exported from the `bindata` gem. # Please instead update this file by running `bin/tapioca gem bindata`. # source://bindata//lib/bindata/version.rb#1 module BinData extend ::BinData::BitFieldFactory extend ::BinData::IntFactory private # @yield [@tracer] # # source://bindata//lib/bindata/trace.rb#40 def trace_message; end # Turn on trace information when reading a BinData object. # If +block+ is given then the tracing only occurs for that block. # This is useful for debugging a BinData declaration. # # source://bindata//lib/bindata/trace.rb#26 def trace_reading(io = T.unsafe(nil)); end class << self # @yield [@tracer] # # source://bindata//lib/bindata/trace.rb#40 def trace_message; end # Turn on trace information when reading a BinData object. # If +block+ is given then the tracing only occurs for that block. # This is useful for debugging a BinData declaration. # # source://bindata//lib/bindata/trace.rb#26 def trace_reading(io = T.unsafe(nil)); end end end # source://bindata//lib/bindata/params.rb#4 module BinData::AcceptedParametersPlugin # source://bindata//lib/bindata/params.rb#30 def accepted_parameters; end # Default parameters can be overridden when instantiating a data object. # # source://bindata//lib/bindata/params.rb#16 def default_parameter(*args); end # Default parameters can be overridden when instantiating a data object. # # source://bindata//lib/bindata/params.rb#16 def default_parameters(*args); end # Mandatory parameters must be present when instantiating a data object. # # source://bindata//lib/bindata/params.rb#6 def mandatory_parameter(*args); end # Mandatory parameters must be present when instantiating a data object. # # source://bindata//lib/bindata/params.rb#6 def mandatory_parameters(*args); end # Mutually exclusive parameters may not all be present when # instantiating a data object. # # source://bindata//lib/bindata/params.rb#22 def mutually_exclusive_parameters(*args); end # Optional parameters may be present when instantiating a data object. # # source://bindata//lib/bindata/params.rb#11 def optional_parameter(*args); end # Optional parameters may be present when instantiating a data object. # # source://bindata//lib/bindata/params.rb#11 def optional_parameters(*args); end end # BinData objects accept parameters when initializing. AcceptedParameters # allow a BinData class to declaratively identify accepted parameters as # mandatory, optional, default or mutually exclusive. # # source://bindata//lib/bindata/params.rb#41 class BinData::AcceptedParametersPlugin::AcceptedParameters # @return [AcceptedParameters] a new instance of AcceptedParameters # # source://bindata//lib/bindata/params.rb#42 def initialize(ancestor_parameters = T.unsafe(nil)); end # source://bindata//lib/bindata/params.rb#94 def all; end # source://bindata//lib/bindata/params.rb#72 def default(args = T.unsafe(nil)); end # source://bindata//lib/bindata/params.rb#56 def mandatory(*args); end # source://bindata//lib/bindata/params.rb#82 def mutually_exclusive(*args); end # source://bindata//lib/bindata/params.rb#64 def optional(*args); end private # source://bindata//lib/bindata/params.rb#107 def ensure_valid_names(names); end # source://bindata//lib/bindata/params.rb#101 def to_syms(args); end class << self # source://bindata//lib/bindata/params.rb#117 def invalid_parameter_names; end end end # An Array is a list of data objects of the same type. # # require 'bindata' # # data = "\x03\x04\x05\x06\x07\x08\x09" # # obj = BinData::Array.new(type: :int8, initial_length: 6) # obj.read(data) #=> [3, 4, 5, 6, 7, 8] # # obj = BinData::Array.new(type: :int8, # read_until: -> { index == 1 }) # obj.read(data) #=> [3, 4] # # obj = BinData::Array.new(type: :int8, # read_until: -> { element >= 6 }) # obj.read(data) #=> [3, 4, 5, 6] # # obj = BinData::Array.new(type: :int8, # read_until: -> { array[index] + array[index - 1] == 13 }) # obj.read(data) #=> [3, 4, 5, 6, 7] # # obj = BinData::Array.new(type: :int8, read_until: :eof) # obj.read(data) #=> [3, 4, 5, 6, 7, 8, 9] # # == Parameters # # Parameters may be provided at initialisation to control the behaviour of # an object. These params are: # # :type:: The symbol representing the data type of the # array elements. If the type is to have params # passed to it, then it should be provided as # [type_symbol, hash_params]. # :initial_length:: The initial length of the array. # :read_until:: While reading, elements are read until this # condition is true. This is typically used to # read an array until a sentinel value is found. # The variables +index+, +element+ and +array+ # are made available to any lambda assigned to # this parameter. If the value of this parameter # is the symbol :eof, then the array will read # as much data from the stream as possible. # # Each data object in an array has the variable +index+ made available # to any lambda evaluated as a parameter of that data object. # # source://bindata//lib/bindata/array.rb#50 class BinData::Array < ::BinData::Base include ::Enumerable extend ::BinData::DSLMixin # source://bindata//lib/bindata/array.rb#106 def <<(*args); end # Returns the element at +index+. # # source://bindata//lib/bindata/array.rb#139 def [](arg1, arg2 = T.unsafe(nil)); end # Sets the element at +index+. # # source://bindata//lib/bindata/array.rb#174 def []=(index, value); end # @raise [ArgumentError] # # source://bindata//lib/bindata/array.rb#82 def assign(array); end # Returns the element at +index+. Unlike +slice+, if +index+ is out # of range the array will not be automatically extended. # # source://bindata//lib/bindata/array.rb#169 def at(index); end # @return [Boolean] # # source://bindata//lib/bindata/array.rb#78 def clear?; end # source://bindata//lib/bindata/array.rb#117 def concat(array); end # source://bindata//lib/bindata/array.rb#223 def debug_name_of(child); end # source://bindata//lib/bindata/array.rb#239 def do_num_bytes; end # source://bindata//lib/bindata/array.rb#235 def do_write(io); end # source://bindata//lib/bindata/array.rb#219 def each; end # @return [Boolean] # # source://bindata//lib/bindata/array.rb#210 def empty?; end # source://bindata//lib/bindata/array.rb#94 def find_index(obj); end # Returns the first index of +obj+ in self. # # Uses equal? for the comparator. # # source://bindata//lib/bindata/array.rb#102 def find_index_of(obj); end # Returns the first element, or the first +n+ elements, of the array. # If the array is empty, the first form returns nil, and the second # form returns an empty array. # # source://bindata//lib/bindata/array.rb#182 def first(n = T.unsafe(nil)); end # source://bindata//lib/bindata/array.rb#94 def index(obj); end # source://bindata//lib/bindata/array.rb#74 def initialize_instance; end # source://bindata//lib/bindata/array.rb#61 def initialize_shared_instance; end # source://bindata//lib/bindata/array.rb#122 def insert(index, *objs); end # Returns the last element, or the last +n+ elements, of the array. # If the array is empty, the first form returns nil, and the second # form returns an empty array. # # source://bindata//lib/bindata/array.rb#196 def last(n = T.unsafe(nil)); end # source://bindata//lib/bindata/array.rb#205 def length; end # source://bindata//lib/bindata/array.rb#228 def offset_of(child); end # source://bindata//lib/bindata/array.rb#106 def push(*args); end # source://bindata//lib/bindata/array.rb#205 def size; end # Returns the element at +index+. # # source://bindata//lib/bindata/array.rb#139 def slice(arg1, arg2 = T.unsafe(nil)); end # source://bindata//lib/bindata/array.rb#90 def snapshot; end # Allow this object to be used in array context. # # source://bindata//lib/bindata/array.rb#215 def to_ary; end # source://bindata//lib/bindata/array.rb#112 def unshift(*args); end private # source://bindata//lib/bindata/array.rb#257 def append_new_element; end # source://bindata//lib/bindata/array.rb#253 def elements; end # source://bindata//lib/bindata/array.rb#246 def extend_array(max_index); end # source://bindata//lib/bindata/array.rb#263 def new_element; end # source://bindata//lib/bindata/array.rb#153 def slice_index(index); end # source://bindata//lib/bindata/array.rb#162 def slice_range(range); end # source://bindata//lib/bindata/array.rb#158 def slice_start_length(start, length); end # source://bindata//lib/bindata/array.rb#271 def sum_num_bytes_below_index(index); end # source://bindata//lib/bindata/array.rb#267 def sum_num_bytes_for_all_elements; end end # source://bindata//lib/bindata/array.rb#284 class BinData::ArrayArgProcessor < ::BinData::BaseArgProcessor # source://bindata//lib/bindata/array.rb#285 def sanitize_parameters!(obj_class, params); end end # Add these offset options to Base # # source://bindata//lib/bindata/base.rb#11 class BinData::Base include ::BinData::Framework include ::BinData::RegisterNamePlugin extend ::BinData::AcceptedParametersPlugin # source://bindata//lib/bindata/warnings.rb#12 def initialize(*args); end # source://bindata//lib/bindata/base.rb#231 def ==(other); end # Override and delegate =~ as it is defined in Object. # # source://bindata//lib/bindata/base.rb#199 def =~(other); end # Returns the offset (in bytes) of this object with respect to its most # distant ancestor. # # source://bindata//lib/bindata/base.rb#214 def abs_offset; end def base_respond_to?(*_arg0); end # Resets the internal state to that of a newly created object. # # source://bindata//lib/bindata/base.rb#137 def clear; end # Returns a user friendly name of this object for debugging purposes. # # source://bindata//lib/bindata/base.rb#204 def debug_name; end # Returns the result of evaluating the parameter identified by +key+. # # +overrides+ is an optional +parameters+ like hash that allow the # parameters given at object construction to be overridden. # # Returns nil if +key+ does not refer to any parameter. # # source://bindata//lib/bindata/base.rb#110 def eval_parameter(key, overrides = T.unsafe(nil)); end # Returns the parameter referenced by +key+. # Use this method if you are sure the parameter is not to be evaluated. # You most likely want #eval_parameter. # # source://bindata//lib/bindata/base.rb#127 def get_parameter(key); end # Returns whether +key+ exists in the +parameters+ hash. # # @return [Boolean] # # source://bindata//lib/bindata/base.rb#132 def has_parameter?(key); end # source://bindata//lib/bindata/warnings.rb#25 def initialize_instance(*args); end # source://bindata//lib/bindata/warnings.rb#12 def initialize_with_warning(*args); end # Return a human readable representation of this data object. # # source://bindata//lib/bindata/base.rb#184 def inspect; end # Returns a lazy evaluator for this object. # # source://bindata//lib/bindata/base.rb#120 def lazy_evaluator; end # Creates a new data object based on this instance. # # All parameters will be be duplicated. Use this method # when creating multiple objects with the same parameters. # # source://bindata//lib/bindata/base.rb#95 def new(value = T.unsafe(nil), parent = T.unsafe(nil)); end # Returns the number of bytes it will take to write this data object. # # source://bindata//lib/bindata/base.rb#167 def num_bytes; end # Returns the value of attribute parent. # # source://bindata//lib/bindata/base.rb#88 def parent; end # Work with Ruby's pretty-printer library. # # source://bindata//lib/bindata/base.rb#194 def pretty_print(pp); end # Reads data into this data object. # # source://bindata//lib/bindata/base.rb#142 def read(io, &block); end # Returns the offset (in bytes) of this object with respect to its parent. # # source://bindata//lib/bindata/base.rb#223 def rel_offset; end # A version of +respond_to?+ used by the lazy evaluator. It doesn't # reinvoke the evaluator so as to avoid infinite evaluation loops. # # @return [Boolean] # # source://bindata//lib/bindata/base.rb#238 def safe_respond_to?(symbol, include_private = T.unsafe(nil)); end # Returns the string representation of this data object. # # source://bindata//lib/bindata/base.rb#172 def to_binary_s(&block); end # Returns the hexadecimal string representation of this data object. # # source://bindata//lib/bindata/base.rb#179 def to_hex(&block); end # Return a string representing this data object. # # source://bindata//lib/bindata/base.rb#189 def to_s; end # Writes the value for this data object to +io+. # # source://bindata//lib/bindata/base.rb#155 def write(io, &block); end protected # Sets the attribute parent # # @param value the value to set the attribute parent to. # # source://bindata//lib/bindata/base.rb#88 def parent=(_arg0); end private # source://bindata//lib/bindata/base.rb#284 def binary_string(str); end # source://bindata//lib/bindata/base.rb#247 def extract_args(args); end # Creates a new data object. # # Args are optional, but if present, must be in the following order. # # +value+ is a value that is +assign+ed immediately after initialization. # # +parameters+ is a hash containing symbol keys. Some parameters may # reference callable objects (methods or procs). # # +parent+ is the parent data object (e.g. struct, array, choice) this # object resides under. # Don't override initialize. If you are defining a new kind of datatype # (list, array, choice etc) then put your initialization code in # #initialize_instance. BinData objects might be initialized as prototypes # and your initialization code may not be called. # # If you're subclassing BinData::Record, you are definitely doing the wrong # thing. Read the documentation on how to use BinData. # http://github.com/dmendel/bindata/wiki/Records # # @return [Base] a new instance of Base # # source://bindata//lib/bindata/base.rb#80 def initialize_without_warning(*args); end # Is this object tree currently being read? Used by BasePrimitive. # # @return [Boolean] # # source://bindata//lib/bindata/base.rb#259 def reading?; end # source://bindata//lib/bindata/base.rb#251 def start_read; end # source://bindata//lib/bindata/base.rb#273 def top_level; end # source://bindata//lib/bindata/base.rb#267 def top_level_get(sym); end # source://bindata//lib/bindata/base.rb#263 def top_level_set(sym, value); end class << self # The arg processor for this class. # # source://bindata//lib/bindata/base.rb#26 def arg_processor(name = T.unsafe(nil)); end # The +auto_call_delayed_io+ keyword sets a data object tree to perform # multi pass I/O automatically. # # source://bindata//lib/bindata/delayed_io.rb#161 def auto_call_delayed_io; end # The name of this class as used by Records, Arrays etc. # # source://bindata//lib/bindata/base.rb#41 def bindata_name; end # source://bindata//lib/bindata/base.rb#53 def inherited(subclass); end # Instantiates this class and reads from +io+, returning the newly # created data object. +args+ will be used when instantiating. # # source://bindata//lib/bindata/base.rb#19 def read(io, *args, &block); end private # Registers all subclasses of this class for use # # source://bindata//lib/bindata/base.rb#51 def register_subclasses; end # Call this method if this class is abstract and not to be used. # # source://bindata//lib/bindata/base.rb#46 def unregister_self; end end end # source://bindata//lib/bindata/delayed_io.rb#179 module BinData::Base::AutoCallDelayedIO # source://bindata//lib/bindata/delayed_io.rb#180 def initialize_shared_instance; end # source://bindata//lib/bindata/delayed_io.rb#193 def num_bytes; end # source://bindata//lib/bindata/delayed_io.rb#185 def read(io); end # source://bindata//lib/bindata/delayed_io.rb#189 def write(io, *_); end end # ArgProcessors process the arguments passed to BinData::Base.new into # the form required to initialise the BinData object. # # Any passed parameters are sanitized so the BinData object doesn't # need to perform error checking on the parameters. # # source://bindata//lib/bindata/base.rb#294 class BinData::BaseArgProcessor # Takes the arguments passed to BinData::Base.new and # extracts [value, sanitized_parameters, parent]. # # source://bindata//lib/bindata/base.rb#299 def extract_args(obj_class, obj_args); end # Performs sanity checks on the given parameters. # This method converts the parameters to the form expected # by the data object. # # source://bindata//lib/bindata/base.rb#332 def sanitize_parameters!(obj_class, obj_params); end # Separates the arguments passed to BinData::Base.new into # [value, parameters, parent]. Called by #extract_args. # # source://bindata//lib/bindata/base.rb#308 def separate_args(_obj_class, obj_args); end end # A BinData::BasePrimitive object is a container for a value that has a # particular binary representation. A value corresponds to a primitive type # such as as integer, float or string. Only one value can be contained by # this object. This value can be read from or written to an IO stream. # # require 'bindata' # # obj = BinData::Uint8.new(initial_value: 42) # obj #=> 42 # obj.assign(5) # obj #=> 5 # obj.clear # obj #=> 42 # # obj = BinData::Uint8.new(value: 42) # obj #=> 42 # obj.assign(5) # obj #=> 42 # # obj = BinData::Uint8.new(assert: 3) # obj.read("\005") #=> BinData::ValidityError: value is '5' but expected '3' # # obj = BinData::Uint8.new(assert: -> { value < 5 }) # obj.read("\007") #=> BinData::ValidityError: value not as expected # # == Parameters # # Parameters may be provided at initialisation to control the behaviour of # an object. These params include those for BinData::Base as well as: # # [:initial_value] This is the initial value to use before one is # either #read or explicitly set with #value=. # [:value] The object will always have this value. # Calls to #value= are ignored when # using this param. While reading, #value # will return the value of the data read from the # IO, not the result of the :value param. # [:assert] Raise an error unless the value read or assigned # meets this criteria. The variable +value+ is # made available to any lambda assigned to this # parameter. A boolean return indicates success # or failure. Any other return is compared to # the value just read in. # [:asserted_value] Equivalent to :assert and :value. # # source://bindata//lib/bindata/base_primitive.rb#49 class BinData::BasePrimitive < ::BinData::Base # source://bindata//lib/bindata/base_primitive.rb#115 def <=>(other); end # @raise [ArgumentError] # # source://bindata//lib/bindata/base_primitive.rb#72 def assign(val); end # @return [Boolean] # # source://bindata//lib/bindata/base_primitive.rb#68 def clear?; end # source://bindata//lib/bindata/base_primitive.rb#136 def do_num_bytes; end # source://bindata//lib/bindata/base_primitive.rb#128 def do_read(io); end # source://bindata//lib/bindata/trace.rb#58 def do_read_with_hook(io); end # source://bindata//lib/bindata/base_primitive.rb#132 def do_write(io); end # @return [Boolean] # # source://bindata//lib/bindata/base_primitive.rb#119 def eql?(other); end # source://bindata//lib/bindata/base_primitive.rb#124 def hash; end # source://bindata//lib/bindata/base_primitive.rb#64 def initialize_instance; end # source://bindata//lib/bindata/base_primitive.rb#56 def initialize_shared_instance; end # source://bindata//lib/bindata/base_primitive.rb#102 def method_missing(symbol, *args, &block); end # @return [Boolean] # # source://bindata//lib/bindata/base_primitive.rb#97 def respond_to?(symbol, include_private = T.unsafe(nil)); end # source://bindata//lib/bindata/base_primitive.rb#85 def snapshot; end # source://bindata//lib/bindata/trace.rb#63 def trace_value; end # source://bindata//lib/bindata/base_primitive.rb#89 def value; end # source://bindata//lib/bindata/base_primitive.rb#93 def value=(val); end private # The unmodified value of this data object. Note that #snapshot calls this # method. This indirection is so that #snapshot can be overridden in # subclasses to modify the presentation value. # # source://bindata//lib/bindata/base_primitive.rb#146 def _value; end # Read a number of bytes from +io+ and return the value they represent. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/base_primitive.rb#236 def read_and_return_value(io); end # Return a sensible default for this data. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/base_primitive.rb#241 def sensible_default; end # Return the string representation that +val+ will take when written. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/base_primitive.rb#231 def value_to_binary_string(val); end class << self # source://bindata//lib/bindata/alignment.rb#72 def bit_aligned; end # source://bindata//lib/bindata/base.rb#53 def inherited(subclass); end # source://bindata//lib/bindata/trace.rb#53 def turn_off_tracing; end # source://bindata//lib/bindata/trace.rb#48 def turn_on_tracing; end end end # Logic for the :assert parameter # # source://bindata//lib/bindata/base_primitive.rb#169 module BinData::BasePrimitive::AssertPlugin # @raise [ValidityError] # # source://bindata//lib/bindata/base_primitive.rb#180 def assert!; end # source://bindata//lib/bindata/base_primitive.rb#170 def assign(val); end # source://bindata//lib/bindata/base_primitive.rb#175 def do_read(io); end end # Logic for the :asserted_value parameter # # source://bindata//lib/bindata/base_primitive.rb#198 module BinData::BasePrimitive::AssertedValuePlugin # source://bindata//lib/bindata/base_primitive.rb#204 def _value; end # source://bindata//lib/bindata/base_primitive.rb#213 def assert!; end # source://bindata//lib/bindata/base_primitive.rb#217 def assert_value(current_value); end # source://bindata//lib/bindata/base_primitive.rb#199 def assign(val); end # source://bindata//lib/bindata/base_primitive.rb#208 def do_read(io); end end # Logic for the :initial_value parameter # # source://bindata//lib/bindata/base_primitive.rb#162 module BinData::BasePrimitive::InitialValuePlugin # source://bindata//lib/bindata/base_primitive.rb#163 def _value; end end # Logic for the :value parameter # # source://bindata//lib/bindata/base_primitive.rb#151 module BinData::BasePrimitive::ValuePlugin # source://bindata//lib/bindata/base_primitive.rb#156 def _value; end # source://bindata//lib/bindata/base_primitive.rb#152 def assign(val); end end # source://bindata//lib/bindata/bits.rb#15 class BinData::Bit < ::BinData::BasePrimitive def assign(val); end def bit_aligned?; end def do_num_bytes; end def do_write(io); end private def read_and_return_value(io); end def sensible_default; end end # A monkey patch to force byte-aligned primitives to # become bit-aligned. This allows them to be used at # non byte based boundaries. # # class BitString < BinData::String # bit_aligned # end # # class MyRecord < BinData::Record # bit4 :preamble # bit_string :str, length: 2 # end # # source://bindata//lib/bindata/alignment.rb#43 module BinData::BitAligned # @return [Boolean] # # source://bindata//lib/bindata/alignment.rb#55 def bit_aligned?; end # source://bindata//lib/bindata/alignment.rb#63 def do_num_bytes; end # source://bindata//lib/bindata/alignment.rb#67 def do_write(io); end # source://bindata//lib/bindata/alignment.rb#59 def read_and_return_value(io); end end # source://bindata//lib/bindata/alignment.rb#44 class BinData::BitAligned::BitAlignedIO # @return [BitAlignedIO] a new instance of BitAlignedIO # # source://bindata//lib/bindata/alignment.rb#45 def initialize(io); end # source://bindata//lib/bindata/alignment.rb#48 def readbytes(n); end end # Defines a number of classes that contain a bit based integer. # The integer is defined by endian and number of bits. # # source://bindata//lib/bindata/bits.rb#8 module BinData::BitField class << self # source://bindata//lib/bindata/bits.rb#92 def create_clamp_code(nbits, signed); end # source://bindata//lib/bindata/bits.rb#84 def create_do_num_bytes_code(nbits); end # source://bindata//lib/bindata/bits.rb#100 def create_dynamic_clamp_code(signed); end # source://bindata//lib/bindata/bits.rb#112 def create_fixed_clamp_code(nbits, signed); end # source://bindata//lib/bindata/bits.rb#135 def create_int2uint_code(nbits, signed); end # source://bindata//lib/bindata/bits.rb#76 def create_nbits_code(nbits); end # source://bindata//lib/bindata/bits.rb#68 def create_params_code(nbits); end # source://bindata//lib/bindata/bits.rb#145 def create_uint2int_code(nbits, signed); end # source://bindata//lib/bindata/bits.rb#12 def define_class(name, nbits, endian, signed = T.unsafe(nil)); end # source://bindata//lib/bindata/bits.rb#26 def define_methods(bit_class, nbits, endian, signed); end end end # Create classes on demand # # source://bindata//lib/bindata/bits.rb#166 module BinData::BitFieldFactory # source://bindata//lib/bindata/bits.rb#167 def const_missing(name); end end # source://bindata//lib/bindata/bits.rb#15 class BinData::BitLe < ::BinData::BasePrimitive def assign(val); end def bit_aligned?; end def do_num_bytes; end def do_write(io); end private def read_and_return_value(io); end def sensible_default; end end # A Buffer is conceptually a substream within a data stream. It has a # defined size and it will always read or write the exact number of bytes to # fill the buffer. Short reads will skip over unused bytes and short writes # will pad the substream with "\0" bytes. # # require 'bindata' # # obj = BinData::Buffer.new(length: 5, type: [:string, {value: "abc"}]) # obj.to_binary_s #=> "abc\000\000" # # # class MyBuffer < BinData::Buffer # default_parameter length: 8 # # endian :little # # uint16 :num1 # uint16 :num2 # # padding occurs here # end # # obj = MyBuffer.read("\001\000\002\000\000\000\000\000") # obj.num1 #=> 1 # obj.num1 #=> 2 # obj.raw_num_bytes #=> 4 # obj.num_bytes #=> 8 # # # class StringTable < BinData::Record # endian :little # # uint16 :table_size_in_bytes # buffer :strings, length: :table_size_in_bytes do # array read_until: :eof do # uint8 :len # string :str, length: :len # end # end # end # # # == Parameters # # Parameters may be provided at initialisation to control the behaviour of # an object. These params are: # # :length:: The number of bytes in the buffer. # :type:: The single type inside the buffer. Use a struct if # multiple fields are required. # # source://bindata//lib/bindata/buffer.rb#54 class BinData::Buffer < ::BinData::Base extend ::BinData::DSLMixin # source://bindata//lib/bindata/buffer.rb#75 def assign(val); end # @return [Boolean] # # source://bindata//lib/bindata/buffer.rb#71 def clear?; end # source://bindata//lib/bindata/buffer.rb#103 def do_num_bytes; end # source://bindata//lib/bindata/buffer.rb#91 def do_read(io); end # source://bindata//lib/bindata/buffer.rb#97 def do_write(io); end # source://bindata//lib/bindata/buffer.rb#62 def initialize_instance; end # source://bindata//lib/bindata/buffer.rb#87 def method_missing(symbol, *args, &block); end # The number of bytes used, ignoring the padding imposed by the buffer. # # source://bindata//lib/bindata/buffer.rb#67 def raw_num_bytes; end # @return [Boolean] # # source://bindata//lib/bindata/buffer.rb#83 def respond_to?(symbol, include_private = T.unsafe(nil)); end # source://bindata//lib/bindata/buffer.rb#79 def snapshot; end end # source://bindata//lib/bindata/buffer.rb#108 class BinData::BufferArgProcessor < ::BinData::BaseArgProcessor include ::BinData::MultiFieldArgSeparator # source://bindata//lib/bindata/buffer.rb#111 def sanitize_parameters!(obj_class, params); end end # Align fields to a multiple of :byte_align # # source://bindata//lib/bindata/struct.rb#294 module BinData::ByteAlignPlugin # @return [Boolean] # # source://bindata//lib/bindata/struct.rb#343 def align_obj?(obj); end # source://bindata//lib/bindata/struct.rb#338 def bytes_to_align(obj, rel_offset); end # source://bindata//lib/bindata/struct.rb#295 def do_read(io); end # source://bindata//lib/bindata/struct.rb#308 def do_write(io); end # source://bindata//lib/bindata/struct.rb#321 def sum_num_bytes_below_index(index); end end # A Choice is a collection of data objects of which only one is active # at any particular time. Method calls will be delegated to the active # choice. # # require 'bindata' # # type1 = [:string, {value: "Type1"}] # type2 = [:string, {value: "Type2"}] # # choices = {5 => type1, 17 => type2} # a = BinData::Choice.new(choices: choices, selection: 5) # a # => "Type1" # # choices = [ type1, type2 ] # a = BinData::Choice.new(choices: choices, selection: 1) # a # => "Type2" # # choices = [ nil, nil, nil, type1, nil, type2 ] # a = BinData::Choice.new(choices: choices, selection: 3) # a # => "Type1" # # # Chooser = Struct.new(:choice) # mychoice = Chooser.new # mychoice.choice = 'big' # # choices = {'big' => :uint16be, 'little' => :uint16le} # a = BinData::Choice.new(choices: choices, copy_on_change: true, # selection: -> { mychoice.choice }) # a.assign(256) # a.to_binary_s #=> "\001\000" # # mychoice.choice = 'little' # a.to_binary_s #=> "\000\001" # # == Parameters # # Parameters may be provided at initialisation to control the behaviour of # an object. These params are: # # :choices:: Either an array or a hash specifying the possible # data objects. The format of the # array/hash.values is a list of symbols # representing the data object type. If a choice # is to have params passed to it, then it should # be provided as [type_symbol, hash_params]. An # implementation constraint is that the hash may # not contain symbols as keys, with the exception # of :default. :default is to be used when then # :selection does not exist in the :choices hash. # :selection:: An index/key into the :choices array/hash which # specifies the currently active choice. # :copy_on_change:: If set to true, copy the value of the previous # selection to the current selection whenever the # selection changes. Default is false. # # source://bindata//lib/bindata/choice.rb#60 class BinData::Choice < ::BinData::Base extend ::BinData::DSLMixin def assign(*args); end def clear?(*args); end def do_num_bytes(*args); end def do_read(*args); end # source://bindata//lib/bindata/trace.rb#83 def do_read_with_hook(io); end def do_write(*args); end # source://bindata//lib/bindata/choice.rb#74 def initialize_instance; end # source://bindata//lib/bindata/choice.rb#69 def initialize_shared_instance; end # source://bindata//lib/bindata/choice.rb#92 def method_missing(symbol, *args, &block); end # @return [Boolean] # # source://bindata//lib/bindata/choice.rb#88 def respond_to?(symbol, include_private = T.unsafe(nil)); end # Returns the current selection. # # source://bindata//lib/bindata/choice.rb#80 def selection; end def snapshot(*args); end # source://bindata//lib/bindata/trace.rb#88 def trace_selection; end private # source://bindata//lib/bindata/choice.rb#107 def current_choice; end # source://bindata//lib/bindata/choice.rb#112 def instantiate_choice(selection); end class << self # source://bindata//lib/bindata/trace.rb#78 def turn_off_tracing; end # source://bindata//lib/bindata/trace.rb#73 def turn_on_tracing; end end end # source://bindata//lib/bindata/choice.rb#121 class BinData::ChoiceArgProcessor < ::BinData::BaseArgProcessor # source://bindata//lib/bindata/choice.rb#122 def sanitize_parameters!(obj_class, params); end private # source://bindata//lib/bindata/choice.rb#135 def choices_as_hash(choices); end # source://bindata//lib/bindata/choice.rb#151 def ensure_valid_keys(choices); end # source://bindata//lib/bindata/choice.rb#143 def key_array_by_index(array); end end # Logic for the :copy_on_change parameter # # source://bindata//lib/bindata/choice.rb#162 module BinData::CopyOnChangePlugin # source://bindata//lib/bindata/choice.rb#169 def copy_previous_value(obj); end # source://bindata//lib/bindata/choice.rb#163 def current_choice; end # source://bindata//lib/bindata/choice.rb#176 def get_previous_choice(selection); end # source://bindata//lib/bindata/choice.rb#182 def remember_current_selection(selection); end end # Counts the number of bytes remaining in the input stream from the current # position to the end of the stream. This only makes sense for seekable # streams. # # require 'bindata' # # class A < BinData::Record # count_bytes_remaining :bytes_remaining # string :all_data, read_length: :bytes_remaining # end # # obj = A.read("abcdefghij") # obj.all_data #=> "abcdefghij" # # source://bindata//lib/bindata/count_bytes_remaining.rb#19 class BinData::CountBytesRemaining < ::BinData::BasePrimitive private # source://bindata//lib/bindata/count_bytes_remaining.rb#26 def read_and_return_value(io); end # source://bindata//lib/bindata/count_bytes_remaining.rb#30 def sensible_default; end # source://bindata//lib/bindata/count_bytes_remaining.rb#22 def value_to_binary_string(val); end end # BinData classes that are part of the DSL must be extended by this. # # source://bindata//lib/bindata/dsl.rb#37 module BinData::DSLMixin # source://bindata//lib/bindata/dsl.rb#38 def dsl_parser(parser_type = T.unsafe(nil)); end # source://bindata//lib/bindata/dsl.rb#45 def method_missing(symbol, *args, &block); end # Assert object is not an array or string. # # source://bindata//lib/bindata/dsl.rb#50 def to_ary; end # source://bindata//lib/bindata/dsl.rb#51 def to_str; end end # Handles the :big_and_little endian option. # This option creates two subclasses, each handling # :big or :little endian. # # source://bindata//lib/bindata/dsl.rb#255 class BinData::DSLMixin::DSLBigAndLittleEndianHandler class << self # source://bindata//lib/bindata/dsl.rb#323 def class_with_endian(class_name, endian); end # source://bindata//lib/bindata/dsl.rb#269 def create_subclasses_with_endian(bnl_class); end # source://bindata//lib/bindata/dsl.rb#290 def delegate_field_creation(bnl_class); end # source://bindata//lib/bindata/dsl.rb#303 def fixup_subclass_hierarchy(bnl_class); end # source://bindata//lib/bindata/dsl.rb#257 def handle(bnl_class); end # source://bindata//lib/bindata/dsl.rb#265 def make_class_abstract(bnl_class); end # source://bindata//lib/bindata/dsl.rb#331 def obj_attribute(obj, attr); end # source://bindata//lib/bindata/dsl.rb#274 def override_new_in_class(bnl_class); end end end # Extracts the details from a field declaration. # # source://bindata//lib/bindata/dsl.rb#338 class BinData::DSLMixin::DSLFieldParser # @return [DSLFieldParser] a new instance of DSLFieldParser # # source://bindata//lib/bindata/dsl.rb#339 def initialize(hints, symbol, *args, &block); end # Returns the value of attribute name. # # source://bindata//lib/bindata/dsl.rb#346 def name; end # source://bindata//lib/bindata/dsl.rb#348 def name_from_field_declaration(args); end # Returns the value of attribute params. # # source://bindata//lib/bindata/dsl.rb#346 def params; end # source://bindata//lib/bindata/dsl.rb#367 def params_from_args(args); end # source://bindata//lib/bindata/dsl.rb#374 def params_from_block(&block); end # source://bindata//lib/bindata/dsl.rb#357 def params_from_field_declaration(args, &block); end # Returns the value of attribute type. # # source://bindata//lib/bindata/dsl.rb#346 def type; end end # Validates a field defined in a DSLMixin. # # source://bindata//lib/bindata/dsl.rb#398 class BinData::DSLMixin::DSLFieldValidator # @return [DSLFieldValidator] a new instance of DSLFieldValidator # # source://bindata//lib/bindata/dsl.rb#399 def initialize(the_class, parser); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#448 def all_or_none_names_failed?(name); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#463 def duplicate_name?(name); end # source://bindata//lib/bindata/dsl.rb#420 def ensure_valid_name(name); end # source://bindata//lib/bindata/dsl.rb#475 def fields; end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#459 def malformed_name?(name); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#444 def must_have_a_name_failed?(name); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#440 def must_not_have_a_name_failed?(name); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#471 def name_is_reserved?(name); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#467 def name_shadows_method?(name); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#479 def option?(opt); end # source://bindata//lib/bindata/dsl.rb#404 def validate_field(name); end end # A DSLParser parses and accumulates field definitions of the form # # type name, params # # where: # * +type+ is the under_scored name of a registered type # * +name+ is the (possible optional) name of the field # * +params+ is a hash containing any parameters # # source://bindata//lib/bindata/dsl.rb#62 class BinData::DSLMixin::DSLParser # @return [DSLParser] a new instance of DSLParser # # source://bindata//lib/bindata/dsl.rb#63 def initialize(the_class, parser_type); end # source://bindata//lib/bindata/dsl.rb#113 def dsl_params; end # source://bindata//lib/bindata/dsl.rb#74 def endian(endian = T.unsafe(nil)); end # source://bindata//lib/bindata/dsl.rb#109 def fields; end # source://bindata//lib/bindata/dsl.rb#98 def hide(*args); end # source://bindata//lib/bindata/dsl.rb#118 def method_missing(*args, &block); end # Returns the value of attribute parser_type. # # source://bindata//lib/bindata/dsl.rb#72 def parser_type; end # source://bindata//lib/bindata/dsl.rb#83 def search_prefix(*args); end private # source://bindata//lib/bindata/dsl.rb#190 def append_field(type, name, params); end # @raise [exception] # # source://bindata//lib/bindata/dsl.rb#206 def dsl_raise(exception, msg); end # source://bindata//lib/bindata/dsl.rb#142 def ensure_hints; end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#176 def fields?; end # source://bindata//lib/bindata/dsl.rb#147 def hints; end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#138 def option?(opt); end # source://bindata//lib/bindata/dsl.rb#196 def parent_attribute(attr, default = T.unsafe(nil)); end # source://bindata//lib/bindata/dsl.rb#172 def parent_fields; end # source://bindata//lib/bindata/dsl.rb#180 def parse_and_append_field(*args, &block); end # source://bindata//lib/bindata/dsl.rb#126 def parser_abilities; end # source://bindata//lib/bindata/dsl.rb#151 def set_endian(endian); end # source://bindata//lib/bindata/dsl.rb#224 def to_choice_params(key); end # source://bindata//lib/bindata/dsl.rb#213 def to_object_params(key); end # source://bindata//lib/bindata/dsl.rb#236 def to_struct_params(*unused); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#168 def valid_endian?(endian); end end # BinData declarations are evaluated in a single pass. # However, some binary formats require multi pass processing. A common # reason is seeking backwards in the input stream. # # DelayedIO supports multi pass processing. It works by ignoring the normal # #read or #write calls. The user must explicitly call the #read_now! or # #write_now! methods to process an additional pass. This additional pass # must specify the abs_offset of the I/O operation. # # require 'bindata' # # obj = BinData::DelayedIO.new(read_abs_offset: 3, type: :uint16be) # obj.read("\x00\x00\x00\x11\x12") # obj #=> 0 # # obj.read_now! # obj #=> 0x1112 # # - OR - # # obj.read("\x00\x00\x00\x11\x12") { obj.read_now! } #=> 0x1122 # # obj.to_binary_s { obj.write_now! } #=> "\x00\x00\x00\x11\x12" # # You can use the +auto_call_delayed_io+ keyword to cause #read and #write to # automatically perform the extra passes. # # class ReversePascalString < BinData::Record # auto_call_delayed_io # # delayed_io :str, read_abs_offset: 0 do # string read_length: :len # end # count_bytes_remaining :total_size # skip to_abs_offset: -> { total_size - 1 } # uint8 :len, value: -> { str.length } # end # # s = ReversePascalString.read("hello\x05") # s.to_binary_s #=> "hello\x05" # # # == Parameters # # Parameters may be provided at initialisation to control the behaviour of # an object. These params are: # # :read_abs_offset:: The abs_offset to start reading at. # :type:: The single type inside the delayed io. Use # a struct if multiple fields are required. # # source://bindata//lib/bindata/delayed_io.rb#55 class BinData::DelayedIO < ::BinData::Base extend ::BinData::DSLMixin # source://bindata//lib/bindata/delayed_io.rb#94 def abs_offset; end # Sets the +abs_offset+ to use when writing this object. # # source://bindata//lib/bindata/delayed_io.rb#99 def abs_offset=(offset); end # source://bindata//lib/bindata/delayed_io.rb#74 def assign(val); end # @return [Boolean] # # source://bindata//lib/bindata/delayed_io.rb#70 def clear?; end # source://bindata//lib/bindata/delayed_io.rb#115 def do_num_bytes; end # source://bindata//lib/bindata/delayed_io.rb#107 def do_read(io); end # source://bindata//lib/bindata/delayed_io.rb#111 def do_write(io); end # @return [Boolean] # # source://bindata//lib/bindata/delayed_io.rb#119 def include_obj?; end # source://bindata//lib/bindata/delayed_io.rb#63 def initialize_instance; end # source://bindata//lib/bindata/delayed_io.rb#90 def method_missing(symbol, *args, &block); end # source://bindata//lib/bindata/delayed_io.rb#82 def num_bytes; end # DelayedIO objects aren't read when #read is called. # The reading is delayed until this method is called. # # @raise [IOError] # # source://bindata//lib/bindata/delayed_io.rb#125 def read_now!; end # source://bindata//lib/bindata/delayed_io.rb#103 def rel_offset; end # @return [Boolean] # # source://bindata//lib/bindata/delayed_io.rb#86 def respond_to?(symbol, include_private = T.unsafe(nil)); end # source://bindata//lib/bindata/delayed_io.rb#78 def snapshot; end # DelayedIO objects aren't written when #write is called. # The writing is delayed until this method is called. # # @raise [IOError] # # source://bindata//lib/bindata/delayed_io.rb#137 def write_now!; end end # source://bindata//lib/bindata/delayed_io.rb#146 class BinData::DelayedIoArgProcessor < ::BinData::BaseArgProcessor include ::BinData::MultiFieldArgSeparator # source://bindata//lib/bindata/delayed_io.rb#149 def sanitize_parameters!(obj_class, params); end end # Double precision floating point number in big endian format # # source://bindata//lib/bindata/float.rb#80 class BinData::DoubleBe < ::BinData::BasePrimitive def do_num_bytes; end private def read_and_return_value(io); end def sensible_default; end def value_to_binary_string(val); end end # Double precision floating point number in little endian format # # source://bindata//lib/bindata/float.rb#75 class BinData::DoubleLe < ::BinData::BasePrimitive def do_num_bytes; end private def read_and_return_value(io); end def sensible_default; end def value_to_binary_string(val); end end # Single precision floating point number in big endian format # # source://bindata//lib/bindata/float.rb#70 class BinData::FloatBe < ::BinData::BasePrimitive def do_num_bytes; end private def read_and_return_value(io); end def sensible_default; end def value_to_binary_string(val); end end # Single precision floating point number in little endian format # # source://bindata//lib/bindata/float.rb#65 class BinData::FloatLe < ::BinData::BasePrimitive def do_num_bytes; end private def read_and_return_value(io); end def sensible_default; end def value_to_binary_string(val); end end # Defines a number of classes that contain a floating point number. # The float is defined by precision and endian. # # source://bindata//lib/bindata/float.rb#7 module BinData::FloatingPoint class << self # source://bindata//lib/bindata/float.rb#44 def create_num_bytes_code(precision); end # source://bindata//lib/bindata/float.rb#48 def create_read_code(precision, endian); end # source://bindata//lib/bindata/float.rb#55 def create_to_binary_s_code(precision, endian); end # source://bindata//lib/bindata/float.rb#21 def define_methods(float_class, precision, endian); end end end # All methods provided by the framework are to be implemented or overridden # by subclasses of BinData::Base. # # source://bindata//lib/bindata/framework.rb#7 module BinData::Framework # Assigns the value of +val+ to this data object. Note that +val+ must # always be deep copied to ensure no aliasing problems can occur. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/framework.rb#29 def assign(val); end # Is this object aligned on non-byte boundaries? # # @return [Boolean] # # source://bindata//lib/bindata/framework.rb#51 def bit_aligned?; end # Returns true if the object has not been changed since creation. # # @raise [NotImplementedError] # @return [Boolean] # # source://bindata//lib/bindata/framework.rb#23 def clear?; end # Returns the debug name of +child+. This only needs to be implemented # by objects that contain child objects. # # source://bindata//lib/bindata/framework.rb#40 def debug_name_of(child); end # Returns the offset of +child+. This only needs to be implemented # by objects that contain child objects. # # source://bindata//lib/bindata/framework.rb#46 def offset_of(child); end # Returns a snapshot of this data object. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/framework.rb#34 def snapshot; end protected # Returns the number of bytes it will take to write this data. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/framework.rb#66 def do_num_bytes; end # Reads the data for this data object from +io+. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/framework.rb#56 def do_read(io); end # Writes the value for this data to +io+. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/framework.rb#61 def do_write(io); end # Initializes the state of the object. All instance variables that # are used by the object must be initialized here. # # source://bindata//lib/bindata/framework.rb#10 def initialize_instance; end # Initialises state that is shared by objects with the same parameters. # # This should only be used when optimising for performance. Instance # variables set here, and changes to the singleton class will be shared # between all objects that are initialized with the same parameters. # This method is called only once for a particular set of parameters. # # source://bindata//lib/bindata/framework.rb#19 def initialize_shared_instance; end end # A wrapper around an IO object. The wrapper provides a consistent # interface for BinData objects to use when accessing the IO. # # source://bindata//lib/bindata/io.rb#6 module BinData::IO class << self # Creates a StringIO around +str+. # # source://bindata//lib/bindata/io.rb#215 def create_string_io(str = T.unsafe(nil)); end end end # Common operations for both Read and Write. # # source://bindata//lib/bindata/io.rb#9 module BinData::IO::Common # source://bindata//lib/bindata/io.rb#10 def initialize(io); end private # source://bindata//lib/bindata/io.rb#40 def buffer_limited_n(n); end # source://bindata//lib/bindata/io.rb#36 def seek(n); end # @return [Boolean] # # source://bindata//lib/bindata/io.rb#30 def seekable?; end # source://bindata//lib/bindata/io.rb#54 def with_buffer_common(n); end end # Use #seek and #pos on seekable streams # # source://bindata//lib/bindata/io.rb#69 module BinData::IO::Common::SeekableStream # The number of bytes remaining in the input stream. # # source://bindata//lib/bindata/io.rb#71 def num_bytes_remaining; end # All io calls in +block+ are rolled back after this # method completes. # # source://bindata//lib/bindata/io.rb#90 def with_readahead; end private # source://bindata//lib/bindata/io.rb#106 def offset_raw; end # source://bindata//lib/bindata/io.rb#114 def read_raw(n); end # source://bindata//lib/bindata/io.rb#110 def seek_raw(n); end # source://bindata//lib/bindata/io.rb#102 def stream_init; end # source://bindata//lib/bindata/io.rb#118 def write_raw(data); end end # Manually keep track of offset for unseekable streams. # # source://bindata//lib/bindata/io.rb#124 module BinData::IO::Common::UnSeekableStream # The number of bytes remaining in the input stream. # # @raise [IOError] # # source://bindata//lib/bindata/io.rb#130 def num_bytes_remaining; end # source://bindata//lib/bindata/io.rb#125 def offset_raw; end # All io calls in +block+ are rolled back after this # method completes. # # source://bindata//lib/bindata/io.rb#136 def with_readahead; end private # source://bindata//lib/bindata/io.rb#161 def read_raw(n); end # source://bindata//lib/bindata/io.rb#167 def read_raw_with_readahead(n); end # @raise [IOError] # # source://bindata//lib/bindata/io.rb#199 def seek_raw(n); end # source://bindata//lib/bindata/io.rb#157 def stream_init; end # source://bindata//lib/bindata/io.rb#194 def write_raw(data); end end # Create a new IO Read wrapper around +io+. +io+ must provide #read, # #pos if reading the current stream position and #seek if setting the # current stream position. If +io+ is a string it will be automatically # wrapped in an StringIO object. # # The IO can handle bitstreams in either big or little endian format. # # M byte1 L M byte2 L # S 76543210 S S fedcba98 S # B B B B # # In big endian format: # readbits(6), readbits(5) #=> [765432, 10fed] # # In little endian format: # readbits(6), readbits(5) #=> [543210, a9876] # # source://bindata//lib/bindata/io.rb#238 class BinData::IO::Read include ::BinData::IO::Common # @return [Read] a new instance of Read # # source://bindata//lib/bindata/io.rb#241 def initialize(io); end # Returns the current offset of the io stream. Offset will be rounded # up when reading bitfields. # # source://bindata//lib/bindata/io.rb#261 def offset; end # Reads all remaining bytes from the stream. # # source://bindata//lib/bindata/io.rb#282 def read_all_bytes; end # Reads exactly +nbits+ bits from the stream. +endian+ specifies whether # the bits are stored in +:big+ or +:little+ endian format. # # source://bindata//lib/bindata/io.rb#289 def readbits(nbits, endian); end # Reads exactly +n+ bytes from +io+. # # If the data read is nil an EOFError is raised. # # If the data read is too short an IOError is raised. # # source://bindata//lib/bindata/io.rb#276 def readbytes(n); end # Discards any read bits so the stream becomes aligned at the # next byte boundary. # # source://bindata//lib/bindata/io.rb#305 def reset_read_bits; end # Seek +n+ bytes from the current position in the io stream. # # source://bindata//lib/bindata/io.rb#266 def seekbytes(n); end # Sets a buffer of +n+ bytes on the io stream. Any reading or seeking # calls inside the +block+ will be contained within this buffer. # # source://bindata//lib/bindata/io.rb#252 def with_buffer(n); end private # source://bindata//lib/bindata/io.rb#334 def accumulate_big_endian_bits; end # source://bindata//lib/bindata/io.rb#352 def accumulate_little_endian_bits; end # source://bindata//lib/bindata/io.rb#358 def mask(nbits); end # source://bindata//lib/bindata/io.rb#313 def read(n = T.unsafe(nil)); end # source://bindata//lib/bindata/io.rb#322 def read_big_endian_bits(nbits); end # source://bindata//lib/bindata/io.rb#340 def read_little_endian_bits(nbits); end end # Create a new IO Write wrapper around +io+. +io+ must provide #write. # If +io+ is a string it will be automatically wrapped in an StringIO # object. # # The IO can handle bitstreams in either big or little endian format. # # See IO::Read for more information. # # source://bindata//lib/bindata/io.rb#370 class BinData::IO::Write include ::BinData::IO::Common # @return [Write] a new instance of Write # # source://bindata//lib/bindata/io.rb#372 def initialize(io); end # To be called after all +writebits+ have been applied. # # source://bindata//lib/bindata/io.rb#428 def flush; end # To be called after all +writebits+ have been applied. # # source://bindata//lib/bindata/io.rb#428 def flushbits; end # Returns the current offset of the io stream. Offset will be rounded # up when writing bitfields. # # source://bindata//lib/bindata/io.rb#393 def offset; end # Seek +n+ bytes from the current position in the io stream. # # source://bindata//lib/bindata/io.rb#398 def seekbytes(n); end # Sets a buffer of +n+ bytes on the io stream. Any writes inside the # +block+ will be contained within this buffer. If less than +n+ bytes # are written inside the block, the remainder will be padded with '\0' # bytes. # # source://bindata//lib/bindata/io.rb#384 def with_buffer(n); end # Writes +nbits+ bits from +val+ to the stream. +endian+ specifies whether # the bits are to be stored in +:big+ or +:little+ endian format. # # source://bindata//lib/bindata/io.rb#411 def writebits(val, nbits, endian); end # Writes the given string of bytes to the io stream. # # source://bindata//lib/bindata/io.rb#404 def writebytes(str); end private # source://bindata//lib/bindata/io.rb#491 def mask(nbits); end # source://bindata//lib/bindata/io.rb#440 def write(data); end # source://bindata//lib/bindata/io.rb#449 def write_big_endian_bits(val, nbits); end # source://bindata//lib/bindata/io.rb#470 def write_little_endian_bits(val, nbits); end end # Logic for the :initial_length parameter # # source://bindata//lib/bindata/array.rb#328 module BinData::InitialLengthPlugin # source://bindata//lib/bindata/array.rb#329 def do_read(io); end # source://bindata//lib/bindata/array.rb#333 def elements; end end # Defines a number of classes that contain an integer. The integer # is defined by endian, signedness and number of bytes. # # source://bindata//lib/bindata/int.rb#8 module BinData::Int class << self # source://bindata//lib/bindata/int.rb#12 def define_class(name, nbits, endian, signed); end # source://bindata//lib/bindata/int.rb#26 def define_methods(int_class, nbits, endian, signed); end private # source://bindata//lib/bindata/int.rb#150 def bits_per_word(nbits); end # source://bindata//lib/bindata/int.rb#60 def create_clamp_code(nbits, signed); end # source://bindata//lib/bindata/int.rb#142 def create_int2uint_code(nbits); end # source://bindata//lib/bindata/int.rb#82 def create_raw_read_code(nbits, endian, signed); end # source://bindata//lib/bindata/int.rb#101 def create_read_assemble_code(nbits, endian, signed); end # source://bindata//lib/bindata/int.rb#72 def create_read_code(nbits, endian, signed); end # source://bindata//lib/bindata/int.rb#94 def create_read_unpack_code(nbits, endian, signed); end # source://bindata//lib/bindata/int.rb#115 def create_to_binary_s_code(nbits, endian, signed); end # source://bindata//lib/bindata/int.rb#146 def create_uint2int_code(nbits); end # @return [Boolean] # # source://bindata//lib/bindata/int.rb#172 def need_signed_conversion_code?(nbits, signed); end # source://bindata//lib/bindata/int.rb#157 def pack_directive(nbits, endian, signed); end # source://bindata//lib/bindata/int.rb#130 def val_as_packed_words(nbits, endian, signed); end end end # Signed 1 byte integer. # # source://bindata//lib/bindata/int.rb#185 class BinData::Int8 < ::BinData::BasePrimitive def assign(val); end def do_num_bytes; end private def read_and_return_value(io); end def sensible_default; end def value_to_binary_string(val); end end # Create classes on demand # # source://bindata//lib/bindata/int.rb#190 module BinData::IntFactory # source://bindata//lib/bindata/int.rb#191 def const_missing(name); end end # A LazyEvaluator is bound to a data object. The evaluator will evaluate # lambdas in the context of this data object. These lambdas # are those that are passed to data objects as parameters, e.g.: # # BinData::String.new(value: -> { %w(a test message).join(" ") }) # # As a shortcut, :foo is the equivalent of lambda { foo }. # # When evaluating lambdas, unknown methods are resolved in the context of the # parent of the bound data object. Resolution is attempted firstly as keys # in #parameters, and secondly as methods in this parent. This # resolution propagates up the chain of parent data objects. # # An evaluation will recurse until it returns a result that is not # a lambda or a symbol. # # This resolution process makes the lambda easier to read as we just write # field instead of obj.field. # # source://bindata//lib/bindata/lazy.rb#20 class BinData::LazyEvaluator # Creates a new evaluator. All lazy evaluation is performed in the # context of +obj+. # # @return [LazyEvaluator] a new instance of LazyEvaluator # # source://bindata//lib/bindata/lazy.rb#24 def initialize(obj); end # Returns the index of this data object inside it's nearest container # array. # # @raise [NoMethodError] # # source://bindata//lib/bindata/lazy.rb#50 def index; end # source://bindata//lib/bindata/lazy.rb#28 def lazy_eval(val, overrides = T.unsafe(nil)); end # source://bindata//lib/bindata/lazy.rb#65 def method_missing(symbol, *args); end # Returns a LazyEvaluator for the parent of this data object. # # source://bindata//lib/bindata/lazy.rb#40 def parent; end private # @return [Boolean] # # source://bindata//lib/bindata/lazy.rb#105 def callable?(obj); end # source://bindata//lib/bindata/lazy.rb#78 def eval_symbol_in_parent_context(symbol, args); end # source://bindata//lib/bindata/lazy.rb#95 def recursively_eval(val, args); end # source://bindata//lib/bindata/lazy.rb#83 def resolve_symbol_in_parent_context(symbol, args); end end # Extracts args for Records and Buffers. # # Foo.new(bar: "baz) is ambiguous as to whether :bar is a value or parameter. # # BaseArgExtractor always assumes :bar is parameter. This extractor correctly # identifies it as value or parameter. # # source://bindata//lib/bindata/dsl.rb#8 module BinData::MultiFieldArgSeparator # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#28 def field_names_in_parameters?(obj_class, parameters); end # @return [Boolean] # # source://bindata//lib/bindata/dsl.rb#20 def parameters_is_value?(obj_class, value, parameters); end # source://bindata//lib/bindata/dsl.rb#9 def separate_args(obj_class, obj_args); end end # A Primitive is a declarative way to define a new BinData data type. # The data type must contain a primitive value only, i.e numbers or strings. # For new data types that contain multiple values see BinData::Record. # # To define a new data type, set fields as if for Record and add a # #get and #set method to extract / convert the data between the fields # and the #value of the object. # # require 'bindata' # # class PascalString < BinData::Primitive # uint8 :len, value: -> { data.length } # string :data, read_length: :len # # def get # self.data # end # # def set(v) # self.data = v # end # end # # ps = PascalString.new(initial_value: "hello") # ps.to_binary_s #=> "\005hello" # ps.read("\003abcde") # ps #=> "abc" # # # Unsigned 24 bit big endian integer # class Uint24be < BinData::Primitive # uint8 :byte1 # uint8 :byte2 # uint8 :byte3 # # def get # (self.byte1 << 16) | (self.byte2 << 8) | self.byte3 # end # # def set(v) # v = 0 if v < 0 # v = 0xffffff if v > 0xffffff # # self.byte1 = (v >> 16) & 0xff # self.byte2 = (v >> 8) & 0xff # self.byte3 = v & 0xff # end # end # # u24 = Uint24be.new # u24.read("\x12\x34\x56") # "0x%x" % u24 #=> 0x123456 # # == Parameters # # Primitive objects accept all the parameters that BinData::BasePrimitive do. # # source://bindata//lib/bindata/primitive.rb#62 class BinData::Primitive < ::BinData::BasePrimitive extend ::BinData::DSLMixin # source://bindata//lib/bindata/primitive.rb#88 def assign(val); end # source://bindata//lib/bindata/primitive.rb#94 def debug_name_of(child); end # source://bindata//lib/bindata/primitive.rb#103 def do_num_bytes; end # source://bindata//lib/bindata/primitive.rb#98 def do_write(io); end # source://bindata//lib/bindata/primitive.rb#71 def initialize_instance; end # source://bindata//lib/bindata/primitive.rb#80 def method_missing(symbol, *args, &block); end # @return [Boolean] # # source://bindata//lib/bindata/primitive.rb#76 def respond_to?(symbol, include_private = T.unsafe(nil)); end private # Extracts the value for this data object from the fields of the # internal struct. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/primitive.rb#125 def get; end # source://bindata//lib/bindata/primitive.rb#115 def read_and_return_value(io); end # source://bindata//lib/bindata/primitive.rb#111 def sensible_default; end # Sets the fields of the internal struct to represent +v+. # # @raise [NotImplementedError] # # source://bindata//lib/bindata/primitive.rb#130 def set(v); end class << self # source://bindata//lib/bindata/alignment.rb#76 def bit_aligned; end end end # source://bindata//lib/bindata/primitive.rb#138 class BinData::PrimitiveArgProcessor < ::BinData::BaseArgProcessor # source://bindata//lib/bindata/primitive.rb#139 def sanitize_parameters!(obj_class, params); end end # Logic for the read_until: :eof parameter # # source://bindata//lib/bindata/array.rb#313 module BinData::ReadUntilEOFPlugin # source://bindata//lib/bindata/array.rb#314 def do_read(io); end end # Logic for the :read_until parameter # # source://bindata//lib/bindata/array.rb#301 module BinData::ReadUntilPlugin # source://bindata//lib/bindata/array.rb#302 def do_read(io); end end # A Record is a declarative wrapper around Struct. # # See +Struct+ for more info. # # source://bindata//lib/bindata/record.rb#8 class BinData::Record < ::BinData::Struct extend ::BinData::DSLMixin class << self # source://bindata//lib/bindata/base.rb#53 def inherited(subclass); end end end # source://bindata//lib/bindata/record.rb#16 class BinData::RecordArgProcessor < ::BinData::StructArgProcessor include ::BinData::MultiFieldArgSeparator # source://bindata//lib/bindata/record.rb#19 def sanitize_parameters!(obj_class, params); end end # == Parameters # # Parameters may be provided at initialisation to control the behaviour of # an object. These parameters are: # # :name:: The name that this object can be referred to may be # set explicitly. This is only useful when dynamically # generating types. # 
#                    BinData::Struct.new(name: :my_struct, fields: ...)
#                    array = BinData::Array.new(type: :my_struct)
#
# # source://bindata//lib/bindata/name.rb#14 module BinData::RegisterNamePlugin # source://bindata//lib/bindata/name.rb#21 def initialize_shared_instance; end class << self # source://bindata//lib/bindata/name.rb#16 def included(base); end end end # A singleton registry of all registered classes. # # source://bindata//lib/bindata/registry.rb#133 BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry) # This registry contains a register of name -> class mappings. # # Numerics (integers and floating point numbers) have an endian property as # part of their name (e.g. int32be, float_le). # # Classes can be looked up based on their full name or an abbreviated +name+ # with +hints+. # # There are two hints supported, :endian and :search_prefix. # # #lookup("int32", { endian: :big }) will return Int32Be. # # #lookup("my_type", { search_prefix: :ns }) will return NsMyType. # # Names are stored in under_score_style, not camelCase. # # source://bindata//lib/bindata/registry.rb#20 class BinData::Registry # @return [Registry] a new instance of Registry # # source://bindata//lib/bindata/registry.rb#22 def initialize; end # source://bindata//lib/bindata/registry.rb#39 def lookup(name, hints = T.unsafe(nil)); end # source://bindata//lib/bindata/registry.rb#26 def register(name, class_to_register); end # Convert CamelCase +name+ to underscore style. # # source://bindata//lib/bindata/registry.rb#51 def underscore_name(name); end # source://bindata//lib/bindata/registry.rb#35 def unregister(name); end private # source://bindata//lib/bindata/registry.rb#96 def name_with_endian(name, endian); end # source://bindata//lib/bindata/registry.rb#87 def name_with_prefix(name, prefix); end # source://bindata//lib/bindata/registry.rb#64 def normalize_name(name, hints); end # source://bindata//lib/bindata/registry.rb#113 def register_dynamic_class(name); end # @return [Boolean] # # source://bindata//lib/bindata/registry.rb#107 def registered?(name); end # source://bindata//lib/bindata/registry.rb#123 def warn_if_name_is_already_registered(name, class_to_register); end end # Rest will consume the input stream from the current position to the end of # the stream. This will mainly be useful for debugging and developing. # # require 'bindata' # # class A < BinData::Record # string :a, read_length: 5 # rest :rest # end # # obj = A.read("abcdefghij") # obj.a #=> "abcde" # obj.rest #=" "fghij" # # source://bindata//lib/bindata/rest.rb#19 class BinData::Rest < ::BinData::BasePrimitive private # source://bindata//lib/bindata/rest.rb#26 def read_and_return_value(io); end # source://bindata//lib/bindata/rest.rb#30 def sensible_default; end # source://bindata//lib/bindata/rest.rb#22 def value_to_binary_string(val); end end # Resets the stream alignment to the next byte. This is # only useful when using bit-based primitives. # # class MyRec < BinData::Record # bit4 :a # resume_byte_alignment # bit4 :b # end # # MyRec.read("\x12\x34") #=> {"a" => 1, "b" => 3} # # source://bindata//lib/bindata/alignment.rb#15 class BinData::ResumeByteAlignment < ::BinData::Base # source://bindata//lib/bindata/alignment.rb#17 def assign(val); end # @return [Boolean] # # source://bindata//lib/bindata/alignment.rb#16 def clear?; end # source://bindata//lib/bindata/alignment.rb#19 def do_num_bytes; end # source://bindata//lib/bindata/alignment.rb#21 def do_read(io); end # source://bindata//lib/bindata/alignment.rb#25 def do_write(io); end # source://bindata//lib/bindata/alignment.rb#18 def snapshot; end end # ---------------------------------------------------------------------------- # # source://bindata//lib/bindata/sanitize.rb#157 class BinData::SanitizedBigEndian < ::BinData::SanitizedParameter # source://bindata//lib/bindata/sanitize.rb#158 def endian; end end # ---------------------------------------------------------------------------- # # source://bindata//lib/bindata/sanitize.rb#132 class BinData::SanitizedChoices < ::BinData::SanitizedParameter # @return [SanitizedChoices] a new instance of SanitizedChoices # # source://bindata//lib/bindata/sanitize.rb#133 def initialize(choices, hints); end # source://bindata//lib/bindata/sanitize.rb#151 def [](key); end end # ---------------------------------------------------------------------------- # # source://bindata//lib/bindata/sanitize.rb#46 class BinData::SanitizedField < ::BinData::SanitizedParameter # @return [SanitizedField] a new instance of SanitizedField # # source://bindata//lib/bindata/sanitize.rb#47 def initialize(name, field_type, field_params, hints); end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#62 def has_parameter?(param); end # source://bindata//lib/bindata/sanitize.rb#66 def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end # source://bindata//lib/bindata/sanitize.rb#58 def name; end # source://bindata//lib/bindata/sanitize.rb#54 def name_as_sym; end # Returns the value of attribute prototype. # # source://bindata//lib/bindata/sanitize.rb#52 def prototype; end end # ---------------------------------------------------------------------------- # # source://bindata//lib/bindata/sanitize.rb#72 class BinData::SanitizedFields < ::BinData::SanitizedParameter include ::Enumerable # @return [SanitizedFields] a new instance of SanitizedFields # # source://bindata//lib/bindata/sanitize.rb#75 def initialize(hints, base_fields = T.unsafe(nil)); end # source://bindata//lib/bindata/sanitize.rb#94 def [](idx); end # source://bindata//lib/bindata/sanitize.rb#84 def add_field(type, name, params); end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#118 def all_field_names_blank?; end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#126 def any_field_has_parameter?(parameter); end # source://bindata//lib/bindata/sanitize.rb#106 def each(&block); end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#98 def empty?; end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#114 def field_name?(name); end # source://bindata//lib/bindata/sanitize.rb#110 def field_names; end # source://bindata//lib/bindata/sanitize.rb#102 def length; end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#122 def no_field_names_blank?; end # source://bindata//lib/bindata/sanitize.rb#90 def raw_fields; end end # source://bindata//lib/bindata/sanitize.rb#163 class BinData::SanitizedLittleEndian < ::BinData::SanitizedParameter # source://bindata//lib/bindata/sanitize.rb#164 def endian; end end # Subclasses of this are sanitized # # source://bindata//lib/bindata/sanitize.rb#6 class BinData::SanitizedParameter; end # BinData objects are instantiated with parameters to determine their # behaviour. These parameters must be sanitized to ensure their values # are valid. When instantiating many objects with identical parameters, # such as an array of records, there is much duplicated sanitizing. # # The purpose of the sanitizing code is to eliminate the duplicated # validation. # # SanitizedParameters is a hash-like collection of parameters. Its purpose # is to recursively sanitize the parameters of an entire BinData object chain # at a single time. # # source://bindata//lib/bindata/sanitize.rb#181 class BinData::SanitizedParameters < ::Hash # @return [SanitizedParameters] a new instance of SanitizedParameters # # source://bindata//lib/bindata/sanitize.rb#197 def initialize(parameters, the_class, hints); end # source://bindata//lib/bindata/sanitize.rb#287 def create_sanitized_params(params, the_class); end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#215 def has_at_least_one_of?(*keys); end def has_parameter?(_arg0); end # source://bindata//lib/bindata/sanitize.rb#291 def hints; end # def warn_renamed_parameter(old_key, new_key) # val = delete(old_key) # if val # self[new_key] = val # Kernel.warn ":#{old_key} has been renamed to :#{new_key} in #{@the_class}. " \ # "Using :#{old_key} is now deprecated and will be removed in the future" # end # end # # source://bindata//lib/bindata/sanitize.rb#239 def must_be_integer(*keys); end # source://bindata//lib/bindata/sanitize.rb#253 def rename_parameter(old_key, new_key); end # source://bindata//lib/bindata/sanitize.rb#281 def sanitize(key, &block); end # source://bindata//lib/bindata/sanitize.rb#271 def sanitize_choices(key, &block); end # source://bindata//lib/bindata/sanitize.rb#277 def sanitize_endian(key); end # source://bindata//lib/bindata/sanitize.rb#263 def sanitize_fields(key, &block); end # source://bindata//lib/bindata/sanitize.rb#259 def sanitize_object_prototype(key); end # source://bindata//lib/bindata/sanitize.rb#223 def warn_replacement_parameter(bad_key, suggested_key); end private # source://bindata//lib/bindata/sanitize.rb#359 def create_sanitized_choices(choices); end # source://bindata//lib/bindata/sanitize.rb#347 def create_sanitized_endian(endian); end # source://bindata//lib/bindata/sanitize.rb#363 def create_sanitized_fields; end # source://bindata//lib/bindata/sanitize.rb#367 def create_sanitized_object_prototype(obj_type, obj_params); end # source://bindata//lib/bindata/sanitize.rb#327 def ensure_mandatory_parameters_exist; end # source://bindata//lib/bindata/sanitize.rb#336 def ensure_mutual_exclusion_of_parameters; end # source://bindata//lib/bindata/sanitize.rb#312 def ensure_no_nil_values; end # source://bindata//lib/bindata/sanitize.rb#321 def merge_default_parameters!; end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#308 def needs_sanitizing?(key); end # source://bindata//lib/bindata/sanitize.rb#298 def sanitize!; end class << self # source://bindata//lib/bindata/sanitize.rb#188 def sanitize(parameters, the_class); end end end # Memoized constants # # source://bindata//lib/bindata/sanitize.rb#184 BinData::SanitizedParameters::BIG_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedBigEndian) # source://bindata//lib/bindata/sanitize.rb#185 BinData::SanitizedParameters::LITTLE_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedLittleEndian) # source://bindata//lib/bindata/sanitize.rb#8 class BinData::SanitizedPrototype < ::BinData::SanitizedParameter # @return [SanitizedPrototype] a new instance of SanitizedPrototype # # source://bindata//lib/bindata/sanitize.rb#9 def initialize(obj_type, obj_params, hints); end # @return [Boolean] # # source://bindata//lib/bindata/sanitize.rb#30 def has_parameter?(param); end # source://bindata//lib/bindata/sanitize.rb#38 def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end end # source://bindata//lib/bindata/bits.rb#15 class BinData::Sbit < ::BinData::BasePrimitive def assign(val); end def bit_aligned?; end def do_num_bytes; end def do_write(io); end private def read_and_return_value(io); end def sensible_default; end end # source://bindata//lib/bindata/bits.rb#15 class BinData::SbitLe < ::BinData::BasePrimitive def assign(val); end def bit_aligned?; end def do_num_bytes; end def do_write(io); end private def read_and_return_value(io); end def sensible_default; end end # Skip will skip over bytes from the input stream. If the stream is not # seekable, then the bytes are consumed and discarded. # # When writing, skip will write the appropriate number of zero bytes. # # require 'bindata' # # class A < BinData::Record # skip length: 5 # string :a, read_length: 5 # end # # obj = A.read("abcdefghij") # obj.a #=> "fghij" # # # class B < BinData::Record # skip until_valid: [:string, {read_length: 2, assert: "ef"} ] # string :b, read_length: 5 # end # # obj = B.read("abcdefghij") # obj.b #=> "efghi" # # # == Parameters # # Skip objects accept all the params that BinData::BasePrimitive # does, as well as the following: # # :length:: The number of bytes to skip. # :to_abs_offset:: Skips to the given absolute offset. # :until_valid:: Skips untils a given byte pattern is matched. # This parameter contains a type that will raise # a BinData::ValidityError unless an acceptable byte # sequence is found. The type is represented by a # Symbol, or if the type is to have params # # passed to it, then it should be provided as # # [type_symbol, hash_params]. # # source://bindata//lib/bindata/skip.rb#44 class BinData::Skip < ::BinData::BasePrimitive # source://bindata//lib/bindata/skip.rb#50 def initialize_shared_instance; end private # source://bindata//lib/bindata/skip.rb#69 def read_and_return_value(io); end # source://bindata//lib/bindata/skip.rb#79 def sensible_default; end # source://bindata//lib/bindata/skip.rb#60 def value_to_binary_string(val); end end # source://bindata//lib/bindata/skip.rb#84 class BinData::SkipArgProcessor < ::BinData::BaseArgProcessor # source://bindata//lib/bindata/skip.rb#85 def sanitize_parameters!(obj_class, params); end end # Logic for the :length parameter # # source://bindata//lib/bindata/skip.rb#96 module BinData::SkipLengthPlugin # source://bindata//lib/bindata/skip.rb#97 def skip_length; end end # Logic for the :to_abs_offset parameter # # source://bindata//lib/bindata/skip.rb#103 module BinData::SkipToAbsOffsetPlugin # source://bindata//lib/bindata/skip.rb#104 def skip_length; end end # Logic for the :until_valid parameter # # source://bindata//lib/bindata/skip.rb#110 module BinData::SkipUntilValidPlugin # source://bindata//lib/bindata/skip.rb#116 def read_and_return_value(io); end # source://bindata//lib/bindata/skip.rb#111 def skip_length; end end # A String is a sequence of bytes. This is the same as strings in Ruby 1.8. # The issue of character encoding is ignored by this class. # # require 'bindata' # # data = "abcdefghij" # # obj = BinData::String.new(read_length: 5) # obj.read(data) # obj #=> "abcde" # # obj = BinData::String.new(length: 6) # obj.read(data) # obj #=> "abcdef" # obj.assign("abcdefghij") # obj #=> "abcdef" # obj.assign("abcd") # obj #=> "abcd\000\000" # # obj = BinData::String.new(length: 6, trim_padding: true) # obj.assign("abcd") # obj #=> "abcd" # obj.to_binary_s #=> "abcd\000\000" # # obj = BinData::String.new(length: 6, pad_byte: 'A') # obj.assign("abcd") # obj #=> "abcdAA" # obj.to_binary_s #=> "abcdAA" # # == Parameters # # String objects accept all the params that BinData::BasePrimitive # does, as well as the following: # # :read_length:: The length in bytes to use when reading a value. # :length:: The fixed length of the string. If a shorter # string is set, it will be padded to this length. # :pad_byte:: The byte to use when padding a string to a # set length. Valid values are Integers and # Strings of length 1. "\0" is the default. # :pad_front:: Signifies that the padding occurs at the front # of the string rather than the end. Default # is false. # :trim_padding:: Boolean, default false. If set, #value will # return the value with all pad_bytes trimmed # from the end of the string. The value will # not be trimmed when writing. # # source://bindata//lib/bindata/string.rb#51 class BinData::String < ::BinData::BasePrimitive # source://bindata//lib/bindata/string.rb#67 def assign(val); end # source://bindata//lib/bindata/string.rb#59 def initialize_shared_instance; end # source://bindata//lib/bindata/string.rb#71 def snapshot; end private # source://bindata//lib/bindata/string.rb#86 def clamp_to_length(str); end # source://bindata//lib/bindata/string.rb#116 def read_and_return_value(io); end # source://bindata//lib/bindata/string.rb#121 def sensible_default; end # source://bindata//lib/bindata/string.rb#104 def trim_padding(str); end # source://bindata//lib/bindata/string.rb#112 def value_to_binary_string(val); end end # source://bindata//lib/bindata/string.rb#126 class BinData::StringArgProcessor < ::BinData::BaseArgProcessor # source://bindata//lib/bindata/string.rb#127 def sanitize_parameters!(obj_class, params); end private # source://bindata//lib/bindata/string.rb#137 def sanitized_pad_byte(byte); end end # A BinData::Stringz object is a container for a zero ("\0") terminated # string. # # For convenience, the zero terminator is not necessary when setting the # value. Likewise, the returned value will not be zero terminated. # # require 'bindata' # # data = "abcd\x00efgh" # # obj = BinData::Stringz.new # obj.read(data) # obj.snapshot #=> "abcd" # obj.num_bytes #=> 5 # obj.to_binary_s #=> "abcd\000" # # == Parameters # # Stringz objects accept all the params that BinData::BasePrimitive # does, as well as the following: # # :max_length:: The maximum length of the string including the zero # byte. # # source://bindata//lib/bindata/stringz.rb#27 class BinData::Stringz < ::BinData::BasePrimitive # source://bindata//lib/bindata/stringz.rb#31 def assign(val); end # source://bindata//lib/bindata/stringz.rb#35 def snapshot; end private # source://bindata//lib/bindata/stringz.rb#90 def append_zero_byte_if_needed!(str); end # source://bindata//lib/bindata/stringz.rb#48 def read_and_return_value(io); end # source://bindata//lib/bindata/stringz.rb#64 def sensible_default; end # source://bindata//lib/bindata/stringz.rb#68 def trim_and_zero_terminate(str); end # source://bindata//lib/bindata/stringz.rb#80 def trim_to!(str, max_length = T.unsafe(nil)); end # source://bindata//lib/bindata/stringz.rb#76 def truncate_after_first_zero_byte!(str); end # source://bindata//lib/bindata/stringz.rb#44 def value_to_binary_string(val); end end # 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. # :search_prefix:: Allows abbreviated type names. If a type is # unrecognised, then each prefix is applied until # a match is found. # # == 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. # [:byte_align] This field's rel_offset must be a multiple of # :byte_align. # # source://bindata//lib/bindata/struct.rb#59 class BinData::Struct < ::BinData::Base # source://bindata//lib/bindata/struct.rb#153 def [](key); end # source://bindata//lib/bindata/struct.rb#157 def []=(key, value); end # source://bindata//lib/bindata/struct.rb#101 def assign(val); end # source://bindata//lib/bindata/struct.rb#93 def clear; end # @return [Boolean] # # source://bindata//lib/bindata/struct.rb#97 def clear?; end # source://bindata//lib/bindata/struct.rb#127 def debug_name_of(child); end # source://bindata//lib/bindata/struct.rb#148 def do_num_bytes; end # source://bindata//lib/bindata/struct.rb#138 def do_read(io); end # :nodoc # # source://bindata//lib/bindata/struct.rb#143 def do_write(io); end # source://bindata//lib/bindata/struct.rb#168 def each_pair; end # Returns a list of the names of all fields accessible through this # object. +include_hidden+ specifies whether to include hidden names # in the listing. # # source://bindata//lib/bindata/struct.rb#118 def field_names(include_hidden = T.unsafe(nil)); end # has_key? is deprecated # # @return [Boolean] # # source://bindata//lib/bindata/struct.rb#164 def has_key?(key); end # source://bindata//lib/bindata/struct.rb#89 def initialize_instance; end # source://bindata//lib/bindata/struct.rb#81 def initialize_shared_instance; end # @return [Boolean] # # source://bindata//lib/bindata/struct.rb#164 def key?(key); end # source://bindata//lib/bindata/struct.rb#132 def offset_of(child); end # source://bindata//lib/bindata/struct.rb#106 def snapshot; end private # source://bindata//lib/bindata/struct.rb#239 def as_stringified_hash(val); end # source://bindata//lib/bindata/struct.rb#228 def assign_fields(val); end # source://bindata//lib/bindata/struct.rb#213 def base_field_name(name); end # source://bindata//lib/bindata/struct.rb#177 def define_field_accessors; end # source://bindata//lib/bindata/struct.rb#184 def define_field_accessors_for(name, index); end # source://bindata//lib/bindata/struct.rb#199 def find_index_of(obj); end # source://bindata//lib/bindata/struct.rb#203 def find_obj_for_name(name); end # @return [Boolean] # # source://bindata//lib/bindata/struct.rb#273 def include_obj?(obj); end # @return [Boolean] # # source://bindata//lib/bindata/struct.rb#267 def include_obj_for_io?(obj); end # source://bindata//lib/bindata/struct.rb#217 def instantiate_all_objs; end # source://bindata//lib/bindata/struct.rb#221 def instantiate_obj_at(index); end # source://bindata//lib/bindata/struct.rb#255 def sum_num_bytes_below_index(index); end # source://bindata//lib/bindata/struct.rb#251 def sum_num_bytes_for_all_fields; end class << self # source://bindata//lib/bindata/base.rb#53 def inherited(subclass); end end end # These reserved words may not be used as field names # # source://bindata//lib/bindata/struct.rb#66 BinData::Struct::RESERVED = T.let(T.unsafe(nil), Hash) # A hash that can be accessed via attributes. # # source://bindata//lib/bindata/struct.rb#278 class BinData::Struct::Snapshot < ::Hash # source://bindata//lib/bindata/struct.rb#279 def []=(key, value); end # source://bindata//lib/bindata/struct.rb#287 def method_missing(symbol, *args); end # @return [Boolean] # # source://bindata//lib/bindata/struct.rb#283 def respond_to?(symbol, include_private = T.unsafe(nil)); end end # source://bindata//lib/bindata/struct.rb#348 class BinData::StructArgProcessor < ::BinData::BaseArgProcessor # source://bindata//lib/bindata/struct.rb#349 def sanitize_parameters!(obj_class, params); end private # source://bindata//lib/bindata/struct.rb#403 def ensure_field_names_are_valid(obj_class, field_names); end # source://bindata//lib/bindata/struct.rb#399 def hidden_field_names(hidden); end # source://bindata//lib/bindata/struct.rb#359 def sanitize_endian(params); end # source://bindata//lib/bindata/struct.rb#375 def sanitize_fields(obj_class, params); end # source://bindata//lib/bindata/struct.rb#386 def sanitize_hide(params); end # source://bindata//lib/bindata/struct.rb#363 def sanitize_search_prefix(params); end # source://bindata//lib/bindata/struct.rb#395 def sanitized_field_names(sanitized_fields); end end # source://bindata//lib/bindata/trace.rb#5 class BinData::Tracer # @return [Tracer] a new instance of Tracer # # source://bindata//lib/bindata/trace.rb#6 def initialize(io); end # source://bindata//lib/bindata/trace.rb#10 def trace(msg); end # source://bindata//lib/bindata/trace.rb#14 def trace_obj(obj_name, val); end end # Unsigned 1 byte integer. # # source://bindata//lib/bindata/int.rb#180 class BinData::Uint8 < ::BinData::BasePrimitive def assign(val); end def do_num_bytes; end private def read_and_return_value(io); end def sensible_default; end def value_to_binary_string(val); end end # Uint8Array is a specialised type of array that only contains # bytes (Uint8). It is a faster and more memory efficient version # of `BinData::Array.new(:type => :uint8)`. # # require 'bindata' # # obj = BinData::Uint8Array.new(initial_length: 5) # obj.read("abcdefg") #=> [97, 98, 99, 100, 101] # obj[2] #=> 99 # obj.collect { |x| x.chr }.join #=> "abcde" # # == Parameters # # Parameters may be provided at initialisation to control the behaviour of # an object. These params are: # # :initial_length:: The initial length of the array. # :read_until:: May only have a value of `:eof`. This parameter # instructs the array to read as much data from # the stream as possible. # # source://bindata//lib/bindata/uint8_array.rb#24 class BinData::Uint8Array < ::BinData::BasePrimitive private # source://bindata//lib/bindata/uint8_array.rb#36 def read_and_return_value(io); end # source://bindata//lib/bindata/uint8_array.rb#46 def sensible_default; end # source://bindata//lib/bindata/uint8_array.rb#32 def value_to_binary_string(val); end end # source://bindata//lib/bindata/uint8_array.rb#51 class BinData::Uint8ArrayArgProcessor < ::BinData::BaseArgProcessor # source://bindata//lib/bindata/uint8_array.rb#52 def sanitize_parameters!(obj_class, params); end end # source://bindata//lib/bindata/registry.rb#3 class BinData::UnRegisteredTypeError < ::StandardError; end # source://bindata//lib/bindata/version.rb#2 BinData::VERSION = T.let(T.unsafe(nil), String) # Error raised when unexpected results occur when reading data from IO. # # source://bindata//lib/bindata/framework.rb#3 class BinData::ValidityError < ::StandardError; end # A virtual field is one that is neither read, written nor occupies space in # the data stream. It is used to make assertions or as a convenient label # for determining offsets or storing values. # # require 'bindata' # # class A < BinData::Record # string :a, read_length: 5 # string :b, read_length: 5 # virtual :c, assert: -> { a == b } # end # # obj = A.read("abcdeabcde") # obj.a #=> "abcde" # obj.c.offset #=> 10 # # obj = A.read("abcdeABCDE") #=> BinData::ValidityError: assertion failed for obj.c # # == Parameters # # Parameters may be provided at initialisation to control the behaviour of # an object. These params include those for BinData::Base as well as: # # [:assert] Raise an error when reading or assigning if the value # of this evaluated parameter is false. # [:value] The virtual object will always have this value. # # source://bindata//lib/bindata/virtual.rb#31 class BinData::Virtual < ::BinData::BasePrimitive # source://bindata//lib/bindata/virtual.rb#39 def do_num_bytes; end # source://bindata//lib/bindata/virtual.rb#33 def do_read(io); end # source://bindata//lib/bindata/virtual.rb#36 def do_write(io); end # source://bindata//lib/bindata/virtual.rb#43 def sensible_default; end end # Warns when reading if :value && no :read_length # # source://bindata//lib/bindata/string.rb#147 module BinData::WarnNoReadLengthPlugin # source://bindata//lib/bindata/string.rb#148 def read_and_return_value(io); end end