node-aurora/lib/AuroraTransformBinary.js

Provides an interface to the Aurora Dreamband.

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of");

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require("babel-runtime/helpers/createClass");

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn");

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _inherits2 = require("babel-runtime/helpers/inherits");

var _inherits3 = _interopRequireDefault(_inherits2);

var _stream = require("stream");

var _stream2 = _interopRequireDefault(_stream);

var _binaryParser = require("binary-parser");

var _AuroraConstants = require("./AuroraConstants");

var _AuroraConstants2 = _interopRequireDefault(_AuroraConstants);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var AuroraTransformBinary = function (_Stream$Transform) {
    (0, _inherits3.default)(AuroraTransformBinary, _Stream$Transform);

    function AuroraTransformBinary() {
        var dataType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _AuroraConstants2.default.DataTypes.UINT8;
        (0, _classCallCheck3.default)(this, AuroraTransformBinary);

        var _this = (0, _possibleConstructorReturn3.default)(this, (AuroraTransformBinary.__proto__ || (0, _getPrototypeOf2.default)(AuroraTransformBinary)).call(this, { encoding: null }));

        _this.dataType = dataType;
        _this.parseType = _this._getParseTypeFromDataType(dataType);
        _this.parseTypeLength = _this._getParseTypeLengthFromDataType(dataType);

        _this.parser = new _binaryParser.Parser();

        _this.leftoverBuffer = null;
        _this.hasData = false;

        _this.parser.array('values', {
            type: _this.parseType,
            readUntil: 'eof',
            formatter: function formatter(values) {
                return values.join(',');
            }
        });
        return _this;
    }

    (0, _createClass3.default)(AuroraTransformBinary, [{
        key: "_transform",
        value: function _transform(respChunk, encoding, done) {

            if (!respChunk.length) {

                done();
                return;
            }

            if (Buffer.isBuffer(this.leftoverBuffer)) {

                respChunk = Buffer.concat([this.leftoverBuffer, respChunk], this.leftoverBuffer.length + respChunk.length);
                this.leftoverBuffer = null;
            }

            if (respChunk.length < this.parseTypeLength) {

                this.leftoverBuffer = respChunk;
                done();
                return;
            }

            var numBytesLeftover = respChunk.length % this.parseTypeLength;

            var parsedChunk = void 0;

            if (numBytesLeftover) {

                parsedChunk = this.parser.parse(respChunk.slice(0, -numBytesLeftover));

                this.leftoverBuffer = respChunk.slice(-numBytesLeftover);
            } else {

                parsedChunk = this.parser.parse(respChunk);
            }

            this.push((this.hasData ? ',' : '') + parsedChunk.values);

            this.hasData = true;

            done();
        }
    }, {
        key: "_flush",
        value: function _flush(done) {

            if (this.leftoverBuffer) {
                console.log("Unparsed binary buffer: ", this.leftoverBuffer);
            }

            this.hasData = false;

            done();
        }
    }, {
        key: "_getParseTypeFromDataType",
        value: function _getParseTypeFromDataType(dataType) {

            switch (dataType) {

                case _AuroraConstants2.default.DataTypes.INT8:
                    return 'int8';

                case _AuroraConstants2.default.DataTypes.UINT16:
                    return 'uint16le';

                case _AuroraConstants2.default.DataTypes.INT16:
                    return 'int16le';

                case _AuroraConstants2.default.DataTypes.FLOAT:
                    return 'floatle';

                case _AuroraConstants2.default.DataTypes.UINT32:
                case _AuroraConstants2.default.DataTypes.STR:
                case _AuroraConstants2.default.DataTypes.PTR:

                    return 'uint32le';

                case _AuroraConstants2.default.DataTypes.INT32:
                    return 'int32le';

                case _AuroraConstants2.default.DataTypes.UINT8:
                case _AuroraConstants2.default.DataTypes.CHAR:
                default:
                    return 'uint8';

            }
        }
    }, {
        key: "_getParseTypeLengthFromDataType",
        value: function _getParseTypeLengthFromDataType(dataType) {

            switch (dataType) {

                case _AuroraConstants2.default.DataTypes.UINT16:
                case _AuroraConstants2.default.DataTypes.INT16:
                    return 2;

                case _AuroraConstants2.default.DataTypes.UINT32:
                case _AuroraConstants2.default.DataTypes.FLOAT:
                case _AuroraConstants2.default.DataTypes.STR:
                case _AuroraConstants2.default.DataTypes.PTR:
                case _AuroraConstants2.default.DataTypes.INT32:
                    return 4;

                case _AuroraConstants2.default.DataTypes.UINT8:
                case _AuroraConstants2.default.DataTypes.CHAR:
                case _AuroraConstants2.default.DataTypes.INT8:
                default:
                    return 1;

            }
        }
    }]);
    return AuroraTransformBinary;
}(_stream2.default.Transform);

exports.default = AuroraTransformBinary;