collections_mod Module Reference

Collection data structures. More...

Data Types
interface	c_add_generic
	Adds a generic element to the end of the list. More...
interface	c_add_integer
	Adds an integer element to the end of the list. More...
interface	c_add_logical
	Adds a logical element to the end of the list. More...
interface	c_add_real
	Adds a double precision real element to the end of the list. More...
interface	c_add_string
	Adds a string to the end of the list. More...
interface	c_contains
	Determines whether or not a map contains a specific key. More...
interface	c_free
	Frees up all the allocatable, heap, memory associated with a list, stack, queue or map. More...
interface	c_generic_at
	Retrieves the generic value held at the specific map index or null if index > map elements. More...
interface	c_generic_entry_at
	Retrieves a map entry at a specific index or null if index > map elements. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value. More...
interface	c_get_generic
	Gets a specific generic element out of the list, stack, queue or map with the corresponding key. More...
interface	c_get_integer
	Gets a specific integer element out of the list, stack, queue or map with the corresponding key. More...
interface	c_get_iterator
interface	c_get_logical
	Gets a specific logical element out of the list, stack, queue or map with the corresponding key. More...
interface	c_get_real
	Gets a specific double precision real element out of the list, stack, queue or map with the corresponding key. More...
interface	c_get_string
	Gets a specific string element out of the list, stack, queue or map with the corresponding key. More...
interface	c_has_next
interface	c_insert_generic
	Inserts a generic element into the list or places at the end if the index > list size. More...
interface	c_insert_integer
	Inserts an integer element into the list or places at the end if the index > list size. More...
interface	c_insert_logical
	Inserts a logical element into the list or places at the end if the index > list size. More...
interface	c_insert_real
	Inserts a double precision real element into the list or places at the end if the index > list size. More...
interface	c_insert_string
	Inserts a string into the list or places at the end if the index > list size. More...
interface	c_integer_at
	Retrieves the integer value held at the specific map index or null if index > map elements. More...
interface	c_integer_entry_at
	Retrieves a map entry at a specific index. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value. More...
interface	c_is_empty
	Returns whether a collection is empty. More...
interface	c_key_at
	Retrieves the key currently being held at a specific index in the map or "" if the index > map elements. More...
interface	c_logical_at
	Retrieves the logical value held at the specific map index or null if index > map elements. More...
interface	c_logical_entry_at
	Retrieves a map entry at a specific index. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value. More...
interface	c_next_generic
interface	c_next_integer
interface	c_next_logical
interface	c_next_mapentry
interface	c_next_real
interface	c_next_string
interface	c_pop_generic
	Pops a generic element off the stack or queue. More...
interface	c_pop_integer
	Pops an integer element off the stack or queue. More...
interface	c_pop_logical
	Pops a logical element off the stack or queue. More...
interface	c_pop_real
	Pops a double precision real element off the stack or queue. More...
interface	c_pop_string
	Pops a string off the stack or queue. More...
interface	c_push_generic
	Pushes a generic element onto the stack or queue. More...
interface	c_push_integer
	Pushes an integer element onto the stack or queue. More...
interface	c_push_logical
	Pushes a logical element onto the stack or queue. More...
interface	c_push_real
	Pushes a double precision real element onto the stack or queue. More...
interface	c_push_string
	Pushes a string element onto the stack or queue. More...
interface	c_put_generic
	Puts a generic key-value pair into the map. More...
interface	c_put_integer
	Puts an integer key-value pair into the map. More...
interface	c_put_logical
	Puts a logical key-value pair into the map. More...
interface	c_put_real
	Puts a double precision real key-value pair into the map. More...
interface	c_put_string
	Puts a string key-value pair into the map. More...
interface	c_real_at
	Retrieves the double precision real value held at the specific map index or null if index > map elements. More...
interface	c_real_entry_at
	Retrieves a map entry at a specific index. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value. More...
interface	c_remove
	Removes a specific element from the list or map. More...
interface	c_size
	Returns the number of elements in the collection. More...
interface	c_string_at
	Retrieves the string value held at the specific map index or null if index > map elements. More...
interface	c_string_entry_at
	Retrieves a map entry at a specific index. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value. More...
type	hashmap_type
	A hashmap structure, the same as a map but uses hashing for greatly improved performance when storing large numbers of entries, with the lookup complexisty being almost constant (assuming good hash distribution.) Note that this does require more storage than a map and unlike a map does not preserve ordering. More...
type	hashset_type
	Hashset structure which will store unique strings. The hashing aspect means that lookup is very fast but it does add extra memory overhead and the order is non-deterministic. More...
type	iterator_type
type	list_type
	List data structure which implements a doubly linked list. This list will preserve its order. More...
type	listnode_type
	Private list node which holds the raw generic node data and pointers to next and previous list nodes. More...
type	map_type
	Map data structure that holds string (length 20 maximum) key value pairs. More...
type	mapentry_type
type	mapnode_type
	Private map key-value pair data structure. More...
type	queue_type
	Queue (FIFO) data structure. More...
type	setnode_type
	Private set key structure. More...
type	stack_type
	Stack (FILO) data structure. More...

Functions/Subroutines
type(iterator_type) function	map_get_iterator (specificmap)
	Retrieves an iterator representation of the map, ready to access the first element. More...
subroutine	map_put_int (specificmap, key, int_data)
	Puts a specific key-value pair into the map. More...
subroutine	map_put_string (specificmap, key, str_data)
	Puts a specific key-value pair into the map. More...
subroutine	map_put_real (specificmap, key, real_data)
	Puts a specific key-value pair into the map. More...
subroutine	map_put_logical (specificmap, key, logical_data)
	Puts a specific key-value pair into the map. More...
subroutine	map_put_generic (specificmap, key, data, memory_allocation_automatic)
	Puts a specific key-value pair into the map. More...
logical function	map_contains_key (specificmap, key)
	Determines whether or not a map contains a specific key. More...
character(len=string_length) function	map_key_at (specificmap, i)
	Retrieves the key currently being held at a specific index in the map or "" if the index > map elements. More...
integer function	map_integer_at (specificmap, i)
	Retrieves the integer value held at the specific map index. More...
character(len=string_length) function	map_string_at (specificmap, i)
	Retrieves the string value held at the specific map index. More...
real(kind=default_precision) function	map_real_at (specificmap, i)
	Retrieves the real value held at the specific map index. Converts between precision and int. More...
logical function	map_logical_at (specificmap, i)
	Retrieves the logical value held at the specific map index. More...
class(*) function, pointer	map_generic_at (specificmap, i)
	Retrieves the generic value held at the specific map index or null if index > map elements. More...
logical function	map_integer_entry_at (specificmap, i, key, int_val)
	Retrieves the entry at a specific map index or null if index > map elements. More...
logical function	map_string_entry_at (specificmap, i, key, str_val)
	Retrieves the entry at a specific map index or null if index > map elements. More...
logical function	map_real_entry_at (specificmap, i, key, real_val)
	Retrieves the entry at a specific map index or null if index > map elements. This converts precision and from ints. More...
logical function	map_logical_entry_at (specificmap, i, key, logical_val)
	Retrieves the entry at a specific map index or null if index > map elements. More...
logical function	map_generic_entry_at (specificmap, i, key, val)
	Retrieves the entry at a specific map index or null if index > map elements. More...
subroutine	map_remove (specificmap, key)
	Removes a specific key-value pair from the map. More...
integer function	map_get_int (specificmap, key)
	Gets a specific element out of the map with the corresponding key. More...
character(len=string_length) function	map_get_string (specificmap, key)
	Gets a specific element out of the map with the corresponding key. More...
real(kind=default_precision) function	map_get_real (specificmap, key)
	Gets a specific element out of the map with the corresponding key. This converts between precision and from ints. More...
logical function	map_get_logical (specificmap, key)
	Gets a specific element out of the map with the corresponding key. More...
class(*) function, pointer	map_get_generic (specificmap, key)
	Gets a specific element out of the map with the corresponding key. More...
class(*) function, pointer	map_getnode (specificmap, key, foundindex)
	This gets the map node that the key represents (rather than the specific value) More...
integer function	map_size (specificmap)
	Returns the number of elements in the map. More...
logical function	map_is_empty (specificmap)
	Returns whether a map is empty. More...
subroutine	map_free (specificmap)
	Frees up all the allocatable, heap, memory associated with a specific map. More...
type(iterator_type) function	hashmap_get_iterator (specificmap)
	Retrieves an iterator representation of the hashmap, ready to access the first element. More...
subroutine	hashmap_put_int (specificmap, key, int_data)
	Puts a specific key-value pair into the hashmap. More...
subroutine	hashmap_put_string (specificmap, key, str_data)
	Puts a specific key-value pair into the hashmap. More...
subroutine	hashmap_put_real (specificmap, key, real_data)
	Puts a specific key-value pair into the hashmap. More...
