bin_utils 0.0.2 → 0.0.3

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 (5) hide show
  1. data/ext/bin_utils/native.c +271 -701
  2. data/lib/bin_utils/pure_ruby.rb +188 -8
  3. data/lib/bin_utils/version.rb +1 -1
  4. data/test/benchmark.rb +171 -0
  5. metadata +4 -2
data/lib/bin_utils/pure_ruby.rb CHANGED
@@ -6,8 +6,8 @@ end
6
6
 
7
7
  module BinUtils
8
8
  # Pure Ruby implementation of bin utils.
9
- # It is provided mostly as reference implementation, but JIT enabled ruby implementations
10
- # (such as jruby and rubinius) could benefit from it.
9
+ # It is provided just reference implementation, so that I could write tests before writting
10
+ # native code. You should not expect performance from it.
11
11
  module PureRuby
12
12
  extend self
13
13
  INT32_INT32_LE = 'VV'.freeze
@@ -280,7 +280,10 @@ module BinUtils
280
280
  res
281
281
  end
282
282
 
283
+ BINARY = ::Encoding::BINARY
283
284
  def append_int8!(str, *ints)
285
+ str ||= ''.force_encoding(BINARY)
286
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
284
287
  i = 0
285
288
  sz = ints.size
286
289
  while i < sz
@@ -291,6 +294,8 @@ module BinUtils
291
294
  end
292
295
 
293
296
  def append_int16_le!(str, *ints)
297
+ str ||= ''.force_encoding(BINARY)
298
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
294
299
  i = 0
295
300
  sz = ints.size
296
301
  while i < sz
@@ -302,6 +307,8 @@ module BinUtils
302
307
  end
303
308
 
304
309
  def append_int24_le!(str, *ints)
310
+ str ||= ''.force_encoding(BINARY)
311
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
305
312
  i = 0
306
313
  sz = ints.size
307
314
  while i < sz
@@ -314,6 +321,8 @@ module BinUtils
314
321
  end
315
322
 
316
323
  def append_int32_le!(str, *ints)
324
+ str ||= ''.force_encoding(BINARY)
325
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
317
326
  i = 0
318
327
  sz = ints.size
319
328
  while i < sz
@@ -326,6 +335,8 @@ module BinUtils
326
335
  end
327
336
 
328
337
  def append_int40_le!(str, *ints)
338
+ str ||= ''.force_encoding(BINARY)
339
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
329
340
  i = 0
330
341
  sz = ints.size
331
342
  while i < sz
@@ -339,6 +350,8 @@ module BinUtils
339
350
  end
340
351
 
341
352
  def append_int48_le!(str, *ints)
353
+ str ||= ''.force_encoding(BINARY)
354
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
342
355
  i = 0
343
356
  sz = ints.size
344
357
  while i < sz
@@ -350,6 +363,8 @@ module BinUtils
350
363
  end
351
364
 
352
365
  def append_int56_le!(str, *ints)
366
+ str ||= ''.force_encoding(BINARY)
367
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
353
368
  i = 0
354
369
  sz = ints.size
355
370
  while i < sz
@@ -361,6 +376,8 @@ module BinUtils
361
376
  end
362
377
 
363
378
  def append_int64_le!(str, *ints)
379
+ str ||= ''.force_encoding(BINARY)
380
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
364
381
  i = 0
365
382
  sz = ints.size
366
383
  while i < sz
@@ -372,6 +389,8 @@ module BinUtils
372
389
  end
373
390
 
374
391
  def append_int16_be!(str, *ints)
392
+ str ||= ''.force_encoding(BINARY)
393
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
375
394
  i = 0
376
395
  sz = ints.size
377
396
  while i < sz
@@ -383,6 +402,8 @@ module BinUtils
383
402
  end
384
403
 
385
404
  def append_int24_be!(str, *ints)
405
+ str ||= ''.force_encoding(BINARY)
406
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
386
407
  i = 0
387
408
  sz = ints.size
388
409
  while i < sz
@@ -394,6 +415,8 @@ module BinUtils
394
415
  end
395
416
 
396
417
  def append_int32_be!(str, *ints)
418
+ str ||= ''.force_encoding(BINARY)
419
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
397
420
  i = 0
398
421
  sz = ints.size
399
422
  while i < sz
@@ -406,6 +429,8 @@ module BinUtils
406
429
  end
407
430
 
408
431
  def append_int40_be!(str, *ints)
