json_get_by_path_jsonpath_bracket Subroutine

private subroutine json_get_by_path_jsonpath_bracket(json, me, path, p, found, create_it, was_created)

Returns the json_value pointer given the path string, using the "JSON Pointer" path specification defined by the JSONPath "bracket-notation".

The first character $ is optional, and signifies the root of the structure. If it is not present, then the first key is taken to be in the me object.

Single or double quotes may be used.

Example

    type(json_core) :: json
    type(json_value),pointer :: dat,p
    logical :: found
    !...
    call json%initialize(path_mode=3)
    call json%get(dat,"$['store']['book'][1]['title']",p,found)

See also

Reference

Arguments

Type IntentOptional AttributesName
class(json_core), intent(inout) :: json
type(json_value), intent(in), pointer:: me

a JSON linked list

character(kind=CK,len=*), intent(in) :: path

path to the variable (using JSONPath "bracket-notation")

type(json_value), intent(out), pointer:: p

pointer to the variable specify by path

logical(kind=LK), intent(out), optional :: found

true if it was found

logical(kind=LK), intent(in), optional :: create_it

if a variable is not present in the path, then it is created. the leaf node is returned as a null json type and can be changed by the caller.

logical(kind=LK), intent(out), optional :: was_created

if create_it is true, this will be true if the variable was actually created. Otherwise it will be false.


Calls

proc~~json_get_by_path_jsonpath_bracket~~CallsGraph proc~json_get_by_path_jsonpath_bracket json_get_by_path_jsonpath_bracket proc~string_to_integer string_to_integer proc~json_get_by_path_jsonpath_bracket->proc~string_to_integer proc~json_value_create json_value_create proc~json_get_by_path_jsonpath_bracket->proc~json_value_create

Contents


