Frees up all the allocatable, heap, memory associated with a list, stack, queue or map. More...

Private Member Functions
subroutine	list_free (specificlist)
	Frees up all the allocatable, heap, memory associated with a specific list. More...

subroutine	stack_free (specificstack)
	Frees up all the allocatable, heap, memory associated with a specific stack. More...

subroutine	queue_free (specificqueue)
	Frees up all the allocatable, heap, memory associated with a specific queue. More...

subroutine	map_free (specificmap)
	Frees up all the allocatable, heap, memory associated with a specific map. More...

subroutine	hashmap_free (specificmap)
	Frees up all the allocatable, heap, memory associated with a specific hashmap. More...

subroutine	hashset_free (specificset)
	Frees up all the allocatable, heap, memory associated with a specific set. More...

Detailed Description

Frees up all the allocatable, heap, memory associated with a list, stack, queue or map.

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 This has a time complexity of O(n)

Parameters

collection The list, stack, queue or map to delete all members and free all allocated memory of

Definition at line 577 of file collections.F90.

Member Function/Subroutine Documentation

◆ hashmap_free()

subroutine collections_mod::c_free::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 1893 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

◆ hashset_free()

subroutine collections_mod::c_free::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 2115 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

◆ list_free()

subroutine collections_mod::c_free::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 3146 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

◆ map_free()

subroutine collections_mod::c_free::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 1222 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

◆ queue_free()

subroutine collections_mod::c_free::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 2760 of file collections.F90.

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

◆ stack_free()

subroutine collections_mod::c_free::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 2464 of file collections.F90.

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

The documentation for this interface was generated from the following file:

/nfs/a277/earlcd/dev/monc/svn-git/monc/model_core/src/utils/collections.F90

Private Member Functions

Detailed Description

Member Function/Subroutine Documentation

◆ hashmap_free()

◆ hashset_free()

◆ list_free()

◆ map_free()

◆ queue_free()

◆ stack_free()