Result type

Author: mzecc

meson.build

@@ -69,6 +69,7 @@ if pyprojectwheelbuild_enabled
     'src/example_fgen_basic/get_wavelength.f90',
     'src/example_fgen_basic/kind_parameters.f90',
     'src/example_fgen_basic/result/result.f90',
+    'src/example_fgen_basic/result/result0D_int.f90',
     'src/example_fgen_basic/result/result_int.f90',
   )
 

src/example_fgen_basic/error_v/error_v.f90

@@ -35,7 +35,9 @@ module m_error_v
 
         private
 
-        procedure, public :: build, finalise
+        procedure, public :: build
+        procedure, public :: finalise
+        final :: clean_up
         ! get_res sort of not needed (?)
         ! get_err sort of not needed (?)
 
@@ -93,4 +95,14 @@ subroutine finalise(self)
 
     end subroutine finalise
 
+    subroutine clean_up(self)
+        !! Finalise the instance (i.e. free/deallocate)
+
+        type(ErrorV), intent(inout) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        call self%finalise()
+
+    end subroutine clean_up
+
 end module m_error_v

src/example_fgen_basic/result/result.f90

@@ -55,7 +55,7 @@ subroutine clean_up(self)
         class(Result), intent(inout) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        if (allocated(self % error_v)) deallocate (self % error_v)
+        deallocate (self % error_v)
 
     end subroutine clean_up
 

src/example_fgen_basic/result/result0D_int.f90

@@ -0,0 +1,98 @@
+!> Result value for integers
+!>
+!> Inspired by the excellent, MIT licensed
+!> https://github.com/samharrison7/fortran-error-handler
+module m_result_int
+
+    use m_error_v, only: ErrorV
+    use m_result, only: Result_base
+
+    implicit none (type, external)
+    private
+
+    type, extends(Result_base), public :: ResultInteger0D
+    !! Result type that holds integer values
+    !!
+    !! Holds either an integer value or an error.
+
+        integer, allocatable :: data_v
+        !! Data i.e. the result (if no error occurs)
+
+        ! class(ErrorV), allocatable :: error_v
+        !! Error
+
+    contains
+
+        private
+
+        procedure, public :: build
+        ! `finalise` and `is_error` come from abstract base class
+        final :: finalise
+
+    end type ResultInteger0D
+
+    interface ResultInteger0D
+    !! Constructor interface - see build (TODO: figure out cross-ref syntax) for details
+        module procedure :: constructor
+    end interface ResultInteger0D
+
+contains
+
+    function constructor(data_v, error_v) result(self)
+        !! Build instance
+
+        type(ResultInteger0D) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        class(ErrorV), intent(inout), optional :: error_v
+        !! Error message
+
+        integer, intent(in), optional :: data_v
+        !! Data
+
+        call self % build(data_v_in=data_v, error_v_in=error_v)
+
+    end function constructor
+
+    function build(data_v_in, error_v_in) result(res)
+        !! Build instance
+
+        class(Result_base), intent(out) :: res
+        ! Hopefully can leave without docstring (like Python)
+
+        integer, intent(in), optional :: data_v_in
+        !! Data
+
+        class(ErrorV), intent(inout), optional :: error_v_in
+        !! Error message
+
+        if (present(data_v_in) .and. present(error_v_in)) then
+            allocate(Result_base :: res)
+            res % error_v % message = "Both data and error were provided"
+        else if (present(data_v_in)) then
+            allocate (ResultInteger0D :: res)
+            allocate (self % data_v, source=data_v_in)
+            ! No error - no need to call res % build
+        else if (present(error_v_in)) then
+            allocate(Result_base :: res)
+            allocate (res % error_v, source=error_v_in)
+            ! No error - no need to call res % build
+        else
+            allocate(Result_base :: res)
+            res % error_v % message = "Neither data nor error were provided"
+        end if
+
+    end function build
+
+    subroutine finalise(self)
+      !! Finalise instance
+
+        type(ResultInteger0D), intent(inout) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        if (allocated(self % data_v)) deallocate (self % data_v)
+        call self % clean_up()
+
+    end subroutine finalise
+
+end module m_result_int