۞边城浪子
۞边城浪子

c++ hiredis封装

/*
 * ----------------------------------------------------------------------------
 * Copyright (c) 2013-2014, xSky
 * All rights reserved.
 * Distributed under GPL license.
 * ----------------------------------------------------------------------------
 */


#ifndef _XREDIS_CLIENT_H_
#define _XREDIS_CLIENT_H_
#include "hiredis.h"


#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "util.h"




using namespace std;


#define MAX_ERR_STR_LEN 128


typedef std::string             KEY;
typedef std::string             VALUE;
typedef std::vector        KEYS;
typedef std::vector      VALUES;
typedef std::vector     VDATA;


typedef std::set        SETDATA;










typedef struct _REDIS_NODE_
{
    unsigned int dbindex;
    const char  *host;
    unsigned int port;
    const char  *passwd;
    unsigned int poolsize;
    unsigned int timeout;
}RedisNode;




class xRedisClient;




typedef struct _DATA_ITEM_
 {
    int    type;
    string str;
}DataItem;


typedef std::vector       ReplyData;
typedef ReplyData                   ArrayReply;
typedef std::map    ZSETDATA;






typedef enum _BIT_OP_
{
    AND = 0,
    OR  = 1,
    XOR = 2,
    NOT = 3
}BITOP;


typedef enum _LIST_MODEL_
 {
    BEFORE = 0,
    AFTER  = 1
}LMODEL;






#define PING_REDIS_SEC       5


class xRedisClient
{
public:
    xRedisClient(string host, const unsigned int  port, string pass, const unsigned int  timeout )
    {
       mHost     = host;
       mPort     = port;
       mPass     = pass;
       mTimeout  = timeout;
       mLastTime = 0;
    }
    
    ~xRedisClient()
    {
      if(mCtx)
      {
        redisFree(mCtx);
      }


      if(mStrerr)
      {
        delete(mStrerr);
      }
      
    }


public:


    //              connection
    /* ECHO        */  
    /* PING        */  
    /* QUIT        */  
    /* SELECT      */  
    //                 Commands operating on string values
    /* DECR        */  bool decr(const string& key, int& result);
    /* DECRBY      */  bool decrby(const string& key, const int by, int& result);
    /* GET         */  bool get(const string& key,  string& value);
    /* GETBIT      */  bool getbit(const string& key,  const int& offset, int& bit);
    /* GETRANGE    */  bool getrange(const string& key,  const int start, const int end, string& out);
    /* GETSET      */  bool getset(const string& key,  const string& newValue, string& oldValue);
    /* INCR        */  bool incr(const string& key, int& result);
    /* INCRBY      */  bool incrby(const string& key, const int by, int& result);
    /* INCRBYFLOAT */  
    /* MGET        */  bool mget(const KEYS &  keys, ReplyData& vDdata);
    /* MSET        */  bool mset(const VDATA& data);
    /* MSETNX      */  
    /* SET         */  bool set(const string& key,  const string& value);
    /* SETBIT      */  bool setbit(const string& key,  const int offset, const int64_t newbitValue, int64_t oldbitValue);
    /* SETEX       */  bool setex(const string& key,  const int seconds, const string& value);
    /* SETNX       */  bool setnx(const string& key,  const string& value);
    /* SETRANGE    */  bool setrange(const string& key,  const int offset, const string& value, int& length);
    /* STRLEN      */ // bool strlen(const string& key, int& length);
    /* DEL          */  bool del(const string& key);
                bool del(const KEYS &  vkey, int64_t& count);
    /* DUMP         */
    /* EXISTS       */  bool exists( const string& key);
    /* RANDOMKEY    */  bool randomkey(  KEY& key);
    /* HDEL         */  bool hdel(const string& key, const string& filed, int64_t& num);
                        bool hdel(const string& key, const KEYS& vfiled, int64_t& num);
    /* HEXISTS      */  bool hexist(const string& key, const string& filed);
    /* HGET         */  bool hget(const string& key, const string& filed, string& value);
    /* HGETALL      */  bool hgetall(const string& key, ArrayReply& array);
    /* HKEYS        */  bool hkeys(const string& key, KEYS& keys);
    /* HLEN         */  bool hlen(const string& key, int64_t& count);
    /* HMGET        */  bool hmget(const string& key, const KEYS& filed, ArrayReply& array);
    /* HMSET        */  bool hmset(const string& key, const VDATA& vData);
    /* HSCAN        */                                     
    /* HSET         */  bool hset(const string& key, const string& filed, const string& value, int64_t& retval);
    /* HSETNX       */  bool hsetnx(const string& key, const string& filed, const string& value);
    /* HVALS        */  bool hvals(const string& key, VALUES& values);


