Errors bubble-up:1

Author: mzecc

meson.build

@@ -57,6 +57,7 @@ if pyprojectwheelbuild_enabled
     'src/example_fgen_basic/get_square_root_wrapper.f90',
     'src/example_fgen_basic/get_wavelength_wrapper.f90',
     'src/example_fgen_basic/result/result_dp_wrapper.f90',
+    'src/example_fgen_basic/result/result_int_wrapper.f90',
   )
 
   # Specify all the other source Fortran files (original files and managers)
@@ -72,11 +73,12 @@ 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/result_none.f90',
     'src/example_fgen_basic/result/result_dp.f90',
     'src/example_fgen_basic/result/result_dp_manager.f90',
     'src/example_fgen_basic/result/result_int.f90',
+    'src/example_fgen_basic/result/result_int_manager.f90',
     'src/example_fgen_basic/result/result_int1D.f90',
-    'src/example_fgen_basic/result/result_none.f90',
   )
 
   # All Python files (wrappers and otherwise)
@@ -94,6 +96,7 @@ if pyprojectwheelbuild_enabled
     'src/example_fgen_basic/pyfgen_runtime/exceptions.py',
     'src/example_fgen_basic/result/__init__.py',
     'src/example_fgen_basic/result/result_dp.py',
+    'src/example_fgen_basic/result/result_int.py',
     'src/example_fgen_basic/typing.py',
   )
 

src/example_fgen_basic/meson.build

@@ -2,7 +2,20 @@ srcs += files(
   'error_v/creation.f90',
   'error_v/error_v.f90',
   'error_v/passing.f90',
+  'error_v/creation_wrapper.f90',
+  'error_v/error_v_manager.f90',
+  'error_v/error_v_wrapper.f90',
+  'error_v/passing_wrapper.f90',
   'fpyfgen/base_finalisable.f90',
   'get_wavelength.f90',
   'kind_parameters.f90',
+  'result/result_dp_manager.f90',
+  'result/result_dp_wrapper.f90',
+  'result/result_int1D.f90',
+  'result/result_int_manager.f90',
+  'result/result_int_wrapper.f90',
+  'result/result_dp.f90',
+  'result/result.f90',
+  'result/result_int.f90',
+  'result/result_none.f90',
 )

src/example_fgen_basic/result/__init__.py

@@ -3,5 +3,6 @@
 """
 
 from example_fgen_basic.result.result_dp import ResultDP
+from example_fgen_basic.result.result_int import ResultInt
 
-__all__ = ["ResultDP"]
+__all__ = ["ResultDP", "ResultInt"]

src/example_fgen_basic/result/result_dp.py

@@ -51,7 +51,7 @@ def from_instance_index(cls, instance_index: int) -> ResultDP:
         """
         # Different wrapping strategies are needed
 
-        # Integer is very simple
+        # Float is very simple
         if m_result_dp_w.data_v_is_set(instance_index):
             data_v: float | None = m_result_dp_w.get_data_v(instance_index)
             # data_v: np.Float64 = m_result_dp_w.get_data_v(instance_index)

src/example_fgen_basic/result/result_dp_manager.f90

@@ -4,6 +4,7 @@ module m_result_dp_manager
     use kind_parameters, only: dp
     use m_error_v, only: ErrorV
     use m_result_dp, only: ResultDP
+    use m_result_int, only: ResultInt
     use m_result_none, only: ResultNone
 
     implicit none(type, external)
@@ -18,7 +19,7 @@ module m_result_dp_manager
 
 contains
 
-    function build_instance(data_v_in, error_v_in) result(instance_index)
+    function build_instance(data_v_in, error_v_in) result(res_available_instance_index)
         !! Build an instance
 
         real(kind=dp), intent(in), optional :: data_v_in
@@ -27,14 +28,18 @@ function build_instance(data_v_in, error_v_in) result(instance_index)
         class(ErrorV), intent(in), optional :: error_v_in
         !! Error message
 
-        integer :: instance_index
+        type(ResultInt) :: res_available_instance_index
         !! Index of the built instance
 
         type(ResultNone) :: res_build
 
         call ensure_instance_array_size_is_at_least(1)
