listmodule Module Reference

Data Types
type	listtype
	A generic heterogeneous doubly-linked list. More...
type	listnodetype
interface	isEqualIface

Functions/Subroutines
subroutine	add (this, objptr)
	Append the given item to the list. More...
subroutine	clear (this, destroy)
	Deallocate all items in list. More...
integer(i4b) function	count (this)
	Return number of nodes in list. More...
logical function	containsobject (this, obj, isEqual)
	Determine whether the list contains the given object. More...
subroutine	deallocatebackward (this, fromNode)
	Deallocate fromNode and all previous nodes, and reassign firstNode. More...
integer(i4b) function	getindex (this, obj)
	Get the index of the given item in the list. More...
class(*) function, pointer	getnextitem (this)
	Get the next item in the list. More...
class(*) function, pointer	getpreviousitem (this)
	Get the previous item in the list. More...
subroutine	insertafter (this, objptr, indx)
	Insert the given item after the given index. More...
subroutine	insertbefore (this, objptr, targetNode)
	Insert the given item before the given node. More...
subroutine	next (this)
	Move the list's current node pointer and index one node forwards. More...
subroutine	previous (this)
	Move the list's current node pointer and index one node backwards. More...
subroutine	reset (this)
	Reset the list's current node pointer and index. More...
subroutine	remove_node_by_index (this, i, destroyValue)
	Remove the node at the given index, optionally destroying its value. More...
subroutine	remove_this_node (this, node, destroyValue)
	Remove the given node, optionally destroying its value. More...
class(*) function, pointer	get_current_item (this)
	Get a pointer to the item at the current node. More...
class(*) function, pointer	get_item_by_index (this, indx)
	Get a pointer to the item at the given index. More...
type(listnodetype) function, pointer	get_node_by_index (this, indx)
	Get the node at the given index. More...
class(*) function, pointer	getitem (this)
	Return a pointer to this node's value. More...
subroutine	deallocvalue (this, destroy)
	Nullify (optionally deallocating) this node's value. More...

Function/Subroutine Documentation

add()

subroutine listmodule::add ( class(listtype), intent(inout)  this, class(*), intent(inout), pointer  objptr  )

private

Definition at line 69 of file List.f90.

    ! -- dummy variables
    class(ListType), intent(inout) :: this
    class(*), pointer, intent(inout) :: objptr
    !
    if (.not. associated(this%firstNode)) then
      allocate (this%firstNode)
      this%firstNode%Value => objptr
      this%firstNode%prevNode => null()
      this%lastNode => this%firstNode
    else
      allocate (this%lastNode%nextNode)
      this%lastNode%nextNode%prevNode => this%lastNode
      this%lastNode%nextNode%value => objptr
      this%lastNode => this%lastNode%nextNode
    end if
    this%nodeCount = this%nodeCount + 1

clear()

subroutine listmodule::clear ( class(listtype)  this, logical, intent(in), optional  destroy  )

private

Definition at line 89 of file List.f90.

    ! -- dummy variables
    class(ListType) :: this
    logical, intent(in), optional :: destroy
    ! -- local
    logical :: destroyLocal
    type(ListNodeType), pointer :: current => null()
    type(ListNodeType), pointer :: next => null()
    !
    destroylocal = .false.
    if (present(destroy)) then
      destroylocal = destroy
    end if
    !
    if (.not. associated(this%firstNode)) return
    ! -- The last node will be deallocated in the loop below.
    !    Just nullify the pointer to the last node to avoid
    !    having a dangling pointer. Also nullify currentNode.
    nullify (this%lastNode)
    nullify (this%currentNode)
    !
    current => this%firstNode
    do while (associated(current))
      ! -- Assign a pointer to the next node in the list
      next => current%nextNode
      ! -- Deallocate the object stored in the current node
      call current%DeallocValue(destroylocal)
      ! -- Deallocate the current node
      deallocate (current)
      this%firstNode => next
      this%nodeCount = this%nodeCount - 1
      ! -- Advance to the next node
      current => next
    end do
    !
    call this%Reset()
 

containsobject()

logical function listmodule::containsobject ( class(listtype), intent(inout)  this, class(*), pointer  obj, procedure(isequaliface), intent(in), optional, pointer  isEqual  )

private