432
+ str ||= ''.force_encoding(BINARY)
433
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
409
434
  i = 0
410
435
  sz = ints.size
411
436
  while i < sz
@@ -419,6 +444,8 @@ module BinUtils
419
444
  end
420
445
 
421
446
  def append_int48_be!(str, *ints)
447
+ str ||= ''.force_encoding(BINARY)
448
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
422
449
  i = 0
423
450
  sz = ints.size
424
451
  while i < sz
@@ -430,6 +457,8 @@ module BinUtils
430
457
  end
431
458
 
432
459
  def append_int56_be!(str, *ints)
460
+ str ||= ''.force_encoding(BINARY)
461
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
433
462
  i = 0
434
463
  sz = ints.size
435
464
  while i < sz
@@ -441,6 +470,8 @@ module BinUtils
441
470
  end
442
471
 
443
472
  def append_int64_be!(str, *ints)
473
+ str ||= ''.force_encoding(BINARY)
474
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
444
475
  i = 0
445
476
  sz = ints.size
446
477
  while i < sz
@@ -452,162 +483,224 @@ module BinUtils
452
483
  end
453
484
 
454
485
  def append_bersize_int8!(str, *ints)
486
+ str ||= ''.force_encoding(BINARY)
487
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
455
488
  append_ber!(str, ints.size)
456
489
  append_int8!(str, *ints)
457
490
  end
458
491
 
459
492
  def append_bersize_int16_le!(str, *ints)
493
+ str ||= ''.force_encoding(BINARY)
494
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
460
495
  append_ber!(str, ints.size * 2)
461
496
  append_int16_le!(str, *ints)
462
497
  end
463
498
 
464
499
  def append_bersize_int24_le!(str, *ints)
500
+ str ||= ''.force_encoding(BINARY)
501
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
465
502
  append_ber!(str, ints.size * 3)
466
503
  append_int24_le!(str, *ints)
467
504
  end
468
505
 
469
506
  def append_bersize_int32_le!(str, *ints)
507
+ str ||= ''.force_encoding(BINARY)
508
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
470
509
  append_ber!(str, ints.size * 4)
471
510
  append_int32_le!(str, *ints)
472
511
  end
473
512
 
474
513
  def append_bersize_int40_le!(str, *ints)
514
+ str ||= ''.force_encoding(BINARY)
515
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
475
516
  append_ber!(str, ints.size * 5)
476
517
  append_int40_le!(str, *ints)
477
518
  end
478
519
 
479
520
  def append_bersize_int48_le!(str, *ints)
521
+ str ||= ''.force_encoding(BINARY)
522
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
480
523
  append_ber!(str, ints.size * 6)
481
524
  append_int48_le!(str, *ints)
482
525
  end
483
526
 
484
527
  def append_bersize_int56_le!(str, *ints)
528
+ str ||= ''.force_encoding(BINARY)
529
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
485
530
  append_ber!(str, ints.size * 7)
486
531
  append_int56_le!(str, *ints)
487
532
  end
488
533
 
489
534
  def append_bersize_int64_le!(str, *ints)
535
+ str ||= ''.force_encoding(BINARY)
536
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
490
537
  append_ber!(str, ints.size * 8)
491
538
  append_int64_le!(str, *ints)
492
539
  end
493
540
 
494
541
  def append_bersize_int16_be!(str, *ints)
542
+ str ||= ''.force_encoding(BINARY)
543
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
495
544
  append_ber!(str, ints.size * 2)
496
545
  append_int16_be!(str, *ints)
497
546
  end
498
547
 
499
548
  def append_bersize_int24_be!(str, *ints)
549
+ str ||= ''.force_encoding(BINARY)
550
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
500
551
  append_ber!(str, ints.size * 3)
501
552
  append_int24_be!(str, *ints)
502
553
  end
503
554
 
504
555
  def append_bersize_int32_be!(str, *ints)
556
+ str ||= ''.force_encoding(BINARY)
557
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
505
558
  append_ber!(str, ints.size * 4)
506
559
  append_int32_be!(str, *ints)
507
560
  end
508
561
 
509
562
  def append_bersize_int40_be!(str, *ints)
563
+ str ||= ''.force_encoding(BINARY)
564
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
510
565
  append_ber!(str, ints.size * 5)
511
566
  append_int40_be!(str, *ints)
512
567
  end
513
568
 
514
569
  def append_bersize_int48_be!(str, *ints)