    /* LLEN         */  bool llen(const string& key, int64_t& len);
    /* LPOP         */  bool lpop(const string& key, string& value);
    /* LPUSH        */  bool lpush(const string& key, const VALUES& vValue, int64_t& length);
    /* LPUSHX       */  bool lpushx(const string& key, const string& value, int64_t& length);
    /* LRANGE       */  bool lrange(const string& key, const int64_t start, const int64_t end, ArrayReply& array);
    /* LTRIM        */  bool ltrim(const string& key,  const int start, const int end);
    /* RPOP         */  bool rpop(const string& key, string& value);
    /* RPOPLPUSH    */  bool rpoplpush(const string& key_src, const string& key_dest, string& value);
    /* RPUSH        */  bool rpush(const string& key, const VALUES& vValue, int64_t& length);
    /* RPUSHX       */  bool rpushx(const string& key, const string& value, int64_t& length);
    /* SADD         */  bool sadd(const KEY& key, const VALUES& vValue, int64_t& count);
    /* SMOVE        */  bool smove(const KEY& srckey, const KEY& deskey,  const VALUE& member);
    /* SPOP         */  bool spop(const KEY& key, VALUE& member);
    /* SRANDMEMBER  */  bool srandmember(const KEY& key, VALUES& vmember, int num=0);
    /* ZADD             */ bool zadd(const KEY& deskey,   const VALUES& vValues, int64_t& count);
private:
    void addparam(VDATA& vDes, const VDATA& vSrc) 
    {
        for (VDATA::const_iterator iter=vSrc.begin(); iter!=vSrc.end();++iter) 
        {
            vDes.push_back(*iter);
        }
    }


    bool command_bool(const char* cmd, ...);
    bool command_status(const char* cmd, ...);
    bool command_integer(int64_t &intval,   const char* cmd, ...);
    bool command_string(string &data,      const char* cmd, ...);
    bool command_list(VALUES &vValue,    const char* cmd, ...);
    bool command_array(ArrayReply& array, const char* cmd, ...);
    bool commandargv_bool(const VDATA& vData);
    bool commandargv_status(const VDATA& vData);
    bool commandargv_array(const VDATA& vDataIn, ArrayReply& array);
    bool commandargv_array(const VDATA& vDataIn, VALUES& array);
    bool commandargv_integer(const VDATA& vDataIn, int64_t& retval);




public:
    char *GetErrInfo()
    {
     return this->mStrerr;
    }
    
    bool SetErrInfo(const char *info)
    {
        if (NULL==info) 
        {
            return false;
        }


        if (NULL == this->mStrerr)
        {
            this->mStrerr = new char[MAX_ERR_STR_LEN];
        }


        if (NULL!=this->mStrerr) 
        {
            memset(this->mStrerr,0, MAX_ERR_STR_LEN);
            strncpy(this->mStrerr, info, MAX_ERR_STR_LEN);
            return true;
        }
        return false;
    }






    bool CheckReply(const redisReply *reply)
    {
        if(NULL==reply) 
        {
            return false;
        }


        switch(reply->type)
        {
        case REDIS_REPLY_STRING:
        {
        return true;
        }
        case REDIS_REPLY_ARRAY:
        {
        return (strcasecmp(reply->str,"OK") == 0)?true:false;
        }
        case REDIS_REPLY_INTEGER:
        {
        return true;
        }
        case REDIS_REPLY_NIL:
        {
        return false;
        }
        case REDIS_REPLY_STATUS:
        {
        return (strcasecmp(reply->str,"OK") == 0)?true:false;
        }
        case REDIS_REPLY_ERROR:
        {
        return false;
        }
        default:
        {
        return false;
        }
        }


        return false;
    }




   
   
