Type mods2

Source/FTObjects/FTDataClass.f90

@@ -123,6 +123,20 @@ SUBROUTINE releaseFTData(self)
          CALL release(obj) 
          IF(.NOT.ASSOCIATED(obj)) self => NULL()
       END SUBROUTINE releaseFTData
+!
+!//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE releaseFTDataClass(self)  
+         IMPLICIT NONE
+         CLASS(FTData)  , POINTER :: self
+         CLASS(FTObject), POINTER :: obj
+
+         IF(.NOT. ASSOCIATED(self)) RETURN
+
+         obj => self
+         CALL release(obj) 
+         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+      END SUBROUTINE releaseFTDataClass
 !@mark -
 !
 !//////////////////////////////////////////////////////////////////////// 

Source/FTObjects/FTDictionaryClass.f90

@@ -107,6 +107,20 @@ SUBROUTINE releaseFTKeyObjectPair(self)
          CALL release(obj) 
          IF(.NOT.ASSOCIATED(obj)) self => NULL()
       END SUBROUTINE releaseFTKeyObjectPair
+!!
+!!//////////////////////////////////////////////////////////////////////// 
+!! 
+!      SUBROUTINE releaseFTKeyObjectPairClass(self)  
+!         IMPLICIT NONE
+!         CLASS(FTKeyObjectPair), POINTER :: self
+!         CLASS(FTObject)       , POINTER :: obj
+!         
+!         IF(.NOT. ASSOCIATED(self)) RETURN
+!         
+!         obj => self
+!         CALL release(obj) 
+!         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+!      END SUBROUTINE releaseFTKeyObjectPairClass
 !
 !//////////////////////////////////////////////////////////////////////// 
 ! 
@@ -316,6 +330,20 @@ SUBROUTINE releaseFTDictionary(self)
       END SUBROUTINE releaseFTDictionary
 !
 !//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE releaseFTDictionaryClass(self)  
+         IMPLICIT NONE
+         CLASS(FTDictionary) , POINTER :: self
+         CLASS(FTObject)     , POINTER :: obj
+
+         IF(.NOT. ASSOCIATED(self)) RETURN
+
+         obj => self
+         CALL release(obj) 
+         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+      END SUBROUTINE releaseFTDictionaryClass
+!
+!//////////////////////////////////////////////////////////////////////// 
 ! 
          SUBROUTINE destructFTDictionary(self)  
             IMPLICIT NONE  

Source/FTObjects/FTExceptionClass.f90

@@ -73,7 +73,8 @@
 !>
 !>### Destruction
 !>
-!>        CALL releaseFTException(e) [pointers]
+!>        CALL releaseFTExceptionClass(e) [pointers]
+!>        CALL releaseFTException(e) [pointers, TYPE]
 !>
 !>###Setting the infoDictionary
 !>
