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

static rc_t SaveToFile( struct KFile * f, const VNamelist * nl, const char * delim ){    uint32_t count;    rc_t rc = VNameListCount ( nl, &count );    if ( rc == 0 && count > 0 )    {        uint32_t idx;        uint64_t pos = 0;        for ( idx = 0; idx < count && rc == 0; ++idx )        {            const char * s;            rc = VNameListGet ( nl, idx, &s );            if ( rc == 0 && s != NULL )            {                size_t num_writ;                rc = KFileWriteAll ( f, pos, s, string_size ( s ), &num_writ );                if ( rc == 0 )                {                    pos += num_writ;                    rc = KFileWriteAll ( f, pos, delim, string_size ( delim ), &num_writ );                    if ( rc == 0 )                        pos += num_writ;                }            }        }        if ( rc == 0 )            rc = KFileSetSize ( f, pos );    }    return rc;}

/* ----------------------------------------------------------------------------- */static bool has_col( const VTable * tab, const char * colname ){    bool res = false;    struct KNamelist * columns;    rc_t rc = VTableListReadableColumns( tab, &columns );    if ( rc == 0 )    {        uint32_t count;        rc = KNamelistCount( columns, &count );        if ( rc == 0 && count > 0 )        {            uint32_t idx;            size_t colname_size = string_size( colname );            for ( idx = 0; idx < count && rc == 0 && !res; ++idx )            {                const char * a_name;                rc = KNamelistGet ( columns, idx, &a_name );                if ( rc == 0 )                {                    int cmp;                    size_t a_name_size = string_size( a_name );                    uint32_t max_chars = ( uint32_t )colname_size;                    if ( a_name_size > max_chars ) max_chars = ( uint32_t )a_name_size;                    cmp = strcase_cmp ( colname, colname_size,                                        a_name, a_name_size,                                        max_chars );                    res = ( cmp == 0 );                }            }        }        KNamelistRelease( columns );    }    return res;}

staticint64_t CC sort_cmp (const void ** l, const void ** r, void * data){/*  KDirectory * d; */    uint64_t lz, rz;    rc_t rc;/*    d = data; *//*     lz = l; *//*     rz = r; */    rc = KDirectoryFileSize (data, &lz, *l);    if (rc == 0)    {        rc = KDirectoryFileSize (data, &rz, *r);        if (rc == 0)        {            int64_t zdiff;            zdiff = lz - rz;            if (zdiff != 0)                return (zdiff < 0) ? -1 : 1;            else            {                size_t lsz = string_size (*l);                size_t rsz = string_size (*r);                return string_cmp (*l, lsz, *r, rsz, lsz+1);            }        }    }    return 0; /* dunno just leave it... */}

rc_t vds_append_str( p_dump_str s, const char *s1 ){    rc_t rc = 0;    if ( ( s == NULL )||( s1 == NULL ) )    {        rc = RC( rcVDB, rcNoTarg, rcInserting, rcParam, rcNull );    }    else    {        size_t append_len = string_size( s1 );        if ( append_len > 0 )        {            if ( ( s->str_limit > 0 )&&( s->str_len >= s->str_limit ) )            {                s->truncated = true;            }            else            {                rc = vds_inc_buffer( s, append_len );                if ( rc == 0 )                {                    size_t l = string_size( s->buf );                    string_copy( s->buf + l, s->buf_size - l, s1, append_len );                    rc = vds_truncate( s ); /* adjusts str_len */                }            }        }    }    return rc;}

bool namelist_contains( const KNamelist *names, const char * a_name ){    bool res = false;    uint32_t count;    rc_t rc = KNamelistCount( names, &count );    if ( rc == 0 && count > 0 )    {        uint32_t idx;        size_t a_name_len = string_size( a_name );        for ( idx = 0; idx < count && rc == 0 && !res; ++idx )        {            const char * s;            rc = KNamelistGet( names, idx, &s );            if ( rc == 0 && s != NULL )            {                size_t s_len = string_size( s );                size_t max_len = a_name_len > s_len ? a_name_len : s_len;                int cmp = string_cmp( a_name, a_name_len, s, s_len, max_len );                if ( cmp == 0 )                    res = true;            }        }    }    return res;}

