wrap_initialize_json_file_from_string Function

private function wrap_initialize_json_file_from_string(str, verbose, compact_reals, print_signs, real_format, spaces_per_tab, strict_type_checking, trailing_spaces_significant, case_sensitive_keys, no_whitespace, unescape_strings, comment_char, path_mode, path_separator, compress_vectors, allow_duplicate_keys, escape_solidus, stop_on_error, null_to_real_mode, non_normal_mode, use_quiet_nan, strict_integer_type_checking, allow_trailing_comma, parser_mode, parser_initial_stack_size, parser_max_stack_size, string_to_real_mode) result(file_object)

Alternate version of initialize_json_file_from_string, where “str” is kind=CDK.

Arguments

Type IntentOptional Attributes Name
character(kind=CDK, len=*), intent(in) :: str

string to load JSON data from
logical(kind=LK), intent(in), optional :: verbose

mainly useful for debugging (default is false)
logical(kind=LK), intent(in), optional :: compact_reals

to compact the real number strings for output (default is true)
logical(kind=LK), intent(in), optional :: print_signs

always print numeric sign (default is false)
character(kind=CDK, len=*), intent(in), optional :: real_format

Real number format: ‘E’ [default], ‘*’, ‘G’, ‘EN’, or ‘ES’
integer(kind=IK), intent(in), optional :: spaces_per_tab

number of spaces per tab for indenting (default is 2)
logical(kind=LK), intent(in), optional :: strict_type_checking

if true, no integer, double, or logical type conversions are done for the get routines (default is false).
logical(kind=LK), intent(in), optional :: trailing_spaces_significant

for name and path comparisons, is trailing space to be considered significant. (default is false)
logical(kind=LK), intent(in), optional :: case_sensitive_keys

for name and path comparisons, are they case sensitive. (default is true)
logical(kind=LK), intent(in), optional :: no_whitespace

if true, printing the JSON structure is done without adding any non-significant spaces or linebreaks (default is false)
logical(kind=LK), intent(in), optional :: unescape_strings

If false, then the raw escaped string is returned from json_get_string and similar routines. If true [default], then the string is returned unescaped.
character(kind=CK, len=*), intent(in), optional :: comment_char

If present, these characters are used to denote comments in the JSON file, which will be ignored if present. Example: !, #, or /!#. Setting this to a blank string disables the ignoring of comments. (Default is /!#).
integer(kind=IK), intent(in), optional :: path_mode

How the path strings are interpreted in the get_by_path routines:
character(kind=CK, len=1), intent(in), optional :: path_separator

The path separator to use in the “default” mode for the paths in the various get_by_path routines. Example: . [default] or %. Note: if path_mode/=1 then this is ignored.
logical(kind=LK), intent(in), optional :: compress_vectors

If true, then arrays of integers, nulls, doubles, and logicals are printed all on one line. [Note: no_whitespace will override this option if necessary]. (Default is False).
logical(kind=LK), intent(in), optional :: allow_duplicate_keys
  • If True [default] then no special checks are done to check for duplicate keys.
  • If False, then after parsing, if any duplicate keys are found, an error is thrown. A call to json_value_validate will also check for duplicates.
logical(kind=LK), intent(in), optional :: escape_solidus
  • If True then the solidus “/” is always escaped “\/” when serializing JSON
  • If False [default], then it is not escaped.

Note that this option does not affect parsing (both escaped and unescaped are still valid in all cases).
logical(kind=LK), intent(in), optional :: stop_on_error

If an exception is raised, then immediately quit. (Default is False).
integer(kind=IK), intent(in), optional :: null_to_real_mode

if strict_type_checking=false:

  • 1 : an exception will be raised if try to retrieve a null as a real.
  • 2 : a null retrieved as a real will return a NaN. [default]
  • 3 : a null retrieved as a real will return 0.0.
integer(kind=IK), intent(in), optional :: non_normal_mode

How to serialize NaN, Infinity, and -Infinity real values:

  • 1 : as strings (e.g., “NaN”, “Infinity”, “-Infinity”) [default]
  • 2 : as JSON null values
logical(kind=LK), intent(in), optional :: use_quiet_nan
  • If true [default], null_to_real_mode=2 and string_to_real will use ieee_quiet_nan for NaN values.
  • If false, ieee_signaling_nan will be used.
logical(kind=LK), intent(in), optional :: strict_integer_type_checking
  • If false, when parsing JSON, if an integer numeric value cannot be converted to an integer (integer(IK)), then an attempt is then make to convert it to a real (real(RK)).
  • If true, an exception will be raised if the integer value cannot be read.

(default is true)
logical(kind=LK), intent(in), optional :: allow_trailing_comma

Allow a single trailing comma in arrays and objects. (default is true)
integer(kind=IK), intent(in), optional :: parser_mode

Which version of the JSON parser to use:

  • 1 : the original recursive version [default]
  • 2 : a non-recursive version that uses an explicit stack to avoid deep recursion issues.
integer(kind=IK), intent(in), optional :: parser_initial_stack_size

The initial stack size (in number of elements) to use when parser_mode=2 (non-recursive parser). (default is 32)
integer(kind=IK), intent(in), optional :: parser_max_stack_size

The maximum stack size (in number of elements) to use when parser_mode=2 (non-recursive parser). (default is 10000)
integer(kind=IK), intent(in), optional :: string_to_real_mode

