Tags on listFactors and lsf

Author: Affie

src/CloudGraphsDFG/services/CloudGraphsDFG.jl

@@ -339,8 +339,9 @@ function getFactors(dfg::CloudGraphsDFG, regexFilter::Union{Nothing, Regex}=noth
     return map(vId->getFactor(dfg, vId), factorIds)
 end
 
-function listFactors(dfg::CloudGraphsDFG, regexFilter::Union{Nothing, Regex}=nothing; solvable::Int=0)::Vector{Symbol}
+function listFactors(dfg::CloudGraphsDFG, regexFilter::Union{Nothing, Regex}=nothing; tags::Vector{Symbol}=Symbol[], solvable::Int=0)::Vector{Symbol}
     # Optimized for DB call
+    length(tags) > 0 @error "Filter on tags not implemented for CloudGraphsDFG"
     if regexFilter == nothing
         return _getLabelsFromCyphonQuery(dfg.neo4jInstance, "(node:$(dfg.userId):$(dfg.robotId):$(dfg.sessionId):FACTOR) where node.solvable >= $solvable")
     else

src/LightDFG/services/LightDFG.jl

@@ -184,8 +184,11 @@ function getFactors(dfg::LightDFG, regexFilter::Union{Nothing, Regex}=nothing; t
     return factors
 end
 
-function listFactors(dfg::LightDFG, regexFilter::Union{Nothing, Regex}=nothing; solvable::Int=0)::Vector{Symbol}
+function listFactors(dfg::LightDFG, regexFilter::Union{Nothing, Regex}=nothing; tags::Vector{Symbol}=Symbol[], solvable::Int=0)::Vector{Symbol}
     # factors = map(v -> v.dfgNode, filter(n -> n.dfgNode isa DFGFactor, vertices(dfg.g)))
+    if length(tags) > 0
+        return map(v -> v.label, getFactor(dfg, regexFilter, tags=tags, solvable=solvable))
+    end
     factors = collect(keys(dfg.g.factors))
     if regexFilter != nothing
         factors = filter(f -> occursin(regexFilter, String(f)), factors)

src/services/AbstractDFG.jl

@@ -292,22 +292,19 @@ end
     $(SIGNATURES)
 Checks if the graph is fully connected, returns true if so.
 """
-function isFullyConnected(dfg::G)::Bool where G <: AbstractDFG
+function isFullyConnected(dfg::AbstractDFG)::Bool
     error("isFullyConnected not implemented for $(typeof(dfg))")
 end
 
 """
     $(SIGNATURES)
 Retrieve a list of labels of the immediate neighbors around a given variable or factor specified by its label.
 """
-function getNeighbors(dfg::G, label::Symbol; solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
-    error("getNeighbors not implemented for $(typeof(dfg))")
-end
-##TODO reduce with  getNeighbors(dfg, node.label)
-function getNeighbors(dfg::G, node::T; solvable::Int=0)::Vector{Symbol}  where {G <: AbstractDFG, T <: DFGNode}
+function getNeighbors(dfg::AbstractDFG, label::Symbol; solvable::Int=0)::Vector{Symbol}
     error("getNeighbors not implemented for $(typeof(dfg))")
 end
 
+
 ##------------------------------------------------------------------------------
 ## copy and duplication
 ##------------------------------------------------------------------------------
@@ -416,6 +413,11 @@ end
 ##------------------------------------------------------------------------------
 ## Connectivity Alias
 ##------------------------------------------------------------------------------
+
+function getNeighbors(dfg::AbstractDFG, node::DFGNode; solvable::Int=0)::Vector{Symbol}
+    getNeighbors(dfg, node.label, solvable=solvable)
+end
+
 #Alias
 #TODO rather actually check if there are orphaned factors (factors without all variables)
 """
@@ -457,8 +459,8 @@ end
 Get a list of the IDs (labels) of the DFGFactors in the DFG.
 Optionally specify a label regular expression to retrieves a subset of the factors.
 """
-function listFactors(dfg::G, regexFilter::Union{Nothing, Regex}=nothing; solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
-    return map(f -> f.label, getFactors(dfg, regexFilter, solvable=solvable))
+function listFactors(dfg::G, regexFilter::Union{Nothing, Regex}=nothing; tags::Vector{Symbol}=Symbol[], solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
+    return map(f -> f.label, getFactors(dfg, regexFilter, tags=tags, solvable=solvable))
 end
 
 ##------------------------------------------------------------------------------
@@ -485,8 +487,8 @@ end
 List the DFGFactors in the DFG.
 Optionally specify a label regular expression to retrieves a subset of the factors.
 """
-function lsf(dfg::G, regexFilter::Union{Nothing, Regex}=nothing; solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
-    return listFactors(dfg, regexFilter, solvable=solvable)
+function lsf(dfg::G, regexFilter::Union{Nothing, Regex}=nothing; tags::Vector{Symbol}=Symbol[], solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
+    return listFactors(dfg, regexFilter, tags=tags, solvable=solvable)
 end