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

void test_reverse() {  const char * val1 = "value1";  const char * val2 = "value2";  const char * val3 = "value3";  const char * val4 = "value4";    vector_type * vector1 = vector_alloc_new(  );  vector_type * vector2 = vector_alloc_new(  );  vector_append_ref( vector1 , val1 );  vector_append_ref( vector1 , val2 );  vector_append_ref( vector1 , val3 );  vector_append_ref( vector1 , val4 );  vector_append_ref( vector2 , val1 );  vector_append_ref( vector2 , val2 );  vector_append_ref( vector2 , val3 );  vector_append_ref( vector2 , val4 );  vector_inplace_reverse( vector1 );  {    int i;    int size = vector_get_size( vector1 );    for (i=0; i < vector_get_size( vector1 ); i++)      test_assert_ptr_equal( vector_iget_const( vector2 , i ) , vector_iget_const( vector1 , size - 1 - i ));  }  vector_free( vector1 );  vector_free( vector2 );}

static int well_ts_get_index__( const well_ts_type * well_ts , int report_step , time_t sim_time , bool use_report) {  const int size = vector_get_size( well_ts->ts );  if (size == 0)    return 0;  else {    const well_node_type * first_node = vector_iget_const( well_ts->ts , 0 );     const well_node_type * last_node  = vector_get_last_const( well_ts->ts );         if (use_report) {      if (report_step < first_node->report_nr)        return -1;         // Before the start            if (report_step >= last_node->report_nr)        return size - 1;   // After end    } else {      if (sim_time < first_node->sim_time)        return -1;         // Before the start            if (sim_time >= last_node->sim_time)        return size - 1;   // After end    }        // Binary search     {      int lower_index  = 0;      int upper_index  = size - 1;            while (true) {        int center_index = (lower_index + upper_index) / 2;        const well_node_type * center_node = vector_iget_const( well_ts->ts , center_index );              double cmp;        if (use_report)          cmp = center_node->report_nr - report_step;        else          cmp = difftime( center_node->sim_time , sim_time );                if (cmp > 0) {          if ((center_index - lower_index) == 1)    // We found an interval of length 1            return lower_index;          else             upper_index = center_index;                  } else {                    if ((upper_index - center_index) == 1)    // We found an interval of length 1            return center_index;          else             lower_index = center_index;        }      }    }  }}

void menu_run(const menu_type * menu) {    while (1) {        int cmd;        menu_display(menu);        cmd = menu_read_cmd(menu);        if (strchr(menu->quit_keys , cmd) != NULL) /* We have recieved a quit command - leave the building. */            break;        /*          OK - we start looking through all the available commands to see          which this is. */        {            int item_index = 0;            while (1) {                const menu_item_type * item = vector_iget_const(menu->items , item_index);                if (!item->separator) {                    if(!item->helptext) {                        if (strchr(item->key_set , cmd) != NULL) {                            /* Calling the function ... */                            menu_item_call( item );                            break;                        }                    }                }                item_index++;            }        }    }}

int main(int argc , char ** argv) {  util_install_signals();  {    ecl_grid_type * grid = ecl_grid_alloc( argv[1] );    vector_type * expected = load_expected( grid, argv[2] );    for (int c=0; c < vector_get_size( expected ); c++) {      const point_type * p = vector_iget_const( expected , c );      int g = ecl_grid_get_global_index_from_xyz(grid , p->x, p->y , p->z , 0 );      if (g != ecl_grid_get_global_index3(grid, p->i,p->j, p->k)) {        int i,j,k;        ecl_grid_get_ijk1(grid, g, &i, &j, &k);        fprintf(stderr,"point:%d   (%g,%g,%g), Simulated: %d:(%d,%d,%d)   Expected: %d:(%d,%d,%d)  contains:%d/n",                c , p->x, p->y, p->z, g, i,j,k, p->g, p->i, p->j, p->k, ecl_grid_cell_contains_xyz1( grid, p->g , p->x , p->y, p->z));      }      if (!p->skip)        test_assert_int_equal( g , ecl_grid_get_global_index3(grid, p->i,p->j, p->k));      else {        if ( g != ecl_grid_get_global_index3(grid, p->i,p->j, p->k))          fprintf(stderr," ** Skipping failed test for point:%d /n",c);      }    }    ecl_grid_free( grid );    vector_free( expected );  }  exit(0);}

int ecl_sum_data_get_report_step_from_days(const ecl_sum_data_type * data , double sim_days) {  if ((sim_days < data->days_start) || (sim_days > data->sim_length))    return -1;  else {    int report_step = -1;    double_vector_type * days_map = double_vector_alloc( 0 , 0 );    int_vector_type    * report_map = int_vector_alloc( 0 , 0 );    int i;    for (i=1; i < int_vector_size( data->report_last_index ); i++) {      int ministep_index = int_vector_iget( data->report_last_index , i );      const ecl_sum_tstep_type * ministep = vector_iget_const( data->data , ministep_index );            double_vector_iset( days_map , i , ecl_sum_tstep_get_sim_days( ministep ));      int_vector_iset( report_map , i , ecl_sum_tstep_get_report( ministep ));    }        {      /** Hmmmm - double == comparison ... */      int index = double_vector_index_sorted( days_map , sim_days );            if (index >= 0)        report_step = int_vector_iget( report_map , index );    }        int_vector_free( report_map );    double_vector_free( days_map );    return report_step;  }}

double ecl_rft_node_iget_grat( const ecl_rft_node_type * rft_node , int index) {  assert_type_and_index( rft_node , PLT , index );  {    const ecl_rft_cell_type * cell = vector_iget_const( rft_node->cells , index);    return ecl_rft_cell_get_grat( cell );  }}

void subst_list_fprintf(const subst_list_type * subst_list , FILE * stream) {  int index;  for (index=0; index < vector_get_size( subst_list->string_data ); index++) {    const subst_list_string_type * node = vector_iget_const( subst_list->string_data , index );    fprintf(stream , "%s = %s/n" , node->key , node->value);  }}

int ecl_sum_data_get_report_step_from_time(const ecl_sum_data_type * data , time_t sim_time) {  if ((sim_time < data->data_start_time) || (sim_time > data->sim_end))    return -1;  {    int report_step = -1;    time_t_vector_type * time_map = time_t_vector_alloc( 0 , 0 );    int_vector_type    * report_map = int_vector_alloc( 0 , 0 );    int i;    for (i=1; i < int_vector_size( data->report_last_index ); i++) {      int ministep_index = int_vector_iget( data->report_last_index , i );      const ecl_sum_tstep_type * ministep = vector_iget_const( data->data , ministep_index );            time_t_vector_iset( time_map , i , ecl_sum_tstep_get_sim_time( ministep ));      int_vector_iset( report_map , i , ecl_sum_tstep_get_report( ministep ));          }        {      int index = time_t_vector_index_sorted( time_map , sim_time );            if (index >= 0)        report_step = int_vector_iget( report_map , index );    }        int_vector_free( report_map );    time_t_vector_free( time_map );    return report_step;  }}

void ensemble_init( ensemble_type * ensemble , config_type * config) {  /*1 : Loading ensembles and settings from the config instance */  /*1a: Loading the eclipse summary cases. */  {    thread_pool_type * tp = thread_pool_alloc( LOAD_THREADS , true );    {      int i,j;      for (i=0; i < config_get_occurences( config , "CASE_LIST"); i++) {        const stringlist_type * case_list = config_iget_stringlist_ref( config , "CASE_LIST" , i );        for (j=0; j < stringlist_get_size( case_list ); j++)           ensemble_load_from_glob( ensemble , stringlist_iget( case_list , j ) , tp);      }    }    thread_pool_join( tp );    thread_pool_free( tp );  }    {    const sum_case_type * tmp = vector_iget_const( ensemble->data , 0 );    ensemble->refcase = tmp->ecl_sum;  }    /*1b: Other config settings */  if (config_item_set( config , "NUM_INTERP" ))    ensemble->num_interp  = config_iget_as_int( config , "NUM_INTERP" , 0 , 0 );      /*2: Remaining initialization */  ensemble_init_time_interp( ensemble );  if (vector_get_size( ensemble->data ) < MIN_SIZE )    util_exit("Sorry - quantiles make no sense with with < %d realizations; should have ~> 100./n" , MIN_SIZE);}

static void sched_block_fprintf(const sched_block_type * block, FILE * stream){  int i;  for (i=0; i < vector_get_size(block->kw_list); i++) {    const sched_kw_type * sched_kw = vector_iget_const( block->kw_list , i);    sched_kw_fprintf(sched_kw, stream);  }}

void obs_vector_install_node(obs_vector_type * obs_vector , int index , void * node) {  obs_vector_assert_node_type( obs_vector , node );  {    if (vector_iget_const( obs_vector->nodes , index ) == NULL)      obs_vector->num_active++;        vector_iset_owned_ref( obs_vector->nodes , index , node , obs_vector->freef );  }}

static bool file_map_has_kw_ptr( const file_map_type * file_map, const ecl_kw_type * ecl_kw) {  int index;  for (index = 0; index < vector_get_size( file_map->kw_list ); index++) {    const ecl_file_kw_type * file_kw = vector_iget_const( file_map->kw_list , index );    if (ecl_file_kw_ptr_eq( file_kw , ecl_kw ))      return true;  }   return false;} 

const char * subst_list_iget_doc_string( const subst_list_type * subst_list , int index) {  if (index < vector_get_size(subst_list->string_data)) {    const subst_list_string_type * node = vector_iget_const( subst_list->string_data , index );    return node->doc_string;  } else {    util_abort("%s: index:%d to large /n",__func__ , index);    return NULL;  }}

bool local_updatestep_has_data_key( const local_updatestep_type * update_step , const char * key) {    bool has_key = false;    for (int i = 0; i < vector_get_size( update_step->ministep ); i++) {        const local_ministep_type * ministep = vector_iget_const( update_step->ministep , i );        if (local_ministep_has_data_key(ministep, key))            has_key = true;    }    return has_key;}

const ecl_rft_cell_type * ecl_rft_node_iget_cell_sorted( ecl_rft_node_type * rft_node , int index) {  if (ecl_rft_node_is_RFT( rft_node ))    return ecl_rft_node_iget_cell( rft_node , index );  else {    if (!rft_node->sort_perm_in_sync)      ecl_rft_node_create_sort_perm( rft_node );    return vector_iget_const( rft_node->cells , int_vector_iget( rft_node->sort_perm , index ));  }}

static void file_map_fprintf_kw_list(const file_map_type * file_map , FILE * stream) {  int i;  for (i=0; i < vector_get_size( file_map->kw_list ); i++) {    const ecl_file_kw_type * file_kw = vector_iget_const( file_map->kw_list , i );    fprintf(stream , "%-8s %7d:%s/n",            ecl_file_kw_get_header( file_kw ) ,             ecl_file_kw_get_size( file_kw ) ,             ecl_util_get_type_name( ecl_file_kw_get_type( file_kw )));  }}

time_t_vector_type * sched_file_alloc_time_t_vector( const sched_file_type * sched_file ) {  time_t_vector_type * vector = time_t_vector_alloc(0,0);  int i;  time_t_vector_append( vector , sched_file->start_time );  for (i=1; i < vector_get_size( sched_file->blocks ); i++) {    const sched_block_type * block = vector_iget_const( sched_file->blocks , i );    time_t_vector_append( vector , block->block_end_time );  }  return vector;}

stringlist_type * gen_kw_config_alloc_name_list( const gen_kw_config_type * config ) {    stringlist_type * name_list = stringlist_alloc_new();  int i;  for (i=0; i < vector_get_size( config->parameters ); i++) {    const gen_kw_parameter_type * parameter = vector_iget_const( config->parameters , i );    stringlist_append_ref( name_list , parameter->name );    /* If the underlying parameter goes out scope - whom bang .. */  }  return name_list;}

void sched_kw_compdat_fprintf(const sched_kw_compdat_type *kw , FILE *stream) {  fprintf(stream , "COMPDAT/n");  {    int index;    for (index = 0; index < vector_get_size( kw->completions ); index++) {      const comp_type * comp = vector_iget_const( kw->completions , index );      comp_sched_fprintf(comp , stream);    }  }  fprintf(stream , "//n/n");}

nnc_info_type * nnc_info_alloc_copy( const nnc_info_type * src_info ) {  nnc_info_type * copy_info = nnc_info_alloc( src_info->lgr_nr );  int ivec;    for (ivec = 0; ivec < vector_get_size( src_info->lgr_list ); ivec++) {    nnc_vector_type * copy_vector = nnc_vector_alloc_copy( vector_iget_const( src_info->lgr_list , ivec));    nnc_info_add_vector( copy_info , copy_vector );  }  return copy_info;}

bool sched_file_well_open( const sched_file_type * sched_file ,                            int restart_nr ,                            const char * well_name) {  bool well_found = false;  bool well_open  = false;  int block_nr    = restart_nr;  while (!well_found && (block_nr >= 0)) {    sched_block_type * block = sched_file_iget_block( sched_file , block_nr );        if (hash_has_key( block->kw_hash , "WCONHIST")) {      const vector_type * wconhist_vector = hash_get( block->kw_hash , "WCONHIST");      int i;      for (i=0; i < vector_get_size( wconhist_vector ); i++) {        const sched_kw_type * kw = vector_iget_const( wconhist_vector , i );        if (sched_kw_has_well( kw , well_name )) {          well_found = true;          well_open = sched_kw_well_open( kw , well_name );        }      }    }        if (hash_has_key( block->kw_hash , "WCONINJE")) {      const vector_type * wconinje_vector = hash_get( block->kw_hash , "WCONINJE");      int i;      for (i=0; i < vector_get_size( wconinje_vector ); i++) {        const sched_kw_type * kw = vector_iget_const( wconinje_vector , i );        if (sched_kw_has_well( kw , well_name )) {          well_found = true;          well_open  = sched_kw_well_open( kw , well_name );        }      }    }        block_nr--;  }   return well_open;}

void obs_vector_install_node(obs_vector_type * obs_vector , int index , void * node) {  obs_vector_assert_node_type( obs_vector , node );  {    if (vector_iget_const( obs_vector->nodes , index ) == NULL) {      obs_vector->num_active++;      int_vector_append( obs_vector->step_list , index );      int_vector_sort( obs_vector->step_list );    }    vector_iset_owned_ref( obs_vector->nodes , index , node , obs_vector->freef );  }}

int obs_vector_get_last_active_step(const obs_vector_type * obs_vector) {  int step = vector_get_size( obs_vector->nodes ) - 1;  while (true) {    const void * obs_node = vector_iget_const( obs_vector->nodes , step );    if (obs_node)      break;        step--;    if (step < 0)      break;  }  return step;}

void rms_tag_fprintf(const rms_tag_type * tag , FILE * stream) {    fprintf(stream , "  <%s>/n",tag->name);    {        int i;        for (i=0; i < vector_get_size( tag->key_list ); i++) {            const rms_tagkey_type * tagkey = vector_iget_const( tag->key_list , i );            rms_tagkey_fprintf( tagkey , stream);        }    }    fprintf(stream , "  </%s>/n",tag->name);}

/**   Updates the buffer inplace with all the string substitutions in the   subst_list. This is the lowest level function, which does *NOT*   consider the parent pointer.*/static void subst_list_replace_strings__(const subst_list_type * subst_list , buffer_type * buffer) {  int index;  for (index = 0; index < vector_get_size( subst_list->string_data ); index++) {    const subst_list_string_type * node = vector_iget_const( subst_list->string_data , index );    if (node->value != NULL) {      bool    match;      buffer_rewind( buffer );      do {        match = buffer_search_replace( buffer , node->key , node->value);      } while (match);    }  }}

void rms_tag_fwrite(const rms_tag_type * tag , FILE * stream) {    rms_util_fwrite_string("tag"     , stream);    rms_util_fwrite_string(tag->name , stream);    {        int i;        for (i=0; i < vector_get_size( tag->key_list ); i++) {            const rms_tagkey_type * tagkey = vector_iget_const( tag->key_list , i );            rms_tagkey_fwrite( tagkey , stream);        }    }    rms_util_fwrite_string("endtag" , stream);}

subst_list_type * subst_list_alloc_deep_copy(const subst_list_type * src) {  subst_list_type * copy;  if (src->parent != NULL)    copy = subst_list_alloc( src->parent );  else    copy = subst_list_alloc( src->func_pool);    {    int index;    for (index = 0; index < vector_get_size( src->string_data ); index++) {      const subst_list_string_type * node = vector_iget_const( src->string_data , index );      subst_list_insert__( copy , node->key , node->value , node->doc_string , true , SUBST_DEEP_COPY);    }    for (index = 0; index < vector_get_size( src->func_data ); index++) {      const subst_list_func_type * src_node  = vector_iget_const( src->func_data , index );      subst_list_func_type       * copy_node = subst_list_func_alloc( src_node->name , src_node->func );      vector_append_owned_ref( copy->func_data , copy_node , subst_list_func_free__ );    }      }  return copy;}

static void menu_display(const menu_type * menu) {    int i;    int length = strlen(menu->title);    for (i = 0; i < vector_get_size(menu->items); i++) {        const menu_item_type * item = vector_iget_const( menu->items , i);        if(!item->helptext)            length = util_int_max(length , item->label_length);        if(item->helptext)            length = util_int_max(length , 60); /* Hardcoded length for helptext*/    }    printf("/n");    __print_line(length + 10 , 0);    printf("| ");    util_fprintf_string(menu->title , length + 6 , center_pad , stdout);    printf(" |/n");    __print_line(length + 10 , 1);    for (i=0; i < vector_get_size(menu->items); i++) {        const menu_item_type * item = vector_iget_const( menu->items , i);        if (item->separator)            __print_sep(length + 6);        else if (item->helptext)            __print_helptext(item->label,length);        else {            printf("| %c: ", menu_item_get_key( item ));            util_fprintf_string(item->label , length + 3 , right_pad , stdout);            printf(" |/n");        }    }    __print_sep(length + 6);    printf("| %c: ",menu->quit_keys[0]);    util_fprintf_string(menu->quit_label , length + 3 , right_pad , stdout);    printf(" |/n");    __print_line(length + 10 , 2);    printf("/n");}

static void subst_list_eval_funcs____(const subst_list_type * subst_list , const parser_type * parser , buffer_type * buffer) {  {    int index;    for (index = 0; index < vector_get_size( subst_list->func_data); index++) {      const subst_list_func_type * subst_func = vector_iget_const( subst_list->func_data , index );      const char                 * func_name  = subst_func->name;            bool match;      buffer_rewind( buffer );      do {        size_t match_pos;        match     = buffer_strstr( buffer , func_name );        match_pos = buffer_get_offset( buffer );                if (match) {          bool   update     = false;          char * arg_start  = buffer_get_data( buffer );          arg_start        += buffer_get_offset( buffer ) + strlen( func_name );                    if (arg_start[0] == '(') {  /* We require that an opening paren follows immediately behind the function name. */            char * arg_end = strchr( arg_start , ')');            if (arg_end != NULL) {              /* OK - we found an enclosing () pair. */              char            * arg_content = util_alloc_substring_copy( arg_start, 1 , arg_end - arg_start - 1);              stringlist_type * arg_list    = parser_tokenize_buffer( parser , arg_content , true);              char            * func_eval   = subst_list_func_eval( subst_func , arg_list );              int               old_len     = strlen(func_name) + strlen( arg_content) + 2;                                   if (func_eval != NULL) {                buffer_memshift( buffer , match_pos + old_len , strlen( func_eval ) - old_len);                buffer_fwrite( buffer , func_eval , strlen( func_eval ) , sizeof * func_eval );                free( func_eval );                update = true;              }                            free( arg_content );              stringlist_free( arg_list );            }           }                     if (!update)             buffer_fseek( buffer , match_pos + strlen( func_name ) , SEEK_SET);        }      } while (match);    }  }  if (subst_list->parent != NULL)     subst_list_eval_funcs____( subst_list->parent , parser , buffer );}

bool workflow_run(workflow_type * workflow, void * self , bool verbose , const subst_list_type * context) {  vector_clear( workflow->stack );  workflow_try_compile( workflow , context);  if (workflow->compiled) {    int icmd;    for (icmd = 0; icmd < vector_get_size( workflow->cmd_list ); icmd++) {      const cmd_type * cmd = vector_iget_const( workflow->cmd_list , icmd );      void * return_value = workflow_job_run( cmd->workflow_job, self , verbose , cmd->arglist );      vector_push_front_ref( workflow->stack , return_value );    }    return true;  } else    return false;}