subroutine	hashmap_put_logical (specificmap, key, logical_data)
	Puts a specific key-value pair into the hashmap. More...
subroutine	hashmap_put_generic (specificmap, key, data, memory_allocation_automatic)
	Puts a specific key-value pair into the hashmap. More...
logical function	hashmap_contains_key (specificmap, key)
	Determines whether or not a hashmap contains a specific key. More...
character(len=string_length) function	hashmap_key_at (specificmap, i)
	Retrieves the key currently being held at a specific index in the hashmap or "" if the index > map elements. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can. More...
integer function	hashmap_integer_at (specificmap, i)
	Retrieves the value held at the specific hashmap index. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can. More...
character(len=string_length) function	hashmap_string_at (specificmap, i)
	Retrieves the value held at the specific hashmap index. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can. More...
integer function	hashmap_real_at (specificmap, i)
	Retrieves the value held at the specific hashmap index. Converts between precision and from int. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can. More...
logical function	hashmap_logical_at (specificmap, i)
	Retrieves the value held at the specific hashmap index. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can. More...
class(*) function, pointer	hashmap_generic_at (specificmap, i)
	Retrieves the value held at the specific hashmap index or null if index > map elements. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can. More...
logical function	hashmap_integer_entry_at (specificmap, i, key, int_val)
	Retrieves the entry at a specific map index. More...
logical function	hashmap_string_entry_at (specificmap, i, key, str_val)
	Retrieves the entry at a specific map index. More...
logical function	hashmap_real_entry_at (specificmap, i, key, real_val)
	Retrieves the entry at a specific map index. This converts between precision and from int. More...
logical function	hashmap_logical_entry_at (specificmap, i, key, logical_val)
	Retrieves the entry at a specific map index. More...
logical function	hashmap_generic_entry_at (specificmap, i, key, val)
	Retrieves the entry at a specific map index or null if index > map elements. More...
subroutine	hashmap_remove (specificmap, key)
	Removes a specific key-value pair from the hashmap. More...
integer function	hashmap_get_int (specificmap, key)
	Gets a specific element out of the hashmap with the corresponding key. More...
character(len=string_length) function	hashmap_get_string (specificmap, key)
	Gets a specific element out of the hashmap with the corresponding key. More...
real(kind=default_precision) function	hashmap_get_real (specificmap, key)
	Gets a specific element out of the hashmap with the corresponding key. Converts between precision and from int. More...
logical function	hashmap_get_logical (specificmap, key)
	Gets a specific element out of the hashmap with the corresponding key. More...
class(*) function, pointer	hashmap_get_generic (specificmap, key)
	Gets a specific element out of the hashmap with the corresponding key. More...
class(*) function, pointer	hashmap_getnode (specificmap, key, key_location)
	This gets the hashmap node that the key represents (rather than the specific value) More...
class(*) function, pointer	hashmap_getnode_atindex (specificmap, index)
	This gets the hashmap node at a specific index, from the first hash linked list to the end. More...
integer function	hashmap_size (specificmap)
	Returns the number of elements in the hashmap. More...
logical function	hashmap_is_empty (specificmap)
	Returns whether a hashmap is empty. More...
subroutine	hashmap_free (specificmap)
	Frees up all the allocatable, heap, memory associated with a specific hashmap. More...
type(iterator_type) function	hashset_get_iterator (specificset)
	Retrieves an iterator representation of the hashset, ready to access the first element. More...
subroutine	hashset_add (specificset, key)
	Adds a string to the hashset which stores unique strings, therefore if the string already exists then this is ignored. More...
subroutine	hashset_remove (specificset, key)
	Removes a string from the hashset. More...
logical function	hashset_contains (specificset, key)
	Determines wheter the hashset contains a specific key or not. More...
subroutine	hashset_getlocation (specificset, key, hash, key_location)
	Determines the location and hash of a key within a specific hashset. The hash is set regardless of whether the key is found (assuming the set data structure is allocated) and corresponds to the entry in the hash table. The location is set if the key is found and is the entry in the linked list of a specific hash table entry. This is zero if no key is in the hash set. More...
logical function	hashset_is_empty (specificset)
	Determines whether or not the hashset is empty. More...
character(len=string_length) function	hashset_get_string (specificset, index)
	Retrieves the key at index i from the set or empty string if index < list size. More...
subroutine	hashset_free (specificset)
	Frees up all the allocatable, heap, memory associated with a specific set. More...
integer function	hashset_size (specificset)
	Returns the number of elements in a list. More...
integer function	get_hashkey (key)
	Translates the string key into a hash from 1 to hash_size (inclusive.) This encoding is deterministic, so will result in the same hash for a key on multiple calls and is therefore used as the basis of our hashing collections. More...
type(iterator_type) function	stack_get_iterator (specificstack)
	Retrieves an iterator representation of the stack, ready to access the first element. More...
subroutine	stack_push_int (specificstack, int_data)
	Pushes an element onto the stack (LIFO) More...
subroutine	stack_push_string (specificstack, str_data)
	Pushes an element onto the stack (LIFO) More...
subroutine	stack_push_real (specificstack, real_data)
	Pushes an element onto the stack (LIFO) More...
subroutine	stack_push_logical (specificstack, logical_data)
	Pushes an element onto the stack (LIFO) More...
subroutine	stack_push_generic (specificstack, data, memory_allocation_automatic)
	Pushes an element onto the stack (LIFO) More...
integer function	stack_pop_int (specificstack)
	Pops an element off the stack (LIFO) More...
character(len=string_length) function	stack_pop_string (specificstack)
	Pops an element off the stack (LIFO) More...
real(kind=default_precision) function	stack_pop_real (specificstack)
	Pops an element off the stack (LIFO). Converts between precision and from int. More...
logical function	stack_pop_logical (specificstack)
	Pops an element off the stack (LIFO) More...
class(*) function, pointer	stack_pop_generic (specificstack)
	Pops an element off the stack (LIFO) More...
integer function	stack_get_int (specificstack, i)
	Gets a specific element from the stack at index specified. More...
character(len=string_length) function	stack_get_string (specificstack, i)
	Gets a specific element from the stack at index specified. More...
real(kind=default_precision) function	stack_get_real (specificstack, i)
	Gets a specific element from the stack at index specified. Converts between precision and from int. More...
logical function	stack_get_logical (specificstack, i)
	Gets a specific element from the stack at index specified. More...
class(*) function, pointer	stack_get_generic (specificstack, i)
	Gets a specific element from the stack at index specified or null if the index > stack size. More...
integer function	stack_size (specificstack)
	Returns the number of elements held on the stack. More...
logical function	stack_is_empty (specificstack)
	Returns whether a stack is empty. More...
subroutine	stack_free (specificstack)
	Frees up all the allocatable, heap, memory associated with a specific stack. More...
type(iterator_type) function	queue_get_iterator (specificqueue)
	Retrieves an iterator representation of the queue, ready to access the first element. More...
subroutine	queue_push_int (specificqueue, int_data)
	Adds an element to the end of the queue (FIFO) More...
subroutine	queue_push_string (specificqueue, str_data)
	Adds an element to the end of the queue (FIFO) More...
subroutine	queue_push_real (specificqueue, real_data)
	Adds an element to the end of the queue (FIFO) More...
subroutine	queue_push_logical (specificqueue, logical_data)
	Adds an element to the end of the queue (FIFO) More...
subroutine	queue_push_generic (specificqueue, data, memory_allocation_automatic)
	Adds an element to the end of the queue (FIFO) More...
integer function	queue_pop_int (specificqueue)
	Pops the queue element off the head of the queue (FIFO) More...
character(len=string_length) function	queue_pop_string (specificqueue)
	Pops the queue element off the head of the queue (FIFO) More...
real(kind=default_precision) function	queue_pop_real (specificqueue)
	Pops the queue element off the head of the queue (FIFO). Converts between precision and from int. More...
logical function	queue_pop_logical (specificqueue)
	Pops the queue element off the head of the queue (FIFO) More...
class(*) function, pointer	queue_pop_generic (specificqueue)
	Pops the queue element off the head of the queue (FIFO) More...
integer function	queue_get_int (specificqueue, i)
	Returns a specific queue element at an index. More...
character(len=string_length) function	queue_get_string (specificqueue, i)
	Returns a specific queue element at an index. More...
real(kind=default_precision) function	queue_get_real (specificqueue, i)
	Returns a specific queue element at an index. Converts between precision and from int. More...
logical function	queue_get_logical (specificqueue, i)
	Returns a specific queue element at an index. More...
class(*) function, pointer	queue_get_generic (specificqueue, i)
	Returns a specific queue element at an index or null if index > queue size. More...
integer function	queue_size (specificqueue)
	Returns the number of elements held in a queue. More...
logical function	queue_is_empty (specificqueue)
	Returns whether a queue is empty. More...