/** * Processes the command-line options, filling in the members of the Options * structure corresponding to the switches */int options_parse(Options *self, int argc, char *argv[]){  int arg = 1;  while (arg < argc) {    String s = string_from_c(argv[arg]);    /* Debug: */    if (!strcmp(argv[arg], "-d") || !strcmp(argv[arg], "--debug")) {      self->debug = 1;    /* Output filename: */    } else if (!strcmp(argv[arg], "-o")) {      ++arg;      if (argc <= arg) return 0;      self->name_out = string_from_c(argv[arg]);    /* Output filename, smushed: */    } else if (2 == string_match(s, string_from_k("-o"))) {      self->name_out = string(s.p + 2, s.end);    /* Input filename: */    } else {      if (string_size(self->name_in)) return 0;      self->name_in = s;    }    ++arg;  }  if (!string_size(self->name_in))    return 0;  return 1;}

/****************************************************************************************    splits an argument    example: "/path/file=grp1" into path = "/path/file" and attribute = "grp1"    or    example: "/path/file" into path = "/path/file" and attribute = NULL****************************************************************************************/static rc_t split_argument( const char *argument, char ** path, char ** attribute, char delim ){    if ( argument == NULL || path == NULL || attribute == NULL )        return RC( rcApp, rcNoTarg, rcConstructing, rcParam, rcNull );    else    {        char * delim_ptr = string_chr ( argument, string_size ( argument ), delim );        if ( delim_ptr == NULL )        {            *path = string_dup_measure( argument, NULL );            *attribute = NULL;        }        else        {            size_t len = string_size( argument );            size_t len1 = ( delim_ptr - argument );            *path = string_dup ( argument, len1 );            if ( delim_ptr < argument + len - 1 )                *attribute = string_dup ( delim_ptr + 1, len - ( len1 + 1 ) );            else                *attribute = NULL;        }    }    return 0;}

LIB_EXPORTrc_t CCXFS_StrEndsWith ( const char * Str, const char * End ){    uint32_t StrLen, EndLen;    if ( Str == NULL || End == NULL ) {        return false;    }    StrLen = string_len ( Str, string_size ( Str ) );    EndLen = string_len ( End, string_size ( End ) );    if ( StrLen >= EndLen && EndLen > 0 ) {        return string_cmp (                        Str + ( StrLen - EndLen ),                        EndLen,                        End,                        EndLen,                        EndLen                        ) == 0;    }    return false;}   /* XFS_StrEndsWith () */

static int64_t DictionaryEntryFind ( const void *p_a, const BSTNode *p_b ){    const char * a = ( const char * ) p_a;    DictionaryEntry* b = ( DictionaryEntry * ) p_b;        size_t a_path_size = string_size ( a );    return string_cmp ( a, a_path_size, b -> path, string_size ( b -> path ), ( uint32_t ) a_path_size );}

static int64_t DictionaryEntryCompare ( const BSTNode *p_a, const BSTNode *p_b ){    DictionaryEntry* a = ( DictionaryEntry * ) p_a;    DictionaryEntry* b = ( DictionaryEntry * ) p_b;        size_t a_path_size = string_size ( a -> path );    return string_cmp ( a -> path, a_path_size, b -> path, string_size ( b -> path ), ( uint32_t ) a_path_size );}