-        call get_available_instance_index(instance_index)
-        res_build = instance_array(instance_index) % build(data_v_in=data_v_in, error_v_in=error_v_in)
+        call get_available_instance_index(res_available_instance_index)
+        ! MZ check for errors ?
+        ! MZ function with side effect: good idea??
+        ! MZ why res_build is ResultNone??
+        res_build = instance_array(res_available_instance_index%data_v) % &
+                                  build(data_v_in=data_v_in, error_v_in=error_v_in)
 
         ! TODO: check build has no error
 
@@ -46,44 +51,46 @@ subroutine finalise_instance(instance_index)
         integer, intent(in) :: instance_index
         !! Index of the instance to finalise
 
-        call check_index_claimed(instance_index)
+        type(ResultNone) :: res_check_index_claimed
+
+        res_check_index_claimed = check_index_claimed(instance_index)
+        if(res_check_index_claimed%is_error()) return
 
         call instance_array(instance_index) % finalise()
         instance_available(instance_index) = .true.
 
     end subroutine finalise_instance
 
-    subroutine get_available_instance_index(available_instance_index)
+    subroutine get_available_instance_index(res_available_instance_index)
         !! Get a free instance index
 
         ! TODO: think through whether race conditions are possible
         ! e.g. while returning a free index number to one Python call
         ! a different one can be looking up a free instance index at the same time
         ! and something goes wrong (maybe we need a lock)
 
-        integer, intent(out) :: available_instance_index
+        type(ResultInt), intent(out) :: res_available_instance_index
+        ! integer, intent(out) :: available_instance_index
         !! Available instance index
-
         integer :: i
 
         do i = 1, size(instance_array)
 
             if (instance_available(i)) then
 
                 instance_available(i) = .false.
-                available_instance_index = i
+                ! available_instance_index = i
                 ! TODO: switch to returning a Result type
-                ! res = ResultInt(data=i)
+                res_available_instance_index = ResultInt(data_v=i)
                 return
 
             end if
 
         end do
 
         ! TODO: switch to returning a Result type with an error set
-        ! res = ResultInt(ResultDP(code=1, message="No available instances"))
-        error stop 1
-
+        res_available_instance_index = ResultInt(error_v=ErrorV(code=1, message="No available instances"))
+        ! error stop 1
     end subroutine get_available_instance_index
 
     ! Change to pure function when we update check_index_claimed to be pure
@@ -95,8 +102,14 @@ function get_instance(instance_index) result(inst)
         type(ResultDP) :: inst
         !! Instance at `instance_array(instance_index)`
 
-        call check_index_claimed(instance_index)
-        inst = instance_array(instance_index)
+        type(ResultNone) :: res_check_index_claimed
+
+        res_check_index_claimed = check_index_claimed(instance_index)
+        if(res_check_index_claimed%is_error()) then
+          inst = ResultDP(error_v=res_check_index_claimed%error_v)
+        else
+          inst = instance_array(instance_index)
+        end if
 
     end function get_instance
 
@@ -106,19 +119,22 @@ subroutine set_instance_index_to(instance_index, val)
         !! Index in `instance_array` of which to set the value equal to `val`
 
         type(ResultDP), intent(in) :: val
+        type(ResultNone) :: res_check_index_claimed
 
-        call check_index_claimed(instance_index)
-        instance_array(instance_index) = val
+        res_check_index_claimed = check_index_claimed(instance_index)
+        if(res_check_index_claimed%is_error()) instance_array(instance_index) = val
 
     end subroutine set_instance_index_to
 
-    subroutine check_index_claimed(instance_index)
+    function check_index_claimed(instance_index) result(res_check_index_claimed)
         !! Check that an index has already been claimed
         !!
         !! Stops execution if the index has not been claimed.
 
         integer, intent(in) :: instance_index
         !! Instance index to check
+        type(ResultNone) :: res_check_index_claimed
+        character(len=:), allocatable :: msg
 
         if (instance_available(instance_index)) then
             ! TODO: Switch to using Result here
@@ -128,8 +144,12 @@ subroutine check_index_claimed(instance_index)
             ! if it fails, the result_dp attribute will be set).
             ! So the code would be something like
             ! res = ResultNone(ResultDP(code=1, message="Index ", instance_index, " has not been claimed"))