subroutine	queue_free (specificqueue)
	Frees up all the allocatable, heap, memory associated with a specific queue. More...
type(iterator_type) function	list_get_iterator (specificlist)
	Retrieves an iterator representation of the list, ready to access the first element. More...
subroutine	list_insert_int (specificlist, int_data, i)
	Inserts an element into the list or places at the end if the index > list size. More...
subroutine	list_insert_string (specificlist, str_data, i)
	Inserts an element into the list or places at the end if the index > list size. More...
subroutine	list_insert_real (specificlist, real_data, i)
	Inserts an element into the list or places at the end if the index > list size. More...
subroutine	list_insert_logical (specificlist, logical_data, i)
	Inserts an element into the list or places at the end if the index > list size. More...
subroutine	list_insert_generic (specificlist, data, i, memory_allocation_automatic)
	Inserts an element into the list or places at the end if the index > list size. More...
subroutine	list_add_int (specificlist, int_data)
	Adds an element to the end of the list. More...
subroutine	list_add_string (specificlist, str_data)
	Adds an element to the end of the list. More...
subroutine	list_add_real (specificlist, real_data)
	Adds an element to the end of the list. More...
subroutine	list_add_logical (specificlist, logical_data)
	Adds an element to the end of the list. More...
subroutine	list_add_generic (specificlist, data, memory_allocation_automatic)
	Adds an element to the end of the list. More...
subroutine	list_remove (specificlist, i)
	Removes an element from the list at a specific index. More...
logical function	list_is_empty (specificlist)
	Determines whether or not the list is empty. More...
integer function	list_get_int (specificlist, i)
	Retrieves the element at index i from the list. More...
character(len=string_length) function	list_get_string (specificlist, i)
	Retrieves the element at index i from the list. More...
real(kind=default_precision) function	list_get_real (specificlist, i)
	Retrieves the element at index i from the list. Converts between precision and from int. More...
logical function	list_get_logical (specificlist, i)
	Retrieves the element at index i from the list. More...
class(*) function, pointer	list_get_generic (specificlist, i)
	Retrieves the element at index i from the list or null if index < list size. More...
subroutine	list_free (specificlist)
	Frees up all the allocatable, heap, memory associated with a specific list. More...
integer function	list_size (specificlist)
	Returns the number of elements in a list. More...
logical function	iteratior_has_next (iterator)
	Deduces whether an iterator has a next entry or not. More...
integer function	iterator_get_next_integer (iterator)
	Returns the next integer referenced by the iterator and advanced it, or an error if it has reached the end of iteration. More...
character(len=string_length) function	iterator_get_next_string (iterator)
	Returns the next string referenced by the iterator and advanced it, or an error if it has reached the end of iteration. More...
real(kind=default_precision) function	iterator_get_next_real (iterator)
	Returns the next real (double precision) referenced by the iterator and advanced it, or an error if it has reached the end of iteration. More...
logical function	iterator_get_next_logical (iterator)
	Returns the next logical referenced by the iterator and advanced it, or an error if it has reached the end of iteration. More...
type(mapentry_type) function	iterator_get_next_mapentry (iterator)
	Returns the next mapentry referenced by the iterator and advanced it, or an error if it has reached the end of iteration or the next item was not a mapentry. More...
class(*) function, pointer	iterator_get_next_generic (iterator)
	Returns the next generic referenced by the iterator and advanced it, or null if it has reached the end of iteration. More...
integer function	mapentry_get_int (mapentry_item)
	Retrieves the integer value from a map entry. More...
character(len=string_length) function	mapentry_get_string (mapentry_item)
	Retrieves the string value from a map entry. More...
real(kind=default_precision) function	mapentry_get_real (mapentry_item)
	Retrieves the double precision real value from a map entry. More...
logical function	mapentry_get_logical (mapentry_item)
	Retrieves the logical value from a map entry. More...
class(*) function, pointer	mapentry_get_generic (mapentry_item)
	Retrieves the generic value from a map entry. More...

Variables
integer, parameter, private	hash_size = 4993
	Number of entries in the hash table, this is a tradeoff - larger means more memory but smaller runtime assuming a hashing function with good distribution. More...

Detailed Description

Collection data structures.

The collections utilities which provide common collection structures for different components of MONC. Currently a list, map, stack and queue all with appropriate functionality are provided. The core of all collections is currently a doubly linked list, this is abstracted to allow for the internal structure of collections to change without requiring any user code modifications.

Function/Subroutine Documentation

get_hashkey()

integer function collections_mod::get_hashkey ( character(len=*), intent(in)  key )

private

Translates the string key into a hash from 1 to hash_size (inclusive.) This encoding is deterministic, so will result in the same hash for a key on multiple calls and is therefore used as the basis of our hashing collections.

Parameters

key	The key to find the hash code for

Returns

The corresponding hash code

Definition at line 2161 of file collections.F90.

    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

Here is the caller graph for this function:

hashmap_contains_key()

logical function collections_mod::hashmap_contains_key ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Determines whether or not a hashmap contains a specific key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key we are looking up

Returns

Whether the map contains the key

Definition at line 1403 of file collections.F90.

    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)

Here is the call graph for this function:

hashmap_free()

subroutine collections_mod::hashmap_free ( type(hashmap_type), intent(inout)  specificmap )

private

Frees up all the allocatable, heap, memory associated with a specific hashmap.

This basically acts like a clear operation and once freed the data structure can be reused Note that it does not free the value at all as this might be referenced else where in the code Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap

The hashmap to delete all members and free all allocated memory of

Definition at line 1892 of file collections.F90.

    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

hashmap_generic_at()

class(*) function, pointer collections_mod::hashmap_generic_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the value held at the specific hashmap index or null if index > map elements. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
i	Index to get value from

Returns

Pointer to the generic value

Definition at line 1528 of file collections.F90.

    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

Here is the call graph for this function:

Here is the caller graph for this function:

hashmap_generic_entry_at()

logical function collections_mod::hashmap_generic_entry_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, class(*), intent(out), pointer  val  )

private

Retrieves the entry at a specific map index or null if index > map elements.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	Generic pointer to corresponding value

Definition at line 1640 of file collections.F90.

    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.

Here is the call graph for this function:

Here is the caller graph for this function:

hashmap_get_generic()

class(*) function, pointer collections_mod::hashmap_get_generic ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the hashmap with the corresponding key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
key	Look up key

Returns

Pointer to the generic value associated with the key or null if none exists

Definition at line 1774 of file collections.F90.

    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()

Here is the call graph for this function:

Here is the caller graph for this function:

hashmap_get_int()

integer function collections_mod::hashmap_get_int ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the hashmap with the corresponding key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
key	Look up key

Returns

Integer value associated with the key or raises an error if none is found

Definition at line 1695 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_get_iterator()

type(iterator_type) function collections_mod::hashmap_get_iterator ( type(hashmap_type), intent(inout)  specificmap )

private

Retrieves an iterator representation of the hashmap, ready to access the first element.

Parameters

specificmap

Specific collection to base this iterator on

Returns

The iterator ready to access the first element

Definition at line 1255 of file collections.F90.

    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

hashmap_get_logical()

logical function collections_mod::hashmap_get_logical ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the hashmap with the corresponding key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
key	Look up key

Returns

Logical value associated with the key or raises an error if none is found

Definition at line 1756 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_get_real()

real(kind=default_precision) function collections_mod::hashmap_get_real ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the hashmap with the corresponding key. Converts between precision and from int.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
key	Look up key

Returns

Double precision real value associated with the key or raises an error if none is found

Definition at line 1731 of file collections.F90.

    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

Here is the call graph for this function:

hashmap_get_string()

character(len=string_length) function collections_mod::hashmap_get_string ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the hashmap with the corresponding key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
key	Look up key

Returns

String value associated with the key or raises an error if none is found

Definition at line 1713 of file collections.F90.

    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)

Here is the call graph for this function:

hashmap_getnode()

class(*) function, pointer collections_mod::hashmap_getnode ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key, integer, intent(out), optional  key_location  )

private

This gets the hashmap node that the key represents (rather than the specific value)

It allows us to twiddle with map properties but also grab the value out too Optionally provides us with the list index that the specific node was found at

Parameters

specificmap	The specific hashmap involved
key	Lookup key
foundindex	(Optional) index where the node is currently held (in that hash list)

Returns

The pointer to the generic map node data structure

Definition at line 1798 of file collections.F90.

    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

Here is the call graph for this function:

Here is the caller graph for this function:

hashmap_getnode_atindex()

class(*) function, pointer collections_mod::hashmap_getnode_atindex ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  index  )

private

This gets the hashmap node at a specific index, from the first hash linked list to the end.

Parameters

specificmap	The specific hashmap involved
index	Index to locate at

Returns

The pointer to the generic map node data structure

Definition at line 1842 of file collections.F90.

    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

Here is the call graph for this function:

Here is the caller graph for this function:

hashmap_integer_at()

