top level JSON2.write only, Neo4jDFG broken

Author: dehann

src/entities/DFGFactor.jl

@@ -46,12 +46,6 @@ mutable struct GenericFunctionNodeData{T<:Union{<:AbstractPackedFactor, <:Abstra
     nullhypo::Float64
     solveInProgress::Int
     inflation::Float64
-    # inner constructor needed for dual use
-    # GenericFunctionNodeData{T}(x1::Bool,x2::Bool,x3,x4::T,args...) where T = new{T}(x1,x2,x3,x4,args...)
-    # TODO deprecate all these inner constructors at end of DFG v0.9.x (was added for GFND.nullhypo::Float64 breaking change)
-    # GenericFunctionNodeData{T}(el,po,ed,fn,mu::Vector{<:Real},ce::Vector{Int},so::Int) where T = 
-    #                            new{T}(el,po,ed,fn,mu,ce,0.0,so)
-    # GenericFunctionNodeData{T}(el,po,ed,fn,mu::Vector{<:Real},ce::Vector{Int},nu::Real,so::Int,infl::Real) where T = new{T}(el,po,ed,fn,mu,ce,nu,so,infl)
 end
 
 ## Constructors

src/services/Serialization.jl

@@ -298,10 +298,11 @@ function _packSolverData(
     #
     packtype = convertPackedType(fnctype)
     try
-        packed = convert( PackedFunctionNodeData{packtype}, getSolverData(f) )
-        packedJson = JSON2.write(packed)
+        packedJson = convert( PackedFunctionNodeData{packtype}, getSolverData(f) )
+        # packedJson = JSON2.write(packed) # NOTE SINGLE TOP LEVEL JSON.write ONLY
         if base64Encode
             # 833
+            packedJson = JSON2.write(packed)
             packedJson = base64encode(packedJson)
         end
         return packedJson
@@ -321,13 +322,13 @@ function packFactor(dfg::AbstractDFG, f::DFGFactor)
     props["label"] = string(f.label)
     props["timestamp"] = Dates.format(f.timestamp, "yyyy-mm-ddTHH:MM:SS.ssszzz")
     props["nstime"] = string(f.nstime.value)
-    props["tags"] = JSON2.write(f.tags)
+    props["tags"] = String.(f.tags) # JSON2.write(f.tags)
     # Pack the node data
     fnctype = getSolverData(f).fnc.usrfnc!
     props["data"] = _packSolverData(f, fnctype)
     # Include the type
     props["fnctype"] = String(_getname(fnctype))
-    props["_variableOrderSymbols"] = JSON2.write(f._variableOrderSymbols)
+    props["_variableOrderSymbols"] = String.(f._variableOrderSymbols) # JSON2.write(f._variableOrderSymbols)
     props["solvable"] = getSolvable(f)
     props["_version"] = _getDFGVersion()
     return props
@@ -347,6 +348,27 @@ function decodePackedType(dfg::AbstractDFG, varOrder::AbstractVector{Symbol}, ::
     return factordata
 end
 
+function Base.convert(::Type{PF}, nt::NamedTuple) where {PF <: AbstractPackedFactor}
+    # Here we define a convention, must provide PackedType(;kw...) constructor, easiest is just use Base.@kwdef
+    PF(;nt...)
+end
+
+function Base.convert(::Type{GenericFunctionNodeData{P}}, nt::NamedTuple) where P
+    @show P
+    GenericFunctionNodeData{P}(
+        nt.eliminated,
+        nt.potentialused,
+        nt.edgeIDs,
+        convert(P,nt.fnc),
+        nt.multihypo,
+        nt.certainhypo,
+        nt.nullhypo,
+        nt.solveInProgress,
+        nt.inflation,
+    )
+end
+
+
 # Returns `::DFGFactor`
 function unpackFactor(dfg::G, packedProps::Dict{String, Any}) where G <: AbstractDFG
     # Version checking.
@@ -383,8 +405,10 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any}) where G <: Abstrac
         Symbol.(packedProps["_variableOrderSymbols"])
     end
 
+    # @show packtype
+    # @show data
     try
-        packed = JSON2.read(data, GenericFunctionNodeData{packtype})
+        packed = convert(GenericFunctionNodeData{packtype}, data) # JSON2.read(data, GenericFunctionNodeData{packtype})
         decodeType = getFactorOperationalMemoryType(dfg)
         fullFactorData = decodePackedType(dfg, _variableOrderSymbols, decodeType, packed)
     catch ex

test/testBlocks.jl

@@ -34,10 +34,10 @@ struct TestAbstractPrior <: AbstractPrior end
 struct TestAbstractRelativeFactor <: AbstractRelativeRoots end
 struct TestAbstractRelativeFactorMinimize <: AbstractRelativeMinimize end
 
-struct PackedTestFunctorInferenceType1 <: AbstractPackedFactor
-    s::String
+Base.@kwdef struct PackedTestFunctorInferenceType1 <: AbstractPackedFactor
+    s::String = ""
 end
-PackedTestFunctorInferenceType1() = PackedTestFunctorInferenceType1("")
+# PackedTestFunctorInferenceType1() = PackedTestFunctorInferenceType1("")
 
 function Base.convert(::Type{PackedTestFunctorInferenceType1}, d::TestFunctorInferenceType1)
     # @info "convert(::Type{PackedTestFunctorInferenceType1}, d::TestFunctorInferenceType1)"
@@ -55,10 +55,10 @@ function Base.convert(::Type{TestFunctorInferenceType1}, d::PackedTestFunctorInf
 end
 
 
-struct PackedTestAbstractPrior <: AbstractPackedFactor
+Base.@kwdef struct PackedTestAbstractPrior <: AbstractPackedFactor
     s::String
 end
-PackedTestAbstractPrior() = PackedTestAbstractPrior("")
+# PackedTestAbstractPrior() = PackedTestAbstractPrior("")
 
 function Base.convert(::Type{PackedTestAbstractPrior}, d::TestAbstractPrior)
     # @info "convert(::Type{PackedTestAbstractPrior}, d::TestAbstractPrior)"