Definition at line 136 of file List.f90.

    class(ListType), intent(inout) :: this
    class(*), pointer :: obj
    procedure(isEqualIface), pointer, intent(in), optional :: isEqual
    logical :: hasObj
    ! local
    type(ListNodeType), pointer :: current => null()
 
    hasobj = .false.
    current => this%firstNode
    do while (associated(current))
      if (present(isequal)) then
        if (isequal(current%Value, obj)) then
          hasobj = .true.
          return
        end if
      else
        if (associated(current%Value, obj)) then
          hasobj = .true.
          return
        end if
      end if
 
      ! -- Advance to the next node
      current => current%nextNode
    end do
 

count()

integer(i4b) function listmodule::count ( class(listtype)  this )

private

Definition at line 129 of file List.f90.

    integer(I4B) :: Count
    class(ListType) :: this
    count = this%nodeCount

deallocatebackward()

subroutine listmodule::deallocatebackward ( class(listtype), intent(inout), target  this, type(listnodetype), intent(inout), pointer  fromNode  )

private

Definition at line 166 of file List.f90.

    ! -- dummy
    class(ListType), target, intent(inout) :: this
    type(ListNodeType), pointer, intent(inout) :: fromNode
    ! -- local
    type(ListNodeType), pointer :: current => null()
    type(ListNodeType), pointer :: prev => null()
    !
    if (associated(fromnode)) then
      ! -- reassign firstNode
      if (associated(fromnode%nextNode)) then
        this%firstNode => fromnode%nextNode
      else
        this%firstNode => null()
      end if
      ! -- deallocate fromNode and all previous nodes
      current => fromnode
      do while (associated(current))
        prev => current%prevNode
        call current%DeallocValue(.true.)
        deallocate (current)
        this%nodeCount = this%nodeCount - 1
        current => prev
      end do
      fromnode => null()
    end if
 

deallocvalue()

subroutine listmodule::deallocvalue ( class(listnodetype), intent(inout)  this, logical, intent(in), optional  destroy  )

private

Definition at line 537 of file List.f90.

    class(ListNodeType), intent(inout) :: this
    logical, intent(in), optional :: destroy
 
    if (associated(this%Value)) then
      if (present(destroy)) then
        if (destroy) then
          deallocate (this%Value)
        end if
      end if
      nullify (this%Value)
    end if

get_current_item()

class(*) function, pointer listmodule::get_current_item ( class(listtype), intent(inout), target  this )

private

Definition at line 405 of file List.f90.

    class(ListType), target, intent(inout) :: this
    ! result
    class(*), pointer :: resultobj
    !
    resultobj => null()
    if (associated(this%currentNode)) then
      resultobj => this%currentNode%Value
    end if

Here is the caller graph for this function:

get_item_by_index()

class(*) function, pointer listmodule::get_item_by_index ( class(listtype), intent(inout)  this, integer(i4b), intent(in)  indx  )

private

Definition at line 417 of file List.f90.

    ! -- dummy
    class(ListType), intent(inout) :: this
    integer(I4B), intent(in) :: indx
    ! result
    class(*), pointer :: resultobj
    ! -- local
    integer(I4B) :: i
    !
    ! -- Initialize
    resultobj => null()
    !
    ! -- Ensure that this%currentNode is associated
    if (.not. associated(this%currentNode)) then
      this%currentNodeIndex = 0
    end if
    if (this%currentNodeIndex == 0) then
      if (associated(this%firstNode)) then
        this%currentNode => this%firstNode
        this%currentNodeIndex = 1
      end if
    end if
    !
    ! -- Check indx position relative to current node index
    i = 0
    if (indx < this%currentNodeIndex) then
      ! Start at beginning of list
      call this%Reset()
      if (associated(this%firstNode)) then
        this%currentNode => this%firstNode
        this%currentNodeIndex = 1
        i = 1
      end if
    else
      i = this%currentNodeIndex
    end if
    if (i == 0) return
    !
    ! -- If current node is requested node,
    !    assign pointer and return
    if (i == indx) then
      resultobj => this%currentNode%Value
      return
    end if
    !
    ! -- Iterate from current node to requested node
    do while (associated(this%currentNode%nextNode))
      this%currentNode => this%currentNode%nextNode
      this%currentNodeIndex = this%currentNodeIndex + 1
      if (this%currentNodeIndex == indx) then
        resultobj => this%currentNode%Value
        return
      end if
    end do

Here is the caller graph for this function:

get_node_by_index()

type(listnodetype) function, pointer listmodule::get_node_by_index ( class(listtype), intent(inout)  this, integer(i4b), intent(in)  indx  )