Source Code

    subroutine json_get_by_path_jsonpath_bracket(json,me,path,p,found,create_it,was_created)

    implicit none

    class(json_core),intent(inout)       :: json
    type(json_value),pointer,intent(in)  :: me          !! a JSON linked list
    character(kind=CK,len=*),intent(in)  :: path        !! path to the variable
                                                        !! (using JSONPath
                                                        !! "bracket-notation")
    type(json_value),pointer,intent(out) :: p           !! pointer to the variable
                                                        !! specify by `path`
    logical(LK),intent(out),optional     :: found       !! true if it was found
    logical(LK),intent(in),optional      :: create_it   !! if a variable is not present
                                                        !! in the path, then it is created.
                                                        !! the leaf node is returned as
                                                        !! a `null` json type and can be
                                                        !! changed by the caller.
    logical(LK),intent(out),optional     :: was_created !! if `create_it` is true, this
                                                        !! will be true if the variable
                                                        !! was actually created. Otherwise
                                                        !! it will be false.

    character(kind=CK,len=:),allocatable :: token  !! a token in the path
                                                   !! (between the `['']` or
                                                   !! `[]` characters)
    integer(IK)              :: istart             !! location of current '['
                                                   !! character in the path
    integer(IK)              :: iend               !! location of current ']'
                                                   !! character in the path
    integer(IK)              :: ival               !! integer array index value
    logical(LK)              :: status_ok          !! error flag
    type(json_value),pointer :: tmp                !! temporary variable for
                                                   !! traversing the structure
    integer(IK)              :: i                  !! counter
    integer(IK)              :: ilen               !! length of `path` string
    logical(LK)              :: double_quotes      !! if the keys are enclosed in `"`,
                                                   !! rather than `'` tokens.
    logical(LK)              :: create             !! if the object is to be created
    logical(LK)              :: created            !! if `create` is true, then this will be
                                                   !! true if the leaf object had to be created
    integer(IK)              :: j                  !! counter of children when creating object

    !TODO instead of reallocating `token` all the time, just
    !     allocate a big size and keep track of the length,
    !     then just reallocate only if necessary.
    !     [would probably be inefficient if there was a very large token,
    !     and then a bunch of small ones... but for similarly-sized ones
    !     it should be way more efficient since it would avoid most
    !     reallocations.]

    nullify(p)

    if (.not. json%exception_thrown) then

        if (present(create_it)) then
            create = create_it
        else
            create = .false.
        end if

        p => me ! initialize
        created = .false.

        if (path==CK_'') then
            call json%throw_exception('Error in json_get_by_path_jsonpath_bracket: '//&
                                      'invalid path specification: '//trim(path))
        else

            if (path(1:1)==root .or. path(1:1)==start_array) then ! the first character must be
                                                                  ! a `$` (root) or a `[`
                                                                  ! (element of `me`)

                if (path(1:1)==root) then
                    ! go to the root
                    do while (associated (p%parent))
                        p => p%parent
                    end do
                    if (create) created = .false. ! should always exist
                end if

                !path length (don't need trailing spaces:)
                ilen = len_trim(path)

                if (ilen>1) then

                    istart = 2   ! initialize first '[' location index

                    do

                        if (istart>ilen) exit  ! finished

                        ! must be the next start bracket:
                        if (path(istart:istart) /= start_array) then
                            call json%throw_exception(&
                                    'Error in json_get_by_path_jsonpath_bracket: '//&
                                    'expecting "[", found: "'//trim(path(istart:istart))//&
                                    '" in path: '//trim(path))
                            exit
                        end if

                        ! get the next token by checking:
                        !
                        ! * [''] -- is the token after istart a quote?
                        !           if so, then search for the next `']`
                        !
                        ! * [1] -- if not, then maybe it is a number,
                        !          so search for the next `]`

                        ! verify length of remaining string
                        if (istart+2<=ilen) then

                            double_quotes = path(istart+1:istart+1) == quotation_mark   ! ["

                            if (double_quotes .or. path(istart+1:istart+1)==single_quote) then  ! ['

                                ! it might be a key value: ['abc']

                                istart = istart + 1 ! move counter to ' index
                                if (double_quotes) then
                                    iend = istart + index(path(istart+1:ilen),&
                                           quotation_mark//end_array)  ! "]
                                else
                                    iend = istart + index(path(istart+1:ilen),&
                                           single_quote//end_array)  ! ']
                                end if
                                if (iend>istart) then

                                    !     istart  iend
                                    !       |       |
                                    ! ['p']['abcdefg']

                                    if (iend>istart+1) then
                                        token = path(istart+1:iend-1)
                                    else
                                        token = CK_''  ! blank string
                                    end if
                                    ! remove trailing spaces in
                                    ! the token here if necessary:
                                    if (.not. json%trailing_spaces_significant) &
                                        token = trim(token)

                                    if (create) then
                                        ! have a token, create it if necessary

                                        ! we need to convert it into an object here
                                        ! (e.g., if p was also just created)
                                        ! and destroy its data to prevent a memory leak
                                        call json%convert(p,json_object)

                                        ! don't want to throw exceptions in this case
                                        call json%get_child(p,token,tmp,status_ok)
                                        if (.not. status_ok) then
                                            ! have to create this child
                                            ! [make it a null since we don't
                                            ! know what it is yet]
                                            call json_value_create(tmp)
                                            call json%to_null(tmp,token)
                                            call json%add(p,tmp)
                                            status_ok = .true.
                                            created = .true.
                                        else
                                            ! it was already there.
                                            created = .false.
                                        end if
                                    else
                                        ! have a token, see if it is valid:
                                        call json%get_child(p,token,tmp,status_ok)
                                    end if

                                    if (status_ok) then
                                        ! it was found
                                        p => tmp
                                    else
                                        call json%throw_exception(&
                                                'Error in json_get_by_path_jsonpath_bracket: '//&
                                                'invalid token found: "'//token//&
                                                '" in path: '//trim(path))
                                        exit
                                    end if
                                    iend = iend + 1 ! move counter to ] index
                                else
                                    call json%throw_exception(&
                                            'Error in json_get_by_path_jsonpath_bracket: '//&
                                            'invalid path: '//trim(path))
                                    exit
                                end if

                            else

                                ! it might be an integer value: [123]

                                iend = istart + index(path(istart+1:ilen),end_array)   ! ]
                                if (iend>istart+1) then

                                    ! this should be an integer:
                                    token = path(istart+1:iend-1)

                                    ! verify that there are no spaces or other
                                    ! characters in the string:
                                    status_ok = .true.
                                    do i=1,len(token)
                                        ! It must only contain (0..9) characters
                                        ! (it must be unsigned)
                                        if (scan(token(i:i),CK_'0123456789')<1) then
                                            status_ok = .false.
                                            exit
                                        end if
                                    end do
                                    if (status_ok) then
                                        call string_to_integer(token,ival,status_ok)
                                        if (status_ok) status_ok = ival>0  ! assuming 1-based array indices
                                    end if

                                    if (status_ok) then

                                        ! have a valid integer to use as an index
                                        ! see if this element is really there:
                                        call json%get_child(p,ival,tmp,status_ok)

                                        if (create .and. .not. status_ok) then

                                            ! have to create it:

                                            if (.not.(p%var_type==json_object .or. p%var_type==json_array)) then
                                                ! we need to convert it into an array here
                                                ! (e.g., if p was also just created)
                                                ! and destroy its data to prevent a memory leak
                                                call json%convert(p,json_array)
                                            end if

                                            ! have to create this element
                                            ! [make it a null]
                                            ! (and any missing ones before it)
                                            do j = 1, ival
                                                nullify(tmp)
                                                call json%get_child(p, j, tmp, status_ok)
                                                if (.not. status_ok) then
                                                    call json_value_create(tmp)
                                                    call json%to_null(tmp)  ! array element doesn't need a name
                                                    call json%add(p,tmp)
                                                    if (j==ival) created = .true.
                                                else
                                                    if (j==ival) created = .false.
                                                end if
                                            end do
                                            status_ok = .true.

                                        else
                                            created = .false.
                                        end if

                                        if (status_ok) then
                                            ! found it
                                            p => tmp
                                        else
                                            ! not found
                                            call json%throw_exception(&
                                                    'Error in json_get_by_path_jsonpath_bracket: '//&
                                                    'invalid array index found: "'//token//&
                                                    '" in path: '//trim(path))
                                            exit
                                        end if
                                    else
                                        call json%throw_exception(&
                                                'Error in json_get_by_path_jsonpath_bracket: '//&
                                                'invalid token: "'//token//&
                                                '" in path: '//trim(path))
                                        exit
                                    end if

                                else
                                    call json%throw_exception(&
                                            'Error in json_get_by_path_jsonpath_bracket: '//&
                                            'invalid path: '//trim(path))
                                    exit
                                end if

                            end if

                        else
                            call json%throw_exception(&
                                    'Error in json_get_by_path_jsonpath_bracket: '//&
                                    'invalid path: '//trim(path))
                            exit
                        end if

                        ! set up for next token:
                        istart = iend + 1

                    end do

                end if

            else
                call json%throw_exception(&
                        'Error in json_get_by_path_jsonpath_bracket: '//&
                        'expecting "'//root//'", found: "'//path(1:1)//&
                        '" in path: '//trim(path))
            end if

        end if

        if (json%exception_thrown) then
            nullify(p)
            if (present(found)) then
                found = .false.
                call json%clear_exceptions()
            end if
        else
            if (present(found)) found = .true.
        end if

        ! if it had to be created:
        if (present(was_created)) was_created = created

    else
        if (present(found)) found = .false.
        if (present(was_created)) was_created = .false.
    end if

    end subroutine json_get_by_path_jsonpath_bracket