Merge pull request #12 from JuliaImageRecon/nh/observables

Move from custom listeners logic to observables

Author: nHackel

Project.toml

@@ -5,15 +5,17 @@ version = "0.3.6"
 
 [deps]
 LRUCache = "8ac3fa9e-de4c-5943-b1dc-09c6b5f20637"
+Observables = "510215fc-4207-5dde-b226-833fc4488ee2"
 Scratch = "6c6a2e73-6563-6170-7368-637461726353"
 TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
 ThreadPools = "b189fb0b-2eb5-4ed4-bc0c-d34c51242431"
 
 [compat]
+LRUCache = "1.6"
+Observables = "0.5.5"
 Scratch = "1.2"
 TOML = "1"
 ThreadPools = "2.1"
-LRUCache = "1.6"
 julia = "1.9"
 
 [extras]

src/AbstractImageReconstruction.jl

@@ -2,6 +2,7 @@ module AbstractImageReconstruction
 
 using TOML
 using ThreadPools
+using Observables
 using Scratch
 using LRUCache
 

src/RecoPlans/Cache.jl

@@ -18,14 +18,13 @@ end
 
 function clear!(plan::RecoPlan{<:ProcessResultCache}, preserve::Bool = true)
   dict = getfield(plan, :values)
-  set = getfield(plan, :setProperties)
   for key in keys(dict)
-    value = dict[key]
+    value = dict[key][]
+    # Dont remove cache when clearing and preserving structure
     if typeof(value) <: RecoPlan && preserve 
       clear!(value, preserve)
     else
-      dict[key] = missing
-      set[key] = false
+      dict[key] = Observable{Any}(missing)
     end
   end
   return plan
@@ -34,23 +33,15 @@ end
 # Make cache transparent for property getter/setter
 function Base.setproperty!(plan::RecoPlan{<:ProcessResultCache}, name::Symbol, value)
   if in(name, [:param, :cache, :maxsize])
-    old = getproperty(plan, name) 
-    setvalue!(plan, name, value)
-    getfield(plan, :setProperties)[name] = true
-    for listener in getlisteners(plan, name)
-      try
-        propertyupdate!(listener, plan, name, old, x)
-      catch e
-        @error "Exception in listener $listener " e
-      end
-    end  
+    t = type(plan, name)
+    getfield(plan, :values)[name][] = validvalue(plan, t, value) ? value : convert(t, x)
   else
     setproperty!(plan.param, name, value)
   end
 end
 function Base.getproperty(plan::RecoPlan{<:ProcessResultCache}, name::Symbol)
   if in(name, [:param, :cache, :maxsize])
-    return getfield(plan, :values)[name]
+    return getfield(plan, :values)[name][]
   else
     return getproperty(plan.param, name)
   end

src/RecoPlans/LinkedFieldListener.jl

@@ -0,0 +1,58 @@
+export LinkedPropertyListener
+mutable struct LinkedPropertyListener{T<:AbstractImageReconstructionParameters} <: AbstractPlanListener
+  plan::RecoPlan{T}
+  field::Symbol
+  fn::Function
+  active::Bool
+end
+
+"""
+    LinkedPropertyListener(fn, target::RecoPlan, targetProp, source::RecoPlan, sourceProp)
+
+Connect two properties of `RecoPlans`. Set `target.targetProp` to `fn(source.sourceProp)` whenever `source.sourceProp` changes and `target.targetProp` was not changed outside of the listener.  
+"""
+function LinkedPropertyListener(fn::Function, target::RecoPlan, targetProp::Symbol, source::RecoPlan, sourceProp::Symbol)
+  listener = LinkedPropertyListener(source, sourceProp, fn, true)
+
+  # Attach the listener to the target property
+  # We can serialize the listener from the target property and store the source property
+  on(listener, target, targetProp)
+
+  # Attach callback to the source property
+  on(source, sourceProp) do x
+    if listener.active
+      setproperty!(target, targetProp, fn(x))
+      # Set active to true again, because the flag is changed by the target listener
+      listener.active = true
+    end
+  end
+
+  return listener
+end
+(listener::LinkedPropertyListener)(val) = listener.active = false
+
+
+function toDictValue!(dict, value::LinkedPropertyListener)
+  dict["plan"] = string.(parentproperties(value.plan))
+  dict["field"] = string(value.field)
+  dict["fn"] = toDict(value.fn)
+end
+
+function loadListener!(::Type{LinkedPropertyListener}, target::RecoPlan, targetProp, dict, args...)
+  # Find the root plan
+  root = parent(target)
+  while !isnothing(parent(root))
+    root = parent(root)
+  end
+
+  # From the root plan, find the source plan
+  source = root
+  for param in dict["plan"][1:end]
+    source = getproperty(plan, Symbol(param))
+  end
+  sourceProp = Symbol(dict["field"])
+
+  # Retrieve the function
+  fn = tomlType(dict["fn"], modDict)
+  return LinkedPropertyListener(fn, target, targetProp, source, sourceProp)
+end

src/RecoPlans/LinkedPropertyListener.jl

@@ -1,27 +1,9 @@
-export TransientListener, SerializableListener
-abstract type TransientListener <: AbstractPlanListener end
-abstract type SerializableListener <: AbstractPlanListener end
+export AbstractPlanListener
+abstract type AbstractPlanListener end
 
 const LISTENER_TAG = "_listener"
 
-export propertyupdate!, valueupdate 
-function propertyupdate!(listener::AbstractPlanListener, origin, field, old, new)
-  # NOP
-end
-function valueupdate(listener::AbstractPlanListener, origin, field, old, new)
-  # NOP
-end
+Observables.on(f, plan::RecoPlan, field::Symbol; kwargs...) = on(f, getfield(plan, :values)[field]; kwargs...)
+Observables.off(plan::RecoPlan, field::Symbol, f) = off(f, getfield(plan, :values)[field])
 
-export getlisteners, addListener!, removeListener!
-getlisteners(plan::RecoPlan, field::Symbol) = getfield(plan, :listeners)[field]
-function addListener!(plan::RecoPlan, field::Symbol, listener::AbstractPlanListener)
-  listeners = getlisteners(plan, field)
-  push!(listeners, listener)
-end
-function removeListener!(plan::RecoPlan, field::Symbol, listener::AbstractPlanListener)
-  listeners = getlisteners(plan, field)
-  idx = findall(x->isequal(x, listener), listeners)
-  isnothing(idx) && deleteat!(listeners, idx)
-end
-
-include("LinkedFieldListener.jl")
+include("LinkedPropertyListener.jl")