Module: Borsh::Readable

Included in:
Buffer
Defined in:
lib/borsh/readable.rb

Instance Method Summary collapse

Instance Method Details

#read_array(element_type, count) ⇒ Object 



111
112
113
 
# File 'lib/borsh/readable.rb', line 111

def read_array(element_type, count)
  Array.new(count) { self.read_object(element_type) }
end

#read_bool ⇒ Object 



45
46
47
 
# File 'lib/borsh/readable.rb', line 45

def read_bool
  self.read_u8 == 1
end

#read_enum(variants) ⇒ Object 



157
158
159
160
161
162
 
# File 'lib/borsh/readable.rb', line 157

def read_enum(variants)
  ordinal = self.read_u8
  type = variants.fetch(ordinal)
  value = self.read_object(type)
  [ordinal, value]
end

#read_f32 ⇒ Object 



99
100
101
 
# File 'lib/borsh/readable.rb', line 99

def read_f32
  self.read(4).unpack('e').first
end

#read_f64 ⇒ Object 



103
104
105
 
# File 'lib/borsh/readable.rb', line 103

def read_f64
  self.read(8).unpack('E').first
end

#read_i128 ⇒ Object 



89
90
91
92
93
94
95
96
97
 
# File 'lib/borsh/readable.rb', line 89

def read_i128
  n = self.read_u128
  # Handle two's complement for negative numbers:
  if n >= (1 << 127)
    n - (1 << 128)
  else
    n
  end
end

#read_i16 ⇒ Object 



77
78
79
 
# File 'lib/borsh/readable.rb', line 77

def read_i16
  self.read(2).unpack('s').first
end

#read_i32 ⇒ Object 



81
82
83
 
# File 'lib/borsh/readable.rb', line 81

def read_i32
  self.read(4).unpack('l<').first
end

#read_i64 ⇒ Object 



85
86
87
 
# File 'lib/borsh/readable.rb', line 85

def read_i64
  self.read(8).unpack('q<').first
end

#read_i8 ⇒ Object 



73
74
75
 
# File 'lib/borsh/readable.rb', line 73

def read_i8
  self.read(1).unpack('c').first
end

#read_map(key_type, value_type) ⇒ Object Also known as: read_hash 



130
131
132
133
134
135
136
137
138
139
 
# File 'lib/borsh/readable.rb', line 130

def read_map(key_type, value_type)
  count = self.read_u32
  result = {}
  count.times do
    key = self.read_object(key_type)
    value = self.read_object(value_type)
    result[key] = value
  end
  result
end

#read_object(type) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/borsh/readable.rb', line 6

def read_object(type)
  case type
    when :nil     then self.read_unit
    when :bool    then self.read_bool
    when :u8      then self.read_u8
    when :u16     then self.read_u16
    when :u32     then self.read_u32
    when :u64     then self.read_u64
    when :u128    then self.read_u128
    when :i8      then self.read_i8
    when :i16     then self.read_i16
    when :i32     then self.read_i32
    when :i64     then self.read_i64
    when :i128    then self.read_i128
    when :f32     then self.read_f32
    when :f64     then self.read_f64
    when :string  then self.read_string
    when Array
      case type.first
        when :array   then self.read_array(type[1], type[2])
        when :vector  then self.read_vector(type[1])
        when :map     then self.read_map(type[1], type[2])
        when :set     then self.read_set(type[1])
        when :option  then self.read_option(type[1])
        when :result  then self.read_result(type[1], type[2])
        else raise "unsupported array type specifier: #{type.inspect}"
      end
    when Class
      raise "unsupported class type: #{type}" unless type < Struct
      self.read_struct(type)
    else raise "unsupported type specifier: #{type.inspect}"
  end
end

#read_option(element_type) ⇒ Object 



142
143
144
145
146
147
148
 
# File 'lib/borsh/readable.rb', line 142

def read_option(element_type)
  if self.read_bool
    self.read_object(element_type)
  else
    nil
  end
end

#read_result(ok_type, err_type = ok_type) ⇒ Object 



150
151
152
153
154
155
 
# File 'lib/borsh/readable.rb', line 150

def read_result(ok_type, err_type = ok_type)
  ok = self.read_bool
  type = ok ? ok_type : err_type
  value = self.read_object(type)
  [ok, value]
end

#read_set(element_type) ⇒ Object 



121
122
123
124
125
126
127
128
 
# File 'lib/borsh/readable.rb', line 121

def read_set(element_type)
  count = self.read_u32
  result = Set.new
  count.times do
    result << self.read_object(element_type)
  end
  result
end

#read_string ⇒ Object 



107
108
109
 
# File 'lib/borsh/readable.rb', line 107

def read_string
  self.read(self.read_u32).force_encoding('UTF-8')
end

#read_struct(struct_class) ⇒ Object 



164
165
166
167
168
169
170
 
# File 'lib/borsh/readable.rb', line 164

def read_struct(struct_class)
  values = struct_class.members.map { |member|
    type = struct_class::MEMBER_TYPES.fetch(member)
    self.read_object(type)
  }
  struct_class.new(*values)
end

#read_u128 ⇒ Object 



65
66
67
68
69
70
71
 
# File 'lib/borsh/readable.rb', line 65

def read_u128
  # Read two 64-bit integers (little-endian):
  lower = self.read_u64
  upper = self.read_u64
  # Combine into a 128-bit number:
  (upper << 64) | lower
end

#read_u16 ⇒ Object 



53
54
55
 
# File 'lib/borsh/readable.rb', line 53

def read_u16
  self.read(2).unpack('v').first
end

#read_u32 ⇒ Object 



57
58
59
 
# File 'lib/borsh/readable.rb', line 57

def read_u32
  self.read(4).unpack('V').first
end

#read_u64 ⇒ Object 



61
62
63
 
# File 'lib/borsh/readable.rb', line 61

def read_u64
  self.read(8).unpack('Q<').first
end

#read_u8 ⇒ Object 



49
50
51
 
# File 'lib/borsh/readable.rb', line 49

def read_u8
  self.read(1).unpack('C').first
end

#read_unit ⇒ Object Also known as: read_nil 



40
41
42
 
# File 'lib/borsh/readable.rb', line 40

def read_unit
  nil
end

#read_vector(element_type) ⇒ Object Also known as: read_vec 



115
116
117
118
 
# File 'lib/borsh/readable.rb', line 115

def read_vector(element_type)
  count = self.read_u32
  self.read_array(element_type, count)
end