integer function collections_mod::hashmap_integer_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the value held at the specific hashmap index. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
i	Index to get value from

Returns

Integer value or raises an error if none is found

Definition at line 1445 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_integer_entry_at()

logical function collections_mod::hashmap_integer_entry_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, integer, intent(out)  int_val  )

private

Retrieves the entry at a specific map index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	Integer value or raises an error if none is found

Definition at line 1553 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_is_empty()

logical function collections_mod::hashmap_is_empty ( type(hashmap_type), intent(inout)  specificmap )

private

Returns whether a hashmap is empty.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap

The specific hashmap involved

Returns

Whether the map is empty

Definition at line 1880 of file collections.F90.

    type(hashmap_type), intent(inout) :: specificmap
 
    hashmap_is_empty=(specificmap%size == 0)

hashmap_key_at()

character(len=string_length) function collections_mod::hashmap_key_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the key currently being held at a specific index in the hashmap or "" if the index > map elements. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
i	The index to retrieve the key from

Returns

The key string

Definition at line 1420 of file collections.F90.

    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

Here is the call graph for this function:

hashmap_logical_at()

logical function collections_mod::hashmap_logical_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the value held at the specific hashmap index. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
i	Index to get value from

Returns

Logical value or raises an error if none is found

Definition at line 1509 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_logical_entry_at()

logical function collections_mod::hashmap_logical_entry_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, logical, intent(out)  logical_val  )

private

Retrieves the entry at a specific map index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	Logical value or raises an error if none is found

Definition at line 1620 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_put_generic()

subroutine collections_mod::hashmap_put_generic ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key, class(*), intent(in), pointer  data, logical, intent(in)  memory_allocation_automatic  )

private

Puts a specific key-value pair into the hashmap.

If the key is not already held in the hashmap then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique). This uses a hashing function for performance Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	Pointer to the generic data value to place in the map
memory_allocation_automatic	Whether the collections API should manage the freeing of memory

Definition at line 1364 of file collections.F90.

    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

Here is the call graph for this function:

Here is the caller graph for this function:

hashmap_put_int()

subroutine collections_mod::hashmap_put_int ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key, integer, intent(in)  int_data  )

private

Puts a specific key-value pair into the hashmap.

If the key is not already held in the hashmap then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique). This uses a hashing function for performance Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	Integer data value to place in the map

Definition at line 1283 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_put_logical()

subroutine collections_mod::hashmap_put_logical ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key, logical, intent(in)  logical_data  )

private

Puts a specific key-value pair into the hashmap.

If the key is not already held in the hashmap then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique). This uses a hashing function for performance Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	Logical data value to place in the map

Definition at line 1343 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_put_real()

subroutine collections_mod::hashmap_put_real ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key, real(kind=default_precision), intent(in)  real_data  )

private

Puts a specific key-value pair into the hashmap.

If the key is not already held in the hashmap then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique). This uses a hashing function for performance Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	Double precision real data value to place in the map

Definition at line 1323 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_put_string()

subroutine collections_mod::hashmap_put_string ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key, character(len=string_length), intent(in)  str_data  )

private

Puts a specific key-value pair into the hashmap.

If the key is not already held in the hashmap then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique). This uses a hashing function for performance Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	String data value to place in the map

Definition at line 1303 of file collections.F90.

    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.)

Here is the call graph for this function:

hashmap_real_at()

integer function collections_mod::hashmap_real_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the value held at the specific hashmap index. Converts between precision and from int. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
i	Index to get value from

Returns

Double precision real value or raises an error if none is found

Definition at line 1483 of file collections.F90.

    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

Here is the call graph for this function:

hashmap_real_entry_at()

logical function collections_mod::hashmap_real_entry_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, real(kind=default_precision), intent(out)  real_val  )

private

Retrieves the entry at a specific map index. This converts between precision and from int.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	Double precision realvalue or raises an error if none is found

Definition at line 1593 of file collections.F90.

    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

Here is the call graph for this function:

hashmap_remove()

subroutine collections_mod::hashmap_remove ( type(hashmap_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Removes a specific key-value pair from the hashmap.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
key	Key of the key-value pair to remove from the map

Definition at line 1667 of file collections.F90.

    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

Here is the call graph for this function:

hashmap_size()

integer function collections_mod::hashmap_size ( type(hashmap_type), intent(inout)  specificmap )

private

Returns the number of elements in the hashmap.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap

The specific hashmap involved

Returns

Number of key-value pairs held in the map

Definition at line 1869 of file collections.F90.

    type(hashmap_type), intent(inout) :: specificmap
 
    hashmap_size=specificmap%size

hashmap_string_at()

character(len=string_length) function collections_mod::hashmap_string_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the value held at the specific hashmap index. Note that this is an expensive operation has it has to potentially process all internal hashed lists so avoid if can.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific hashmap involved
i	Index to get value from

Returns

String value or raises an error if none is found

Definition at line 1464 of file collections.F90.

    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)

Here is the call graph for this function:

hashmap_string_entry_at()

logical function collections_mod::hashmap_string_entry_at ( type(hashmap_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, character(len=string_length), intent(out)  str_val  )

private

Retrieves the entry at a specific map index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	String value or raises an error if none is found

Definition at line 1573 of file collections.F90.

    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)

Here is the call graph for this function:

hashset_add()

subroutine collections_mod::hashset_add ( type(hashset_type), intent(inout)  specificset, character(len=*), intent(in)  key  )

private

Adds a string to the hashset which stores unique strings, therefore if the string already exists then this is ignored.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificset	The specific set involved
key	The string key to add to the set

Definition at line 1958 of file collections.F90.

    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

Here is the call graph for this function:

hashset_contains()

logical function collections_mod::hashset_contains ( type(hashset_type), intent(inout)  specificset, character(len=*), intent(in)  key  )

private

Determines wheter the hashset contains a specific key or not.

Parameters

specificset	The specific set involved
key	The string key to test for

Returns

Whether the hashset contains this key or not

Definition at line 2005 of file collections.F90.

    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)

Here is the call graph for this function:

hashset_free()

subroutine collections_mod::hashset_free ( type(hashset_type), intent(inout)  specificset )

private

Frees up all the allocatable, heap, memory associated with a specific set.

This basically acts like a clear operation and once freed the data structure can be reused Note that it does not free the data memory at all as this might be referenced else where in the code Do not call directly from external module, this is called via the appropriate interface

Parameters

specificset

The set to delete all members and free all allocated memory of

Definition at line 2114 of file collections.F90.

    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

hashset_get_iterator()

type(iterator_type) function collections_mod::hashset_get_iterator ( type(hashset_type), intent(inout)  specificset )

private

Retrieves an iterator representation of the hashset, ready to access the first element.

Parameters

specificset

Specific collection to base this iterator on

Returns

The iterator ready to access the first element

Definition at line 1933 of file collections.F90.

    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

hashset_get_string()

character(len=string_length) function collections_mod::hashset_get_string ( type(hashset_type), intent(inout)  specificset, integer, intent(in)  index  )

private

Retrieves the key at index i from the set or empty string if index < list size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificset	The specific set involved
i	Index to look up

Returns

The corresponding key at this location or empty string if none is found

Definition at line 2078 of file collections.F90.

    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

Here is the call graph for this function:

hashset_getlocation()

subroutine collections_mod::hashset_getlocation ( type(hashset_type), intent(inout)  specificset, character(len=*), intent(in)  key, integer, intent(out)  hash, integer, intent(out)  key_location  )

private

Determines the location and hash of a key within a specific hashset. The hash is set regardless of whether the key is found (assuming the set data structure is allocated) and corresponds to the entry in the hash table. The location is set if the key is found and is the entry in the linked list of a specific hash table entry. This is zero if no key is in the hash set.

Parameters

specificset	The specific set involved
key	The string key to locate
hash	The hash code of the key
key_location	Key location (relative to the hash table entry) or zero if no key is found

Definition at line 2023 of file collections.F90.

    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

Here is the call graph for this function:

Here is the caller graph for this function:

hashset_is_empty()

logical function collections_mod::hashset_is_empty ( type(hashset_type), intent(in)  specificset )

private

Determines whether or not the hashset is empty.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificset

The specific set involved

Returns

Whether the set is empty or not

Definition at line 2066 of file collections.F90.

    type(hashset_type), intent(in) :: specificset
 
    hashset_is_empty = specificset%size == 0

hashset_remove()

subroutine collections_mod::hashset_remove ( type(hashset_type), intent(inout)  specificset, character(len=*), intent(in)  key  )

private

Removes a string from the hashset.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificset	The specific ste involved
key	The string key to remove

Definition at line 1987 of file collections.F90.

    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

Here is the call graph for this function:

hashset_size()

integer function collections_mod::hashset_size ( type(hashset_type), intent(in)  specificset )

private

Returns the number of elements in a list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist

