index.js - Code Metrics - Inspection of "Review documentation" - rochars/byte-data - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d4a04a...a690f0 )

by Rafael S.

created 2018-08-02 23:57 UTC

index.js A

↳ Parent: Project

Complexity

Total Complexity	22
Complexity/F	2.2

Size

Lines of Code	209
Function Count	10

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes	5
Bugs	1	Features	0

Metric	Value
cc	0
eloc	68
nc	1
dl	0
loc	209
rs	10
c	5
b	1
f	0
wmc	22
mnd	2
bc	23
fnc	10
bpm	2.3
cpm	2.2
noi	1

10 Functions

Rating	Name	Size	Complexity
B	➔ unpackArrayTo	27	7
A	➔ packArrayTo	18	4
A	➔ packTo	3	1
A	➔ packString	6	1
A	➔ packStringTo	3	1
A	➔ pack	6	1
A	➔ packArray	6	1
A	➔ unpackString	3	1
A	➔ unpack	16	4
A	➔ unpackArray	7	1

/*
 * Copyright (c) 2017-2018 Rafael da Silva Rocha.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */

/**
 * @fileoverview The byte-data API.
 * @see https://github.com/rochars/byte-data
 */

/** @module byteData */

import endianness from 'endianness';
import utf8BufferSize from 'utf8-buffer-size';
import {pack as packUTF8, unpack as unpackUTF8} from 'utf8-buffer';
import NumberBuffer from './lib/number-buffer.js';
import {validateValueType} from './lib/validation.js';

const SIZE_ERR = 'Bad buffer length';

/**
 * Read a string of UTF-8 characters from a byte buffer.
 * @param {!Uint8Array|!Array<number>} buffer A byte buffer.
 * @param {number=} index The buffer index to start reading.
 * @param {?number=} end The buffer index to stop reading.
 *   If end is null will read until the end of the buffer.
 * @return {string}
 */
export function unpackString(buffer, index=0, end=null) {
  return unpackUTF8(buffer, index, end);
}

/**
 * Write a string of UTF-8 characters as a byte buffer.
 * @param {string} str The string to pack.
 * @return {!Uint8Array} The buffer with the packed string written.
 * @deprecated
 */ 
export function packString(str) {
  /** @type {!Uint8Array} */
  let buffer = new Uint8Array(utf8BufferSize(str));
  packUTF8(str, buffer, 0);
  return buffer;
}

/**
 * Write a string of UTF-8 characters to a byte buffer.
 * @param {string} str The string to pack.
 * @param {!Uint8Array|!Array<number>} buffer The output buffer.
 * @param {number=} index The buffer index to start writing.
 *   Assumes zero if undefined.
 * @return {number} The next index to write in the buffer.
 */
export function packStringTo(str, buffer, index=0) {
  return packUTF8(str, buffer, index);
}

// Numbers
/**
 * Pack a number as a byte buffer.
 * @param {number} value The number.
 * @param {!Object} theType The type definition.
 * @return {!Array<number>} The packed value.
 * @throws {Error} If the type definition is not valid.
 * @throws {Error} If the value is not valid.
 */
export function pack(value, theType) {
  /** @type {!Array<number>} */
  let output = [];
  packTo(value, theType, output);
  return output;
}

/**
 * Pack a number to a byte buffer.
 * @param {number} value The value.
 * @param {!Object} theType The type definition.
 * @param {!Uint8Array|!Array<number>} buffer The output buffer.
 * @param {number=} index The buffer index to write. Assumes 0 if undefined.
 * @return {number} The next index to write.
 * @throws {Error} If the type definition is not valid.
 * @throws {Error} If the value is not valid.
 */
export function packTo(value, theType, buffer, index=0) {
  return packArrayTo([value], theType, buffer, index);
}

/**
 * Pack an array of numbers as a byte buffer.
 * @param {!Array<number>|!TypedArray} values The values.
 * @param {!Object} theType The type definition.
 * @return {!Array<number>} The packed values.
 * @throws {Error} If the type definition is not valid.
 * @throws {Error} If any of the values are not valid.
 */
export function packArray(values, theType) {
  /** @type {!Array<number>} */
  let output = [];
  packArrayTo(values, theType, output);
  return output;
}

/**
 * Pack a array of numbers to a byte buffer.
 * @param {!Array<number>|!TypedArray} values The value.
 * @param {!Object} theType The type definition.
 * @param {!Uint8Array|!Array<number>} buffer The output buffer.
 * @param {number=} index The buffer index to start writing.
 *   Assumes zero if undefined.
 * @return {number} The next index to write.
 * @throws {Error} If the type definition is not valid.
 * @throws {Error} If the value is not valid.
 */
