slow_blink 0.0.6 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (62) hide show
  1. checksums.yaml +4 -4
  2. data/ext/slow_blink/ext_schema_parser/lexer.c +2793 -839
  3. data/ext/slow_blink/ext_schema_parser/lexer.h +14 -137
  4. data/ext/slow_blink/ext_schema_parser/parser.c +616 -670
  5. data/ext/slow_blink/ext_schema_parser/parser.h +6 -4
  6. data/ext/slow_blink/message/ext_compact_encoder/blink_compact.c +642 -0
  7. data/ext/slow_blink/message/ext_compact_encoder/blink_compact.h +411 -0
  8. data/ext/slow_blink/message/ext_compact_encoder/blink_debug.h +46 -0
  9. data/ext/slow_blink/message/ext_compact_encoder/blink_stream.c +314 -0
  10. data/ext/slow_blink/message/ext_compact_encoder/blink_stream.h +185 -0
  11. data/ext/slow_blink/message/ext_compact_encoder/ext_compact_encoder.c +382 -269
  12. data/lib/slow_blink/definition.rb +18 -53
  13. data/lib/slow_blink/dynamic_group.rb +8 -0
  14. data/lib/slow_blink/enum.rb +101 -0
  15. data/lib/slow_blink/field.rb +63 -33
  16. data/lib/slow_blink/generate_c/model.rb +89 -0
  17. data/lib/slow_blink/group.rb +119 -100
  18. data/lib/slow_blink/message/binary.rb +3 -4
  19. data/lib/slow_blink/message/boolean.rb +3 -4
  20. data/lib/slow_blink/message/date.rb +3 -4
  21. data/lib/slow_blink/message/decimal.rb +3 -5
  22. data/lib/slow_blink/message/{enumeration.rb → enum.rb} +17 -17
  23. data/lib/slow_blink/message/field.rb +77 -27
  24. data/lib/slow_blink/message/fixed.rb +5 -21
  25. data/lib/slow_blink/message/floating_point.rb +3 -4
  26. data/lib/slow_blink/message/group.rb +90 -161
  27. data/lib/slow_blink/message/integer.rb +24 -32
  28. data/lib/slow_blink/message/model.rb +50 -110
  29. data/lib/slow_blink/message/string.rb +3 -4
  30. data/lib/slow_blink/message/time.rb +5 -5
  31. data/lib/slow_blink/message/time_of_day.rb +5 -12
  32. data/lib/slow_blink/ref.rb +22 -71
  33. data/lib/slow_blink/schema.rb +64 -85
  34. data/lib/slow_blink/schema_buffer.rb +1 -4
  35. data/lib/slow_blink/static_group.rb +37 -0
  36. data/lib/slow_blink/string.rb +4 -5
  37. data/lib/slow_blink/sym.rb +8 -28
  38. data/lib/slow_blink/type.rb +10 -19
  39. data/lib/slow_blink/version.rb +1 -1
  40. data/lib/slow_blink.rb +1 -0
  41. data/test/tc_compact_encoder.rb +114 -147
  42. data/test/tc_inputs.rb +2 -4
  43. data/test/tc_model_string.rb +29 -0
  44. data/test/tc_schema_new.rb +212 -0
  45. metadata +17 -26
  46. data/ext/slow_blink/ext_schema_parser/common.h +0 -27
  47. data/ext/slow_blink/message/ext_compact_encoder/compact_encoder.c +0 -258
  48. data/ext/slow_blink/message/ext_compact_encoder/compact_encoder.h +0 -92
  49. data/lib/slow_blink/annotatable.rb +0 -48
  50. data/lib/slow_blink/annotation.rb +0 -47
  51. data/lib/slow_blink/enumeration.rb +0 -90
  52. data/lib/slow_blink/incremental_annotation.rb +0 -151
  53. data/lib/slow_blink/log.rb +0 -51
  54. data/lib/slow_blink/message/sequence.rb +0 -98
  55. data/lib/slow_blink/name_with_id.rb +0 -49
  56. data/lib/slow_blink/namespace.rb +0 -143
  57. data/lib/slow_blink/sequence.rb +0 -57
  58. data/test/tc_field.rb +0 -94
  59. data/test/tc_group.rb +0 -114
  60. data/test/tc_incr_annote.rb +0 -22
  61. data/test/tc_namespace.rb +0 -8
  62. data/test/tc_types.rb +0 -218
@@ -25,31 +25,19 @@
25
25
  #include <ruby.h>
26
26
  #include <stdint.h>
27
27
  #include <stdbool.h>
28
+ #include <stddef.h>
28
29
  #include <assert.h>
