solverData -> getSolverData and test if deprecated and sort

Author: Affie

src/CloudGraphsDFG/services/CloudGraphsDFG.jl

@@ -163,7 +163,7 @@ function getFactor(dfg::CloudGraphsDFG, factorId::Int64)::DFGFactor
     factor = dfg.rebuildFactorMetadata!(dfg, factor)
     # GUARANTEED never to bite us in the future...
     # ... TODO: refactor if changed: https://github.com/JuliaRobotics/IncrementalInference.jl/issues/350
-    solverData(factor).fncargvID = factor._variableOrderSymbols
+    getSolverData(factor).fncargvID = factor._variableOrderSymbols
 
     # Add to cache
     push!(dfg.factorCache, factor.label=>factor)

src/Common.jl

@@ -114,7 +114,6 @@ Related
 ls, lsf
 """
 sortDFG(vars::Vector{Symbol})::Vector{Symbol} = sortVarNested(vars)
-
 """
     $SIGNATURES
 
@@ -137,7 +136,7 @@ function getfnctype(data::GenericFunctionNodeData)
   return data.fnc.usrfnc!
 end
 function getfnctype(fact::DFGFactor; solveKey::Symbol=:default)
-  data = solverData(fact) # TODO , solveKey=solveKey)
+  data = getSolverData(fact) # TODO , solveKey=solveKey)
   return getfnctype(data)
 end
 function getfnctype(dfg::T, lbl::Symbol; solveKey::Symbol=:default) where T <: AbstractDFG
@@ -153,7 +152,7 @@ Notes
 - Replaces older `getfnctype`.
 """
 getFactorType(data::GenericFunctionNodeData) = data.fnc.usrfnc!
-getFactorType(fct::DFGFactor) = getFactorType(solverData(fct))
+getFactorType(fct::DFGFactor) = getFactorType(getSolverData(fct))
 function getFactorType(dfg::G, lbl::Symbol) where G <: AbstractDFG
   getFactorType(getFactor(dfg, lbl))
 end
@@ -464,3 +463,29 @@ function hasTagsNeighbors(dfg::InMemoryDFGTypes,
   alltags = union( (ls(dfg, sym) .|> x->getTags(getNeiFnc(dfg,x)))... )
   length(filter(x->x in alltags, tags)) >= (matchAll ? length(tags) : 1)
 end
+
+
+
+#Natural Sorting
+# Adapted from https://rosettacode.org/wiki/Natural_sorting
+# split at digit to not digit change
+splitbynum(x::AbstractString) = split(x, r"(?<=\D)(?=\d)|(?<=\d)(?=\D)")
+#parse to Int
+numstringtonum(arr::Vector{<:AbstractString}) = [(n = tryparse(Int, e)) != nothing ? n : e for e in arr]
+#natural less than
+function natural_lt(x::T, y::T) where T <: AbstractString
+    xarr = numstringtonum(splitbynum(x))
+    yarr = numstringtonum(splitbynum(y))
+    for i in 1:min(length(xarr), length(yarr))
+        if typeof(xarr[i]) != typeof(yarr[i])
+            return isa(xarr[i], Int)
+        elseif xarr[i] == yarr[i]
+            continue
+        else
+            return xarr[i] < yarr[i]
+        end
+    end
+    return length(xarr) < length(yarr)
+end
+
+natural_lt(x::Symbol, y::Symbol) = natural_lt(string(x),string(y))

src/Deprecated.jl

@@ -131,7 +131,7 @@ end
 Retrieve data structure stored in a variable.
 """
 function getData(v::DFGVariable; solveKey::Symbol=:default)::VariableNodeData
-  @warn "getData is deprecated, please use solverData()"
+  @warn "getData is deprecated, please use getSolverData()"
   return v.solverDataDict[solveKey]
 end
 
