hjs-future/lib/executor.js

Future classes of Hubrijs framework

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.Executors = exports.ParallelExecutor = exports.BlockingExecutor = exports.SerialExecutor = exports.ExecutorService = exports.Executor = 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 _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

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

var _inherits3 = _interopRequireDefault(_inherits2);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

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

var _list = require('hjs-collection/lib/list');

var _queue = require('hjs-collection/lib/queue');

var _future = require('./future');

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

/** @babel */
var Executor = exports.Executor = function () {
    function Executor() {
        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref$execute = _ref.execute,
            execute = _ref$execute === undefined ? null : _ref$execute;

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

        if (execute) {
            this.execute = execute;
        }
    }

    (0, _createClass3.default)(Executor, [{
        key: 'execute',
        value: function execute(r) {
            if (!r) {
                throw new ReferenceError("NullPointerException");
            }
            if (!r.run) {
                throw new TypeError("Not a runnable object");
            }

            for (var _len = arguments.length, params = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                params[_key - 1] = arguments[_key];
            }

            return r.run.apply(r, params);
        }
    }]);
    return Executor;
}();

var ExecutorService = exports.ExecutorService = function (_Executor) {
    (0, _inherits3.default)(ExecutorService, _Executor);

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

    (0, _createClass3.default)(ExecutorService, [{
        key: 'awaitTermination',
        value: function awaitTermination() {
            var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                _ref2$timeout = _ref2.timeout,
                timeout = _ref2$timeout === undefined ? 0 : _ref2$timeout,
                _ref2$unit = _ref2.unit,
                unit = _ref2$unit === undefined ? _time.MILLISECONDS : _ref2$unit,
                _ref2$callback = _ref2.callback,
                callback = _ref2$callback === undefined ? null : _ref2$callback;

            return false;
        }
    }, {
        key: 'invokeAll',
        value: function invokeAll() {
            var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                tasks = _ref3.tasks,
                _ref3$timeout = _ref3.timeout,
                timeout = _ref3$timeout === undefined ? 0 : _ref3$timeout,
                _ref3$unit = _ref3.unit,
                unit = _ref3$unit === undefined ? _time.MILLISECONDS : _ref3$unit,
                _ref3$callback = _ref3.callback,
                callback = _ref3$callback === undefined ? null : _ref3$callback;

            return null;
        }
    }, {
        key: 'invokeAny',
        value: function invokeAny() {
            var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                tasks = _ref4.tasks,
                _ref4$ecs = _ref4.ecs,
                ecs = _ref4$ecs === undefined ? null : _ref4$ecs,
                _ref4$timeout = _ref4.timeout,
                timeout = _ref4$timeout === undefined ? 0 : _ref4$timeout,
                _ref4$unit = _ref4.unit,
                unit = _ref4$unit === undefined ? _time.MILLISECONDS : _ref4$unit,
                _ref4$callback = _ref4.callback,
                callback = _ref4$callback === undefined ? null : _ref4$callback;

            return null;
        }
    }, {
        key: 'isShutdown',
        value: function isShutdown() {
            return false;
        }
    }, {
        key: 'isTerminated',
        value: function isTerminated() {
            return false;
        }
    }, {
        key: 'shutdown',
        value: function shutdown() {}
    }, {
        key: 'shutdownNow',
        value: function shutdownNow() {
            return null;
        }
    }, {
        key: 'submit',
        value: function submit() {
            var _ref5 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                _ref5$callable = _ref5.callable,
                callable = _ref5$callable === undefined ? null : _ref5$callable,
                _ref5$runnable = _ref5.runnable,
                runnable = _ref5$runnable === undefined ? null : _ref5$runnable,
                _ref5$result = _ref5.result,
                result = _ref5$result === undefined ? null : _ref5$result,
                _ref5$done = _ref5.done,
                done = _ref5$done === undefined ? null : _ref5$done;

            return null;
        }
    }]);
    return ExecutorService;
}(Executor);