29
30
 
30
- #include "compact_encoder.h"
31
+ #include "blink_compact.h"
32
+ #include "blink_stream.h"
31
33
 
32
34
  /* defines ************************************************************/
33
35
 
34
-
35
- #define MIN8 -128L
36
- #define MAX8 127L
37
- #define MIN16 -32768L
38
- #define MAX16 32767L
39
- #define MIN32 -2147483648L
40
- #define MAX32 2147483647L
41
- #define MIN64 -9223372036854775808L
42
- #define MAX64 9223372036854775807L
43
- #define MAXU8 0xffUL
44
- #define MAXU16 0xffffUL
45
- #define MAXU32 0xffffffffUL
46
- #define MAXU64 0xffffffffffffffffUL
47
-
48
36
  /* static function prototypes *****************************************/
49
37
 
50
38
  static VALUE putNull(VALUE self);
51
39
 
52
- static VALUE putPresent(VALUE self, VALUE val);
40
+ static VALUE putPresent(VALUE self);
53
41
  static VALUE getPresent(VALUE self);
54
42
 
55
43
  static VALUE putU8(VALUE self, VALUE val);
@@ -66,7 +54,6 @@ static VALUE putBool(VALUE self, VALUE val);
66
54
  static VALUE putBinary(VALUE self, VALUE val);
67
55
  static VALUE putString(VALUE self, VALUE val);
68
56
  static VALUE putFixed(VALUE self, VALUE val);
69
- static VALUE putFixedOptional(VALUE self, VALUE val);
70
57
 
71
58
  static VALUE getU8(VALUE self);
72
59
  static VALUE getU16(VALUE self);
@@ -82,10 +69,9 @@ static VALUE getBool(VALUE self);
82
69
  static VALUE getBinary(VALUE self);
83
70
  static VALUE getString(VALUE self);
84
71
  static VALUE getFixed(VALUE self, VALUE size);
85
- static VALUE getFixedOptional(VALUE self, VALUE size);
86
72
 
87
- static VALUE putInt(VALUE self, VALUE val, int64_t min, int64_t max, bool isSigned);
88
- static VALUE getInt(VALUE input, int64_t min, int64_t max, bool isSigned);
73
+ static bool myRead(void *state, void *buf, size_t nbyte);
74
+ static bool myWrite(void *state, const void *buf, size_t nbyte);
89
75
 
90
76
  /* static variables ***************************************************/
91
77
 
@@ -96,7 +82,10 @@ static VALUE cWeakError4;
96
82
  static VALUE cWeakError9;
97
83
  static VALUE cWeakError11;
98
84
 
99
-
85
+ static struct blink_stream_user cUserStream = {
86
+ .read = myRead,
87
+ .write = myWrite
88
+ };
100
89
 
101
90
  /* functions **********************************************************/
102
91
 
