public:

client() {

try

{

socket_ = cpp_redis::traits::make_unique<cpp_redis_net>();

request_ = cpp_redis::traits::make_unique<cpp_redis_request>();

}

catch (const std::exception & ex)

{

std::cout << ex.what() << std::endl;

socket_ = nullptr;

request_ = nullptr;

}

}

virtual ~client() {

close();

}

//从左边弹出元素，元素弹完了，redis直接删除

std::string get_current_error()

{

check_args();

const auto res = socket_->get_responese();

return res->get_error();

}

std::string get_current_status()

{

check_args();

const auto res = socket_->get_responese();

return res->get_status();

}

/********ip,port,password,db_num********************/

template<typename...Args>

constexpr bool connect_to(std::string&& ip, Args&&...args) {

check_args();

return socket_->connect_to(std::move(ip), std::forward<Args>(args)...);

}

bool set_db_num(int&& num)

{

check_args();

if (num < 0) {

return false;

}

return select_db(std::move(num));

}

bool auth(std::string&& password)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::auth), std::forward<std::string>(password));

if (!socket_->send_msg(std::move(msg))){

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() == status::unconnected_ ||

res->get_result_code() == status::errors_) {

return false;

}

return true;

}

bool delete_key(std::string&& key)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::del), std::forward<std::string>(key));

if (!socket_->send_msg(std::move(msg))){

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() == status::errors_) {

return false;

}

const auto int_results = res->get_int_results();

if (int_results.empty()) {

return false;

}

if (int_results[0] == 0) {

return false;

}

return true;

}

bool is_key_exist(std::string&& key)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::exists), std::forward<std::string>(key));

if (!socket_->send_msg(std::move(msg))){

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() == status::errors_) {

return false;

}

const auto int_results = res->get_int_results();

if (int_results.empty()) {

return false;

}

if (int_results[0] == 0) {

return false;

}

return true;

}

//给key加上时间

bool expire(std::string&& key, std::size_t seconds)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::expire), std::forward<std::string>(key), unit::int_to_string(seconds));

if (!socket_->send_msg(std::move(msg))){

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::int_result_) {

return false;

}

return true;

}

bool pexpire(std::string&& key, std::size_t milliseconds)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::pexpire),

std::forward<std::string>(key), unit::int_to_string(milliseconds));

if (!socket_->send_msg(std::move(msg))){

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::int_result_) {

return false;

}

const auto results = res->get_int_results();

return ((!results.empty()) ? (results[0] ==1):false);

}

//给key加上在什么时间过期

bool expire_at(std::string&& key, std::size_t unix_timestamp)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::expire_at),

std::forward<std::string>(key), unit::int_to_string(unix_timestamp));

if (!socket_->send_msg(std::move(msg))){

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::int_result_) {

return false;

}

const auto results = res->get_int_results();

return ((!results.empty()) ? (results[0] == 1) : false);

}

//给key加上在什么时间过期

bool pexpire_at(std::string&& key, std::size_t unix_milli_timestamp)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::pexpire_at),

std::forward<std::string>(key), unit::int_to_string(unix_milli_timestamp));

if (!socket_->send_msg(std::move(msg))){

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::int_result_) {

return false;

}

const auto results = res->get_int_results();

return ((!results.empty()) ? (results[0] == 1) : false);

}

//key的剩余时间 -1:表示永久 -2:表示不存在

int remainder_ttl(std::string&& key)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::ttl), std::forward<std::string>(key));

if (!socket_->send_msg(std::move(msg))){

return -2;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::int_result_) {

return -2;

}

const auto int_results = res->get_int_results();

if (int_results.empty()) {

return -2;

}

return int_results[0];

}

//key的剩余时间 -1:表示永久 -2:表示不存在

int64_t remainder_pttl(std::string&& key)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::pttl),

std::forward<std::string>(key));

if (!socket_->send_msg(std::move(msg))){

return -2;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::int_result_) {

return -2;

}

const auto int_results = res->get_int_results();

if (int_results.empty()) {

return -2;

}

return int_results[0];

}

bool rename_key(std::string&& key,std::string &&new_key)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::rename),

std::forward<std::string>(key),std::forward<std::string>(new_key));

if (!socket_->send_msg(std::move(msg))) {

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::status_){

return false;

}

return true;

}

bool renamenx_key(std::string&& key, std::string&& new_key)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::renamenx),

std::forward<std::string>(key), std::forward<std::string>(new_key));

if (!socket_->send_msg(std::move(msg))) {

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::status_) {

return false;

}

return true;

}

bool start_multi()

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::multi));

if (!socket_->send_msg(std::move(msg))) {

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() != status::status_) {

return false;

}

return true;

}

bool exec()

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::exec));

if (!socket_->send_msg(std::move(msg))) {

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() == status::errors_) {

return false;

}

return true;

}

bool discard()

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::discard));