570
+ str ||= ''.force_encoding(BINARY)
571
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
515
572
  append_ber!(str, ints.size * 6)
516
573
  append_int48_be!(str, *ints)
517
574
  end
518
575
 
519
576
  def append_bersize_int56_be!(str, *ints)
577
+ str ||= ''.force_encoding(BINARY)
578
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
520
579
  append_ber!(str, ints.size * 7)
521
580
  append_int56_be!(str, *ints)
522
581
  end
523
582
 
524
583
  def append_bersize_int64_be!(str, *ints)
584
+ str ||= ''.force_encoding(BINARY)
585
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
525
586
  append_ber!(str, ints.size * 8)
526
587
  append_int64_be!(str, *ints)
527
588
  end
528
589
 
529
590
  def append_int32size_int8_le!(str, *ints)
591
+ str ||= ''.force_encoding(BINARY)
592
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
530
593
  append_int32_le!(str, ints.size)
531
594
  append_int8!(str, *ints)
532
595
  end
533
596
 
534
597
  def append_int32size_int16_le!(str, *ints)
598
+ str ||= ''.force_encoding(BINARY)
599
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
535
600
  append_int32_le!(str, ints.size * 2)
536
601
  append_int16_le!(str, *ints)
537
602
  end
538
603
 
539
604
  def append_int32size_int24_le!(str, *ints)
605
+ str ||= ''.force_encoding(BINARY)
606
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
540
607
  append_int32_le!(str, ints.size * 3)
541
608
  append_int24_le!(str, *ints)
542
609
  end
543
610
 
544
611
  def append_int32size_int32_le!(str, *ints)
612
+ str ||= ''.force_encoding(BINARY)
613
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
545
614
  append_int32_le!(str, ints.size * 4)
546
615
  append_int32_le!(str, *ints)
547
616
  end
548
617
 
549
618
  def append_int32size_int40_le!(str, *ints)
619
+ str ||= ''.force_encoding(BINARY)
620
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
550
621
  append_int32_le!(str, ints.size * 5)
551
622
  append_int40_le!(str, *ints)
552
623
  end
553
624
 
554
625
  def append_int32size_int48_le!(str, *ints)
626
+ str ||= ''.force_encoding(BINARY)
627
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
555
628
  append_int32_le!(str, ints.size * 6)
556
629
  append_int48_le!(str, *ints)
557
630
  end
558
631
 
559
632
  def append_int32size_int56_le!(str, *ints)
633
+ str ||= ''.force_encoding(BINARY)
634
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
560
635
  append_int32_le!(str, ints.size * 7)
561
636
  append_int56_le!(str, *ints)
562
637
  end
563
638
 
564
639
  def append_int32size_int64_le!(str, *ints)
640
+ str ||= ''.force_encoding(BINARY)
641
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
565
642
  append_int32_le!(str, ints.size * 8)
566
643
  append_int64_le!(str, *ints)
567
644
  end
568
645
 
569
646
  def append_int32size_int8_be!(str, *ints)
647
+ str ||= ''.force_encoding(BINARY)
648
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
570
649
  append_int32_be!(str, ints.size)
571
650
  append_int8!(str, *ints)
572
651
  end
573
652
 
574
653
  def append_int32size_int16_be!(str, *ints)
654
+ str ||= ''.force_encoding(BINARY)
655
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
575
656
  append_int32_be!(str, ints.size * 2)
576
657
  append_int16_be!(str, *ints)
577
658
  end
578
659
 
579
660
  def append_int32size_int24_be!(str, *ints)
661
+ str ||= ''.force_encoding(BINARY)
662
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
580
663
  append_int32_be!(str, ints.size * 3)
581
664
  append_int24_be!(str, *ints)
582
665
  end
583
666
 
584
667
  def append_int32size_int32_be!(str, *ints)
668
+ str ||= ''.force_encoding(BINARY)
669
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
585
670
  append_int32_be!(str, ints.size * 4)
586
671
  append_int32_be!(str, *ints)
587
672
  end
588
673
 
589
674
  def append_int32size_int40_be!(str, *ints)
675
+ str ||= ''.force_encoding(BINARY)
676
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
590
677
  append_int32_be!(str, ints.size * 5)
591
678
  append_int40_be!(str, *ints)
592
679
  end
593
680
 
594
681
  def append_int32size_int48_be!(str, *ints)
682
+ str ||= ''.force_encoding(BINARY)
683
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
595
684
  append_int32_be!(str, ints.size * 6)
