optionsdatabase_mod Module Reference

Manages the options database. Contains administration functions and deduce runtime options from the command line. More...

Data Types
interface	options_add
	Generic add interface for adding different types of data to the databases. More...

Functions/Subroutines
integer function, public	options_size (options_database)
	Returns the number of entries in the options database. More...
character(len=string_length) function, public	options_key_at (options_database, i)
	Returns the ith key in the options database. More...
class(*) function, pointer, public	options_value_at (options_database, i)
	Returns the value at index in the database. More...
logical function, public	options_has_key (options_database, key)
	Determines whether a specific key is in the database. More...
real(kind=default_precision) function, public	options_get_real (options_database, key, index)
	Retrieves a real value from the database that matches the provided key. More...
subroutine, public	options_get_real_array (options_database, key, array_data, from, to)
	Retrieves an entire (or subset) real array. More...
logical function, public	options_get_logical (options_database, key, index)
	Retrieves a logical value from the database that matches the provided key. More...
subroutine, public	options_get_logical_array (options_database, key, array_data, from, to)
	Retrieves an entire (or subset) logical array. More...
integer function, public	options_get_integer (options_database, key, index)
	Retrieves an integer value from the database that matches the provided key. More...
subroutine, public	options_get_integer_array (options_database, key, array_data, from, to)
	Retrieves an entire (or subset) integer array. More...
character(len=string_length) function, public	options_get_string (options_database, key, index)
	Retrieves a string value from the database that matches the provided key. More...
subroutine, public	options_get_string_array (options_database, key, array_data, from, to)
	Retrieves an entire (or subset) string array. More...
integer function, public	options_get_array_size (options_database, key)
	Gets the size of the array held in the options database corresponding to a specific key. More...
subroutine, public	load_command_line_into_options_database (options_database)
	Loads in the command line arguments and stores them in the options database. More...
subroutine, public	options_remove_key (options_database, key)
	Removes a specific key from the options database, if it is an array then the entire array is removed. More...
subroutine	check_options_key_exists (options_database, key)
	Determines whether a specific options key exists in the database or not, if it doesn't then this results in a log error being issued. More...
subroutine	options_add_real (options_database, key, real_value, do_not_replace, array_index)
	Adds a real value to the options database with a specific key. More...
subroutine	options_add_logical (options_database, key, logical_value, do_not_replace, array_index)
	Adds a logical value to the options database with a specific key. More...
subroutine	options_add_string (options_database, key, string_value, do_not_replace, array_index)
	Adds a string value to the options database with a specific key. More...
recursive subroutine	options_add_integer (options_database, key, int_value, do_not_replace, array_index)
	Adds an integer value to the options database with a specific key. More...
character(len=string_length) function	get_options_array_key (key, index)
	Gets a key corresponding to the correct options key and index combination. More...
integer function	get_argument_value_type (specific_value)
	Given a specific value this will determine the type of data. More...
subroutine	add_specific_option_key_value_pair (type_of_config, parse_options, specific_arg)
	This will add a specific option key value pair to the options hashmap_type. More...
subroutine	set_options_logical_value (optionhashmap_type, key, logical_value)
	A helper procedure to set a specific logical value. More...
subroutine	set_options_real_value (optionhashmap_type, key, real_value)
	A helper procedure to set a specific real value. More...
subroutine	set_options_integer_value (optionhashmap_type, key, int_value)
	A helper procedure to set a specific integer value. More...
subroutine	set_options_string_value (optionhashmap_type, key, str_value)
	A helper procedure to set a specific string value. More...

Variables
integer, parameter	logical_type =0
	Type of logical value data. More...
integer, parameter	integer_type =1
	Type of integer value data. More...
integer, parameter	real_type =2
	Type of real value data. More...
integer, parameter	string_type =3
	Type of string value data. More...
integer, parameter	array_append_size = 10

Detailed Description

Manages the options database. Contains administration functions and deduce runtime options from the command line.

The key-value character length limit for each option is 64 characters, the value length limit is 44 characters and key length 20 characters. Note that the options database should be entirely agnostic of where or now the database is stored (in our case in the state.)

Function/Subroutine Documentation

add_specific_option_key_value_pair()

subroutine optionsdatabase_mod::add_specific_option_key_value_pair ( integer, intent(in)  type_of_config, type(hashmap_type), intent(inout)  parse_options, character(len=*), intent(in)  specific_arg  )

private