   void FreeReply(const redisReply *reply)
   {
       if (NULL!=reply) 
       {
           freeReplyObject((void*)reply);
       } 


   }


   
    bool RedisConnect() 
    {
     
      bool bRet = false;
      struct timeval timeoutVal;
      timeoutVal.tv_sec  = mTimeout;
      timeoutVal.tv_usec = 0;


      mCtx = redisConnectWithTimeout(mHost.c_str(), mPort, timeoutVal);
      if (NULL == mCtx || mCtx->err) 
      {
          if (NULL!=mCtx) 
          {
              redisFree(mCtx);
          } else
          {


          }
      } else
      {
          if (0 == mPass.size()) 
          {
              bRet = true;
          } else 
          {
              redisReply *reply = static_cast(redisCommand(mCtx,"AUTH %s", mPass.c_str()));
              if((NULL==reply)||(strcasecmp(reply->str,"OK") != 0)) 
              {
                  bRet = false;
              }
              freeReplyObject(reply);
          }
      }


      return bRet;
    }




    bool Ping() const
    {
        redisReply *reply = static_cast(redisCommand(mCtx,"PING"));
        bool bRet = (NULL!=reply);
        freeReplyObject(reply);
        return bRet;
    }




   
   //计算频率
    bool checkRedisNetwork()
    {
       time_t tick = time(NULL);
       if(tick >= mLastTime + PING_REDIS_SEC)
       {    
           if(Ping() == false)
           {
               DEBUG_LOG("检测redis断开");
               this->RedisConnect();
           }
           mLastTime = tick;
       }
    }


    redisContext  *getCtx() const     
    {
        return mCtx;
    }
     redisContext *mCtx;
private:
    char        *mStrerr;
    string  mHost;         // redis host
    unsigned int  mPort;          // redis sever port
    string mPass;         // redis server password
    unsigned int  mTimeout;       // connect timeout second
    time_t mLastTime;      //
};




#endif



/*
 * ----------------------------------------------------------------------------
 * Copyright (c) 2013-2014, xSky
 * All rights reserved.
 * Distributed under GPL license.
 * ----------------------------------------------------------------------------
 */






#include "redis_client.h"
#include


#include