The specific list involved

Returns

Number of list elements

Definition at line 2151 of file collections.F90.

    type(hashset_type), intent(in) :: specificset
 
    hashset_size = specificset%size

iteratior_has_next()

logical function collections_mod::iteratior_has_next ( type(iterator_type), intent(inout)  iterator )

private

Deduces whether an iterator has a next entry or not.

Parameters

iterator

The iterator to test upon

Returns

Whether there is a next entry to access

Definition at line 3184 of file collections.F90.

    type(iterator_type), intent(inout) :: iterator
 
    iteratior_has_next=associated(iterator%next_item)

iterator_get_next_generic()

class(*) function, pointer collections_mod::iterator_get_next_generic ( type(iterator_type), intent(inout)  iterator )

private

Returns the next generic referenced by the iterator and advanced it, or null if it has reached the end of iteration.

Parameters

iterator

The iterator of which to access and advance the next element

Returns

The next generic or null if none is found

Definition at line 3294 of file collections.F90.

    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

Here is the caller graph for this function:

iterator_get_next_integer()

integer function collections_mod::iterator_get_next_integer ( type(iterator_type), intent(inout)  iterator )

private

Returns the next integer referenced by the iterator and advanced it, or an error if it has reached the end of iteration.

Parameters

iterator

The iterator of which to access and advance the next element

Returns

The next integer

Definition at line 3193 of file collections.F90.

    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

Here is the call graph for this function:

iterator_get_next_logical()

logical function collections_mod::iterator_get_next_logical ( type(iterator_type), intent(inout)  iterator )

private

Returns the next logical referenced by the iterator and advanced it, or an error if it has reached the end of iteration.

Parameters

iterator

The iterator of which to access and advance the next element

Returns

The next logical

Definition at line 3254 of file collections.F90.

    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

Here is the call graph for this function:

iterator_get_next_mapentry()

type(mapentry_type) function collections_mod::iterator_get_next_mapentry ( type(iterator_type), intent(inout)  iterator )

private

Returns the next mapentry referenced by the iterator and advanced it, or an error if it has reached the end of iteration or the next item was not a mapentry.

Parameters

iterator

The iterator of which to access and advance the next element

Returns

The next map entry

Definition at line 3271 of file collections.F90.

    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

Here is the call graph for this function:

iterator_get_next_real()

real(kind=default_precision) function collections_mod::iterator_get_next_real ( type(iterator_type), intent(inout)  iterator )

private

Returns the next real (double precision) referenced by the iterator and advanced it,
or an error if it has reached the end of iteration.

Parameters

iterator

The iterator of which to access and advance the next element

Returns

The next double precision real, conversion between single and integers is done automatically

Definition at line 3231 of file collections.F90.

    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

Here is the call graph for this function:

iterator_get_next_string()

character(len=string_length) function collections_mod::iterator_get_next_string ( type(iterator_type), intent(inout)  iterator )

private

Returns the next string referenced by the iterator and advanced it, or an error if it has reached the end of iteration.

Parameters

iterator

The iterator of which to access and advance the next element

Returns

The next string

Definition at line 3209 of file collections.F90.

    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

Here is the call graph for this function:

list_add_generic()

subroutine collections_mod::list_add_generic ( type(list_type), intent(inout)  specificlist, class(*), intent(in), pointer  data, logical, intent(in)  memory_allocation_automatic  )

private

Adds an element to the end of the list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	Pointer to the generic data to add
memory_allocation_automatic	Whether the collections API should manage the freeing of memory

Definition at line 2963 of file collections.F90.

    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

Here is the caller graph for this function:

list_add_int()

subroutine collections_mod::list_add_int ( type(list_type), intent(inout)  specificlist, integer, intent(in)  int_data  )

private

Adds an element to the end of the list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	Integer data to add

Definition at line 2902 of file collections.F90.

    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.)

Here is the call graph for this function:

list_add_logical()

subroutine collections_mod::list_add_logical ( type(list_type), intent(inout)  specificlist, logical, intent(in)  logical_data  )

private

Adds an element to the end of the list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	Logical data to add

Definition at line 2947 of file collections.F90.

    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.)

Here is the call graph for this function:

list_add_real()

subroutine collections_mod::list_add_real ( type(list_type), intent(inout)  specificlist, real(kind=default_precision), intent(in)  real_data  )

private

Adds an element to the end of the list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	Double precision real data to add

Definition at line 2932 of file collections.F90.

    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.)

Here is the call graph for this function:

list_add_string()

subroutine collections_mod::list_add_string ( type(list_type), intent(inout)  specificlist, character(len=string_length), intent(in)  str_data  )

private

Adds an element to the end of the list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	String data to add

Definition at line 2917 of file collections.F90.

    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.)

Here is the call graph for this function:

list_free()

subroutine collections_mod::list_free ( type(list_type), intent(inout)  specificlist )

private

Frees up all the allocatable, heap, memory associated with a specific list.

This basically acts like a clear operation and once freed the data structure can be reused Note that it does not free the data memory at all as this might be referenced else where in the code Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist

The list to delete all members and free all allocated memory of

Definition at line 3145 of file collections.F90.

    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

Here is the caller graph for this function:

list_get_generic()

class(*) function, pointer collections_mod::list_get_generic ( type(list_type), intent(inout)  specificlist, integer, intent(in)  i  )

private

Retrieves the element at index i from the list or null if index < list size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
i	Index to look up

Returns

Pointer to the generic data in the list

Definition at line 3117 of file collections.F90.

    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

Here is the caller graph for this function:

list_get_int()

integer function collections_mod::list_get_int ( type(list_type), intent(inout)  specificlist, integer, intent(in)  i  )

private

Retrieves the element at index i from the list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
i	Index to look up

Returns

Integer data in the list or raises an error if none is found

Definition at line 3038 of file collections.F90.

    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.)

Here is the call graph for this function:

list_get_iterator()

type(iterator_type) function collections_mod::list_get_iterator ( type(list_type), intent(inout)  specificlist )

private

Retrieves an iterator representation of the list, ready to access the first element.

Parameters

specificlist

Specific collection to base this iterator on

Returns

The iterator ready to access the first element

Definition at line 2768 of file collections.F90.

    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

list_get_logical()

logical function collections_mod::list_get_logical ( type(list_type), intent(inout)  specificlist, integer, intent(in)  i  )

private

Retrieves the element at index i from the list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
i	Index to look up

Returns

Logical data in the list or raises an error if none is found

Definition at line 3099 of file collections.F90.

    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.)

Here is the call graph for this function:

list_get_real()

real(kind=default_precision) function collections_mod::list_get_real ( type(list_type), intent(inout)  specificlist, integer, intent(in)  i  )

private

Retrieves the element at index i from the list. Converts between precision and from int.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
i	Index to look up

Returns

Double precision real data in the list or raises an error if none is found

Definition at line 3074 of file collections.F90.

    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

Here is the call graph for this function:

list_get_string()

character(len=string_length) function collections_mod::list_get_string ( type(list_type), intent(inout)  specificlist, integer, intent(in)  i  )

private

Retrieves the element at index i from the list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
i	Index to look up

Returns

String data in the list or raises an error if none is found

Definition at line 3056 of file collections.F90.

    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)

Here is the call graph for this function:

list_insert_generic()

subroutine collections_mod::list_insert_generic ( type(list_type), intent(inout)  specificlist, class(*), intent(in), pointer  data, integer, intent(in)  i, logical, intent(in)  memory_allocation_automatic  )

private

Inserts an element into the list or places at the end if the index > list size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	Pointer to the generic data to insert
i	The list index to insert to

Definition at line 2849 of file collections.F90.

    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

Here is the caller graph for this function:

list_insert_int()

subroutine collections_mod::list_insert_int ( type(list_type), intent(inout)  specificlist, integer, intent(in)  int_data, integer, intent(in)  i  )

private

Inserts an element into the list or places at the end if the index > list size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	Integer data to insert
i	The list index to insert to

Definition at line 2782 of file collections.F90.

    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.)

Here is the call graph for this function:

list_insert_logical()

subroutine collections_mod::list_insert_logical ( type(list_type), intent(inout)  specificlist, logical, intent(in)  logical_data, integer, intent(in)  i  )

private

Inserts an element into the list or places at the end if the index > list size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	Logical data to insert
i	The list index to insert to

Definition at line 2832 of file collections.F90.

    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.)

Here is the call graph for this function:

list_insert_real()

subroutine collections_mod::list_insert_real ( type(list_type), intent(inout)  specificlist, real(kind=default_precision), intent(in)  real_data, integer, intent(in)  i  )

private

Inserts an element into the list or places at the end if the index > list size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	Double precision real data to insert
i	The list index to insert to

Definition at line 2815 of file collections.F90.

    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.)

Here is the call graph for this function:

list_insert_string()

