deprecate GenericFunctionNodeData and related

Author: Affie

src/Deprecated.jl

@@ -1,7 +1,7 @@
 ## ================================================================================
 ## Deprecated in v0.27
 ##=================================================================================
-export AbstractFactor 
+export AbstractFactor
 const AbstractFactor = AbstractFactorObservation
 
 export AbstractPackedFactor
@@ -202,6 +202,37 @@ function updateVariableSolverData!(
     end
 end
 
+## factor refactor deprecations
+"""
+$(TYPEDEF)
+
+Notes
+- S::Symbol
+
+Designing (WIP)
+- T <: Union{FactorSolverCache, AbstractPackedFactorObservation}
+- in IIF.CCW{T <: DFG.AbstractFactorObservation}
+- in DFG.AbstractRelativeMinimize <: AbstractFactorObservation
+- in Main.SomeFactor <: AbstractRelativeMinimize
+"""
+Base.@kwdef mutable struct GenericFunctionNodeData{
+    T <: Union{
+        <:AbstractPackedFactorObservation,
+        <:AbstractFactorObservation,
+        <:FactorSolverCache,
+    },
+}
+    eliminated::Bool = false
+    potentialused::Bool = false
+    edgeIDs::Vector{Int} = Int[]
+    fnc::T
+    multihypo::Vector{Float64} = Float64[] # TODO re-evaluate after refactoring w #477
+    certainhypo::Vector{Int} = Int[]
+    nullhypo::Float64 = 0.0
+    solveInProgress::Int = 0
+    inflation::Float64 = 0.0
+end
+
 function FactorCompute(
     label::Symbol,
     timestamp::Union{DateTime, ZonedDateTime},
@@ -297,6 +328,80 @@ function _packSolverData(f::FactorCompute, fnctype::AbstractFactorObservation)
         error(msg)
     end
 end
+
+export GenericFunctionNodeData, PackedFunctionNodeData, FunctionNodeData
+
+const PackedFunctionNodeData{T} =
+    GenericFunctionNodeData{T} where {T <: AbstractPackedFactorObservation}
+function PackedFunctionNodeData(args...; kw...)
+    error("PackedFunctionNodeData is obsolete")
+    return PackedFunctionNodeData{typeof(args[4])}(args...; kw...)
+end
+
+const FunctionNodeData{T} = GenericFunctionNodeData{
+    T,
+} where {T <: Union{<:AbstractFactorObservation, <:FactorSolverCache}}
+FunctionNodeData(args...; kw...) = FunctionNodeData{typeof(args[4])}(args...; kw...)
+
+# this is the GenericFunctionNodeData for packed types
+#TODO deprecate FactorData in favor of FactorState (with no more distinction between packed and compute)
+const FactorData = PackedFunctionNodeData{AbstractPackedFactorObservation}
+
+function FactorCompute(
+    label::Symbol,
+    variableOrder::Union{Vector{Symbol}, Tuple},
+    solverData::GenericFunctionNodeData;
+    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}(),
+)
+    Base.depwarn(
+        "`FactorCompute` constructor with `GenericFunctionNodeData` is deprecated. observation, state, and solvercache should be provided explicitly.",
+        :FactorCompute,
+    )
+    observation = getFactorType(solverData)
+    state = FactorState(
+        solverData.eliminated,
+        solverData.potentialused,
+        solverData.multihypo,
+        solverData.certainhypo,
+        solverData.nullhypo,
+        solverData.solveInProgress,
+        solverData.inflation,
+    )
+
+    if solverData.fnc isa FactorSolverCache
+        solvercache = solverData.fnc
+    else
+        solvercache = nothing
+    end
+
+    return FactorCompute(
+        label,
+        Tuple(variableOrder),
+        observation,
+        state,
+        solvercache;
+        id,
+        timestamp,
+        nstime,
+        tags,
+        smallData,
+        solvable,
+    )
+end
+
+# Deprecated check usefull? # packedFnc = fncStringToData(factor.fnctype, factor.data)
+# Deprecated check usefull? # decodeType = getFactorOperationalMemoryType(dfg)
+# Deprecated check usefull? # fullFactorData = decodePackedType(dfg, factor._variableOrderSymbols, decodeType, packedFnc)
+function fncStringToData(args...; kwargs...)
+    @warn "fncStringToData is obsolete, called with" args kwargs
+    return error("fncStringToData is obsolete.")
+end
+
 ## ================================================================================
 ## Deprecated in v0.25
 ##=================================================================================

src/DistributedFactorGraphs.jl

@@ -248,7 +248,6 @@ export @format_str
 # Factors
 ##------------------------------------------------------------------------------
 # Factor Data
-export GenericFunctionNodeData, PackedFunctionNodeData, FunctionNodeData
 export AbstractFactorObservation, AbstractPackedFactorObservation
 export AbstractPrior, AbstractRelative, AbstractRelativeMinimize, AbstractManifoldMinimize
 export FactorSolverCache
@@ -303,7 +302,6 @@ export compare,
     compareField,
     compareFields,
     compareAll,
-    compareAllSpecial,
     compareVariable,
     compareFactor,
     compareAllVariables,

src/FileDFG/services/FileDFG.jl

@@ -168,7 +168,7 @@ function loadDFG!(
         jstr = read("$varFolder/$varFile", String)
         packedvar = JSON3.read(jstr, VariableDFG)
         v = usePackedVariable ? packedvar : unpackVariable(packedvar)
-        addVariable!(dfgLoadInto, v)
+        return addVariable!(dfgLoadInto, v)
     end
 
     @info "Loaded $(length(variables)) variables"#- $(map(v->v.label, variables))"
@@ -181,7 +181,7 @@ function loadDFG!(
         jstr = read("$factorFolder/$factorFile", String)
         packedfact = JSON3.read(jstr, FactorDFG)
         f = usePackedFactor ? packedfact : unpackFactor(packedfact)
-        addFactor!(dfgLoadInto, f)
+        return addFactor!(dfgLoadInto, f)
     end
 
     @info "Loaded $(length(factors)) factors"# - $(map(f->f.label, factors))"

src/entities/DFGFactor.jl

@@ -18,36 +18,6 @@ abstract type FactorSolverCache end
 # we can add to IIF or have IIF.CommonConvWrapper <: FactorSolverCache directly
 # abstract type ConvolutionObject <: FactorSolverCache end
 
-##==============================================================================
-## GenericFunctionNodeData
-##==============================================================================
-
-"""
-$(TYPEDEF)
-
-Notes
-- S::Symbol
-
-Designing (WIP)
-- T <: Union{FactorSolverCache, AbstractPackedFactorObservation}
-- in IIF.CCW{T <: DFG.AbstractFactorObservation}
-- in DFG.AbstractRelativeMinimize <: AbstractFactorObservation
-- in Main.SomeFactor <: AbstractRelativeMinimize
-"""
-Base.@kwdef mutable struct GenericFunctionNodeData{
-    T <: Union{<:AbstractPackedFactorObservation, <:AbstractFactorObservation, <:FactorSolverCache},
-}
-    eliminated::Bool = false
-    potentialused::Bool = false
-    edgeIDs::Vector{Int} = Int[]
-    fnc::T
-    multihypo::Vector{Float64} = Float64[] # TODO re-evaluate after refactoring w #477
-    certainhypo::Vector{Int} = Int[]
-    nullhypo::Float64 = 0.0
-    solveInProgress::Int = 0
-    inflation::Float64 = 0.0
-end
-
 #TODO is this mutable
 @kwdef mutable struct FactorState
     eliminated::Bool = false
@@ -66,25 +36,6 @@ end
 
 ## Constructors
 
-##------------------------------------------------------------------------------
-## PackedFunctionNodeData and FunctionNodeData
-
-const PackedFunctionNodeData{T} =
-    GenericFunctionNodeData{T} where {T <: AbstractPackedFactorObservation}
-function PackedFunctionNodeData(args...; kw...)
-    return PackedFunctionNodeData{typeof(args[4])}(args...; kw...)
-end
-
-const FunctionNodeData{T} = GenericFunctionNodeData{
-    T,
-} where {T <: Union{<:AbstractFactorObservation, <:FactorSolverCache}}
-FunctionNodeData(args...; kw...) = FunctionNodeData{typeof(args[4])}(args...; kw...)
-
-# PackedFunctionNodeData(x2, x3, x4, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where T <: AbstractPackedFactorObservation =
-#     GenericFunctionNodeData{T}(x2, x3, x4, x6, multihypo, certainhypo, x9)
-# FunctionNodeData(x2, x3, x4, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where T <: Union{AbstractFactorObservation, FactorSolverCache} =
-#     GenericFunctionNodeData{T}(x2, x3, x4, x6, multihypo, certainhypo, x9)
-
 ##==============================================================================
 ## Factors
 ##==============================================================================
@@ -114,7 +65,7 @@ Base.@kwdef struct FactorDFG <: AbstractDFGFactor
     nstime::String
     fnctype::String
     solvable::Int
-    data::Union{Nothing, String} #TODO deprecate data completely, left as a bridge to old serialization structure
+    data::Union{Nothing, String} = nothing #TODO deprecate data completely, left as a bridge to old serialization structure
     metadata::String
     _version::String = string(_getDFGVersion())
     state::FactorState
@@ -129,7 +80,7 @@ end
 
 StructTypes.StructType(::Type{FactorDFG}) = StructTypes.UnorderedStruct()
 StructTypes.idproperty(::Type{FactorDFG}) = :id
-StructTypes.omitempties(::Type{FactorDFG}) = (:id,)
+StructTypes.omitempties(::Type{FactorDFG}) = (:id, :data)
 
 #TODO deprecate, added in v0.27 as a bridge to new serialization structure
 function FactorDFG(
@@ -189,10 +140,6 @@ abstract type InferenceType <: AbstractPackedFactorObservation end
 
 #TODO deprecate InferenceType in favor of AbstractPackedFactorObservation v0.26
 
-# this is the GenericFunctionNodeData for packed types
-#TODO deprecate FactorData in favor of FactorState (with no more distinction between packed and compute)
-const FactorData = PackedFunctionNodeData{AbstractPackedFactorObservation}
-
 # Packed Factor constructor
 function assembleFactorName(xisyms::Union{Vector{String}, Vector{Symbol}})
     return Symbol(xisyms..., "_f", randstring(4))
@@ -331,57 +278,11 @@ function FactorCompute(
     )
 end
 
-function FactorCompute(
-    label::Symbol,
-    variableOrder::Union{Vector{Symbol}, Tuple},
-    solverData::GenericFunctionNodeData;
-    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}(),
-)
-    Base.depwarn(
-        "`FactorCompute` constructor with `GenericFunctionNodeData` is deprecated. observation, state, and solvercache should be provided explicitly.",
-        :FactorCompute,
-    )
-    observation = getFactorType(solverData)
-    state = FactorState(
-        solverData.eliminated,
-        solverData.potentialused,
-        solverData.multihypo,
-        solverData.certainhypo,
-        solverData.nullhypo,
-        solverData.solveInProgress,
-        solverData.inflation,
-    )
-
-    if solverData.fnc isa FactorSolverCache
-        solvercache = solverData.fnc
-    else
-        solvercache = nothing
-    end
-
-    return FactorCompute(
-        label,
-        Tuple(variableOrder),
-        observation,
-        state,
-        solvercache;
-        id,
-        timestamp,
-        nstime,
-        tags,
-        smallData,
-        solvable,
-    )
-end
-
 function Base.getproperty(x::FactorCompute, f::Symbol)
     if f == :solvable
         getfield(x, f)[]
     elseif f == :solverData
+        # TODO remove, deprecated in v0.27
         error(
             "`solverData` is obsolete in `FactorCompute`. Use `getObservation`, `getState` or `getCache` instead.",
         )

src/services/CompareUtils.jl

@@ -25,7 +25,6 @@ const GeneratedCompareUnion = Union{
     VariableDFG,
     VariableSummary,
     VariableSkeleton,
-    GenericFunctionNodeData,
     FactorCompute,
     FactorDFG,
     FactorSummary,
@@ -267,38 +266,6 @@ function compareVariable(
     return TP::Bool
 end
 
-function compareAllSpecial(
-    A::T1,
-    B::T2;
-    skip = Symbol[],
-    show::Bool = true,
-) where {T1 <: GenericFunctionNodeData, T2 <: GenericFunctionNodeData}
-    if T1 != T2
-        @warn "compareAllSpecial is comparing different types" T1 T2
-        # return false
-        # else
-    end
-    return compareAll(A, B; skip = skip, show = show)
-end
-
-# Compare FunctionNodeData
-function compare(
-    a::GenericFunctionNodeData{T1},
-    b::GenericFunctionNodeData{T2},
-) where {T1, T2}
-    # TODO -- beef up this comparison to include the gwp
-    TP = true
-    TP = TP && a.eliminated == b.eliminated
-    TP = TP && a.potentialused == b.potentialused
-    TP = TP && a.edgeIDs == b.edgeIDs
-    # TP = TP && typeof(a.fnc) == typeof(b.fnc)
-    TP = TP && (a.multihypo - b.multihypo |> norm < 1e-10)
-    TP = TP && a.certainhypo == b.certainhypo
-    TP = TP && a.nullhypo == b.nullhypo
-    TP = TP && a.solveInProgress == b.solveInProgress
-    return TP
-end
-
 """
     $SIGNATURES
 
@@ -406,7 +373,6 @@ end
 # Bd = getSolverData(B)
 # TP =  compareAll(A, B, skip=[:attributes;:data], show=show)
 # TP &= compareAll(A.attributes, B.attributes, skip=[:data;], show=show)
-# TP &= compareAllSpecial(getSolverData(A).fnc, getSolverData(B).fnc, skip=[:cpt;], show=show)
 # TP &= compareAll(getSolverData(A).fnc.cpt, getSolverData(B).fnc.cpt, show=show)
 
 """