collections.F90

Go to the documentation of this file.

 
module collections_mod
  use datadefn_mod, only : string_length, default_precision
  use conversions_mod, only : conv_to_generic, generic_to_double_real, conv_to_integer, conv_to_string, conv_to_logical, &
       conv_single_real_to_double, conv_to_real
  use logging_mod, only : log_error, log_log
  implicit none
 
#ifndef TEST_MODE
  private
#endif
 
  integer, parameter, private :: hash_size  = 4993
 
  type listnode_type
     type(listnode_type), pointer :: next=>null(),& 
          prev=>null() 
     class(*), pointer :: data => null()
     logical :: memory_allocation_automatic
  end type listnode_type
 
  type mapnode_type
     logical :: memory_allocation_automatic
     character(len=STRING_LENGTH) :: key
     class(*), pointer :: value => null()
  end type mapnode_type
 
  type setnode_type
     character(len=STRING_LENGTH) :: key
  end type setnode_type
 
  type, public :: mapentry_type
     character(len=STRING_LENGTH) :: key
     class(*), pointer :: value => null()
  end type mapentry_type  
 
  type, public :: iterator_type
     type(listnode_type), pointer :: next_item
     type(list_type), dimension(:), pointer :: hash_structure
     integer :: hash_ptr
  end type iterator_type
 
  type, public :: list_type
     type(listnode_type), pointer, private :: head=>null(),& 
          tail=>null()  
     integer, private :: size=0
  end type list_type
 
  type, public :: queue_type
     type(list_type), private :: queue_ds
  end type queue_type
 
  type, public :: stack_type
     type(list_type), private :: stack_ds
  end type stack_type
 
  type, public :: map_type
     type(list_type), private :: map_ds
  end type map_type
 
  type, public :: hashmap_type
     type(list_type), pointer, dimension(:), private :: map_ds => null()
     integer, private :: size=0
  end type hashmap_type
 
  type, public :: hashset_type
     type(list_type), pointer, dimension(:), private :: set_ds => null()
     integer, private :: size=0
  end type hashset_type  
 
  interface c_push_generic
     module procedure stack_push_generic, queue_push_generic
  end interface c_push_generic
 
  interface c_push_integer
     module procedure stack_push_int, queue_push_int
  end interface c_push_integer
 
  interface c_push_string
     module procedure stack_push_string, queue_push_string
  end interface c_push_string
 
  interface c_push_real
     module procedure stack_push_real, queue_push_real
  end interface c_push_real
 
  interface c_push_logical
     module procedure stack_push_logical, queue_push_logical
  end interface c_push_logical
 
  interface c_pop_generic
     module procedure stack_pop_generic, queue_pop_generic
  end interface c_pop_generic
 
  interface c_pop_integer
     module procedure stack_pop_int, queue_pop_int
  end interface c_pop_integer
 
  interface c_pop_string
     module procedure stack_pop_string, queue_pop_string
  end interface c_pop_string
 
  interface c_pop_real
     module procedure stack_pop_real, queue_pop_real
  end interface c_pop_real
 
  interface c_pop_logical
     module procedure stack_pop_logical, queue_pop_logical
  end interface c_pop_logical
 
  interface c_add_generic
     module procedure list_add_generic
  end interface c_add_generic
 
  interface c_add_integer
     module procedure list_add_int
  end interface c_add_integer
 
  interface c_add_string
     module procedure list_add_string, hashset_add
  end interface c_add_string
 
  interface c_add_real
     module procedure list_add_real
  end interface c_add_real
 
  interface c_add_logical
     module procedure list_add_logical
  end interface c_add_logical
 
  interface c_insert_generic
     module procedure list_insert_generic
  end interface c_insert_generic
 
  interface c_insert_integer
     module procedure list_insert_int
  end interface c_insert_integer
 
  interface c_insert_string
     module procedure list_insert_string
  end interface c_insert_string
 
  interface c_insert_real
     module procedure list_insert_real
  end interface c_insert_real
 
  interface c_insert_logical
     module procedure list_insert_logical
  end interface c_insert_logical
 
  interface c_put_generic
     module procedure map_put_generic, hashmap_put_generic
  end interface c_put_generic
 
  interface c_put_integer
     module procedure map_put_int, hashmap_put_int
  end interface c_put_integer
 
  interface c_put_string
     module procedure map_put_string, hashmap_put_string
  end interface c_put_string
 
  interface c_put_real
     module procedure map_put_real, hashmap_put_real
  end interface c_put_real
 
  interface c_put_logical
     module procedure map_put_logical, hashmap_put_logical
  end interface c_put_logical
 
  interface c_get_generic
     module procedure list_get_generic, stack_get_generic, queue_get_generic, map_get_generic, hashmap_get_generic, &
          mapentry_get_generic
  end interface c_get_generic
 
  interface c_get_integer
     module procedure list_get_int, stack_get_int, queue_get_int, map_get_int, hashmap_get_int, mapentry_get_int
  end interface c_get_integer
 
  interface c_get_string
     module procedure list_get_string, stack_get_string, queue_get_string, map_get_string, hashmap_get_string, &
          hashset_get_string, mapentry_get_string
  end interface c_get_string
 
  interface c_get_real
     module procedure list_get_real, stack_get_real, queue_get_real, map_get_real, hashmap_get_real, mapentry_get_real
  end interface c_get_real
 
  interface c_get_logical
     module procedure list_get_logical, stack_get_logical, queue_get_logical, map_get_logical, &
          hashmap_get_logical, mapentry_get_logical
  end interface c_get_logical
 
  interface c_remove
     module procedure list_remove, map_remove, hashmap_remove, hashset_remove
  end interface c_remove
 
  interface c_size
     module procedure list_size, stack_size, queue_size, map_size, hashmap_size, hashset_size
  end interface c_size
 
  interface c_is_empty
     module procedure list_is_empty, stack_is_empty, queue_is_empty, map_is_empty, hashmap_is_empty, hashset_is_empty
  end interface c_is_empty
 
  interface c_contains
     module procedure map_contains_key, hashmap_contains_key, hashset_contains
  end interface c_contains
 
  interface c_key_at
     module procedure map_key_at, hashmap_key_at
  end interface c_key_at
 
  interface c_generic_at
     module procedure map_generic_at, hashmap_generic_at
  end interface c_generic_at
 
  interface c_integer_at
     module procedure map_integer_at, hashmap_integer_at
  end interface c_integer_at
 
  interface c_string_at
     module procedure map_string_at, hashmap_string_at
  end interface c_string_at
 
  interface c_real_at
     module procedure map_real_at, hashmap_real_at
  end interface c_real_at
 
  interface c_logical_at
     module procedure map_logical_at, hashmap_logical_at
  end interface c_logical_at
 
  interface c_generic_entry_at
     module procedure map_generic_entry_at, hashmap_generic_entry_at
  end interface c_generic_entry_at
 
  interface c_integer_entry_at
     module procedure map_integer_entry_at, hashmap_integer_entry_at
  end interface c_integer_entry_at
 
  interface c_string_entry_at
     module procedure map_string_entry_at, hashmap_string_entry_at
  end interface c_string_entry_at
 
  interface c_real_entry_at
     module procedure map_real_entry_at, hashmap_real_entry_at
  end interface c_real_entry_at
 
  interface c_logical_entry_at
     module procedure map_logical_entry_at, hashmap_logical_entry_at
  end interface c_logical_entry_at
 
  interface c_free
     module procedure list_free, stack_free, queue_free, map_free, hashmap_free, hashset_free
  end interface c_free
 
  interface c_get_iterator
     module procedure list_get_iterator, map_get_iterator, hashmap_get_iterator, hashset_get_iterator, stack_get_iterator, &
          queue_get_iterator
  end interface c_get_iterator  
 
  interface c_has_next
     module procedure iteratior_has_next
  end interface c_has_next
  
  interface c_next_integer
     module procedure iterator_get_next_integer
  end interface c_next_integer
 
  interface c_next_string
     module procedure iterator_get_next_string
  end interface c_next_string
 
  interface c_next_real
     module procedure iterator_get_next_real
  end interface c_next_real
 
  interface c_next_logical
     module procedure iterator_get_next_logical
  end interface c_next_logical
 
  interface c_next_mapentry
     module procedure iterator_get_next_mapentry
  end interface c_next_mapentry
 
  interface c_next_generic
     module procedure iterator_get_next_generic
  end interface c_next_generic
 
  ! Explicit public interfaces and data items
  public c_push_generic, c_push_integer, c_push_string, c_push_real, c_push_logical, c_pop_generic, c_pop_integer, c_pop_real, &
       c_pop_string, c_pop_logical, c_add_generic, c_add_integer, c_add_string, c_add_real, c_add_logical, c_insert_generic, &
       c_insert_integer, c_insert_string, c_insert_real, c_insert_logical, c_put_generic, c_put_integer, c_put_string, &
       c_put_real, c_put_logical, c_get_generic, c_get_integer, c_get_string, c_get_real, c_get_logical, c_remove, c_size, &
       c_is_empty, c_contains, c_key_at, c_generic_at, c_integer_at, c_string_at, c_real_at, c_logical_at, c_generic_entry_at, &
       c_integer_entry_at, c_string_entry_at, c_real_entry_at, c_logical_entry_at, c_free, c_get_iterator, c_has_next, &
       c_next_integer, c_next_string, c_next_real, c_next_logical, c_next_mapentry, c_next_generic
