hjs-future/lib/future.js

Future classes of Hubrijs framework

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.RunnableFuture = exports.Future = exports.FutureState = exports.RunnableAdapter = exports.RunnablePromise = exports.Callable = undefined;

var _promise = require("babel-runtime/core-js/promise");

var _promise2 = _interopRequireDefault(_promise);

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 _events = require("events");

var _events2 = _interopRequireDefault(_events);

var _time = require("hjs-core/lib/time");

var _handler = require("hjs-message/lib/handler");

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

var Callable = exports.Callable = function (_EventEmitter) {
    (0, _inherits3.default)(Callable, _EventEmitter);

    function Callable() {
        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref$compute = _ref.compute,
            compute = _ref$compute === undefined ? null : _ref$compute;

        (0, _classCallCheck3.default)(this, Callable);

        var _this = (0, _possibleConstructorReturn3.default)(this, (Callable.__proto__ || (0, _getPrototypeOf2.default)(Callable)).call(this));

        if (compute) {
            _this.compute = compute;
        }
        _this.mResult = null;
        return _this;
    }

    (0, _createClass3.default)(Callable, [{
        key: "cancel",
        value: function cancel() {
            this.emit(Callable.CANCEL);
        }
    }, {
        key: "call",
        value: function call() {
            if (this.mResult === null || this.mResult === undefined) {
                this.compute();
            }
            return this.mResult;
        }
    }, {
        key: "compute",
        value: function compute() {}
    }, {
        key: "getResult",
        value: function getResult() {
            return this.mResult;
        }
    }, {
        key: "signal",
        value: function signal() {
            var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

            this.emit(Callable.COMPUTE, this.mResult = result);
        }
    }]);
    return Callable;
}(_events2.default); /** @babel */


Callable.COMPUTE = "compute";
Callable.CANCEL = "cancel";

var RunnablePromise = exports.RunnablePromise = function (_Runnable) {
    (0, _inherits3.default)(RunnablePromise, _Runnable);

    function RunnablePromise() {
        var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref2$handlePromise = _ref2.handlePromise,
            handlePromise = _ref2$handlePromise === undefined ? null : _ref2$handlePromise,
            _ref2$process = _ref2.process,
            process = _ref2$process === undefined ? null : _ref2$process;

        (0, _classCallCheck3.default)(this, RunnablePromise);

        var _this2 = (0, _possibleConstructorReturn3.default)(this, (RunnablePromise.__proto__ || (0, _getPrototypeOf2.default)(RunnablePromise)).call(this));

        if (handlePromise) {
            _this2.handlePromise = handlePromise;
        }
        if (process) {
            _this2.process = process;
        }
        return _this2;
    }

    (0, _createClass3.default)(RunnablePromise, [{
        key: "handlePromise",
        value: function handlePromise(result) {}
    }, {
        key: "process",
        value: function process(resolve, reject) {}
    }, {
        key: "run",
        value: function run() {
            var _this3 = this;

            var p = new _promise2.default(function (resolve, reject) {
                _this3.process(resolve, reject);
            });
            p.then(function (result) {
                _this3.handlePromise(result);
            }).catch(function (e) {
                _this3.handlePromise(e);
            });
        }
    }]);
    return RunnablePromise;
}(_handler.Runnable);

var RunnableAdapter = exports.RunnableAdapter = function (_Callable) {
    (0, _inherits3.default)(RunnableAdapter, _Callable);

    function RunnableAdapter(_ref3) {
        var task = _ref3.task,
            _ref3$result = _ref3.result,
            result = _ref3$result === undefined ? null : _ref3$result;
        (0, _classCallCheck3.default)(this, RunnableAdapter);

        var _this4 = (0, _possibleConstructorReturn3.default)(this, (RunnableAdapter.__proto__ || (0, _getPrototypeOf2.default)(RunnableAdapter)).call(this));

        if (!task) {
            throw new ReferenceError('NullPointerException');
        }
        _this4.mTask = task;
        _this4.mResult = null;
        _this4.mDefaultResult = result;
        return _this4;
    }

    (0, _createClass3.default)(RunnableAdapter, [{
        key: "compute",
        value: function compute() {
            this.mTask.run(this);
        }
    }, {
        key: "getTask",
        value: function getTask() {
            return this.mTask;
        }
    }, {
        key: "signal",
        value: function signal() {
            var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

            if (result === null || result === undefined) {
                this.emit(Callable.COMPUTE, this.mResult = this.mDefaultResult);
            } else {
                this.emit(Callable.COMPUTE, this.mResult = result);
            }
        }
    }]);
    return RunnableAdapter;
}(Callable);

var FutureState = exports.FutureState = {
    NEW: 0,
    COMPLETING: 1,
    NORMAL: 2,
    EXCEPTIONAL: 3,
    CANCELLED: 4,
    INTERRUPTING: 5,
    INTERRUPTED: 6
};

var Future = exports.Future = function (_EventEmitter2) {
    (0, _inherits3.default)(Future, _EventEmitter2);

    function Future() {
        (0, _classCallCheck3.default)(this, Future);
        return (0, _possibleConstructorReturn3.default)(this, (Future.__proto__ || (0, _getPrototypeOf2.default)(Future)).call(this));
    }

    (0, _createClass3.default)(Future, [{
        key: "cancel",
        value: function cancel() {
            var mayInterruptIfRunning = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

            return false;
        }
    }, {
        key: "get",
        value: function get() {
            var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                _ref4$timeout = _ref4.timeout,
                timeout = _ref4$timeout === undefined ? 0 : _ref4$timeout,
                _ref4$unit = _ref4.unit,
                unit = _ref4$unit === undefined ? _time.MILLISECONDS : _ref4$unit,
                _ref4$done = _ref4.done,
                done = _ref4$done === undefined ? null : _ref4$done;

            return null;
        }
    }, {
        key: "isCancelled",
        value: function isCancelled() {
            return false;
        }
    }, {
        key: "isDone",
        value: function isDone() {
            return false;
        }
    }]);
    return Future;
}(_events2.default);

Future.DONE = "done";

var RunnableFuture = exports.RunnableFuture = function (_Future) {
    (0, _inherits3.default)(RunnableFuture, _Future);

    function RunnableFuture() {
        (0, _classCallCheck3.default)(this, RunnableFuture);
        return (0, _possibleConstructorReturn3.default)(this, (RunnableFuture.__proto__ || (0, _getPrototypeOf2.default)(RunnableFuture)).call(this));
    }

    (0, _createClass3.default)(RunnableFuture, [{
        key: "run",
        value: function run() {}
    }]);
    return RunnableFuture;
}(Future);