Add abstract type for utiltiy processing steps

Author: nHackel

docs/src/literate/howto/caching.jl

@@ -10,7 +10,7 @@ include("../../literate/example/example_include_all.jl") #hide
 # This How-To builds on the results of the example sections.
 
 # ## 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.
+# The caching mechanism is based on the `ProcessResultCache` type. This type wraps around a different `AbstractImageReconstructionParameter` 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.

src/AlgorithmInterface.jl

@@ -20,7 +20,7 @@ export AbstractUtilityReconstructionParameters
 
 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
+abstract type AbstractUtilityReconstructionParameters{T <: AbstractImageReconstructionParameters} <: AbstractImageReconstructionParameters end
 
 export put!, take!
 """
@@ -122,4 +122,10 @@ export parameter
 
 Return the parameters of the algorithm `algo`.
 """
-parameter(algo::AbstractImageReconstructionAlgorithm) = error("$(typeof(algo)) must implement parameter")
+parameter(algo::AbstractImageReconstructionAlgorithm) = error("$(typeof(algo)) must implement `parameter`")
+"""
+    parameter(param::AbstractUtilityReconstructionParameters)
+  
+Return the wrapped parameter. Can themselves be utility parameters again
+"""
+parameter(param::AbstractUtilityReconstructionParameters) = error("$(typeof(param)) must implement `parameter`")

src/RecoPlans/Cache.jl

@@ -5,14 +5,18 @@ 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} <: AbstractUtilityReconstructionParameters{P}
+mutable struct ProcessResultCache{P} <: AbstractUtilityReconstructionParameters{P}
   param::P
-  const maxsize::Int64 = 1
-  cache::LRU{UInt64, Any} = LRU{UInt64, Any}(maxsize = maxsize)
+  const maxsize::Int64
+  cache::LRU{UInt64, Any}
+  function ProcessResultCache(; param::Union{P, AbstractUtilityReconstructionParameters{P}}, maxsize::Int64 = 1, cache::LRU{UInt64, Any} = LRU{UInt64, Any}(maxsize = maxsize)) where P
+    return new{P}(param, maxsize, cache)
+  end
 end
 ProcessResultCache(param::AbstractImageReconstructionParameters; kwargs...) = ProcessResultCache(;param, kwargs...)
 process(algo::A, param::ProcessResultCache, inputs...) where {A <: AbstractImageReconstructionAlgorithm} = hashed_process(algo, param, inputs...)
 process(algoT::Type{<:A}, param::ProcessResultCache, inputs...) where {A <: AbstractImageReconstructionAlgorithm} = hashed_process(algoT, param, inputs...)
+parameter(param::ProcessResultCache) = param.param
 
 function hashed_process(algo, param::ProcessResultCache, inputs...)
   id = hash(param.param, hash(inputs, hash(algo)))