contains
 
  type(iterator_type) function map_get_iterator(specificmap)
    type(map_type), intent(inout) :: specificmap
 
    map_get_iterator%next_item=>specificmap%map_ds%head
    map_get_iterator%hash_structure=>null()
    map_get_iterator%hash_ptr=0
  end function map_get_iterator 
 
  subroutine map_put_int(specificmap, key, int_data)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: int_data
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(int_data, .true.)
    call map_put_generic(specificmap, key, generic, .true.)
  end subroutine map_put_int
 
  subroutine map_put_string(specificmap, key, str_data)
    type(map_type), intent(inout) :: specificmap
    character(len=STRING_LENGTH), intent(in) :: str_data
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(str_data, .true.)
    call map_put_generic(specificmap, key, generic, .true.)
  end subroutine map_put_string
  
  subroutine map_put_real(specificmap, key, real_data)
    type(map_type), intent(inout) :: specificmap
    real(kind=default_precision), intent(in) :: real_data
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(real_data, .true.)
    call map_put_generic(specificmap, key, generic, .true.)
  end subroutine map_put_real
 
  subroutine map_put_logical(specificmap, key, logical_data)
    type(map_type), intent(inout) :: specificmap
    logical, intent(in) :: logical_data
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(logical_data, .true.)
    call map_put_generic(specificmap, key, generic, .true.)
  end subroutine map_put_logical
  
  subroutine map_put_generic(specificmap, key, data, memory_allocation_automatic)
    type(map_type), intent(inout) :: specificmap
    class(*), pointer, intent(in) :: data
    character(len=*), intent(in) :: key
    logical, intent(in) :: memory_allocation_automatic
 
    class(*), pointer :: raw_map_node, generic_map_node
    type(mapnode_type), pointer :: newmapnode
 
    ! Test to see if key already exists in the map
    raw_map_node=>map_getnode(specificmap, key)
 
    if (associated(raw_map_node)) then
      select type(raw_map_node)
      type is (mapnode_type)
        raw_map_node%value => data
      end select
    else
      allocate(newmapnode)
      newmapnode%value => data
      newmapnode%key = key
      newmapnode%memory_allocation_automatic=memory_allocation_automatic
      ! Clone and deallocate the newmapnode - this keeps GNU happy with passing the correct pointer and Cray
      ! doesn't link the generic pointer just pointing to the data structure hence we clone it
      allocate(generic_map_node, source=newmapnode)
      deallocate(newmapnode)
      call list_add_generic(specificmap%map_ds, generic_map_node, .false.)
    end if
  end subroutine map_put_generic
 
  logical function map_contains_key(specificmap, key)
    type(map_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
 
    integer :: key_location
    class(*), pointer :: raw_map_node
 
    raw_map_node => map_getnode(specificmap, key, key_location)
    map_contains_key = key_location .gt. 0
  end function map_contains_key
 
  character(len=STRING_LENGTH) function map_key_at(specificmap, i)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
 
    class(*), pointer :: raw_map_node
    integer :: the_map_size
 
    the_map_size = map_size(specificmap)
    if (i .le. the_map_size) then
      raw_map_node=>list_get_generic(specificmap%map_ds, i)
      if (associated(raw_map_node)) then
        select type(raw_map_node)
        type is(mapnode_type)
          map_key_at = raw_map_node%key
        end select
        return
      end if
    end if
    map_key_at=""
  end function map_key_at
 
  function map_integer_at(specificmap, i)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    integer :: map_integer_at
 
    class(*), pointer :: generic
 
    generic=>map_generic_at(specificmap, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not find integer at "//trim(conv_to_string(i)))
    map_integer_at=conv_to_integer(generic, .false.)
  end function map_integer_at
 
  function map_string_at(specificmap, i)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=STRING_LENGTH) :: map_string_at
 
    class(*), pointer :: generic
 
    generic=>map_generic_at(specificmap, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not find string at "//trim(conv_to_string(i)))
    map_string_at=conv_to_string(generic, .false., string_length)
  end function map_string_at
 
  function map_real_at(specificmap, i)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    real(kind=default_precision) :: map_real_at
 
    class(*), pointer :: generic
 
    generic=>map_generic_at(specificmap, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not find real at "//trim(conv_to_string(i)))
    select type(vr=>generic)
    type is (real(kind=default_precision))
      map_real_at=vr
    type is (real)
      map_real_at=conv_single_real_to_double(vr)
    type is (integer)  
      map_real_at=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function map_real_at
 
  function map_logical_at(specificmap, i)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    logical :: map_logical_at
 
    class(*), pointer :: generic
 
    generic=>map_generic_at(specificmap, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not find logical at "//trim(conv_to_string(i)))
    map_logical_at=conv_to_logical(generic, .false.)
  end function map_logical_at
 
  function map_generic_at(specificmap, i)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
 
    class(*), pointer :: raw_map_node, map_generic_at
    integer :: the_map_size
 
    the_map_size = map_size(specificmap)
    if (i .le. the_map_size) then
      raw_map_node=>list_get_generic(specificmap%map_ds, i)
      if (associated(raw_map_node)) then
        select type(raw_map_node)
        type is (mapnode_type)
          map_generic_at => raw_map_node%value
        end select
        return
      end if
    end if
    map_generic_at=>null()
  end function map_generic_at
 
  logical function map_integer_entry_at(specificmap, i, key, int_val)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    integer, intent(out) :: int_val
 
    class(*), pointer :: generic
 
    map_integer_entry_at=map_generic_entry_at(specificmap, i, key, generic)
    if (.not. associated(generic)) call log_log(log_error, "Can not find integer entry with key '"//trim(key)//"'")
    int_val=conv_to_integer(generic, .false.)
  end function map_integer_entry_at
 
  logical function map_string_entry_at(specificmap, i, key, str_val)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    character(len=STRING_LENGTH), intent(out) :: str_val
 
    class(*), pointer :: generic
 
    map_string_entry_at=map_generic_entry_at(specificmap, i, key, generic)
    if (.not. associated(generic)) call log_log(log_error, "Can not find string entry with key '"//trim(key)//"'")
    str_val=conv_to_string(generic, .false., string_length)
  end function map_string_entry_at
 
  logical function map_real_entry_at(specificmap, i, key, real_val)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    real(kind=default_precision), intent(out) :: real_val
 
    class(*), pointer :: generic
 
    map_real_entry_at=map_generic_entry_at(specificmap, i, key, generic)
    if (.not. associated(generic)) call log_log(log_error, "Can not find real entry with key '"//trim(key)//"'")
    select type(vr=>generic)
    type is (real(kind=default_precision))
      real_val=vr
    type is (real)
      real_val=conv_single_real_to_double(vr)
    type is (integer)  
      real_val=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function map_real_entry_at
 
  logical function map_logical_entry_at(specificmap, i, key, logical_val)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    logical, intent(out) :: logical_val
 
    class(*), pointer :: generic
 
    map_logical_entry_at=map_generic_entry_at(specificmap, i, key, generic)
    if (.not. associated(generic)) call log_log(log_error, "Can not find logical entry with key '"//trim(key)//"'")
    logical_val=conv_to_logical(generic, .false.)
  end function map_logical_entry_at  
 
  logical function map_generic_entry_at(specificmap, i, key, val)
    type(map_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    class(*), pointer, intent(out) :: val
 
    class(*), pointer :: raw_map_node
    integer :: the_map_size
 
    the_map_size = map_size(specificmap)
    if (i .le. the_map_size) then
      raw_map_node=>list_get_generic(specificmap%map_ds, i)
      if (associated(raw_map_node)) then
        select type(raw_map_node)
        type is (mapnode_type)
          val=>raw_map_node%value
          key=raw_map_node%key          
        end select
        map_generic_entry_at=.true.
        return
      end if
    end if
    val=>null()
    map_generic_entry_at=.false.
  end function map_generic_entry_at
 
  subroutine map_remove(specificmap, key)
    type(map_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
 
    integer :: key_location
    class(*), pointer :: raw_map_node
 
    raw_map_node=>map_getnode(specificmap, key, key_location)
 
    if (key_location .gt. 0) then
      select type (raw_map_node)
      type is (mapnode_type)
        if (raw_map_node%memory_allocation_automatic) then
          if (associated(raw_map_node%value)) deallocate(raw_map_node%value)
        end if
        deallocate(raw_map_node)
      end select
      call list_remove(specificmap%map_ds, key_location)      
    end if
  end subroutine map_remove
 
  function map_get_int(specificmap, key)
    type(map_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    integer :: map_get_int
 
    class(*), pointer :: generic
 
    generic=>map_get_generic(specificmap, key)
    if (.not. associated(generic)) call log_log(log_error, "Can not find integer entry with key '"//trim(key)//"'")
    map_get_int=conv_to_integer(generic, .false.)
  end function map_get_int
 
  function map_get_string(specificmap, key)
    type(map_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    character(len=STRING_LENGTH) :: map_get_string
 
    class(*), pointer :: generic
 
    generic=>map_get_generic(specificmap, key)
    if (.not. associated(generic)) call log_log(log_error, "Can not find string entry with key '"//trim(key)//"'")
    map_get_string=conv_to_string(generic, .false., string_length)
  end function map_get_string
 
  function map_get_real(specificmap, key)
    type(map_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    real(kind=default_precision) :: map_get_real
 
    class(*), pointer :: generic
 
    generic=>map_get_generic(specificmap, key)
    if (.not. associated(generic)) call log_log(log_error, "Can not find real entry with key '"//trim(key)//"'")
    select type(vr=>generic)
    type is (real(kind=default_precision))
      map_get_real=vr
    type is (real)
      map_get_real=conv_single_real_to_double(vr)
    type is (integer)  
      map_get_real=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function map_get_real
 
  function map_get_logical(specificmap, key)
    type(map_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    logical :: map_get_logical
 
    class(*), pointer :: generic
 
    generic=>map_get_generic(specificmap, key)
    if (.not. associated(generic)) call log_log(log_error, "Can not find logical entry with key '"//trim(key)//"'")
    map_get_logical=conv_to_logical(generic, .false.)
  end function map_get_logical
 
  function map_get_generic(specificmap, key)
    type(map_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    class(*), pointer :: map_get_generic, raw_map_node
 
    raw_map_node=>map_getnode(specificmap, key)
    if (associated(raw_map_node)) then
      select type (raw_map_node)
      type is (mapnode_type)
        map_get_generic => raw_map_node%value
      end select
      return
    end if
    map_get_generic => null()
  end function map_get_generic
 
  function map_getnode(specificmap, key, foundindex)
    type(map_type), intent(inout) :: specificmap
    integer, intent(out), optional :: foundindex
    character(len=*), intent(in) :: key
    class(*), pointer :: raw_data, map_getnode
 
    integer :: i
    type(listnode_type), pointer :: node
 
    i=1
    node=>specificmap%map_ds%head
    if (associated(node)) then
      do while(1==1)
        raw_data=>node%data
        if (associated(raw_data)) then
          select type (raw_data)
          type is (mapnode_type)
            if (raw_data%key .eq. key) then
              map_getnode=>raw_data
              if (present(foundindex)) foundindex=i
              return
            end if
          end select
        end if
        node=>node%next
        i=i+1
        if (.not. associated(node)) exit
      end do
    end if
    map_getnode => null()
    if(present(foundindex)) foundindex = 0
  end function map_getnode
 
  integer function map_size(specificmap)
    type(map_type), intent(inout) :: specificmap
 
    map_size = list_size(specificmap%map_ds)
  end function map_size
 
  logical function map_is_empty(specificmap)
    type(map_type), intent(inout) :: specificmap
 
    map_is_empty = list_is_empty(specificmap%map_ds)
  end function map_is_empty
 
  subroutine map_free(specificmap)
    type(map_type), intent(inout) :: specificmap
 
    type(listnode_type), pointer :: node, previousnode
 
    node=>specificmap%map_ds%head
    previousnode=>null()
 
    if (associated(node)) then
      do while(1==1)
        previousnode=>node
        node=>node%next
        if (associated(previousnode%data)) then
          select type (n=>previousnode%data)
          type is (mapnode_type)
            if (n%memory_allocation_automatic) then
              if (associated(n%value)) deallocate(n%value)
            end if
          end select
          deallocate(previousnode%data) ! Free the mapnode data structure
        end if
        deallocate(previousnode)
        if (.not. associated(node)) exit
      end do
    end if
 
    specificmap%map_ds%tail=>null()
    specificmap%map_ds%head=>null()
    specificmap%map_ds%size=0
  end subroutine map_free
 
  type(iterator_type) function hashmap_get_iterator(specificmap)
    type(hashmap_type), intent(inout) :: specificmap
 
    integer :: i
 
    hashmap_get_iterator%next_item=>null()
    if (associated(specificmap%map_ds)) then
      hashmap_get_iterator%hash_structure=>specificmap%map_ds
 
      do i=1, size(specificmap%map_ds)
        if (specificmap%map_ds(i)%size .gt. 0) then
          hashmap_get_iterator%next_item=>specificmap%map_ds(i)%head
          exit
        end if
      end do
      hashmap_get_iterator%hash_ptr=i+1
    end if
  end function hashmap_get_iterator 
 
  subroutine hashmap_put_int(specificmap, key, int_data)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: int_data
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(int_data, .true.)
    call hashmap_put_generic(specificmap, key, generic, .true.)
  end subroutine hashmap_put_int
 
  subroutine hashmap_put_string(specificmap, key, str_data)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=STRING_LENGTH), intent(in) :: str_data
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(str_data, .true.)
    call hashmap_put_generic(specificmap, key, generic, .true.)
  end subroutine hashmap_put_string
 
  subroutine hashmap_put_real(specificmap, key, real_data)
    type(hashmap_type), intent(inout) :: specificmap
    real(kind=default_precision), intent(in) :: real_data
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(real_data, .true.)
    call hashmap_put_generic(specificmap, key, generic, .true.)
  end subroutine hashmap_put_real
 
  subroutine hashmap_put_logical(specificmap, key, logical_data)
    type(hashmap_type), intent(inout) :: specificmap
    logical, intent(in) :: logical_data
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(logical_data, .true.)
    call hashmap_put_generic(specificmap, key, generic, .true.)
  end subroutine hashmap_put_logical
 
  subroutine hashmap_put_generic(specificmap, key, data, memory_allocation_automatic)
    type(hashmap_type), intent(inout) :: specificmap
    class(*), pointer, intent(in) :: data
    character(len=*), intent(in) :: key
    logical, intent(in) :: memory_allocation_automatic
 
    class(*), pointer :: raw_map_node, generic_map_node
    type(mapnode_type), pointer :: newmapnode
 
    if (.not. associated(specificmap%map_ds)) allocate(specificmap%map_ds(hash_size))
 
    ! Test to see if key already exists in the map
    raw_map_node=>hashmap_getnode(specificmap, key)
 
    if (associated(raw_map_node)) then
      select type(raw_map_node)
      type is (mapnode_type)
        raw_map_node%value=>data
      end select
    else
      allocate(newmapnode)
      newmapnode%value=>data
      newmapnode%key=key
      newmapnode%memory_allocation_automatic=memory_allocation_automatic
      ! Clone and deallocate the newmapnode - this keeps GNU happy with passing the correct pointer and Cray
      ! doesn't link the generic pointer just pointing to the data structure hence we clone it
      allocate(generic_map_node, source=newmapnode)
      deallocate(newmapnode)
      call list_add_generic(specificmap%map_ds(get_hashkey(key)), generic_map_node, .false.)
      specificmap%size=specificmap%size+1
    end if
  end subroutine hashmap_put_generic
 
  logical function hashmap_contains_key(specificmap, key)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
 
    class(*), pointer :: raw_map_node
 
    raw_map_node=>hashmap_getnode(specificmap, key)
    hashmap_contains_key=associated(raw_map_node)
  end function hashmap_contains_key
 
  character(len=STRING_LENGTH) function hashmap_key_at(specificmap, i)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
 
    class(*), pointer :: raw_map_node    
 
    raw_map_node=>hashmap_getnode_atindex(specificmap, i)
    if (associated(raw_map_node)) then
      select type(raw_map_node)
      type is(mapnode_type)
        hashmap_key_at = raw_map_node%key
      end select
      return
    else
      hashmap_key_at=""
    end if
  end function hashmap_key_at
 
  function hashmap_integer_at(specificmap, i)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    integer :: hashmap_integer_at
 
    class(*), pointer :: generic
 
    generic=>hashmap_generic_at(specificmap, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not find integer at "//trim(conv_to_string(i)))
    hashmap_integer_at=conv_to_integer(generic, .false.)
  end function hashmap_integer_at
 
  function hashmap_string_at(specificmap, i)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=STRING_LENGTH) :: hashmap_string_at
 
    class(*), pointer :: generic
 
    generic=>hashmap_generic_at(specificmap, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not find string at "//trim(conv_to_string(i)))
    hashmap_string_at=conv_to_string(generic, .false., string_length)
  end function hashmap_string_at
 
  function hashmap_real_at(specificmap, i)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    integer :: hashmap_real_at
 
    class(*), pointer :: generic
 
    generic=>hashmap_generic_at(specificmap, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not find real at "//trim(conv_to_string(i)))
    select type(vr=>generic)
    type is (real(kind=default_precision))
      hashmap_real_at=vr
    type is (real)
      hashmap_real_at=conv_single_real_to_double(vr)
    type is (integer)  
      hashmap_real_at=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function hashmap_real_at
 
  function hashmap_logical_at(specificmap, i)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    logical :: hashmap_logical_at
 
    class(*), pointer :: generic
 
    generic=>hashmap_generic_at(specificmap, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not find logical at "//trim(conv_to_string(i)))
    hashmap_logical_at=conv_to_logical(generic, .false.)
  end function hashmap_logical_at
 
  function hashmap_generic_at(specificmap, i)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
 
    class(*), pointer :: raw_map_node, hashmap_generic_at    
 
    raw_map_node=>hashmap_getnode_atindex(specificmap, i)
    if (associated(raw_map_node)) then
      select type(raw_map_node)
      type is (mapnode_type)
        hashmap_generic_at=>raw_map_node%value
      end select
      return
    else
      hashmap_generic_at=>null()
    end if
  end function hashmap_generic_at
 
  logical function hashmap_integer_entry_at(specificmap, i, key, int_val)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    integer, intent(out) :: int_val
 
    class(*), pointer :: generic
 
    hashmap_integer_entry_at=hashmap_generic_entry_at(specificmap, i, key, generic)
    if (.not. associated(generic)) call log_log(log_error, "Can not find integer entry with key '"//trim(key)//"'")
    int_val=conv_to_integer(generic, .false.)
  end function hashmap_integer_entry_at
 
  logical function hashmap_string_entry_at(specificmap, i, key, str_val)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    character(len=STRING_LENGTH), intent(out) :: str_val
 
    class(*), pointer :: generic
 
    hashmap_string_entry_at=hashmap_generic_entry_at(specificmap, i, key, generic)
    if (.not. associated(generic)) call log_log(log_error, "Can not find string entry with key '"//trim(key)//"'")
    str_val=conv_to_string(generic, .false., string_length)
  end function hashmap_string_entry_at
 
  logical function hashmap_real_entry_at(specificmap, i, key, real_val)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    real(kind=default_precision), intent(out) :: real_val
 
    class(*), pointer :: generic
 
    hashmap_real_entry_at=hashmap_generic_entry_at(specificmap, i, key, generic)
    if (.not. associated(generic)) call log_log(log_error, "Can not find real entry with key '"//trim(key)//"'")
    select type(vr=>generic)
    type is (real(kind=default_precision))
      real_val=vr
    type is (real)
      real_val=conv_single_real_to_double(vr)
    type is (integer)  
      real_val=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function hashmap_real_entry_at
 
  logical function hashmap_logical_entry_at(specificmap, i, key, logical_val)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    logical, intent(out) :: logical_val
 
    class(*), pointer :: generic
 
    hashmap_logical_entry_at=hashmap_generic_entry_at(specificmap, i, key, generic)
    if (.not. associated(generic)) call log_log(log_error, "Can not find logical entry with key '"//trim(key)//"'")
    logical_val=conv_to_logical(generic, .false.)
  end function hashmap_logical_entry_at  
 
  logical function hashmap_generic_entry_at(specificmap, i, key, val)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: i
    character(len=*), intent(out) :: key
    class(*), pointer, intent(out) :: val
 
    class(*), pointer :: raw_map_node
 
    raw_map_node => hashmap_getnode_atindex(specificmap, i)
    if (associated(raw_map_node)) then
      select type(raw_map_node)
      type is (mapnode_type)
        val=>raw_map_node%value
        key=raw_map_node%key          
      end select
      hashmap_generic_entry_at=.true.
      return
    end if
    val=>null()
    hashmap_generic_entry_at=.false.
  end function hashmap_generic_entry_at
 
  subroutine hashmap_remove(specificmap, key)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
 
    integer :: key_location
    class(*), pointer :: raw_map_node
 
    raw_map_node=>hashmap_getnode(specificmap, key, key_location)
    
    if (key_location .gt. 0) then
      select type (raw_map_node)
      type is (mapnode_type)
        if (raw_map_node%memory_allocation_automatic) then
          if (associated(raw_map_node%value)) deallocate(raw_map_node%value)
        end if
        deallocate(raw_map_node)
      end select
      call list_remove(specificmap%map_ds(get_hashkey(key)), key_location)      
      specificmap%size=specificmap%size-1
    end if
  end subroutine hashmap_remove
 
  function hashmap_get_int(specificmap, key)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    integer :: hashmap_get_int
 
    class(*), pointer :: generic
 
    generic=>hashmap_get_generic(specificmap, key)
    if (.not. associated(generic)) call log_log(log_error, "Can not find integer entry with key '"//trim(key)//"'")
    hashmap_get_int=conv_to_integer(generic, .false.)
  end function hashmap_get_int
 
  function hashmap_get_string(specificmap, key)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    character(len=STRING_LENGTH) :: hashmap_get_string
 
    class(*), pointer :: generic
 
    generic=>hashmap_get_generic(specificmap, key)
    if (.not. associated(generic)) call log_log(log_error, "Can not find string entry with key '"//trim(key)//"'")
    hashmap_get_string=conv_to_string(generic, .false., string_length)
  end function hashmap_get_string
 
  function hashmap_get_real(specificmap, key)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    real(kind=default_precision) :: hashmap_get_real
 
    class(*), pointer :: generic
 
    generic=>hashmap_get_generic(specificmap, key)
    if (.not. associated(generic)) call log_log(log_error, "Can not find real entry with key '"//trim(key)//"'")
    select type(vr=>generic)
    type is (real(kind=default_precision))
      hashmap_get_real=vr
    type is (real)
      hashmap_get_real=conv_single_real_to_double(vr)
    type is (integer)  
      hashmap_get_real=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function hashmap_get_real
 
  function hashmap_get_logical(specificmap, key)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    logical :: hashmap_get_logical
 
    class(*), pointer :: generic
 
    generic=>hashmap_get_generic(specificmap, key)
    if (.not. associated(generic)) call log_log(log_error, "Can not find logical entry with key '"//trim(key)//"'")
    hashmap_get_logical=conv_to_logical(generic, .false.)
  end function hashmap_get_logical
 
  function hashmap_get_generic(specificmap, key)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    class(*), pointer :: hashmap_get_generic, raw_map_node
 
    raw_map_node=>hashmap_getnode(specificmap, key)
    if (associated(raw_map_node)) then
      select type (raw_map_node)
      type is (mapnode_type)
        hashmap_get_generic=>raw_map_node%value
      end select
      return
    end if
    hashmap_get_generic=>null()
  end function hashmap_get_generic
 
  function hashmap_getnode(specificmap, key, key_location)
    type(hashmap_type), intent(inout) :: specificmap
    character(len=*), intent(in) :: key
    integer, intent(out), optional :: key_location
    class(*), pointer :: raw_data, hashmap_getnode
 
    integer :: i, hash
    type(listnode_type), pointer :: node
 
    hashmap_getnode=>null()
    if (present(key_location)) key_location=0
 
    if (.not. associated(specificmap%map_ds)) return
 
    hash=get_hashkey(key)
    
    i=1
    node=>specificmap%map_ds(hash)%head
    if (associated(node)) then
      do while(1==1)
        raw_data=>node%data
        if (associated(raw_data)) then
          select type (raw_data)
          type is (mapnode_type)
            if (raw_data%key .eq. key) then
              hashmap_getnode=>raw_data
              if (present(key_location)) key_location=i
              return
            end if
          end select
        end if
        node=>node%next
        i=i+1
        if (.not. associated(node)) exit
      end do
    end if
    if (present(key_location)) key_location=0
  end function hashmap_getnode
 
  function hashmap_getnode_atindex(specificmap, index)
    type(hashmap_type), intent(inout) :: specificmap
    integer, intent(in) :: index
    class(*), pointer :: hashmap_getnode_atindex
 
    integer :: i, current_size, prev
 
    hashmap_getnode_atindex=>null()
    if (.not. associated(specificmap%map_ds) .or. index .gt. specificmap%size) return
 
    current_size=0
    prev=0
    do i=1, hash_size
      current_size=current_size+list_size(specificmap%map_ds(i))
      if (current_size .ge. index) then
        hashmap_getnode_atindex=>list_get_generic(specificmap%map_ds(i), index-prev)        
        return
      end if
      prev=current_size
    end do
  end function hashmap_getnode_atindex
 
  integer function hashmap_size(specificmap)
    type(hashmap_type), intent(inout) :: specificmap
 
    hashmap_size=specificmap%size
  end function hashmap_size
 
  logical function hashmap_is_empty(specificmap)
    type(hashmap_type), intent(inout) :: specificmap
 
    hashmap_is_empty=(specificmap%size == 0)
  end function hashmap_is_empty
 
  subroutine hashmap_free(specificmap)
    type(hashmap_type), intent(inout) :: specificmap
 
    type(listnode_type), pointer :: node, previousnode
    integer :: i
 
    if (associated(specificmap%map_ds)) then
      do i=1, hash_size
        node=>specificmap%map_ds(i)%head
        previousnode=>null()
 
        if (associated(node)) then
          do while(1==1)
            previousnode=>node
            node=>node%next
            if (associated(previousnode%data)) then
              select type (n=>previousnode%data)
              type is (mapnode_type)
                if (n%memory_allocation_automatic) then
                  if (associated(n%value)) deallocate(n%value)
                end if
              end select
              deallocate(previousnode%data) ! Free the mapnode data structure
            end if
            deallocate(previousnode)
            if (.not. associated(node)) exit
          end do
        end if
 
        specificmap%map_ds(i)%tail=>null()
        specificmap%map_ds(i)%head=>null()
        specificmap%map_ds(i)%size=0
      end do
      specificmap%size=0
      deallocate(specificmap%map_ds)
    end if
  end subroutine hashmap_free
 
  type(iterator_type) function hashset_get_iterator(specificset)
    type(hashset_type), intent(inout) :: specificset
 
    integer :: i
 
    hashset_get_iterator%next_item=>null()
    if (associated(specificset%set_ds)) then
      hashset_get_iterator%hash_structure=>specificset%set_ds
 
      do i=1, size(specificset%set_ds)
        if (specificset%set_ds(i)%size .gt. 0) then
          hashset_get_iterator%next_item=>specificset%set_ds(i)%head
          exit
        end if
      end do
      hashset_get_iterator%hash_ptr=i+1
    end if
  end function hashset_get_iterator 
 
  subroutine hashset_add(specificset, key)
    type(hashset_type), intent(inout) :: specificset
    character(len=*), intent(in) :: key
 
    class(*), pointer :: generic
    type(setnode_type), pointer :: newsetnode
    integer :: hash, location
 
    if (.not. associated(specificset%set_ds)) allocate(specificset%set_ds(hash_size))
 
    call hashset_getlocation(specificset, key, hash, location)
 
    if (hash .gt. 0 .and. location .eq. 0) then      
      allocate(newsetnode)
      newsetnode%key=key
      ! Clone and deallocate the newmapnode - this keeps GNU happy with passing the correct pointer and Cray
      ! doesn't link the generic pointer just pointing to the data structure hence we clone it
      allocate(generic, source=newsetnode)
      deallocate(newsetnode)
      call list_add_generic(specificset%set_ds(hash), generic, .true.)
      specificset%size=specificset%size+1
    end if
  end subroutine hashset_add
 
  subroutine hashset_remove(specificset, key)
    type(hashset_type), intent(inout) :: specificset
    character(len=*), intent(in) :: key
 
    integer :: location, hash
 
    call hashset_getlocation(specificset, key, hash, location)
    if (hash .gt. 0 .and. location .gt. 0) then
      call list_remove(specificset%set_ds(hash), location)
      specificset%size=specificset%size-1
    end if
  end subroutine hashset_remove
 
  logical function hashset_contains(specificset, key)
    type(hashset_type), intent(inout) :: specificset
    character(len=*), intent(in) :: key
 
    integer :: hash, key_location
 
    call hashset_getlocation(specificset, key, hash, key_location)
    hashset_contains= (hash .gt. 0 .and. key_location .gt. 0)
  end function hashset_contains  
 
  subroutine hashset_getlocation(specificset, key, hash, key_location)
    type(hashset_type), intent(inout) :: specificset
    character(len=*), intent(in) :: key
    integer, intent(out) :: hash, key_location
    class(*), pointer :: raw_data
 
    integer :: i
    type(listnode_type), pointer :: node
 
    hash=0
    key_location=0
 
    if (.not. associated(specificset%set_ds)) return
 
    hash=get_hashkey(key)
    
    i=1
    node=>specificset%set_ds(hash)%head
    if (associated(node)) then
      do while(1==1)
        raw_data=>node%data
        if (associated(raw_data)) then
          select type (raw_data)
          type is (setnode_type)
            if (raw_data%key .eq. key) then            
              key_location=i
              return
            end if
          end select
        end if
        node=>node%next
        i=i+1
        if (.not. associated(node)) exit
      end do
    end if
    key_location=0
  end subroutine hashset_getlocation
 
  logical function hashset_is_empty(specificset)
    type(hashset_type), intent(in) :: specificset
 
    hashset_is_empty = specificset%size == 0
  end function hashset_is_empty
 
  character(len=STRING_LENGTH) function hashset_get_string(specificset, index)
    type(hashset_type), intent(inout) :: specificset
    integer, intent(in) :: index
    class(*), pointer :: generic
 
    integer :: i, current_size, prev
 
    hashset_get_string=""
    if (.not. associated(specificset%set_ds) .or. index .gt. specificset%size) return
 
    current_size=0
    prev=0
    do i=1, hash_size
      current_size=current_size+list_size(specificset%set_ds(i))
      if (current_size .ge. index) then
        generic=>list_get_generic(specificset%set_ds(i), index-prev)        
        if (associated(generic)) then
          select type (generic)
          type is (setnode_type)
            hashset_get_string=generic%key
          end select
          return
        else
          call log_log(log_error, "Can not find hashset entry at index "//trim(conv_to_string(index)))
        end if
      end if
      prev=current_size
    end do
  end function hashset_get_string
 
  subroutine hashset_free(specificset)
    type(hashset_type), intent(inout) :: specificset
 
    type(listnode_type), pointer :: node, previousnode
    integer :: i
 
    if (associated(specificset%set_ds)) then
      do i=1, hash_size
        node=>specificset%set_ds(i)%head
        previousnode=>null()
 
        if (associated(node)) then
          do while(1==1)        
            previousnode=>node
            node=>node%next
            if (associated(previousnode%data)) then            
              deallocate(previousnode%data) ! Free the mapnode data structure
            end if
            deallocate(previousnode)
            if (.not. associated(node)) exit
          end do
        end if
 
        specificset%set_ds(i)%tail=>null()
        specificset%set_ds(i)%head=>null()
        specificset%set_ds(i)%size=0
      end do
      specificset%size=0
      deallocate(specificset%set_ds)
    end if
  end subroutine hashset_free
 
  integer function hashset_size(specificset)
    type(hashset_type), intent(in) :: specificset
 
    hashset_size = specificset%size
  end function hashset_size
 
  integer function get_hashkey(key)
    character(len=*), intent(in) :: key
 
    integer :: i
 
    get_hashkey=5381
    do i=1, len(trim(key))
      get_hashkey=(ishft(get_hashkey,5) + get_hashkey) + ichar(key(i:i))
    end do
    get_hashkey=abs(mod(get_hashkey, hash_size))+1
  end function get_hashkey
 
  type(iterator_type) function stack_get_iterator(specificstack)
    type(stack_type), intent(inout) :: specificstack
 
    stack_get_iterator%next_item=>specificstack%stack_ds%head
    stack_get_iterator%hash_structure=>null()
    stack_get_iterator%hash_ptr=0
  end function stack_get_iterator 
 
  subroutine stack_push_int(specificstack, int_data)
    type(stack_type), intent(inout) :: specificstack
    integer, intent(in) :: int_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(int_data, .true.)
    call stack_push_generic(specificstack, generic, .true.)
  end subroutine stack_push_int
 
  subroutine stack_push_string(specificstack, str_data)
    type(stack_type), intent(inout) :: specificstack
    character(len=STRING_LENGTH), intent(in) :: str_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(str_data, .true.)
    call stack_push_generic(specificstack, generic, .true.)
  end subroutine stack_push_string
 
  subroutine stack_push_real(specificstack, real_data)
    type(stack_type), intent(inout) :: specificstack
    real(kind=default_precision), intent(in) :: real_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(real_data, .true.)
    call stack_push_generic(specificstack, generic, .true.)
  end subroutine stack_push_real
 
  subroutine stack_push_logical(specificstack, logical_data)
    type(stack_type), intent(inout) :: specificstack
    logical, intent(in) :: logical_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(logical_data, .true.)
    call stack_push_generic(specificstack, generic, .true.)
  end subroutine stack_push_logical
 
  subroutine stack_push_generic(specificstack, data, memory_allocation_automatic)
    type(stack_type), intent(inout) :: specificstack
    class(*), pointer, intent(in) :: data
    logical, intent(in) :: memory_allocation_automatic
 
    call list_insert_generic(specificstack%stack_ds, data, 1, memory_allocation_automatic)
  end subroutine stack_push_generic
 
  function stack_pop_int(specificstack)
    type(stack_type), intent(inout) :: specificstack
    integer :: stack_pop_int
 
    class(*), pointer :: generic
 
    generic=>stack_pop_generic(specificstack)
    if (.not. associated(generic)) call log_log(log_error, "Can not pop integer from stack")
    stack_pop_int=conv_to_integer(generic, .false.)
  end function stack_pop_int
 
  function stack_pop_string(specificstack)
    type(stack_type), intent(inout) :: specificstack
    character(len=STRING_LENGTH) :: stack_pop_string
 
    class(*), pointer :: generic
 
    generic=>stack_pop_generic(specificstack)
    if (.not. associated(generic)) call log_log(log_error, "Can not pop string from stack")
    stack_pop_string=conv_to_string(generic, .false., string_length)
  end function stack_pop_string
 
  function stack_pop_real(specificstack)
    type(stack_type), intent(inout) :: specificstack
    real(kind=default_precision) :: stack_pop_real
 
    class(*), pointer :: generic
 
    generic=>stack_pop_generic(specificstack)
    if (.not. associated(generic)) call log_log(log_error, "Can not pop real from stack")
    select type(vr=>generic)
    type is (real(kind=default_precision))
      stack_pop_real=vr
    type is (real)
      stack_pop_real=conv_single_real_to_double(vr)
    type is (integer)  
      stack_pop_real=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function stack_pop_real
 
  function stack_pop_logical(specificstack)
    type(stack_type), intent(inout) :: specificstack
    logical :: stack_pop_logical
 
    class(*), pointer :: generic
 
    generic=>stack_pop_generic(specificstack)
    if (.not. associated(generic)) call log_log(log_error, "Can not pop logical from stack")
    stack_pop_logical=conv_to_logical(generic, .false.)
  end function stack_pop_logical  
 
  function stack_pop_generic(specificstack)
    type(stack_type), intent(inout) :: specificstack
    class(*), pointer :: stack_pop_generic
 
    stack_pop_generic=>stack_get_generic(specificstack, 1)
    call list_remove(specificstack%stack_ds, 1)
  end function stack_pop_generic
 
  function stack_get_int(specificstack, i)
    type(stack_type), intent(inout) :: specificstack
    integer, intent(in) :: i
    integer :: stack_get_int
 
    class(*), pointer :: generic
 
    generic=>stack_get_generic(specificstack, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get integer from stack at index "//trim(conv_to_string(i)))
    stack_get_int=conv_to_integer(generic, .false.)
  end function stack_get_int
 
  function stack_get_string(specificstack, i)
    type(stack_type), intent(inout) :: specificstack
    integer, intent(in) :: i
    character(len=STRING_LENGTH) :: stack_get_string
 
    class(*), pointer :: generic
 
    generic=>stack_get_generic(specificstack, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get string from stack at index "//trim(conv_to_string(i)))
    stack_get_string=conv_to_string(generic, .false., string_length)
  end function stack_get_string
 
  function stack_get_real(specificstack, i)
    type(stack_type), intent(inout) :: specificstack
    integer, intent(in) :: i
    real(kind=default_precision) :: stack_get_real
 
    class(*), pointer :: generic
 
    generic=>stack_get_generic(specificstack, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get real from stack at index "//trim(conv_to_string(i)))
    select type(vr=>generic)
    type is (real(kind=default_precision))
      stack_get_real=vr
    type is (real)
      stack_get_real=conv_single_real_to_double(vr)
    type is (integer)  
      stack_get_real=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function stack_get_real
 
  function stack_get_logical(specificstack, i)
    type(stack_type), intent(inout) :: specificstack
    integer, intent(in) :: i
    logical :: stack_get_logical
 
    class(*), pointer :: generic
 
    generic=>stack_get_generic(specificstack, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get logical from stack at index "//trim(conv_to_string(i)))
    stack_get_logical=conv_to_logical(generic, .false.)
  end function stack_get_logical
 
  function stack_get_generic(specificstack, i)
    type(stack_type), intent(inout) :: specificstack
    integer, intent(in) :: i
    class(*), pointer :: stack_get_generic
 
    stack_get_generic=>list_get_generic(specificstack%stack_ds, i)
  end function stack_get_generic
 
  integer function stack_size(specificstack)
    type(stack_type), intent(inout) :: specificstack
 
    stack_size = list_size(specificstack%stack_ds)
  end function stack_size
 
  logical function stack_is_empty(specificstack)
    type(stack_type), intent(inout) :: specificstack
 
    stack_is_empty = list_is_empty(specificstack%stack_ds)
  end function stack_is_empty
 
  subroutine stack_free(specificstack)
    type(stack_type), intent(inout) :: specificstack
 
    call list_free(specificstack%stack_ds)
  end subroutine stack_free
 
  type(iterator_type) function queue_get_iterator(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
 
    queue_get_iterator%next_item=>specificqueue%queue_ds%head
    queue_get_iterator%hash_structure=>null()
    queue_get_iterator%hash_ptr=0
  end function queue_get_iterator 
 
  subroutine queue_push_int(specificqueue, int_data)
    type(queue_type), intent(inout) :: specificqueue
    integer, intent(in) :: int_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(int_data, .true.)
    call queue_push_generic(specificqueue, generic, .true.)
  end subroutine queue_push_int
 
  subroutine queue_push_string(specificqueue, str_data)
    type(queue_type), intent(inout) :: specificqueue
    character(len=STRING_LENGTH), intent(in) :: str_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(str_data, .true.)
    call queue_push_generic(specificqueue, generic, .true.)
  end subroutine queue_push_string
 
  subroutine queue_push_real(specificqueue, real_data)
    type(queue_type), intent(inout) :: specificqueue
    real(kind=default_precision), intent(in) :: real_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(real_data, .true.)
    call queue_push_generic(specificqueue, generic, .true.)
  end subroutine queue_push_real
 
  subroutine queue_push_logical(specificqueue, logical_data)
    type(queue_type), intent(inout) :: specificqueue
    logical, intent(in) :: logical_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(logical_data, .true.)
    call queue_push_generic(specificqueue, generic, .true.)
  end subroutine queue_push_logical
 
  subroutine queue_push_generic(specificqueue, data, memory_allocation_automatic)
    type(queue_type), intent(inout) :: specificqueue
    class(*), pointer, intent(in) :: data
    logical, intent(in) :: memory_allocation_automatic
 
    call list_add_generic(specificqueue%queue_ds, data, memory_allocation_automatic)
  end subroutine queue_push_generic
 
  function queue_pop_int(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
    integer :: queue_pop_int
 
    class(*), pointer :: generic
 
    generic=>queue_pop_generic(specificqueue)
    if (.not. associated(generic)) call log_log(log_error, "Can not pop integer from queue")
    queue_pop_int=conv_to_integer(generic, .false.)
  end function queue_pop_int
 
  function queue_pop_string(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
    character(len=STRING_LENGTH) :: queue_pop_string
 
    class(*), pointer :: generic
 
    generic=>queue_pop_generic(specificqueue)
    if (.not. associated(generic)) call log_log(log_error, "Can not pop string from queue")
    queue_pop_string=conv_to_string(generic, .false., string_length)
  end function queue_pop_string
 
  function queue_pop_real(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
    real(kind=default_precision) :: queue_pop_real
 
    class(*), pointer :: generic
 
    generic=>queue_pop_generic(specificqueue)
    if (.not. associated(generic)) call log_log(log_error, "Can not pop real from queue")
    select type(vr=>generic)
    type is (real(kind=default_precision))
      queue_pop_real=vr
    type is (real)
      queue_pop_real=conv_single_real_to_double(vr)
    type is (integer)  
      queue_pop_real=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function queue_pop_real
 
  function queue_pop_logical(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
    logical :: queue_pop_logical
 
    class(*), pointer :: generic
 
    generic=>queue_pop_generic(specificqueue)
    if (.not. associated(generic)) call log_log(log_error, "Can not pop logical from queue")
    queue_pop_logical=conv_to_logical(generic, .false.)
  end function queue_pop_logical
 
  function queue_pop_generic(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
    class(*), pointer :: queue_pop_generic
 
    queue_pop_generic=>queue_get_generic(specificqueue, 1)
    call list_remove(specificqueue%queue_ds, 1)
  end function queue_pop_generic
 
  function queue_get_int(specificqueue, i)
    type(queue_type), intent(inout) :: specificqueue
    integer, intent(in) :: i
    integer :: queue_get_int
 
    class(*), pointer :: generic
 
    generic=>queue_get_generic(specificqueue, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get integer from queue at index "//trim(conv_to_string(i)))
    queue_get_int=conv_to_integer(generic, .false.)
  end function queue_get_int
 
  function queue_get_string(specificqueue, i)
    type(queue_type), intent(inout) :: specificqueue
    integer, intent(in) :: i
    character(len=STRING_LENGTH) :: queue_get_string
 
    class(*), pointer :: generic
 
    generic=>queue_get_generic(specificqueue, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get string from queue at index "//trim(conv_to_string(i)))
    queue_get_string=conv_to_string(generic, .false., string_length)
  end function queue_get_string
 
  function queue_get_real(specificqueue, i)
    type(queue_type), intent(inout) :: specificqueue
    integer, intent(in) :: i
    real(kind=default_precision) :: queue_get_real
 
    class(*), pointer :: generic
 
    generic=>queue_get_generic(specificqueue, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get real from queue at index "//trim(conv_to_string(i)))
    select type(vr=>generic)
    type is (real(kind=default_precision))
      queue_get_real=vr
    type is (real)
      queue_get_real=conv_single_real_to_double(vr)
    type is (integer)  
      queue_get_real=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function queue_get_real
 
  function queue_get_logical(specificqueue, i)
    type(queue_type), intent(inout) :: specificqueue
    integer, intent(in) :: i
    logical :: queue_get_logical
 
    class(*), pointer :: generic
 
    generic=>queue_get_generic(specificqueue, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get logical from queue at index "//trim(conv_to_string(i)))
    queue_get_logical=conv_to_logical(generic, .false.)
  end function queue_get_logical
 
  function queue_get_generic(specificqueue, i)
    type(queue_type), intent(inout) :: specificqueue
    integer, intent(in) :: i
    class(*), pointer :: queue_get_generic
 
    queue_get_generic=>list_get_generic(specificqueue%queue_ds, i)
  end function queue_get_generic
 
  integer function queue_size(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
 
    queue_size = list_size(specificqueue%queue_ds)
  end function queue_size
 
  logical function queue_is_empty(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
 
    queue_is_empty = list_is_empty(specificqueue%queue_ds)
  end function queue_is_empty
 
  subroutine queue_free(specificqueue)
    type(queue_type), intent(inout) :: specificqueue
 
    call list_free(specificqueue%queue_ds)
  end subroutine queue_free
 
  type(iterator_type) function list_get_iterator(specificlist)
    type(list_type), intent(inout) :: specificlist
 
    list_get_iterator%next_item=>specificlist%head
    list_get_iterator%hash_structure=>null()
    list_get_iterator%hash_ptr=0
  end function list_get_iterator    
 
  subroutine list_insert_int(specificlist, int_data, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i, int_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(int_data, .true.)
    call list_insert_generic(specificlist, generic, i, .true.)
  end subroutine list_insert_int
 
  subroutine list_insert_string(specificlist, str_data, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    character(len=STRING_LENGTH), intent(in) :: str_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(str_data, .true.)
    call list_insert_generic(specificlist, generic, i, .true.)
  end subroutine list_insert_string
 
  subroutine list_insert_real(specificlist, real_data, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    real(kind=default_precision), intent(in) :: real_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(real_data, .true.)
    call list_insert_generic(specificlist, generic, i, .true.)
  end subroutine list_insert_real
 
  subroutine list_insert_logical(specificlist, logical_data, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    logical, intent(in) :: logical_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(logical_data, .true.)
    call list_insert_generic(specificlist, generic, i, .true.)
  end subroutine list_insert_logical
 
  subroutine list_insert_generic(specificlist, data, i, memory_allocation_automatic)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    class(*), pointer, intent(in) :: data
    logical, intent(in) :: memory_allocation_automatic
 
    integer ::j
    type(listnode_type), pointer :: newnode, node
 
    allocate(newnode)
    newnode%data => data
 
    j=1
    node => specificlist%head
    if (associated(node)) then
      do while(j .lt. i)
        if (.not. associated(node%next)) exit
        node => node%next
        j=j+1
      end do
      if (j .eq. i) then
        ! Insert node
        newnode%next => node
        newnode%prev => node%prev
        newnode%memory_allocation_automatic=memory_allocation_automatic
        if (associated(node%prev)) node%prev%next=>newnode
        node%prev => newnode
        if (associated(node, target=specificlist%head)) specificlist%head=>newnode
      else
        ! Ran out of list nodes so add this one onto the end
        newnode%prev=>specificlist%tail
        if (associated(specificlist%tail)) then
          specificlist%tail%next => newnode
        end if
        specificlist%tail => newnode
 
        if (associated(specificlist%head) .eqv. .false.) then
          specificlist%head=>newnode
        end if
      end if
    else
      ! No current list data so set up the list with this node
      specificlist%head => newnode
      specificlist%tail => newnode
    end if
    specificlist%size=specificlist%size+1
  end subroutine list_insert_generic
 
  subroutine list_add_int(specificlist, int_data)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: int_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(int_data, .true.)
    call list_add_generic(specificlist, generic, .true.)
  end subroutine list_add_int
 
  subroutine list_add_string(specificlist, str_data)
    type(list_type), intent(inout) :: specificlist
    character(len=STRING_LENGTH), intent(in) :: str_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(str_data, .true.)
    call list_add_generic(specificlist, generic, .true.)
  end subroutine list_add_string
 
  subroutine list_add_real(specificlist, real_data)
    type(list_type), intent(inout) :: specificlist
    real(kind=default_precision), intent(in) :: real_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(real_data, .true.)
    call list_add_generic(specificlist, generic, .true.)
  end subroutine list_add_real
 
  subroutine list_add_logical(specificlist, logical_data)
    type(list_type), intent(inout) :: specificlist
    logical, intent(in) :: logical_data
 
    class(*), pointer :: generic
 
    generic=>conv_to_generic(logical_data, .true.)
    call list_add_generic(specificlist, generic, .true.)
  end subroutine list_add_logical
 
  subroutine list_add_generic(specificlist, data, memory_allocation_automatic)
    type(list_type), intent(inout) :: specificlist
    class(*), pointer, intent(in) :: data
    logical, intent(in) :: memory_allocation_automatic
 
    type(listnode_type), pointer :: newnode
 
    allocate(newnode)
    newnode%data => data
 
    newnode%prev=>specificlist%tail
    newnode%memory_allocation_automatic=memory_allocation_automatic
    if (associated(specificlist%tail)) then
      specificlist%tail%next => newnode
    end if
    specificlist%tail => newnode
 
    if (associated(specificlist%head) .eqv. .false.) then
      specificlist%head=>newnode
    end if
 
    specificlist%size=specificlist%size+1
  end subroutine list_add_generic
 
  subroutine list_remove(specificlist, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
 
    integer ::j
    type(listnode_type), pointer :: node
 
    j=1
    if (i .le. specificlist%size) then
      node => specificlist%head
      do while(j .lt. i)
        if (.not. associated(node)) exit
        node => node%next
        j=j+1
      end do
      if (associated(node)) then
        if (associated(node%prev)) node%prev%next => node%next
        if (associated(node%next)) node%next%prev => node%prev
        if (associated(node, target=specificlist%head)) specificlist%head => node%next
        if (associated(node, target=specificlist%tail)) specificlist%tail => node%prev
        if (node%memory_allocation_automatic) then
          if (associated(node%data)) deallocate(node%data)
        end if
        deallocate(node)
        specificlist%size = specificlist%size - 1
      end if
    end if
  end subroutine list_remove
 
  logical function list_is_empty(specificlist)
    type(list_type), intent(in) :: specificlist
 
    list_is_empty = specificlist%size == 0
  end function list_is_empty
 
  function list_get_int(specificlist, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    integer :: list_get_int
 
    class(*), pointer :: generic
 
    generic=>list_get_generic(specificlist, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get integer from list at index "//trim(conv_to_string(i)))
    list_get_int=conv_to_integer(generic, .false.)
  end function list_get_int
 
  function list_get_string(specificlist, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    character(len=STRING_LENGTH) :: list_get_string
 
    class(*), pointer :: generic
 
    generic=>list_get_generic(specificlist, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get string from list at index "//trim(conv_to_string(i)))
    list_get_string=conv_to_string(generic, .false., string_length)
  end function list_get_string
 
  function list_get_real(specificlist, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    real(kind=default_precision) :: list_get_real
 
    class(*), pointer :: generic
 
    generic=>list_get_generic(specificlist, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get real from list at index "//trim(conv_to_string(i)))
    select type(vr=>generic)
    type is (real(kind=default_precision))
      list_get_real=vr
    type is (real)
      list_get_real=conv_single_real_to_double(vr)
    type is (integer)  
      list_get_real=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function list_get_real
 
  function list_get_logical(specificlist, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    logical :: list_get_logical
 
    class(*), pointer :: generic
 
    generic=>list_get_generic(specificlist, i)
    if (.not. associated(generic)) call log_log(log_error, "Can not get logical from list at index "//trim(conv_to_string(i)))
    list_get_logical=conv_to_logical(generic, .false.)
  end function list_get_logical
 
  function list_get_generic(specificlist, i)
    type(list_type), intent(inout) :: specificlist
    integer, intent(in) :: i
    class(*), pointer :: list_get_generic
 
    integer :: j
    type(listnode_type), pointer :: node
 
    j=1
    if (specificlist%size .lt. i) then
      list_get_generic => null()
      return
    end if
    node => specificlist%head
    do while(j .lt. i)
      if (.not. associated(node)) exit
      node => node%next
      j=j+1
    end do
    list_get_generic => node%data
  end function list_get_generic
 
  subroutine list_free(specificlist)
    type(list_type), intent(inout) :: specificlist
 
    type(listnode_type), pointer :: node, previousnode
 
    node=>specificlist%head
    previousnode=>null()
 
    if (associated(node)) then
      do while(1==1)
        previousnode=>node
        node=>node%next
        if (previousnode%memory_allocation_automatic) then
          if (associated(previousnode%data)) deallocate(previousnode%data)
        end if
        deallocate(previousnode)
        if (.not. associated(node)) exit
      end do
    end if
 
    specificlist%tail=>null()
    specificlist%head=>null()
    specificlist%size=0
  end subroutine list_free
 
  integer function list_size(specificlist)
    type(list_type), intent(in) :: specificlist
 
    list_size = specificlist%size
  end function list_size
 
  logical function iteratior_has_next(iterator)
    type(iterator_type), intent(inout) :: iterator
 
    iteratior_has_next=associated(iterator%next_item)
  end function iteratior_has_next
 
  integer function iterator_get_next_integer(iterator)
    type(iterator_type), intent(inout) :: iterator
 
    class(*), pointer :: generic
 
    generic=>iterator_get_next_generic(iterator)
    if (associated(generic)) then
      iterator_get_next_integer=conv_to_integer(generic, .false.)
    else
      call log_log(log_error, "Can not get next integer in iterator as iterator has reached end of collection")
    end if
  end function iterator_get_next_integer
  
  character(len=STRING_LENGTH) function iterator_get_next_string(iterator)
    type(iterator_type), intent(inout) :: iterator
 
    class(*), pointer :: generic
 
    generic=>iterator_get_next_generic(iterator)
    if (associated(generic)) then
      select type(generic)
        type is (setnode_type)
          iterator_get_next_string=generic%key
        class default
          iterator_get_next_string=conv_to_string(generic, .false., string_length)
      end select      
    else
      call log_log(log_error, "Can not get next string in iterator as iterator has reached end of collection")
    end if
  end function iterator_get_next_string
 
  real(kind=default_precision) function iterator_get_next_real(iterator)
    type(iterator_type), intent(inout) :: iterator
 
    class(*), pointer :: generic
 
    generic=>iterator_get_next_generic(iterator)
    if (associated(generic)) then
      select type(vr=>generic)
      type is (real(kind=default_precision))
        iterator_get_next_real=vr
      type is (real)
        iterator_get_next_real=conv_single_real_to_double(vr)
      type is (integer)  
        iterator_get_next_real=conv_single_real_to_double(conv_to_real(vr))
      end select
    else
      call log_log(log_error, "Can not get next real in iterator as iterator has reached end of collection")
    end if
  end function iterator_get_next_real
 
  logical function iterator_get_next_logical(iterator)
    type(iterator_type), intent(inout) :: iterator
 
    class(*), pointer :: generic
 
    generic=>iterator_get_next_generic(iterator)
    if (associated(generic)) then
      iterator_get_next_logical=conv_to_logical(generic, .false.)
    else
      call log_log(log_error, "Can not get next logical in iterator as iterator has reached end of collection")
    end if
  end function iterator_get_next_logical
 
  function iterator_get_next_mapentry(iterator)
    type(iterator_type), intent(inout) :: iterator
    type(mapentry_type) :: iterator_get_next_mapentry
 
    class(*), pointer :: generic
 
    generic=>iterator_get_next_generic(iterator)
    if (associated(generic)) then
      select type(generic)
        type is (mapnode_type)
          iterator_get_next_mapentry%key=generic%key
          iterator_get_next_mapentry%value=>generic%value
        class default
          call log_log(log_error, "Next item in iterator is not a map entry")
      end select
    else
      call log_log(log_error, "Can not get next map entry in iterator as iterator has reached end of collection")
    end if
  end function iterator_get_next_mapentry  
  
  function iterator_get_next_generic(iterator)
    type(iterator_type), intent(inout) :: iterator
    class(*), pointer :: iterator_get_next_generic
 
    integer :: i
    
    if (associated(iterator%next_item)) then
      iterator_get_next_generic=>iterator%next_item%data
      iterator%next_item=>iterator%next_item%next
      if (.not. associated(iterator%next_item) .and. associated(iterator%hash_structure) .and. &
           iterator%hash_ptr .le. size(iterator%hash_structure)) then
        do i=iterator%hash_ptr, size(iterator%hash_structure)
          if (iterator%hash_structure(i)%size .gt. 0) then
            iterator%next_item=>iterator%hash_structure(i)%head
            exit
          end if          
        end do
        iterator%hash_ptr=i+1
      end if      
    else
      iterator_get_next_generic=>null()
    end if
  end function iterator_get_next_generic
 
  function mapentry_get_int(mapentry_item)
    type(mapentry_type), intent(in) :: mapentry_item    
    integer :: mapentry_get_int
 
    class(*), pointer :: generic
 
    generic=>mapentry_item%value
    if (.not. associated(generic)) call log_log(log_error, "Can not get integer from map entry")
    mapentry_get_int=conv_to_integer(generic, .false.)
  end function mapentry_get_int
 
  function mapentry_get_string(mapentry_item)
    type(mapentry_type), intent(in) :: mapentry_item
    character(len=STRING_LENGTH) :: mapentry_get_string
 
    class(*), pointer :: generic
 
    generic=>mapentry_item%value
    if (.not. associated(generic)) call log_log(log_error, "Can not get string from map entry")
    mapentry_get_string=conv_to_string(generic, .false., string_length)
  end function mapentry_get_string
 
  function mapentry_get_real(mapentry_item)
    type(mapentry_type), intent(in) :: mapentry_item
    real(kind=default_precision) :: mapentry_get_real
 
    class(*), pointer :: generic
 
    generic=>mapentry_item%value
    if (.not. associated(generic)) call log_log(log_error, "Can not get real from map entry")
    select type(vr=>generic)
    type is (real(kind=default_precision))
      mapentry_get_real=vr
    type is (real)
      mapentry_get_real=conv_single_real_to_double(vr)
    type is (integer)  
      mapentry_get_real=conv_single_real_to_double(conv_to_real(vr))
    end select
  end function mapentry_get_real
 
  function mapentry_get_logical(mapentry_item)
    type(mapentry_type), intent(in) :: mapentry_item
    logical :: mapentry_get_logical
 
    class(*), pointer :: generic
 
    generic=>mapentry_item%value
    if (.not. associated(generic)) call log_log(log_error, "Can not get logical from map entry")
    mapentry_get_logical=conv_to_logical(generic, .false.)
  end function mapentry_get_logical
 
  function mapentry_get_generic(mapentry_item)
    type(mapentry_type), intent(in) :: mapentry_item
    class(*), pointer :: mapentry_get_generic
    
    mapentry_get_generic=>mapentry_item%value
  end function mapentry_get_generic  
end module collections_mod