export function packArrayTo(values, theType, buffer, index=0) {
  /** @type {NumberBuffer} */
  let packer = new NumberBuffer(theType);
  let valuesLen = values.length;
  for (let i = 0; i < valuesLen; i++) {
    validateValueType(values[i]);
    /** @type {number} */
    let len = index + packer.offset;
    while (index < len) {
      index = packer.pack(buffer, values[i], index);
    }
    if (theType.be) {
      endianness(
        buffer, packer.offset, index - packer.offset, index);
    }
  }
  return index;
}

/**
 * Unpack a number from a byte buffer.
 * @param {!Uint8Array|!Array<number>} buffer The byte buffer.
 * @param {!Object} theType The type definition.
 * @param {number=} index The buffer index to read. Assumes zero if undefined.
 * @return {number}
 * @throws {Error} If the type definition is not valid
 * @throws {Error} On bad buffer length.
 */
export function unpack(buffer, theType, index=0) {
  /** @type {NumberBuffer} */
  let packer = new NumberBuffer(theType);
  if ((packer.offset + index) > buffer.length) {
    throw Error(SIZE_ERR);
  }
  if (theType.be) {
    endianness(buffer, packer.offset, index, index + packer.offset);
  }
  /** @type {number} */
  let value = packer.unpack(buffer, index);
  if (theType.be) {
    endianness(buffer, packer.offset, index, index + packer.offset);
  }
  return value;
}

/**
 * Unpack an array of numbers from a byte buffer.
 * @param {!Uint8Array|!Array<number>} buffer The byte buffer.
 * @param {!Object} theType The type definition.
 * @param {number=} index The buffer index to start reading.
 *   Assumes zero if undefined.
 * @param {number=} end The buffer index to stop reading.
 *   Assumes the buffer length if undefined.
 * @param {boolean=} safe If set to false, extra bytes in the end of
 *   the array are ignored and input buffers with insufficient bytes will
 *   produce a empty output array. Defaults to false.
 * @return {!Array<number>}
 * @throws {Error} If the type definition is not valid
 */
export function unpackArray(
    buffer, theType, index=0, end=buffer.length, safe=false) {
  /** @type {!Array<number>} */
  let output = [];
  unpackArrayTo(buffer, theType, output, index, end, safe);
  return output;
}

/**
 * Unpack a array of numbers to a typed array.
 * @param {!Uint8Array|!Array<number>} buffer The byte buffer.
 * @param {!Object} theType The type definition.
 * @param {!TypedArray|!Array<number>} output The output array.
 * @param {number=} index The buffer index to start reading.
 *   Assumes zero if undefined.
 * @param {number=} end The buffer index to stop reading.
 *   Assumes the buffer length if undefined.
 * @param {boolean=} safe If set to false, extra bytes in the end of
 *   the array are ignored and input buffers with insufficient bytes will
 *   write nothing to the output array. Defaults to false.
 * @throws {Error} If the type definition is not valid
 */