@@ -153,6 +153,6 @@ end
 Retrieve solver data structure stored in a factor.
 """
 function data(f::DFGFactor)::GenericFunctionNodeData
-  @warn "data() is deprecated, please use solverData()"
+  @warn "data() is deprecated, please use getSolverData()"
   return f.data
 end

src/FileDFG/services/FileDFG.jl

@@ -138,7 +138,7 @@ function loadDFG(dst::String, iifModule, dfgLoadInto::G; loaddir=joinpath("/","t
     # PATCH - To update the fncargvID for factors, it's being cleared somewhere in rebuildFactorMetadata.
     # TEMPORARY
     # TODO: Remove in future
-    map(f->solverData(f).fncargvID = f._variableOrderSymbols, getFactors(dfgLoadInto))
+    map(f->getSolverData(f).fncargvID = f._variableOrderSymbols, getFactors(dfgLoadInto))
 
     return dfgLoadInto
 end

src/LightDFG/LightDFG.jl

@@ -40,8 +40,7 @@ import ...DistributedFactorGraphs:  setSolverParams,
                                     getNeighbors,
                                     getSubgraphAroundNode,
                                     getSubgraph,
-                                    getIncidenceMatrix,
-                                    getIncidenceMatrixSparse,
+                                    getBiadjacencyMatrix,
                                     _getDuplicatedEmptyDFG,
                                     toDot,
                                     toDotFile

src/LightDFG/services/LightDFG.jl

@@ -261,7 +261,7 @@ function _copyIntoGraph!(sourceDFG::LightDFG{<:AbstractParams, V, F}, destDFG::L
 
     for v in values(sourceDFG.g.variables)
         if v.label in labels
-            exists(destDFG, v) ? (@warn "_copyIntoGraph $(v.label) exists, ignoring") : addVariable!(destDFG, deepcopy(v))
+            exists(destDFG, v) ? (@warn "_copyIntoGraph $(v.label) exists, ignoring pending error behaviour decision") : addVariable!(destDFG, deepcopy(v))
         end
     end
 
@@ -283,7 +283,7 @@ function _copyIntoGraph!(sourceDFG::LightDFG{<:AbstractParams, V, F}, destDFG::L
 
             # Only if we have all of them should we add it (otherwise strange things may happen on evaluation)
             if includeOrphanFactors || length(factVariables) == length(neigh_labels)
-                exists(destDFG, f.label) ? (@warn "_copyIntoGraph $(f.label) exists, ignoring") : addFactor!(destDFG, factVariables, deepcopy(f))
+                exists(destDFG, f.label) ? (@warn "_copyIntoGraph $(f.label) exists, ignoring pending error behaviour decision") : addFactor!(destDFG, factVariables, deepcopy(f))
             end
         end
     end

src/services/AbstractDFG.jl

@@ -823,7 +823,7 @@ function getSolveInProgress(var::Union{DFGVariable, DFGFactor}; solveKey::Symbol
     # Variable
     var isa DFGVariable && return haskey(getSolverDataDict(var), solveKey) ? getSolverDataDict(var)[solveKey].solveInProgress : 0
     # Factor
-    return solverData(var).solveInProgress
+    return getSolverData(var).solveInProgress
 end
 
 """