bool xRedisClient::command_bool( const char *cmd, ...)
{
    bool bRet = false;




    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast(redisvCommand(mCtx, cmd, args));
    va_end(args);


    if (CheckReply(reply))
{
        bRet = (reply->integer==1)?true:false;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}




bool xRedisClient::command_status( const char* cmd, ...) 
{
    bool bRet = false;


    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast(redisvCommand(mCtx, cmd, args));
    va_end(args);


    if (CheckReply(reply)) 
{
        bRet = true;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);
    return bRet;
}


bool xRedisClient::command_integer( int64_t &retval, const char* cmd, ...) 
{
    bool bRet = false;


if(this->mCtx == NULL)
{
return bRet;
}




    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast(redisvCommand(this->mCtx, cmd, args));
    va_end(args);

    if (CheckReply(reply)) 
{
        retval = reply->integer;
        bRet = true;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}


bool xRedisClient::command_string( string &data, const char* cmd, ...) 
{
    bool bRet = false;


if(this->mCtx == NULL)
{
return bRet;
}




    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast(redisvCommand(this->mCtx, cmd, args));
    va_end(args);
    if (CheckReply(reply)) 
{
        data = reply->str;
        bRet = true;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}


bool xRedisClient::command_list( VALUES &vValue, const char* cmd, ...) 
{
    bool bRet = false;
    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast(redisvCommand(this->mCtx, cmd, args));
    va_end(args);
    if (CheckReply(reply)) 
{
        for (unsigned int i =0; ielements; i++) 
{
            vValue.push_back(reply->element[i]->str);
        }
        bRet  = true;
    } else 
    {
         SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}


bool xRedisClient::command_array(  ArrayReply& array,  const char* cmd, ...){


bool bRet = false;


    va_list args;
    va_start(args, cmd);
    redisReply *reply = static_cast(redisvCommand(this->mCtx, cmd, args));
    va_end(args);
    if (CheckReply(reply)) 
{
        for (unsigned int i =0; ielements; i++) 
{
            DataItem item;
            item.type = reply->element[i]->type;
            item.str  = reply->element[i]->str;
            array.push_back(item);
        }
        bRet  = true;
    } else 
   {


        SetErrInfo(reply->str);
    }


    FreeReply(reply);
    return bRet;
}


bool xRedisClient::commandargv_bool( const VDATA& vData) {
    bool bRet = false;


    vector argv( vData.size() );
    vector argvlen( vData.size() );
    unsigned int j = 0;
    for ( vector::const_iterator i = vData.begin(); i != vData.end(); ++i, ++j )
{
        argv[j] = i->c_str(), argvlen[j] = i->size();
    }


    redisReply *reply = static_cast(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply)) 
{
        bRet = (reply->integer==1)?true:false;
    }
    FreeReply(reply);
    return bRet;
}


bool xRedisClient::commandargv_status( const VDATA& vData)
{
    bool bRet = false;
    vector argv( vData.size() );
    vector argvlen( vData.size() );
    unsigned int j = 0;
    for ( vector::const_iterator i = vData.begin(); i != vData.end(); ++i, ++j )
{
        argv[j] = i->c_str(), argvlen[j] = i->size();
    }
    redisReply *reply = static_cast(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply))
{
        bRet = true;
    }
    FreeReply(reply);
    return bRet;
}


bool xRedisClient::commandargv_array( const VDATA& vDataIn, ArrayReply& array)
{
    bool bRet = false;
    vector argv( vDataIn.size() );
    vector argvlen( vDataIn.size() );
    unsigned int j = 0;
    for ( vector::const_iterator i = vDataIn.begin(); i != vDataIn.end(); ++i, ++j )
{
        argv[j] = i->c_str(), argvlen[j] = i->size();
    }
    redisReply *reply = static_cast(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply))
{
        for (unsigned int i =0; ielements; i++) 
{
            DataItem item;
            item.type = reply->element[i]->type;
            item.str  = reply->element[i]->str;
            array.push_back(item);
        }
        bRet  = true;
    } else 
    {


        SetErrInfo(reply->str);
    }
    FreeReply(reply);
    return bRet;
}


bool xRedisClient::commandargv_array( const VDATA& vDataIn, VALUES& array)
{
    bool bRet = false;
    vector argv( vDataIn.size() );
    vector argvlen( vDataIn.size() );
    unsigned int j = 0;
    for ( vector::const_iterator i = vDataIn.begin(); i != vDataIn.end(); ++i, ++j )
{
        argv[j] = i->c_str(), argvlen[j] = i->size();
    }
    redisReply *reply = static_cast(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply))
{
        for (unsigned int i =0; ielements; i++) 
{
            array.push_back(reply->element[i]->str);
        }
        bRet  = true;
    } else 
    {
        SetErrInfo(reply->str);
    }


    FreeReply(reply);
   
    return bRet;
}


bool xRedisClient::commandargv_integer( const VDATA& vDataIn, int64_t& retval)
{
    bool bRet = false;




    vector argv( vDataIn.size() );
    vector argvlen( vDataIn.size() );
    unsigned int j = 0;
    for ( vector::const_iterator iter = vDataIn.begin(); iter != vDataIn.end(); ++iter, ++j ) 
{
        argv[j] = iter->c_str(), argvlen[j] = iter->size();
    }


    redisReply *reply = static_cast(redisCommandArgv(this->mCtx, argv.size(), &(argv[0]), &(argvlen[0])));
    if (CheckReply(reply)) 
{
        retval = reply->integer;
        bRet  = true;
    } else 
    {


        SetErrInfo(reply->str);
    }


    FreeReply(reply);


    return bRet;
}








bool xRedisClient::incr( const string& key, int& result) 
{
return command_integer((int64_t&)result, "INCR %s", key.c_str());
}




bool xRedisClient::set( const string& key, const  string& value) 
{
VDATA vCmdData;
vCmdData.push_back("SET");
vCmdData.push_back(key);
vCmdData.push_back(value);
return commandargv_status( vCmdData);
}




bool  xRedisClient::del(const string& key)
{
    return command_bool( "DEL %s", key.c_str());
}




bool xRedisClient::hdel(const string& key, const string& filed, int64_t& count) 
{
    return command_integer( count, "HDEL %s %s %s", key.c_str(), filed.c_str());
}


bool xRedisClient::hdel(const string& key, const KEYS& vfiled, int64_t& count) 
{
    VDATA vCmdData;
    vCmdData.push_back("HDEL");
    vCmdData.push_back(key);
    addparam(vCmdData, vfiled);
    return commandargv_integer(vCmdData, count);
}


