towards consolidated FactorCompute constructor

Author: Affie

src/Deprecated.jl

@@ -190,6 +190,39 @@ function updateVariableSolverData!(
     end
 end
 
+function FactorCompute(
+    label::Symbol,
+    timestamp::Union{DateTime, ZonedDateTime},
+    nstime::Nanosecond,
+    tags::Set{Symbol},
+    solverData::GenericFunctionNodeData,
+    solvable::Int,
+    variableOrder::Union{Vector{Symbol}, Tuple};
+    observation = getFactorType(solverData),
+    state::FactorState = FactorState(),
+    workmem::Base.RefValue{<:FactorOperationalMemory} = Ref{FactorOperationalMemory}(),
+    id::Union{UUID, Nothing} = nothing,
+    smallData::Dict{Symbol, SmallDataTypes} = Dict{Symbol, SmallDataTypes}(),
+)
+    error(
+        "This constructor is deprecated, use FactorCompute(label, variableOrder, solverData; ...) instead",
+    )
+    return FactorCompute(
+        id,
+        label,
+        tags,
+        Tuple(variableOrder),
+        timestamp,
+        nstime,
+        Ref(solverData),
+        Ref(solvable),
+        smallData,
+        observation,
+        state,
+        workmem,
+    )
+end
+
 ## ================================================================================
 ## Deprecated in v0.25
 ##=================================================================================

src/entities/DFGFactor.jl

@@ -253,7 +253,7 @@ $(TYPEDFIELDS)
 """
 Base.@kwdef struct FactorCompute{FT <: AbstractFactor, N} <: AbstractDFGFactor
     """The ID for the factor"""
-    id::Union{UUID, Nothing} = nothing
+    id::Union{UUID, Nothing} = nothing #TODO deprecate id
     """Factor label, e.g. :x1f1.
     Accessor: [`getLabel`](@ref)"""
     label::Symbol
@@ -279,55 +279,62 @@ Base.@kwdef struct FactorCompute{FT <: AbstractFactor, N} <: AbstractDFGFactor
     smallData::Dict{Symbol, SmallDataTypes} = Dict{Symbol, SmallDataTypes}()
 
     #refactor fields
+    """Observation function or measurement for this factor.
+    Accessors: [`getObservation`](@ref)(@ref)"""
     observation::FT
+    """Describes the current state of the factor. Persisted in serialization.
+    Accessors: [`getFactorState`](@ref)"""
     state::FactorState
-    computeMem::Base.RefValue{<:FactorOperationalMemory} #TODO easy of use vs. performance as container is abstract in any case.
+    """Temporary, non-persistent memory used internally by the solver for intermediate numerical computations and buffers.  
+    `workmem` is lazily allocated and only used during factor operations; it is not serialized or retained after solving.
+    Accessors: [`getWorkmem`](@ref), [`setWorkmem!`](@ref)"""
+    workmem::Base.RefValue{<:FactorOperationalMemory} #TODO easy of use vs. performance as container is abstract in any case.
 end
 
 ##------------------------------------------------------------------------------
 ## Constructors
 
-#TODO consolidate constructors, currently IIF calls only
-# DFGFactor(
-#     Symbol(namestring),
-#     varOrderLabels,
-#     solverData;
-#     tags = Set(union(tags, [:FACTOR])),
-#     solvable,
-#     timestamp = _zonedtime(timestamp),
-# )
-
+# TODO standardize new fields in kw constructors, .id
 function FactorCompute(
     label::Symbol,
-    timestamp::Union{DateTime, ZonedDateTime},
-    nstime::Nanosecond,
-    tags::Set{Symbol},
-    solverData::GenericFunctionNodeData,
-    solvable::Int,
-    variableOrder::Union{Vector{Symbol}, Tuple};
-    observation = getFactorType(solverData),
+    variableOrder::Union{Vector{Symbol}, Tuple},
+    observation::AbstractFactor,
     state::FactorState = FactorState(),
-    computeMem::Base.RefValue{<:FactorOperationalMemory} = Ref{FactorOperationalMemory}(),
+    workmem = Ref{FactorOperationalMemory}();
+    tags::Set{Symbol} = Set{Symbol}(),
+    timestamp::Union{DateTime, ZonedDateTime} = now(localzone()),
+    solvable::Int = 1,
+    nstime::Nanosecond = Nanosecond(0),
     id::Union{UUID, Nothing} = nothing,
     smallData::Dict{Symbol, SmallDataTypes} = Dict{Symbol, SmallDataTypes}(),
+    solverData = nothing
 )
+    if isnothing(solverData)
+        refsolverData = Ref{GenericFunctionNodeData}() #TODO solverData deprecated in v0.27 WIP
+    else
+        Base.depwarn(
+            "`FactorCompute` solverData is deprecated",
+            :FactorCompute,
+        )
+        refsolverData = Ref(solverData)
+    end
+   
     return FactorCompute(
         id,
         label,
         tags,
         Tuple(variableOrder),
         timestamp,
         nstime,
-        Ref(solverData),
+        refsolverData,
         Ref(solvable),
         smallData,
         observation,
         state,
-        computeMem,
+        workmem,
     )
 end
 
-# TODO standardize new fields in kw constructors, .id
 function FactorCompute(
     label::Symbol,
     variableOrder::Union{Vector{Symbol}, Tuple},
@@ -339,6 +346,10 @@ function FactorCompute(
     id::Union{UUID, Nothing} = nothing,
     smallData::Dict{Symbol, SmallDataTypes} = Dict{Symbol, SmallDataTypes}(),
 )
+    Base.depwarn(
+        "`FactorCompute` constructor with `GenericFunctionNodeData` is deprecated. observation, state, and workmem should be provided explicitly.",
+        :FactorCompute,
+    )
     observation = getFactorType(solverData)
     state = FactorState(
         solverData.eliminated,
@@ -351,24 +362,24 @@ function FactorCompute(
     )
 
     if solverData.fnc isa FactorOperationalMemory
-        computeMem = Ref(solverData.fnc)
+        workmem = Ref(solverData.fnc)
     else
-        computeMem = Ref{FactorOperationalMemory}()
+        workmem = Ref{FactorOperationalMemory}()
     end
 
     return FactorCompute(
         label,
+        Tuple(variableOrder),
+        observation,
+        state,
+        workmem;
+        id,
         timestamp,
         nstime,
         tags,
         solverData,
-        solvable,
-        Tuple(variableOrder);
-        observation,
-        computeMem,
-        id,
         smallData,
-        state,
+        solvable,
     )
 end
 

src/services/CompareUtils.jl

@@ -34,7 +34,7 @@ const GeneratedCompareUnion = Union{
 }
 
 @generated function ==(x::T, y::T) where {T <: GeneratedCompareUnion}
-    ignored = [:computeMem]
+    ignored = [:workmem]
     return mapreduce(
         n -> :(x.$n == y.$n),
         (a, b) -> :($a && $b),
@@ -321,7 +321,7 @@ function compareFactor(
             :attributes,
             :solverData,
             :observation,
-            :computeMem,
+            :workmem,
             :_variableOrderSymbols,
             :_gradients,
         ],

src/services/DFGFactor.jl

@@ -39,13 +39,20 @@ getFactorType(f::FactorDFG) = getTypeFromSerializationModule(f.fnctype)() # TODO
 getFactorType(dfg::AbstractDFG, lbl::Symbol) = getFactorType(getFactor(dfg, lbl))
 
 getState(f::AbstractDFGFactor) = f.state
+
+getFactorState(f::AbstractDFGFactor) = f.state
+getFactorState(dfg::AbstractDFG, lbl::Symbol) = getFactorState(getFactor(dfg, lbl))
+
 getObservation(f::FactorCompute) = f.observation
 function getObservation(f::FactorDFG)
     #FIXME completely refactor to not need getTypeFromSerializationModule and just use StructTypes
     packtype = DFG.getTypeFromSerializationModule("Packed" * f.fnctype)
     return packtype(; JSON3.read(f.observJSON)...)
 end
 
+getWorkmem(f::FactorCompute) = f.workmem[]
+setWorkmem!(f::FactorCompute, workmem::FactorOperationalMemory) = f.workmem[] = workmem
+
 """
     $SIGNATURES
 
@@ -155,12 +162,12 @@ end
 function setTimestamp(f::FactorCompute, ts::ZonedDateTime)
     return FactorCompute(
         f.label,
-        ts,
-        f.nstime,
-        f.tags,
-        f.solverData,
-        f.solvable,
-        getfield(f, :_variableOrderSymbols);
+        getfield(f, :_variableOrderSymbols),
+        f.solverData;
+        timestamp = ts,
+        nstime = f.nstime,
+        tags = f.tags,
+        solvable = f.solvable,
         id = f.id,
     )
 end

src/services/Serialization.jl

@@ -403,23 +403,23 @@ function unpackFactor(dfg::AbstractDFG, factor::FactorDFG; skipVersionCheck::Boo
     metadata = JSON3.read(base64decode(factor.metadata), Dict{Symbol, DFG.SmallDataTypes})
 
     if fullFactorData.fnc isa FactorOperationalMemory
-        computeMem = Ref(fullFactorData.fnc)
+        workmem = Ref(fullFactorData.fnc)
     else
-        computeMem = Ref{FactorOperationalMemory}()
+        workmem = Ref{FactorOperationalMemory}()
     end
     return FactorCompute(
         factor.label,
-        factor.timestamp,
-        Nanosecond(factor.nstime),
-        Set(factor.tags),
-        fullFactorData,
-        factor.solvable,
-        Tuple(factor._variableOrderSymbols);
+        Tuple(factor._variableOrderSymbols),
+        observation,
+        factor.state,
+        workmem;
+        solverData = fullFactorData,
+        nstime = Nanosecond(factor.nstime),
+        tags = Set(factor.tags),
+        solvable = factor.solvable,
+        timestamp = factor.timestamp,
         id = factor.id,
         smallData = metadata,
-        state = factor.state,
-        observation,
-        computeMem,
     )
 end
 

test/testBlocks.jl

@@ -493,12 +493,12 @@ function VariablesandFactorsCRUD_SET!(fg, v1, v2, v3, f0, f1, f2)
     if f2 isa FactorCompute
         f2_mod = FactorCompute(
             f2.label,
-            f2.timestamp,
-            f2.nstime,
-            f2.tags,
-            f2.solverData,
-            f2.solvable,
             (:a,),
+            f2.solverData;
+            timestamp = f2.timestamp,
+            nstime = f2.nstime,
+            tags = f2.tags,
+            solvable = f2.solvable,
         )
     else
         f2_mod = deepcopy(f2)