C++ (Cpp) config_add_schema_itemの例

コード例 #1

ファイル: config_content_item.c プロジェクト: YingfangZhou/ert

int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_parser_type * config = config_alloc();

  config_add_schema_item( config , "SET" , true );
  config_add_schema_item( config , "NOTSET" , false );

  {
    config_content_type * content = config_parse( config , config_file , "--" , "INCLUDE" , NULL , CONFIG_UNRECOGNIZED_IGNORE , true );
    test_assert_true( config_content_is_instance( content ));
    test_assert_true(config_content_is_valid( content ));

    test_assert_true( config_content_has_item( content , "SET" ));
    test_assert_false( config_content_has_item( content , "NOTSET" ) );
    test_assert_false( config_content_has_item( content , "UNKNOWN" ) );

    test_assert_true( config_has_schema_item( config , "SET" ));
    test_assert_true( config_has_schema_item( config , "NOTSET" ));
    test_assert_false( config_has_schema_item( config , "UNKNOWN" ));

    config_content_free( content );
  }

  exit(0);
}

コード例 #2

ファイル: config_node_test.c プロジェクト: Ensembles/ert

int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_parser_type * config = config_alloc();
  {
    config_schema_item_type * item  = config_add_schema_item(config , "APPEND" , false );
    config_schema_item_set_argc_minmax( item , 1 , 1);
  }
  config_add_schema_item(config , "NEXT"   , false );

  config_content_type * content = config_parse(config , config_file , "--" , NULL , NULL , NULL , false , true );

  if (config_content_is_valid( content )) {
    if (config_content_get_size( content ) == 4) {
      const config_content_node_type * node0 = config_content_iget_node( content , 0 );
      if (strcmp( config_content_node_get_kw( node0 ) , "APPEND") == 0) {
        if (config_content_node_get_size(node0) == 1) {
          const config_content_node_type * node3 = config_content_iget_node( content , 3 );
          if (strcmp( config_content_node_get_kw( node3 ) , "NEXT") == 0) {
            if (config_content_node_get_size(node3) == 2) {
              config_content_free( content );
              exit(0);
            } else printf("Size error node3\n");
          } else printf("kw error node3 \n");
        } else printf("Size error node0\n");
      } else printf("kw error node0 kw:%s \n", config_content_node_get_kw( node0 ));
    } else printf("Size error \n");
  } else printf("Parse error");

  config_content_free( content );
  exit(1);
}

コード例 #3

ファイル: config_typeOK.c プロジェクト: JacobStoren/ert

int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_type * config = config_alloc();
  bool OK;
  {
    config_schema_item_type * item  = config_add_schema_item(config , "TYPE_KEY" , false );
    config_schema_item_set_argc_minmax( item , 4 , 4 );
    config_schema_item_iset_type( item , 0 , CONFIG_INT );
    config_schema_item_iset_type( item , 1 , CONFIG_FLOAT );
    config_schema_item_iset_type( item , 2 , CONFIG_BOOL );

    item = config_add_schema_item( config , "SHORT_KEY" , false );
    config_schema_item_set_argc_minmax( item , 1 , 1 );
    
    item = config_add_schema_item( config , "LONG_KEY" , false );
    config_schema_item_set_argc_minmax( item , 3 , CONFIG_DEFAULT_ARG_MAX );
  }
  OK = config_parse(config , config_file , "--" , NULL , NULL , false , true );
  
  if (OK) {
    
  } else error("Parse error\n");
  
  exit(0);
}

コード例 #4

ファイル: enkf_analysis_config.c プロジェクト: danielfmva/ert

