Merge pull request #440 from JuliaRobotics/maint/20Q2/gfnd#274part2

Remove deprecated fncargvID and remove unused frommodule.

Author: Affie

src/DistributedFactorGraphs.jl

@@ -176,7 +176,7 @@ export addData!, fetchData, fetchDataEntryElement
 # Factors
 ##------------------------------------------------------------------------------
 # Factor Data
-export GenericFunctionNodeData
+export GenericFunctionNodeData, PackedFunctionNodeData, FunctionNodeData
 export InferenceType, PackedInferenceType, FunctorInferenceType, FactorOperationalMemory
 export FunctorSingleton, FunctorPairwise, FunctorPairwiseMinimize
 

src/entities/DFGFactor.jl

@@ -30,36 +30,49 @@ Notes
 
 Designing (WIP)
 - T <: Union{FactorOperationalMemory, PackedInferenceType}
-# in IIF.CCW{T <: DFG.InferenceType}
-# in IIF.FunctorPairwiseMinimize <: InferenceType # DFG whatever, something, we'll figure it out
-# in Main/User, SomeFactor <: FunctorPairwiseMinimize
+- in IIF.CCW{T <: DFG.InferenceType}
+- in IIF.FunctorPairwiseMinimize <: InferenceType # DFG whatever, something, we'll figure it out
+- in Main/User, SomeFactor <: FunctorPairwiseMinimize
 """
-mutable struct GenericFunctionNodeData{T<:Union{PackedInferenceType, FunctorInferenceType, FactorOperationalMemory}, S<:Union{Symbol, AbstractString}}
-    fncargvID::Vector{Symbol}
+mutable struct GenericFunctionNodeData{T<:Union{PackedInferenceType, FunctorInferenceType, FactorOperationalMemory}}
     eliminated::Bool
     potentialused::Bool
-    edgeIDs::Array{Int,1}
-    frommodule::S # JT TODO remove frommodule, not used at all as far as i can tell
+    edgeIDs::Vector{Int}
     fnc::T
     multihypo::Vector{Float64} # likely to moved when GenericWrapParam is refactored
     certainhypo::Vector{Int}
     solveInProgress::Int
-    GenericFunctionNodeData{T, S}() where {T, S} = new{T,S}()
-    GenericFunctionNodeData{T, S}(x1, x2, x3, x4, x5::S, x6::T, multihypo::Vector{<:Real}=Float64[], certainhypo::Vector{Int}=Int[], x9::Int=0) where {T, S} = new{T,S}(x1, x2, x3, x4, x5, x6, multihypo, certainhypo, x9)
-    GenericFunctionNodeData(x1, x2, x3, x4, x5::S, x6::T, multihypo::Vector{<:Real}=Float64[], certainhypo::Vector{Int}=Int[], x9::Int=0) where {T, S} = new{T,S}(x1, x2, x3, x4, x5, x6, multihypo, certainhypo, x9)
-    # GenericFunctionNodeData(x1, x2, x3, x4, x5::S, x6::T, x7::String) where {T, S} = new{T,S}(x1, x2, x3, x4, x5, x6, x7)
 end
 
 ## Constructors
 
+GenericFunctionNodeData{T}() where T =
+    GenericFunctionNodeData{T}(false, false, Int[], T(), Float64[], Int[], 0)
+
+function GenericFunctionNodeData(eliminated,
+                                 potentialused,
+                                 edgeIDs,
+                                 fnc,
+                                 multihypo=Float64[],
+                                 certainhypo=Int[])
+    return GenericFunctionNodeData(eliminated, potentialused, edgeIDs, fnc, multihypo, certainhypo, 0)
+end
+
+
 ##------------------------------------------------------------------------------
 ## PackedFunctionNodeData and FunctionNodeData
 
-# Simply for convenience - don't export, TODO Its used in IIF so maybe it should be exported
-const PackedFunctionNodeData{T} = GenericFunctionNodeData{T, <: AbstractString}
-PackedFunctionNodeData(x1, x2, x3, x4, x5::S, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where {T <: PackedInferenceType, S <: AbstractString} = GenericFunctionNodeData(x1, x2, x3, x4, x5, x6, multihypo, certainhypo, x9)
-const FunctionNodeData{T} = GenericFunctionNodeData{T, Symbol}
-FunctionNodeData(x1, x2, x3, x4, x5::Symbol, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where {T <: Union{FunctorInferenceType, FactorOperationalMemory}}= GenericFunctionNodeData{T, Symbol}(x1, x2, x3, x4, x5, x6, multihypo, certainhypo, x9)
+const PackedFunctionNodeData{T} = GenericFunctionNodeData{T} where T <: PackedInferenceType
+PackedFunctionNodeData(args...) = PackedFunctionNodeData{typeof(args[4])}(args...)
+
+const FunctionNodeData{T} = GenericFunctionNodeData{T} where T <: Union{FunctorInferenceType, FactorOperationalMemory}
+FunctionNodeData(args...) = FunctionNodeData{typeof(args[4])}(args...)
+
+
+# PackedFunctionNodeData(x2, x3, x4, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where T <: PackedInferenceType =
+#     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{FunctorInferenceType, FactorOperationalMemory} =
+#     GenericFunctionNodeData{T}(x2, x3, x4, x6, multihypo, certainhypo, x9)
 
 ##==============================================================================
 ## Factors
@@ -81,7 +94,7 @@ Complete factor structure for a DistributedFactorGraph factor.
 Fields:
 $(TYPEDFIELDS)
 """
