Passed
Push — master ( 567ae9...db344a )
by Rafael S.
01:53
created

main.js ➔ packString   A

Complexity

Conditions 1
Paths 1

Size

Total Lines 3
Code Lines 2

Duplication

Lines 0
Ratio 0 %

Importance

Changes 2
Bugs 0 Features 0
Metric Value
cc 1
eloc 2
nc 1
nop 1
dl 0
loc 3
rs 10
c 2
b 0
f 0
1
/*
2
 * Copyright (c) 2017-2018 Rafael da Silva Rocha.
3
 *
4
 * Permission is hereby granted, free of charge, to any person obtaining
5
 * a copy of this software and associated documentation files (the
6
 * "Software"), to deal in the Software without restriction, including
7
 * without limitation the rights to use, copy, modify, merge, publish,
8
 * distribute, sublicense, and/or sell copies of the Software, and to
9
 * permit persons to whom the Software is furnished to do so, subject to
10
 * the following conditions:
11
 *
12
 * The above copyright notice and this permission notice shall be
13
 * included in all copies or substantial portions of the Software.
14
 *
15
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22
 *
23
 */
24
25
/**
26
 * @fileoverview The byte-data API.
27
 * @see https://github.com/rochars/byte-data
28
 */
29
30
/** @module byteData */
31
32
import endianness from 'endianness';
33
import Packer from './lib/packer.js';
34
import {validateNotUndefined, validateValueType} from './lib/validation.js';
35
import {pack as packUTF8, unpack as unpackUTF8} from 'utf8-buffer';
36
37
let packer = new Packer();
38
39
/**
40
 * Read a string of UTF-8 characters from a byte buffer.
41
 * @param {!Uint8Array|!Array<!number>} buffer A byte buffer.
42
 * @param {number=} index The index to read.
43
 * @param {?number=} len The number of bytes to read.
44
 *    If len is undefined will read until the end of the buffer.
45
 * @return {string}
46
 */
47
export function unpackString(buffer, index=0, len=undefined) {
48
  return unpackUTF8(buffer, index, len);
49
}
50
51
/**
52
 * Write a string of UTF-8 characters as a byte buffer.
53
 * @param {string} str The string to pack.
54
 * @return {!Uint8Array} The packed string.
55
 */
56
export function packString(str) {
57
  return packUTF8(str);
58
}
59
60
/**
61
 * Write a string of UTF-8 characters to a byte buffer.
62
 * @param {string} str The string to pack.
63
 * @param {!Uint8Array|!Array<number>} buffer The output buffer.
64
 * @param {number=} index The buffer index to start writing.
65
 *   Assumes zero if undefined.
66
 * @return {number} The next index to write in the buffer.
67
 */
68
export function packStringTo(str, buffer, index=0) {
69
  /** @type {!Uint8Array} */
70
  let bytes = packString(str);
71
  for (let i = 0, len = bytes.length; i < len; i++) {
72
    buffer[index++] = bytes[i];
73
  }
74
  return index;
75
}
76
77
// Numbers
78
/**
79
 * Pack a number as a byte buffer.
80
 * @param {number} value The number.
81
 * @param {!Object} theType The type definition.
82
 * @return {!Array<number>} The packed value.
83
 * @throws {Error} If the type definition is not valid.
84
 * @throws {Error} If the value is not valid.
85
 */
86
export function pack(value, theType) {
87
  /** @type {!Array<!number>} */
88
  let output = [];
89
  packTo(value, theType, output);
90
  return output;
91
}
92
93
/**
94
 * Pack a number to a byte buffer.
95
 * @param {number} value The value.
96
 * @param {!Object} theType The type definition.
97
 * @param {!Uint8Array|!Array<number>} buffer The output buffer.
98
 * @param {number=} index The buffer index to write. Assumes 0 if undefined.
99
 * @return {number} The next index to write.
100
 * @throws {Error} If the type definition is not valid.
101
 * @throws {Error} If the value is not valid.
102
 */
103
export function packTo(value, theType, buffer, index=0) {
104
  return packArrayTo([value], theType, buffer, index);
105
}
106
107
/**
108
 * Pack an array of numbers as a byte buffer.
109
 * @param {!Array<number>|!TypedArray} values The values.
110
 * @param {!Object} theType The type definition.
111
 * @return {!Array<number>} The packed values.
112
 * @throws {Error} If the type definition is not valid.
113
 * @throws {Error} If any of the values are not valid.
114
 */