596
685
  append_int48_be!(str, *ints)
597
686
  end
598
687
 
599
688
  def append_int32size_int56_be!(str, *ints)
689
+ str ||= ''.force_encoding(BINARY)
690
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
600
691
  append_int32_be!(str, ints.size * 7)
601
692
  append_int56_be!(str, *ints)
602
693
  end
603
694
 
604
695
  def append_int32size_int64_be!(str, *ints)
696
+ str ||= ''.force_encoding(BINARY)
697
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
605
698
  append_int32_be!(str, ints.size * 8)
606
699
  append_int64_be!(str, *ints)
607
700
  end
608
701
 
609
- BINARY = ::Encoding::BINARY
610
702
  def append_string!(data, str)
703
+ data ||= ''.force_encoding(BINARY)
611
704
  data << str.dup.force_encoding(BINARY)
612
705
  end
613
706
 
@@ -615,14 +708,17 @@ module BinUtils
615
708
  INT32LE_STRING = "Va*".freeze
616
709
  INT32BE_STRING = "Na*".freeze
617
710
  def append_bersize_string!(data, str)
711
+ data ||= ''.force_encoding(BINARY)
618
712
  data << [str.bytesize, str].pack(BER_STRING)
619
713
  end
620
714
 
621
715
  def append_int32size_string_le!(data, str)
716
+ data ||= ''.force_encoding(BINARY)
622
717
  data << [str.bytesize, str].pack(INT32LE_STRING)
623
718
  end
624
719
 
625
720
  def append_int32size_string_be!(data, str)
721
+ data ||= ''.force_encoding(BINARY)
626
722
  data << [str.bytesize, str].pack(INT32BE_STRING)
627
723
  end
628
724
 
@@ -630,6 +726,8 @@ module BinUtils
630
726
  INT32LE_BER = 'Vw'
631
727
  INT32BE_BER = 'Nw'
632
728
  def append_ber!(data, *ints)
729
+ data ||= ''.force_encoding(BINARY)
730
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
633
731
  if ints.size == 1 && ints[0] < 128
634
732
  data << ints[0]
635
733
  else
@@ -638,18 +736,24 @@ module BinUtils
638
736
  end
639
737
 
640
738
  def append_bersize_ber!(data, *ints)
739
+ data ||= ''.force_encoding(BINARY)
740
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
641
741
  bers = ints.pack(BER)
642
742
  append_ber!(data, bers.size)
643
743
  data << bers
644
744
  end
645
745
 
646
746
  def append_int32size_ber_le!(data, *ints)
747
+ data ||= ''.force_encoding(BINARY)
748
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
647
749
  bers = ints.pack(BER)
648
750
  append_int32_le!(data, bers.size)
649
751
  data << bers
650
752
  end
651
753
 
652
754
  def append_int32size_ber_be!(data, *ints)
755
+ data ||= ''.force_encoding(BINARY)
756
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
653
757
  bers = ints.pack(BER)
654
758
  append_int32_be!(data, bers.size)
655
759
  data << bers
@@ -658,41 +762,57 @@ module BinUtils
658
762
  # complex
659
763
 
660
764
  def append_int8_ber!(data, int1, *ints)
765
+ data ||= ''.force_encoding(BINARY)
766
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
661
767
  data << (int1 & 255)
662
768
  append_ber!(data, *ints)
663
769
  end
664
770
 
665
771
  def append_int8_int16_le!(data, int1, *ints)
772
+ data ||= ''.force_encoding(BINARY)
773
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
666
774
  data << (int1 & 255)
667
775
  append_int16_le!(data, *ints)
668
776
  end
669
777
 
670
778
  def append_int8_int24_le!(data, int1, *ints)
779
+ data ||= ''.force_encoding(BINARY)
780
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
671
781
  data << (int1 & 255)
672
782
  append_int24_le!(data, *ints)
673
783
  end
674
784
 
675
785
  def append_int8_int32_le!(data, int1, *ints)
786
+ data ||= ''.force_encoding(BINARY)
787
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
676
788
  data << (int1 & 255)
677
789
  append_int32_le!(data, *ints)
678
790
  end
679
-
791
+
680
792
  def append_int16_ber_le!(data, int1, *ints)
793
+ data ||= ''.force_encoding(BINARY)
794
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
681
795
  append_int16_le!(data, int1)
682
796
  append_ber!(data, *ints)
683
797
  end
684
798
 
685
799
  def append_int16_int8_le!(data, int1, *ints)
