Merge pull request #450 from JuliaRobotics/maint/20Q2/reminternalId

Remove _internalId

Author: Affie

src/Deprecated.jl

@@ -10,6 +10,7 @@
 include("../attic/GraphsDFG/GraphsDFG.jl")
 @reexport using .GraphsDFGs
 
+@deprecate getInternalId(args...) error("getInternalId is no longer in use")
 
 @deprecate loadDFG(source::String, iifModule::Module, dest::AbstractDFG) loadDFG!(dest, source)
 
@@ -20,8 +21,6 @@ include("../attic/GraphsDFG/GraphsDFG.jl")
 Base.getproperty(x::DFGFactor,f::Symbol) = begin
     if f == :solvable
         getfield(x,:_dfgNodeParams).solvable
-    elseif f == :_internalId
-        getfield(x,:_dfgNodeParams)._internalId
     else
         getfield(x,f)
     end
@@ -31,8 +30,6 @@ Base.setproperty!(x::DFGFactor,f::Symbol, val) = begin
     if f == :solvable
         setfield!(x,f,val)
         getfield(x,:_dfgNodeParams).solvable = val
-    elseif f == :_internalId
-        getfield(x,:_dfgNodeParams)._internalId = val
     else
         setfield!(x,f,val)
     end
@@ -41,8 +38,6 @@ end
 Base.getproperty(x::DFGVariable,f::Symbol) = begin
     if f == :solvable
         getfield(x,:_dfgNodeParams).solvable
-    elseif f == :_internalId
-        getfield(x,:_dfgNodeParams)._internalId
     else
         getfield(x,f)
     end
@@ -51,8 +46,6 @@ end
 Base.setproperty!(x::DFGVariable,f::Symbol, val) = begin
     if f == :solvable
         getfield(x,:_dfgNodeParams).solvable = val
-    elseif f == :_internalId
-        getfield(x,:_dfgNodeParams)._internalId = val
     else
         setfield!(x,f,val)
     end

src/LightDFG/services/LightDFG.jl

@@ -27,9 +27,6 @@ function addVariable!(dfg::LightDFG{<:AbstractParams, V, <:AbstractDFGFactor}, v
         error("Variable '$(variable.label)' already exists in the factor graph")
     end
 
-    #NOTE Internal ID always set to zero as it is not needed?
-    # variable._internalId = 0
-
     FactorGraphs.addVariable!(dfg.g, variable) || return false
 
     # Track insertion

src/entities/AbstractDFG.jl

@@ -26,8 +26,6 @@ The common node parameters for variables and factors.
 """
 mutable struct DFGNodeParams
     solvable::Int
-    _internalId::Int64
-    DFGNodeParams(s1=0,s2=0) = new(s1,s2)
 end
 
 """

src/entities/DFGFactor.jl

@@ -122,24 +122,22 @@ end
 ##------------------------------------------------------------------------------
 ## Constructors
 
-#TODO _internalId?
 """
 $(SIGNATURES)
 
 Construct a DFG factor given a label.
 """
-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{T}(label::Symbol, timestamp::DateTime=now()) where {T} =
+                DFGFactor(label, timestamp, Set{Symbol}(), GenericFunctionNodeData{T}(), 1, DFGNodeParams(1), Symbol[])
 
 
 DFGFactor(label::Symbol,
           variableOrderSymbols::Vector{Symbol},
           data::GenericFunctionNodeData{T};
           tags::Set{Symbol}=Set{Symbol}(),
           timestamp::DateTime=now(),
-          solvable::Int=1,
-          _internalId::Int64=0) where {T} =
-                DFGFactor{T}(label,timestamp,tags,data,solvable,DFGNodeParams(solvable, _internalId),variableOrderSymbols)
+          solvable::Int=1) where {T} =
+                DFGFactor{T}(label,timestamp,tags,data,solvable,DFGNodeParams(solvable),variableOrderSymbols)
 
 
 
