Class: Majoron::AntHill::BinaryDecoder

Inherits:
DecoderBase show all
Defined in:
lib/binary_decoder.rb

Instance Method Summary collapse

Constructor Details

#initialize ⇒ BinaryDecoder

Constructor.



23
24
25
26
27
28
 
# File 'lib/binary_decoder.rb', line 23

def initialize()
  super()
  @offset = 0
  @buffer = ""

end

Instance Method Details

#append_buffer(buf) ⇒ Object 



211
212
213
 
# File 'lib/binary_decoder.rb', line 211

def append_buffer(buf)
  @buffer << buf
end

#decode_binary(size, limit = nil) ⇒ Object

Decode methods



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/binary_decoder.rb', line 179

def decode_binary(size, limit = nil)
  if @offset <= @buffer.size
    pos = 0
    value = ""
    while @offset < @buffer.size() && pos < size
      value << @buffer [ @offset ]
      @offset += 1
      pos += 1
    end

    # Check overflow
    overflow = !limit.nil? && @offset > limit
    raise sprintf(CodecErrors::DECODER_DUE_TO_LIMIT, @offset, limit) if overflow
    value
  else
    raise sprintf( CodecErrors::DECODER_INV_BINARY, @offset)
  end
end

#decode_char(limit = nil) ⇒ Object

Decode methods



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/binary_decoder.rb', line 51

def decode_char(limit = nil)
  sizeof = 1
  if @offset <= @buffer.size() - sizeof
    if RUBY_VERSION >= "1.9.0"
      value = @buffer[@offset].ord
    else
      value = @buffer[@offset]
    end
    # value = @buffer[@offset]
    @offset += sizeof

    # Check overflow
    overflow = !limit.nil? && @offset > limit
    raise sprintf(CodecErrors::DECODER_DUE_TO_LIMIT, @offset, limit) if overflow
    value
  else
    raise sprintf(CodecErrors::DECODER_INV_CHAR, @offset)
  end
end

#decode_cstring(value, limit = nil) ⇒ Object

Decode methods



140
141
142
 
# File 'lib/binary_decoder.rb', line 140

def decode_cstring(value, limit = nil)
  raise "not implemented"
end

#decode_cstring_max(maxlen, limit = nil) ⇒ Object

Decode methods



145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/binary_decoder.rb', line 145

def decode_cstring_max(maxlen, limit = nil)
  if @offset <= @buffer.size
    value = ""
    if RUBY_VERSION >= "1.9.0"
      while @offset < @buffer.size() && @buffer[@offset].ord != 0
        value << @buffer [ @offset ]
        @offset += 1

        # Check max limitation
        overmax = value.size() + 1 > maxlen
        raise sprintf(CodecErrors::DECODER_OVERFLOW_CSTRING, @offset) if overmax
      end
    else
      while @offset < @buffer.size() && @buffer[@offset] != 0
        value << @buffer [ @offset ]
        @offset += 1

        # Check max limitation
        overmax = value.size() + 1 > maxlen
        raise sprintf(CodecErrors::DECODER_OVERFLOW_CSTRING, @offset) if overmax
      end
    end
    @offset += 1

    # Check overflow
    overflow = !limit.nil? && @offset > limit
    raise sprintf(CodecErrors::DECODER_DUE_TO_LIMIT, @offset, limit) if overflow
    value
  else
    raise sprintf( CodecErrors::DECODER_INV_CSTRING, @offset)
  end
end

#decode_integer16(value, limit = nil) ⇒ Object

Decode methods



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

def decode_integer16(value, limit = nil)
  raise "not implemented"
end

#decode_integer24(value, limit = nil) ⇒ Object

Decode methods



98
99
100
 
# File 'lib/binary_decoder.rb', line 98

def decode_integer24(value, limit = nil)
  raise "not implemented"
end

#decode_integer32(value, limit = nil) ⇒ Object

Decode methods



93
94
95
 
# File 'lib/binary_decoder.rb', line 93

def decode_integer32(value, limit = nil)
  raise "not implemented"
end

#decode_uchar(limit = nil) ⇒ Object

Decode methods



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/binary_decoder.rb', line 72

def decode_uchar(limit = nil)
  sizeof = 1
  if @offset <= @buffer.size() - sizeof
    if RUBY_VERSION >= "1.9.0"
      value = @buffer[@offset].ord
    else
      value = @buffer[@offset]
    end
    # value = @buffer[@offset]
    @offset += sizeof

    # Check overflow
    overflow = !limit.nil? && @offset > limit
    raise sprintf(CodecErrors::DECODER_DUE_TO_LIMIT, @offset, limit) if overflow
    value
  else
    raise sprintf(CodecErrors::DECODER_INV_CHAR, @offset)
  end
end

#decode_unsigned16(limit = nil) ⇒ Object

Decode methods



124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/binary_decoder.rb', line 124

def decode_unsigned16(limit = nil)
  sizeof = 2
  if @offset <= @buffer.size() - sizeof
    value = @buffer[@offset..@offset+(sizeof-1)].unpack('n').first
    @offset += sizeof

    # Check overflow
    overflow = !limit.nil? && @offset > limit
    raise sprintf(CodecErrors::DECODER_DUE_TO_LIMIT, @offset, limit) if overflow
    value
  else
    raise sprintf(CodecErrors::DECODER_INV_CHAR, @offset)
  end
end

#decode_unsigned32(limit = nil) ⇒ Object

Decode methods



108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/binary_decoder.rb', line 108

def decode_unsigned32(limit = nil)
  sizeof = 4
  if @offset <= @buffer.size() - sizeof
    value = @buffer[@offset..@offset+(sizeof-1)].unpack('N').first
    @offset += sizeof

    # Check overflow
    overflow = !limit.nil? && @offset > limit
    raise sprintf(CodecErrors::DECODER_DUE_TO_LIMIT, @offset, limit) if overflow
    value
  else
    raise sprintf(CodecErrors::DECODER_INV_CHAR, @offset)
  end
end

#get_buffer ⇒ Object 



206
207
208
 
# File 'lib/binary_decoder.rb', line 206

def get_buffer()
  @buffer
end

#padding_n_bytes(bytes, limit = nil) ⇒ Object

Methods to align on n bytes



46
47
48
 
# File 'lib/binary_decoder.rb', line 46

def padding_n_bytes(bytes, limit = nil)
  raise "not implemented"
end

#reset_buffer ⇒ Object 



200
201
202
203
 
# File 'lib/binary_decoder.rb', line 200

def reset_buffer()
  @offset = 0
  @buffer = ""
end

#skip_n_bytes(bytes, limit = nil) ⇒ Object

Method to skip n bytes



31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/binary_decoder.rb', line 31

def skip_n_bytes(bytes, limit = nil)
  return if bytes == 0
  if @offset <= @buffer.size() - bytes
    @offset += bytes

    # Check overflow
    overflow = !limit.nil? && @offset > limit
    raise sprintf(CodecErrors::DECODER_DUE_TO_LIMIT, @offset, limit) if overflow
  else
    raise sprintf(CodecErrors::DECODER_INV_CHAR, @offset)
  end
end

#validate_offset(len) ⇒ Object 



216
217
218
219
 
# File 'lib/binary_decoder.rb', line 216

def validate_offset(len)
  return if @offset == len
  raise sprintf(CodecErrors::DECODER_INV_OFFSET, @offset, len)
end