var SerialExecutor = exports.SerialExecutor = function (_Executor2) {
    (0, _inherits3.default)(SerialExecutor, _Executor2);

    function SerialExecutor() {
        var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref6$capacity = _ref6.capacity,
            capacity = _ref6$capacity === undefined ? 10 : _ref6$capacity,
            _ref6$queue = _ref6.queue,
            queue = _ref6$queue === undefined ? null : _ref6$queue;

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

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

        if (queue) {
            _this2.mTasks = queue;
        } else {
            _this2.mTasks = new _queue.Queue(capacity);
        }
        _this2.mResults = [];
        _this2.mActive = null;
        return _this2;
    }

    (0, _createClass3.default)(SerialExecutor, [{
        key: 'active',
        value: function active() {
            if (this.mTasks) {
                return this.mTasks.peek();
            }
            return null;
        }
    }, {
        key: 'execute',
        value: function execute() {
            var _this3 = this;

            for (var _len2 = arguments.length, params = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
                params[_key2 - 1] = arguments[_key2];
            }

            var r = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

            if (!r) {
                throw new ReferenceError("NullPointerException");
            }
            if (!r.run) {
                throw new TypeError("Not a runnable object");
            }
            if (this.isEmpty()) {
                this.mResults = [];
            }
            if (this.mTasks.offer({
                get task() {
                    return r;
                },
                run: function run() {
                    try {
                        _this3.mResults.push(r.run.apply(r, params));
                    } catch (e) {
                        console.error(e);
                    } finally {
                        _this3.scheduleNext();
                    }
                }
            }) && this.mActive) {
                return this.scheduleNext();
            }
            return this;
        }
    }, {
        key: 'getPromiseResults',
        value: function getPromiseResults() {
            return _promise2.default.all(this.scheduleNext().getResults());
        }
    }, {
        key: 'getResults',
        value: function getResults() {
            return this.mResults;
        }
    }, {
        key: 'isActive',
        value: function isActive() {
            return this.active() !== null;
        }
    }, {
        key: 'isEmpty',
        value: function isEmpty() {
            if (this.mTasks) {
                return this.mTasks.isEmpty();
            }
            return true;
        }
    }, {
        key: 'isBlocked',
        value: function isBlocked() {
            return !(this.isEmpty() && this.isActive());
        }
    }, {
        key: 'scheduleNext',
        value: function scheduleNext() {
            if ((this.mActive = this.mTasks.poll()) !== null) {
                try {
                    this.mActive.run();
                } catch (e) {
                    console.log(e);
                }
            }
            return this;
        }
    }, {
        key: 'size',
        value: function size() {
            if (this.mTasks) {
                return this.mTasks.size();
            }
            return 0;
        }
    }, {
        key: 'unblock',
        value: function unblock() {
            if (this.isBlocked()) {
                this.scheduleNext();
            }
        }
    }]);
    return SerialExecutor;
}(Executor);

var BlockingExecutor = exports.BlockingExecutor = function (_SerialExecutor) {
    (0, _inherits3.default)(BlockingExecutor, _SerialExecutor);

    function BlockingExecutor() {
        var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref7$capacity = _ref7.capacity,
            capacity = _ref7$capacity === undefined ? 10 : _ref7$capacity,
            _ref7$queue = _ref7.queue,
            queue = _ref7$queue === undefined ? null : _ref7$queue;

        (0, _classCallCheck3.default)(this, BlockingExecutor);
        return (0, _possibleConstructorReturn3.default)(this, (BlockingExecutor.__proto__ || (0, _getPrototypeOf2.default)(BlockingExecutor)).call(this, { capacity: capacity, queue: queue }));
    }

    (0, _createClass3.default)(BlockingExecutor, [{
        key: 'execute',
        value: function execute() {
            var _this5 = this;

            for (var _len3 = arguments.length, params = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
                params[_key3 - 1] = arguments[_key3];
            }

            var r = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

            if (!r) {
                throw new ReferenceError("NullPointerException");
            }
            if (!r.run) {
                throw new TypeError("Not a runnable object");
            }
            if (this.isEmpty()) {
                this.mResults = [];
            }
            if (this.mTasks.offer({
                get task() {
                    return r;
                },
                run: function run() {
                    try {
                        _this5.mResults.push(r.run.apply(r, params));
                    } catch (e) {
                        console.log(e);
                    }
                }
            }) && this.mActive) {
                return this.scheduleNext();
            }
            return this;
        }
    }]);
    return BlockingExecutor;
}(SerialExecutor);

