自学教程：C++ str_to_int64函数代码示例

  Bignum::Bignum(const char * number) {    init();    bool symbol = false;    if (number[0] == '-') {      number += 1;      symbol = true;    }    int len = strlen(number), tmp_i = 0;        for (int i = bignum_len - 1; len > 0 && i >= 0; i--) {      tmp_i++;      if (len >= LONG_LEN) {        bignum[i] += str_to_int64(number + (len - LONG_LEN), LONG_LEN);        carry(i);      } else {        bignum[i] += str_to_int64(number, len);        break;      }       len -= LONG_LEN;    }    if (symbol) { bignum[bignum_len - tmp_i] *= -1; }      }

static bool bvfs_parse_arg(UAContext *ua,                           DBId_t *pathid,                           char **path,                           char **jobid,                           char **username,                           int *limit,                           int *offset){   *pathid = 0;   *limit = 2000;   *offset = 0;   *path = NULL;   *jobid = NULL;   *username = NULL;   for (int i=1; i<ua->argc; i++) {      if (bstrcasecmp(ua->argk[i], NT_("pathid"))) {         if (is_a_number(ua->argv[i])) {            *pathid = str_to_int64(ua->argv[i]);         }      }      if (bstrcasecmp(ua->argk[i], NT_("path"))) {         *path = ua->argv[i];      }      if (bstrcasecmp(ua->argk[i], NT_("username"))) {         *username = ua->argv[i];      }      if (bstrcasecmp(ua->argk[i], NT_("jobid"))) {         if (is_a_number_list(ua->argv[i])) {            *jobid = ua->argv[i];         }      }      if (bstrcasecmp(ua->argk[i], NT_("limit"))) {         if (is_a_number(ua->argv[i])) {            *limit = str_to_int64(ua->argv[i]);         }      }      if (bstrcasecmp(ua->argk[i], NT_("offset"))) {         if (is_a_number(ua->argv[i])) {            *offset = str_to_int64(ua->argv[i]);         }      }   }   if (!((*pathid || *path) && *jobid)) {      return false;   }   if (!open_client_db(ua, true)) {      return false;   }   return true;}

/* * This callback routine is responsible for inserting the *  items it gets into the bootstrap structure. For each JobId selected *  this routine is called once for each file. We do not allow *  duplicate filenames, but instead keep the info from the most *  recent file entered (i.e. the JobIds are assumed to be sorted) * *   See uar_sel_files in sql_cmds.c for query that calls us. *      row[0]=Path, row[1]=Filename, row[2]=FileIndex *      row[3]=JobId row[4]=LStat */static int insert_bootstrap_handler(void *ctx, int num_fields, char **row){   JobId_t JobId;   int FileIndex;   RBSR *bsr = (RBSR *)ctx;   JobId = str_to_int64(row[3]);   FileIndex = str_to_int64(row[2]);   add_findex(bsr, JobId, FileIndex);   return 0;}

/* * Called here to make in memory list of JobIds to be *  deleted and the associated PurgedFiles flag. *  The in memory list will then be transversed *  to issue the SQL DELETE commands.  Note, the list *  is allowed to get to MAX_DEL_LIST_LEN to limit the *  maximum malloc'ed memory. */int job_delete_handler(void *ctx, int num_fields, char **row){   struct del_ctx *del = (struct del_ctx *)ctx;   if (!grow_del_list(del)) {      return 1;   }   del->JobId[del->num_ids] = (JobId_t)str_to_int64(row[0]);   Dmsg2(60, "job_delete_handler row=%d val=%d/n", del->num_ids, del->JobId[del->num_ids]);   del->PurgedFiles[del->num_ids++] = (char)str_to_int64(row[1]);   return 0;}

