gcl/com/coooders/collection/pool.js

码农村nodejs类库，完成解决回调陷阱，配置框架，IOC框架，统一多DB访问框架，可扩展日志框架和io/db/net/thread/pool 克隆表达式，加解密算法等等一系列基础类库和算法的实现

'use strict';

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

var _symbol = require('babel-runtime/core-js/symbol');

var _symbol2 = _interopRequireDefault(_symbol);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var _tool = require('../common/tool');

var _tool2 = _interopRequireDefault(_tool);

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

/**
 * 仅限于池方式调用的方法
 * @author(baibing)
 * @param('size','')
 * @param(func:创建对象的方法)
 * @param(waitTime,过期时间)
 */
var Pool = exports.Pool = function () {
    function Pool() {
        var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
        var func = arguments[1];
        var waitTime = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 10;
        (0, _classCallCheck3.default)(this, Pool);

        var that = this;

        var _pri = pri(that, {
            size: size,
            func: func,
            waitTime: waitTime,
            data: [], //总数
            have: [], //有可用资源
            wait: [], //等待调用的请求
            use: {}, //使用中的
            KEY: (0, _symbol2.default)('_____poolid'),
            addUse: function addUse(v) {
                if (v) {
                    if (!_tool2.default.isValid(v[__.KEY])) {
                        v[__.KEY] = _tool2.default.random();
                    }
                    __.use[v[__.KEY]] = v;
                }
            },
            delUse: function delUse(v) {
                if (v && _tool2.default.isValid(v[__.KEY])) {
                    delete __.use[v[__.KEY]];
                }
            }
        }),
            _ = _pri._,
            __ = _pri.__;

        __.clear = new Clearer(_, __);
        __.clear.start();
    }

    (0, _createClass3.default)(Pool, [{
        key: 'getValue',
        value: function getValue() {
            var _pri2 = pri(this),
                _ = _pri2._,
                __ = _pri2.__;

            return _tool2.default.callback(function (call) {
                var v = __.have.pop();
                if (v) {
                    v = v.value;
                    __.addUse(v);
                    call(null, v);
                } else if (__.data.length < __.size) {
                    _tool2.default.callback2(__.func, __).then(function (v) {
                        __.addUse(v);
                        __.data.push(v);
                        call(null, v);
                    });
                } else {
                    __.wait.push({ endDate: new Date().add('s', __.waitTime), value: call, dispose: call });
                }
            });
        }
    }, {
        key: 'setValue',
        value: function setValue(v) {
            var _pri3 = pri(this),
                _ = _pri3._,
                __ = _pri3.__;

            if (_tool2.default.isValid(v) && _tool2.default.isValid(v[__.KEY])) {
                if (__.wait.length > 0) {
                    //仅针对getValue异步操作有效
                    __.wait.shift().value(null, v);
                } else {
                    __.delUse(v);
                    __.have.push({
                        endDate: new Date().add('s', __.waitTime),
                        value: v,
                        dispose: function dispose() {
                            if (v.dispose) _tool2.default.tryC(v.dispose);
                        }
                    });
                }
            }
        }
    }, {
        key: 'dispose',
        value: function dispose() {
            var _pri4 = pri(this),
                _ = _pri4._,
                __ = _pri4.__;

            __.clear.stop();

            var _loop = function _loop(i) {
                _tool2.default.tryC(function () {
                    if (__.data[i].dispose) __.data[i].dispose();
                });
            };

            for (var i in __.data) {
                _loop(i);
            }
            var _loop2 = function _loop2(i) {
                _tool2.default.tryC(function () {
                    if (__.wait[i].dispose) __.wait[i].dispose();
                });
            };

            for (var i in __.wait) {
                _loop2(i);
            }__.data = null;
            __.have = null;
            __.use = null;
        }
    }]);
    return Pool;
}();
exports.default = { Pool: Pool };

var pri = _tool2.default.pris();

var Clearer = function () {
    function Clearer(obj, objpri) {
        (0, _classCallCheck3.default)(this, Clearer);

        var _pri5 = pri(this, { obj: obj, pri: objpri }),
            _ = _pri5._,
            __ = _pri5.__;

        this.tid = null;
    }

    (0, _createClass3.default)(Clearer, [{
        key: 'check',
        value: function check(datas) {
            var endDate = datas.length > 0 ? datas[0].endDate : null;
            if (_tool2.default.isValid(endDate) && new Date().diff('ms', endDate) > 0) {
                return false;
            } else {
                while (datas.length > 0) {
                    var val = datas.shift();
                    if (_tool2.default.isValid(val.endDate) && new Date().diff('ms', val.endDate) <= 0) {
                        if (val.dispose) {
                            _tool2.default.tryC(val.dispose);
                        }
                    } else return true;
                    val = null;
                }
                return true;
            }
        }
    }, {
        key: 'start',
        value: function start() {
            var _pri6 = pri(this),
                _ = _pri6._,
                __ = _pri6.__;

            _.tid = global.setTimeout(function () {
                var ret = _.check(__.pri.have);
                _.check(__.pri.wait);
                _.start();
            }, 500);
        }
    }, {
        key: 'stop',
        value: function stop() {
            var _ = this;
            if (_.tid) global.clearTimeout(_.tid);
            _.tid = null;
        }
    }]);
    return Clearer;
}();

;
//# sourceMappingURL=pool.js.map