subroutine collections_mod::list_insert_string ( type(list_type), intent(inout)  specificlist, character(len=string_length), intent(in)  str_data, integer, intent(in)  i  )

private

Inserts an element into the list or places at the end if the index > list size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
data	String data to insert
i	The list index to insert to

Definition at line 2798 of file collections.F90.

    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.)

Here is the call graph for this function:

list_is_empty()

logical function collections_mod::list_is_empty ( type(list_type), intent(in)  specificlist )

private

Determines whether or not the list is empty.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist

The specific list involved

Returns

Whether the list is empty or not

Definition at line 3026 of file collections.F90.

    type(list_type), intent(in) :: specificlist
 
    list_is_empty = specificlist%size == 0

Here is the caller graph for this function:

list_remove()

subroutine collections_mod::list_remove ( type(list_type), intent(inout)  specificlist, integer, intent(in)  i  )

private

Removes an element from the list at a specific index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist	The specific list involved
i	Index to remove from

Definition at line 2992 of file collections.F90.

    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

Here is the caller graph for this function:

list_size()

integer function collections_mod::list_size ( type(list_type), intent(in)  specificlist )

private

Returns the number of elements in a list.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificlist

The specific list involved

Returns

Number of list elements

Definition at line 3175 of file collections.F90.

    type(list_type), intent(in) :: specificlist
 
    list_size = specificlist%size

Here is the caller graph for this function:

map_contains_key()

logical function collections_mod::map_contains_key ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Determines whether or not a map contains a specific key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key we are looking up

Returns

Whether the map contains the key

Definition at line 761 of file collections.F90.

    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

Here is the call graph for this function:

map_free()

subroutine collections_mod::map_free ( type(map_type), intent(inout)  specificmap )

private

Frees up all the allocatable, heap, memory associated with a specific map.

This basically acts like a clear operation and once freed the data structure can be reused Note that it does not free the value at all as this might be referenced else where in the code Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap

The map to delete all members and free all allocated memory of

Definition at line 1221 of file collections.F90.

    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

map_generic_at()

class(*) function, pointer collections_mod::map_generic_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the generic value held at the specific map index or null if index > map elements.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from

Returns

Pointer to the generic value

Definition at line 884 of file collections.F90.

    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()

Here is the call graph for this function:

Here is the caller graph for this function:

map_generic_entry_at()

logical function collections_mod::map_generic_entry_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, class(*), intent(out), pointer  val  )

private

Retrieves the entry at a specific map index or null if index > map elements.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	Generic pointer to corresponding value

Definition at line 999 of file collections.F90.

    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.

Here is the call graph for this function:

Here is the caller graph for this function:

map_get_generic()

class(*) function, pointer collections_mod::map_get_generic ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the map with the corresponding key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	Look up key

Returns

Pointer to the generic value associated with the key or null if none exists

Definition at line 1136 of file collections.F90.

    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()

Here is the call graph for this function:

Here is the caller graph for this function:

map_get_int()

integer function collections_mod::map_get_int ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the map with the corresponding key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	Look up key

Returns

Integer value associated with the key or raises an error if none is found

Definition at line 1057 of file collections.F90.

    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.)

Here is the call graph for this function:

map_get_iterator()

type(iterator_type) function collections_mod::map_get_iterator ( type(map_type), intent(inout)  specificmap )

private

Retrieves an iterator representation of the map, ready to access the first element.

Parameters

specificmap

Specific collection to base this iterator on

Returns

The iterator ready to access the first element

Definition at line 627 of file collections.F90.

    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

map_get_logical()

logical function collections_mod::map_get_logical ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the map with the corresponding key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	Look up key

Returns

Logical value associated with the key or raises an error if none is found

Definition at line 1118 of file collections.F90.

    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.)

Here is the call graph for this function:

map_get_real()

real(kind=default_precision) function collections_mod::map_get_real ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the map with the corresponding key. This converts between precision and from ints.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	Look up key

Returns

Real value associated with the key or raises an error if none is found

Definition at line 1093 of file collections.F90.

    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

Here is the call graph for this function:

map_get_string()

character(len=string_length) function collections_mod::map_get_string ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Gets a specific element out of the map with the corresponding key.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	Look up key

Returns

String value associated with the key or raises an error if none is found

Definition at line 1075 of file collections.F90.

    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)

Here is the call graph for this function:

map_getnode()

class(*) function, pointer collections_mod::map_getnode ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key, integer, intent(out), optional  foundindex  )

private

This gets the map node that the key represents (rather than the specific value)

It allows us to twiddle with map properties but also grab the value out too Optionally provides us with the list index that the specific node was found at

Parameters

specificmap	The specific map involved
key	Lookup key
foundindex	(Optional) index where the node is currently held

Returns

The pointer to the generic map node data structure

Definition at line 1160 of file collections.F90.

    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

Here is the caller graph for this function:

map_integer_at()

integer function collections_mod::map_integer_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the integer value held at the specific map index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from

Returns

Integer value or raises an error if none is found

Definition at line 805 of file collections.F90.

    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.)

Here is the call graph for this function:

map_integer_entry_at()

logical function collections_mod::map_integer_entry_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, integer, intent(out)  int_val  )

private

Retrieves the entry at a specific map index or null if index > map elements.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	Integer value or raises an error if none is found

Definition at line 912 of file collections.F90.

    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.)

Here is the call graph for this function:

map_is_empty()

logical function collections_mod::map_is_empty ( type(map_type), intent(inout)  specificmap )

private

Returns whether a map is empty.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap

The specific map involved

Returns

Whether the map is empty

Definition at line 1209 of file collections.F90.

    type(map_type), intent(inout) :: specificmap
 
    map_is_empty = list_is_empty(specificmap%map_ds)

Here is the call graph for this function:

map_key_at()

character(len=string_length) function collections_mod::map_key_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the key currently being held at a specific index in the map or "" if the index > map elements.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	The index to retrieve the key from

Returns

The key string

Definition at line 778 of file collections.F90.

    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=""

Here is the call graph for this function:

map_logical_at()

logical function collections_mod::map_logical_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the logical value held at the specific map index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from

Returns

Logical value or raises an error if none is found

Definition at line 866 of file collections.F90.

    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.)

Here is the call graph for this function:

map_logical_entry_at()

logical function collections_mod::map_logical_entry_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, logical, intent(out)  logical_val  )

private

Retrieves the entry at a specific map index or null if index > map elements.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	Logical value or raises an error if none is found

Definition at line 979 of file collections.F90.

    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.)

Here is the call graph for this function:

map_put_generic()

subroutine collections_mod::map_put_generic ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key, class(*), intent(in), pointer  data, logical, intent(in)  memory_allocation_automatic  )

private

Puts a specific key-value pair into the map.

If the key is not already held in the map then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique) Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	Pointer to the generic data value to place in the map
memory_allocation_automatic	Whether the collections API should manage the freeing of memory

Definition at line 725 of file collections.F90.

    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

Here is the call graph for this function:

Here is the caller graph for this function:

map_put_int()

subroutine collections_mod::map_put_int ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key, integer, intent(in)  int_data  )

private

Puts a specific key-value pair into the map.

If the key is not already held in the map then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique) Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	Integer value to place in the map

Definition at line 644 of file collections.F90.

    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.)

Here is the call graph for this function:

map_put_logical()

subroutine collections_mod::map_put_logical ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key, logical, intent(in)  logical_data  )

private

Puts a specific key-value pair into the map.

If the key is not already held in the map then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique) Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	Logical value to place in the map

Definition at line 704 of file collections.F90.

    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.)

Here is the call graph for this function:

map_put_real()

subroutine collections_mod::map_put_real ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key, real(kind=default_precision), intent(in)  real_data  )

private

Puts a specific key-value pair into the map.

If the key is not already held in the map then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique) Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	Double precision real value to place in the map

Definition at line 684 of file collections.F90.

    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.)

Here is the call graph for this function:

map_put_string()

subroutine collections_mod::map_put_string ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key, character(len=string_length), intent(in)  str_data  )

private

Puts a specific key-value pair into the map.

If the key is not already held in the map then the key-value pair will be added, otherwise the existing key-value pair will be modified to hold this updated value (keys must be unique) Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	The key to place in the map
data	String value to place in the map

Definition at line 664 of file collections.F90.

    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.)

Here is the call graph for this function:

map_real_at()

real(kind=default_precision) function collections_mod::map_real_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the real value held at the specific map index. Converts between precision and int.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from

Returns

Double precision real value or raises an error if none is found

Definition at line 841 of file collections.F90.

    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

Here is the call graph for this function:

map_real_entry_at()

logical function collections_mod::map_real_entry_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, real(kind=default_precision), intent(out)  real_val  )

private

Retrieves the entry at a specific map index or null if index > map elements. This converts precision and from ints.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	Real value or raises an error if none is found

Definition at line 952 of file collections.F90.

    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

Here is the call graph for this function:

map_remove()

