helpers.js ➔ turnToArray - Code Metrics - Inspection of "helpers.js" - rochars/byte-data - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7c19a0...ad5e1b )

by Rafael S.

created 2017-11-29 19:10 UTC

helpers.js ➔ turnToArray A

↳ Parent: src/helpers.js

Complexity

Conditions	3
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	6
rs	9.4285

/*
 * helpers: functions to work with bytes and byte arrays.
 * Copyright (c) 2017 Rafael da Silva Rocha.
 * https://github.com/rochars/byte-data
 */

const endianness = require("endianness");
const bitDepths = require("../src/bit-depth.js");

/**
 * Padding for binary strings.
 * @param {!Array<string>} bytes The bytes as binary strings.
 * @param {number} base The base.
 * @param {number} index The byte to pad.
 */
function padding(bytes, base, index) {
    bytes[index] = bytePadding(bytes[index], base);
}

/**
 * Padding with 0s for byte strings.
 * @param {string} byte The byte as a binary or hex string.
 * @param {number} base The base.
 * @returns {string} The padded byte.
 */
function bytePadding(byte, base) {
    let offset = byte.length + 1;
    if (base == 2) {
        offset = 8;
    } else if (base == 16) {
        offset = 2;
    }
    return lPadZeros(byte, offset);
}

/**
 * Fix the size of nibbles.
 * @param {!Array<string>} nibbles The nibble as a binary or hex string.
 * @param {number} base The base.
 * @param {number} index The nibble offset.
 */
function paddingNibble(nibbles, base, index) {
    if (base == 2 && nibbles[index].length < 4) {
        nibbles[index] = 
            new Array((5 - nibbles[index].length)).join("0")  + nibbles[index];
    }
}   

/**
 * Fix the size of crumbs.
 * @param {!Array<string>} crumbs The nibble as a binary or hex string.
 * @param {number} base The base.
 * @param {number} index The nibble offset.
 */
function paddingCrumb(crumbs, base, index) {
    if ((base == 2 || base == 16) && crumbs[index].length < 2) {
        crumbs[index] = '0' + crumbs[index];
    }
}   

/**
 * Pad a string with zeros to the left.
 * TODO: This should support both arrays and strings.
 * @param {string} value The string (representing a binary or hex value).
 * @param {number} numZeros the max number of zeros.
 *      For 1 binary byte string it should be 8.
 */
function lPadZeros(value, numZeros) {
    let i = 0;

    while (value.length < numZeros) {
        value = '0' + value;
    }
    return value;
}

/**
 * Pad a array with zeros to the right.
 * @param {!Array<number>} byteArray The array.
 * @param {number} numZeros the max number of zeros.
 *      For 1 binary byte string it should be 8.
 *      TODO: better explanation of numZeros
 */
function fixByteArraySize(byteArray, numZeros) {
    let i = 0;
    let fix = byteArray.length % numZeros;
    if (fix) {
        fix = (fix - numZeros) * -1;
        while(i < fix) {
            byteArray.push(0);
            i++;
        }
    }
}

/**
 * Swap the endianness to big endian.
 * @param {!Array<number>} bytes The values.
 * @param {boolean} isBigEndian True if the bytes should be big endian.
 * @param {number} bitDepth The bitDepth of the data.
 */
function makeBigEndian(bytes, isBigEndian, bitDepth) {
    if (isBigEndian) {
        endianness.endianness(bytes, bitDepths.BitDepthOffsets[bitDepth]);
    }
}

/**
 * Turn bytes to base 2, 10 or 16.
 * @param {!Array<string>|!Array<number>} bytes The bytes.
 * @param {number} base The base.
 * @param {Function} padFunction The function to use for padding.
 */
function bytesToBase(bytes, base, padFunction=padding) {
    if (base != 10) {
        let i = 0;
        let len = bytes.length;
        while (i < len) {
            bytes[i] = bytes[i].toString(base);
            padFunction(bytes, base, i);
            i++;
        }
    }
}

/**
 * Turn the output to the correct base.
 * @param {!Array<number>} bytes The bytes.
 * @param {number} bitDepth The bit depth of the data.
 * @param {number} base The desired base for the output data.
 */