app_action_t application_function_flash_receive(string_t *src, string_t *dst){	unsigned int chunk_offset, chunk_length;	if(string_size(&flash_sector_buffer) < SPI_FLASH_SEC_SIZE)	{		string_format(dst, "ERROR flash-receive: flash sector buffer too small: %d/n", string_size(&flash_sector_buffer));		return(app_action_error);	}	if(parse_uint(1, src, &chunk_offset, 0, ' ') != parse_ok)	{		string_append(dst, "ERROR flash-receive: chunk offset required/n");		return(app_action_error);	}	if(parse_uint(2, src, &chunk_length, 0, ' ') != parse_ok)	{		string_append(dst, "ERROR flash-receive: chunk chunk_length required/n");		return(app_action_error);	}	if((chunk_length == 0) || ((chunk_offset % chunk_length) != 0))	{		string_append(dst, "ERROR: flash-receive: chunk offset should be divisible by chunk size");		return(app_action_error);	}	if((chunk_length == 0) || ((SPI_FLASH_SEC_SIZE % chunk_length) != 0))	{		string_append(dst, "ERROR: flash-receive: chunk length should be divisible by flash sector size");		return(app_action_error);	}	if((chunk_offset + chunk_length) > SPI_FLASH_SEC_SIZE)	{		string_format(dst, "ERROR flash-receive: chunk_length(%u) + chunk_offset(%u) > sector size(%d)/n", chunk_length, chunk_offset, SPI_FLASH_SEC_SIZE);		return(app_action_error);	}	if((flash_sector_buffer_use != fsb_free) && (flash_sector_buffer_use != fsb_config_cache) && (flash_sector_buffer_use != fsb_ota))	{		string_format(dst, "ERROR: flash_send: sector buffer in use: %u/n", flash_sector_buffer_use);		return(app_action_error);	}	flash_sector_buffer_use = fsb_ota;	string_format(dst, "OK flash-receive: sending bytes: %u, from offset: %u, data: @", chunk_length, chunk_offset);	string_splice(dst, -1, &flash_sector_buffer, chunk_offset, chunk_length);	string_append(dst, "/n");	if((chunk_offset + chunk_length) >= SPI_FLASH_SEC_SIZE)		flash_sector_buffer_use = fsb_free;	return(app_action_normal);}

