rochars / byte-data

const Type = require("../src/type");

const endianness = require("endianness");

/**

 * Turn a byte buffer into what the bytes represent.

 * @param {!Array<number>|!Array<string>|Uint8Array} buffer An array of bytes.

 * @param {Object} type One of the available types.

 * @return {!Array<number>|number|string}

 */

function fromBytes(buffer, type) {

    if (type.be) {

        endianness(buffer, type.offset);

    }

    if (type.base != 10) {

        bytesFromBase(buffer, type.base);

    }

    return readBytes(buffer, type);

}

/**

 * Turn numbers and strings to bytes.

 * @param {!Array<number>|number|string} values The data.

 * @param {Object} type One of the available types.

 * @return {!Array<number>|!Array<string>} the data as a byte buffer.

 */

function toBytes(values, type) {

    let bytes = writeBytes(values, type);

    if (type.be) {

        endianness(bytes, type.offset);

    }

    if (type.base != 10) {

        bytesToBase(bytes, type.base);

        formatOutput(bytes, type);

    }

    return bytes;

}

/**

 * Turn a array of bytes into an array of what the bytes should represent.

 * @param {!Array<number>|Uint8Array} bytes An array of bytes.

 * @param {Object} type The type.

 * @return {!Array<number>|string}

 */

function readBytes(bytes, type) {

    let values = [];

    let i = 0;

    let len = bytes.length - (type.offset - 1);

    while (i < len) {

        values.push(

                type.overflow(type.sign(type.reader(bytes, i, type)))

            );

        i += type.offset;

    }

    if (type.char) {

        values = values.join("");

    }

    return values;

}

/**

 * Write values as bytes.

 * @param {!Array<number>|number|string} values The data.

 * @param {Object} type One of the available types.

 * @return {!Array<number>} the bytes.

 */

function writeBytes(values, type) {

    let i = 0;

    let j = 0;

    let len = values.length;

    let bytes = [];

    while (i < len) {

        j = type.writer(bytes, type.overflow(values[i]), j);

        i++;

    }

    return bytes;

}

/**

 * Get the full type spec for the reading/writing.

 * @param {Object} type One of the available types.

 * @param {number} base The base of the input.

 * @return {Object}

 */

function getType(type, base) {

    let theType = Object.assign(new Type({}), type);

    theType.base = base;

    return theType;

}

/**

 * Turn bytes to base 10 from base 2 or 16.

 * @param {!Array<number>|Uint8Array} bytes The bytes as binary or hex strings.

 * @param {number} base The base.

 */

function bytesFromBase(bytes, base) {

    let i = 0;

    let len = bytes.length;

    while(i < len) {

        bytes[i] = parseInt(bytes[i], base);

        i++;

    }

}

/**

 * Turn the output to the correct base.

 * @param {Array} bytes The bytes.

 * @param {Object} type The type.

 */

function formatOutput(bytes, type) {

    let i = 0;

    let len = bytes.length;

    let offset = getOutputByteOffset(type);

    while(i < len) {

        bytes[i] = Array(offset - bytes[i].length).join("0") + bytes[i];

        i++;

    }

}

/**

 * Get the number of chars a non-string output should have

 * according to the number of bits used by the type.

 * @param {Object} type The type.

 * @return {number}

 */

function getOutputByteOffset(type) {

    return (type.base == 2 ? 8 : 2) + 1;

}

/**

 * Turn bytes from base 10 to base 2 or 16.

 * @param {!Array<string>|Array<number>} bytes The bytes.

 * @param {number} base The base.

 */

function bytesToBase(bytes, base) {

    let i = 0;

    let len = bytes.length;

    while (i < len) {

        bytes[i] = bytes[i].toString(base);

        i++;

    }

}

exports.getType = getType;

exports.toBytes = toBytes;

exports.fromBytes = fromBytes;