@@ -165,8 +163,6 @@ struct DFGFactorSummary <: AbstractDFGFactor
     """Factor tags, e.g [:FACTOR].
     Accessors: [`getTags`](@ref), [`mergeTags!`](@ref), and [`removeTags!`](@ref)"""
     tags::Set{Symbol}
-    """Internal ID used by some of the DFG drivers. We don't suggest using this outside of DFG."""
-    _internalId::Int64
     """Internal cache of the ordering of the neighbor variables. Rather use getNeighbors to get the list as this is an internal value.
     Accessors: [`getVariableOrder`](@ref)"""
     _variableOrderSymbols::Vector{Symbol}
@@ -214,7 +210,7 @@ const FactorDataLevel2 = Union{DFGFactor}
 ##==============================================================================
 
 DFGFactorSummary(f::DFGFactor) =
-    DFGFactorSummary(f.label, f.timestamp, deepcopy(f.tags), f._dfgNodeParams._internalId, deepcopy(f._variableOrderSymbols))
+    DFGFactorSummary(f.label, f.timestamp, deepcopy(f.tags), deepcopy(f._variableOrderSymbols))
 
 SkeletonDFGFactor(f::FactorDataLevel1) =
     SkeletonDFGFactor(f.label, deepcopy(f.tags), deepcopy(f._variableOrderSymbols))

src/entities/DFGVariable.jl

@@ -219,9 +219,8 @@ DFGVariable(label::Symbol, softtype::T;
             solverDataDict::Dict{Symbol, VariableNodeData{T}}=Dict{Symbol, VariableNodeData{T}}(),
             smallData::Dict{String, String}=Dict{String, String}(),
             bigData::Dict{Symbol, AbstractBigDataEntry}=Dict{Symbol,AbstractBigDataEntry}(),
-            solvable::Int=1,
-            _internalId::Int64=0) where {T <: InferenceVariable} =
-    DFGVariable{T}(label, timestamp, tags, estimateDict, solverDataDict, smallData, bigData, DFGNodeParams(solvable, _internalId))
+            solvable::Int=1) where {T <: InferenceVariable} =
+    DFGVariable{T}(label, timestamp, tags, estimateDict, solverDataDict, smallData, bigData, DFGNodeParams(solvable))
 
 
 DFGVariable(label::Symbol,
@@ -231,15 +230,14 @@ DFGVariable(label::Symbol,
             estimateDict::Dict{Symbol, <: AbstractPointParametricEst}=Dict{Symbol, MeanMaxPPE}(),
             smallData::Dict{String, String}=Dict{String, String}(),
             bigData::Dict{Symbol, AbstractBigDataEntry}=Dict{Symbol,AbstractBigDataEntry}(),
-            solvable::Int=1,
-            _internalId::Int64=0) where {T <: InferenceVariable} =
-    DFGVariable{T}(label, timestamp, tags, estimateDict, Dict{Symbol, VariableNodeData{T}}(:default=>solverData), smallData, bigData, DFGNodeParams(solvable, _internalId))
+            solvable::Int=1) where {T <: InferenceVariable} =
+    DFGVariable{T}(label, timestamp, tags, estimateDict, Dict{Symbol, VariableNodeData{T}}(:default=>solverData), smallData, bigData, DFGNodeParams(solvable))
 
 ##------------------------------------------------------------------------------
 function Base.copy(o::DFGVariable)::DFGVariable
     return DFGVariable(o.label, getSofttype(o)(), tags=copy(o.tags), estimateDict=copy(o.estimateDict),
                         solverDataDict=copy(o.solverDataDict), smallData=copy(o.smallData),
-                        bigData=copy(o.bigData), solvable=getSolvable(o), _internalId=getInternalId(o))
+                        bigData=copy(o.bigData), solvable=getSolvable(o))
 end
 
 ##------------------------------------------------------------------------------
@@ -273,8 +271,6 @@ struct DFGVariableSummary <: AbstractDFGVariable
     """Dictionary of large data associated with this variable.
     Accessors: [`addBigDataEntry!`](@ref), [`getBigDataEntry`](@ref), [`updateBigDataEntry!`](@ref), and [`deleteBigDataEntry!`](@ref)"""
     bigData::Dict{Symbol, AbstractBigDataEntry}
