Line data    Source code

       1              : import 'dart:typed_data';
       2              : 
       3              : extension ByteUtil on ByteData {
       4            6 :   int writeUint64(int offset, int val) {
       5            6 :     setInt64(offset, val, Endian.little);
       6              :     return 8;
       7              :   }
       8              : 
       9            6 :   int writeUint32(int offset, int val) {
      10            6 :     setUint32(offset, val, Endian.little);
      11              :     return 4;
      12              :   }
      13              : 
      14            0 :   int writeUint24(int offset, int value) {
      15            0 :     setUint8(offset, (value & 0xff0000) >> 16); //most significant byte
      16            0 :     setUint8(offset + 1, (value & 0x00ff00) >> 8); //middle byte
      17            0 :     setUint8(offset + 2, value & 0x0000ff); //least significant byte
      18              :     return 3;
      19              :   }
      20              : 
      21            1 :   int writeUint16(int offset, int val) {
      22            1 :     setUint16(offset, val, Endian.little);
      23              :     return 2;
      24              :   }
      25              : 
      26            3 :   int writeUint8(int offset, int val) {
      27            3 :     setUint8(offset, val);
      28              :     return 1;
      29              :   }
      30              : 
      31            6 :   int writeVarInt(int offset, int val) {
      32            6 :     if (val < 0xfd) {
      33            6 :       setUint8(offset, val);
      34              :       return 1;
      35              :     }
      36            0 :     if (val <= 0xffff) {
      37            0 :       setUint8(offset, 0xfd);
      38            0 :       setUint16(offset + 1, val, Endian.little);
      39              :       return 3;
      40              :     }
      41            0 :     if (val <= 0xffffffff) {
      42            0 :       setUint8(offset, 0xfe);
      43            0 :       setUint32(offset + 1, val, Endian.little);
      44              :       return 5;
      45              :     }
      46              : 
      47            0 :     setUint8(offset, 0xff);
      48            0 :     setUint64(offset + 1, val, Endian.little);
      49              :     return 9;
      50              :   }
      51              : 
      52            3 :   (int, int) readUint64(int offset) {
      53            3 :     return (getInt64(offset, Endian.little), 8);
      54              :   }
      55              : 
      56            3 :   (int, int) readUint32(int offset) {
      57            3 :     return (getUint32(offset, Endian.little), 4);
      58              :   }
      59              : 
      60            1 :   (int, int) readUint16(int offset) {
      61            1 :     return (getUint16(offset, Endian.little), 2);
      62              :   }
      63              : 
      64            2 :   (int, int) readUint8(int offset) {
      65            2 :     return (getUint8(offset), 1);
      66              :   }
      67              : 
      68            3 :   (int, int) readVarInt(int offset) {
      69            3 :     final firstByte = getUint8(offset);
      70            3 :     if (firstByte < 0xfd) {
      71              :       return (firstByte, 1);
      72              :     }
      73            0 :     if (firstByte == 0xfd) {
      74            0 :       return (getUint16(offset + 1, Endian.little), 3);
      75              :     }
      76            0 :     if (firstByte == 0xfe) {
      77            0 :       return (getUint32(offset + 1, Endian.little), 5);
      78              :     }
      79            0 :     return (getUint64(offset + 1, Endian.little), 9);
      80              :   }
      81              : 
      82            0 :   int readVarIntFromLength(
      83              :     int offset,
      84              :     int length,
      85              :     Endian endian,
      86              :   ) {
      87            0 :     if (length < 0xfd) {
      88            0 :       return getUint8(offset);
      89              :     }
      90            0 :     if (length == 0xfd) {
      91            0 :       return getUint16(offset, endian);
      92              :     }
      93            0 :     if (length == 0xfe) {
      94            0 :       return getUint32(offset, endian);
      95              :     }
      96            0 :     return getUint64(offset, endian);
      97              :   }
      98              : }
      99              : 
     100              : extension BufferUtil on Uint8List {
     101           36 :   ByteData get bytes => buffer.asByteData();
     102              : 
     103            8 :   int writeSlice(int offset, Uint8List slice) {
     104           24 :     setRange(offset, offset + slice.length, slice);
     105            8 :     return slice.length;
     106              :   }
     107              : 
     108            3 :   (Uint8List, int) readSlice(int offset, int length) {
     109            6 :     return (sublist(offset, offset + length), length);
     110              :   }
     111              : 
     112            6 :   int writeVarSlice(int offset, Uint8List slice) {
     113              :     var diff = 0;
     114           24 :     diff += bytes.writeVarInt(offset, slice.length);
     115           18 :     diff += writeSlice(offset + diff, slice);
     116              :     return diff;
     117              :   }
     118              : 
     119            3 :   (Uint8List, int) readVarSlice(int offset) {
     120            6 :     final (length, lengthByteLength) = bytes.readVarInt(offset);
     121              :     final (slice, sliceByteLength) =
     122            6 :         readSlice(offset + lengthByteLength, length);
     123            3 :     return (slice, lengthByteLength + sliceByteLength);
     124              :   }
     125              : }
     126              : 
     127            3 : int varSliceSize(Uint8List slice) {
     128           12 :   return encodingLength(slice.length) + slice.length;
     129              : }
     130              : 
     131            3 : int encodingLength(int number) {
     132              :   // if (!isUint(number, 53)) throw ArgumentError("Expected UInt53");
     133            3 :   return (number < 0xfd
     134              :       ? 1
     135            0 :       : number <= 0xffff
     136              :           ? 3
     137            0 :           : number <= 0xffffffff
     138              :               ? 5
     139              :               : 9);
     140              : }