Merge pull request #848 from JuliaRobotics/22Q1/enh/topjsononly

top level JSON2.write only, distr are JSON

Author: dehann

src/Neo4jDFG/services/Neo4jDFG.jl

@@ -271,7 +271,9 @@ function getFactor(dfg::Neo4jDFG, label::Union{Symbol, String})
     props = result.results[1]["data"][1]["row"][1]
 
     # NOTE: Until we address #590, base64 decode the data to ensure robustness, #833
-    props["data"] = String(base64decode(props["data"]))
+    # TODO: consolidate with top level only JSON, #848
+    packedData = String(base64decode(props["data"]))
+    props["data"] = JSON2.read(packedData)
 
     return rebuildFactorMetadata!(dfg, unpackFactor(dfg, props))
 end

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

@@ -299,9 +299,10 @@ function _packSolverData(
     packtype = convertPackedType(fnctype)
     try
         packed = convert( PackedFunctionNodeData{packtype}, getSolverData(f) )
-        packedJson = JSON2.write(packed)
+        packedJson = packed # JSON2.write(packed) # NOTE SINGLE TOP LEVEL JSON.write ONLY
         if base64Encode
-            # 833
+            # 833, 848, Neo4jDFG still using base64(JSON2.write(solverdata))...
+            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,26 @@ 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
+    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.
@@ -367,6 +388,14 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any}) where G <: Abstrac
             tags = Vector{Symbol}()
         end
     end
+    
+    # Get the stored variable order
+    _variableOrderSymbols = if packedProps["_variableOrderSymbols"] isa String
+        JSON2.read(packedProps["_variableOrderSymbols"], Vector{Symbol})
+    else
+        Symbol.(packedProps["_variableOrderSymbols"])
+    end
+
     data = packedProps["data"]
     datatype = packedProps["fnctype"]
     @debug "DECODING factor type = '$(datatype)' for factor '$label'"
@@ -376,15 +405,10 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any}) where G <: Abstrac
     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
-    
+    # @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
-    s::String
+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)"