Merge pull request #832 from JuliaRobotics/22Q4/refacc/unpackFactor

switch to reconstFactorData

Author: dehann

src/DistributedFactorGraphs.jl

@@ -218,6 +218,8 @@ export mergeVariableData!, mergeGraphVariableData!
 # Serialization type conversion
 export convertPackedType, convertStructType
 
+export reconstFactorData
+
 ##------------------------------------------------------------------------------
 ## Other utility functions
 ##------------------------------------------------------------------------------

src/services/Serialization.jl

@@ -332,17 +332,22 @@ function packFactor(dfg::AbstractDFG, f::DFGFactor)
     return props
 end
 
-function decodePackedType(::Type{T}, packeddata::GenericFunctionNodeData{PT}) where {T<:FactorOperationalMemory, PT}
-    # usrtyp = convert(FunctorInferenceType, packeddata.fnc)
+function reconstFactorData() end
+
+function decodePackedType(dfg::AbstractDFG, varOrder::AbstractVector{Symbol}, ::Type{T}, packeddata::GenericFunctionNodeData{PT}) where {T<:FactorOperationalMemory, PT}
+    #
+    # TODO, to solve IIF 1424
+    # variables = map(lb->getVariable(dfg, lb), varOrder)
+
     # Also look at parentmodule
     usrtyp = convertStructType(PT)
     fulltype = DFG.FunctionNodeData{T{usrtyp}}
-    factordata = convert(fulltype, packeddata)
+    factordata = reconstFactorData(dfg, varOrder, fulltype, packeddata)
     return factordata
 end
 
-
-function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G <: AbstractDFG
+# Returns `::DFGFactor`
+function unpackFactor(dfg::G, packedProps::Dict{String, Any}) where G <: AbstractDFG
     # Version checking.
     _versionCheck(packedProps)
 
@@ -369,10 +374,18 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G
     # FIXME type instability from nothing to T
     packed = nothing
     fullFactorData = nothing
+    
+    # Get the stored variable order
+    _variableOrderSymbols = if packedProps["_variableOrderSymbols"] isa String
+        JSON2.read(packedProps["_variableOrderSymbols"], Vector{Symbol})
+    else
+        Symbol.(packedProps["_variableOrderSymbols"])
+    end
+    
     try
         packed = JSON2.read(data, GenericFunctionNodeData{packtype})
         decodeType = getFactorOperationalMemoryType(dfg)
-        fullFactorData = decodePackedType(decodeType, packed)
+        fullFactorData = decodePackedType(dfg, _variableOrderSymbols, decodeType, packed)
     catch ex
         io = IOBuffer()
         showerror(io, ex, catch_backtrace())
@@ -381,12 +394,6 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G
         error(msg)
     end
 
-    # Include the type
-    if packedProps["_variableOrderSymbols"] isa String
-        _variableOrderSymbols = JSON2.read(packedProps["_variableOrderSymbols"], Vector{Symbol})
-    else
-        _variableOrderSymbols = Symbol.(packedProps["_variableOrderSymbols"])
-    end
     solvable = packedProps["solvable"]
 
     # Rebuild DFGFactor

test/testBlocks.jl

@@ -4,6 +4,7 @@ using Dates
 using Manifolds
 
 import Base: convert
+import DistributedFactorGraphs: reconstFactorData
 
 # Test InferenceVariable Types
 # struct TestVariableType1 <: InferenceVariable
@@ -43,11 +44,17 @@ function Base.convert(::Type{PackedTestFunctorInferenceType1}, d::TestFunctorInf
     PackedTestFunctorInferenceType1()
 end
 
-function Base.convert(::Type{TestFunctorInferenceType1}, d::PackedTestFunctorInferenceType1)
+function reconstFactorData(dfg::AbstractDFG, vo::AbstractVector, ::Type{TestFunctorInferenceType1}, d::PackedTestFunctorInferenceType1, ::String)
+    TestFunctorInferenceType1()
+end
+
+# overly simplified test requires both reconstitute and convert
+function Base.convert(::Type{TestFunctorInferenceType1}, d::PackedTestFunctorInferenceType1 )
     # @info "convert(::Type{TestFunctorInferenceType1}, d::PackedTestFunctorInferenceType1)"
     TestFunctorInferenceType1()
 end
 
+
 struct PackedTestAbstractPrior <: PackedInferenceType
     s::String
 end
@@ -74,13 +81,15 @@ Base.:(==)(a::TestCCW, b::TestCCW) = a.usrfnc! == b.usrfnc!
 DFG.getFactorOperationalMemoryType(par::NoSolverParams) = TestCCW
 DFG.rebuildFactorMetadata!(dfg::AbstractDFG{NoSolverParams}, fac::DFGFactor) = fac
 
-function Base.convert(::Type{DFG.FunctionNodeData{TestCCW{F}}},
-                     d::DFG.PackedFunctionNodeData{<:AbstractPackedFactor}) where {F <: DFG.AbstractFactor}
-
+function reconstFactorData(dfg::AbstractDFG,
+                                vo::AbstractVector,
+                                ::Type{<:DFG.FunctionNodeData{TestCCW{F}}},
+                                d::DFG.PackedFunctionNodeData{<:AbstractPackedFactor} ) where {F <: DFG.AbstractFactor}
+    nF = convert(F, d.fnc)
     return DFG.FunctionNodeData(d.eliminated,
                                 d.potentialused,
                                 d.edgeIDs,
-                                TestCCW(convert(F, d.fnc)),
+                                TestCCW(nF),
                                 d.multihypo,
                                 d.certainhypo,
                                 d.nullhypo,