Add abstract type for utility process parameter

Author: nHackel

docs/src/literate/howto/caching.jl

@@ -11,6 +11,8 @@ include("../../literate/example/example_include_all.jl") #hide
 
 # ## ProcessResultCache
 # The caching mechanism is based on the `ProcessResultCache` type. This type wraps around a different `ÀbstractImageReconstructionParameter` and caches the result of a processing step.
+# Such a `process`ing step which offer functionality to other `process` steps is a `AbstractUtilityReconstructionParameter`. These utility steps should return the same result as if the inner step was called directly.
+
 # The cache itself is connected to a `RecoPlan` and any instances build from the same plan instance share this cache and can reuse the result of the processing step.
 
 # Let's implement the `ProcessResultCache` type for the Radon preprocessing step. We first define a struct a very costly preprocessing step:
@@ -27,8 +29,8 @@ function AbstractImageReconstruction.process(::Type{<:AbstractRadonAlgorithm}, p
 end
 
 # Now we can define a processing step that internally uses another processing step. We allow this inner parameter to be cached by considering the following `Union`:
-Base.@kwdef struct RadonCachedPreprocessingParameters{P <: AbstractRadonPreprocessingParameters} <: AbstractRadonPreprocessingParameters
-  params::Union{P, ProcessResultCache{P}}
+Base.@kwdef struct RadonCachedPreprocessingParameters{P <: AbstractRadonPreprocessingParameters, PU <: AbstractUtilityReconstructionParameters{P}} <: AbstractRadonPreprocessingParameters
+  params::Union{P, PU}
 end
 # Note that this case is a bit artifical and a more sensible place would be the algorithm parameters themselves. However, for the case of simplicity we did not introduce the concept in the example.
 # In this artifical case we just pass the parameters to the processing step. A real implementation might do some more processing with the result of the inner processing step:

src/AlgorithmInterface.jl

@@ -14,6 +14,14 @@ Abstract type for image reconstruction parameters.  An algorithm consists of one
 """
 abstract type AbstractImageReconstructionParameters end
 
+export AbstractUtilityReconstructionParameters
+"""
+    AbstractUtilityReconstructionParameters{T <: AbstractImageReconstructionParameters}
+
+Abstract type that offer utility functions for a given reconstruction parameter and its associated `process` steps. Utility `process` steps should return the same result as `T` for the same inputs.
+"""
+abstract type AbstractUtilityReconstructionParameters{T <: AbstractImageReconstructionParameters} end
+
 export put!, take!
 """
     put!(algo::AbstractImageReconstructionAlgorithm, inputs...)
@@ -91,7 +99,12 @@ If not implemented for an instance of `algo`, the default implementation is call
 """
 function process end
 process(algo::AbstractImageReconstructionAlgorithm, param::AbstractImageReconstructionParameters, inputs...) = process(typeof(algo), param, inputs...)
+"""
+    process(algo::Union{A, Type{A}}, param::AbstractUtilityReconstructionParameters{P}, inputs...) where {A <: AbstractImageReconstructionAlgorithm, P <: AbstractImageReconstructionParameters}
 
+Process `inputs` with algorithm `algo` and return the result as if the arguments were given to `P`. Examples of utility `process` are processes which offer caching or remote execution. 
+"""
+process(::A, param::AbstractUtilityReconstructionParameters{P}, inputs...) where {A, P} = error("$(typeof(param)) must implement `process` for $A and given inputs")
 """
 Enable multiple process steps by supplying a Vector of parameters
 """

src/RecoPlans/Cache.jl

@@ -5,7 +5,7 @@ export ProcessResultCache
 Cache of size `maxsize` for the result of `process` methods. The cache is based on the `hash` of the inputs of the `process` function. Cache is shared between all algorithms constructed from the same plan.
 The cache is transparent for properties of the underlying parameter. Cache can be invalidated by calling `empty!` on the cache.
 """
-Base.@kwdef mutable struct ProcessResultCache{P <: AbstractImageReconstructionParameters} <: AbstractImageReconstructionParameters
+Base.@kwdef mutable struct ProcessResultCache{P} <: AbstractUtilityReconstructionParameters{P}
   param::P
   const maxsize::Int64 = 1
   cache::LRU{UInt64, Any} = LRU{UInt64, Any}(maxsize = maxsize)