private

Definition at line 474 of file List.f90.

    ! -- dummy
    class(ListType), intent(inout) :: this
    integer(I4B), intent(in) :: indx
    ! result
    type(ListNodeType), pointer :: resultnode
    ! -- local
    integer(I4B) :: i
    !
    ! -- Initialize
    resultnode => null()
    !
    ! -- Ensure that this%currentNode is associated
    if (this%currentNodeIndex == 0) then
      if (associated(this%firstNode)) then
        this%currentNode => this%firstNode
        this%currentNodeIndex = 1
      end if
    end if
    !
    ! -- Check indx position relative to current node index
    i = 0
    if (indx < this%currentNodeIndex) then
      ! Start at beginning of list
      call this%Reset()
      if (associated(this%firstNode)) then
        this%currentNode => this%firstNode
        this%currentNodeIndex = 1
        i = 1
      end if
    else
      i = this%currentNodeIndex
    end if
    if (i == 0) return
    !
    ! -- If current node is requested node,
    !    assign pointer and return
    if (i == indx) then
      resultnode => this%currentNode
      return
    end if
    !
    ! -- Iterate from current node to requested node
    do while (associated(this%currentNode%nextNode))
      this%currentNode => this%currentNode%nextNode
      this%currentNodeIndex = this%currentNodeIndex + 1
      if (this%currentNodeIndex == indx) then
        resultnode => this%currentNode
        return
      end if
    end do

getindex()

integer(i4b) function listmodule::getindex ( class(listtype), intent(inout), target  this, class(*), pointer  obj  )

private

Definition at line 196 of file List.f90.

    class(ListType), target, intent(inout) :: this
    class(*), pointer :: obj
    integer(I4B) :: idx
    ! local
    integer(I4B) :: i
    class(*), pointer :: obj_in_list
 
    idx = -1
    do i = 1, this%Count()
      obj_in_list => this%GetItem(i)
      if (associated(obj, obj_in_list)) then
        idx = i
        exit
      end if
    end do
 

getitem()

class(*) function, pointer listmodule::getitem ( class(listnodetype), intent(inout)  this )

private

Definition at line 530 of file List.f90.

    class(ListNodeType), intent(inout) :: this
    class(*), pointer :: valueObject
    valueobject => this%Value

Here is the caller graph for this function:

getnextitem()

class(*) function, pointer listmodule::getnextitem ( class(listtype), intent(inout), target  this )

private

Definition at line 216 of file List.f90.

    class(ListType), target, intent(inout) :: this
    class(*), pointer :: resultobj
    call this%Next()
    resultobj => this%get_current_item()

getpreviousitem()

class(*) function, pointer listmodule::getpreviousitem ( class(listtype), intent(inout), target  this )

private

Definition at line 224 of file List.f90.

    class(ListType), target, intent(inout) :: this
    class(*), pointer :: resultobj
    call this%Previous()
    resultobj => this%get_current_item()

insertafter()

subroutine listmodule::insertafter ( class(listtype), intent(inout)  this, class(*), intent(inout), pointer  objptr, integer(i4b), intent(in)  indx  )

private

Definition at line 232 of file List.f90.

    ! -- dummy
    class(ListType), intent(inout) :: this
    class(*), pointer, intent(inout) :: objptr
    integer(I4B), intent(in) :: indx
    ! -- local
    integer(I4B) :: numnodes
    type(ListNodeType), pointer :: precedingNode => null()
    type(ListNodeType), pointer :: followingNode => null()
    type(ListNodeType), pointer :: newNode => null()
    !
    numnodes = this%Count()
    if (indx >= numnodes) then
      call this%Add(objptr)
    else
      precedingnode => this%get_node_by_index(indx)
      if (associated(precedingnode%nextNode)) then
        followingnode => precedingnode%nextNode
        allocate (newnode)
        newnode%Value => objptr
        newnode%nextNode => followingnode
        newnode%prevNode => precedingnode
        precedingnode%nextNode => newnode
        followingnode%prevNode => newnode
        this%nodeCount = this%nodeCount + 1
      else
        call pstop(1, 'Programming error in ListType%insert_after')
      end if
    end if
 

Here is the call graph for this function:

insertbefore()

subroutine listmodule::insertbefore ( class(listtype), intent(inout)  this, class(*), intent(inout), pointer  objptr, type(listnodetype), intent(inout), pointer  targetNode  )