function outputToBase(bytes, bitDepth, base) {
    if (bitDepth == 4) {
        bytesToBase(bytes, base, paddingNibble);
    } else if (bitDepth == 2) {
        bytesToBase(bytes, base, paddingCrumb);
    } else if(bitDepth == 1) {
        bytesToBase(bytes, base, function(){});
    }else {
        bytesToBase(bytes, base);
    }
}

/**
 * Make a single value an array in case it is not.
 * If the value is a string it stays a string.
 * @param {!Array<number>|number|string} values The value or values.
 * @return {!Array<number>|string}
 */
function turnToArray(values) {
    if (!Array.isArray(values) && typeof values != "string") {
        values = [values];
    }
    return values;
}

/**
 * Turn a unsigned number to a signed number.
 * @param {number} number The number.
 * @param {number} maxValue The max range for the number bit depth.
 */
function signed(number, maxValue) {
    if (number > parseInt(maxValue / 2, 10) - 1) {
        number -= maxValue;
    }
    return number;
}

/**
 * Turn bytes to base 10.
 * @param {!Array<number>|Uint8Array} bytes The bytes as binary or hex strings.
 * @param {number} base The base.
 */
function bytesToInt(bytes, base) {
    if (base != 10) {
        let i = 0;
        let len = bytes.length;
        while(i < len) {
            bytes[i] = parseInt(bytes[i], base);
            i++;
        }
    }
}

module.exports.makeBigEndian = makeBigEndian;
module.exports.bytesToBase = bytesToBase;
module.exports.outputToBase = outputToBase;
module.exports.turnToArray = turnToArray;
module.exports.signed = signed;
module.exports.bytesToInt = bytesToInt;
module.exports.fixByteArraySize = fixByteArraySize;
module.exports.padding = padding;
module.exports.paddingNibble = paddingNibble;
module.exports.paddingCrumb = paddingCrumb;
module.exports.bytePadding = bytePadding;
module.exports.lPadZeros = lPadZeros;