subroutine collections_mod::map_remove ( type(map_type), intent(inout)  specificmap, character(len=*), intent(in)  key  )

private

Removes a specific key-value pair from the map.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
key	Key of the key-value pair to remove from the map

Definition at line 1030 of file collections.F90.

    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

Here is the call graph for this function:

map_size()

integer function collections_mod::map_size ( type(map_type), intent(inout)  specificmap )

private

Returns the number of elements in the map.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap

The specific map involved

Returns

Number of key-value pairs held in the map

Definition at line 1198 of file collections.F90.

    type(map_type), intent(inout) :: specificmap
 
    map_size = list_size(specificmap%map_ds)

Here is the call graph for this function:

Here is the caller graph for this function:

map_string_at()

character(len=string_length) function collections_mod::map_string_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i  )

private

Retrieves the string value held at the specific map index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from

Returns

String value or raises an error if none is found

Definition at line 823 of file collections.F90.

    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)

Here is the call graph for this function:

map_string_entry_at()

logical function collections_mod::map_string_entry_at ( type(map_type), intent(inout)  specificmap, integer, intent(in)  i, character(len=*), intent(out)  key, character(len=string_length), intent(out)  str_val  )

private

Retrieves the entry at a specific map index or null if index > map elements.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificmap	The specific map involved
i	Index to get value from
key	The associated key
value	String value or raises an error if none is found

Definition at line 932 of file collections.F90.

    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)

Here is the call graph for this function:

mapentry_get_generic()

class(*) function, pointer collections_mod::mapentry_get_generic ( type(mapentry_type), intent(in)  mapentry_item )

private

Retrieves the generic value from a map entry.

Parameters

mapentry_item

The map entry to retrieve the generic value from

Definition at line 3379 of file collections.F90.

    type(mapentry_type), intent(in) :: mapentry_item
    class(*), pointer :: mapentry_get_generic
    
    mapentry_get_generic=>mapentry_item%value

mapentry_get_int()

integer function collections_mod::mapentry_get_int ( type(mapentry_type), intent(in)  mapentry_item )

private

Retrieves the integer value from a map entry.

Parameters

mapentry_item

The map entry to retrieve the integer value from

Definition at line 3320 of file collections.F90.

    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.)

mapentry_get_logical()

logical function collections_mod::mapentry_get_logical ( type(mapentry_type), intent(in)  mapentry_item )

private

Retrieves the logical value from a map entry.

Parameters

mapentry_item

The map entry to retrieve the logical value from

Definition at line 3366 of file collections.F90.

    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.)

mapentry_get_real()

real(kind=default_precision) function collections_mod::mapentry_get_real ( type(mapentry_type), intent(in)  mapentry_item )

private

Retrieves the double precision real value from a map entry.

Parameters

mapentry_item

The map entry to retrieve the double precision real value from (auto converts from single/ints)

Definition at line 3346 of file collections.F90.

    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

mapentry_get_string()

character(len=string_length) function collections_mod::mapentry_get_string ( type(mapentry_type), intent(in)  mapentry_item )

private

Retrieves the string value from a map entry.

Parameters

mapentry_item

The map entry to retrieve the string value from

Definition at line 3333 of file collections.F90.

    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)

queue_free()

subroutine collections_mod::queue_free ( type(queue_type), intent(inout)  specificqueue )

private

Frees up all the allocatable, heap, memory associated with a specific queue.

This basically acts like a clear operation and once freed the data structure can be reused Note that it does not free the data memory at all as this might be referenced else where in the code Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue

The queue to delete all members and free all allocated memory of

Definition at line 2759 of file collections.F90.

    type(queue_type), intent(inout) :: specificqueue
 
    call list_free(specificqueue%queue_ds)

Here is the call graph for this function:

queue_get_generic()

class(*) function, pointer collections_mod::queue_get_generic ( type(queue_type), intent(inout)  specificqueue, integer, intent(in)  i  )

private

Returns a specific queue element at an index or null if index > queue size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
i	The index to look up

Returns

Pointer to the generic queue element at i or null if the index does not exist

Definition at line 2723 of file collections.F90.

    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)

Here is the call graph for this function:

Here is the caller graph for this function:

queue_get_int()

integer function collections_mod::queue_get_int ( type(queue_type), intent(inout)  specificqueue, integer, intent(in)  i  )

private

Returns a specific queue element at an index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
i	The index to look up

Returns

Integer element at i or raises an error if none is found

Definition at line 2644 of file collections.F90.

    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.)

Here is the call graph for this function:

queue_get_iterator()

type(iterator_type) function collections_mod::queue_get_iterator ( type(queue_type), intent(inout)  specificqueue )

private

Retrieves an iterator representation of the queue, ready to access the first element.

Parameters

specificqueue

Specific collection to base this iterator on

Returns

The iterator ready to access the first element

Definition at line 2472 of file collections.F90.

    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

queue_get_logical()

logical function collections_mod::queue_get_logical ( type(queue_type), intent(inout)  specificqueue, integer, intent(in)  i  )

private

Returns a specific queue element at an index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
i	The index to look up

Returns

Logical element at i or raises an error if none is found

Definition at line 2705 of file collections.F90.

    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.)

Here is the call graph for this function:

queue_get_real()

real(kind=default_precision) function collections_mod::queue_get_real ( type(queue_type), intent(inout)  specificqueue, integer, intent(in)  i  )

private

Returns a specific queue element at an index. Converts between precision and from int.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
i	The index to look up

Returns

Double precision real element at i or raises an error if none is found

Definition at line 2680 of file collections.F90.

    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

Here is the call graph for this function:

queue_get_string()

character(len=string_length) function collections_mod::queue_get_string ( type(queue_type), intent(inout)  specificqueue, integer, intent(in)  i  )

private

Returns a specific queue element at an index.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
i	The index to look up

Returns

String element at i or raises an error if none is found

Definition at line 2662 of file collections.F90.

    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)

Here is the call graph for this function:

queue_is_empty()

logical function collections_mod::queue_is_empty ( type(queue_type), intent(inout)  specificqueue )

private

Returns whether a queue is empty.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue

The specific queue involved

Returns

Whether the queue is empty

Definition at line 2747 of file collections.F90.

    type(queue_type), intent(inout) :: specificqueue
 
    queue_is_empty = list_is_empty(specificqueue%queue_ds)

Here is the call graph for this function:

queue_pop_generic()

class(*) function, pointer collections_mod::queue_pop_generic ( type(queue_type), intent(inout)  specificqueue )

private

Pops the queue element off the head of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue

The specific queue involved

Returns

Pointer to the generic element at head of the queue or null if none

Definition at line 2630 of file collections.F90.

    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)

Here is the call graph for this function:

Here is the caller graph for this function:

queue_pop_int()

integer function collections_mod::queue_pop_int ( type(queue_type), intent(inout)  specificqueue )

private

Pops the queue element off the head of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue

The specific queue involved

Returns

Integer element at head of the queue or raises an error if there is none

Definition at line 2559 of file collections.F90.

    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.)

Here is the call graph for this function:

queue_pop_logical()

logical function collections_mod::queue_pop_logical ( type(queue_type), intent(inout)  specificqueue )

private

Pops the queue element off the head of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue

The specific queue involved

Returns

Logical element at head of the queue or raises an error if there is none

Definition at line 2614 of file collections.F90.

    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.)

Here is the call graph for this function:

queue_pop_real()

real(kind=default_precision) function collections_mod::queue_pop_real ( type(queue_type), intent(inout)  specificqueue )

private

Pops the queue element off the head of the queue (FIFO). Converts between precision and from int.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue

The specific queue involved

Returns

Double precision real element at head of the queue or raises an error if there is none

Definition at line 2591 of file collections.F90.

    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

Here is the call graph for this function:

queue_pop_string()

character(len=string_length) function collections_mod::queue_pop_string ( type(queue_type), intent(inout)  specificqueue )

private

Pops the queue element off the head of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue

The specific queue involved

Returns

String element at head of the queue or raises an error if there is none

Definition at line 2575 of file collections.F90.

    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)

Here is the call graph for this function:

queue_push_generic()

subroutine collections_mod::queue_push_generic ( type(queue_type), intent(inout)  specificqueue, class(*), intent(in), pointer  data, logical, intent(in)  memory_allocation_automatic  )

private

Adds an element to the end of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
data	Pointer to the generic data to add to the queue
memory_allocation_automatic	Whether the collections API should manage the freeing of memory

Definition at line 2546 of file collections.F90.

    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)

Here is the call graph for this function:

Here is the caller graph for this function:

queue_push_int()

subroutine collections_mod::queue_push_int ( type(queue_type), intent(inout)  specificqueue, integer, intent(in)  int_data  )

private

Adds an element to the end of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
data	Integer data to add to the queue

Definition at line 2485 of file collections.F90.

    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.)

