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

Passed

Push — master ( 2cddad...eee927 )

by Rafael S.

created 2017-12-03 09:02 UTC

helpers.js ➔ buildType A

↳ Parent: src/helpers.js

Complexity

Conditions	3
Paths	4

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	4
nop	2
dl	0
loc	9
rs	9.6666

/*
 * 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} theByte The byte as a binary or hex string.
 * @param {number} base The base.
 * @returns {string} The padded byte.
 */
function bytePadding(theByte, base) {
    let offset = theByte.length + 1;
    if (base == 2) {
        offset = 8;
    } else if (base == 16) {
        offset = 2;
    }
    return lPadZeros(theByte, 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) {
    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(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} num The number.
 * @param {number} maxValue The max range for the number bit depth.
 */
function signed(num, maxValue) {
    if (num > parseInt(maxValue / 2, 10) - 1) {
        num -= maxValue;
    }
    return num;
}

/**
 * Fix the endianness of float16 bytes (r/w is always big-endian).
 * @param {!Array<number>|Uint8Array} bytes The bytes.
 * @param {Object} options The type.
 */
function fixFloat16Endianness(bytes, options) {
    if (options.float && options.bits == 16) {
        endianness(bytes, 2);
    }
}

/**
 * Build a type based on the arguments.
 * @param {Object} options The type.
 * @param {number} bitDepth The bit depth.
 */
function buildType(options, bitDepth) {
    if (bitDepth == 64) {
        options.float = true;
    }
    if (options.float) {
        options.signed = true;
    }
    options.bits = bitDepth;
}

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


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} theByte The byte as a binary or hex string.
23			* @param {number} base The base.
24			* @returns {string} The padded byte.
25			*/
26			function bytePadding(theByte, base) {
27			let offset = theByte.length + 1;
28			if (base == 2) {
29			offset = 8;
30			} else if (base == 16) {
31			offset = 2;
32			}
33			return lPadZeros(theByte, 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			while (value.length < numZeros) {
70			value = '0' + value;
71			}
72			return value;
73			}
74
75			/**
76			* Pad a array with zeros to the right.
77			* @param {!Array<number>} byteArray The array.
78			* @param {number} numZeros the max number of zeros.
79			* For 1 binary byte string it should be 8.
80			* TODO: better explanation of numZeros
81			*/
82			function fixByteArraySize(byteArray, numZeros) {
83			let i = 0;
84			let fix = byteArray.length % numZeros;
85			if (fix) {
86			fix = (fix - numZeros) * -1;
87			while(i < fix) {
88			byteArray.push(0);
89			i++;
90			}
91			}
92			}
93
94			/**
95			* Swap the endianness to big endian.
96			* @param {!Array<number>} bytes The values.
97			* @param {boolean} isBigEndian True if the bytes should be big endian.
98			* @param {number} bitDepth The bitDepth of the data.
99			*/
100			function makeBigEndian(bytes, isBigEndian, bitDepth) {
101			if (isBigEndian) {
102			endianness(bytes, bitDepths.BitDepthOffsets[bitDepth]);
103			}
104			}
105
106			/**
107			* Turn bytes to base 2, 10 or 16.
108			* @param {!Array<string>\|!Array<number>} bytes The bytes.
109			* @param {number} base The base.
110			* @param {Function} padFunction The function to use for padding.
111			*/
112			function bytesToBase(bytes, base, padFunction=padding) {
113			if (base != 10) {
114			let i = 0;
115			let len = bytes.length;
116			while (i < len) {
117			bytes[i] = bytes[i].toString(base);
118			padFunction(bytes, base, i);
119			i++;
120			}
121			}
122			}
123
124			/**
125			* Turn the output to the correct base.
126			* @param {!Array<number>} bytes The bytes.
127			* @param {number} bitDepth The bit depth of the data.
128			* @param {number} base The desired base for the output data.
129			*/
130			function outputToBase(bytes, bitDepth, base) {
131			if (bitDepth == 4) {
132			bytesToBase(bytes, base, paddingNibble);
133			} else if (bitDepth == 2) {
134			bytesToBase(bytes, base, paddingCrumb);
135			} else if(bitDepth == 1) {
136			bytesToBase(bytes, base, function(){});
137			}else {
138			bytesToBase(bytes, base);
139			}
140			}
141
142			/**
143			* Make a single value an array in case it is not.
144			* If the value is a string it stays a string.
145			* @param {!Array<number>\|number\|string} values The value or values.
146			* @return {!Array<number>\|string}
147			*/
148			function turnToArray(values) {
149			if (!Array.isArray(values) && typeof values != "string") {
150			values = [values];
151			}
152			return values;
153			}
154
155			/**
156			* Turn a unsigned number to a signed number.
157			* @param {number} num The number.
158			* @param {number} maxValue The max range for the number bit depth.
159			*/
160			function signed(num, maxValue) {
161			if (num > parseInt(maxValue / 2, 10) - 1) {
162			num -= maxValue;
163			}
164			return num;
165			}
166
167			/**
168			* Fix the endianness of float16 bytes (r/w is always big-endian).
169			* @param {!Array<number>\|Uint8Array} bytes The bytes.
170			* @param {Object} options The type.
171			*/
172			function fixFloat16Endianness(bytes, options) {
173			if (options.float && options.bits == 16) {
174			endianness(bytes, 2);
175			}
176			}
177
178			/**
179			* Build a type based on the arguments.
180			* @param {Object} options The type.
181			* @param {number} bitDepth The bit depth.
182			*/
183			function buildType(options, bitDepth) {
184			if (bitDepth == 64) {
185			options.float = true;
186			}
187			if (options.float) {
188			options.signed = true;
189			}
190			options.bits = bitDepth;
191			}
192
193			module.exports.makeBigEndian = makeBigEndian;
194			module.exports.bytesToBase = bytesToBase;
195			module.exports.outputToBase = outputToBase;
196			module.exports.turnToArray = turnToArray;
197			module.exports.signed = signed;
198			module.exports.fixByteArraySize = fixByteArraySize;
199			module.exports.padding = padding;
200			module.exports.paddingNibble = paddingNibble;
201			module.exports.paddingCrumb = paddingCrumb;
202			module.exports.bytePadding = bytePadding;
203			module.exports.lPadZeros = lPadZeros;
204			module.exports.fixFloat16Endianness = fixFloat16Endianness;
205			module.exports.buildType = buildType;
206

rochars / byte-data

Push — master ( 2cddad...eee927 )

helpers.js ➔ buildType A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like