Class: MemoryIO::Types::Type

Inherits:
Object
  • Object
show all
Defined in:
lib/memory_io/types/type.rb

Overview

The base class, all descendents of this class would be consider as a valid 'type'.

Direct Known Subclasses

CPP::String, Clang::CStr

Constant Summary collapse

SIZE_T =

The size of size_t. i.e. sizeof(size_t).

8

Class Method Summary collapse

Class Method Details

.find(symbol) ⇒ {Symbol => Object}

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Find the subclass of MemoryIO::Types::Type by symbol.

Parameters:

  • symbol (Symbol)

    Symbol that has been registered in register.

Returns:

  • ({Symbol => Object})

    The object that registered in register.

See Also:


88
89
90
# File 'lib/memory_io/types/type.rb', line 88

def find(symbol)
  @map[symbol]
end

.keep_pos(stream, pos: nil) {|stream| ... } ⇒ Object

Yield a block and resume the position of stream.

Examples:

s = StringIO.new('1234')
Type.keep_pos(s, pos: 2) { |s| s.read(2) }
#=> '34'
s.pos
#=> 0

Parameters:

  • stream (#pos, #pos=)

    Stream.

  • pos (Integer) (defaults to: nil)

    Move stream's position to pos before invoke the block.

Yield Parameters:

  • stream (#pos, #pos=)

    Same as parameter stream.

Yield Returns:

  • (Object)

    The returned object will be returned by this method.

Returns:

  • (Object)

    Returns the object returned by block.


69
70
71
72
73
74
75
# File 'lib/memory_io/types/type.rb', line 69

def keep_pos(stream, pos: nil)
  org = stream.pos
  stream.pos = pos if pos
  ret = yield stream
  stream.pos = org
  ret
end

.read(_stream) ⇒ Object

This method is abstract.

Raises:

  • (NotImplementedError)

138
139
# File 'lib/memory_io/types/type.rb', line 138

def read(_stream) raise NotImplementedError
end

.read_size_t(stream) ⇒ Integer

Read SIZE_T bytes and cast to a little endian unsigned integer.

Examples:

s = StringIO.new("\xEF\xBE\xAD\xDExV4\x00")
Type.read_size_t(s).to_s(16)
#=> '345678deadbeef'

Parameters:

  • stream (#read)

    Stream to read.

Returns:

  • (Integer)

    Result.


26
27
28
# File 'lib/memory_io/types/type.rb', line 26

def read_size_t(stream)
  MemoryIO::Util.unpack(stream.read(SIZE_T))
end

.register(object, option = {}) ⇒ Array<Symbol>

Note:

If all symbols in alias have been registered, an ArgumentError will be raised. However, if at least one of aliases hasn't been used, registration will success.

Register a new type.

Examples:

Type.register(MemoryIO::Types::Clang::CStr, alias: :meow)
#=> [:'clang/c_str', :c_str, :meow]

Type.register(ModuleOne::CStr, alias: :my_class)
#=> [:'module_one/c_str', :my_class]

Type.register(AnotherClass, alias: :my_class)
# An error will be raised because the 'alias' has been registered.

Type.register(AnotherClass, alias: [:my_class, my_class2])
#=> [:another_class, :my_class2]

Parameters:

  • object (#read, #write)

    Normally, object is a descendent class of MemoryIO::Types::Type.

  • [Symbol, (Hash)

    a customizable set of options

  • [String] (Hash)

    a customizable set of options

Returns:

  • (Array<Symbol>)

    Array of symbols that can be used for finding the registered object.

See Also:


123
124
125
126
127
128
129
130
131
132
133
134
135
# File 'lib/memory_io/types/type.rb', line 123

def register(object, option = {})
  @map ||= OpenStruct.new
  aliases = Array(option[:alias])
  reg_fail = ArgumentError.new(<<-EOS.strip)
Register '#{object.inspect}' fails because another object with same name has been registered.
Specify an alias such as `register(MyClass, alias: :custom_alias_name)`.
  EOS
  raise reg_fail if aliases.any? && aliases.all? { |ali| @map[ali] }
  keys = get_keys(object).concat(aliases).uniq.reject { |k| @map[k] }
  raise reg_fail if keys.empty?
  rec = MemoryIO::Types::Record.new(object, keys, option)
  keys.each { |k| @map[k] = rec }
end

.write(_stream, _obj) ⇒ Object

This method is abstract.

Raises:

  • (NotImplementedError)

142
143
# File 'lib/memory_io/types/type.rb', line 142

def write(_stream, _obj) raise NotImplementedError
end

.write_size_t(stream, val) ⇒ void

This method returns an undefined value.

Pack val into SIZE_T bytes and write to stream.

Examples:

s = StringIO.new
Type.write_size_t(s, 0x123)
s.string
#=> "\x23\x01\x00\x00\x00\x00\x00\x00"

Parameters:

  • stream (#write)

    Stream to write.

  • val (Integer)

    Value to be written.


44
45
46
# File 'lib/memory_io/types/type.rb', line 44

def write_size_t(stream, val)
  stream.write(MemoryIO::Util.pack(val, SIZE_T))
end