/* * Return next JobId from comma separated list * * Returns: *   1 if next JobId returned *   0 if no more JobIds are in list *  -1 there is an error */int get_next_jobid_from_list(char **p, uint32_t *JobId){    const int maxlen = 30;    char jobid[maxlen+1];    char *q = *p;    jobid[0] = 0;    for (int i=0; i<maxlen; i++) {        if (*q == 0) {            break;        } else if (*q == ',') {            q++;            break;        }        jobid[i] = *q++;        jobid[i+1] = 0;    }    if (jobid[0] == 0) {        return 0;    } else if (!is_a_number(jobid)) {        return -1;                      /* error */    }    *p = q;    *JobId = str_to_int64(jobid);    return 1;}

int64_t Config::get_int64(const char *key) const{	const Config *c = this->get(key);	if(!c){		return 0;	}	return str_to_int64(c->val);}

int SSDB::zincr(const Bytes &name, const Bytes &key, int64_t by, std::string *new_val, char log_type){	Transaction trans(binlogs);	int64_t val;	std::string old;	int ret = this->zget(name, key, &old);	if(ret == -1){		return -1;	}else if(ret == 0){		val = by;	}else{		val = str_to_int64(old.data(), old.size()) + by;	}	*new_val = int64_to_str(val);	ret = zset_one(this, name, key, *new_val, log_type);	if(ret >= 0){		if(ret > 0){			if(incr_zsize(this, name, ret) == -1){				return -1;			}		}		leveldb::Status s = binlogs->commit();		if(!s.ok()){			log_error("zset error: %s", s.ToString().c_str());			return -1;		}	}	return ret;}

static bool bvfs_parse_arg_version(UAContext *ua, char **client, DBId_t *fnid, bool *versions, bool *copies){   *fnid = 0;   *client = NULL;   *versions = false;   *copies = false;   for (int i = 1; i < ua->argc; i++) {      if (bstrcasecmp(ua->argk[i], NT_("fnid")) ||          bstrcasecmp(ua->argk[i], NT_("filenameid"))) {         if (is_a_number(ua->argv[i])) {            *fnid = str_to_int64(ua->argv[i]);         }      }      if (bstrcasecmp(ua->argk[i], NT_("client"))) {         *client = ua->argv[i];      }      if (copies && bstrcasecmp(ua->argk[i], NT_("copies"))) {         *copies = true;      }      if (versions && bstrcasecmp(ua->argk[i], NT_("versions"))) {         *versions = true;      }   }   return (*client && *fnid > 0);}

int SSDBImpl::hincr(const Bytes &name, const Bytes &key, int64_t by, int64_t *new_val, char log_type){	Transaction trans(binlogs);	std::string old;	int ret = this->hget(name, key, &old);	if(ret == -1){		return -1;	}else if(ret == 0){		*new_val = by;	}else{		*new_val = str_to_int64(old) + by;		if(errno != 0){			return 0;		}	}	ret = hset_one(this, name, key, str(*new_val), log_type);	if(ret == -1){		return -1;	}	if(ret >= 0){		if(ret > 0){			if(incr_hsize(this, name, ret) == -1){				return -1;			}		}		leveldb::Status s = binlogs->commit();		if(!s.ok()){			return -1;		}	}	return 1;}

static void fill_attr(ATTR_DBR *ar, char *data){   char *p;   char *b;   int index=0;   ar->Stream = STREAM_UNIX_ATTRIBUTES;   ar->JobId = getpid();   for(p = b = data; *p; p++) {      if (*p == ';') {         *p = '/0';         switch (index) {         case 0:            ar->FileIndex = str_to_int64(b);            break;         case 1:            ar->fname = b;            break;         case 2:            ar->attr = b;            break;         case 3:            ar->Digest = b;            break;         }         index++;         b = ++p;      }   }}