-            print *, "Index ", instance_index, " has not been claimed"
-            error stop 1
+            ! print *, "Index ", instance_index, " has not been claimed"
+            ! error stop 1
+            ! MZ Weird thing allocatable message
+            msg = ""
+            write(msg,fmt="(A, I0, A)") "Index ", instance_index," has not been claimed"
+            res_check_index_claimed = ResultNone(error_v=ErrorV(code=1, message=msg))
         end if
 
         if (instance_index < 1) then
@@ -140,8 +160,10 @@ subroutine check_index_claimed(instance_index)
             ! if it fails, the result_dp attribute will be set).
             ! So the code would be something like
             ! res = ResultNone(ResultDP(code=2, message="Requested index is ", instance_index, " which is less than 1"))
-            print *, "Requested index is ", instance_index, " which is less than 1"
-            error stop 1
+            ! print *, "Requested index is ", instance_index, " which is less than 1"
+            ! error stop 1
+            write(msg,fmt="(A, I0, A)") "Requested index is ", instance_index, " which is less than 1"
+            res_check_index_claimed = ResultNone(error_v=ErrorV(code=2, message=msg))
         end if
 
         ! ! Here, result becomes
@@ -151,8 +173,9 @@ subroutine check_index_claimed(instance_index)
         ! ! We will no longer have subroutines that return nothing
         ! ! (like this one currently does).
         ! res = ResultNone()
+        res_check_index_claimed = ResultNone()
 
-    end subroutine check_index_claimed
+    end function check_index_claimed
 
     subroutine ensure_instance_array_size_is_at_least(n)
         !! Ensure that `instance_array` and `instance_available` have at least `n` slots

src/example_fgen_basic/result/result_dp_wrapper.f90

@@ -3,6 +3,7 @@ module m_result_dp_w
 
     use m_error_v, only: ErrorV
     use m_result_dp, only: ResultDP
+    use m_result_int, only: ResultInt
 
     ! The manager module, which makes this all work
     use m_error_v_manager, only: &
@@ -26,7 +27,7 @@ module m_result_dp_w
 
 contains
 
-    subroutine build_instance(data_v, error_v_instance_index, instance_index)
+    subroutine build_instance(data_v, error_v_instance_index, res_available_instance_index)
         !! Build an instance
 
         ! Annoying that this has to be injected everywhere,
@@ -39,7 +40,8 @@ subroutine build_instance(data_v, error_v_instance_index, instance_index)
         integer, intent(in), optional :: error_v_instance_index
         !! Error
 
-        integer, intent(out) :: instance_index
+        ! integer, intent(out) :: instance_index
+        type(ResultInt), intent(out) :: res_available_instance_index
         !! Instance index of the built instance
         !
         ! This is the major trick for wrapping.
@@ -51,7 +53,7 @@ subroutine build_instance(data_v, error_v_instance_index, instance_index)
 
         error_v = error_v_manager_get_instance(error_v_instance_index)
 
-        instance_index = result_dp_manager_build_instance(data_v, error_v)
+        res_available_instance_index = result_dp_manager_build_instance(data_v, error_v)
 
     end subroutine build_instance
 

src/example_fgen_basic/result/result_int.f90

@@ -4,6 +4,7 @@
 !> https://github.com/samharrison7/fortran-error-handler
 module m_result_int
 
+    use kind_parameters, only: i8
     use m_error_v, only: ErrorV
     use m_result, only: ResultBase
     use m_result_none, only: ResultNone
@@ -14,7 +15,7 @@ module m_result_int
     type, extends(ResultBase), public :: ResultInt
     !! Result type that holds integer values
 
-        integer, allocatable :: data_v
+        integer(kind=i8), allocatable :: data_v
         !! Data i.e. the result (if no error occurs)
 
         ! Note: the error_v attribute comes from ResultBase
@@ -42,7 +43,7 @@ function constructor(data_v, error_v) result(self)
         type(ResultInt) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        integer, intent(in), optional :: data_v
+        integer(kind=i8), intent(in), optional :: data_v
         !! Data
 
         class(ErrorV), intent(in), optional :: error_v
@@ -73,7 +74,7 @@ function build(self, data_v_in, error_v_in) result(res)
         class(ResultInt), intent(out) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        integer, intent(in), optional :: data_v_in
+        integer(kind=i8), intent(in), optional :: data_v_in
         !! Data
 
         class(ErrorV), intent(in), optional :: error_v_in