-    """Internal ID used by some of the DFG drivers. We don't suggest using this outside of DFG."""
-    _internalId::Int64
 end
 
 ##------------------------------------------------------------------------------
@@ -313,7 +309,7 @@ const VariableDataLevel2 = Union{DFGVariable}
 ##==============================================================================
 
 DFGVariableSummary(v::DFGVariable) =
-        DFGVariableSummary(v.label, v.timestamp, deepcopy(v.tags), deepcopy(v.ppeDict), Symbol(typeof(getSofttype(v))), v.bigData, v._internalId)
+        DFGVariableSummary(v.label, v.timestamp, deepcopy(v.tags), deepcopy(v.ppeDict), Symbol(typeof(getSofttype(v))), v.bigData)
 
 SkeletonDFGVariable(v::VariableDataLevel1) =
             SkeletonDFGVariable(v.label, deepcopy(v.tags))

src/services/CommonAccessors.jl

@@ -72,20 +72,6 @@ end
 
 
 
-##------------------------------------------------------------------------------
-## _internalId
-##------------------------------------------------------------------------------
-
-"""
-$SIGNATURES
-
-Return the internal ID for DFGNode.
-"""
-getInternalId(v::DataLevel2) = v._dfgNodeParams._internalId
-
-getInternalId(v::Union{DFGVariableSummary, DFGFactorSummary}) = v._internalId
-
-
 ##------------------------------------------------------------------------------
 ## solvable
 ##------------------------------------------------------------------------------

src/services/CompareUtils.jl

@@ -24,7 +24,7 @@ const GeneratedCompareUnion = Union{MeanMaxPPE, VariableNodeData, DFGNodeParams,
                               DFGFactor, DFGFactorSummary, SkeletonDFGFactor}
 
 @generated function ==(x::T, y::T) where T <: GeneratedCompareUnion
-    ignored = [:_internalId]
+    ignored = []
     mapreduce(n -> :(x.$n == y.$n), (a,b)->:($a && $b), setdiff(fieldnames(x), ignored))
 end
 
@@ -178,7 +178,7 @@ function compareVariable(A::DFGVariable,
                          show::Bool=true,
                          skipsamples::Bool=true  )::Bool
   #
-  skiplist = union([:attributes;:solverDataDict;:_internalId;:createdTimestamp;:lastUpdatedTimestamp],skip)
+  skiplist = union([:attributes;:solverDataDict;:createdTimestamp;:lastUpdatedTimestamp],skip)
   TP = compareAll(A, B, skip=skiplist, show=show)
   varskiplist = skipsamples ? [:val; :bw] : Symbol[]
   skiplist = union([:softtype;],varskiplist)
