Result-type : 1D integer

Author: mzecc

src/example_fgen_basic/result/result.f90

@@ -38,7 +38,7 @@ module m_result
         ! TODO: Think about whether build should be on the abstract class
         ! or just on each concrete implementation
         procedure, public:: is_error
-        final, public:: finalise
+        procedure, public :: clean_up
 
     end type Result
 
@@ -49,15 +49,15 @@ module m_result
 
 contains
 
-    subroutine finalise(self)
+    subroutine clean_up(self)
         !! Finalise the instance (i.e. free/deallocate)
 
         class(Result), intent(inout) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        if (allocated(self % error_v)) deallocate(self % error_v)
+        if (allocated(self % error_v)) deallocate(self%error_v)
 
-    end subroutine finalise
+    end subroutine clean_up
 
     pure function is_error(self) result(is_err)
         !! Determine whether `self` contains an error or not

src/example_fgen_basic/result/result_int.f90

@@ -10,12 +10,12 @@ module m_result_int
     implicit none
     private
 
-    type, extends(Result), public :: ResultInteger0D
+    type, extends(Result), public :: ResultInteger1D
     !! Result type that holds integer values
     !!
     !! Holds either an integer value or an error.
 
-        integer, allocatable :: data_vvvvv
+        integer, allocatable :: data_v(:)
         !! Data i.e. the result (if no error occurs)
 
        ! class(ErrorV), allocatable :: error_v
@@ -29,55 +29,68 @@ module m_result_int
         ! `finalise` and `is_error` come from abstract base class
         final :: finalise
 
-    end type ResultInteger0D
+    end type ResultInteger1D
 
-    interface ResultInteger0D
+    interface ResultInteger1D
     !! Constructor interface - see build (TODO: figure out cross-ref syntax) for details
         module procedure :: constructor
-    end interface ResultInteger0D
+    end interface ResultInteger1D
 
 contains
 
     function constructor(data_v, error_v) result(self)
         !! Build instance
 
-        type(ResultInteger0D), intent(inout) :: self
+        type(ResultInteger1D) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        class(ErrorV), intent(in) :: error_v
+        class(ErrorV), intent(inout), optional :: error_v
         !! Error message
 
-        integer, optional, intent(in) :: data_v
+        integer, allocatable, intent(in), optional :: data_v(:)
         !! Data
 
-        call self%build(data_v=data_v, error_v=error_v)
+        call self%build(data_v_in=data_v, error_v_in=error_v)
 
     end function constructor
 
-    subroutine build(self, data_v, error_v)
+    subroutine build(self, data_v_in, error_v_in)
         !! Build instance
 
-        type(ResultInteger0D), intent(inout) :: self
+        class(ResultInteger1D), intent(inout) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        integer, optional, intent(in) :: data_v
+        integer, intent(in), optional :: data_v_in(:)
         !! Data
 
-        class(ErrorV), optional, intent(in) :: error_v
+        class(ErrorV), intent(inout), optional :: error_v_in
         !! Error message
 
-        if (present(data_v) .and. present(error_v)) then
-            call self % build(message="Both data and error were provided")
-        elseif (present(data_v)) then
-            allocate(self % data_v, source=data_v)
+        if (present(data_v_in) .and. present(error_v_in)) then
+            error_v_in%message="Both data and error were provided"
+        elseif (present(data_v_in)) then
+            allocate(self % data_v, source=data_v_in)
             ! No error - no need to call res % build
-        elseif (present(error_v)) then
-            allocate(self % error_v, source=error_v)
+        elseif (present(error_v_in)) then
+            allocate(self % error_v, source=error_v_in)
             ! No error - no need to call res % build
         else
-            call self % build(message="Neither data nor error were provided")
+            error_v_in%message="Neither data nor error were provided"
         end if
 
     end subroutine build
 
+    subroutine finalise(self)
+      !! Finalise instance
+
+      type(ResultInteger1D), intent(inout) :: self
+      ! Hopefully can leave without docstring (like Python)
+
+      if (allocated(self%data_v)) deallocate(self%data_v)
+      if (allocated(self%error_v)) call self%clean_up()
+
+    end subroutine finalise
+
+
+
 end module m_result_int