initialize_json_file Function

private function initialize_json_file(p, 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, nullify_pointer) result(file_object)

Cast a json_value object as a json_file object. It also calls the initialize() method.

Note

initialize_json_core, json_initialize, initialize_json_core_in_file, initialize_json_file, initialize_json_file_v2, initialize_json_file_from_string, and initialize_json_file_from_string_v2 all have a similar interface.

Arguments

Type IntentOptional Attributes Name
type(json_value), optional, pointer :: p

json_value object to cast as a json_file object. This will be nullified.
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)
logical(kind=LK), intent(in), optional :: nullify_pointer

if True, then p will be nullified if present. (default is True). Normally, this should be done, because the json_file will destroy the pointer when the class goes out of scope (causing p to be a dangling pointer). However, if the intent is to use p in a json_file and then call nullify and continue to use p, then this should be set to False.

Return Value type(json_file)


Calls

proc~~initialize_json_file~~CallsGraph proc~initialize_json_file initialize_json_file none~initialize json_file%initialize proc~initialize_json_file->none~initialize 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~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~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~wrap_json_throw_exception->none~throw_exception interface~to_unicode to_unicode proc~wrap_json_throw_exception->interface~to_unicode 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

Called by

proc~~initialize_json_file~~CalledByGraph proc~initialize_json_file initialize_json_file interface~json_file json_file interface~json_file->proc~initialize_json_file

Source Code

    function initialize_json_file(p,&
#include "json_initialize_dummy_arguments.inc"
                                  , nullify_pointer &
                                  ) result(file_object)

    implicit none

    type(json_file) :: file_object
    type(json_value),pointer,optional :: p  !! `json_value` object to cast
                                            !! as a `json_file` object. This
                                            !! will be nullified.
#include "json_initialize_arguments.inc"
    logical(LK),intent(in),optional :: nullify_pointer !! if True, then `p` will be nullified
                                                       !! if present. (default is True). Normally,
                                                       !! this should be done, because the [[json_file]] will destroy
                                                       !! the pointer when the class goes out of scope (causing `p` to be
                                                       !! a dangling pointer). However, if the intent is to use `p` in
                                                       !! a [[json_file]] and then call [[json_file:nullify]] and continue
                                                       !! to use `p`, then this should be set to False.

    call file_object%initialize(&
#include "json_initialize_dummy_arguments.inc"
                               )

    if (present(p)) then
        file_object%p => p
        ! we have to nullify it to avoid
        ! a dangling pointer when the file
        ! goes out of scope
        if (present(nullify_pointer)) then
            if (nullify_pointer) nullify(p)
        else
            nullify(p)
        end if
    end if

    end function initialize_json_file