Here is the call graph for this function:

queue_push_logical()

subroutine collections_mod::queue_push_logical ( type(queue_type), intent(inout)  specificqueue, logical, intent(in)  logical_data  )

private

Adds an element to the end of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
data	Logical data to add to the queue

Definition at line 2530 of file collections.F90.

    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.)

Here is the call graph for this function:

queue_push_real()

subroutine collections_mod::queue_push_real ( type(queue_type), intent(inout)  specificqueue, real(kind=default_precision), intent(in)  real_data  )

private

Adds an element to the end of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
data	Double precision real data to add to the queue

Definition at line 2515 of file collections.F90.

    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.)

Here is the call graph for this function:

queue_push_string()

subroutine collections_mod::queue_push_string ( type(queue_type), intent(inout)  specificqueue, character(len=string_length), intent(in)  str_data  )

private

Adds an element to the end of the queue (FIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue	The specific queue involved
data	String data to add to the queue

Definition at line 2500 of file collections.F90.

    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.)

Here is the call graph for this function:

queue_size()

integer function collections_mod::queue_size ( type(queue_type), intent(inout)  specificqueue )

private

Returns the number of elements held in a queue.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificqueue

The specific queue involved

Returns

Number of elements in the queue

Definition at line 2736 of file collections.F90.

    type(queue_type), intent(inout) :: specificqueue
 
    queue_size = list_size(specificqueue%queue_ds)

Here is the call graph for this function:

stack_free()

subroutine collections_mod::stack_free ( type(stack_type), intent(inout)  specificstack )

private

Frees up all the allocatable, heap, memory associated with a specific stack.

This basically acts like a clear operation and once freed the data structure can be reused Note that it does not free the data memory at all as this might be referenced else where in the code Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack

The stack to delete all members and free all allocated memory of

Definition at line 2463 of file collections.F90.

    type(stack_type), intent(inout) :: specificstack
 
    call list_free(specificstack%stack_ds)

Here is the call graph for this function:

stack_get_generic()

class(*) function, pointer collections_mod::stack_get_generic ( type(stack_type), intent(inout)  specificstack, integer, intent(in)  i  )

private

Gets a specific element from the stack at index specified or null if the index > stack size.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
i	The index to retrieve the element at

Returns

Pointer to the generic data

Definition at line 2427 of file collections.F90.

    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)

Here is the call graph for this function:

Here is the caller graph for this function:

stack_get_int()

integer function collections_mod::stack_get_int ( type(stack_type), intent(inout)  specificstack, integer, intent(in)  i  )

private

Gets a specific element from the stack at index specified.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
i	The index to retrieve the element at

Returns

Integer data or raises an error if none is found

Definition at line 2348 of file collections.F90.

    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.)

Here is the call graph for this function:

stack_get_iterator()

type(iterator_type) function collections_mod::stack_get_iterator ( type(stack_type), intent(inout)  specificstack )

private

Retrieves an iterator representation of the stack, ready to access the first element.

Parameters

specificstack

Specific collection to base this iterator on

Returns

The iterator ready to access the first element

Definition at line 2176 of file collections.F90.

    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

stack_get_logical()

logical function collections_mod::stack_get_logical ( type(stack_type), intent(inout)  specificstack, integer, intent(in)  i  )

private

Gets a specific element from the stack at index specified.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
i	The index to retrieve the element at

Returns

Logical data or raises an error if none is found

Definition at line 2409 of file collections.F90.

    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.)

Here is the call graph for this function:

stack_get_real()

real(kind=default_precision) function collections_mod::stack_get_real ( type(stack_type), intent(inout)  specificstack, integer, intent(in)  i  )

private

Gets a specific element from the stack at index specified. Converts between precision and from int.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
i	The index to retrieve the element at

Returns

Double precision real data or raises an error if none is found

Definition at line 2384 of file collections.F90.

    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

Here is the call graph for this function:

stack_get_string()

character(len=string_length) function collections_mod::stack_get_string ( type(stack_type), intent(inout)  specificstack, integer, intent(in)  i  )

private

Gets a specific element from the stack at index specified.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
i	The index to retrieve the element at

Returns

String data or raises an error if none is found

Definition at line 2366 of file collections.F90.

    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)

Here is the call graph for this function:

stack_is_empty()

logical function collections_mod::stack_is_empty ( type(stack_type), intent(inout)  specificstack )

private

Returns whether a stack is empty.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack

The specific stack involved

Returns

Whether the stack is empty

Definition at line 2451 of file collections.F90.

    type(stack_type), intent(inout) :: specificstack
 
    stack_is_empty = list_is_empty(specificstack%stack_ds)

Here is the call graph for this function:

stack_pop_generic()

class(*) function, pointer collections_mod::stack_pop_generic ( type(stack_type), intent(inout)  specificstack )

private

Pops an element off the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack

The specific stack involved

Returns

Pointer to the generic data of the last element added to the stack

Definition at line 2334 of file collections.F90.

    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)

Here is the call graph for this function:

Here is the caller graph for this function:

stack_pop_int()

integer function collections_mod::stack_pop_int ( type(stack_type), intent(inout)  specificstack )

private

Pops an element off the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack

The specific stack involved

Returns

Integer data of the last element added to the stack or raises an error if none is found

Definition at line 2263 of file collections.F90.

    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.)

Here is the call graph for this function:

stack_pop_logical()

logical function collections_mod::stack_pop_logical ( type(stack_type), intent(inout)  specificstack )

private

Pops an element off the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack

The specific stack involved

Returns

Logical data of the last element added to the stack or raises an error if none is found

Definition at line 2318 of file collections.F90.

    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.)

Here is the call graph for this function:

stack_pop_real()

real(kind=default_precision) function collections_mod::stack_pop_real ( type(stack_type), intent(inout)  specificstack )

private

Pops an element off the stack (LIFO). Converts between precision and from int.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack

The specific stack involved

Returns

Double precision real data of the last element added to the stack or raises an error if none is found

Definition at line 2295 of file collections.F90.

    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

Here is the call graph for this function:

stack_pop_string()

character(len=string_length) function collections_mod::stack_pop_string ( type(stack_type), intent(inout)  specificstack )

private

Pops an element off the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack

The specific stack involved

Returns

String data of the last element added to the stack or raises an error if none is found

Definition at line 2279 of file collections.F90.

    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)

Here is the call graph for this function:

stack_push_generic()

subroutine collections_mod::stack_push_generic ( type(stack_type), intent(inout)  specificstack, class(*), intent(in), pointer  data, logical, intent(in)  memory_allocation_automatic  )

private

Pushes an element onto the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
data	Pointer to the generic data to push onto the stack
memory_allocation_automatic	Whether the collections API should manage the freeing of memory

Definition at line 2250 of file collections.F90.

    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)

Here is the call graph for this function:

Here is the caller graph for this function:

stack_push_int()

subroutine collections_mod::stack_push_int ( type(stack_type), intent(inout)  specificstack, integer, intent(in)  int_data  )

private

Pushes an element onto the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
data	Integer data to push onto the stack

Definition at line 2189 of file collections.F90.

    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.)

Here is the call graph for this function:

stack_push_logical()

subroutine collections_mod::stack_push_logical ( type(stack_type), intent(inout)  specificstack, logical, intent(in)  logical_data  )

private

Pushes an element onto the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
data	Logical data to push onto the stack

Definition at line 2234 of file collections.F90.

    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.)

Here is the call graph for this function:

stack_push_real()

subroutine collections_mod::stack_push_real ( type(stack_type), intent(inout)  specificstack, real(kind=default_precision), intent(in)  real_data  )

private

Pushes an element onto the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
data	Double precision real data to push onto the stack

Definition at line 2219 of file collections.F90.

    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.)

Here is the call graph for this function:

stack_push_string()

subroutine collections_mod::stack_push_string ( type(stack_type), intent(inout)  specificstack, character(len=string_length), intent(in)  str_data  )

private

Pushes an element onto the stack (LIFO)

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack	The specific stack involved
data	String data to push onto the stack

Definition at line 2204 of file collections.F90.

    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.)

Here is the call graph for this function:

stack_size()

integer function collections_mod::stack_size ( type(stack_type), intent(inout)  specificstack )

private

Returns the number of elements held on the stack.

Do not call directly from external module, this is called via the appropriate interface

Parameters

specificstack

The specific stack involved

Returns

Number of stack elements

Definition at line 2440 of file collections.F90.

    type(stack_type), intent(inout) :: specificstack
 
    stack_size = list_size(specificstack%stack_ds)

Here is the call graph for this function:

Variable Documentation

hash_size

integer, parameter, private collections_mod::hash_size = 4993

private

Number of entries in the hash table, this is a tradeoff - larger means more memory but smaller runtime assuming a hashing function with good distribution.

Definition at line 20 of file collections.F90.

  integer, parameter, private :: hash_size  = 4993