@@ -277,6 +278,20 @@ SUBROUTINE initAssertionFailureException(self,msg,expectedValueObject,observedVa
       END SUBROUTINE initAssertionFailureException
 !
 !//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE releaseFTExceptionClass(self)  
+         IMPLICIT NONE
+         CLASS(FTException) , POINTER :: self
+         CLASS(FTObject)    , POINTER :: obj
+
+         IF(.NOT. ASSOCIATED(self)) RETURN
+
+         obj => self
+         CALL release(obj) 
+         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+      END SUBROUTINE releaseFTExceptionClass
+!
+!//////////////////////////////////////////////////////////////////////// 
 ! 
       SUBROUTINE releaseFTException(self)  
          IMPLICIT NONE
@@ -626,6 +641,27 @@ SUBROUTINE throw(exceptionToThrow)
       END SUBROUTINE throw
 !
 !//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE throwClass(exceptionToThrow)
+!
+!>Throws the exception: exceptionToThrow
+!
+         IMPLICIT NONE  
+         CLASS (FTException), POINTER :: exceptionToThrow
+         CLASS(FTObject)    , POINTER :: ptr => NULL()
+
+         IF ( .NOT.ASSOCIATED(errorStack) )     THEN
+            CALL initializeFTExceptions 
+         END IF 
+
+         ptr => exceptionToThrow
+         CALL errorStack % push(ptr)
+
+         maxErrorLevel = MAX(maxErrorLevel, exceptionToThrow % severity())
+
+      END SUBROUTINE throwClass
+!
+!//////////////////////////////////////////////////////////////////////// 
 ! 
       LOGICAL FUNCTION catchAll()
 !
@@ -718,7 +754,7 @@ LOGICAL FUNCTION catchErrorWithName(exceptionName)
          END IF 
 
          ptr => errorStack
-         CALL iterator % initWithFTLinkedList(ptr)
+         CALL iterator % initWithFTLinkedListClass(ptr)
          CALL iterator % setToStart()
 
          DO WHILE (.NOT.iterator % isAtEnd())
@@ -833,7 +869,7 @@ SUBROUTINE printAllExceptions
          CLASS(FTException) , POINTER :: e         => NULL()
 
         list => errorStack
-        CALL iterator % initWithFTLinkedList(list)
+        CALL iterator % initWithFTLinkedListClass(list)
 !
 !       ----------------------------------------------------
 !       Write out the descriptions of each of the exceptions

Source/FTObjects/FTLinkedListClass.f90

@@ -577,13 +577,27 @@ END FUNCTION numberOfRecords
 !
 !//////////////////////////////////////////////////////////////////////// 
 ! 
-      SUBROUTINE releaseFTLinkedList(self)  
+      SUBROUTINE releaseFTLinkedListClass(self)  
          IMPLICIT NONE
          CLASS (FTLinkedList), POINTER :: self
          CLASS(FTObject)   , POINTER :: obj
 
          IF(.NOT. ASSOCIATED(self)) RETURN
 
+         obj => self
+         CALL release(obj) 
+         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+      END SUBROUTINE releaseFTLinkedListClass
+!
+!//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE releaseFTLinkedList(self)  
+         IMPLICIT NONE
+         TYPE (FTLinkedList), POINTER :: self
+         CLASS(FTObject)   , POINTER :: obj
+
+         IF(.NOT. ASSOCIATED(self)) RETURN
+
          obj => self
          CALL release(obj) 
          IF(.NOT.ASSOCIATED(obj)) self => NULL()
@@ -873,13 +887,15 @@ Module FTLinkedListIteratorClass
 !
          PROCEDURE :: init           => initEmpty
          PROCEDURE :: initWithFTLinkedList
+         PROCEDURE :: initWithFTLinkedListClass
          FINAL     :: destructIterator
          PROCEDURE :: isAtEnd        => FTLinkedListIsAtEnd
          PROCEDURE :: object         => FTLinkedListObject
          PROCEDURE :: currentRecord  => FTLinkedListCurrentRecord
          PROCEDURE :: linkedList     => returnLinkedList
          PROCEDURE :: className      => linkedListIteratorClassName
          PROCEDURE :: setLinkedList
+         PROCEDURE :: setLinkedListClass
          PROCEDURE :: setToStart
          PROCEDURE :: moveToNext
          PROCEDURE :: removeCurrentRecord
@@ -917,7 +933,7 @@ END SUBROUTINE initEmpty
       SUBROUTINE initWithFTLinkedList(self,list) 
          IMPLICIT NONE 
          CLASS(FTLinkedListIterator)  :: self
-         CLASS(FTLinkedList), POINTER :: list
+         TYPE(FTLinkedList), POINTER  :: list
 !
 !        --------------------------------------------
 !        Always call the superclass initializer first
@@ -936,6 +952,30 @@ SUBROUTINE initWithFTLinkedList(self,list)
 
       END SUBROUTINE initWithFTLinkedList   
 !
+!////////////////////////////////////////////////////////////////////////
+!
+      SUBROUTINE initWithFTLinkedListClass(self,list) 
+         IMPLICIT NONE 
+         CLASS(FTLinkedListIterator)  :: self
+         CLASS(FTLinkedList), POINTER :: list
+!
+!        --------------------------------------------
+!        Always call the superclass initializer first
+!        --------------------------------------------
+!
+         CALL self % FTObject % init()
+!
+!        ----------------------------------------------
+!        Then call the initializations for the subclass
+!        ----------------------------------------------
+!
+         self % list    => NULL()
+         self % current => NULL()
+         CALL self % setLinkedListClass(list)
+         CALL self % setToStart()
+
+      END SUBROUTINE initWithFTLinkedListClass   
+!
 !//////////////////////////////////////////////////////////////////////// 
 ! 
       SUBROUTINE releaseFTLinkedListIterator(self)  
@@ -950,6 +990,20 @@ SUBROUTINE releaseFTLinkedListIterator(self)
          IF(.NOT.ASSOCIATED(obj)) self => NULL()
       END SUBROUTINE releaseFTLinkedListIterator
 !
+!//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE releaseFTLinkedListIteratorClass(self)  
+         IMPLICIT NONE
+         CLASS(FTLinkedListIterator), POINTER :: self
+         CLASS(FTObject)   , POINTER :: obj
+
+         IF(.NOT. ASSOCIATED(self)) RETURN
+
+         obj => self
+         CALL release(obj) 
+         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+      END SUBROUTINE releaseFTLinkedListIteratorClass
+!
 !////////////////////////////////////////////////////////////////////////
 !
 !< The destructor must not be called except at the end of destructors of
@@ -1018,14 +1072,51 @@ END FUNCTION FTLinkedListIsAtEnd
 !
 !////////////////////////////////////////////////////////////////////////
 !
-      SUBROUTINE setLinkedList(self,list)
+      SUBROUTINE setLinkedListClass(self,list)
          IMPLICIT NONE 
          CLASS(FTLinkedListIterator)  :: self
          CLASS(FTLinkedList), POINTER :: list
 !
 !        -----------------------------------
 !        Remove current list if there is one
 !        -----------------------------------
+!
+         IF ( ASSOCIATED(list) )     THEN
+
+            IF ( ASSOCIATED(self % list, list) )     THEN
+               CALL self % setToStart()
+            ELSE IF( ASSOCIATED(self % list) )     THEN
+               CALL releaseMemberList(self)
+               self % list => list
+               CALL self % list % retain()
+               CALL self % setToStart
+            ELSE
+               self % list => list
+               CALL self % list % retain()
+               CALL self % setToStart()
+            END IF 
+
+         ELSE
+
+            IF( ASSOCIATED(self % list) )     THEN
+               CALL releaseMemberList(self)
+            END IF 
+            self % list => NULL()
+
+         END IF
+
+      END SUBROUTINE setLinkedListClass   
+!
+!////////////////////////////////////////////////////////////////////////
+!
+      SUBROUTINE setLinkedList(self,list)
+         IMPLICIT NONE 
+         CLASS(FTLinkedListIterator)  :: self
+         TYPE (FTLinkedList), POINTER :: list
+!
+!        -----------------------------------
+!        Remove current list if there is one
+!        -----------------------------------
 !
          IF ( ASSOCIATED(list) )     THEN
 

Source/FTObjects/FTMultiIndexTable.f90

@@ -275,6 +275,20 @@ SUBROUTINE releaseFTMultiIndexTable(self)
       END SUBROUTINE releaseFTMultiIndexTable
 !
 !//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE releaseFTMultiIndexTableClass(self)  
+         IMPLICIT NONE
+         CLASS(FTMultiIndexTable), POINTER :: self
+         CLASS(FTObject)         , POINTER :: obj
+
+         IF(.NOT. ASSOCIATED(self)) RETURN
+
+         obj => self
+         CALL release(obj) 
+         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+      END SUBROUTINE releaseFTMultiIndexTableClass
+!
+!//////////////////////////////////////////////////////////////////////// 
 ! 
       SUBROUTINE destructMultiIndexTable(self)
          IMPLICIT NONE  

Source/FTObjects/FTObjectArrayClass.f90

@@ -172,6 +172,20 @@ SUBROUTINE releaseFTMutableObjectArray(self)
       END SUBROUTINE releaseFTMutableObjectArray
 !
 !//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE releaseFTMutableObjectArrayClass(self)  
+         IMPLICIT NONE
+         CLASS(FTMutableObjectArray), POINTER :: self
+         CLASS(FTObject)            , POINTER :: obj
+
+         IF(.NOT. ASSOCIATED(self)) RETURN
+
+         obj => self
+         CALL release(obj) 
+         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+      END SUBROUTINE releaseFTMutableObjectArrayClass
+!
+!//////////////////////////////////////////////////////////////////////// 
 ! 
 !>
 !> Destructor for the class. This is called automatically when the

Source/FTObjects/FTSparseMatrixClass.f90

@@ -378,7 +378,7 @@ FUNCTION objectInSparseMatrixForKeys(self,i,j) RESULT(r)
 !
          r => NULL()
 
-         CALL self % iterator % setLinkedList(self % table(i) % list)
+         CALL self % iterator % setLinkedListClass(self % table(i) % list)
          DO WHILE (.NOT.self % iterator % isAtEnd())
 
             obj => self % iterator % object()
@@ -424,7 +424,7 @@ FUNCTION SparseMatrixContainsKeys(self,i,j)  RESULT(r)
 !        ----------------------------
 !
          list => self % table(i) % list
-         CALL self % iterator % setLinkedList(list)
+         CALL self % iterator % setLinkedListClass(list)
          CALL self % iterator % setToStart()
          DO WHILE (.NOT.self % iterator % isAtEnd())
 
@@ -455,6 +455,20 @@ SUBROUTINE releaseFTSparseMatrix(self)
       END SUBROUTINE releaseFTSparseMatrix
 !
 !//////////////////////////////////////////////////////////////////////// 
+! 
+      SUBROUTINE releaseFTSparseMatrixClass(self)  
+         IMPLICIT NONE
+         CLASS(FTSparseMatrix), POINTER :: self
+         CLASS(FTObject)      , POINTER :: obj
+
+         IF(.NOT. ASSOCIATED(self)) RETURN
+
+         obj => self
+         CALL release(obj) 
+         IF(.NOT.ASSOCIATED(obj)) self => NULL()
+      END SUBROUTINE releaseFTSparseMatrixClass
+!
+!//////////////////////////////////////////////////////////////////////// 
 ! 
       SUBROUTINE destructSparseMatrix(self)
          IMPLICIT NONE