800
+ data ||= ''.force_encoding(BINARY)
801
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
686
802
  append_int16_le!(data, int1)
687
803
  append_int8!(data, *ints)
688
804
  end
689
805
 
690
806
  def append_int16_int24_le!(data, int1, *ints)
807
+ data ||= ''.force_encoding(BINARY)
808
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
691
809
  append_int16_le!(data, int1)
692
810
  append_int24_le!(data, *ints)
693
811
  end
694
812
 
695
813
  def append_int16_int32_le!(data, int1, *ints)
814
+ data ||= ''.force_encoding(BINARY)
815
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
696
816
  append_int16_le!(data, int1)
697
817
  append_int32_le!(data, *ints)
698
818
  end
@@ -703,151 +823,211 @@ module BinUtils
703
823
  end
704
824
 
705
825
  def append_int24_int8_le!(data, int1, *ints)
826
+ data ||= ''.force_encoding(BINARY)
827
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
706
828
  append_int24_le!(data, int1)
707
829
  append_int8!(data, *ints)
708
830
  end
709
831
 
710
832
  def append_int24_int16_le!(data, int1, *ints)
833
+ data ||= ''.force_encoding(BINARY)
834
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
711
835
  append_int24_le!(data, int1)
712
836
  append_int16_le!(data, *ints)
713
837
  end
714
838
 
715
839
  def append_int24_int32_le!(data, int1, *ints)
840
+ data ||= ''.force_encoding(BINARY)
841
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
716
842
  append_int24_le!(data, int1)
717
843
  append_int32_le!(data, *ints)
718
844
  end
719
-
845
+
720
846
  def append_int32_ber_le!(data, int1, *ints)
847
+ data ||= ''.force_encoding(BINARY)
848
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
721
849
  append_int32_le!(data, int1)
722
850
  append_ber!(data, *ints)
723
851
  end
724
852
 
725
853
  def append_int32_int8_le!(data, int1, *ints)
854
+ data ||= ''.force_encoding(BINARY)
855
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
726
856
  append_int32_le!(data, int1)
727
857
  append_int8!(data, *ints)
728
858
  end
729
859
 
730
860
  def append_int32_int16_le!(data, int1, *ints)
861
+ data ||= ''.force_encoding(BINARY)
862
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
731
863
  append_int32_le!(data, int1)
732
864
  append_int16_le!(data, *ints)
733
865
  end
734
866
 
735
867
  def append_int32_int24_le!(data, int1, *ints)
868
+ data ||= ''.force_encoding(BINARY)
869
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
736
870
  append_int32_le!(data, int1)
737
871
  append_int24_le!(data, *ints)
738
872
  end
739
873
 
740
874
  def append_int8_int16_be!(data, int1, *ints)
875
+ data ||= ''.force_encoding(BINARY)
876
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
741
877
  data << (int1 & 255)
742
878
  append_int16_be!(data, *ints)
743
879
  end
744
880
 
745
881
  def append_int8_int24_be!(data, int1, *ints)
882
+ data ||= ''.force_encoding(BINARY)
883
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
746
884
  data << (int1 & 255)
747
885
  append_int24_be!(data, *ints)
748
886
  end
749
887
 
750
888
  def append_int8_int32_be!(data, int1, *ints)
889
+ data ||= ''.force_encoding(BINARY)
890
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
751
891
  data << (int1 & 255)
752
892
  append_int32_be!(data, *ints)
753
893
  end
754
-
894
+
755
895
  def append_int16_ber_be!(data, int1, *ints)
896
+ data ||= ''.force_encoding(BINARY)
897
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
756
898
  append_int16_be!(data, int1)
757
899
  append_ber!(data, *ints)
758
900
  end
759
901
 
760
902
  def append_int16_int8_be!(data, int1, *ints)
903
+ data ||= ''.force_encoding(BINARY)
904
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
761
905
  append_int16_be!(data, int1)
762
906
  append_int8!(data, *ints)
763
907
  end
764
908
 
765
909
  def append_int16_int24_be!(data, int1, *ints)
910
+ data ||= ''.force_encoding(BINARY)
911
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
766
912
  append_int16_be!(data, int1)
767
913
  append_int24_be!(data, *ints)
768
914
  end
769
915
 
770
916
  def append_int16_int32_be!(data, int1, *ints)
917
+ data ||= ''.force_encoding(BINARY)
918
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
771
919
  append_int16_be!(data, int1)