115
export function packArray(values, theType) {
116
  /** @type {!Array<!number>} */
117
  let output = [];
118
  packArrayTo(values, theType, output);
119
  return output;
120
}
121
122
/**
123
 * Pack a array of numbers to a byte buffer.
124
 * @param {!Array<number>|!TypedArray} values The value.
125
 * @param {!Object} theType The type definition.
126
 * @param {!Uint8Array|!Array<number>} buffer The output buffer.
127
 * @param {number=} index The buffer index to start writing.
128
 *   Assumes zero if undefined.
129
 * @return {number} The next index to write.
130
 * @throws {Error} If the type definition is not valid.
131
 * @throws {Error} If the value is not valid.
132
 */
133
export function packArrayTo(values, theType, buffer, index=0) {
134
  packer.setUp(theType);
135
  for (let i = 0, valuesLen = values.length; i < valuesLen; i++) {
136
    validateNotUndefined(values[i]);
137
    validateValueType(values[i]);
138
    /** @type {number} */
139
    let len = index + packer.offset;
140
    while (index < len) {
141
      index = packer.write(buffer, values[i], index);
142
    }
143
    if (theType.be) {
144
      endianness(
145
        buffer, packer.offset, index - packer.offset, index);
146
    }
147
  }
148
  return index;
149
}
150
151
/**
152
 * Unpack a number from a byte buffer.
153
 * @param {!Uint8Array|!Array<!number>} buffer The byte buffer.
154
 * @param {!Object} theType The type definition.
155
 * @param {number=} index The buffer index to read. Assumes zero if undefined.
156
 * @return {number}
157
 * @throws {Error} If the type definition is not valid
158
 * @throws {Error} On bad buffer length.
159
 */
160
export function unpack(buffer, theType, index=0) {
161
  packer.setUp(theType);
162
  if ((packer.offset + index) > buffer.length) {
163
    throw Error('Bad buffer length.');
164
  }
165
  if (theType.be) {
166
    endianness(buffer, packer.offset, index, index + packer.offset);
167
  }
168
  /** @type {number} */
169
  let value = packer.read(buffer, index);
170
  if (theType.be) {
171
    endianness(buffer, packer.offset, index, index + packer.offset);
172
  }
173
  return value;
174
}
175
176
/**
177
 * Unpack an array of numbers from a byte buffer.
178
 * @param {!Uint8Array|!Array<!number>} buffer The byte buffer.
179
 * @param {!Object} theType The type definition.
180
 * @param {number=} index The buffer index to start reading.
181
 *   Assumes zero if undefined.
182
 * @param {number=} end The buffer index to stop reading.
183
 *   Assumes the buffer length if undefined.
184
 * @return {!Array<number>}
185
 * @throws {Error} If the type definition is not valid
186
 */
187
export function unpackArray(buffer, theType, index=0, end=buffer.length) {
188
  /** @type {!Array<!number>} */
189
  let output = [];
190
  unpackArrayTo(buffer, theType, output, index, end);
191
  return output;
192
}
193
194
/**
195
 * Unpack a array of numbers to a typed array.
196
 * @param {!Uint8Array|!Array<!number>} buffer The byte buffer.
197
 * @param {!Object} theType The type definition.
198
 * @param {!TypedArray|!Array<!number>} output The output array.
199
 * @param {number=} index The buffer index to start reading.
200
 *   Assumes zero if undefined.
201
 * @param {number=} end The buffer index to stop reading.
202
 *   Assumes the buffer length if undefined.
203
 * @throws {Error} If the type definition is not valid
204
 */
205
export function unpackArrayTo(
206
    buffer, theType, output, index=0, end=buffer.length) {
207
  packer.setUp(theType);
208
  /** @type {number} */
209
  let originalIndex = index;
210
  while ((end - index) % packer.offset) {
211
      end--;
212
  }
213
  if (theType.be) {
214
    endianness(buffer, packer.offset, index, end);
215
  }
216
  for (let i = 0; index < end; index += packer.offset, i++) {
0 ignored issues
show
Unused Code introduced by Rafael Rocha
The loop variable i is initialized by the loop but not used in the test. Consider using another type of loop if this is the intended behavior.
Loading history...
217
    output[i] = packer.read(buffer, index);
218
  }
219
  if (theType.be) {
220
    endianness(buffer, packer.offset, originalIndex, end);
221
  }
222
}
223