1189 lines
27 KiB
Ruby
1189 lines
27 KiB
Ruby
# DO NOT EDIT MANUALLY
|
|
# This is an autogenerated file for types exported from the `bindata` gem.
|
|
# Please instead update this file by running `tapioca generate --exclude json`.
|
|
|
|
# typed: true
|
|
|
|
module BinData
|
|
extend(::BinData::BitFieldFactory)
|
|
extend(::BinData::IntFactory)
|
|
|
|
|
|
private
|
|
|
|
def trace_message; end
|
|
def trace_reading(io = T.unsafe(nil)); end
|
|
|
|
class << self
|
|
def trace_message; end
|
|
def trace_reading(io = T.unsafe(nil)); end
|
|
end
|
|
end
|
|
|
|
module BinData::AcceptedParametersPlugin
|
|
def accepted_parameters; end
|
|
def default_parameter(*args); end
|
|
def default_parameters(*args); end
|
|
def mandatory_parameter(*args); end
|
|
def mandatory_parameters(*args); end
|
|
def mutually_exclusive_parameters(*args); end
|
|
def optional_parameter(*args); end
|
|
def optional_parameters(*args); end
|
|
end
|
|
|
|
class BinData::AcceptedParametersPlugin::AcceptedParameters
|
|
def initialize(ancestor_parameters = T.unsafe(nil)); end
|
|
|
|
def all; end
|
|
def default(args = T.unsafe(nil)); end
|
|
def mandatory(*args); end
|
|
def mutually_exclusive(*args); end
|
|
def optional(*args); end
|
|
|
|
private
|
|
|
|
def ensure_valid_names(names); end
|
|
def to_syms(args); end
|
|
|
|
class << self
|
|
def invalid_parameter_names; end
|
|
end
|
|
end
|
|
|
|
class BinData::Array < ::BinData::Base
|
|
include(::Enumerable)
|
|
extend(::BinData::DSLMixin)
|
|
|
|
def <<(*args); end
|
|
def [](arg1, arg2 = T.unsafe(nil)); end
|
|
def []=(index, value); end
|
|
def assign(array); end
|
|
def at(index); end
|
|
def clear?; end
|
|
def concat(array); end
|
|
def debug_name_of(child); end
|
|
def do_num_bytes; end
|
|
def do_write(io); end
|
|
def each; end
|
|
def empty?; end
|
|
def find_index(obj); end
|
|
def find_index_of(obj); end
|
|
def first(n = T.unsafe(nil)); end
|
|
def index(obj); end
|
|
def initialize_instance; end
|
|
def initialize_shared_instance; end
|
|
def insert(index, *objs); end
|
|
def last(n = T.unsafe(nil)); end
|
|
def length; end
|
|
def offset_of(child); end
|
|
def push(*args); end
|
|
def size; end
|
|
def slice(arg1, arg2 = T.unsafe(nil)); end
|
|
def snapshot; end
|
|
def to_ary; end
|
|
def unshift(*args); end
|
|
|
|
private
|
|
|
|
def append_new_element; end
|
|
def elements; end
|
|
def extend_array(max_index); end
|
|
def new_element; end
|
|
def slice_index(index); end
|
|
def slice_range(range); end
|
|
def slice_start_length(start, length); end
|
|
def sum_num_bytes_below_index(index); end
|
|
def sum_num_bytes_for_all_elements; end
|
|
end
|
|
|
|
class BinData::ArrayArgProcessor < ::BinData::BaseArgProcessor
|
|
def sanitize_parameters!(obj_class, params); end
|
|
end
|
|
|
|
class BinData::Base
|
|
include(::BinData::Framework)
|
|
include(::BinData::RegisterNamePlugin)
|
|
extend(::BinData::AcceptedParametersPlugin)
|
|
|
|
def initialize(*args); end
|
|
|
|
def ==(other); end
|
|
def =~(other); end
|
|
def abs_offset; end
|
|
def base_respond_to?(*_); end
|
|
def clear; end
|
|
def debug_name; end
|
|
def eval_parameter(key, overrides = T.unsafe(nil)); end
|
|
def get_parameter(key); end
|
|
def has_parameter?(key); end
|
|
def initialize_instance(*args); end
|
|
def initialize_with_warning(*args); end
|
|
def inspect; end
|
|
def lazy_evaluator; end
|
|
def new(value = T.unsafe(nil), parent = T.unsafe(nil)); end
|
|
def num_bytes; end
|
|
def parent; end
|
|
def pretty_print(pp); end
|
|
def read(io, &block); end
|
|
def rel_offset; end
|
|
def safe_respond_to?(symbol, include_private = T.unsafe(nil)); end
|
|
def to_binary_s(&block); end
|
|
def to_hex(&block); end
|
|
def to_s; end
|
|
def write(io, &block); end
|
|
|
|
protected
|
|
|
|
def parent=(_); end
|
|
|
|
private
|
|
|
|
def binary_string(str); end
|
|
def extract_args(args); end
|
|
def initialize_without_warning(*args); end
|
|
def reading?; end
|
|
def start_read; end
|
|
def top_level; end
|
|
def top_level_get(sym); end
|
|
def top_level_set(sym, value); end
|
|
|
|
class << self
|
|
def arg_processor(name = T.unsafe(nil)); end
|
|
def auto_call_delayed_io; end
|
|
def bindata_name; end
|
|
def inherited(subclass); end
|
|
def read(io, *args, &block); end
|
|
|
|
private
|
|
|
|
def register_subclasses; end
|
|
def unregister_self; end
|
|
end
|
|
end
|
|
|
|
module BinData::Base::AutoCallDelayedIO
|
|
def initialize_shared_instance; end
|
|
def num_bytes; end
|
|
def read(io); end
|
|
def write(io, *_); end
|
|
end
|
|
|
|
class BinData::BaseArgProcessor
|
|
def extract_args(obj_class, obj_args); end
|
|
def sanitize_parameters!(obj_class, obj_params); end
|
|
def separate_args(_obj_class, obj_args); end
|
|
end
|
|
|
|
class BinData::BasePrimitive < ::BinData::Base
|
|
def <=>(other); end
|
|
def assign(val); end
|
|
def clear?; end
|
|
def do_num_bytes; end
|
|
def do_read(io); end
|
|
def do_read_with_hook(io); end
|
|
def do_write(io); end
|
|
def eql?(other); end
|
|
def hash; end
|
|
def initialize_instance; end
|
|
def initialize_shared_instance; end
|
|
def method_missing(symbol, *args, &block); end
|
|
def respond_to?(symbol, include_private = T.unsafe(nil)); end
|
|
def snapshot; end
|
|
def trace_value; end
|
|
def value; end
|
|
def value=(val); end
|
|
|
|
private
|
|
|
|
def _value; end
|
|
def read_and_return_value(io); end
|
|
def sensible_default; end
|
|
def value_to_binary_string(val); end
|
|
|
|
class << self
|
|
def bit_aligned; end
|
|
def inherited(subclass); end
|
|
def turn_off_tracing; end
|
|
def turn_on_tracing; end
|
|
end
|
|
end
|
|
|
|
module BinData::BasePrimitive::AssertPlugin
|
|
def assert!; end
|
|
def assign(val); end
|
|
def do_read(io); end
|
|
end
|
|
|
|
module BinData::BasePrimitive::AssertedValuePlugin
|
|
def _value; end
|
|
def assert!; end
|
|
def assert_value(current_value); end
|
|
def assign(val); end
|
|
def do_read(io); end
|
|
end
|
|
|
|
module BinData::BasePrimitive::InitialValuePlugin
|
|
def _value; end
|
|
end
|
|
|
|
module BinData::BasePrimitive::ValuePlugin
|
|
def _value; end
|
|
def assign(val); end
|
|
end
|
|
|
|
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
|
|
|
|
module BinData::BitAligned
|
|
def bit_aligned?; end
|
|
def do_num_bytes; end
|
|
def do_write(io); end
|
|
def read_and_return_value(io); end
|
|
end
|
|
|
|
class BinData::BitAligned::BitAlignedIO
|
|
def initialize(io); end
|
|
|
|
def readbytes(n); end
|
|
end
|
|
|
|
module BinData::BitField
|
|
class << self
|
|
def create_clamp_code(nbits, signed); end
|
|
def create_do_num_bytes_code(nbits); end
|
|
def create_dynamic_clamp_code(signed); end
|
|
def create_fixed_clamp_code(nbits, signed); end
|
|
def create_int2uint_code(nbits, signed); end
|
|
def create_nbits_code(nbits); end
|
|
def create_params_code(nbits); end
|
|
def create_uint2int_code(nbits, signed); end
|
|
def define_class(name, nbits, endian, signed = T.unsafe(nil)); end
|
|
def define_methods(bit_class, nbits, endian, signed); end
|
|
end
|
|
end
|
|
|
|
module BinData::BitFieldFactory
|
|
def const_missing(name); end
|
|
end
|
|
|
|
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
|
|
|
|
class BinData::Buffer < ::BinData::Base
|
|
extend(::BinData::DSLMixin)
|
|
|
|
def assign(val); end
|
|
def clear?; end
|
|
def do_num_bytes; end
|
|
def do_read(io); end
|
|
def do_write(io); end
|
|
def initialize_instance; end
|
|
def method_missing(symbol, *args, &block); end
|
|
def raw_num_bytes; end
|
|
def respond_to?(symbol, include_private = T.unsafe(nil)); end
|
|
def snapshot; end
|
|
end
|
|
|
|
class BinData::BufferArgProcessor < ::BinData::BaseArgProcessor
|
|
include(::BinData::MultiFieldArgSeparator)
|
|
|
|
def sanitize_parameters!(obj_class, params); end
|
|
end
|
|
|
|
module BinData::ByteAlignPlugin
|
|
def align_obj?(obj); end
|
|
def bytes_to_align(obj, rel_offset); end
|
|
def do_read(io); end
|
|
def do_write(io); end
|
|
def sum_num_bytes_below_index(index); end
|
|
end
|
|
|
|
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
|
|
def do_read_with_hook(io); end
|
|
def do_write(*args); end
|
|
def initialize_instance; end
|
|
def initialize_shared_instance; end
|
|
def method_missing(symbol, *args, &block); end
|
|
def respond_to?(symbol, include_private = T.unsafe(nil)); end
|
|
def selection; end
|
|
def snapshot(*args); end
|
|
def trace_selection; end
|
|
|
|
private
|
|
|
|
def current_choice; end
|
|
def instantiate_choice(selection); end
|
|
|
|
class << self
|
|
def turn_off_tracing; end
|
|
def turn_on_tracing; end
|
|
end
|
|
end
|
|
|
|
class BinData::ChoiceArgProcessor < ::BinData::BaseArgProcessor
|
|
def sanitize_parameters!(obj_class, params); end
|
|
|
|
private
|
|
|
|
def choices_as_hash(choices); end
|
|
def ensure_valid_keys(choices); end
|
|
def key_array_by_index(array); end
|
|
end
|
|
|
|
module BinData::CopyOnChangePlugin
|
|
def copy_previous_value(obj); end
|
|
def current_choice; end
|
|
def get_previous_choice(selection); end
|
|
def remember_current_selection(selection); end
|
|
end
|
|
|
|
class BinData::CountBytesRemaining < ::BinData::BasePrimitive
|
|
|
|
private
|
|
|
|
def read_and_return_value(io); end
|
|
def sensible_default; end
|
|
def value_to_binary_string(val); end
|
|
end
|
|
|
|
module BinData::DSLMixin
|
|
def dsl_parser(parser_type = T.unsafe(nil)); end
|
|
def method_missing(symbol, *args, &block); end
|
|
def to_ary; end
|
|
def to_str; end
|
|
end
|
|
|
|
class BinData::DSLMixin::DSLBigAndLittleEndianHandler
|
|
class << self
|
|
def class_with_endian(class_name, endian); end
|
|
def create_subclasses_with_endian(bnl_class); end
|
|
def delegate_field_creation(bnl_class); end
|
|
def fixup_subclass_hierarchy(bnl_class); end
|
|
def handle(bnl_class); end
|
|
def make_class_abstract(bnl_class); end
|
|
def obj_attribute(obj, attr); end
|
|
def override_new_in_class(bnl_class); end
|
|
end
|
|
end
|
|
|
|
class BinData::DSLMixin::DSLFieldParser
|
|
def initialize(hints, symbol, *args, &block); end
|
|
|
|
def name; end
|
|
def name_from_field_declaration(args); end
|
|
def params; end
|
|
def params_from_args(args); end
|
|
def params_from_block(&block); end
|
|
def params_from_field_declaration(args, &block); end
|
|
def type; end
|
|
end
|
|
|
|
class BinData::DSLMixin::DSLFieldValidator
|
|
def initialize(the_class, parser); end
|
|
|
|
def all_or_none_names_failed?(name); end
|
|
def duplicate_name?(name); end
|
|
def ensure_valid_name(name); end
|
|
def fields; end
|
|
def malformed_name?(name); end
|
|
def must_have_a_name_failed?(name); end
|
|
def must_not_have_a_name_failed?(name); end
|
|
def name_is_reserved?(name); end
|
|
def name_shadows_method?(name); end
|
|
def option?(opt); end
|
|
def validate_field(name); end
|
|
end
|
|
|
|
class BinData::DSLMixin::DSLParser
|
|
def initialize(the_class, parser_type); end
|
|
|
|
def dsl_params; end
|
|
def endian(endian = T.unsafe(nil)); end
|
|
def fields; end
|
|
def hide(*args); end
|
|
def method_missing(*args, &block); end
|
|
def parser_type; end
|
|
def search_prefix(*args); end
|
|
|
|
private
|
|
|
|
def append_field(type, name, params); end
|
|
def dsl_raise(exception, msg); end
|
|
def ensure_hints; end
|
|
def fields?; end
|
|
def hints; end
|
|
def option?(opt); end
|
|
def parent_attribute(attr, default = T.unsafe(nil)); end
|
|
def parent_fields; end
|
|
def parse_and_append_field(*args, &block); end
|
|
def parser_abilities; end
|
|
def set_endian(endian); end
|
|
def to_choice_params(key); end
|
|
def to_object_params(key); end
|
|
def to_struct_params(*unused); end
|
|
def valid_endian?(endian); end
|
|
end
|
|
|
|
class BinData::DelayedIO < ::BinData::Base
|
|
extend(::BinData::DSLMixin)
|
|
|
|
def abs_offset; end
|
|
def abs_offset=(offset); end
|
|
def assign(val); end
|
|
def clear?; end
|
|
def do_num_bytes; end
|
|
def do_read(io); end
|
|
def do_write(io); end
|
|
def initialize_instance; end
|
|
def method_missing(symbol, *args, &block); end
|
|
def num_bytes; end
|
|
def read_now!; end
|
|
def rel_offset; end
|
|
def respond_to?(symbol, include_private = T.unsafe(nil)); end
|
|
def snapshot; end
|
|
def write_now!; end
|
|
end
|
|
|
|
class BinData::DelayedIoArgProcessor < ::BinData::BaseArgProcessor
|
|
include(::BinData::MultiFieldArgSeparator)
|
|
|
|
def sanitize_parameters!(obj_class, params); end
|
|
end
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
module BinData::FloatingPoint
|
|
class << self
|
|
def create_num_bytes_code(precision); end
|
|
def create_read_code(precision, endian); end
|
|
def create_to_binary_s_code(precision, endian); end
|
|
def define_methods(float_class, precision, endian); end
|
|
end
|
|
end
|
|
|
|
module BinData::Framework
|
|
def assign(val); end
|
|
def bit_aligned?; end
|
|
def clear?; end
|
|
def debug_name_of(child); end
|
|
def offset_of(child); end
|
|
def snapshot; end
|
|
|
|
protected
|
|
|
|
def do_num_bytes; end
|
|
def do_read(io); end
|
|
def do_write(io); end
|
|
def initialize_instance; end
|
|
def initialize_shared_instance; end
|
|
end
|
|
|
|
module BinData::IO
|
|
class << self
|
|
def create_string_io(str = T.unsafe(nil)); end
|
|
end
|
|
end
|
|
|
|
module BinData::IO::Common
|
|
def initialize(io); end
|
|
|
|
|
|
private
|
|
|
|
def buffer_limited_n(n); end
|
|
def seek(n); end
|
|
def seekable?; end
|
|
def with_buffer_common(n); end
|
|
end
|
|
|
|
module BinData::IO::Common::SeekableStream
|
|
def num_bytes_remaining; end
|
|
def with_readahead; end
|
|
|
|
private
|
|
|
|
def offset_raw; end
|
|
def read_raw(n); end
|
|
def seek_raw(n); end
|
|
def stream_init; end
|
|
def write_raw(data); end
|
|
end
|
|
|
|
module BinData::IO::Common::UnSeekableStream
|
|
def num_bytes_remaining; end
|
|
def offset_raw; end
|
|
def with_readahead; end
|
|
|
|
private
|
|
|
|
def read_raw(n); end
|
|
def read_raw_with_readahead(n); end
|
|
def seek_raw(n); end
|
|
def stream_init; end
|
|
def write_raw(data); end
|
|
end
|
|
|
|
class BinData::IO::Read
|
|
include(::BinData::IO::Common)
|
|
|
|
def initialize(io); end
|
|
|
|
def offset; end
|
|
def read_all_bytes; end
|
|
def readbits(nbits, endian); end
|
|
def readbytes(n); end
|
|
def reset_read_bits; end
|
|
def seekbytes(n); end
|
|
def with_buffer(n); end
|
|
|
|
private
|
|
|
|
def accumulate_big_endian_bits; end
|
|
def accumulate_little_endian_bits; end
|
|
def mask(nbits); end
|
|
def read(n = T.unsafe(nil)); end
|
|
def read_big_endian_bits(nbits); end
|
|
def read_little_endian_bits(nbits); end
|
|
end
|
|
|
|
class BinData::IO::Write
|
|
include(::BinData::IO::Common)
|
|
|
|
def initialize(io); end
|
|
|
|
def flush; end
|
|
def flushbits; end
|
|
def offset; end
|
|
def seekbytes(n); end
|
|
def with_buffer(n); end
|
|
def writebits(val, nbits, endian); end
|
|
def writebytes(str); end
|
|
|
|
private
|
|
|
|
def mask(nbits); end
|
|
def write(data); end
|
|
def write_big_endian_bits(val, nbits); end
|
|
def write_little_endian_bits(val, nbits); end
|
|
end
|
|
|
|
module BinData::InitialLengthPlugin
|
|
def do_read(io); end
|
|
def elements; end
|
|
end
|
|
|
|
module BinData::Int
|
|
class << self
|
|
def define_class(name, nbits, endian, signed); end
|
|
def define_methods(int_class, nbits, endian, signed); end
|
|
|
|
private
|
|
|
|
def bits_per_word(nbits); end
|
|
def create_clamp_code(nbits, signed); end
|
|
def create_int2uint_code(nbits); end
|
|
def create_raw_read_code(nbits, endian, signed); end
|
|
def create_read_assemble_code(nbits, endian, signed); end
|
|
def create_read_code(nbits, endian, signed); end
|
|
def create_read_unpack_code(nbits, endian, signed); end
|
|
def create_to_binary_s_code(nbits, endian, signed); end
|
|
def create_uint2int_code(nbits); end
|
|
def need_signed_conversion_code?(nbits, signed); end
|
|
def pack_directive(nbits, endian, signed); end
|
|
def val_as_packed_words(nbits, endian, signed); end
|
|
end
|
|
end
|
|
|
|
class BinData::Int32be < ::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
|
|
|
|
class BinData::Int32le < ::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
|
|
|
|
class BinData::Int64be < ::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
|
|
|
|
class BinData::Int64le < ::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
|
|
|
|
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
|
|
|
|
module BinData::IntFactory
|
|
def const_missing(name); end
|
|
end
|
|
|
|
class BinData::LazyEvaluator
|
|
def initialize(obj); end
|
|
|
|
def index; end
|
|
def lazy_eval(val, overrides = T.unsafe(nil)); end
|
|
def method_missing(symbol, *args); end
|
|
def parent; end
|
|
|
|
private
|
|
|
|
def callable?(obj); end
|
|
def eval_symbol_in_parent_context(symbol, args); end
|
|
def recursively_eval(val, args); end
|
|
def resolve_symbol_in_parent_context(symbol, args); end
|
|
end
|
|
|
|
module BinData::MultiFieldArgSeparator
|
|
def field_names_in_parameters?(obj_class, parameters); end
|
|
def parameters_is_value?(obj_class, value, parameters); end
|
|
def separate_args(obj_class, obj_args); end
|
|
end
|
|
|
|
class BinData::Primitive < ::BinData::BasePrimitive
|
|
extend(::BinData::DSLMixin)
|
|
|
|
def assign(val); end
|
|
def debug_name_of(child); end
|
|
def do_num_bytes; end
|
|
def do_write(io); end
|
|
def initialize_instance; end
|
|
def method_missing(symbol, *args, &block); end
|
|
def respond_to?(symbol, include_private = T.unsafe(nil)); end
|
|
|
|
private
|
|
|
|
def get; end
|
|
def read_and_return_value(io); end
|
|
def sensible_default; end
|
|
def set(v); end
|
|
|
|
class << self
|
|
def bit_aligned; end
|
|
end
|
|
end
|
|
|
|
class BinData::PrimitiveArgProcessor < ::BinData::BaseArgProcessor
|
|
def sanitize_parameters!(obj_class, params); end
|
|
end
|
|
|
|
module BinData::ReadUntilEOFPlugin
|
|
def do_read(io); end
|
|
end
|
|
|
|
module BinData::ReadUntilPlugin
|
|
def do_read(io); end
|
|
end
|
|
|
|
class BinData::Record < ::BinData::Struct
|
|
extend(::BinData::DSLMixin)
|
|
|
|
class << self
|
|
def inherited(subclass); end
|
|
end
|
|
end
|
|
|
|
class BinData::RecordArgProcessor < ::BinData::StructArgProcessor
|
|
include(::BinData::MultiFieldArgSeparator)
|
|
|
|
def sanitize_parameters!(obj_class, params); end
|
|
end
|
|
|
|
module BinData::RegisterNamePlugin
|
|
def initialize_shared_instance; end
|
|
|
|
class << self
|
|
def included(base); end
|
|
end
|
|
end
|
|
|
|
BinData::RegisteredClasses = T.let(T.unsafe(nil), BinData::Registry)
|
|
|
|
class BinData::Registry
|
|
def initialize; end
|
|
|
|
def lookup(name, hints = T.unsafe(nil)); end
|
|
def register(name, class_to_register); end
|
|
def underscore_name(name); end
|
|
def unregister(name); end
|
|
|
|
private
|
|
|
|
def name_with_endian(name, endian); end
|
|
def name_with_prefix(name, prefix); end
|
|
def normalize_name(name, hints); end
|
|
def register_dynamic_class(name); end
|
|
def registered?(name); end
|
|
def warn_if_name_is_already_registered(name, class_to_register); end
|
|
end
|
|
|
|
class BinData::Rest < ::BinData::BasePrimitive
|
|
|
|
private
|
|
|
|
def read_and_return_value(io); end
|
|
def sensible_default; end
|
|
def value_to_binary_string(val); end
|
|
end
|
|
|
|
class BinData::ResumeByteAlignment < ::BinData::Base
|
|
def assign(val); end
|
|
def clear?; end
|
|
def do_num_bytes; end
|
|
def do_read(io); end
|
|
def do_write(io); end
|
|
def snapshot; end
|
|
end
|
|
|
|
class BinData::SanitizedBigEndian < ::BinData::SanitizedParameter
|
|
def endian; end
|
|
end
|
|
|
|
class BinData::SanitizedChoices < ::BinData::SanitizedParameter
|
|
def initialize(choices, hints); end
|
|
|
|
def [](key); end
|
|
end
|
|
|
|
class BinData::SanitizedField < ::BinData::SanitizedParameter
|
|
def initialize(name, field_type, field_params, hints); end
|
|
|
|
def has_parameter?(param); end
|
|
def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
|
|
def name; end
|
|
def name_as_sym; end
|
|
def prototype; end
|
|
end
|
|
|
|
class BinData::SanitizedFields < ::BinData::SanitizedParameter
|
|
include(::Enumerable)
|
|
|
|
def initialize(hints, base_fields = T.unsafe(nil)); end
|
|
|
|
def [](idx); end
|
|
def add_field(type, name, params); end
|
|
def all_field_names_blank?; end
|
|
def any_field_has_parameter?(parameter); end
|
|
def each(&block); end
|
|
def empty?; end
|
|
def field_name?(name); end
|
|
def field_names; end
|
|
def length; end
|
|
def no_field_names_blank?; end
|
|
def raw_fields; end
|
|
end
|
|
|
|
class BinData::SanitizedLittleEndian < ::BinData::SanitizedParameter
|
|
def endian; end
|
|
end
|
|
|
|
class BinData::SanitizedParameter
|
|
end
|
|
|
|
class BinData::SanitizedParameters < ::Hash
|
|
def initialize(parameters, the_class, hints); end
|
|
|
|
def create_sanitized_params(params, the_class); end
|
|
def has_at_least_one_of?(*keys); end
|
|
def has_parameter?(_); end
|
|
def hints; end
|
|
def must_be_integer(*keys); end
|
|
def rename_parameter(old_key, new_key); end
|
|
def sanitize(key, &block); end
|
|
def sanitize_choices(key, &block); end
|
|
def sanitize_endian(key); end
|
|
def sanitize_fields(key, &block); end
|
|
def sanitize_object_prototype(key); end
|
|
def warn_replacement_parameter(bad_key, suggested_key); end
|
|
|
|
private
|
|
|
|
def create_sanitized_choices(choices); end
|
|
def create_sanitized_endian(endian); end
|
|
def create_sanitized_fields; end
|
|
def create_sanitized_object_prototype(obj_type, obj_params); end
|
|
def ensure_mandatory_parameters_exist; end
|
|
def ensure_mutual_exclusion_of_parameters; end
|
|
def ensure_no_nil_values; end
|
|
def merge_default_parameters!; end
|
|
def needs_sanitizing?(key); end
|
|
def sanitize!; end
|
|
|
|
class << self
|
|
def sanitize(parameters, the_class); end
|
|
end
|
|
end
|
|
|
|
BinData::SanitizedParameters::BIG_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedBigEndian)
|
|
|
|
BinData::SanitizedParameters::LITTLE_ENDIAN = T.let(T.unsafe(nil), BinData::SanitizedLittleEndian)
|
|
|
|
class BinData::SanitizedPrototype < ::BinData::SanitizedParameter
|
|
def initialize(obj_type, obj_params, hints); end
|
|
|
|
def has_parameter?(param); end
|
|
def instantiate(value = T.unsafe(nil), parent = T.unsafe(nil)); end
|
|
end
|
|
|
|
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
|
|
|
|
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
|
|
|
|
class BinData::Skip < ::BinData::BasePrimitive
|
|
def initialize_shared_instance; end
|
|
|
|
private
|
|
|
|
def read_and_return_value(io); end
|
|
def sensible_default; end
|
|
def value_to_binary_string(val); end
|
|
end
|
|
|
|
class BinData::SkipArgProcessor < ::BinData::BaseArgProcessor
|
|
def sanitize_parameters!(obj_class, params); end
|
|
end
|
|
|
|
module BinData::SkipLengthPlugin
|
|
def skip_length; end
|
|
end
|
|
|
|
module BinData::SkipToAbsOffsetPlugin
|
|
def skip_length; end
|
|
end
|
|
|
|
module BinData::SkipUntilValidPlugin
|
|
def read_and_return_value(io); end
|
|
def skip_length; end
|
|
end
|
|
|
|
class BinData::String < ::BinData::BasePrimitive
|
|
def assign(val); end
|
|
def initialize_shared_instance; end
|
|
def snapshot; end
|
|
|
|
private
|
|
|
|
def clamp_to_length(str); end
|
|
def read_and_return_value(io); end
|
|
def sensible_default; end
|
|
def trim_padding(str); end
|
|
def value_to_binary_string(val); end
|
|
end
|
|
|
|
class BinData::StringArgProcessor < ::BinData::BaseArgProcessor
|
|
def sanitize_parameters!(obj_class, params); end
|
|
|
|
private
|
|
|
|
def sanitized_pad_byte(byte); end
|
|
end
|
|
|
|
class BinData::Stringz < ::BinData::BasePrimitive
|
|
def assign(val); end
|
|
def snapshot; end
|
|
|
|
private
|
|
|
|
def append_zero_byte_if_needed!(str); end
|
|
def read_and_return_value(io); end
|
|
def sensible_default; end
|
|
def trim_and_zero_terminate(str); end
|
|
def trim_to!(str, max_length = T.unsafe(nil)); end
|
|
def truncate_after_first_zero_byte!(str); end
|
|
def value_to_binary_string(val); end
|
|
end
|
|
|
|
class BinData::Struct < ::BinData::Base
|
|
def [](key); end
|
|
def []=(key, value); end
|
|
def assign(val); end
|
|
def clear; end
|
|
def clear?; end
|
|
def debug_name_of(child); end
|
|
def do_num_bytes; end
|
|
def do_read(io); end
|
|
def do_write(io); end
|
|
def each_pair; end
|
|
def field_names(include_hidden = T.unsafe(nil)); end
|
|
def has_key?(key); end
|
|
def initialize_instance; end
|
|
def initialize_shared_instance; end
|
|
def key?(key); end
|
|
def offset_of(child); end
|
|
def snapshot; end
|
|
|
|
private
|
|
|
|
def as_stringified_hash(val); end
|
|
def assign_fields(val); end
|
|
def base_field_name(name); end
|
|
def define_field_accessors; end
|
|
def define_field_accessors_for(name, index); end
|
|
def find_index_of(obj); end
|
|
def find_obj_for_name(name); end
|
|
def include_obj?(obj); end
|
|
def instantiate_all_objs; end
|
|
def instantiate_obj_at(index); end
|
|
def sum_num_bytes_below_index(index); end
|
|
def sum_num_bytes_for_all_fields; end
|
|
|
|
class << self
|
|
def inherited(subclass); end
|
|
end
|
|
end
|
|
|
|
BinData::Struct::RESERVED = T.let(T.unsafe(nil), Hash)
|
|
|
|
class BinData::Struct::Snapshot < ::Hash
|
|
def []=(key, value); end
|
|
def method_missing(symbol, *args); end
|
|
def respond_to?(symbol, include_private = T.unsafe(nil)); end
|
|
end
|
|
|
|
class BinData::StructArgProcessor < ::BinData::BaseArgProcessor
|
|
def sanitize_parameters!(obj_class, params); end
|
|
|
|
private
|
|
|
|
def ensure_field_names_are_valid(obj_class, field_names); end
|
|
def hidden_field_names(hidden); end
|
|
def sanitize_endian(params); end
|
|
def sanitize_fields(obj_class, params); end
|
|
def sanitize_hide(params); end
|
|
def sanitize_search_prefix(params); end
|
|
def sanitized_field_names(sanitized_fields); end
|
|
end
|
|
|
|
class BinData::Tracer
|
|
def initialize(io); end
|
|
|
|
def trace(msg); end
|
|
def trace_obj(obj_name, val); end
|
|
end
|
|
|
|
class BinData::Uint16be < ::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
|
|
|
|
class BinData::Uint16le < ::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
|
|
|
|
class BinData::Uint32be < ::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
|
|
|
|
class BinData::Uint32le < ::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
|
|
|
|
class BinData::Uint64be < ::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
|
|
|
|
class BinData::Uint64le < ::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
|
|
|
|
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
|
|
|
|
class BinData::Uint8Array < ::BinData::BasePrimitive
|
|
|
|
private
|
|
|
|
def read_and_return_value(io); end
|
|
def sensible_default; end
|
|
def value_to_binary_string(val); end
|
|
end
|
|
|
|
class BinData::Uint8ArrayArgProcessor < ::BinData::BaseArgProcessor
|
|
def sanitize_parameters!(obj_class, params); end
|
|
end
|
|
|
|
class BinData::UnRegisteredTypeError < ::StandardError
|
|
end
|
|
|
|
BinData::VERSION = T.let(T.unsafe(nil), String)
|
|
|
|
class BinData::ValidityError < ::StandardError
|
|
end
|
|
|
|
class BinData::Virtual < ::BinData::BasePrimitive
|
|
def do_num_bytes; end
|
|
def do_read(io); end
|
|
def do_write(io); end
|
|
def sensible_default; end
|
|
end
|
|
|
|
module BinData::WarnNoReadLengthPlugin
|
|
def read_and_return_value(io); end
|
|
end
|