@@ -104,9 +93,11 @@ void Init_ext_compact_encoder(void)
104
93
  {
105
94
  VALUE cSlowBlink;
106
95
  VALUE cMessage;
96
+ VALUE cStringIO;
107
97
 
108
98
  cSlowBlink = rb_define_module("SlowBlink");
109
99
  cMessage = rb_const_get(cSlowBlink, rb_intern("Message"));
100
+ cStringIO = rb_const_get(rb_cObject, rb_intern("StringIO"));
110
101
 
111
102
  cStrongError1 = rb_const_get(cMessage, rb_intern("StrongError1"));
112
103
 
@@ -117,7 +108,7 @@ void Init_ext_compact_encoder(void)
117
108
 
118
109
  rb_define_method(rb_cString, "putNull", putNull, 0);
119
110
  rb_define_method(rb_cString, "putPresent", putPresent, 0);
120
- rb_define_method(rb_cString, "getPresent", getPresent, 0);
111
+ rb_define_method(cStringIO, "getPresent", getPresent, 0);
121
112
 
122
113
  rb_define_method(rb_cString, "putU8", putU8, 1);
123
114
  rb_define_method(rb_cString, "putU16", putU16, 1);
@@ -135,121 +126,270 @@ void Init_ext_compact_encoder(void)
135
126
  rb_define_method(rb_cString, "putString", putString, 1);
136
127
  rb_define_method(rb_cString, "putBinary", putBinary, 1);
137
128
  rb_define_method(rb_cString, "putFixed", putFixed, 1);
138
- rb_define_method(rb_cString, "putFixedOptional", putFixedOptional, 1);
139
129
 
140
- rb_define_method(rb_cString, "getU8!", getU8, 0);
141
- rb_define_method(rb_cString, "getU16!", getU16, 0);
142
- rb_define_method(rb_cString, "getU32!", getU32, 0);
143
- rb_define_method(rb_cString, "getU64!", getU64, 0);
144
- rb_define_method(rb_cString, "getI8!", getI8, 0);
145
- rb_define_method(rb_cString, "getI16!", getI16, 0);
146
- rb_define_method(rb_cString, "getI32!", getI32, 0);
147
- rb_define_method(rb_cString, "getI64!", getI64, 0);
130
+ rb_define_method(cStringIO, "getU8", getU8, 0);
131
+ rb_define_method(cStringIO, "getU16", getU16, 0);
132
+ rb_define_method(cStringIO, "getU32", getU32, 0);
133
+ rb_define_method(cStringIO, "getU64", getU64, 0);
134
+ rb_define_method(cStringIO, "getI8", getI8, 0);
135
+ rb_define_method(cStringIO, "getI16", getI16, 0);
136
+ rb_define_method(cStringIO, "getI32", getI32, 0);
137
+ rb_define_method(cStringIO, "getI64", getI64, 0);
148
138
 
149
- rb_define_method(rb_cString, "getF64!", getF64, 0);
139
+ rb_define_method(cStringIO, "getF64", getF64, 0);
150
140
 
151
- rb_define_method(rb_cString, "getBool!", getBool, 0);
141
+ rb_define_method(cStringIO, "getBool", getBool, 0);
152
142
 
153
- rb_define_method(rb_cString, "getString!", getString, 0);
154
- rb_define_method(rb_cString, "getBinary!", getBinary, 0);
155
- rb_define_method(rb_cString, "getFixed!", getFixed, 1);
156
- rb_define_method(rb_cString, "getFixedOptional!", getFixedOptional, 1);
143
+ rb_define_method(cStringIO, "getString", getString, 0);
144
+ rb_define_method(cStringIO, "getBinary", getBinary, 0);
145
+ rb_define_method(cStringIO, "getFixed", getFixed, 1);
157
146
  }
158
147
 
159
148
  /* static functions ***************************************************/
160
149
 
150
+ static bool myRead(void *state, void *buf, size_t nbyte)
151
+ {
152
+ bool retval = false;
153
+ VALUE stringIO = *(VALUE *)state;
154
+
155
+ VALUE out = rb_funcall(stringIO, rb_intern("read"), 1, SIZET2NUM(nbyte));
156
+
157
+ if((size_t)RSTRING_LEN(out) == nbyte){
158
+
159
+ (void)memcpy(buf, RSTRING_PTR(out), (size_t)RSTRING_LEN(out));
160
+ retval = true;
161
+ }
162
+ else{
163
+
164
+ rb_raise(cStrongError1, "S1: Group encoding ends prematurely");
165
+ }
166
+
167
+ return retval;
168
+ }
169
+
170
+ static bool myWrite(void *state, const void *buf, size_t nbyte)
171
+ {
172
+ return rb_str_buf_cat(*(VALUE *)state, buf, nbyte);
173
+ }
174
+
161
175
  static VALUE putU8(VALUE self, VALUE val)
162
176
  {
163
- return putInt(self, val, 0, MAXU8, false);
177
+ if(val == Qnil){
178
+
179
+ (void)putNull(self);
180
+ }
181
+ else{
182
+ if(NUM2ULL(val) <= UINT8_MAX){
183
+
184
+ struct blink_stream stream;
185
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
186
+ (void)BLINK_Compact_encodeU8((uint8_t)NUM2ULL(val), &stream);
187
+ }
188
+ else{
189
+
190
+ rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
191
+ }
192
+ }
193
+
194
+ return self;
164
195
  }
165
196
  static VALUE putU16(VALUE self, VALUE val)
166
197
  {
167
- return putInt(self, val, 0, MAXU16, false);
198
+ if(val == Qnil){
199
+
200
+ (void)putNull(self);
201
+ }
202
+ else{
203
+ if(NUM2ULL(val) <= UINT16_MAX){
204
+
205
+ struct blink_stream stream;
206
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
207
+ (void)BLINK_Compact_encodeU16((uint16_t)NUM2ULL(val), &stream);
208
+ }
209
+ else{
210
+
211
+ rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
212
+ }
213
+ }
214
+
215
+ return self;
168
216
  }
169
217
  static VALUE putU32(VALUE self, VALUE val)
170
218
  {
171
- return putInt(self, val, 0, MAXU32, false);
219
+ if(val == Qnil){
220
+
221
+ (void)putNull(self);
222
+ }
223
+ else{
224
+ if(NUM2ULL(val) <= UINT32_MAX){
225
+
226
+ struct blink_stream stream;
227
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
228
+ (void)BLINK_Compact_encodeU32((uint32_t)NUM2ULL(val), &stream);
229
+ }
230
+ else{
231
+
232
+ rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
233
+ }
234
+ }
235
+
236
+ return self;
172
237
  }