bool xRedisClient::hexist(const string& key, const string& filed)
{
    return command_bool("HEXIST %s %s %s", key.c_str(), filed.c_str());
}


bool xRedisClient::hget(const string& key, const string& filed, string& value) 
{
    return command_string(value, "HGET %s %s %s", key.c_str(), filed.c_str());
}


bool  xRedisClient::hgetall(const string& key, ArrayReply& array)
{
    return command_array( array, "HGETALL %s", key.c_str());
}






bool xRedisClient::hkeys(const string& key, KEYS& keys)
{
    return command_list(keys, "HKEYS %s", key.c_str());
}


bool xRedisClient::hlen(const string& key, int64_t& count)
{
    return command_integer(count, "HLEN %s", key.c_str());
}




bool xRedisClient::hmget(const string& key, const KEYS& filed, ArrayReply& array)
{
    VDATA vCmdData;
    vCmdData.push_back("HMGET");
    vCmdData.push_back(key);
    addparam(vCmdData, filed);
    return commandargv_array(vCmdData, array);
}






bool xRedisClient::hmset(const string& key, const VDATA& vData)
{
    VDATA vCmdData;
    vCmdData.push_back("HMGET");
    vCmdData.push_back(key);
    addparam(vCmdData, vData);
    return commandargv_bool(vCmdData);
}


bool xRedisClient::hset(const string& key, const string& filed, const string& value, int64_t& retval)
{
    return command_integer( retval, "HSET %s %s %s", key.c_str(), filed.c_str(), value.c_str());
}






bool xRedisClient::hvals(const string& key, VALUES& values) 
{
    return command_list( values, "HVALS %s", key.c_str());
}


bool xRedisClient::exists(const string& key) 
{
    return command_bool( "EXISTS %s", key.c_str());
}




bool xRedisClient::randomkey( KEY& key)
{
    return command_string( key, "RANDOMKEY");
}








bool xRedisClient::llen(const string& key, int64_t& retval)
{
    return command_integer(retval, "LLEN %s", key.c_str());
}


bool xRedisClient::lpop(const string& key, string& value)
{
    return command_string(value, "LPOP %s", key.c_str());
}


bool xRedisClient::lpush(const string& key, const VALUES& vValue, int64_t& length)
{
    VDATA vCmdData;
    vCmdData.push_back("lpush");
    vCmdData.push_back(key);
    addparam(vCmdData, vValue);
    return commandargv_integer(vCmdData, length);
}


bool xRedisClient::lrange( const string& key, const int64_t start, const int64_t end, ArrayReply& array)
{
    return command_array(array, "LRANGE %s", key.c_str(), start, end);
}






bool xRedisClient::ltrim(const string& key, const int start, const int end)
{
    return command_status( "ltrim %s %d %d", key.c_str(), start, end);
}


bool xRedisClient::rpop(const string& key, string& value)
{
    return command_string(value, "LPOP %s", key.c_str());
}


bool xRedisClient::rpoplpush(const string& key_src, const string& key_dest, string& value)
{
    return command_string(value, "RPOPLPUSH %s %s", key_src.c_str(), key_dest.c_str());
}


bool xRedisClient::rpush(const string& key, const VALUES& vValue, int64_t& length)
{
    VDATA vCmdData;
    vCmdData.push_back("rpush");
    vCmdData.push_back(key);
    addparam(vCmdData, vValue);
    return commandargv_integer( vCmdData, length);
}


bool xRedisClient::rpushx( const string& key, const string& value, int64_t& length)
{
    return command_integer(length, "RPUSHX %s %s", key.c_str(), value.c_str());
}


//sets
bool xRedisClient::sadd( const string& key, const VALUES& vValue, int64_t& count)
{
    VDATA vCmdData;
    vCmdData.push_back("SADD");
    vCmdData.push_back(key);
    addparam(vCmdData, vValue);
    return commandargv_integer(vCmdData, count);
}




bool xRedisClient::smove(const KEY& srckey, const KEY& deskey,  const VALUE& member)
{
    return command_bool( "SMOVE %s", srckey.c_str(), deskey.c_str(), member.c_str());
}


bool xRedisClient::spop(const KEY& key, VALUE& member)
{
    return command_string(member, "SPOP %s", key.c_str());
}