This will add a specific option key value pair to the options hashmap_type.

As per the hashmap_type semantics, if the user supplies an option then this will override any existing default value.

Parameters

type_of_config	The type of value to add to the configuration hashmap_type
parse_options	The key-value pairs of configuration options
specific_arg	The argument string (key=value or just key)

Definition at line 640 of file optionsdatabase.F90.

    integer, intent(in) :: type_of_config
    character(len=*), intent(in) :: specific_arg
    type(hashmap_type), intent(inout) :: parse_options
 
    integer :: equals_posn
    equals_posn=index(specific_arg, "=")  ! Get the position of the equals character
 
    if (type_of_config == logical_type) then
      if (equals_posn .gt. 0) then
        call set_options_logical_value(parse_options, specific_arg(3:equals_posn-1), &
          conv_to_logical(specific_arg(equals_posn+1:len(specific_arg))))
      else
        ! Handle the case where there is just a key (no value)
        call set_options_logical_value(parse_options, specific_arg(3:len(specific_arg)), .true.)
      end if
    else if (type_of_config == integer_type) then
      call set_options_integer_value(parse_options, specific_arg(3:equals_posn-1), &
        conv_to_integer(specific_arg(equals_posn+1:len(specific_arg))))
    else if (type_of_config == real_type) then
      call set_options_real_value(parse_options, specific_arg(3:equals_posn-1), &
        conv_single_real_to_double(conv_to_real(specific_arg(equals_posn+1:len(specific_arg)))))
    else if (type_of_config == string_type) then
      call set_options_string_value(parse_options, specific_arg(3:equals_posn-1), specific_arg(equals_posn+1:len(specific_arg)))
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

check_options_key_exists()

subroutine optionsdatabase_mod::check_options_key_exists ( type(hashmap_type), intent(inout)  options_database, character(len=*), intent(in)  key  )

private

Determines whether a specific options key exists in the database or not, if it doesn't then this results in a log error being issued.

Parameters

options_database	The options database
key	The key to search for and return the matching value