staticrc_t ConfigRepoSet(DLList* repos, KConfig * kfg, const char* kfgPath, const char *dflt, uint8_t type){    const KConfigNode *node;    rc_t rc = KConfigOpenNodeRead ( kfg, & node, kfgPath );    if ( rc == 0 )    {        KNamelist* children;        rc = KConfigNodeListChild ( node, &children );        if ( rc == 0 )        {            uint32_t count;            rc = KNamelistCount ( children, &count );            if ( rc == 0 )            {                uint32_t i;                for (i = 0; i < count; ++i)                {                    const char* name;                    rc = KNamelistGet ( children, i, &name );                    if ( rc == 0 )                    {                        #define BufSize 4096                        char buf[ BufSize ];                        size_t bSize = string_size(kfgPath);                        string_copy(buf, BufSize, kfgPath, bSize);                        if (bSize + string_size(name) < sizeof(buf))                        {                            NCBIRepository* repo;                            string_copy(buf + bSize, sizeof(buf) - bSize, name, string_size(name) + 1);                            rc = ConfigRepo( kfg, dflt, buf, buf, type, &repo );                            DLListPushTail( repos, (DLNode*) repo );                        }                        #undef BufSize                    }                    else                    {                        rc = RC ( rcSRA, rcMgr, rcConstructing, rcString, rcExcessive );                    }                    if ( rc != 0 )                    {                        break;                    }                }            }            KNamelistRelease ( children );        }        KConfigNodeRelease ( node );    }    if (GetRCState(rc) == rcNotFound)    {        return 0;    }    return rc;}

/** * Concatenates one string onto another. The new string is silently null- * terminated, and can be passed to C functions. */String string_cat(Pool *pool, String s1, String s2){  size_t size = string_size(s1) + string_size(s2);  char *out = (char*)pool_alloc(pool, size + 1, 1);  memcpy(out, s1.p, string_size(s1));  memcpy(out + string_size(s1), s2.p, string_size(s2));  out[size] = 0;  return string(out, out + size);}

/* * walks through the column-definitions and if a column * has the to_copy-flag set, and it's name is in the * given list of column-names the to copy-flag is cleared * does not require an open cursor.*/rc_t col_defs_exclude_these_columns( col_defs* defs, const char * prefix, const char * column_names ){    rc_t rc = 0;    const KNamelist *names;    if ( defs == NULL )        return RC( rcExe, rcNoTarg, rcResolving, rcSelf, rcNull );    /* it is OK if we have not column-names to exclude */    if ( column_names == NULL )        return 0;    if ( column_names[0] == 0 )        return 0;    rc = nlt_make_namelist_from_string( &names, column_names );    DISP_RC( rc, "col_defs_parse_string:nlt_make_namelist_from_string() failed" );    if ( rc == 0 )    {        uint32_t idx, len = VectorLength( &(defs->cols) );        size_t prefix_len = 0;        if ( prefix != 0 )            prefix_len = string_size( prefix ) + 2;        for ( idx = 0;  idx < len; ++idx )        {            p_col_def col = (p_col_def) VectorGet ( &(defs->cols), idx );            if ( col != NULL )            {                if ( col->requested )                {                    if ( nlt_is_name_in_namelist( names, col->name ) )                        col->requested = false;                    else                    {                        if ( prefix != NULL )                        {                            size_t len1 = string_size ( col->name ) + prefix_len;                            char * s = malloc( len1 );                            if ( s != NULL )                            {                                size_t num_writ;                                rc_t rc1 = string_printf ( s, len1, &num_writ, "%s:%s", prefix, col->name );                                if ( rc1 == 0 )                                {                                    if ( nlt_is_name_in_namelist( names, s ) )                                        col->requested = false;                                }                                free( s );                            }                        }                    }                }            }        }        KNamelistRelease( names );    }    return rc;}

static int cmp_pchar( const char * a, const char * b ){    int res = 0;    if ( ( a != NULL )&&( b != NULL ) )    {        size_t len_a = string_size( a );        size_t len_b = string_size( b );        res = string_cmp ( a, len_a, b, len_b, ( len_a < len_b ) ? len_b : len_a );    }    return res;}

static seq_id_node * make_seq_id_node( const char * seq_id, const char * name, INSDC_coord_len seq_len ){    seq_id_node *res = calloc( sizeof *res, 1 );    if ( res != NULL )    {        res->name = string_dup( name, string_size( name ) );        res->seq_id = string_dup( seq_id, string_size( seq_id ) );        res->seq_len = seq_len;    }    return res;}

/** * Initialize string container with an exist sub string container. */void string_init_copy_substring(string_t* pstr_dest, const string_t* cpstr_src, size_t t_pos, size_t t_len){    assert(pstr_dest != NULL);    assert(cpstr_src != NULL);    assert(t_pos < string_size(cpstr_src));    basic_string_init_copy_substring(pstr_dest, cpstr_src, t_pos, t_len);    if(t_len != NPOS && t_pos + t_len <= string_size(cpstr_src))    {        basic_string_push_back(pstr_dest, '/0');    }}

static bool string_ends_in( const char * str, const char * end ){    bool res = false;    if ( str != NULL && end != NULL )    {        uint32_t l_str = string_len( str, string_size( str ) );        uint32_t l_end = string_len( end, string_size( end ) );        if ( l_str >= l_end && l_end > 0 )        {            const char * p = str + ( l_str - l_end );            res = ( string_cmp ( p, l_end, end, l_end, l_end ) == 0 );        }    }    return res;}

app_action_t application_function_flash_read(string_t *src, string_t *dst){	unsigned int address, sector;	SHA_CTX sha_context;	unsigned char sha_result[SHA_DIGEST_LENGTH];	string_new(, sha_string, SHA_DIGEST_LENGTH * 2 + 2);	if(string_size(&flash_sector_buffer) < SPI_FLASH_SEC_SIZE)	{		string_format(dst, "ERROR flash-read: flash sector buffer too small: %d/n", string_size(&flash_sector_buffer));		return(app_action_error);	}	if(parse_uint(1, src, &address, 0, ' ') != parse_ok)	{		string_append(dst, "ERROR flash-read: address required/n");		return(app_action_error);	}	if((address % SPI_FLASH_SEC_SIZE) != 0)	{		string_append(dst, "ERROR flash-read: address should be divisible by flash sector size");		return(app_action_error);	}	if((flash_sector_buffer_use != fsb_free) && (flash_sector_buffer_use != fsb_config_cache))	{		string_format(dst, "ERROR: flash-read: sector buffer in use: %u/n", flash_sector_buffer_use);		return(app_action_error);	}	flash_sector_buffer_use = fsb_ota;	sector = address / SPI_FLASH_SEC_SIZE;	spi_flash_read(sector * SPI_FLASH_SEC_SIZE, string_buffer_nonconst(&flash_sector_buffer), SPI_FLASH_SEC_SIZE);	string_setlength(&flash_sector_buffer, SPI_FLASH_SEC_SIZE);	SHA1Init(&sha_context);	SHA1Update(&sha_context, string_buffer(&flash_sector_buffer), SPI_FLASH_SEC_SIZE);	SHA1Final(sha_result, &sha_context);	string_bin_to_hex(&sha_string, sha_result, SHA_DIGEST_LENGTH);	string_format(dst, "OK flash-read: read bytes: %d, from address: %u (%u), checksum: ", SPI_FLASH_SEC_SIZE, address, sector);	string_append_string(dst, &sha_string);	string_append(dst, "/n");	return(app_action_normal);}

/* returns a NUL-terminated password fitting in the buffer */staticrc_tReadPassword(const struct KFile* pwd_in, size_t* last_pos, char* buf, size_t buf_size){string_copy(buf, buf_size, "screwuahole", string_size("screwuahole")); return 0;    rc_t rc = 0;    size_t i =0;    do    {        size_t num_read;        if (i == buf_size)            return RC(rcApp, rcEncryptionKey, rcReading, rcParam, rcTooLong);                    rc = KFileRead( pwd_in, *last_pos, & buf[i], 1, &num_read );        if (rc == 0)        {            if (num_read != 1)                return RC(rcApp, rcEncryptionKey, rcReading, rcSize, rcInvalid);            if (buf[i] == '/n')            {                buf[i] = 0;                ++ *last_pos;                break;            }        }        ++ *last_pos;        ++ i;    }    while(rc == 0);    return rc;}

rc_t KeyRingInit ( KKeyRing* self, const char* path ){    rc_t rc;        memset ( self, 0, sizeof * self );    KRefcountInit ( & self -> refcount, 0, "KKeyRing", "init", "" );        rc = KDirectoryNativeDir(&self->wd);    if (rc == 0)    {        self->path = string_dup(path, string_size(path));        if (self->path)        {            self->data = (KeyRingData*) malloc(sizeof(*self->data));            if (self->data)            {                rc = KeyRingDataInit ( self->data );                if (rc != 0)                    free(self->data);            }            else                rc = RC ( rcApp, rcDatabase, rcOpening, rcMemory, rcExhausted );                            if (rc != 0)                free(self->path);        }        else            rc = RC ( rcApp, rcDatabase, rcOpening, rcMemory, rcExhausted );                    if (rc != 0)            KDirectoryRelease(self->wd);    }            return rc;}

LIB_EXPORT rc_t CC AlignAccessAlignmentEnumeratorGetShortSeqID(                                                 const AlignAccessAlignmentEnumerator *self,                                                 char *id_buffer, size_t buffer_size, size_t *id_size) {    rc_t rc;    size_t id_act_size;    const char *readName;        if (self == NULL)        return 0;    if (id_buffer == NULL && id_size == NULL)        return RC(rcAlign, rcTable, rcAccessing, rcParam, rcNull);        rc = BAMAlignmentGetReadName(self->innerSelf, &readName);    if (rc)        return rc;    id_act_size = string_size( readName ) + 1;    if (id_size != NULL)        *id_size = id_act_size;    if (id_buffer != NULL) {        if (buffer_size >= id_act_size)            memcpy(id_buffer, readName, id_act_size);        else            rc = RC(rcAlign, rcTable, rcAccessing, rcBuffer, rcInsufficient);    }    return rc;    }

LIB_EXPORT rc_t CC AlignAccessAlignmentEnumeratorGetRefSeqID(                                               const AlignAccessAlignmentEnumerator *self,                                               char *id_buffer, size_t buffer_size, size_t *id_size) {    rc_t rc = 0;    int32_t id;    const BAMRefSeq *cur;    size_t id_act_size;        if (self == NULL)        return 0;    if (id_buffer == NULL && id_size == NULL)        return RC(rcAlign, rcTable, rcAccessing, rcParam, rcNull);    rc = BAMAlignmentGetRefSeqId(self->innerSelf, &id);    if (rc)        return rc;    if (id < 0)        return RC(rcAlign, rcTable, rcAccessing, rcData, rcNotFound);    rc = BAMFileGetRefSeq(self->parent->innerSelf, id, &cur);    if (rc)        return rc;    id_act_size = string_size( cur->name ) + 1;    if (id_size != NULL)        *id_size = id_act_size;    if (id_buffer != NULL) {        if (buffer_size >= id_act_size)            memcpy(id_buffer, cur->name, id_act_size);        else            rc = RC(rcAlign, rcTable, rcAccessing, rcBuffer, rcInsufficient);    }    return rc;}

rc_t ref_walker_set_spot_group( struct ref_walker * self, const char * spot_group ){    if ( self == NULL )        return RC( rcApp, rcNoTarg, rcConstructing, rcParam, rcNull );    self->spot_group = string_dup ( spot_group, string_size( spot_group ) );    return 0;}

bool client_has_data(client_t *client){  if (string_size(client->outbuf) > 0 || client->state == CLIENT_STATE_FEED) {    return true;  }  return false;}

staticbool _StringHas(const String *self, const char *buf, String *res){    String dummy;    size_t len = 0;    assert(self && buf);    if (res == NULL) {        res = &dummy;    }    len = string_size(buf);    assert(len);    StringInit(res, self->addr, self->size, self->len);    while (true) {        if (res->len < len) {            StringInit(res, NULL, 0, 0);            return false;        }        if (_StringStartsWith(res, buf)) {            res->len = (uint32_t)len;            res->size = len;            return true;        }        res->size = res->len - 1;        res->len = res->len - 1;        ++res->addr;    }}

/** * Get one line from specific stream with delimiter. */bool_t string_getline_delimiter(string_t* pstr_string, FILE* fp_stream, char c_delimiter){    int n_char = EOF;    assert(pstr_string != NULL);    assert(fp_stream != NULL);    if(c_delimiter == '/n')    {        return string_getline(pstr_string, fp_stream);    }    else    {        clearerr(fp_stream);        string_clear(pstr_string);        while(!feof(fp_stream) && !ferror(fp_stream) && (char)n_char != c_delimiter &&              string_size(pstr_string) < string_max_size(pstr_string))        {            n_char = fgetc(fp_stream);            if((char)n_char != c_delimiter && n_char != EOF)            {                string_push_back(pstr_string, (char)n_char);            }        }        if((char)n_char == c_delimiter)        {            return true;        }        else        {            return false;        }    }}

static void test_empty_string(string_t *str){	TEST_EXPECT(string_size(str) == 0);	TEST_EXPECT(string_data(str) != 0);	TEST_EXPECT(string_c_str(str) != 0);	TEST_EXPECT(*string_c_str(str) == '/0');}

int evp_sign_internal(EVP_PKEY* evp, EVP_MD_CTX* ctx, enum EVP_DIGEST_TYPE type, const unsigned char* digest, unsigned int digest_length, string* s){  const EVP_MD* md = NULL;  md = get_EVP_MD(type);  if (md == NULL) {    return 0;  }  EVP_MD_CTX_init(ctx);  if (!EVP_SignInit(ctx, md)) {    return 0;  }  if (!EVP_SignUpdate(ctx, digest, digest_length)) {    return 0;  }  if (!EVP_SignFinal(ctx, string_base(s), &string_size(s), evp)) {    return 0;  }  return 1;}