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,6 +332,8 @@ function packFactor(dfg::AbstractDFG, f::DFGFactor)
     return props
 end
 
+function reconstFactorData() end
+
 function decodePackedType(dfg::AbstractDFG, varOrder::AbstractVector{Symbol}, ::Type{T}, packeddata::GenericFunctionNodeData{PT}) where {T<:FactorOperationalMemory, PT}
     #
     # TODO, to solve IIF 1424
@@ -340,7 +342,7 @@ function decodePackedType(dfg::AbstractDFG, varOrder::AbstractVector{Symbol}, ::
     # 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
 

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,20 +81,29 @@ 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,
                                 d.solveInProgress,
                                 d.inflation)
 end
 
+function convert(   T::Type{DFG.FunctionNodeData{TestCCW{F}}},
+                    d::DFG.PackedFunctionNodeData{<:AbstractPackedFactor} ) where {F <: DFG.AbstractFactor}
+    #
+    @error("DEPRECATING $T")
+    reconstFactorData(T, d, "")
+end
+
 function Base.convert(::Type{DFG.PackedFunctionNodeData{P}}, d::DFG.FunctionNodeData{<:FactorOperationalMemory}) where P <: AbstractPackedFactor
   return DFG.PackedFunctionNodeData(d.eliminated,
                                     d.potentialused,