Definition at line 412 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
 
    if (.not. options_has_key(options_database, key)) then
      call log_log(log_error, "No configuration option with key "//trim(key)//" present")
    end if    

Here is the call graph for this function:

Here is the caller graph for this function:

get_argument_value_type()

integer function optionsdatabase_mod::get_argument_value_type ( character(len=*), intent(in)  specific_value )

private

Given a specific value this will determine the type of data.

It basically wraps around the conversion test utilities, but will select a real if the string contains a dot and an integer if not. If no conversions_mod can be achieved then the value is assumed to be of type string

Parameters

specific_value

String value to deduce the type of

Returns

Integer representing the type as per the module parameter type integers

Definition at line 605 of file optionsdatabase.F90.

    character(len=*), intent(in) :: specific_value
    integer :: dot_posn, exponent_posn
 
    if (conv_is_logical(specific_value)) then
      get_argument_value_type = logical_type
      return
      else
    end if
 
    dot_posn = index(specific_value,".")
    exponent_posn = index(specific_value,"e")
    if (dot_posn .eq. 0 .and. exponent_posn .eq. 0) then
      ! No dot, therefore an integer or string
      if (conv_is_integer(specific_value)) then
        get_argument_value_type = integer_type
        return
      end if
    else
      ! A dot is present, therefore a real or string
      if (conv_is_real(specific_value)) then
        get_argument_value_type = real_type
        return
      end if
    end if
    get_argument_value_type = string_type ! Default string type

Here is the caller graph for this function:

get_options_array_key()

character(len=string_length) function optionsdatabase_mod::get_options_array_key ( character(len=*), intent(in)  key, integer, intent(in)  index  )

private

Gets a key corresponding to the correct options key and index combination.

Parameters

key	The key
index	The index

Returns

The key to store the indexed item in

Definition at line 591 of file optionsdatabase.F90.

    character(len=*), intent(in) :: key
    integer, intent(in) :: index
 
    get_options_array_key=trim(key)//"a_"//trim(conv_to_string(index))

Here is the caller graph for this function:

load_command_line_into_options_database()

subroutine, public optionsdatabase_mod::load_command_line_into_options_database

(

type(hashmap_type), intent(inout)

options_database

)

Loads in the command line arguments and stores them in the options database.

Returns

hashmap_type of option-value pairs

Definition at line 356 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
 
    integer :: i, arguments, equals_posn, type_of_config
    character(len=LONG_STRING_LENGTH) :: specific_arg
 
    arguments = command_argument_count()
 
    do i=1,arguments
      call get_command_argument(i, value = specific_arg)
      specific_arg = trim(specific_arg)
      equals_posn=index(specific_arg, "=")  ! Get the position of the equals character
      if (index(specific_arg, "--") .eq. 1) then
        if (equals_posn .gt. 0) then
          type_of_config = get_argument_value_type(specific_arg(equals_posn+1 : len(specific_arg)))
        else
          ! If no equals then it is a logical switch (to true)
          type_of_config = logical_type
        end if        
        call add_specific_option_key_value_pair(type_of_config, options_database, specific_arg)
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

options_add_integer()

recursive subroutine optionsdatabase_mod::options_add_integer ( type(hashmap_type), intent(inout)  options_database, character(len=*), intent(in)  key, integer, intent(in)  int_value, logical, intent(in), optional  do_not_replace, integer, intent(in), optional  array_index  )

private

Adds an integer value to the options database with a specific key.

Parameters

options_database	The options database
key	The key to use
value	The integer value to add to the database
do_not_replace	Optional flag whether to ignore existing values or replace them
array_index	Optional array index which specifies which location in the array to write to

Definition at line 552 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    integer, intent(in) :: int_value
    integer, intent(in), optional :: array_index
    logical, intent(in), optional :: do_not_replace
 
    integer :: temp_size
    character(len=len(key)+ARRAY_APPEND_SIZE) :: lookup_key
 
    if (present(do_not_replace)) then
      if (do_not_replace) then
        if (present(array_index)) then
          if (options_has_key(options_database, trim(key)//"a_"//conv_to_string(array_index))) return
        else
          if (options_has_key(options_database, key)) return
        end if
      end if      
    end if
 
    if (present(array_index)) then
      if (options_has_key(options_database, trim(key)//"a_size")) then
        temp_size=options_get_integer(options_database, trim(key)//"a_size")
        if (temp_size .lt. array_index) temp_size=temp_size+1
      else
        temp_size=1
      end if
      call options_add(options_database, trim(key)//"a_size", temp_size)
      lookup_key=get_options_array_key(key, array_index)
    else
      lookup_key=key
    end if
    call c_put_integer(options_database, lookup_key, int_value)    

Here is the call graph for this function:

options_add_logical()

subroutine optionsdatabase_mod::options_add_logical ( type(hashmap_type), intent(inout)  options_database, character(len=*), intent(in)  key, logical, intent(in)  logical_value, logical, intent(in), optional  do_not_replace, integer, intent(in), optional  array_index  )

private

Adds a logical value to the options database with a specific key.

Parameters

options_database	The options database
key	The key to use
value	The logical value to add to the database
do_not_replace	Optional flag whether to ignore existing values or replace them
array_index	Optional array index which specifies which location in the array to write to

Definition at line 468 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    logical, intent(in) :: logical_value
    integer, intent(in), optional :: array_index
    logical, intent(in), optional :: do_not_replace
 
    integer :: temp_size
    character(len=len(key)+ARRAY_APPEND_SIZE) :: lookup_key
 
    if (present(do_not_replace)) then
      if (do_not_replace) then
        if (present(array_index)) then
          if (options_has_key(options_database, trim(key)//"a_"//conv_to_string(array_index))) return
        else
          if (options_has_key(options_database, key)) return
        end if
      end if      
    end if
 
    if (present(array_index)) then
      if (options_has_key(options_database, trim(key)//"a_size")) then
        temp_size=options_get_integer(options_database, trim(key)//"a_size")
        if (temp_size .lt. array_index) temp_size=temp_size+1
      else
        temp_size=1
      end if
      call options_add(options_database, trim(key)//"a_size", temp_size)
      lookup_key=get_options_array_key(key, array_index)
    else
      lookup_key=key
    end if
    call c_put_logical(options_database, lookup_key, logical_value)    

Here is the call graph for this function:

options_add_real()

subroutine optionsdatabase_mod::options_add_real ( type(hashmap_type), intent(inout)  options_database, character(len=*), intent(in)  key, real(kind=default_precision), intent(in)  real_value, logical, intent(in), optional  do_not_replace, integer, intent(in), optional  array_index  )

private

Adds a real value to the options database with a specific key.

Parameters

options_database	The options database
key	The key to use
value	The real value to add to the database
do_not_replace	Optional flag whether to ignore existing values or replace them
array_index	Optional array index which specifies which location in the array to write to

Definition at line 427 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    real(kind=default_precision), intent(in) :: real_value
    integer, intent(in), optional :: array_index
    logical, intent(in), optional :: do_not_replace
 
    integer :: temp_size
    character(len=len(key)+ARRAY_APPEND_SIZE) :: lookup_key
 
    if (present(do_not_replace)) then
      if (do_not_replace) then
        if (present(array_index)) then
          if (options_has_key(options_database, trim(key)//"a_"//conv_to_string(array_index))) return
        else
          if (options_has_key(options_database, key)) return
        end if
      end if      
    end if
 
    if (present(array_index)) then
      if (options_has_key(options_database, trim(key)//"a_size")) then
        temp_size=options_get_integer(options_database, trim(key)//"a_size")
        if (temp_size .lt. array_index) temp_size=temp_size+1
      else
        temp_size=1
      end if
      call options_add(options_database, trim(key)//"a_size", temp_size)      
      lookup_key=get_options_array_key(key, array_index)
    else
      lookup_key=key
    end if
    call c_put_real(options_database, lookup_key, real_value)

Here is the call graph for this function:

options_add_string()

subroutine optionsdatabase_mod::options_add_string ( type(hashmap_type), intent(inout)  options_database, character(len=*), intent(in)  key, character(len=*), intent(in)  string_value, logical, intent(in), optional  do_not_replace, integer, intent(in), optional  array_index  )

private

Adds a string value to the options database with a specific key.

Parameters

options_database	The options database
key	The key to use
value	The string value to add to the database
do_not_replace	Optional flag whether to ignore existing values or replace them
array_index	Optional array index which specifies which location in the array to write to

Definition at line 509 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key, string_value
    integer, intent(in), optional :: array_index
    logical, intent(in), optional :: do_not_replace
 
    character(len=STRING_LENGTH) :: value_to_store
    integer :: temp_size
    character(len=len(key)+ARRAY_APPEND_SIZE) :: lookup_key
 
    if (present(do_not_replace)) then
      if (do_not_replace) then
        if (present(array_index)) then
          if (options_has_key(options_database, trim(key)//"a_"//conv_to_string(array_index))) return
        else
          if (options_has_key(options_database, key)) return
        end if
      end if      
    end if
 
    value_to_store=string_value
 
    if (present(array_index)) then
      if (options_has_key(options_database, trim(key)//"a_size")) then
        temp_size=options_get_integer(options_database, trim(key)//"a_size")
        if (temp_size .lt. array_index) temp_size=temp_size+1
      else
        temp_size=1
      end if
      call options_add(options_database, trim(key)//"a_size", temp_size)
      lookup_key=get_options_array_key(key, array_index)
    else
      lookup_key=key
    end if
    call c_put_string(options_database, lookup_key, value_to_store)

Here is the call graph for this function:

options_get_array_size()

integer function, public optionsdatabase_mod::options_get_array_size	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key
	)

Gets the size of the array held in the options database corresponding to a specific key.

Parameters

options_database	The options database
key	The key to look up

Returns

The number of elements in the array, 0 means zero elements (key is not in the database or corresponds to scalar.)

Definition at line 341 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
 
    if (options_has_key(options_database, trim(key)//"a_size")) then
      options_get_array_size=options_get_integer(options_database, trim(key)//"a_size")
    else if (options_has_key(options_database, trim(key))) then
      options_get_array_size=1
    else
      options_get_array_size=0
    end if    

Here is the call graph for this function:

Here is the caller graph for this function:

options_get_integer()

integer function, public optionsdatabase_mod::options_get_integer	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key,
		integer, intent(in), optional	index
	)

Retrieves an integer value from the database that matches the provided key.

Parameters

options_database	The options database
key	The key to search for and return the matching value
index	Optional array index to look up an array value

Returns

The matching integer value

Definition at line 216 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    integer, intent(in), optional :: index
 
    character(len=len(key)+ARRAY_APPEND_SIZE) :: lookup_key
 
    if (present(index)) then
      lookup_key=get_options_array_key(key, index)
    else
      lookup_key=key
    end if
    call check_options_key_exists(options_database, lookup_key)
    options_get_integer=c_get_integer(options_database, lookup_key)

Here is the call graph for this function:

Here is the caller graph for this function:

options_get_integer_array()

subroutine, public optionsdatabase_mod::options_get_integer_array	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key,
		integer, dimension(:), intent(inout)	array_data,
		integer, intent(in), optional	from,
		integer, intent(in), optional	to
	)

Retrieves an entire (or subset) integer array.

Parameters

options_database	The options database
key	The key to search for
array_data	The array data to write into
from	Optional starting index
to	Optional end index

Definition at line 238 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    integer, dimension(:), intent(inout) :: array_data
    integer, intent(in), optional :: from, to
 
    integer :: num_elements, i, start, end
 
    num_elements=options_get_array_size(options_database, key)
    if (num_elements .gt. 0 .and. options_has_key(options_database, trim(key)//"a_size")) then
      if (present(from)) then
        start=from
      else
        start=1
      end if
      if (present(to)) then
        end=to
      else
        end=num_elements
      end if
      do i=start, num_elements
        array_data((i-start)+1)=options_get_integer(options_database, key, i)
      end do
    else
      if (options_has_key(options_database, key)) then
        if (present(from)) then
          if (from .gt. 1) return          
        end if
        if (present(to)) then
          if (to .lt. 1) return
        end if
        array_data(1)=options_get_integer(options_database, key)
      end if
    end if

Here is the call graph for this function:

options_get_logical()

logical function, public optionsdatabase_mod::options_get_logical	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key,
		integer, intent(in), optional	index
	)

Retrieves a logical value from the database that matches the provided key.

Parameters

options_database	The options database
key	The key to search for and return the matching value
index	Optional array index to look up an array value

Returns

The matching logical value

Definition at line 153 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    integer, intent(in), optional :: index
 
    character(len=len(key)+ARRAY_APPEND_SIZE) :: lookup_key
 
    if (present(index)) then
      lookup_key=get_options_array_key(key, index)
    else
      lookup_key=key
    end if
    call check_options_key_exists(options_database, lookup_key)
    options_get_logical=c_get_logical(options_database, lookup_key)

Here is the call graph for this function:

Here is the caller graph for this function:

options_get_logical_array()

subroutine, public optionsdatabase_mod::options_get_logical_array	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key,
		logical, dimension(:), intent(inout)	array_data,
		integer, intent(in), optional	from,
		integer, intent(in), optional	to
	)

Retrieves an entire (or subset) logical array.

Parameters

options_database	The options database
key	The key to search for
array_data	The array data to write into
from	Optional starting index
to	Optional end index

Definition at line 175 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    logical, dimension(:), intent(inout) :: array_data
    integer, intent(in), optional :: from, to
 
    integer :: num_elements, i, start, end
 
    num_elements=options_get_array_size(options_database, key)
    if (num_elements .gt. 0 .and. options_has_key(options_database, trim(key)//"a_size")) then
      if (present(from)) then
        start=from
      else
        start=1
      end if
      if (present(to)) then
        end=to
      else
        end=num_elements
      end if
      do i=start, num_elements
        array_data((i-start)+1)=options_get_logical(options_database, key, i)
      end do
    else
      if (options_has_key(options_database, key)) then
        if (present(from)) then
          if (from .gt. 1) return          
        end if
        if (present(to)) then
          if (to .lt. 1) return
        end if
        array_data(1)=options_get_logical(options_database, key)
      end if
    end if

Here is the call graph for this function:

options_get_real()

real(kind=default_precision) function, public optionsdatabase_mod::options_get_real	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key,
		integer, intent(in), optional	index
	)

Retrieves a real value from the database that matches the provided key.

Parameters

options_database	The options database
key	The key to search for and return the matching value
index	Optional array index to look up an array value

Returns

The matching real value

Definition at line 90 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    integer, intent(in), optional :: index
 
    character(len=len(key)+ARRAY_APPEND_SIZE) :: lookup_key
 
    if (present(index)) then
      lookup_key=get_options_array_key(key, index)
    else
      lookup_key=key
    end if
    call check_options_key_exists(options_database, lookup_key)
    options_get_real=c_get_real(options_database, lookup_key)

Here is the call graph for this function:

Here is the caller graph for this function:

options_get_real_array()

subroutine, public optionsdatabase_mod::options_get_real_array	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key,
		real(kind=default_precision), dimension(:), intent(inout)	array_data,
		integer, intent(in), optional	from,
		integer, intent(in), optional	to
	)

Retrieves an entire (or subset) real array.

Parameters

options_database	The options database
key	The key to search for
array_data	The array data to write into
from	Optional starting index
to	Optional end index

Definition at line 112 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    real(kind=default_precision), dimension(:), intent(inout) :: array_data
    integer, intent(in), optional :: from, to
 
    integer :: num_elements, i, start, end
 
    num_elements=options_get_array_size(options_database, key)
    if (num_elements .gt. 0 .and. options_has_key(options_database, trim(key)//"a_size")) then
      if (present(from)) then
        start=from
      else
        start=1
      end if
      if (present(to)) then
        end=to
      else
        end=num_elements
      end if
      do i=start, num_elements
        array_data((i-start)+1)=options_get_real(options_database, key, i)
      end do
    else
      if (options_has_key(options_database, key)) then
        if (present(from)) then
          if (from .gt. 1) return          
        end if
        if (present(to)) then
          if (to .lt. 1) return
        end if
        array_data(1)=options_get_real(options_database, key)
      end if
    end if

Here is the call graph for this function:

options_get_string()

character(len=string_length) function, public optionsdatabase_mod::options_get_string	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key,
		integer, intent(in), optional	index
	)

Retrieves a string value from the database that matches the provided key.

Parameters

options_database	The options database
key	The key to search for and return the matching value
index	Optional array index to look up an array value

Returns

The matching string value

Definition at line 279 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    integer, intent(in), optional :: index
 
    character(len=len(key)+ARRAY_APPEND_SIZE) :: lookup_key
 
    if (present(index)) then
      lookup_key=get_options_array_key(key, index)
    else
      lookup_key=key
    end if
    call check_options_key_exists(options_database, lookup_key)
    options_get_string=c_get_string(options_database, lookup_key)

Here is the call graph for this function:

Here is the caller graph for this function:

options_get_string_array()

subroutine, public optionsdatabase_mod::options_get_string_array	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key,
		character(len=string_length), dimension(:), intent(inout)	array_data,
		integer, intent(in), optional	from,
		integer, intent(in), optional	to
	)

Retrieves an entire (or subset) string array.

Parameters

options_database	The options database
key	The key to search for
array_data	The array data to write into
from	Optional starting index
to	Optional end index

Definition at line 301 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
    character(len=STRING_LENGTH), dimension(:), intent(inout) :: array_data
    integer, intent(in), optional :: from, to
 
    integer :: num_elements, i, start, end
 
    num_elements=options_get_array_size(options_database, key)
    if (num_elements .gt. 0 .and. options_has_key(options_database, trim(key)//"a_size")) then
      if (present(from)) then
        start=from
      else
        start=1
      end if
      if (present(to)) then
        end=to
      else
        end=num_elements
      end if
      do i=start, num_elements
        array_data((i-start)+1)=options_get_string(options_database, key, i)
      end do
    else
      if (options_has_key(options_database, key)) then
        if (present(from)) then
          if (from .gt. 1) return          
        end if
        if (present(to)) then
          if (to .lt. 1) return
        end if
        array_data(1)=options_get_string(options_database, key)
      end if
    end if

Here is the call graph for this function:

options_has_key()

logical function, public optionsdatabase_mod::options_has_key	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key
	)

Determines whether a specific key is in the database.

Parameters

options_database	The options database
key	The key to find

Returns

Whether they key is in the database or not

Definition at line 75 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
 
    options_has_key = c_contains(options_database, trim(key))
    if (.not. options_has_key) then
      options_has_key = c_contains(options_database, trim(key)//"a_size")
    end if

Here is the caller graph for this function:

options_key_at()

character(len=string_length) function, public optionsdatabase_mod::options_key_at	(	type(hashmap_type), intent(inout)	options_database,
		integer, intent(in)	i
	)

Returns the ith key in the options database.

Parameters

options_database	The options database
i	The index to retrieve the key at

Returns

The key at index i

Definition at line 52 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    integer, intent(in) :: i
 
    options_key_at = c_key_at(options_database, i)

Here is the caller graph for this function:

options_remove_key()

subroutine, public optionsdatabase_mod::options_remove_key	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	key
	)

Removes a specific key from the options database, if it is an array then the entire array is removed.

Parameters

options_database	The options database
key	The key to locate and remove

Definition at line 383 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: key
 
    integer :: array_size, i
    
    if (options_has_key(options_database, key)) then          
      array_size=options_get_array_size(options_database, key)
      if (array_size .gt. 0) then
        do i=1,array_size
          if (options_has_key(options_database, get_options_array_key(key, i))) then
            call c_remove(options_database, get_options_array_key(key, i))
          end if
        end do
        call c_remove(options_database, trim(key)//"a_size")
      end if
    else 
      call c_remove(options_database, key)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

options_size()

integer function, public optionsdatabase_mod::options_size

(

type(hashmap_type), intent(inout)

options_database

)

Returns the number of entries in the options database.

Parameters

options_database

The options database

Returns

The number of entries

Definition at line 42 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
 
    options_size = c_size(options_database)

Here is the caller graph for this function:

options_value_at()

class(*) function, pointer, public optionsdatabase_mod::options_value_at	(	type(hashmap_type), intent(inout)	options_database,
		integer, intent(in)	i
	)

Returns the value at index in the database.

Parameters

options_database	The options database
i	The index to retrieve the value at

Returns

The value at index i

Definition at line 63 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: options_database
    integer, intent(in) :: i
    class(*), pointer :: options_value_at
 
    options_value_at=>c_generic_at(options_database, i)

Here is the caller graph for this function:

set_options_integer_value()

subroutine optionsdatabase_mod::set_options_integer_value ( type(hashmap_type), intent(inout)  optionhashmap_type, character(len=*), intent(in)  key, integer, intent(in)  int_value  )

private

A helper procedure to set a specific integer value.

Definition at line 686 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: optionhashmap_type
    character(len=*), intent(in) :: key
    integer, intent(in) :: int_value
 
    call c_put_integer(optionhashmap_type, key, int_value)

Here is the caller graph for this function:

set_options_logical_value()

subroutine optionsdatabase_mod::set_options_logical_value ( type(hashmap_type), intent(inout)  optionhashmap_type, character(len=*), intent(in)  key, logical, intent(in)  logical_value  )

private

A helper procedure to set a specific logical value.

Definition at line 668 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: optionhashmap_type
    character(len=*), intent(in) :: key
    logical, intent(in) :: logical_value
 
    call c_put_logical(optionhashmap_type, key, logical_value)

Here is the caller graph for this function:

set_options_real_value()

subroutine optionsdatabase_mod::set_options_real_value ( type(hashmap_type), intent(inout)  optionhashmap_type, character(len=*), intent(in)  key, real(kind=default_precision), intent(in)  real_value  )

private

A helper procedure to set a specific real value.

Definition at line 677 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: optionhashmap_type
    character(len=*), intent(in) :: key
    real(kind=default_precision), intent(in) :: real_value
 
    call c_put_real(optionhashmap_type, key, real_value)

Here is the caller graph for this function:

set_options_string_value()

subroutine optionsdatabase_mod::set_options_string_value ( type(hashmap_type), intent(inout)  optionhashmap_type, character(len=*), intent(in)  key, character(len=*), intent(in)  str_value  )

private

A helper procedure to set a specific string value.

Definition at line 695 of file optionsdatabase.F90.

    type(hashmap_type), intent(inout) :: optionhashmap_type
    character(len=*), intent(in) :: key
    character(len=*), intent(in) :: str_value
 
    character(len=STRING_LENGTH) :: write_value
 
    ! We do an assignment here to force the value to be default size, otherwise might underflow
    write_value = str_value
    call c_put_string(optionhashmap_type, key, write_value)

Here is the caller graph for this function:

Variable Documentation

array_append_size

integer, parameter optionsdatabase_mod::array_append_size = 10

private

Definition at line 25 of file optionsdatabase.F90.

  integer, parameter :: ARRAY_APPEND_SIZE = 10

integer_type

integer, parameter optionsdatabase_mod::integer_type =1

private

Type of integer value data.

Definition at line 19 of file optionsdatabase.F90.

logical_type

integer, parameter optionsdatabase_mod::logical_type =0

private

Type of logical value data.

Definition at line 19 of file optionsdatabase.F90.

  integer, parameter :: LOGICAL_TYPE=0,&  !< Type of logical value data
                        integer_type=1,&  
                        real_type=2,&     
                        string_type=3     

real_type

integer, parameter optionsdatabase_mod::real_type =2

private

Type of real value data.

Definition at line 19 of file optionsdatabase.F90.

string_type

integer, parameter optionsdatabase_mod::string_type =3

private

Type of string value data.

Definition at line 19 of file optionsdatabase.F90.