private

Definition at line 265 of file List.f90.

    ! -- dummy
    class(ListType), intent(inout) :: this
    class(*), pointer, intent(inout) :: objptr
    type(ListNodeType), pointer, intent(inout) :: targetNode
    ! -- local
    type(ListNodeType), pointer :: newNode => null()
    !
    if (.not. associated(targetnode)) &
      call pstop(1, 'Programming error in ListType%InsertBefore')
    !
    ! Allocate a new list node and point its Value member to the object
    allocate (newnode)
    newnode%Value => objptr
    !
    ! Do the insertion
    newnode%nextNode => targetnode
    if (associated(targetnode%prevNode)) then
      ! Insert between two nodes
      targetnode%prevNode%nextNode => newnode
      newnode%prevNode => targetnode%prevNode
    else
      ! Insert before first node
      this%firstNode => newnode
      newnode%prevNode => null()
    end if
    targetnode%prevNode => newnode
    this%nodeCount = this%nodeCount + 1
 

Here is the call graph for this function:

next()

subroutine listmodule::next ( class(listtype), intent(inout), target  this )

private

Definition at line 297 of file List.f90.

    class(ListType), target, intent(inout) :: this
 
    if (this%currentNodeIndex == 0) then
      if (associated(this%firstNode)) then
        this%currentNode => this%firstNode
        this%currentNodeIndex = 1
      else
        this%currentNode => null()
        this%currentNodeIndex = 0
      end if
    else
      if (associated(this%currentNode%nextNode)) then
        this%currentNode => this%currentNode%nextNode
        this%currentNodeIndex = this%currentNodeIndex + 1
      else
        this%currentNode => null()
        this%currentNodeIndex = 0
      end if
    end if

previous()

subroutine listmodule::previous ( class(listtype), intent(inout), target  this )

private

Definition at line 320 of file List.f90.

    class(ListType), target, intent(inout) :: this
    if (this%currentNodeIndex <= 1) then
      call this%Reset()
    else
      this%currentNode => this%currentNode%prevNode
      this%currentNodeIndex = this%currentNodeIndex - 1
    end if

remove_node_by_index()

subroutine listmodule::remove_node_by_index ( class(listtype), intent(inout)  this, integer(i4b), intent(in)  i, logical, intent(in)  destroyValue  )

private

Definition at line 338 of file List.f90.

    ! -- dummy
    class(ListType), intent(inout) :: this
    integer(I4B), intent(in) :: i
    logical, intent(in) :: destroyValue
    ! -- local
    type(ListNodeType), pointer :: node
    !
    node => null()
    node => this%get_node_by_index(i)
    if (associated(node)) then
      call this%remove_this_node(node, destroyvalue)
    end if
 

Here is the caller graph for this function:

remove_this_node()

subroutine listmodule::remove_this_node ( class(listtype), intent(inout)  this, type(listnodetype), intent(inout), pointer  node, logical, intent(in)  destroyValue  )

private

Definition at line 355 of file List.f90.

    ! -- dummy
    class(ListType), intent(inout) :: this
    type(ListNodeType), pointer, intent(inout) :: node
    logical, intent(in) :: destroyValue
    ! -- local
    !
    logical :: first, last
    !
    first = .false.
    last = .false.
    if (associated(node)) then
      if (associated(node%prevNode)) then
        if (associated(node%nextNode)) then
          node%nextNode%prevNode => node%prevNode
        else
          node%prevNode%nextNode => null()
          this%lastNode => node%prevNode
        end if
      else
        first = .true.
      end if
      if (associated(node%nextNode)) then
        if (associated(node%prevNode)) then
          node%prevNode%nextNode => node%nextNode
        else
          node%nextNode%prevNode => null()
          this%firstNode => node%nextNode
        end if
      else
        last = .true.
      end if
      if (destroyvalue) then
        call node%DeallocValue(destroyvalue)
      end if
      deallocate (node)
      this%nodeCount = this%nodeCount - 1
      if (first .and. last) then
        this%firstNode => null()
        this%lastNode => null()
        this%currentNode => null()
      end if
      call this%Reset()
    end if
 

Here is the caller graph for this function:

reset()

subroutine listmodule::reset ( class(listtype), intent(inout), target  this )

private

Definition at line 331 of file List.f90.

    class(ListType), target, intent(inout) :: this
    this%currentNode => null()
    this%currentNodeIndex = 0