bool xRedisClient::srandmember(const KEY& key, VALUES& members, int count)
{
    if (0==count) 
{
        return command_list( members, "SRANDMEMBER %s", key.c_str());
    }
    return command_list( members, "SRANDMEMBER %s %d", key.c_str(), count);
}




bool xRedisClient::zadd( const KEY& key,   const VALUES& vValues, int64_t& count)
{
    VDATA vCmdData;
    vCmdData.push_back("ZADD");
    vCmdData.push_back(key);
    addparam(vCmdData, vValues);
    return commandargv_integer( vCmdData, count);
}


 
 bool xRedisClient::setbit(const string& key,  const  int offset, const int64_t newbitValue, int64_t oldbitValue) 
 {
return command_integer(oldbitValue, "SETBIT %s %d %lld", key.c_str(), offset, newbitValue);
 }
 
 bool xRedisClient::get(const string& key,  string& value) 
 {
return command_string(value, "GET %s", key.c_str());
 }




 
 bool xRedisClient::getbit( const string& key, const int& offset, int& bit )
 {
return command_integer((int64_t&)bit, "GETBIT %s %d", key.c_str(), offset);
 }
 
 bool xRedisClient::getrange(const string& key,  const  int start, const int end, string& out) 
 {
return command_string(out, "GETRANGE %s %d %d", key.c_str(), start, end);
 }
 
 bool xRedisClient::getset(const string& key,  const string& newValue, string& oldValue)
 {
return command_string(oldValue, "GETSET %s %s", key.c_str(), newValue.c_str());
 }
 




 bool xRedisClient::setrange(const string& key,  const int offset, const string& value, int& length) 
 {
return command_integer((int64_t&)length, "setrange %s %d %s", key. c_str(), offset, value.c_str());
 }




 


 bool xRedisClient::incrby(const string& key, const int by, int& result)
 {
return command_integer((int64_t&)result, "INCR %s %d", key.c_str(), by);
 }






 
bool xRedisClient::decr( const string& key, int& result)
{
 return command_integer((int64_t&)result,"decr %s", key.c_str());
}
 
 bool xRedisClient::decrby( const string& key, const int by, int& result)
 {
return command_integer((int64_t&)result, "decrby %s %d", key.c_str(), by);
 }





