static int result_handler(void *ctx, int fields, char **row){   Bvfs *vfs = (Bvfs *)ctx;   ATTR *attr = vfs->get_attr();   char empty[] = "A A A A A A A A A A A A A A";   memset(&attr->statp, 0, sizeof(struct stat));   decode_stat((row[BVFS_LStat] && row[BVFS_LStat][0])?row[BVFS_LStat]:empty,               &attr->statp, sizeof(attr->statp),  &attr->LinkFI);   if (bvfs_is_dir(row) || bvfs_is_file(row)) {      /* display clean stuffs */      if (bvfs_is_dir(row)) {         pm_strcpy(attr->ofname, bvfs_basename_dir(row[BVFS_Name]));      } else {         /* if we see the requested file, note his filenameid */         if (bstrcmp(row[BVFS_Name], file)) {            fnid = str_to_int64(row[BVFS_FilenameId]);         }         pm_strcpy(attr->ofname, row[BVFS_Name]);      }      print_ls_output(vfs->get_jcr(), attr);   } else {      Pmsg5(0, "JobId=%s FileId=%s/tMd5=%s/tVolName=%s/tVolInChanger=%s/n",            row[BVFS_JobId], row[BVFS_FileId], row[BVFS_Md5], row[BVFS_VolName],            row[BVFS_VolInchanger]);      pm_strcpy(attr->ofname, file);      print_ls_output(vfs->get_jcr(), attr);   }   return 0;}

int SSDB::incr(const Bytes &key, int64_t by, std::string *new_val, char log_type){	Transaction trans(binlogs);	int64_t val;	std::string old;	int ret = this->get(key, &old);	if(ret == -1){		return -1;	}else if(ret == 0){		val = by;	}else{		val = str_to_int64(old.data(), old.size()) + by;	}	*new_val = int64_to_str(val);	std::string buf = encode_kv_key(key);		binlogs->Put(buf, *new_val);	binlogs->add_log(log_type, BinlogCommand::KSET, buf);	leveldb::Status s = binlogs->commit();	if(!s.ok()){		log_error("del error: %s", s.ToString().c_str());		return -1;	}	return 1;}

/* * Find JobId of last job that ran.  E.g. for *   VERIFY_CATALOG we want the JobId of the last INIT. *   For VERIFY_VOLUME_TO_CATALOG, we want the JobId of the last Job. * * Returns: true  on success *          false on failure */booldb_find_last_jobid(JCR *jcr, B_DB *mdb, const char *Name, JOB_DBR *jr){   SQL_ROW row;   char ed1[50];   /* Find last full */   db_lock(mdb);   Dmsg2(100, "JobLevel=%d JobType=%d/n", jr->JobLevel, jr->JobType);   if (jr->JobLevel == L_VERIFY_CATALOG) {      Mmsg(mdb->cmd,"SELECT JobId FROM Job WHERE Type='V' AND Level='%c' AND "" JobStatus IN ('T','W') AND Name='%s' AND ""ClientId=%s ORDER BY StartTime DESC LIMIT 1",           L_VERIFY_INIT, jr->Name,            edit_int64(jr->ClientId, ed1));   } else if (jr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG ||              jr->JobLevel == L_VERIFY_DISK_TO_CATALOG ||              jr->JobType == JT_BACKUP) {      if (Name) {         Mmsg(mdb->cmd,"SELECT JobId FROM Job WHERE Type='B' AND JobStatus IN ('T','W') AND ""Name='%s' ORDER BY StartTime DESC LIMIT 1", Name);      } else {         Mmsg(mdb->cmd,"SELECT JobId FROM Job WHERE Type='B' AND JobStatus IN ('T','W') AND ""ClientId=%s ORDER BY StartTime DESC LIMIT 1",            edit_int64(jr->ClientId, ed1));      }   } else {      Mmsg1(&mdb->errmsg, _("Unknown Job level=%d/n"), jr->JobLevel);      db_unlock(mdb);      return false;   }   Dmsg1(100, "Query: %s/n", mdb->cmd);   if (!QUERY_DB(jcr, mdb, mdb->cmd)) {      db_unlock(mdb);      return false;   }   if ((row = sql_fetch_row(mdb)) == NULL) {      Mmsg1(&mdb->errmsg, _("No Job found for: %s./n"), mdb->cmd);      sql_free_result(mdb);      db_unlock(mdb);      return false;   }   jr->JobId = str_to_int64(row[0]);   sql_free_result(mdb);   Dmsg1(100, "db_get_last_jobid: got JobId=%d/n", jr->JobId);   if (jr->JobId <= 0) {      Mmsg1(&mdb->errmsg, _("No Job found for: %s/n"), mdb->cmd);      db_unlock(mdb);      return false;   }   db_unlock(mdb);   return true;}