-mutable struct DFGFactor{T, S} <: AbstractDFGFactor
+mutable struct DFGFactor{T} <: AbstractDFGFactor
     """Factor label, e.g. :x1f1.
     Accessor: [`getLabel`](@ref)"""
     label::Symbol
@@ -93,7 +106,7 @@ mutable struct DFGFactor{T, S} <: AbstractDFGFactor
     tags::Set{Symbol}
     """Solver data.
     Accessors: [`getSolverData`](@ref), [`setSolverData!`](@ref)"""
-    solverData::GenericFunctionNodeData{T, S}
+    solverData::GenericFunctionNodeData{T}
     """Solvable flag for the factor.
     Accessors: [`getSolvable`](@ref), [`setSolvable!`](@ref)
     TODO: Switch to `DFGNodeParams`"""
@@ -115,18 +128,18 @@ $(SIGNATURES)
 
 Construct a DFG factor given a label.
 """
-DFGFactor{T, S}(label::Symbol, internalId::Int64=0, timestamp::DateTime=now()) where {T, S} =
-                DFGFactor(label, timestamp, Set{Symbol}(), GenericFunctionNodeData{T, S}(), 1, DFGNodeParams(1, internalId), Symbol[])
+DFGFactor{T}(label::Symbol, internalId::Int64=0, timestamp::DateTime=now()) where {T} =
+                DFGFactor(label, timestamp, Set{Symbol}(), GenericFunctionNodeData{T}(), 1, DFGNodeParams(1, internalId), Symbol[])
 
 
 DFGFactor(label::Symbol,
           variableOrderSymbols::Vector{Symbol},
-          data::GenericFunctionNodeData{T, S};
+          data::GenericFunctionNodeData{T};
           tags::Set{Symbol}=Set{Symbol}(),
           timestamp::DateTime=now(),
           solvable::Int=1,
-          _internalId::Int64=0) where {T, S} =
-                DFGFactor{T,S}(label,timestamp,tags,data,solvable,DFGNodeParams(solvable, _internalId),variableOrderSymbols)
+          _internalId::Int64=0) where {T} =
+                DFGFactor{T}(label,timestamp,tags,data,solvable,DFGNodeParams(solvable, _internalId),variableOrderSymbols)
 
 
 

src/services/CompareUtils.jl

@@ -210,13 +210,12 @@ end
 
 
 # Compare FunctionNodeData
-function compare(a::GenericFunctionNodeData{T1,S},b::GenericFunctionNodeData{T2,S}) where {T1, T2, S}
+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 && a.frommodule == b.frommodule
   # TP = TP && typeof(a.fnc) == typeof(b.fnc)
   return TP
 end

src/services/Serialization.jl

@@ -119,7 +119,7 @@ function packFactor(dfg::G, f::DFGFactor)::Dict{String, Any} where G <: Abstract
 end
 
 
-function decodePackedType(::Type{T}, packeddata::GenericFunctionNodeData{PT,<:AbstractString}) where {T<:FactorOperationalMemory, PT}
+function decodePackedType(::Type{T}, packeddata::GenericFunctionNodeData{PT}) where {T<:FactorOperationalMemory, PT}
   # usrtyp = convert(FunctorInferenceType, packeddata.fnc)
   # Also look at parentmodule
   usrtyp = getfield(PT.name.module, Symbol(string(PT.name.name)[7:end]))
@@ -142,7 +142,7 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G
     packed = nothing
     fullFactorData = nothing
     try
-        packed = JSON2.read(data, GenericFunctionNodeData{packtype,String})
+        packed = JSON2.read(data, GenericFunctionNodeData{packtype})
         decodeType = getFactorOperationalMemoryType(dfg)
         fullFactorData = decodePackedType(decodeType, packed)
     catch ex
@@ -159,7 +159,7 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G
 
     # Rebuild DFGFactor
     #TODO use constuctor to create factor
-    factor = DFGFactor{typeof(fullFactorData.fnc), Symbol}(Symbol(label), 0, timestamp)
+    factor = DFGFactor{typeof(fullFactorData.fnc)}(Symbol(label), 0, timestamp)
 
     union!(factor.tags, tags)
     # factor.data = fullFactorData #TODO

test/DataStoreTests.jl

@@ -8,7 +8,7 @@ dfg = LightDFG{NoSolverParams}()
 struct TestInferenceVariable1 <: InferenceVariable end
 v1 = DFGVariable(:a, TestInferenceVariable1())
 v2 = DFGVariable(:b, TestInferenceVariable1())
-f1 = DFGFactor{TestFunctorInferenceType1, Symbol}(:f1)
+f1 = DFGFactor{TestFunctorInferenceType1}(:f1)
 #add tags for filters
 union!(v1.tags, [:VARIABLE, :POSE])
 union!(v2.tags, [:VARIABLE, :LANDMARK])

test/compareTests.jl

@@ -42,9 +42,9 @@ v2.solvable = 0
 @test !(DFGVariable(:x1, TestSofttype1()) == DFGVariable(:x1, TestSofttype2()))
 
 # GenericFunctionNodeData
-gfnd1 = GenericFunctionNodeData([:a,:b], true, true, [1,2], :symbol, TestFunctorInferenceType1())
+gfnd1 = GenericFunctionNodeData(true, true, [1,2], TestFunctorInferenceType1())
 gfnd2 = deepcopy(gfnd1)
-gfnd3 = GenericFunctionNodeData([:a,:b], true, true, [1,2], :symbol, TestFunctorInferenceType2())
+gfnd3 = GenericFunctionNodeData(true, true, [1,2], TestFunctorInferenceType2())
 
 @test gfnd1 == gfnd2
 @test !(gfnd1 == gfnd3)
@@ -72,9 +72,9 @@ vnd2.val[1] = 0.1
 @test !compare(vnd1, vnd2)
 @test !compare(vnd1, vnd3)
 
-gfnd1 = GenericFunctionNodeData([:a,:b], true, true, [1,2], :symbol, TestFunctorInferenceType1())
+gfnd1 = GenericFunctionNodeData(true, true, [1,2], TestFunctorInferenceType1())
 gfnd2 = deepcopy(gfnd1)
-gfnd3 = GenericFunctionNodeData([:a,:b], true, true, [1,2], :symbol, PackedTestFunctorInferenceType1())
+gfnd3 = GenericFunctionNodeData(true, true, [1,2], PackedTestFunctorInferenceType1())
 
 @test compare(gfnd1, gfnd2)
 @test_broken !(compare(gfnd1, gfnd3))

test/interfaceTests.jl

@@ -62,7 +62,7 @@ end
     fg = testDFGAPI()
     addVariable!(fg, DFGVariable(:a, TestSofttype1()))
     addVariable!(fg, DFGVariable(:b, TestSofttype1()))
-    addFactor!(fg, DFGFactor(:abf1, [:a,:b], GenericFunctionNodeData{TestFunctorInferenceType1, Symbol}()))
+    addFactor!(fg, DFGFactor(:abf1, [:a,:b], GenericFunctionNodeData{TestFunctorInferenceType1}()))
     addVariable!(fg, DFGVariable(:orphan, TestSofttype1(), solvable = 0))
 
     AdjacencyMatricesTestBlock(fg)
@@ -101,7 +101,7 @@ end
     addVariable!(fg, DFGVariable(:a, TestSofttype1()))
     addVariable!(fg, DFGVariable(:b, TestSofttype1()))
     addVariable!(fg, DFGVariable(:c, TestSofttype1()))
-    addFactor!(fg, DFGFactor(:f1, [:a,:b,:c], GenericFunctionNodeData{TestFunctorInferenceType1, Symbol}()))
+    addFactor!(fg, DFGFactor(:f1, [:a,:b,:c], GenericFunctionNodeData{TestFunctorInferenceType1}()))
 
     # fgcopy = testDFGAPI()
     # DFG._copyIntoGraph!(fg, fgcopy, union(ls(fg), lsf(fg)))

test/needsahomeTests.jl

@@ -10,7 +10,7 @@ struct TestInferenceVariable2 <: InferenceVariable end
     # Build a graph
     v1 = DFGVariable(:a, TestInferenceVariable1())
     v2 = DFGVariable(:b, TestInferenceVariable1())
-    f1 = DFGFactor{TestFunctorInferenceType1, Symbol}(:f1)
+    f1 = DFGFactor{TestFunctorInferenceType1}(:f1)
     addVariable!(dfg, v1)
     addVariable!(dfg, v2)
     addFactor!(dfg, [v1, v2], f1)

test/plottingTest.jl

@@ -10,7 +10,7 @@ numNodes = 10
 dfg = GraphsDFG{NoSolverParams}()
 verts = map(n -> DFGVariable(Symbol("x$n"), TestInferenceVariable1()), 1:numNodes)
 map(v -> addVariable!(dfg, v), verts)
-map(n -> addFactor!(dfg, [verts[n], verts[n+1]], DFGFactor{TestFunctorInferenceType1, Symbol}(Symbol("x$(n)x$(n+1)f1"))), 1:(numNodes-1))
+map(n -> addFactor!(dfg, [verts[n], verts[n+1]], DFGFactor{TestFunctorInferenceType1}(Symbol("x$(n)x$(n+1)f1"))), 1:(numNodes-1))
 
 # Using GraphPlot plotting
 plot = dfgplot(dfg)

test/testBlocks.jl

@@ -59,6 +59,9 @@ end
 struct TestCCW{T} <: FactorOperationalMemory where {T<:FunctorInferenceType}
     usrfnc!::T
 end
+
+TestCCW{T}() where T = TestCCW(T())
+
 Base.:(==)(a::TestCCW, b::TestCCW) = a.usrfnc! == b.usrfnc!
 
 
@@ -71,11 +74,9 @@ getFactorOperationalMemoryType(par::NoSolverParams) = TestCCW
 function Base.convert(::Type{DFG.FunctionNodeData{TestCCW{F}}},
                      d::DFG.PackedFunctionNodeData{<:PackedInferenceType}) where F<:FunctorInferenceType
 
-    return DFG.FunctionNodeData(d.fncargvID,
-                                d.eliminated,
+    return DFG.FunctionNodeData(d.eliminated,
                                 d.potentialused,
                                 d.edgeIDs,
-                                Symbol(d.frommodule),
                                 TestCCW(convert(F, d.fnc)),
                                 d.multihypo,
                                 d.certainhypo,
@@ -84,11 +85,9 @@ end
 
 function Base.convert(::Type{DFG.PackedFunctionNodeData{P}}, d::DFG.FunctionNodeData{<:FactorOperationalMemory}) where P <: PackedInferenceType
   # mhstr = packmultihypo(d.fnc)  # this is where certainhypo error occurs
-  return DFG.PackedFunctionNodeData(d.fncargvID,
-                                    d.eliminated,
+  return DFG.PackedFunctionNodeData(d.eliminated,
                                     d.potentialused,
                                     d.edgeIDs,
-                                    string(d.frommodule),
                                     convert(P, d.fnc.usrfnc!),
                                     d.multihypo,
                                     d.certainhypo,
@@ -310,14 +309,14 @@ function  DFGFactorSCA()
     f1_tags = Set([:FACTOR])
     testTimestamp = now()
 
-    gfnd_prior = GenericFunctionNodeData(Symbol[], false, false, Int[], :DistributedFactorGraphs, TestCCW(TestFunctorSingleton()))
+    gfnd_prior = GenericFunctionNodeData(false, false, Int[], TestCCW(TestFunctorSingleton()))
 
-    gfnd = GenericFunctionNodeData(Symbol[], false, false, Int[], :DistributedFactorGraphs, TestCCW(TestFunctorInferenceType1()))
+    gfnd = GenericFunctionNodeData(false, false, Int[], TestCCW(TestFunctorInferenceType1()))
 
-    f1 = DFGFactor{TestCCW{TestFunctorInferenceType1}, Symbol}(f1_lbl)
+    f1 = DFGFactor{TestCCW{TestFunctorInferenceType1}}(f1_lbl)
     f1 = DFGFactor(f1_lbl, [:a,:b], gfnd, tags = f1_tags, solvable=0)
 
-    f2 = DFGFactor{TestCCW{TestFunctorInferenceType1}, Symbol}(:bcf1)
+    f2 = DFGFactor{TestCCW{TestFunctorInferenceType1}}(:bcf1)
     #TODO add tests for mutating vos in updateFactor and orphan related checks.
     # we should perhaps prevent an empty vos
     f2._variableOrderSymbols = [:b, :c]
@@ -367,11 +366,9 @@ function  DFGFactorSCA()
     f0 = DFGFactor(:af1, [:a], gfnd_prior, tags = Set([:PRIOR]))
 
     #fill in undefined fields
-    f2.solverData.certainhypo = Int[]
-    f2.solverData.fncargvID = Symbol[]
-    f2.solverData.frommodule = :DistributedFactorGraphs
-    f2.solverData.multihypo = Float64[]
-    f2.solverData.edgeIDs = Int64[]
+    # f2.solverData.certainhypo = Int[]
+    # f2.solverData.multihypo = Float64[]
+    # f2.solverData.edgeIDs = Int64[]
 
     return  (f0=f0, f1=f1, f2=f2)
 end
@@ -1012,7 +1009,7 @@ function connectivityTestGraph(::Type{T}; VARTYPE=DFGVariable, FACTYPE=DFGFactor
         setSolvable!(dfg, :x8, 0)
         setSolvable!(dfg, :x9, 0)
 
-        gfnd = GenericFunctionNodeData(Symbol[], false, false, Int[], :DistributedFactorGraphs, TestCCW(TestFunctorInferenceType1()))
+        gfnd = GenericFunctionNodeData(false, false, Int[], TestCCW(TestFunctorInferenceType1()))
         f_tags = Set([:FACTOR])
         # f1 = DFGFactor(f1_lbl, [:a,:b], gfnd, tags = f_tags)
 
@@ -1202,7 +1199,7 @@ function ProducingDotFiles(testDFGAPI,
         v2 = VARTYPE(:b, VariableNodeData{TestSofttype1}())
     end
     if f1 == nothing
-        f1 = (FACTYPE==DFGFactor) ? DFGFactor{TestFunctorInferenceType1, Symbol}(:abf1) : FACTYPE(:abf1)
+        f1 = (FACTYPE==DFGFactor) ? DFGFactor{TestFunctorInferenceType1}(:abf1) : FACTYPE(:abf1)
     end
 
     addVariable!(dotdfg, v1)