@@ -189,7 +189,7 @@ function compareVariable(A::DFGVariable,
   Bd = getSolverData(B)
 
   # TP = TP && compareAll(A.attributes, B.attributes, skip=[:softtype;], show=show)
-  varskiplist = union(varskiplist, [:softtype;:_internalId])
+  varskiplist = union(varskiplist, [:softtype])
   union!(varskiplist, skip)
   TP = TP && compareAll(Ad, Bd, skip=varskiplist, show=show)
   TP = TP && typeof(Ad.softtype) == typeof(Bd.softtype)
@@ -232,9 +232,9 @@ function compareFactor(A::DFGFactor,
                        skipsamples::Bool=true,
                        skipcompute::Bool=true  )
   #
-  TP =  compareAll(A, B, skip=union([:attributes;:solverData;:_variableOrderSymbols;:_internalId],skip), show=show)
+  TP =  compareAll(A, B, skip=union([:attributes;:solverData;:_variableOrderSymbols],skip), show=show)
   # TP = TP & compareAll(A.attributes, B.attributes, skip=[:data;], show=show)
-  TP = TP & compareAllSpecial(getSolverData(A), getSolverData(B), skip=union([:fnc;:_internalId], skip), show=show)
+  TP = TP & compareAllSpecial(getSolverData(A), getSolverData(B), skip=union([:fnc], skip), show=show)
   TP = TP & compareAllSpecial(getSolverData(A).fnc, getSolverData(B).fnc, skip=union([:cpt;:measurement;:params;:varidx;:threadmodel], skip), show=show)
   TP = TP & (skipsamples || compareAll(getSolverData(A).fnc.measurement, getSolverData(B).fnc.measurement, show=show, skip=skip))
   TP = TP & (skipcompute || compareAll(getSolverData(A).fnc.params, getSolverData(B).fnc.params, show=show, skip=skip))

src/services/DFGFactor.jl

@@ -73,7 +73,7 @@ function setTimestamp(f::DFGFactor, ts::DateTime)
 end
 
 function setTimestamp(f::DFGFactorSummary, ts::DateTime)
-    return DFGFactorSummary(f.label, ts, f.tags, f._internalId, f._variableOrderSymbols)
+    return DFGFactorSummary(f.label, ts, f.tags, f._variableOrderSymbols)
 end
 
 setTimestamp!(f::FactorDataLevel1, ts::DateTime) = f.timestamp = ts
@@ -89,11 +89,10 @@ setTimestamp!(f::FactorDataLevel1, ts::DateTime) = f.timestamp = ts
 # isSolvable
 
 ##------------------------------------------------------------------------------
-## _dfgNodeParams [solvable _internalId]
+## _dfgNodeParams [solvable]
 ##------------------------------------------------------------------------------
 
 ## COMMON
-# getInternalId
 
 
 ##------------------------------------------------------------------------------

src/services/DFGVariable.jl

@@ -173,21 +173,20 @@ function setTimestamp(v::DFGVariableSummary, ts::DateTime; verbose::Bool=true)
     if verbose
         @warn "verbose=true: setTimestamp(::DFGVariableSummary,...) creates and returns a new immutable DFGVariable object (and didn't change a distributed factor graph object), make sure you are using the right pointers: getVariable(...).  See setTimestamp!(...) and note suggested use is at addVariable!(..., [timestamp=...]).  See DFG #315 for explanation."
     end
-    return DFGVariableSummary(v.label, ts, v.tags, v.ppeDict, v.softtypename, v.bigData, v._internalId)
+    return DFGVariableSummary(v.label, ts, v.tags, v.ppeDict, v.softtypename, v.bigData)
 end
 
 
 ##------------------------------------------------------------------------------
-## _dfgNodeParams [_internalId, solvable]
+## _dfgNodeParams [solvable]
 ##------------------------------------------------------------------------------
 
 ## COMMON: solvable
 # getSolvable
 # setSolvable!
 # isSolvable
 
-## COMMON: _internalId
-# getInternalId
+## COMMON:
 
 ##------------------------------------------------------------------------------
 ## ppeDict

src/services/Serialization.jl

@@ -37,7 +37,7 @@ function unpackVariable(dfg::G, packedProps::Dict{String, Any})::DFGVariable whe
     solverData = Dict(Symbol.(keys(packed)) .=> map(p -> unpackVariableNodeData(dfg, p), values(packed)))
 
     # Rebuild DFGVariable using the first solver softtype in solverData
-    variable = DFGVariable{softtype}(Symbol(packedProps["label"]), timestamp, Set(tags), ppeDict, solverData,  smallData, Dict{Symbol,AbstractBigDataEntry}(), DFGNodeParams(packedProps["solvable"],0))
+    variable = DFGVariable{softtype}(Symbol(packedProps["label"]), timestamp, Set(tags), ppeDict, solverData,  smallData, Dict{Symbol,AbstractBigDataEntry}(), DFGNodeParams(packedProps["solvable"]))
 
     # Now rehydrate complete bigData type.
     for (k,bdeInter) in bigDataIntermed
@@ -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(label), 0, timestamp)
+    factor = DFGFactor{typeof(fullFactorData.fnc)}(Symbol(label), timestamp)
 
     union!(factor.tags, tags)
     # factor.data = fullFactorData #TODO