Which implementation to use for converting strings to real values:

  • 1 : use the Fortran implementation [default]
  • 2 : use C library routines to convert strings to real values. This may be faster than the Fortran implementation. If the conversion fails, it will fall back to the Fortran version.

Return Value type(json_file)


Calls

proc~~wrap_initialize_json_file_from_string~~CallsGraph proc~wrap_initialize_json_file_from_string wrap_initialize_json_file_from_string interface~to_unicode to_unicode proc~wrap_initialize_json_file_from_string->interface~to_unicode proc~initialize_json_file_from_string initialize_json_file_from_string proc~wrap_initialize_json_file_from_string->proc~initialize_json_file_from_string proc~to_uni to_uni interface~to_unicode->proc~to_uni proc~to_uni_vec to_uni_vec interface~to_unicode->proc~to_uni_vec none~deserialize json_file%deserialize proc~initialize_json_file_from_string->none~deserialize none~initialize json_file%initialize proc~initialize_json_file_from_string->none~initialize proc~json_file_load_from_string json_file%json_file_load_from_string none~deserialize->proc~json_file_load_from_string proc~wrap_json_file_load_from_string json_file%wrap_json_file_load_from_string none~deserialize->proc~wrap_json_file_load_from_string proc~initialize_json_core_in_file json_file%initialize_json_core_in_file none~initialize->proc~initialize_json_core_in_file proc~set_json_core_in_file json_file%set_json_core_in_file none~initialize->proc~set_json_core_in_file proc~json_initialize json_core%json_initialize proc~initialize_json_core_in_file->proc~json_initialize none~deserialize~2 json_core%deserialize proc~json_file_load_from_string->none~deserialize~2 proc~json_file_destroy json_file%json_file_destroy proc~json_file_load_from_string->proc~json_file_destroy proc~wrap_json_file_load_from_string->interface~to_unicode proc~wrap_json_file_load_from_string->none~deserialize proc~json_parse_string json_core%json_parse_string none~deserialize~2->proc~json_parse_string proc~wrap_json_parse_string json_core%wrap_json_parse_string none~deserialize~2->proc~wrap_json_parse_string none~destroy~3 json_core%destroy proc~json_file_destroy->none~destroy~3 none~throw_exception json_core%throw_exception proc~json_initialize->none~throw_exception proc~integer_to_string integer_to_string proc~json_initialize->proc~integer_to_string proc~json_clear_exceptions json_core%json_clear_exceptions proc~json_initialize->proc~json_clear_exceptions proc~destroy_json_core json_core%destroy_json_core none~destroy~3->proc~destroy_json_core proc~json_value_destroy json_core%json_value_destroy none~destroy~3->proc~json_value_destroy proc~json_throw_exception json_core%json_throw_exception none~throw_exception->proc~json_throw_exception proc~wrap_json_throw_exception json_core%wrap_json_throw_exception none~throw_exception->proc~wrap_json_throw_exception proc~json_parse_string->proc~json_initialize proc~json_parse_string->none~throw_exception proc~annotate_invalid_json json_core%annotate_invalid_json proc~json_parse_string->proc~annotate_invalid_json proc~json_check_all_for_duplicate_keys json_core%json_check_all_for_duplicate_keys proc~json_parse_string->proc~json_check_all_for_duplicate_keys proc~json_parse_end json_core%json_parse_end proc~json_parse_string->proc~json_parse_end proc~json_prepare_parser json_core%json_prepare_parser proc~json_parse_string->proc~json_prepare_parser proc~json_value_create json_value_create proc~json_parse_string->proc~json_value_create proc~wrap_json_parse_string->interface~to_unicode proc~wrap_json_parse_string->none~deserialize~2 proc~annotate_invalid_json->proc~integer_to_string proc~get_current_line_from_file_sequential json_core%get_current_line_from_file_sequential proc~annotate_invalid_json->proc~get_current_line_from_file_sequential proc~get_current_line_from_file_stream json_core%get_current_line_from_file_stream proc~annotate_invalid_json->proc~get_current_line_from_file_stream proc~json_traverse json_core%json_traverse proc~json_check_all_for_duplicate_keys->proc~json_traverse proc~json_parse_end->none~throw_exception proc~pop_char json_core%pop_char proc~json_parse_end->proc~pop_char proc~json_value_destroy->none~destroy~3 proc~destroy_json_data destroy_json_data proc~json_value_destroy->proc~destroy_json_data proc~wrap_json_throw_exception->interface~to_unicode proc~wrap_json_throw_exception->none~throw_exception proc~json_traverse->none~throw_exception

Called by

proc~~wrap_initialize_json_file_from_string~~CalledByGraph proc~wrap_initialize_json_file_from_string wrap_initialize_json_file_from_string interface~json_file json_file interface~json_file->proc~wrap_initialize_json_file_from_string

Source Code

    function wrap_initialize_json_file_from_string(str,&
#include "json_initialize_dummy_arguments.inc"
                                                  ) result(file_object)

    implicit none

    type(json_file) :: file_object
    character(kind=CDK,len=*),intent(in) :: str  !! string to load JSON data from
#include "json_initialize_arguments.inc"

    file_object = initialize_json_file_from_string(&
                                  to_unicode(str),&
#include "json_initialize_dummy_arguments.inc"
                                                )

    end function wrap_initialize_json_file_from_string