173
238
  static VALUE putU64(VALUE self, VALUE val)
174
239
  {
175
- return putInt(self, val, 0, MAXU64, false);
240
+ if(val == Qnil){
241
+
242
+ (void)putNull(self);
243
+ }
244
+ else{
245
+ if(NUM2ULL(val) <= UINT64_MAX){
246
+
247
+ struct blink_stream stream;
248
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
249
+ (void)BLINK_Compact_encodeU64(NUM2ULL(val), &stream);
250
+ }
251
+ else{
252
+
253
+ rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
254
+ }
255
+ }
256
+
257
+ return self;
176
258
  }
177
259
  static VALUE putI8(VALUE self, VALUE val)
178
260
  {
179
- return putInt(self, val, MIN8, MAX8, true);
261
+ if(val == Qnil){
262
+
263
+ (void)putNull(self);
264
+ }
265
+ else{
266
+ if((NUM2LL(val) >= INT8_MIN) && (NUM2LL(val) <= INT8_MAX)){
267
+
268
+ struct blink_stream stream;
269
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
270
+ (void)BLINK_Compact_encodeI8((int8_t)NUM2LL(val), &stream);
271
+ }
272
+ else{
273
+
274
+ rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
275
+ }
276
+ }
277
+ return self;
180
278
  }
181
279
  static VALUE putI16(VALUE self, VALUE val)
182
280
  {
183
- return putInt(self, val, MIN16, MAX16, true);
281
+ if(val == Qnil){
282
+
283
+ (void)putNull(self);
284
+ }
285
+ else{
286
+
287
+ if((NUM2LL(val) >= INT16_MIN) && (NUM2LL(val) <= INT16_MAX)){
288
+
289
+ struct blink_stream stream;
290
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
291
+ (void)BLINK_Compact_encodeI16((int16_t)NUM2LL(val), &stream);
292
+ }
293
+ else{
294
+
295
+ rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
296
+ }
297
+ }
298
+ return self;
184
299
  }
185
300
  static VALUE putI32(VALUE self, VALUE val)
186
301
  {
187
- return putInt(self, val, MIN32, MAX32, true);
302
+ if(val == Qnil){
303
+
304
+ (void)putNull(self);
305
+ }
306
+ else{
307
+
308
+ if((NUM2LL(val) >= INT32_MIN) && (NUM2LL(val) <= INT32_MAX)){
309
+
310
+ struct blink_stream stream;
311
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
312
+ (void)BLINK_Compact_encodeI32((int32_t)NUM2LL(val), &stream);
313
+ }
314
+ else{
315
+
316
+ rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
317
+ }
318
+ }
319
+ return self;
188
320
  }
189
321
  static VALUE putI64(VALUE self, VALUE val)
190
322
  {
191
- return putInt(self, val, MIN64, MAX64, true);
192
- }
193
- static VALUE putF64(VALUE self, VALUE val)
194
- {
195
- VALUE retval;
196
- uint8_t out[10U];
197
-
198
323
  if(val == Qnil){
199
324
 
200
- retval = putNull(self);
325
+ (void)putNull(self);
201
326
  }
202
327
  else{
203
328
 
204
- double value = NUM2DBL(val);
205
- retval = rb_str_buf_cat(self, (const char *)out, BLINK_putVLC(*((uint64_t *)(&value)), false, out, sizeof(out)));
329
+ if((NUM2LL(val) >= INT64_MIN) && (NUM2LL(val) <= INT64_MAX)){
330
+
331
+ struct blink_stream stream;
332
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
333
+ (void)BLINK_Compact_encodeI64(NUM2LL(val), &stream);
334
+ }
335
+ else{
336
+
337
+ rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
338
+ }
206
339
  }
340
+ return self;
341
+ }
342
+ static VALUE putF64(VALUE self, VALUE val)
343
+ {
344
+ if(val == Qnil){
207
345
 
208
- return retval;
346
+ (void)putNull(self);
347
+ }
348
+ else{
349
+
350
+ struct blink_stream stream;
351
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
352
+ (void)BLINK_Compact_encodeF64(NUM2DBL(val), &stream);
353
+ }
354
+ return self;
209
355
  }
210
356
 
211
357
  static VALUE putBool(VALUE self, VALUE val)