if (!socket_->send_msg(std::move(msg))) {

return false;

}

const auto res = socket_->get_responese();

return true;

}

bool remove_expire(std::string&& key)

{

check_args();

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::remove_expire),std::forward<std::string>(key));

if (!socket_->send_msg(std::move(msg))) {

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() !=status::int_result_){

return false;

}

const auto results = res->get_int_results();

return ((!results.empty()) ? results[0] ==1 :false);

}

virtual bool setex(std::string&& key, std::string&& value,std::string && seconds)

{

return false;

}

virtual bool psetex(std::string&& key, std::string&& value,std::string && milliseconds)

{

return false;

}

virtual bool set(std::string&& key, std::string&& value)

{

return false;

}

virtual int setnx(std::string&& key, std::string&& value)

{

return 0;

}

virtual std::vector<std::string> multi_get_keys(std::vector<std::string>&& keys)

{

return {};

}

virtual bool multi_set_keys(std::vector<std::string>&& keys)

{

return false;

}

virtual int multi_set_if_not_set(std::vector<std::string>&& keys)

{

return false;

}

virtual bool setnx_has_seconds(std::string&& key, std::string&& value,std::string&& seconds)

{

return false;

}

virtual bool setxx(std::string&& key, std::string&& value, std::string&& seconds)

{

return false;

}

virtual bool setnx_has_milliseconds(std::string&& key, std::string&& value,std::string&& milliseconds)

{

return false;

}

virtual bool setxx_has_milliseconds(std::string&& key, std::string&& value, std::string&& milliseconds)

{

return false;

}

virtual std::string get_range(std::string&&key, std::string&& start, std::string&& end)

{

return "";

}

virtual int incr_by_increment(std::string&& key,std::string&& increment)

{

return -1 ;

}

virtual std::string incr_by_float(std::string&& key, std::string&& increment)

{

return "";

}

virtual int incr(std::string&& key)

{

return -1;

}

virtual int decr(std::string&& key)

{

return -1;

}

virtual int decr_increment(std::string&& key,std::string && increment)

{

return -1;

}

virtual std::string get_reflect_value(std::string&& key)

{

return { false,-1 };

}

virtual std::string get_set_key(std::string&& key, std::string&& value)

{

return { false,-1 };

}

virtual std::string substr_reflect_value(std::string&& key, int start, int end)

{

return { false,-1 };

}

//在指定key追加值

virtual int append_value(std::string&& key, std::string&& append_value)

{

return -1;

}

virtual int list_rpush(std::string&& key, std::string&& value)

{

return -1 ;

}

virtual int list_rpush_if(std::string&& key, std::string&& value)

{

return -1;

}

virtual int list_lpush(std::string&& key, std::string&& value)

{

return -1;

}

virtual int list_lpush_if(std::string&& key, std::string&& value)

{

return -1;

}

virtual int32_t list_size(std::string&& key)

{

return -1;

}

virtual std::vector<std::string> list_range(std::string&& key, int start, int end)

{

return {};

}

virtual std::string list_lpop(std::string&& key)

{

return "";

}

virtual std::string list_rpop(std::string&& key)

{

return "";

}

virtual std::string list_brpop(std::string&& key, size_t timeout = 0)

{

return "";

}

virtual std::string list_blpop(std::string&& key, size_t timeout = 0)

{

return "";

}

virtual bool list_trim(std::string&& key, int start, int end)

{

return "";

}

virtual std::string list_index(std::string&& key, int index)

{

return "";

}

virtual bool list_set(std::string&& key, std::string&& value,std::string && index)

{

return "";

}

virtual int list_del_elem(std::string&& key, std::string&& value,std::string&&count)

{

return 0;

}

virtual std::string list_rpoplpush(std::string&& src_key, std::string&& dst_key)

{

return "";

}

virtual std::string list_brpoplpush(std::string&& src_key, std::string&& dst_key, int timeout = 0)

{

return "";

}

virtual int list_insert_before(std::string&& key, std::string&& dst_value, std::string&& insert_value)

{

return INT32_MAX;

}

virtual int list_insert_after(std::string&& key, std::string&& dst_value, std::string&& insert_value)

{

return INT32_MAX;

}

virtual int set_add(std::vector<std::string>&& keys)

{

return 0;

}

virtual int set_delete_elem(std::vector<std::string>&& keys)

{

return 0;

}

virtual bool set_is_member(std::string&& key, std::string&& value)

{

return false;

}

virtual std::string set_rdel_elem(std::string&& key)

{

return "";

}

virtual std::vector <std::string> set_sinter(std::vector<std::string>&& keys)

{

return {};

}

virtual int set_inter_store(std::vector<std::string>&& keys)

{

return 0;

}

virtual std::vector <std::string> set_union(std::vector<std::string>&& keys)

{

return {};

}

virtual int set_union_store(std::vector<std::string>&& keys)

{

return 0;

}

