rochars / byte-data

 * type: The Type class.

 * Copyright (c) 2017-2018 Rafael da Silva Rocha.

 * https://github.com/rochars/byte-data

 */

/** @private */

var int8 = new Int8Array(4);

/** @private */

var i32 = new Int32Array(int8.buffer, 0, 1);

/** @private */

var f32 = new Float32Array(int8.buffer, 0, 1);

/** @private */

var int8f64 = new Int8Array(8);

/** @private */

let f64 = new Float64Array(int8f64.buffer);

/** @private */

let ui32 = new Uint32Array(int8f64.buffer);

/** @private */

let GenericInteger = require("generic-integer");

/**

 * A class to represent byte-data types.

 */

class Type extends GenericInteger {

    /**

     * @param {Object} options The type definition.

     */

    /**

     * Read 1 16-bit float from from bytes.

     * Thanks https://stackoverflow.com/a/8796597

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

     * @param {number} i The index to read.

     * @return {number}

     * @private

     */

    read16F_(bytes, i) {

        let type = new GenericInteger(16);

        let int = type.read(bytes, i);

        let exponent = (int & 0x7C00) >> 10;

        let fraction = int & 0x03FF;

        let floatValue;

        if (exponent) {

            floatValue =  Math.pow(2, exponent - 15) * (1 + fraction / 0x400);

        } else {

            floatValue = 6.103515625e-5 * (fraction / 0x400);

        }

        return floatValue * (int >> 15 ? -1 : 1);

    }

    /**

     * Read 1 32-bit float from bytes.

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

     * @param {number} i The index to read.

     * @return {number}

     * @private

     */

    read32F_(bytes, i) {

        i32[0] = this.read(bytes, i);

        return f32[0];

    }

    /**

     * Read 1 64-bit double from bytes.

     * Thanks https://gist.github.com/kg/2192799

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

     * @param {number} i The index to read.

     * @return {number}

     * @private

     */

    read64F_(bytes, i) {

        let type32 = new Type({"bits": 32});

        ui32[0] = type32.read(bytes, i);

        ui32[1] = type32.read(bytes, i + 4);

        return f64[0];

    }

    /**

     * Read 1 char from bytes.

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

     * @param {number} i The index to read.

     * @return {string}

     * @private

     */

    readChar_(bytes, i) {

        let chrs = "";

        for(let j=0; j < this.offset; j++) {

            chrs += String.fromCharCode(bytes[i+j]);

        }

        return chrs;

    }

    /**

     * Write one 64-bit float as a binary value.

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

     * @param {number} number The number to write as bytes.

     * @param {number} j The index being written in the byte buffer.

     * @return {number} The next index to write on the byte buffer.

     * @private

     */

    write64F_(bytes, number, j) {

        f64[0] = number;

        let type = new Type({"bits": 32});

        j = type.write(bytes, ui32[0], j);

        return type.write(bytes, ui32[1], j);

    }

    /**

     * Write one 32-bit float as a binary value.

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

     * @param {number} number The number to write as bytes.

     * @param {number} j The index being written in the byte buffer.

     * @return {number} The next index to write on the byte buffer.

     * @private

     */

    write32F_(bytes, number, j) {

        f32[0] = number;

        j = this.write(bytes, i32[0], j);

        return j;

    }

    /**

     * Write one 16-bit float as a binary value.

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

     * @param {number} number The number to write as bytes.

     * @param {number} j The index being written in the byte buffer.

     * @return {number} The next index to write on the byte buffer.

     * @private

     */

    write16F_(bytes, number, j) {

        f32[0] = number;

        let x = i32[0];

        let bits = (x >> 16) & 0x8000;

        let m = (x >> 12) & 0x07ff;

        let e = (x >> 23) & 0xff;

        if (e >= 103) {

            bits |= ((e - 112) << 10) | (m >> 1);

            bits += m & 1;

        }

        bytes[j++] = bits & 0xFF;

        bytes[j++] = bits >>> 8 & 0xFF;

        return j;

    }

    /**

     * Write one char as a byte.

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

     * @param {string} string The string to write as bytes.

     * @param {number} j The index being written in the byte buffer.

     * @return {number} The next index to write on the byte buffer.

     * @private

     */

    writeChar_(bytes, string, j) {

        bytes[j++] = string.charCodeAt(0);

        return j;

    }

    /**

     * Build the type.

     * @private

     */

    buildType_() {

        this.setReader_();

        this.setWriter_();

        if (this.float) {

            this.min = -Infinity;

            this.max = Infinity;

        }

    }

    /**

     * Set the function to read data of this type.

     * @private

     */

    setReader_() {

        if (this.float) {

            if (this.bits == 16) {

                this.reader = this.read16F_;

            } else if(this.bits == 32) {

                this.reader = this.read32F_;

            } else if(this.bits == 64) {

                this.reader = this.read64F_;

            }

        } else if (this.char) {

            this.reader = this.readChar_;

        }

    }

    /**

     * Set the function to write data of this type.

     * @private

     */

    setWriter_() {

        if (this.float) {

            if (this.bits == 16) {

                this.writer = this.write16F_;

            } else if(this.bits == 32) {

                this.writer = this.write32F_;

            } else if(this.bits == 64) {

                this.writer = this.write64F_;

            }

        } else if (this.char) {

            this.writer = this.writeChar_;

        }

    }

}

module.exports = Type;