1			/*
2			* helpers: functions to work with bytes and byte arrays.
3			* Copyright (c) 2017 Rafael da Silva Rocha.
4			* https://github.com/rochars/byte-data
5			*/
6
7			const endianness = require("endianness");
8			const bitDepths = require("../src/bit-depth.js");
9
10			/**
11			* Padding for binary strings.
12			* @param {!Array<string>} bytes The bytes as binary strings.
13			* @param {number} base The base.
14			* @param {number} index The byte to pad.
15			*/
16			function padding(bytes, base, index) {
17			bytes[index] = bytePadding(bytes[index], base);
18			}
19
20			/**
21			* Padding with 0s for byte strings.
22			* @param {string} byte The byte as a binary or hex string.
23			* @param {number} base The base.
24			* @returns {string} The padded byte.
25			*/
26			function bytePadding(byte, base) {
27			let offset = byte.length + 1;
28			if (base == 2) {
29			offset = 8;
30			} else if (base == 16) {
31			offset = 2;
32			}
33			return lPadZeros(byte, offset);
34			}
35
36			/**
37			* Fix the size of nibbles.
38			* @param {!Array<string>} nibbles The nibble as a binary or hex string.
39			* @param {number} base The base.
40			* @param {number} index The nibble offset.
41			*/
42			function paddingNibble(nibbles, base, index) {
43			if (base == 2 && nibbles[index].length < 4) {
44			nibbles[index] =
45			new Array((5 - nibbles[index].length)).join("0") + nibbles[index];
46			}
47			}
48
49			/**
50			* Fix the size of crumbs.
51			* @param {!Array<string>} crumbs The nibble as a binary or hex string.
52			* @param {number} base The base.
53			* @param {number} index The nibble offset.
54			*/
55			function paddingCrumb(crumbs, base, index) {
56			if ((base == 2 \|\| base == 16) && crumbs[index].length < 2) {
57			crumbs[index] = '0' + crumbs[index];
58			}
59			}
60
61			/**
62			* Pad a string with zeros to the left.
63			* TODO: This should support both arrays and strings.
64			* @param {string} value The string (representing a binary or hex value).
65			* @param {number} numZeros the max number of zeros.
66			* For 1 binary byte string it should be 8.
67			*/
68			function lPadZeros(value, numZeros) {
69			let i = 0;
			0 ignored issues – show Unused Code introduced 2017-11-12 04:26 UTC by Report Bug Copy Issue Report The variable `i` seems to be never used. Consider removing it. Loading history...
70			while (value.length < numZeros) {
71			value = '0' + value;
72			}
73			return value;
74			}
75
76			/**
77			* Pad a array with zeros to the right.
78			* @param {!Array<number>} byteArray The array.
79			* @param {number} numZeros the max number of zeros.
80			* For 1 binary byte string it should be 8.
81			* TODO: better explanation of numZeros
82			*/
83			function fixByteArraySize(byteArray, numZeros) {
84			let i = 0;
85			let fix = byteArray.length % numZeros;
86			if (fix) {
87			fix = (fix - numZeros) * -1;
88			while(i < fix) {
89			byteArray.push(0);
90			i++;
91			}
92			}
93			}
94
95			/**
96			* Swap the endianness to big endian.
97			* @param {!Array<number>} bytes The values.
98			* @param {boolean} isBigEndian True if the bytes should be big endian.
99			* @param {number} bitDepth The bitDepth of the data.
100			*/
101			function makeBigEndian(bytes, isBigEndian, bitDepth) {
102			if (isBigEndian) {
103			endianness.endianness(bytes, bitDepths.BitDepthOffsets[bitDepth]);
104			}
105			}
106
107			/**
108			* Turn bytes to base 2, 10 or 16.
109			* @param {!Array<string>\|!Array<number>} bytes The bytes.
110			* @param {number} base The base.
111			* @param {Function} padFunction The function to use for padding.
112			*/
113			function bytesToBase(bytes, base, padFunction=padding) {
114			if (base != 10) {
115			let i = 0;
116			let len = bytes.length;
117			while (i < len) {
118			bytes[i] = bytes[i].toString(base);
119			padFunction(bytes, base, i);
120			i++;
121			}
122			}
123			}
124
125			/**
126			* Turn the output to the correct base.
127			* @param {!Array<number>} bytes The bytes.
128			* @param {number} bitDepth The bit depth of the data.
129			* @param {number} base The desired base for the output data.
130			*/
131			function outputToBase(bytes, bitDepth, base) {
132			if (bitDepth == 4) {
133			bytesToBase(bytes, base, paddingNibble);
134			} else if (bitDepth == 2) {
135			bytesToBase(bytes, base, paddingCrumb);
136			} else if(bitDepth == 1) {
137			bytesToBase(bytes, base, function(){});
138			}else {
139			bytesToBase(bytes, base);
140			}
141			}
142
143			/**
144			* Make a single value an array in case it is not.
145			* If the value is a string it stays a string.
146			* @param {!Array<number>\|number\|string} values The value or values.
147			* @return {!Array<number>\|string}
148			*/
149			function turnToArray(values) {
150			if (!Array.isArray(values) && typeof values != "string") {
151			values = [values];
152			}
153			return values;
154			}
155
156			/**
157			* Turn a unsigned number to a signed number.
158			* @param {number} number The number.
159			* @param {number} maxValue The max range for the number bit depth.
160			*/
161			function signed(number, maxValue) {
162			if (number > parseInt(maxValue / 2, 10) - 1) {
163			number -= maxValue;
164			}
165			return number;
166			}
167
168			/**
169			* Turn bytes to base 10.
170			* @param {!Array<number>\|Uint8Array} bytes The bytes as binary or hex strings.
171			* @param {number} base The base.
172			*/
173			function bytesToInt(bytes, base) {
174			if (base != 10) {
175			let i = 0;
176			let len = bytes.length;
177			while(i < len) {
178			bytes[i] = parseInt(bytes[i], base);
179			i++;
180			}
181			}
182			}
183
184			module.exports.makeBigEndian = makeBigEndian;
185			module.exports.bytesToBase = bytesToBase;
186			module.exports.outputToBase = outputToBase;
187			module.exports.turnToArray = turnToArray;
188			module.exports.signed = signed;
189			module.exports.bytesToInt = bytesToInt;
190			module.exports.fixByteArraySize = fixByteArraySize;
191			module.exports.padding = padding;
192			module.exports.paddingNibble = paddingNibble;
193			module.exports.paddingCrumb = paddingCrumb;
194			module.exports.bytePadding = bytePadding;
195			module.exports.lPadZeros = lPadZeros;
196

rochars / byte-data

Push — master ( 7c19a0...ad5e1b )

helpers.js ➔ turnToArray A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like