virtual std::vector <std::string> set_rand_elem(std::string&& key, int count)

{

return {};

}

virtual bool set_move_elem(std::string&& src_key, std::string&& dst_key, std::string&& member)

{

return false;

}

virtual std::vector <std::string> set_diff(std::vector<std::string>&& keys)

{

return {};

}

virtual size_t set_get_size(std::string&& key)

{

return 0;

}

virtual std::vector <std::string> set_get_all_member(std::string&& key)

{

return {};

}

virtual int set_diff_store(std::vector<std::string>&& keys)

{

return -1;

}

virtual int zset_add(std::vector<std::string>&& keys)

{

return -1;

}

virtual std::string zset_score(std::string&& key, std::string&& member)

{

return "";

}

virtual std::string zset_incrby(std::string&& key,std::string&& increment,std::string&& member)

{

return "";

}

virtual int zset_card(std::string&& key)

{

return 0;

}

virtual int zset_count(std::string&& key, std::string&& min, std::string&& max)

{

return 0;

}

virtual std::vector <std::string> zset_range(std::string&& key, std::string&& begin, std::string&& end,bool with_scores)

{

return { {} };

}

virtual std::vector <std::string> zset_revrange(std::string&& key, std::string&& begin, std::string&& end, bool with_scores)

{

return { {} };

}

virtual std::vector <std::string> zset_range_score(std::string&& key, std::string&& min, std::string&& max,

bool with_scores, bool limit, std::string&& limit_min, std::string&& limit_max)

{

return { {} };

}

virtual std::vector <std::string> zset_revrange_score(std::string&& key, std::string&& max, std::string&& min,

bool with_scores, bool limit, std::string&& limit_min,std::string&&limit_max)

{

return { {} };

}

virtual int zset_rank(std::string&& key, std::string&& member)

{

return -1;

}

virtual int zset_revrank(std::string&& key, std::string&& member)

{

return -1;

}

virtual bool zset_rem(std::vector<std::string>&& keys)

{

return false;

}

virtual int zset_remrangeby_rank(std::string&& key, std::string&& begin, std::string&& end)

{

return -1;

}

virtual int zset_remrangebyscore(std::string&& key, std::string&& min, std::string&& max)

{

return -1;

}

virtual std::vector <std::string> zset_rangebylex(std::string&& key, std::string&& min,

std::string&& max, bool limit, std::string&& limit_min, std::string&& limit_max)

{

return { {} };

}

virtual int zset_lexcount(std::string&& key, std::string&& min, std::string&& max)

{

return -1;

}

virtual int zset_remrangebylex(std::string&& key, std::string&& min,std::string&& max)

{

return 0;

}

virtual int zset_union_store(std::vector<std::string>&& keys,aggregate_mothod mothod)

{

return -1;

}

virtual int zset_inter_store(std::vector<std::string>&& keys, aggregate_mothod mothod)

{

return -1;

}

virtual int hash_set(std::string&& key, std::string&& field, std::string&& value)

{

return 0;

}

virtual int hash_setx(std::string&& key, std::string&& field, std::string&& value)

{

return 0;

}

virtual int hash_exists(std::string&& key,std::string&& field)

{

return 0;

}

virtual std::string hash_get(std::string&& key, std::string&& field)

{

return "";

}

virtual int hash_del(std::vector<std::string>&& fields)

{

return -1;

}

virtual int hash_len(std::string&& key)

{

return 0;

}

virtual int hash_strlen(std::string&& key, std::string&& field)

{

return 0;

}

virtual int hash_incrby(std::string&& key, std::string && field, std::string&& increment)

{

return 0;

}

virtual std::string hash_incrby_float(std::string&& key, std::string&& field, std::string&& increment)

{

return "";

}

virtual bool hash_mset(std::vector<std::string>&& keys)

{

return false;

}

virtual std::vector <std::string> hash_mget(std::vector<std::string>&& keys)

{

return { {} };

}

virtual std::vector <std::string> hash_keys(std::string&& key)

{

return{ {} };

}

virtual std::vector <std::string> hash_vals(std::string&& key)

{

return{ {} };

}

virtual std::vector <std::string> hash_get_all(std::string&& key)

{

return{ {} };

}

bool select_db(int&& num)

{

check_args();

if (num < 0) {

return false;

}

std::string msg = request_->req_n_key(request_->get_cmd(redis_cmd::select), std::move(unit::int_to_string(num)));

if (!socket_->send_msg(std::move(msg))){

return false;

}

const auto res = socket_->get_responese();

if (res->get_result_code() == status::unconnected_ ||

res->get_result_code() == status::errors_) {

return false;

}

return true;

}

void close() {

check_args();

socket_->close();

}

protected:

void check_args()

{

assert(socket_ != nullptr);

assert(request_ != nullptr);

}

std::unique_ptr<cpp_redis_request>request_;

std::unique_ptr<cpp_redis_net>socket_;