var ParallelExecutor = exports.ParallelExecutor = function (_Executor3) {
    (0, _inherits3.default)(ParallelExecutor, _Executor3);

    function ParallelExecutor() {
        var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref8$capacity = _ref8.capacity,
            capacity = _ref8$capacity === undefined ? 10 : _ref8$capacity,
            _ref8$queue = _ref8.queue,
            queue = _ref8$queue === undefined ? new _list.LinkedList() : _ref8$queue;

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

        var _this6 = (0, _possibleConstructorReturn3.default)(this, (ParallelExecutor.__proto__ || (0, _getPrototypeOf2.default)(ParallelExecutor)).call(this));

        _this6.mResults = [];
        _this6.mActive = null;
        _this6.mTasks = queue;
        _this6.mCapacity = capacity;
        return _this6;
    }

    (0, _createClass3.default)(ParallelExecutor, [{
        key: 'active',
        value: function active() {
            if (this.mActive) {
                return this.mActive;
            }
            return null;
        }
    }, {
        key: 'execute',
        value: function execute() {
            var _this7 = this;

            for (var _len4 = arguments.length, params = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
                params[_key4 - 1] = arguments[_key4];
            }

            var r = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

            if (!r) {
                throw new ReferenceError("NullPointerException");
            }
            if (!r.run) {
                throw new TypeError("Not a runnable object");
            }
            if (this.mActive) {
                this.mActive = null;
            }
            if (this.isEmpty()) {
                this.mResults = [];
            }
            var task = {
                get task() {
                    return r;
                },
                run: function run() {
                    try {
                        _this7.mResults.push(r.run.apply(r, params));
                    } catch (e) {
                        console.error(e);
                    }
                }
            };
            this.mActive = task;
            var rejected = !this.mTasks.offer(task);
            this.executeAll();
            if (rejected) {
                this.mTasks.offer(task);
            }
            return this;
        }
    }, {
        key: 'executeAll',
        value: function executeAll() {
            if (this.isFull()) {
                var r = null;
                while (r = this.mTasks.poll()) {
                    try {
                        r.run();
                    } catch (e) {
                        console.log(e);
                    }
                }
            }
            return this;
        }
    }, {
        key: 'getPromiseResults',
        value: function getPromiseResults() {
            return _promise2.default.all(this.getResults());
        }
    }, {
        key: 'getResults',
        value: function getResults() {
            return this.mResults;
        }
    }, {
        key: 'isActive',
        value: function isActive() {
            return this.active() !== null;
        }
    }, {
        key: 'isBlocked',
        value: function isBlocked() {
            return !this.isFull();
        }
    }, {
        key: 'isEmpty',
        value: function isEmpty() {
            if (this.mTasks) {
                return this.mTasks.isEmpty();
            }
            return true;
        }
    }, {
        key: 'isFull',
        value: function isFull() {
            return this.mTasks.size() === this.mCapacity;
        }
    }, {
        key: 'size',
        value: function size() {
            if (this.mTasks) {
                return this.mTasks.size();
            }
            return 0;
        }
    }]);
    return ParallelExecutor;
}(Executor);

var wrapExecutor = function wrapExecutor(executor, r, handler) {
    var token = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;

    executor.execute(r, handler, token);
    var hasResult = executor instanceof SerialExecutor || executor instanceof ParallelExecutor;
    if (hasResult) {
        if (executor instanceof SerialExecutor) {
            if (executor instanceof BlockingExecutor) {
                executor.scheduleNext();
            } else {
                if (executor.size() === 1) {
                    executor.scheduleNext();
                }
            }
        }
        var results = executor.getResults();
        return results[0];
    }
    return true;
};

