"use strict";
/**
 *
 * @date 2023-02-16 16:36:38
 * @author 鲜伟坚
 */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RedisClient = void 0;
var Redis_1 = require("./Redis");
var RedisClient = /** @class */ (function () {
    function RedisClient() {
        this.mRedis = Redis_1.defRedisClient;
        // /**
        //  * 删除
        //  * @param key key
        //  */
        // async delete(key: string): Promise<boolean> {
        //     return await this.mRedis.DEL(key);
        // }
        // /**
        //  * 判断Key是否存在
        //  * @param key key
        //  */
        // async exists(key: string): Promise<boolean> {
        //     return await this.redisCommands['exists'](key) === 1;
        // }
        // /**
        //  * 用于查找所有符合给定模式 pattern 的 key 
        //  * @param pattern
        //  */
        // async keys(pattern: string): Promise<Array<string>> {
        //     return await this.redisCommands['keys'](pattern);
        // }
        // /**
        //  * 设置过期时间
        //  * @param key key
        //  * @param expires 过期时间(秒)
        //  */
        // async expire(key: string, expires: number): Promise<boolean> {
        //     return await this.redisCommands['expire'](key, expires) === 1;
        // }
        // /**
        //  * 将一个或多个值插入到列表头部
        //  * @param key key
        //  * @param value 值
        //  */
        // async lpush(key: string, value: any): Promise<number> {
        //     return await this.redisCommands['lpush'](key, value);
        // }
        // /**
        //  * 获取列表长度
        //  * @param key key
        //  */
        // async llen(key: string): Promise<number> {
        //     return await this.redisCommands['llen'](key);
        // }
        // /**
        //  * 将一个值插入到已存在的列表头部
        //  * @param key key
        //  * @param value 值
        //  */
        // async lpushx(key: string, value: any): Promise<number> {
        //     return await this.redisCommands['lpushx'](key, value);
        // }
        // /**
        //  * 获取列表指定范围内的元素
        //  * @param key key
        //  * @param start 开始索引
        //  * @param stop 截止索引
        //  */
        // async lrange(key: string, start: number, stop: number): Promise<any> {
        //     return await this.redisCommands['lrange'](key, start, stop);
        // }
        // /**
        //  * 移出并获取列表的第一个元素
        //  * @param key key
        //  */
        // async lpop(key: string): Promise<any> {
        //     return await this.redisCommands['lpop'](key);
        // }
        // /**
        //  * 根据参数 COUNT 的值，移除列表中与参数 VALUE 相等的元素。
        //  * @param key key
        //  * @param count  
        //  *  count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
        //  *  count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
        //  *  count = 0 : 移除表中所有与 VALUE 相等的值。
        //  * @param value
        //  */
        // async lrem(key: string, count: number, value: any): Promise<any> {
        //     return await this.redisCommands['lrem'](key, count, value);
        // }
        // /**
        //  * 向集合添加一个或多个成员
        //  * @param key
        //  * @param value 
        //  */
        // async sadd(key: string, value: any): Promise<any> {
        //     return await this.redisCommands['sadd'](key, value);
        // }
        // /**
        //  * 获取集合的成员数
        //  * @param key 
        //  */
        // async scard(key: string): Promise<any> {
        //     return await this.redisCommands['scard'](key);
        // }
        // /**
        //  * 返回第一个集合与其他集合之间的差异。
        //  * @param key1
        //  * @param key2 
        //  */
        // async sdiff(key1: string, key2: string): Promise<any> {
        //     return await this.redisCommands['sdiff'](key1, key2);
        // }
        // /**
        //  * 判断 member 元素是否是集合 key 的成员
        //  * @param key
        //  * @param member 
        //  */
        // async sismember(key: string, member: any): Promise<any> {
        //     return await this.redisCommands['sismember'](key, member);
        // }
        // /**
        //  * 返回集合中的所有成员
        //  * @param key
        //  */
        // async smembers(key: string): Promise<any> {
        //     return await this.redisCommands['smembers'](key);
        // }
        // /**
        //  * 移除并返回集合中的一个随机元素
        //  * @param key 
        //  */
        // async spop(key: string): Promise<any> {
        //     return await this.redisCommands['spop'](key);
        // }
        // /**
        //  * 返回集合中一个或多个随机数
        //  * @param key 
        //  * @param count 
        //  */
        // async srandmember(key: string, count: number): Promise<any> {
        //     return await this.redisCommands['srandmember'](key, count);
        // }
        // /**
        //  * 移除集合中一个或多个成员
        //  * @param key 
        //  * @param member
        //  */
        // async srem(key: string, member: any): Promise<any> {
        //     return await this.redisCommands['srem'](key, member);
        // }
        // /**
        //  * 返回所有给定集合的并集
        //  * @param key 
        //  */
        // async sunion(key: any): Promise<any> {
        //     return await this.redisCommands['sunion'](key);
        // }
        // /**
        //  * 获取存储在哈希表中指定字段的值
        //  * @param key   
        //  * @param field 字段名称
        //  */
        // async hget(key: any, field: any): Promise<any> {
        //     return await this.redisCommands['hget'](key, field);
        // }
        // /**
        //  * 获取在哈希表中指定 key 的所有字段和值
        //  * @param key   
        //  */
        // async hgetall(key: any): Promise<any> {
        //     return await this.redisCommands['hgetall'](key);
        // }
        // /**
        //  * 为哈希表 key 中的指定字段的整数值加上增量 increment
        //  * @param key   
        //  * @param field
        //  * @param increment
        //  */
        // async hincrby(key: any, field: any, increment: number): Promise<any> {
        //     return await this.redisCommands['hincrby'](key, field, increment);
        // }
        // /**
        //  * 将哈希表 key 中的字段 field 的值设为 value 。
        //  * @param key   
        //  * @param field
        //  * @param value
        //  */
        // async hset(key: any, field: any, value: any): Promise<any> {
        //     return await this.redisCommands['hset'](key, field, value);
        // }
        // /**
        //  * 同时将多个 field-value (域-值)对设置到哈希表 key 中。
        //  * @param key   
        //  * @param ...args [field1,value1,field2,value2 ]
        //  */
        // async hmset(key: any, ...args): Promise<any> {
        //     return await this.redisCommands['hmset'](key, args);
        // }
        // /**
        //  * 删除存储在哈希表中指定字段的值
        //  * @param key   
        //  * @param ...args [field1,value1,field2,value2 ]
        //  */
        // async hdel(key: any, ...args): Promise<any> {
        //     return await this.redisCommands['hdel'](key, args);
        // }
        // /**
        //  * 执行某个Redis指令
        //  * @param command 指令名称,例： set
        //  * @param ...args 指令参数,例： [key value 'EX' expires ] 
        //  */
        // async exec(command: string, ...args): Promise<any> {
        //     return await this.redisCommands[command](args);
        // }
    }
    /**
     * SET
     * @param key key
     * @param value value
     * @param expires 过期时间(秒),可选参数，默认不过期
     */
    RedisClient.prototype.set = function (key, value, expires) {
        if (expires === void 0) { expires = 0; }
        return __awaiter(this, void 0, void 0, function () {
            var ret;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!(expires > 0)) return [3 /*break*/, 2];
                        return [4 /*yield*/, this.mRedis.SETEX(key, value, expires * 1000)];
                    case 1:
                        ret = _a.sent();
                        return [3 /*break*/, 4];
                    case 2: return [4 /*yield*/, this.mRedis.SET(key, value)];
                    case 3: return [2 /*return*/, _a.sent()];
                    case 4: return [2 /*return*/];
                }
            });
        });
    };
    // /**
    //  * setNX 
    //  * @param key key
    //  * @param value value
    //  */
    // async setNX(key: string, value: any, expires: number = 0): Promise<any> {
    //     if (expires > 0) {
    //         return await this.redisCommands['set'](key, value, "EX", expires, 'NX');
    //     } else {
    //         return await this.redisCommands['setnx'](key, value);
    //     }
    // }
    /**
     * 获取
     * @param key key
     */
    RedisClient.prototype.get = function (key) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, this.mRedis.GET(key)];
                    case 1: return [2 /*return*/, _a.sent()];
                }
            });
        });
    };
    return RedisClient;
}());
exports.RedisClient = RedisClient;
//# sourceMappingURL=RedisClient.js.map