212
358
  {
213
- VALUE retval;
214
-
215
359
  if(val == Qnil){
216
360
 
217
- retval = putNull(self);
361
+ (void)putNull(self);
218
362
  }
219
363
  else{
220
364
 
221
- retval = putU8(self, (val == Qfalse) ? INT2FIX(0) : INT2FIX(1));
365
+ struct blink_stream stream;
366
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
367
+ (void)BLINK_Compact_encodeBool((val == Qfalse) ? false : true, &stream);
222
368
  }
223
-
224
- return retval;
369
+ return self;
225
370
  }
226
371
 
227
372
  static VALUE putNull(VALUE self)
228
373
  {
229
- uint8_t str[] = {0xc0};
230
- return rb_str_buf_cat(self, (const char *)str, sizeof(str));
374
+ struct blink_stream stream;
375
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
376
+ (void)BLINK_Compact_encodeNull(&stream);
377
+ return self;
231
378
  }
232
379
 
233
- static VALUE putPresent(VALUE self, VALUE val)
380
+ static VALUE putPresent(VALUE self)
234
381
  {
235
- VALUE retval;
236
-
237
- if(val == Qfalse){
238
-
239
- retval = putNull(self);
240
- }
241
- else{
242
-
243
- uint8_t str[] = {0x1};
244
- retval = rb_str_buf_cat(self, (const char *)str, sizeof(str));
245
- }
246
-
247
- return retval;
382
+ struct blink_stream stream;
383
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
384
+ (void)BLINK_Compact_encodePresent(&stream);
385
+ return self;
248
386
  }
249
387
 
250
388
  static VALUE putBinary(VALUE self, VALUE val)
251
- {
252
- VALUE retval;
389
+ {
390
+ VALUE retval = Qnil;
391
+ struct blink_stream stream;
392
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
253
393
 
254
394
  if(val == Qnil){
255
395
 
@@ -257,11 +397,17 @@ static VALUE putBinary(VALUE self, VALUE val)
257
397
  }
258
398
  else{
259
399
 
260
- retval = putU32(self, UINT2NUM(RSTRING_LEN(val)));
261
- retval = rb_str_concat(retval, val);
400
+ if(RSTRING_LEN(val) <= UINT32_MAX){
401
+
402
+ (void)BLINK_Compact_encodeU32((uint32_t)RSTRING_LEN(val), &stream);
403
+ retval = rb_str_buf_cat(self, RSTRING_PTR(val), RSTRING_LEN(val));
404
+ }
405
+ else{
262
406
 
407
+ rb_raise(rb_eRangeError, "String is too long");
408
+ }
263
409
  }
264
-
410
+
265
411
  return retval;
266
412
  }
267
413
 
@@ -271,300 +417,267 @@ static VALUE putString(VALUE self, VALUE val)
271
417
  return putBinary(self, val);
272
418
  }
273
419
 
274
- static VALUE putFixedOptional(VALUE self, VALUE val)
420
+ static VALUE putFixed(VALUE self, VALUE val)
275
421
  {
276
- VALUE retval;
422
+ return rb_str_buf_cat(self, RSTRING_PTR(val), (size_t)RSTRING_LEN(val));
423
+ }
277
424
 