export function unpackArrayTo(
    buffer, theType, output, index=0, end=buffer.length, safe=false) {
  /** @type {NumberBuffer} */
  let packer = new NumberBuffer(theType);
  /** @type {number} */
  let originalIndex = index;
  // fix the size of the input array if not in safe mode
  if (safe) {
    if ((end - index) % packer.offset) {
      throw new Error(SIZE_ERR);
    }
  } else {
    while ((end - index) % packer.offset) {
        end--;
    }
  }
  if (theType.be) {
    endianness(buffer, packer.offset, index, end);
  }
  for (let i = 0; index < end; index += packer.offset) {

    output[i] = packer.unpack(buffer, index);
    i++;
  }
  if (theType.be) {
    endianness(buffer, packer.offset, originalIndex, end);
  }
}


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 utf8BufferSize from 'utf8-buffer-size';
34			import {pack as packUTF8, unpack as unpackUTF8} from 'utf8-buffer';
35			import NumberBuffer from './lib/number-buffer.js';
36			import {validateValueType} from './lib/validation.js';
37
38			const SIZE_ERR = 'Bad buffer length';
39
40			/**
41			* Read a string of UTF-8 characters from a byte buffer.
42			* @param {!Uint8Array\|!Array<number>} buffer A byte buffer.
43			* @param {number=} index The buffer index to start reading.
44			* @param {?number=} end The buffer index to stop reading.
45			* If end is null will read until the end of the buffer.
46			* @return {string}
47			*/
48			export function unpackString(buffer, index=0, end=null) {
49			return unpackUTF8(buffer, index, end);
50			}
51
52			/**
53			* Write a string of UTF-8 characters as a byte buffer.
54			* @param {string} str The string to pack.
55			* @return {!Uint8Array} The buffer with the packed string written.
56			* @deprecated
57			*/
58			export function packString(str) {
59			/** @type {!Uint8Array} */
60			let buffer = new Uint8Array(utf8BufferSize(str));
61			packUTF8(str, buffer, 0);
62			return buffer;
63			}
64
65			/**
66			* Write a string of UTF-8 characters to a byte buffer.
67			* @param {string} str The string to pack.
68			* @param {!Uint8Array\|!Array<number>} buffer The output buffer.
69			* @param {number=} index The buffer index to start writing.
70			* Assumes zero if undefined.
71			* @return {number} The next index to write in the buffer.
72			*/
73			export function packStringTo(str, buffer, index=0) {
74			return packUTF8(str, buffer, 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			/** @type {NumberBuffer} */
135			let packer = new NumberBuffer(theType);
136			let valuesLen = values.length;
137			for (let i = 0; i < valuesLen; i++) {
138			validateValueType(values[i]);
139			/** @type {number} */
140			let len = index + packer.offset;
141			while (index < len) {
142			index = packer.pack(buffer, values[i], index);
143			}
144			if (theType.be) {
145			endianness(
146			buffer, packer.offset, index - packer.offset, index);
147			}
148			}
149			return index;
150			}
151
152			/**
153			* Unpack a number from a byte buffer.
154			* @param {!Uint8Array\|!Array<number>} buffer The byte buffer.
155			* @param {!Object} theType The type definition.
156			* @param {number=} index The buffer index to read. Assumes zero if undefined.
157			* @return {number}
158			* @throws {Error} If the type definition is not valid
159			* @throws {Error} On bad buffer length.
160			*/
161			export function unpack(buffer, theType, index=0) {
162			/** @type {NumberBuffer} */
163			let packer = new NumberBuffer(theType);
164			if ((packer.offset + index) > buffer.length) {
165			throw Error(SIZE_ERR);
166			}
167			if (theType.be) {
168			endianness(buffer, packer.offset, index, index + packer.offset);
169			}
170			/** @type {number} */
171			let value = packer.unpack(buffer, index);
172			if (theType.be) {
173			endianness(buffer, packer.offset, index, index + packer.offset);
174			}
175			return value;
176			}
177
178			/**
179			* Unpack an array of numbers from a byte buffer.
180			* @param {!Uint8Array\|!Array<number>} buffer The byte buffer.
181			* @param {!Object} theType The type definition.
182			* @param {number=} index The buffer index to start reading.
183			* Assumes zero if undefined.
184			* @param {number=} end The buffer index to stop reading.
185			* Assumes the buffer length if undefined.
186			* @param {boolean=} safe If set to false, extra bytes in the end of
187			* the array are ignored and input buffers with insufficient bytes will
188			* produce a empty output array. Defaults to false.
189			* @return {!Array<number>}
190			* @throws {Error} If the type definition is not valid
191			*/
192			export function unpackArray(
193			buffer, theType, index=0, end=buffer.length, safe=false) {
194			/** @type {!Array<number>} */
195			let output = [];
196			unpackArrayTo(buffer, theType, output, index, end, safe);
197			return output;
198			}
199
200			/**
201			* Unpack a array of numbers to a typed array.
202			* @param {!Uint8Array\|!Array<number>} buffer The byte buffer.
203			* @param {!Object} theType The type definition.
204			* @param {!TypedArray\|!Array<number>} output The output array.
205			* @param {number=} index The buffer index to start reading.
206			* Assumes zero if undefined.
207			* @param {number=} end The buffer index to stop reading.
208			* Assumes the buffer length if undefined.
209			* @param {boolean=} safe If set to false, extra bytes in the end of
210			* the array are ignored and input buffers with insufficient bytes will
211			* write nothing to the output array. Defaults to false.
212			* @throws {Error} If the type definition is not valid
213			*/
214			export function unpackArrayTo(
215			buffer, theType, output, index=0, end=buffer.length, safe=false) {
216			/** @type {NumberBuffer} */
217			let packer = new NumberBuffer(theType);
218			/** @type {number} */
219			let originalIndex = index;
220			// fix the size of the input array if not in safe mode
221			if (safe) {
222			if ((end - index) % packer.offset) {
223			throw new Error(SIZE_ERR);
224			}
225			} else {
226			while ((end - index) % packer.offset) {
227			end--;
228			}
229			}
230			if (theType.be) {
231			endianness(buffer, packer.offset, index, end);
232			}
233			for (let i = 0; index < end; index += packer.offset) {
			0 ignored issues – show Unused Code introduced 2018-07-24 07:53 UTC by Report Bug Copy Issue Report 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...
234			output[i] = packer.unpack(buffer, index);
235			i++;
236			}
237			if (theType.be) {
238			endianness(buffer, packer.offset, originalIndex, end);
239			}
240			}
241

rochars / byte-data

Push — master ( d4a04a...a690f0 )

index.js A

Complexity

Size

Duplication

Importance

10 Functions

Duplication Side-by-Side

Filter issues like