var Executors = exports.Executors = function () {
    function Executors() {
        (0, _classCallCheck3.default)(this, Executors);
    }

    (0, _createClass3.default)(Executors, null, [{
        key: 'callable',
        value: function callable(task) {
            var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

            if (!task) {
                throw new ReferenceError("NullPointerException");
            }
            return new _future.RunnableAdapter({ task: task, result: result });
        }
    }, {
        key: 'postExecutor',
        value: function postExecutor(handler) {
            var executor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

            if (!handler) {
                throw new ReferenceError("NullPointerException");
            }
            if (!executor) {
                return Executors.newPostExecutor(handler);
            }
            return Executors.newSingleExecutor(function (r) {
                var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                return handler.post({
                    run: function run(handler) {
                        var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                        return wrapExecutor(executor, r, handler, token);
                    }
                }, token);
            });
        }
    }, {
        key: 'postExecutorAtFrontOfQueue',
        value: function postExecutorAtFrontOfQueue(handler) {
            var executor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

            if (!handler) {
                throw new ReferenceError("NullPointerException");
            }
            if (!executor) {
                return Executors.newPostAtFrontOfQueueExecutor(handler);
            }
            return Executors.newSingleExecutor(function (r) {
                var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                return handler.postAtFrontOfQueue({
                    run: function run(handler) {
                        var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                        return wrapExecutor(executor, r, handler, token);
                    }
                }, token);
            });
        }
    }, {
        key: 'postExecutorAtTime',
        value: function postExecutorAtTime(handler, executor) {
            if (!handler) {
                throw new ReferenceError("NullPointerException");
            }
            if (!executor) {
                return Executors.newPostAtTimeExecutor(handler);
            }
            return Executors.newSingleExecutor(function (r) {
                var uptimeMillis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
                var token = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

                return handler.postAtTime({
                    run: function run(handler) {
                        var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                        return wrapExecutor(executor, r, handler, token);
                    }
                }, uptimeMillis, token);
            });
        }
    }, {
        key: 'postExecutorDelayed',
        value: function postExecutorDelayed(handler) {
            var executor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

            if (!handler) {
                throw new ReferenceError("NullPointerException");
            }
            if (!executor) {
                return Executors.newPostDelayedExecutor(handler);
            }
            return Executors.newSingleExecutor(function (r) {
                var delayMillis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
                var token = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

                return handler.postDelayed({
                    run: function run(handler) {
                        var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                        return wrapExecutor(executor, r, handler, token);
                    }
                }, delayMillis, token);
            });
        }
    }, {
        key: 'newParallelExecutor',
        value: function newParallelExecutor() {
            var _ref9 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                _ref9$capacity = _ref9.capacity,
                capacity = _ref9$capacity === undefined ? 0 : _ref9$capacity,
                _ref9$queue = _ref9.queue,
                queue = _ref9$queue === undefined ? new _list.LinkedList() : _ref9$queue;

            return new ParallelExecutor({ capacity: capacity, queue: queue });
        }
    }, {
        key: 'newPostExecutor',
        value: function newPostExecutor(handler) {
            if (!handler) {
                throw new ReferenceError("NullPointerException");
            }
            return Executors.newSingleExecutor(function (r) {
                var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                return handler.post(r, token);
            });
        }
    }, {
        key: 'newPostAtFrontOfQueueExecutor',
        value: function newPostAtFrontOfQueueExecutor(handler) {
            var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

            if (!handler) {
                throw new ReferenceError("NullPointerException");
            }
            return Executors.newSingleExecutor(function (r) {
                var token = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

                return handler.postAtFrontOfQueue(r, token);
            });
        }
    }, {
        key: 'newPostAtTimeExecutor',
        value: function newPostAtTimeExecutor(handler) {
            var uptimeMillis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
            var token = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

            if (handler === null) {
                throw new ReferenceError("NullPointerException");
            }
            return Executors.newSingleExecutor(function (r) {
                var uptimeMillis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
                var token = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

                return handler.postAtTime(r, uptimeMillis, token);
            });
        }
    }, {
        key: 'newPostDelayedExecutor',
        value: function newPostDelayedExecutor(handler) {
            var delayMillis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
            var token = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

            if (handler === null) {
                throw new ReferenceError("NullPointerException");
            }
            return Executors.newSingleExecutor(function (r) {
                var delayMillis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
                var token = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

                return handler.postDelayed(r, delayMillis, token);
            });
        }
    }, {
        key: 'newSingleExecutor',
        value: function newSingleExecutor(execute) {
            return new Executor({ execute: execute });
        }
    }, {
        key: 'newSerialExecutor',
        value: function newSerialExecutor() {
            var _ref10 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                _ref10$capacity = _ref10.capacity,
                capacity = _ref10$capacity === undefined ? 0 : _ref10$capacity,
                _ref10$queue = _ref10.queue,
                queue = _ref10$queue === undefined ? null : _ref10$queue;

            return new SerialExecutor({ capacity: capacity, queue: queue });
        }
    }, {
        key: 'newBlockingExecutor',
        value: function newBlockingExecutor() {
            var _ref11 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                _ref11$capacity = _ref11.capacity,
                capacity = _ref11$capacity === undefined ? 0 : _ref11$capacity,
                _ref11$queue = _ref11.queue,
                queue = _ref11$queue === undefined ? null : _ref11$queue;

            return new BlockingExecutor({ capacity: capacity, queue: queue });
        }
    }]);
    return Executors;
}();