void test_min_realizations_percent(const char * num_realizations_str, const char * min_realizations_str, int min_realizations){
  test_work_area_type * work_area = test_work_area_alloc("test_min_realizations");

  {
    FILE * config_file_stream = util_mkdir_fopen("config_file", "w");
    test_assert_not_NULL(config_file_stream);
    fprintf(config_file_stream, num_realizations_str);
    fprintf(config_file_stream, min_realizations_str);
    fclose(config_file_stream);

    config_type * c = config_alloc();
    config_schema_item_type * item = config_add_schema_item(c , NUM_REALIZATIONS_KEY , true );
    config_schema_item_set_default_type(item, CONFIG_INT);
    config_schema_item_set_argc_minmax( item , 1 , 1);
    item = config_add_schema_item(c , MIN_REALIZATIONS_KEY , false );
    config_schema_item_set_argc_minmax( item , 1 , 2);
    test_assert_true(config_parse(c , "config_file" , "--" , NULL , NULL , false , true ));

    analysis_config_type * ac = create_analysis_config( );
    analysis_config_init(ac, c);

    test_assert_int_equal( min_realizations , analysis_config_get_min_realisations( ac ) );

    analysis_config_free( ac );
    config_free( c );
  }

  test_work_area_free(work_area);
}

コード例 #5

ファイル: config_test.c プロジェクト: JacobStoren/ert