278
- if(val == Qnil){
425
+ static VALUE getU8(VALUE self)
426
+ {
427
+ VALUE retval = Qnil;
428
+ uint8_t val;
429
+ bool isNull;
430
+ struct blink_stream stream;
431
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
432
+ if(BLINK_Compact_decodeU8(&stream, &val, &isNull)){
279
433
 
280
- retval = putNull(self);
434
+ retval = (isNull) ? Qnil : UINT2NUM(val);
281
435
  }
282
436
  else{
283
437
 
284
- uint8_t str[] = {0x01};
285
- retval = rb_str_new((const char *)str, sizeof(str));
286
- rb_str_concat(retval, val);
438
+ rb_raise(rb_eRangeError, "out of range");
287
439
  }
288
-
440
+
289
441
  return retval;
290
442
  }
291
443
 
292
- static VALUE putFixed(VALUE self, VALUE val)
293
- {
294
- return rb_str_dup(val);
295
- }
296
-
297
- static VALUE putInt(VALUE self, VALUE val, int64_t min, int64_t max, bool isSigned)
444
+ static VALUE getU16(VALUE self)
298
445
  {
299
- uint8_t out[10U];
300
- VALUE retval;
301
-
302
- if(val == Qnil){
446
+ VALUE retval = Qnil;
447
+ uint16_t val;
448
+ bool isNull;
449
+ struct blink_stream stream;
450
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
451
+ if(BLINK_Compact_decodeU16(&stream, &val, &isNull)){
303
452
 
304
- retval = putNull(self);
453
+ retval = (isNull) ? Qnil : UINT2NUM(val);
305
454
  }
306
455
  else{
307
456
 
308
- if(isSigned){
309
-
310
- int64_t value = NUM2LL(val);
311
-
312
- if((value < min) || (value > max)){
313
-
314
- rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
315
- }
316
-
317
- retval = rb_str_buf_cat(self, (const char *)out, BLINK_putVLC((uint64_t)value, true, out, sizeof(out)));
318
- }
319
- else{
320
-
321
- uint64_t value = NUM2ULL(val);
322
-
323
- if(value > (uint64_t)max){
324
-
325
- rb_raise(rb_eRangeError, "Input exceeds allowable range of type");
326
- }
327
-
328
- retval = rb_str_buf_cat(self, (const char *)out, BLINK_putVLC(value, false, out, sizeof(out)));
329
- }
457
+ rb_raise(rb_eRangeError, "out of range");
330
458
  }
331
-
459
+
332
460
  return retval;
333
461
  }
334
462
 
335
- static VALUE getU8(VALUE self)
463
+ static VALUE getU32(VALUE self)
336
464
  {
337
- return getInt(self, 0, MAXU8, false);
338
- }
465
+ VALUE retval = Qnil;
466
+ uint32_t val;
467
+ bool isNull;
468
+ struct blink_stream stream;
469
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
470
+ if(BLINK_Compact_decodeU32(&stream, &val, &isNull)){
339
471
 
340
- static VALUE getU16(VALUE self)
341
- {
342
- return getInt(self, 0, MAXU16, false);
343
- }
472
+ retval = (isNull) ? Qnil : UINT2NUM(val);
473
+ }
474
+ else{
344
475
 
345
- static VALUE getU32(VALUE self)
346
- {
347
- return getInt(self, 0, MAXU32, false);
476
+ rb_raise(rb_eRangeError, "out of range");
477
+ }
478
+
479
+ return retval;
348
480
  }
349
481
 
350
482
  static VALUE getU64(VALUE self)
351
483
  {
352
- return getInt(self, 0, MAXU64, false);
353
- }
484
+ VALUE retval = Qnil;
485
+ uint64_t val;
486
+ bool isNull;
487
+ struct blink_stream stream;
488
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
489
+ if(BLINK_Compact_decodeU64(&stream, &val, &isNull)){
354
490
 
355
- static VALUE getI8(VALUE self)
356
- {
357
- return getInt(self, MIN8, MAX8, true);
358
- }
491
+ retval = (isNull) ? Qnil : ULL2NUM(val);
492
+ }
493
+ else{
359
494
 
360
- static VALUE getI16(VALUE self)
361
- {
362
- return getInt(self, MIN16, MAX16, true);
495
+ rb_raise(rb_eRangeError, "out of range");
496
+ }
497
+
498
+ return retval;
363
499
  }
364
500
 
365
- static VALUE getI32(VALUE self)
501
+ static VALUE getI8(VALUE self)
366
502
  {
367
- return getInt(self, MIN32, MAX32, true);
368
- }
503
+ VALUE retval = Qnil;
504
+ int8_t val;
505
+ bool isNull;
506
+ struct blink_stream stream;
507
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
508
+ if(BLINK_Compact_decodeI8(&stream, &val, &isNull)){
369
509
 
370
- static VALUE getI64(VALUE self)
371
- {
372
- return getInt(self, MIN64, MAX64, true);
510
+ retval = (isNull) ? Qnil : INT2NUM(val);
511
+ }
512
+ else{
513
+
514
+ rb_raise(rb_eRangeError, "out of range");
515
+ }
516
+
517
+ return retval;
373
518
  }
374
519
 
375
- static VALUE getF64(VALUE self)
520
+ static VALUE getI16(VALUE self)
376
521
  {
377
- bool isNull;
378
- double out;
379
- uint32_t ret;
380
522
  VALUE retval = Qnil;
523
+ int16_t val;
524
+ bool isNull;
525
+ struct blink_stream stream;
526
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
527
+ if(BLINK_Compact_decodeI16(&stream, &val, &isNull)){
381
528
 
382
- ret = BLINK_getVLC((const uint8_t *)RSTRING_PTR(self), RSTRING_LEN(self), false, (uint64_t *)&out, &isNull);
383
-
384
- if(ret > 0){
385
-
386
- rb_str_drop_bytes(self, ret);
387
- if(!isNull){
388
-
389
- retval = rb_float_new(out);
390
- }
529
+ retval = (isNull) ? Qnil : INT2NUM(val);
391
530
  }
392
531
  else{
393
532
 
394
- rb_raise(cStrongError1, "S1: Group encoding ends prematurely");
533
+ rb_raise(rb_eRangeError, "out of range");
395
534
  }
396
-
535
+
397
536
  return retval;
398
537
  }
399
538
 
400
- static VALUE getPresent(VALUE self)
539
+ static VALUE getI32(VALUE self)
401
540
  {
402
- VALUE retval = getInt(self, 0, 1, false);
403
-
404
- if(retval != Qnil){
541
+ VALUE retval = Qnil;
542
+ int32_t val;
543
+ bool isNull;
544
+ struct blink_stream stream;
545
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
546
+ if(BLINK_Compact_decodeI32(&stream, &val, &isNull)){
405
547
 
406
- retval = Qtrue;
548
+ retval = (isNull) ? Qnil : INT2NUM(val);
407
549
  }
550
+ else{
408
551
 
409
- return retval;
552
+ rb_raise(rb_eRangeError, "out of range");
553
+ }
554
+
555
+ return retval;
410
556
  }
411
557
 
412
- static VALUE getBool(VALUE self)
558
+ static VALUE getI64(VALUE self)
413
559
  {
414
- VALUE retval;
415
- VALUE value = getInt(self, 0, MAXU8, false);
416
-
417
- if(value == UINT2NUM(0)){
418
-
419
- retval = Qfalse;
420
- }
421
- else if(value == UINT2NUM(1)){
560
+ VALUE retval = Qnil;
561
+ int64_t val;
562
+ bool isNull;
563
+ struct blink_stream stream;
564
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
565
+ if(BLINK_Compact_decodeI64(&stream, &val, &isNull)){
422
566
 
423
- retval = Qtrue;
567
+ retval = (isNull) ? Qnil : LL2NUM(val);
424
568
  }
425
569
  else{
426
570
 
427
- rb_raise(cWeakError11, "W11: Decoded value is not 0x00 or 0x01");
571
+ rb_raise(rb_eRangeError, "out of range");
428
572
  }
429
-
573
+
430
574
  return retval;
431
575
  }
432
576
 
433
- static VALUE getBinary(VALUE self)
577
+ static VALUE getF64(VALUE self)
434
578
  {
435
579
  VALUE retval = Qnil;
436
- VALUE size = getInt(self, 0, MAXU32, false);
437
-
438
- if(size != Qnil){
439
-
440
- if(NUM2UINT(size) > RSTRING_LEN(self)){
441
- rb_raise(cStrongError1, "S1: Group encoding ends prematurely");
442
- }
580
+ double val;
581
+ bool isNull;
582
+ struct blink_stream stream;
583
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
584
+ if(BLINK_Compact_decodeF64(&stream, &val, &isNull)){
443
585
 
444
- retval = rb_str_substr(self, 0, NUM2UINT(size));
445
- rb_str_drop_bytes(self, NUM2UINT(size));
586
+ retval = (isNull) ? Qnil : DBL2NUM(val);
446
587
  }
588
+ else{
447
589
 
590
+ rb_raise(rb_eRangeError, "out of range");
591
+ }
592
+
448
593
  return retval;
449
594
  }
450
595
 
451
- static VALUE getString(VALUE self)
596
+ static VALUE getPresent(VALUE self)
452
597
  {
453
- VALUE retval = getBinary(self);
454
-
455
- if(retval != Qnil){
598
+ VALUE retval = Qnil;
599
+ bool val;
600
+ struct blink_stream stream;
601
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
602
+ if(BLINK_Compact_decodePresent(&stream, &val)){
456
603
 
457
- //todo: test UTF8 encoding here
604
+ retval = (val) ? Qtrue : Qfalse;
458
605
  }
606
+ else{
459
607
 
608
+ rb_raise(rb_eRangeError, "out of range");
609
+ }
610
+
460
611
  return retval;
461
612
  }
462
613
 
463
- static VALUE getFixed(VALUE self, VALUE size)
614
+ static VALUE getBool(VALUE self)
464
615
  {
465
- VALUE retval;
466
-
467
- if(NUM2UINT(size) > RSTRING_LEN(self)){
616
+ VALUE retval = Qnil;
617
+ bool val;
618
+ bool isNull;
619
+ struct blink_stream stream;
620
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
621
+ if(BLINK_Compact_decodeBool(&stream, &val, &isNull)){
468
622
 
469
- rb_raise(cStrongError1, "S1: Group encoding ends prematurely");
623
+ retval = (val) ? Qtrue : Qfalse;
470
624
  }
625
+ else{
471
626
 
472
- retval = rb_str_substr(self, 0, NUM2UINT(size));
473
- rb_str_drop_bytes(self, NUM2UINT(size));
474
-
627
+ rb_raise(cWeakError11, "out of range");
628
+ }
629
+
475
630
  return retval;
476
631
  }
477
632
 
478
- static VALUE getFixedOptional(VALUE self, VALUE size)
633
+ static VALUE getBinary(VALUE self)
479
634
  {
480
635
  VALUE retval = Qnil;
481
- uint32_t ret;
636
+ uint32_t size;
482
637
  bool isNull;
483
- uint64_t present;
638
+ struct blink_stream stream;
639
+ (void)BLINK_Stream_initUser(&stream, &self, cUserStream);
484
640
 
485
- ret = BLINK_getVLC((const uint8_t *)RSTRING_PTR(self), RSTRING_LEN(self), false, (uint64_t *)&present, &isNull);
641
+ if(BLINK_Compact_decodeU32(&stream, &size, &isNull)){
486
642
 
487
- if(ret > 0){
488
-
489
- rb_str_drop_bytes(self, ret);
490
-
491
- if(isNull){
492
-
493
- retval = Qnil;
494
- }
495
- else if(present == 0x01){
643
+ if(!isNull){
496
644
 
497
- retval = rb_str_substr(self, 0, NUM2UINT(size));
645
+ retval = rb_funcall(self, rb_intern("read"), 1, UINT2NUM(size));
498
646
 
499
- if(RSTRING_LEN(retval) != NUM2UINT(size)){
647
+ if((retval == Qnil) || ((uint32_t)NUM2UINT(rb_funcall(retval, rb_intern("size"), 0)) != size)){
500
648
 
501
649
  rb_raise(cStrongError1, "S1: Group encoding ends prematurely");
502
650
  }
503
-
504
- rb_str_drop_bytes(self, NUM2UINT(size));
505
651
  }
506
- else{
507
-
508
- rb_raise(cWeakError9, "W9: Presence flag is not 0xC0 or 0x01");
509
- }
510
652
  }
511
653
  else{
512
654
 
513
- rb_raise(cStrongError1, "S1: Group encoding ends prematurely");
655
+ rb_raise(rb_eRangeError, "out of range");
514
656
  }
515
-
657
+
516
658
  return retval;
517
659
  }
518
660
 
519
- static VALUE getInt(VALUE input, int64_t min, int64_t max, bool isSigned)
661
+ static VALUE getString(VALUE self)
520
662
  {
521
- bool isNull;
522
- uint64_t out;
523
- VALUE retval = Qnil;
524
- uint32_t ret;
525
-
526
- ret = BLINK_getVLC((const uint8_t *)RSTRING_PTR(input), RSTRING_LEN(input), isSigned, &out, &isNull);
527
-
528
- if(ret > 0){
529
-
530
- rb_str_drop_bytes(input, ret);
531
-
532
- if(!isNull){
533
-
534
- if(isSigned){
535
-
536
- if(((int64_t)out < min) || ((int64_t)out > max)){
537
-
538
- rb_raise(cWeakError3, "W3: Decoded value overflows range");
539
- }
540
-
541
- if(BLINK_getSizeSigned((int64_t)out) != ret){
542
-
543
- rb_raise(cWeakError4, "W4: VLC entity contains more bytes than needed to express full width of type");
544
- }
663
+ VALUE retval = getBinary(self);
545
664
 
546
- retval = LL2NUM((int64_t)out);
547
- }
548
- else{
549
-
550
- if(out > (uint64_t)max){
665
+ if(retval != Qnil){
551
666
 
552
- rb_raise(cWeakError3, "W3: Decoded value overflows range");
553
- }
667
+ //todo: test UTF8 encoding here
668
+ }
554
669
 
555
- if(BLINK_getSizeUnsigned(out) != ret){
670
+ return retval;
671
+ }
556
672
 
557
- rb_raise(cWeakError4, "W4: VLC entity contains more bytes than needed to express full width of type");
558
- }
673
+ static VALUE getFixed(VALUE self, VALUE size)
674
+ {
675
+ VALUE retval = rb_funcall(self, rb_intern("read"), 1, UINT2NUM(size));
559
676
 
560
- retval = ULL2NUM(out);
561
- }
562
- }
563
- }
564
- else{
677
+ if((retval == Qnil) || ((uint32_t)NUM2UINT(rb_funcall(retval, rb_intern("size"), 0)) != NUM2UINT(size))){
565
678
 
566
679
  rb_raise(cStrongError1, "S1: Group encoding ends prematurely");
567
680
  }
568
681
 
569
- return retval;
682
+ return retval;
570
683
  }