772
920
  append_int32_be!(data, *ints)
773
921
  end
774
-
922
+
775
923
  def append_int24_ber_be!(data, int1, *ints)
924
+ data ||= ''.force_encoding(BINARY)
925
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
776
926
  append_int24_be!(data, int1)
777
927
  append_ber!(data, *ints)
778
928
  end
779
929
 
780
930
  def append_int24_int8_be!(data, int1, *ints)
931
+ data ||= ''.force_encoding(BINARY)
932
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
781
933
  append_int24_be!(data, int1)
782
934
  append_int8!(data, *ints)
783
935
  end
784
936
 
785
937
  def append_int24_int16_be!(data, int1, *ints)
938
+ data ||= ''.force_encoding(BINARY)
939
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
786
940
  append_int24_be!(data, int1)
787
941
  append_int16_be!(data, *ints)
788
942
  end
789
943
 
790
944
  def append_int24_int32_be!(data, int1, *ints)
945
+ data ||= ''.force_encoding(BINARY)
946
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
791
947
  append_int24_be!(data, int1)
792
948
  append_int32_be!(data, *ints)
793
949
  end
794
-
950
+
795
951
  def append_int32_ber_be!(data, int1, *ints)
952
+ data ||= ''.force_encoding(BINARY)
953
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
796
954
  append_int32_be!(data, int1)
797
955
  append_ber!(data, *ints)
798
956
  end
799
957
 
800
958
  def append_int32_int8_be!(data, int1, *ints)
959
+ data ||= ''.force_encoding(BINARY)
960
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
801
961
  append_int32_be!(data, int1)
802
962
  append_int8!(data, *ints)
803
963
  end
804
964
 
805
965
  def append_int32_int16_be!(data, int1, *ints)
966
+ data ||= ''.force_encoding(BINARY)
967
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
806
968
  append_int32_be!(data, int1)
807
969
  append_int16_be!(data, *ints)
808
970
  end
809
971
 
810
972
  def append_int32_int24_be!(data, int1, *ints)
973
+ data ||= ''.force_encoding(BINARY)
974
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
811
975
  append_int32_be!(data, int1)
812
976
  append_int24_be!(data, *ints)
813
977
  end
814
978
 
815
979
  def append_ber_int8!(data, int1, *ints)
980
+ data ||= ''.force_encoding(BINARY)
981
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
816
982
  append_ber!(data, int1)
817
983
  append_int8!(data, *ints)
818
984
  end
819
985
 
820
986
  def append_ber_int16_le!(data, int1, *ints)
987
+ data ||= ''.force_encoding(BINARY)
988
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
821
989
  append_ber!(data, int1)
822
990
  append_int16_le!(data, *ints)
823
991
  end
824
992
 
825
993
  def append_ber_int24_le!(data, int1, *ints)
994
+ data ||= ''.force_encoding(BINARY)
995
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
826
996
  append_ber!(data, int1)
827
997
  append_int24_le!(data, *ints)
828
998
  end
829
999
 
830
1000
  def append_ber_int32_le!(data, int1, *ints)
1001
+ data ||= ''.force_encoding(BINARY)
1002
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
831
1003
  append_ber!(data, int1)
832
1004
  append_int32_le!(data, *ints)
833
1005
  end
834
1006
 
835
1007
  def append_ber_int8!(data, int1, *ints)
1008
+ data ||= ''.force_encoding(BINARY)
1009
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
836
1010
  append_ber!(data, int1)
837
1011
  append_int8!(data, *ints)
838
1012
  end
839
1013
 
840
1014
  def append_ber_int16_be!(data, int1, *ints)
1015
+ data ||= ''.force_encoding(BINARY)
1016
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
841
1017
  append_ber!(data, int1)
842
1018
  append_int16_be!(data, *ints)
843
1019
  end
844
1020
 
845
1021
  def append_ber_int24_be!(data, int1, *ints)
1022
+ data ||= ''.force_encoding(BINARY)
1023
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
846
1024
  append_ber!(data, int1)
847
1025
  append_int24_be!(data, *ints)
848
1026
  end
849
1027
 
850
1028
  def append_ber_int32_be!(data, int1, *ints)
1029
+ data ||= ''.force_encoding(BINARY)
1030
+ ints = ints[0] if ints.size == 1 && Array === ints[0]
851
1031
  append_ber!(data, int1)
852
1032
  append_int32_be!(data, *ints)
853
1033
  end