int64_t ExpirationHandler::get_ttl(const Bytes &key){	std::string score;	if(ssdb->zget(this->list_name, key, &score) == 1){		int64_t ex = str_to_int64(score);		return (ex - time_ms())/1000;	}	return -1;}

/* * Called here to make in memory list of JobIds to be *  deleted and the associated PurgedFiles flag. *  The in memory list will then be transversed *  to issue the SQL DELETE commands.  Note, the list *  is allowed to get to MAX_DEL_LIST_LEN to limit the *  maximum malloc'ed memory. */int job_delete_handler(void *ctx, int num_fields, char **row){   struct del_ctx *del = (struct del_ctx *)ctx;   if (del->num_ids == MAX_DEL_LIST_LEN) {      return 1;   }   if (del->num_ids == del->max_ids) {      del->max_ids = (del->max_ids * 3) / 2;      del->JobId = (JobId_t *)brealloc(del->JobId, sizeof(JobId_t) * del->max_ids);      del->PurgedFiles = (char *)brealloc(del->PurgedFiles, del->max_ids);   }   del->JobId[del->num_ids] = (JobId_t)str_to_int64(row[0]);// Dmsg2(60, "row=%d val=%d/n", del->num_ids, del->JobId[del->num_ids]);   del->PurgedFiles[del->num_ids++] = (char)str_to_int64(row[1]);   return 0;}

int main(int argc, char **argv[]){    char *s;    int error;    int64_t i;    uint64_t u;    //s = "-128";    //s = "-32768";    //s = "-2147483648";    //s = "-9223372036854775808";    //s = "128";    //s = "32768";    //s = "2147483648";    //s = "9223372036854775808";    //s = "255";    //s = "65535";    //s = "4294967295";    s = "18446744073709551615";    //s = "256";    //s = "65536";    //s = "4294967296";    //s = "18446744073709551616";    printf("s = '%s'/n/n", s);    i = str_to_int64(s, INT8_MIN, INT8_MAX, &error);    printf(" 8: i = %lld  error = %d/n", i, error);    i = str_to_int64(s, INT16_MIN, INT16_MAX, &error);    printf("16: i = %lld  error = %d/n", i, error);    i = str_to_int64(s, INT32_MIN, INT32_MAX, &error);    printf("32: i = %lld  error = %d/n", i, error);    i = str_to_int64(s, INT64_MIN, INT64_MAX, &error);    printf("64: i = %lld  error = %d/n", i, error);    printf("/n");    u = str_to_uint64(s, UINT8_MAX, &error);    printf(" 8: u = %llu  error = %d/n", u, error);    u = str_to_uint64(s, UINT16_MAX, &error);    printf("16: u = %llu  error = %d/n", u, error);    u = str_to_uint64(s, UINT32_MAX, &error);    printf("32: u = %llu  error = %d/n", u, error);    u = str_to_uint64(s, UINT64_MAX, &error);    printf("64: u = %llu  error = %d/n", u, error);    return 0;}

int64_t config_get_default_int(const config_t *config, const char *section,		const char *name){	const char *value = config_get_default_string(config, section, name);	if (value)		return str_to_int64(value);	return 0;}

/* * Called here to retrieve a 32/64 bit integer from the database. *   The returned integer will be extended to 64 bit. */int db_int64_handler(void *ctx, int num_fields, char **row){   db_int64_ctx *lctx = (db_int64_ctx *)ctx;   if (row[0]) {      lctx->value = str_to_int64(row[0]);      lctx->count++;   }   return 0;}

int file_delete_handler(void *ctx, int num_fields, char **row){   struct del_ctx *del = (struct del_ctx *)ctx;   if (!grow_del_list(del)) {      return 1;   }   del->JobId[del->num_ids++] = (JobId_t)str_to_int64(row[0]);// Dmsg2(150, "row=%d val=%d/n", del->num_ids-1, del->JobId[del->num_ids-1]);   return 0;}

/* * Called here to count entries to be deleted */int del_count_handler(void *ctx, int num_fields, char **row){   struct s_count_ctx *cnt = (struct s_count_ctx *)ctx;   if (row[0]) {      cnt->count = str_to_int64(row[0]);   } else {      cnt->count = 0;   }   return 0;}

inline staticStatus _read_int64(const std::vector<std::string> *resp, int64_t *ret){	Status s(resp);	if(s.ok()){		if(resp->size() >= 2){			*ret = str_to_int64(resp->at(1));		}else{			return Status("server_error");		}	}	return s;}

long long SSDBClient::TTL(const std::string& key){    Base::Mutex::ScopedLock scopedLock(m_oMutex);    long long ttl = 0;    const std::vector<std::string>* rsp = m_Client->request("ttl", RealKey(key));    ssdb::Status status(rsp);    if (status.ok() && rsp->size() >= 2)     {        ttl = str_to_int64(rsp->at(1));    }    return ttl;}

/* * Delete Pool record, must also delete all associated *  Media records. * *  Returns: false on error *           true on success *           PoolId = number of Pools deleted (should be 1) *           NumVols = number of Media records deleted */bool db_delete_pool_record(JCR *jcr, B_DB *mdb, POOL_DBR *pr){   bool retval = false;   SQL_ROW row;   int num_rows;   char esc[MAX_ESCAPE_NAME_LENGTH];   db_lock(mdb);   mdb->db_escape_string(jcr, esc, pr->Name, strlen(pr->Name));   Mmsg(mdb->cmd, "SELECT PoolId FROM Pool WHERE Name='%s'", esc);   Dmsg1(10, "selectpool: %s/n", mdb->cmd);   pr->PoolId = pr->NumVols = 0;   if (QUERY_DB(jcr, mdb, mdb->cmd)) {      num_rows = sql_num_rows(mdb);      if (num_rows == 0) {         Mmsg(mdb->errmsg, _("No pool record %s exists/n"), pr->Name);         sql_free_result(mdb);         goto bail_out;      } else if (num_rows != 1) {         Mmsg(mdb->errmsg, _("Expecting one pool record, got %d/n"), num_rows);         sql_free_result(mdb);         goto bail_out;      }      if ((row = sql_fetch_row(mdb)) == NULL) {         Mmsg1(mdb->errmsg, _("Error fetching row %s/n"), sql_strerror(mdb));         goto bail_out;      }      pr->PoolId = str_to_int64(row[0]);      sql_free_result(mdb);   }   /* Delete Media owned by this pool */   Mmsg(mdb->cmd,"DELETE FROM Media WHERE Media.PoolId = %d", pr->PoolId);   pr->NumVols = DELETE_DB(jcr, mdb, mdb->cmd);   Dmsg1(200, "Deleted %d Media records/n", pr->NumVols);   /* Delete Pool */   Mmsg(mdb->cmd,"DELETE FROM Pool WHERE Pool.PoolId = %d", pr->PoolId);   pr->PoolId = DELETE_DB(jcr, mdb, mdb->cmd);   Dmsg1(200, "Deleted %d Pool records/n", pr->PoolId);   retval = true;bail_out:   db_unlock(mdb);   return retval;}

Status ClientImpl::qpush(const std::string &name, const std::vector<std::string> &items, int64_t *ret_size){	const std::vector<std::string> *resp;	resp = this->request("qpush", name, items);	Status s(resp);	if(ret_size != NULL && s.ok()){		if(resp->size() > 1){			*ret_size = str_to_int64(resp->at(1));		}else{			return Status("error");		}	}	return s;}

/* row: Job.Name, FileSet, Client.Name, FileSetId, ClientId, Type */static int job_select_handler(void *ctx, int num_fields, char **row){   alist *lst = (alist *)ctx;   struct accurate_check_ctx *res;   ASSERT(num_fields == 6);   /* Quick fix for #5507, avoid locking res_head after db_lock() */#ifdef bug5507   /* If this job doesn't exist anymore in the configuration, delete it */   if (GetResWithName(R_JOB, row[0]) == NULL) {      return 0;   }   /* If this fileset doesn't exist anymore in the configuration, delete it */   if (GetResWithName(R_FILESET, row[1]) == NULL) {      return 0;   }   /* If this client doesn't exist anymore in the configuration, delete it */   if (GetResWithName(R_CLIENT, row[2]) == NULL) {      return 0;   }#endif   /* Don't compute accurate things for Verify jobs */   if (*row[5] == 'V') {      return 0;   }   res = (struct accurate_check_ctx*) malloc(sizeof(struct accurate_check_ctx));   res->FileSetId = str_to_int64(row[3]);   res->ClientId = str_to_int64(row[4]);   lst->append(res);// Dmsg2(150, "row=%d val=%d/n", del->num_ids-1, del->JobId[del->num_ids-1]);   return 0;}

int proc_zsum(NetworkServer *net, Link *link, const Request &req, Response *resp){	SSDBServer *serv = (SSDBServer *)net->data;	CHECK_NUM_PARAMS(4);	int64_t sum = 0;	ZIterator *it = serv->ssdb->zscan(req[1], "", req[2], req[3], -1);	while(it->next()){		sum += str_to_int64(it->score);	}	delete it;		resp->reply_int(0, sum);	return 0;}

/* * Called here to make in memory list of JobIds to be *  deleted. The in memory list will then be transversed *  to issue the SQL DELETE commands.  Note, the list *  is allowed to get to MAX_DEL_LIST_LEN to limit the *  maximum malloc'ed memory. */static int delete_handler(void *ctx, int num_fields, char **row){   struct s_del_ctx *del = (struct s_del_ctx *)ctx;   if (del->num_ids == MAX_DEL_LIST_LEN) {      return 1;   }   if (del->num_ids == del->max_ids) {      del->max_ids = (del->max_ids * 3) / 2;      del->JobId = (JobId_t *)brealloc(del->JobId, sizeof(JobId_t) *         del->max_ids);   }   del->JobId[del->num_ids++] = (JobId_t)str_to_int64(row[0]);   return 0;}

int SSDB::zincr(const Bytes &name, const Bytes &key, int64_t by, std::string *new_val) const{	int64_t val;	std::string old;	int ret = this->zget(name, key, &old);	if(ret == -1){		return -1;	}else if(ret == 0){		val = by;	}else{		val = str_to_int64(old.data(), old.size()) + by;	}	*new_val = int64_to_str(val);	return this->zset(name, key, *new_val);}

/* * Called here to retrieve an integer from the database */int db_int_handler(void *ctx, int num_fields, char **row){   uint32_t *val = (uint32_t *)ctx;   Dmsg1(800, "int_handler starts with row pointing at %x/n", row);   if (row[0]) {      Dmsg1(800, "int_handler finds '%s'/n", row[0]);      *val = str_to_int64(row[0]);   } else {      Dmsg0(800, "int_handler finds zero/n");      *val = 0;   }   Dmsg0(800, "int_handler finishes/n");   return 0;}

Status ClientImpl::zsize(const std::string &name, int64_t *ret){	std::vector<std::string> req;	const std::vector<std::string> *resp;	req.push_back("zsize");	req.push_back(name);	resp = request(req);	Status s(resp);	if(s.ok()){		if(resp->size() >= 2){			*ret = str_to_int64(resp->at(1));		}else{			return Status("server_error");		}	}	return s;}