int main(void) {
  const char * config_file = "config_test_input";
  config_type * config = config_alloc();
  config_schema_item_type * item;
  
  item = config_add_schema_item(config , "KEY1" , true  , true);
  item = config_add_schema_item(config , "KEY2" , true  , false);
  config_schema_item_set_argc_minmax(item , 1 , 4 , 4 , (const config_item_types [4]) {CONFIG_EXECUTABLE , CONFIG_EXISTING_FILE , CONFIG_BOOLEAN , CONFIG_BOOLEAN});

コード例 #6

ファイル: rng_config.c プロジェクト: akva2/ResInsight

void rng_config_add_config_items( config_type * config ) {
  config_schema_item_type * item;

  item= config_add_schema_item( config , STORE_SEED_KEY , false , false );
  config_schema_item_set_argc_minmax(item , 1 , 1 , 1 , NULL );
  
  item = config_add_schema_item( config , LOAD_SEED_KEY , false , false );
  config_schema_item_set_argc_minmax(item , 1 , 1 , 1 , (const config_item_types [1]) { CONFIG_EXISTING_FILE});

コード例 #7

ファイル: site_config.c プロジェクト: Ensembles/ert

void site_config_add_queue_config_items(config_parser_type * config, bool site_mode) {
  config_schema_item_type * item = config_add_schema_item(config, QUEUE_SYSTEM_KEY, site_mode);
  config_schema_item_set_argc_minmax(item, 1, 1);

  item = config_add_schema_item(config, MAX_SUBMIT_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_INT);
}

コード例 #8

ファイル: config_define.c プロジェクト: danielfmva/ert

config_type * config_create_schema() {
  config_type * config = config_alloc();
  
  config_add_schema_item( config , "SET" , true );
  config_add_schema_item( config , "NOTSET" , false );

  return config;
}

コード例 #9

ファイル: qc_module.c プロジェクト: joelmheim/ResInsight

void qc_module_add_config_items( config_type * config ) {
  config_schema_item_type * item;
  
  item = config_add_schema_item( config , QC_PATH_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );

  item = config_add_schema_item( config , QC_WORKFLOW_KEY , false );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );
}

コード例 #10

ファイル: rng_config.c プロジェクト: danielfmva/ert

void rng_config_add_config_items( config_type * config ) {
    config_schema_item_type * item;

    item= config_add_schema_item( config , STORE_SEED_KEY , false);
    config_schema_item_set_argc_minmax(item , 1 , 1 );
    config_schema_item_iset_type( item , 0 , CONFIG_PATH );

    item = config_add_schema_item( config , LOAD_SEED_KEY , false );
    config_schema_item_set_argc_minmax(item , 1 , 1 );
    config_schema_item_iset_type( item , 0 , CONFIG_PATH );
}

コード例 #11

ファイル: upgrade_fs104.c プロジェクト: bramirex/ert

config_type * create_config( ) {
    config_type * config = config_alloc( );
    config_schema_item_type * item;

    item = config_add_schema_item(config , ENSPATH_KEY , true , false);
    config_schema_item_set_argc_minmax(item , 1 , 1 , 0 , NULL);

    item = config_add_schema_item(config , NUM_REALIZATIONS_KEY , true , false);
    config_schema_item_set_argc_minmax(item , 1 , 1 , 1, (const config_item_types [1]) {
        CONFIG_INT
    });

コード例 #12

ファイル: ecl_quantile.c プロジェクト: YingfangZhou/ert

void config_init( config_parser_type * config ) {


  config_add_schema_item( config , "CASE_LIST"      , true );
  config_add_key_value( config , "NUM_INTERP" , false , CONFIG_INT);

  {
    config_schema_item_type * item;
    item = config_add_schema_item( config , "OUTPUT" , true );
    config_schema_item_set_argc_minmax( item , 2 , CONFIG_DEFAULT_ARG_MAX );
    config_schema_item_set_indexed_selection_set( item , 1 , 3 , (const char *[3]) { S3GRAPH_STRING , HEADER_STRING , PLAIN_STRING });
  }

コード例 #13

ファイル: ert_workflow_list.c プロジェクト: YingfangZhou/ert

void ert_workflow_list_add_config_items( config_parser_type * config ) {
  config_schema_item_type * item = config_add_schema_item( config , WORKFLOW_JOB_DIRECTORY_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_PATH );

  item = config_add_schema_item( config , LOAD_WORKFLOW_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 2 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );

  item = config_add_schema_item( config , LOAD_WORKFLOW_JOB_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 2 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );
}

コード例 #14

ファイル: ensemble_config.c プロジェクト: chflo/ert

void ensemble_config_add_config_items(config_parser_type * config) {
  config_schema_item_type * item;

  /**
      the two fault types are just added to the config object only to
      be able to print suitable messages before exiting.
  */

  item = config_add_schema_item(config , "HAVANA_FAULT" , false  );
  config_schema_item_set_argc_minmax(item , 2 , 2);

  item = config_add_schema_item(config , "MULTFLT" , false  );
  config_schema_item_set_argc_minmax(item , 3 , 3 );
  config_schema_item_iset_type( item , 2 , CONFIG_EXISTING_PATH );


  /*****************************************************************/


  item = config_add_schema_item(config , GEN_KW_KEY , false  );
  config_schema_item_set_argc_minmax(item , 4 , 6);
  config_schema_item_iset_type( item , 1 , CONFIG_EXISTING_PATH );
  config_schema_item_iset_type( item , 3 , CONFIG_EXISTING_PATH );



  item = config_add_key_value( config , GEN_KW_TAG_FORMAT_KEY , false , CONFIG_STRING);
  item = config_add_schema_item(config , SCHEDULE_PREDICTION_FILE_KEY , false  );
  /* scedhule_prediction_file   filename  <parameters:> <init_files:> */
  config_schema_item_set_argc_minmax(item , 1 , 3 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );



  enkf_config_node_add_GEN_PARAM_config_schema( config );
  enkf_config_node_add_GEN_DATA_config_schema( config );
  enkf_config_node_add_CUSTOM_KW_config_schema( config );

  item = config_add_schema_item(config , SUMMARY_KEY , false  );   /* can have several summary keys on each line. */
  config_schema_item_set_argc_minmax(item , 1 , CONFIG_DEFAULT_ARG_MAX);

  item = config_add_schema_item(config , CONTAINER_KEY , false  );   /* can have several summary keys on each line. */
  config_schema_item_set_argc_minmax(item , 2 , CONFIG_DEFAULT_ARG_MAX);
  
  item = config_add_schema_item( config , SURFACE_KEY , false  );
  config_schema_item_set_argc_minmax(item , 4 , 5 );
  
  /*
     the way config info is entered for fields is unfortunate because
     it is difficult/impossible to let the config system handle run
     time validation of the input.
  */

  item = config_add_schema_item(config , FIELD_KEY , false  );
  config_schema_item_set_argc_minmax(item , 2 , CONFIG_DEFAULT_ARG_MAX);
  config_schema_item_add_required_children(item , GRID_KEY);   /* if you are using a field - you must have a grid. */
}

コード例 #15

ファイル: site_config.c プロジェクト: akva2/ResInsight

void site_config_add_config_items( config_type * config , bool site_only) {
  config_schema_item_type * item;

  item = config_add_schema_item(config , QUEUE_SYSTEM_KEY , site_only , false);
  config_schema_item_set_argc_minmax(item , 1 , 1 , 0 , NULL);
  {
    stringlist_type * lsf_dep    = stringlist_alloc_argv_ref( (const char *[2]) {"LSF_QUEUE" , "MAX_RUNNING_LSF"}   , 2);
    stringlist_type * rsh_dep    = stringlist_alloc_argv_ref( (const char *[3]) {"RSH_HOST"  , "RSH_COMMAND" , "MAX_RUNNING_RSH"} , 2);

コード例 #16

ファイル: hook_manager.c プロジェクト: Thif/ert-1

void hook_manager_add_config_items( config_parser_type * config ) {
  config_schema_item_type * item;

  item = config_add_schema_item( config , QC_PATH_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );

  item = config_add_schema_item( config , QC_WORKFLOW_KEY , false );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );

  item = config_add_schema_item( config , HOOK_WORKFLOW_KEY , false );
  config_schema_item_set_argc_minmax(item , 2 , 2 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );
  config_schema_item_iset_type( item , 1 , CONFIG_STRING );

  item = config_add_schema_item( config , RUNPATH_FILE_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );

}

コード例 #17

ファイル: config_typeFail.c プロジェクト: YingfangZhou/ert

int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_parser_type * config = config_alloc();
  {
    config_schema_item_type * item  = config_add_schema_item(config , "TYPES_KEY" , false );
    config_schema_item_set_argc_minmax( item , 4 , 4 );
    config_schema_item_iset_type( item , 0 , CONFIG_INT );
    config_schema_item_iset_type( item , 1 , CONFIG_FLOAT );
    config_schema_item_iset_type( item , 2 , CONFIG_BOOL );

    item = config_add_schema_item( config , "SHORT_KEY" , false );
    config_schema_item_set_argc_minmax( item , 1 , 1 );

    item = config_add_schema_item( config , "LONG_KEY" , false );
    config_schema_item_set_argc_minmax( item , 3 , CONFIG_DEFAULT_ARG_MAX);
  }

  {
    config_content_type * content = config_parse(config , config_file , "--" , NULL , NULL , false , true );

    if (config_content_is_valid( content )) {
      error("Parse error\n");
    } else {
      const config_error_type * cerror = config_content_get_errors( content );
      if (config_error_count( cerror ) > 0) {
        int i;
        for (i=0; i < config_error_count( cerror ); i++) {
          printf("Error %d: %s \n",i , config_error_iget( cerror , i ));
        }
      }
      test_assert_int_equal( 5 , config_error_count( cerror ));
    }
    config_content_free( content );
  }
  printf("OK \n");
  exit(0);
}

コード例 #18

ファイル: workflow_job.c プロジェクト: bramirex/ert

config_parser_type * workflow_job_alloc_config() {
    config_parser_type * config = config_alloc();
    {
        config_schema_item_type * item;

        item = config_add_schema_item( config , MIN_ARG_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1 );
        config_schema_item_iset_type( item , 0 , CONFIG_INT );

        item = config_add_schema_item( config , MAX_ARG_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1 );
        config_schema_item_iset_type( item , 0 , CONFIG_INT );

        item = config_add_schema_item( config , ARG_TYPE_KEY , false );
        config_schema_item_set_argc_minmax( item , 2 , 2 );
        config_schema_item_iset_type( item , 0 , CONFIG_INT );
        config_schema_item_set_indexed_selection_set( item , 1 , 4 , (const char *[4]) {
            WORKFLOW_JOB_STRING_TYPE , WORKFLOW_JOB_INT_TYPE , WORKFLOW_JOB_FLOAT_TYPE, WORKFLOW_JOB_BOOL_TYPE
        });

        /*****************************************************************/
        item = config_add_schema_item( config , EXECUTABLE_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1 );
        config_schema_item_iset_type( item , 0 , CONFIG_PATH );

        /*****************************************************************/
        item = config_add_schema_item( config , SCRIPT_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1 );
        config_schema_item_iset_type( item , 0 , CONFIG_PATH );

        /*---------------------------------------------------------------*/

        item = config_add_schema_item( config , FUNCTION_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1);

        item = config_add_schema_item( config , MODULE_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1);
        /*****************************************************************/

        item = config_add_schema_item( config , INTERNAL_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1);
        config_schema_item_iset_type( item , 0 , CONFIG_BOOL);
    }

コード例 #19

ファイル: config_append_test.c プロジェクト: JacobStoren/ert

int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_type * config = config_alloc();
  config_schema_item_type * item = config_add_schema_item(config , "APPEND" , false );
  config_schema_item_set_argc_minmax( item , 1 , 1);

  test_assert_true(config_parse(config , config_file , "--" , NULL , NULL , false , true ));

  {
    test_assert_int_equal( config_get_occurences( config , "APPEND" ) , 3);
    {
      const char * value = config_get_value( config , "APPEND");
      test_assert_string_equal( value , "VALUE3");
    }
  } 

  test_assert_false( config_parse( config , "DoesNotExist" , "--" , NULL , NULL , false , true));
  exit(0);
}

コード例 #20

ファイル: site_config.c プロジェクト: Ensembles/ert

void site_config_add_config_items(config_parser_type * config, bool site_mode) {
  config_schema_item_type * item;
  ert_workflow_list_add_config_items(config);
  site_config_add_queue_config_items(config, site_mode);


  /*
     You can set environment variables which will be applied to the
     run-time environment. Can unfortunately not use constructions
     like PATH=$PATH:/some/new/path, use the UPDATE_PATH function instead.
   */
  item = config_add_schema_item(config, SETENV_KEY, false);
  config_schema_item_set_argc_minmax(item, 2, 2);
  config_schema_item_set_envvar_expansion(item, false); /* Do not expand $VAR expressions (that is done in util_interp_setenv()). */

  item = config_add_schema_item(config, UMASK_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);

  /**
     UPDATE_PATH   LD_LIBRARY_PATH   /path/to/some/funky/lib

     Will prepend "/path/to/some/funky/lib" at the front of LD_LIBRARY_PATH.
   */
  item = config_add_schema_item(config, UPDATE_PATH_KEY, false);
  config_schema_item_set_argc_minmax(item, 2, 2);
  config_schema_item_set_envvar_expansion(item, false); /* Do not expand $VAR expressions (that is done in util_interp_setenv()). */

  if (!site_mode) {
    item = config_add_schema_item(config, LICENSE_PATH_KEY, false);
    config_schema_item_set_argc_minmax(item, 1, 1);
    config_schema_item_iset_type(item, 0, CONFIG_PATH);
  }


  /*****************************************************************/
  /* Items related to running jobs with lsf/rsh/local ...          */

  /* These must be set IFF QUEUE_SYSTEM == LSF */
  item = config_add_schema_item(config, LSF_QUEUE_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);

  item = config_add_schema_item(config, LSF_RESOURCES_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, CONFIG_DEFAULT_ARG_MAX);

  item = config_add_schema_item(config, MAX_RUNNING_LSF_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_INT);

  item = config_add_schema_item(config, LSF_SERVER_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);

  /* These must be set IFF QUEUE_SYSTEM == RSH */
  if (!site_mode)
    config_add_schema_item(config, RSH_HOST_KEY, false); /* Only added when user parse. */
  item = config_add_schema_item(config, RSH_COMMAND_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_EXECUTABLE);

  item = config_add_schema_item(config, MAX_RUNNING_RSH_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_INT);

  /* These must be set IFF QUEUE_SYSTEM == LOCAL */
  item = config_add_schema_item(config, MAX_RUNNING_LOCAL_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_INT);


  /*****************************************************************/
  item = config_add_schema_item(config, QUEUE_OPTION_KEY, false);
  config_schema_item_set_argc_minmax(item, 3, CONFIG_DEFAULT_ARG_MAX);

  item = config_add_schema_item(config, JOB_SCRIPT_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_EXISTING_PATH);

  item = config_add_schema_item(config, INSTALL_JOB_KEY, false);
  config_schema_item_set_argc_minmax(item, 2, 2);
  config_schema_item_iset_type(item, 1, CONFIG_EXISTING_PATH);

  item = config_add_schema_item(config, INSTALL_JOB_DIRECTORY_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_PATH);

  item = config_add_schema_item( config , ANALYSIS_LOAD_KEY , false  );
  config_schema_item_set_argc_minmax( item , 2 , 2);
}

コード例 #21

ファイル: ecl_config.c プロジェクト: JacobStoren/ert

void ecl_config_add_config_items( config_type * config ) {
  config_schema_item_type * item;

  item = config_add_schema_item(config , SCHEDULE_FILE_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );
  /*
    Observe that SCHEDULE_PREDICTION_FILE - which is implemented as a
    GEN_KW is added in ensemble_config.c
  */

  item = config_add_schema_item( config , IGNORE_SCHEDULE_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_BOOL);

  
  item = config_add_schema_item(config , ECLBASE_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1);


  item = config_add_schema_item(config , DATA_FILE_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );


  item = config_add_schema_item(config , STATIC_KW_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , CONFIG_DEFAULT_ARG_MAX );
  

  item = config_add_schema_item(config , ADD_FIXED_LENGTH_SCHEDULE_KW_KEY , false  );
  config_schema_item_set_argc_minmax(item , 2 , 2 );
  config_schema_item_iset_type( item , 1 , CONFIG_INT );
  

  item = config_add_schema_item(config , REFCASE_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_PATH );

  item = config_add_schema_item(config , REFCASE_LIST_KEY , false );
  config_schema_item_set_default_type( item , CONFIG_PATH );

  item = config_add_key_value(config , PLOT_REFCASE_LIST_KEY , false , CONFIG_STRING);
  {
    char * message = util_alloc_sprintf("Warning: the key:%s is depreceated - use %s instead" , PLOT_REFCASE_LIST_KEY , REFCASE_LIST_KEY);
    config_install_message( config , PLOT_REFCASE_LIST_KEY , message );
    free( message );
  }
  
  item = config_add_schema_item(config , GRID_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_EXISTING_PATH );

  
  item = config_add_schema_item(config , INIT_SECTION_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
  config_schema_item_iset_type( item , 0 , CONFIG_PATH );
  config_add_alias(config , INIT_SECTION_KEY , "EQUIL_INIT_FILE");
  

  item = config_add_schema_item(config , END_DATE_KEY , false  );
  config_schema_item_set_argc_minmax(item , 1 , 1 );
}

コード例 #22

ファイル: upgrade_fs104.c プロジェクト: bramirex/ert

#define BLOCK_FS_DRIVER_INDEX_ID 3002


config_type * create_config( ) {
    config_type * config = config_alloc( );
    config_schema_item_type * item;

    item = config_add_schema_item(config , ENSPATH_KEY , true , false);
    config_schema_item_set_argc_minmax(item , 1 , 1 , 0 , NULL);

    item = config_add_schema_item(config , NUM_REALIZATIONS_KEY , true , false);
    config_schema_item_set_argc_minmax(item , 1 , 1 , 1, (const config_item_types [1]) {
        CONFIG_INT
    });

    item = config_add_schema_item(config , REFCASE_KEY , true , false);
    config_schema_item_set_argc_minmax(item , 1 , 1 , 1 , NULL );

    return config;
}


void fskip_block_fs( FILE * stream ) {
    util_fread_int( stream );
    util_fread_int( stream );
}


void fskip_block_fs_index( FILE * stream ) {
    return;
}

コード例 #23

ファイル: ecl_config.c プロジェクト: Ensembles/ert

void ecl_config_add_config_items(config_parser_type * config)
{
  config_schema_item_type * item;

  item = config_add_schema_item(config, SCHEDULE_FILE_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 2);
  config_schema_item_iset_type(item, 0, CONFIG_EXISTING_PATH);
  /*
   Observe that SCHEDULE_PREDICTION_FILE - which is implemented as a
   GEN_KW is added in ensemble_config.c
   */

  item = config_add_schema_item(config, IGNORE_SCHEDULE_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_BOOL);

  item = config_add_schema_item(config, ECLBASE_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);

  item = config_add_schema_item(config, DATA_FILE_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_EXISTING_PATH);

  item = config_add_schema_item(config, STATIC_KW_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, CONFIG_DEFAULT_ARG_MAX);

  item = config_add_schema_item(config, ADD_FIXED_LENGTH_SCHEDULE_KW_KEY, false);
  config_schema_item_set_argc_minmax(item, 2, 2);
  config_schema_item_iset_type(item, 1, CONFIG_INT);

  item = config_add_schema_item(config, REFCASE_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_PATH);

  item = config_add_schema_item(config, REFCASE_LIST_KEY, false);
  config_schema_item_set_default_type(item, CONFIG_PATH);

  item = config_add_schema_item(config, GRID_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_EXISTING_PATH);

  item = config_add_schema_item(config, INIT_SECTION_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
  config_schema_item_iset_type(item, 0, CONFIG_PATH);
  config_add_alias(config, INIT_SECTION_KEY, "EQUIL_INIT_FILE");

  item = config_add_schema_item(config, END_DATE_KEY, false);
  config_schema_item_set_argc_minmax(item, 1, 1);
}

コード例 #24

ファイル: config_test.c プロジェクト: JacobStoren/ert

#include <stringlist.h>
#include <hash.h>
#include <config.h>


int main(void) {
  const char * config_file = "config_test_input";
  config_type * config = config_alloc();
  config_schema_item_type * item;
  
  item = config_add_schema_item(config , "KEY1" , true  , true);
  item = config_add_schema_item(config , "KEY2" , true  , false);
  config_schema_item_set_argc_minmax(item , 1 , 4 , 4 , (const config_item_types [4]) {CONFIG_EXECUTABLE , CONFIG_EXISTING_FILE , CONFIG_BOOLEAN , CONFIG_BOOLEAN});


  item = config_add_schema_item(config , "FATHER"  , false , false);
  {
    stringlist_type * children = stringlist_alloc_argv_ref( (const char *[2]) {"CHILD1" , "CHILD2"} , 2);
    config_schema_item_set_required_children(item , children);
    stringlist_free(children);
  }
  item = config_add_schema_item(config , "CHILD1"  , false , false);
  config_schema_item_set_argc_minmax(item , 1 , 1 , 1 , (const config_item_types [1]) {CONFIG_INT});
  
  config_parse(config , config_file , "--" , "INCLUDE" , NULL , true, true);
  


  {
    stringlist_type * sl = config_alloc_complete_stringlist(config , "KEY1");
    char * s = stringlist_alloc_joined_string(sl , "|");