source/binary.js at main · Magnogen/source · GitHub

1
2
3
4
5
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
const BinaryReader = (buffer) => {
  let offset = 0;
  const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);

  return {
    tell: () => offset,
    seek: (pos) => {
      offset = pos;
    },
    uint8: () => {
      const val = view.getUint8(offset);
      offset += 1;
      return val;
    },
    uint16: () => {
      const val = view.getUint16(offset, true);
      offset += 2;
      return val;
    },
    int32: () => {
      const val = view.getInt32(offset, true);
      offset += 4;
      return val;
    },
    float32: () => {
      const val = view.getFloat32(offset, true);
      offset += 4;
      return val;
    },
    string: (length) => {
      let chars = [];
      for (let i = 0; i < length; i++) {
        const code = view.getUint8(offset++);
        if (code !== 0) chars.push(String.fromCharCode(code));
      }
      return chars.join('');
    },
    bytes: (length) => {
      const slice = buffer.slice(offset, offset + length);
      offset += length;
      return slice;
    }
  };
};

const BinaryWriter = (initialSize = 1024) => {
  let buffer = new Uint8Array(initialSize);
  let view = new DataView(buffer.buffer);
  let offset = 0;

  const ensureCapacity = (n) => {
    if (offset + n > buffer.length) {
      const newBuffer = new Uint8Array((offset + n) * 2);
      newBuffer.set(buffer);
      buffer = newBuffer;
      view = new DataView(buffer.buffer);
    }
  };

  return {
    uint8: (val) => {
      ensureCapacity(1);
      view.setUint8(offset, val);
      offset += 1;
    },
    uint16: (val) => {
      ensureCapacity(2);
      view.setUint16(offset, val, true);
      offset += 2;
    },
    int32: (val) => {
      ensureCapacity(4);
      view.setInt32(offset, val, true);
      offset += 4;
    },
    float32: (val) => {
      ensureCapacity(4);
      view.setFloat32(offset, val, true);
      offset += 4;
    },
    string: (str, length) => {
      ensureCapacity(length);
      for (let i = 0; i < length; i++) {
        const char = str.charCodeAt(i) || 0;
        view.setUint8(offset++, char);
      }
    },
    bytes: (arr) => {
      ensureCapacity(arr.length);
      buffer.set(arr, offset);
      offset += arr.length;
    },
    pad: (length, value = 0) => {
      ensureCapacity(length);
      for (let i = 0; i < length; i++) {
        view.setUint8(offset++, value);
      }
    },
    toBuffer: () => buffer.slice(0, offset)
  };
};