@@ -909,7 +909,7 @@ end
 Return reference to the user factor in `<:AbstractDFG` identified by `::Symbol`.
 """
 getFactorFunction(fcd::GenericFunctionNodeData) = fcd.fnc.usrfnc!
-getFactorFunction(fc::DFGFactor) = getFactorFunction(solverData(fc))
+getFactorFunction(fc::DFGFactor) = getFactorFunction(getSolverData(fc))
 function getFactorFunction(dfg::G, fsym::Symbol) where G <: AbstractDFG
   getFactorFunction(getFactor(dfg, fsym))
 end

src/services/CompareUtils.jl

@@ -132,8 +132,8 @@ function compareVariable(A::DFGVariable,
   union!(skiplist, skip)
   TP = TP && compareAll(A.solverDataDict, B.solverDataDict, skip=skiplist, show=show)
 
-  Ad = solverData(A)
-  Bd = solverData(B)
+  Ad = getSolverData(A)
+  Bd = getSolverData(B)
 
   # TP = TP && compareAll(A.attributes, B.attributes, skip=[:softtype;], show=show)
   varskiplist = union(varskiplist, [:softtype;:_internalId])
@@ -169,20 +169,20 @@ function compareFactor(A::DFGFactor,
   #
   TP =  compareAll(A, B, skip=union([:attributes;:data;:_variableOrderSymbols;:_internalId],skip), show=show)
   # TP = TP & compareAll(A.attributes, B.attributes, skip=[:data;], show=show)
-  TP = TP & compareAllSpecial(solverData(A), solverData(B), skip=union([:fnc;:_internalId], skip), show=show)
-  TP = TP & compareAllSpecial(solverData(A).fnc, solverData(B).fnc, skip=union([:cpt;:measurement;:params;:varidx;:threadmodel], skip), show=show)
-  TP = TP & (skipsamples || compareAll(solverData(A).fnc.measurement, solverData(B).fnc.measurement, show=show, skip=skip))
-  TP = TP & (skipcompute || compareAll(solverData(A).fnc.params, solverData(B).fnc.params, show=show, skip=skip))
-  TP = TP & (skipcompute || compareAll(solverData(A).fnc.varidx, solverData(B).fnc.varidx, show=show, skip=skip))
+  TP = TP & compareAllSpecial(getSolverData(A), getSolverData(B), skip=union([:fnc;:_internalId], 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))
+  TP = TP & (skipcompute || compareAll(getSolverData(A).fnc.varidx, getSolverData(B).fnc.varidx, show=show, skip=skip))
 
   return TP
 end
-  # Ad = solverData(A)
-  # Bd = solverData(B)
+  # Ad = getSolverData(A)
+  # Bd = getSolverData(B)
   # TP =  compareAll(A, B, skip=[:attributes;:data], show=show)
   # TP &= compareAll(A.attributes, B.attributes, skip=[:data;], show=show)
-  # TP &= compareAllSpecial(solverData(A).fnc, solverData(B).fnc, skip=[:cpt;], show=show)
-  # TP &= compareAll(solverData(A).fnc.cpt, solverData(B).fnc.cpt, show=show)
+  # TP &= compareAllSpecial(getSolverData(A).fnc, getSolverData(B).fnc, skip=[:cpt;], show=show)
+  # TP &= compareAll(getSolverData(A).fnc.cpt, getSolverData(B).fnc.cpt, show=show)
 
 
 """

src/services/DFGVariable.jl

@@ -164,7 +164,7 @@ end
 Add Big Data Entry to a DFG variable
 """
 function addBigDataEntry!(var::AbstractDFGVariable, bde::AbstractBigDataEntry)::AbstractDFGVariable
-    haskey(var.bigData,bde.key) && @warn "$(bde.key) already exists in variable, overwriting!"
+    haskey(var.bigData,bde.key) && error("BigData entry $(bde.key) already exists in variable")
     var.bigData[bde.key] = bde
     return var
 end
@@ -424,5 +424,5 @@ Related
 getSolved, isSolved
 """
 setSolvedCount!(v::VariableNodeData, val::Int) = v.solvedCount = val
-setSolvedCount!(v::VariableDataLevel2, val::Int, solveKey::Symbol=:default) = setSolvedCount!(solverData(v, solveKey), val)
+setSolvedCount!(v::VariableDataLevel2, val::Int, solveKey::Symbol=:default) = setSolvedCount!(getSolverData(v, solveKey), val)
 setSolvedCount!(dfg::AbstractDFG, sym::Symbol, val::Int, solveKey::Symbol=:default) = setSolvedCount!(getVariable(dfg, sym), val, solveKey)

test/LightDFGSummaryTypes.jl

@@ -68,11 +68,6 @@ end
     @test exists(dfg, :a) == true
     @test exists(dfg, v1) == true
     @test exists(dfg, :nope) == false
-    # Sorting of results
-    # TODO - this function needs to be cleaned up
-    unsorted = [:x1_3;:x1_6;:l1;:april1] #this will not work for :x1x2f1
-    @test sortDFG(unsorted) == sortVarNested(unsorted)
-    @test_skip sortDFG([:x1x2f1, :x1l1f1]) == [:x1l1f1, :x1x2f1]
 end
 
 # Gets