你可能感兴趣的:(c)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • android系统selinux中添加新属性property 辉色投像
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 每日一题——第九十题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
  • 每日一题——第八十一题 互联网打工人no1 C语言程序设计每日一练c语言
    打印如下图案:#includeintmain(){inti,j;charch='A';for(i=1;i<5;i++,ch++){for(j=0;j<5-i;j++){printf("");//控制空格输出}for(j=1;j<2*i;j++)//条件j<2*i{printf("%c",ch);//控制字符输出}printf("\n");}return0;}
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 每日一题——第八十二题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • 继之前的线程循环加到窗口中运行 3213213333332132 javathreadJFrameJPanel
    之前写了有关java线程的循环执行和结束，因为想制作成exe文件，想把执行的效果加到窗口上，所以就结合了JFrame和JPanel写了这个程序，这里直接贴出代码，在窗口上运行的效果下面有附图。 package thread; import java.awt.Graphics; import java.text.SimpleDateFormat; import java.util
  • linux 常用命令 BlueSkator linux命令
    1.grep 相信这个命令可以说是大家最常用的命令之一了。尤其是查询生产环境的日志，这个命令绝对是必不可少的。 但之前总是习惯于使用 （grep -n 关键字 文件名 ）查出关键字以及该关键字所在的行数，然后再用 （sed -n  '100,200p' 文件名），去查出该关键字之后的日志内容。 但其实还有更简便的办法，就是用（grep  -B n、-A n、-C n 关键
  • php heredoc原文档和nowdoc语法 dcj3sjt126com PHPheredocnowdoc
    <!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body> <?
  • overflow的属性 周华华 JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • 《我所了解的Java》——总体目录 g21121 java
            准备用一年左右时间写一个系列的文章《我所了解的Java》，目录及内容会不断完善及调整。         在编写相关内容时难免出现笔误、代码无法执行、名词理解错误等，请大家及时指出，我会第一时间更正。    &n
  • [简单]docx4j常用方法小结 53873039oycg docx
            本代码基于docx4j-3.2.0，在office word 2007上测试通过。代码如下:         import java.io.File; import java.io.FileInputStream; import ja
  • Spring配置学习 云端月影 spring配置
    首先来看一个标准的Spring配置文件 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=&q
  • Java新手入门的30个基本概念三 aijuans java新手java 入门
    17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)　　 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　
  • 《2008 IBM Rational 软件开发高峰论坛会议》小记 antonyup_2006 软件测试敏捷开发项目管理IBM活动
    我一直想写些总结,用于交流和备忘,然都没提笔,今以一篇参加活动的感受小记开个头,呵呵! 其实参加《2008 IBM Rational 软件开发高峰论坛会议》是9月4号,那天刚好调休.但接着项目颇为忙,所以今天在中秋佳节的假期里整理了下. 参加这次活动是一个朋友给的一个邀请书,才知道有这样的一个活动,虽然现在项目暂时没用到IBM的解决方案,但觉的参与这样一个活动可以拓宽下视野和相关知识.
  • PL/SQL的过程编程,异常,声明变量,PL/SQL块 百合不是茶 PL/SQL的过程编程异常PL/SQL块声明变量
    PL/SQL;    过程; 符号; 变量; PL/SQL块; 输出; 异常;     PL/SQL 是过程语言(Procedural Language)与结构化查询语言(SQL)结合而成的编程语言PL/SQL 是对 SQL 的扩展,sql的执行时每次都要写操作
  • Mockito(三)--完整功能介绍 bijian1013 持续集成mockito单元测试
            mockito官网：http://code.google.com/p/mockito/，打开documentation可以看到官方最新的文档资料。 一.使用mockito验证行为 //首先要import Mockito import static org.mockito.Mockito.*; //mo
  • 精通Oracle10编程SQL(8)使用复合数据类型 bijian1013 oracle数据库plsql
    /* *使用复合数据类型 */ --PL/SQL记录 --定义PL/SQL记录 --自定义PL/SQL记录 DECLARE TYPE emp_record_type IS RECORD( name emp.ename%TYPE, salary emp.sal%TYPE, dno emp.deptno%TYPE ); emp_
  • 【Linux常用命令一】grep命令 bit1129 Linux常用命令
    grep命令格式   grep [option] pattern [file-list]     grep命令用于在指定的文件(一个或者多个,file-list)中查找包含模式串(pattern)的行,[option]用于控制grep命令的查找方式。   pattern可以是普通字符串，也可以是正则表达式，当查找的字符串包含正则表达式字符或者特
  • mybatis3入门学习笔记 白糖_ sqlibatisqqjdbc配置管理
    MyBatis 的前身就是iBatis，是一个数据持久层(ORM)框架。  MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。MyBatis对JDBC进行了一次很浅的封装。   以前也学过iBatis，因为MyBatis是iBatis的升级版本，最初以为改动应该不大，实际结果是MyBatis对配置文件进行了一些大的改动，使整个框架更加方便人性化。
  • Linux 命令神器：lsof 入门 ronin47 lsof
           lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息，但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实，因为它是指“列出打开文件（lists openfiles）”。而有一点要切记，在Unix中一切（包括网络套接口）都是文件。 有趣的是，lsof也是有着最多
  • java实现两个大数相加，可能存在溢出。 bylijinnan java实现
    import java.math.BigInteger; import java.util.regex.Matcher; import java.util.regex.Pattern; public class BigIntegerAddition { /** * 题目：java实现两个大数相加，可能存在溢出。 * 如123456789 + 987654321
  • Kettle学习资料分享，附大神用Kettle的一套流程完成对整个数据库迁移方法 Kai_Ge Kettle
    Kettle学习资料分享   Kettle 3.2 使用说明书 目录 概述..........................................................................................................................................7 1.Kettle 资源库管
  • [货币与金融]钢之炼金术士 comsci 金融
           自古以来,都有一些人在从事炼金术的工作.........但是很少有成功的        那么随着人类在理论物理和工程物理上面取得的一些突破性进展......        炼金术这个古老
  • Toast原来也可以多样化 dai_lm androidtoast
    Style 1： 默认 Toast def = Toast.makeText(this, "default", Toast.LENGTH_SHORT); def.show(); Style 2： 顶部显示 Toast top = Toast.makeText(this, "top", Toast.LENGTH_SHORT); t
  • java数据计算的几种解决方法3 datamachine javahadoopibatisr-languer
    4、iBatis     简单敏捷因此强大的数据计算层。和Hibernate不同，它鼓励写SQL，所以学习成本最低。同时它用最小的代价实现了计算脚本和JAVA代码的解耦，只用20%的代价就实现了hibernate 80%的功能,没实现的20%是计算脚本和数据库的解耦。     复杂计算环境是它的弱项，比如：分布式计算、复杂计算、非数据
  • 向网页中插入透明Flash的方法和技巧 dcj3sjt126com htmlWebFlash
    将 Flash 作品插入网页的时候，我们有时候会需要将它设为透明，有时候我们需要在Flash的背面插入一些漂亮的图片，搭配出漂亮的效果……下面我们介绍一些将Flash插入网页中的一些透明的设置技巧。 　　一、Swf透明、无坐标控制　　首先教大家最简单的插入Flash的代码，透明，无坐标控制： 　　注意wmode="transparent"是控制Flash是否透明
  • ios UICollectionView的使用 dcj3sjt126com
    UICollectionView的使用有两种方法，一种是继承UICollectionViewController，这个Controller会自带一个UICollectionView；另外一种是作为一个视图放在普通的UIViewController里面。 个人更喜欢第二种。下面采用第二种方式简单介绍一下UICollectionView的使用。 1.UIViewController实现委托，代码如
  • Eos平台java公共逻辑 蕃薯耀 Eos平台java公共逻辑Eos平台java公共逻辑
     Eos平台java公共逻辑 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:20:4
  • SpringMVC4零配置--Web上下文配置【MvcConfig】 hanqunfeng springmvc4
    与SpringSecurity的配置类似，spring同样为我们提供了一个实现类WebMvcConfigurationSupport和一个注解@EnableWebMvc以帮助我们减少bean的声明。   applicationContext-MvcConfig.xml <!-- 启用注解，并定义组件查找规则 ，mvc层只负责扫描@Controller --> <
  • 解决ie和其他浏览器poi下载excel文件名乱码 jackyrong Excel
       使用poi,做传统的excel导出，然后想在浏览器中，让用户选择另存为，保存用户下载的xls文件，这个时候，可能的是在ie下出现乱码（ie,9,10,11),但在firefox,chrome下没乱码， 因此必须综合判断，编写一个工具类：      /** * * @Title: pro
  • 挥洒泪水的青春 lampcy 编程生活程序员
    2015年2月28日，我辞职了，离开了相处一年的触控，转过身--挥洒掉泪水，毅然来到了兄弟连，背负着许多的不解、质疑——”你一个零基础、脑子又不聪明的人，还敢跨行业，选择Unity3D？“，”真是不自量力••••••“，”真是初生牛犊不怕虎•••••“，••••••我只是淡淡一笑，拎着行李----坐上了通向挥洒泪水的青春之地——兄弟连！ 这就是我青春的分割线，不后悔，只会去用泪水浇灌——已经来到
  • 稳增长之中国股市两点意见-----严控做空，建立涨跌停版停牌重组机制 nannan408
       对于股市，我们国家的监管还是有点拼的，但始终拼不过飞流直下的恐慌，为什么呢？    笔者首先支持股市的监管。对于股市越管越荡的现象，笔者认为首先是做空力量超过了股市自身的升力，并且对于跌停停牌重组的快速反应还没建立好，上市公司对于股价下跌没有很好的利好支撑。    我们来看美国和香港是怎么应对股灾的。美国是靠禁止重要股票做空，在
  • 动态设置iframe高度(iframe高度自适应) Rainbow702 JavaScriptiframecontentDocument高度自适应局部刷新
    如果需要对画面中的部分区域作局部刷新，大家可能都会想到使用ajax。 但有些情况下，须使用在页面中嵌入一个iframe来作局部刷新。 对于使用iframe的情况，发现有一个问题，就是iframe中的页面的高度可能会很高，但是外面页面并不会被iframe内部页面给撑开，如下面的结构： <div id="content"> <div id=&quo
  • 用Rapael做图表 tntxia rap
    function drawReport(paper,attr,data){          var width = attr.width;     var height = attr.height;          var max = 0;   &nbs
  • HTML5 bootstrap2网页兼容（支持IE10以下） xiaoluode html5bootstrap
    <!DOCTYPE html> <html> <head lang="zh-CN"> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge">
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他