deprecate hasTagsNeighbors

Author: Affie

src/Deprecated.jl

@@ -321,6 +321,27 @@ end
     varlabel,
 )
 
+# """
+#     $SIGNATURES
+
+# Determine if the variable or factor neighbors have the `tags:;Vector{Symbol}`, and `matchAll::Bool`.
+# """
+function hasTagsNeighbors(
+    dfg::AbstractDFG,
+    node_label::Symbol,
+    tags::Vector{Symbol};
+    matchAll::Bool = true,
+)
+    #
+    Base.depwarn(
+        "hasTagsNeighbors is deprecated, use listNeighbors with tagsFilter instead",
+        :hasTagsNeighbors,
+    )
+    # assume only variables or factors are neighbors
+    alltags = union((listNeighbors(dfg, node_label) .|> x -> listTags(dfg, x))...)
+    return length(filter(x -> x in alltags, tags)) >= (matchAll ? length(tags) : 1)
+end
+
 ## ================================================================================
 ## Deprecated in v0.28
 ##=================================================================================

src/DistributedFactorGraphs.jl

@@ -276,7 +276,6 @@ export listTags
 export mergeTags!
 export emptyTags!
 export removeTags! #TODO do we want this one
-export hasTags
 
 ##------------------------------------------------------------------------------
 ## Bloblets
@@ -378,7 +377,6 @@ const unstable_functions::Vector{Symbol} = [
     :getVariableLabelNumber,# TODO somewhat used, do we deprecate?
     :getfirstBlobentry,# TODO somewhat used, do we deprecate?
     :getSolveInProgress,#TODO unused, do we deprecate?
-    :hasTagsNeighbors,
     :isVariable,
     :isFactor,
     :isConnected,
@@ -401,6 +399,7 @@ const unstable_functions::Vector{Symbol} = [
     :packState,
     :unpack,
     :unpackDistribution,
+    :hasTags,
     # :unpackVariable,
     # :unpackFactor,
     :unpackBlob,
@@ -426,6 +425,7 @@ const unstable_functions::Vector{Symbol} = [
     # no set on these
 
     #deprecated in v0.29
+    :hasTagsNeighbors,
     # :updateBlobstore!,## TODO deprecated or obsolete
     :emptyMetadata!, #TODO maybe deprecate for just deleteMetadata!
     # :emptyBlobstore!, #TODO maybe deprecate for just deleteBlobstore!

src/GraphsDFG/services/GraphsDFG.jl

@@ -205,8 +205,8 @@ function listVariables(
     if !isnothing(solvableFilter) ||
        !isnothing(tagsFilter) ||
        !isnothing(typeFilter) ||
-       !isnothing(regexFilter) ||  #TODO deprecated
-       !isempty(tags) ||           #TODO deprecated
+       !isnothing(regexFilter) ||  #TODO deprecated v0.28
+       !isempty(tags) ||           #TODO deprecated v0.28
        !isnothing(solvable)        #TODO Maybe deprecated?
         return map(
             getLabel,
@@ -333,16 +333,31 @@ end
 function listNeighbors(
     dfg::GraphsDFG,
     label::Symbol;
-    solvable::Union{Nothing, Int} = nothing,
+    solvableFilter::Union{Nothing, Function} = nothing,
+    tagsFilter::Union{Nothing, Function} = nothing,
+    solvable::Union{Nothing, Int} = nothing, #TODO deprecated for solvableFilter v0.29
 )
+    if !isnothing(solvable)
+        Base.depwarn(
+            "solvable kwarg is deprecated, use kwarg `solvableFilter = (>=solvable)` instead", #v0.29
+            :listNeighbors,
+        )
+        !isnothing(solvableFilter) &&
+            error("Cannot use both solvable and solvableFilter kwargs.")
+        solvableFilter = >=(solvable)
+    end
+
     if !(hasVariable(dfg, label) || hasFactor(dfg, label))
         throw(LabelNotFoundError(label))
     end
 
     neighbors_il = FactorGraphs.outneighbors(dfg.g, dfg.g.labels[label])
     neighbors_ll = [dfg.g.labels[i] for i in neighbors_il]
+
     # Additional filtering
-    solvable != 0 && filter!(lbl -> _isSolvable(dfg, lbl, solvable), neighbors_ll)
+    # solvable != 0 && filter!(lbl -> _isSolvable(dfg, lbl, solvable), neighbors_ll)
+    filterDFG!(neighbors_ll, solvableFilter, l->getSolvable(dfg, l))
+    filterDFG!(neighbors_ll, tagsFilter, l->getTags(dfg, l))
 
     # Variable sorting (order is important)
     if haskey(dfg.g.factors, label)

src/services/Tags.jl

@@ -8,7 +8,7 @@ $SIGNATURES
 
 Return the tags for a Node.
 """
-getTags(node) = node.tags
+refTags(node) = node.tags
 
 """
 $SIGNATURES
@@ -105,22 +105,22 @@ end
 
 function listTags(dfg::AbstractDFG, sym::Symbol)
     getFnc = isVariable(dfg, sym) ? getVariable : getFactor
-    return getTags(getFnc(dfg, sym))
+    return refTags(getFnc(dfg, sym))
 end
 
 function mergeTags!(dfg::InMemoryDFGTypes, sym::Symbol, tags)
     getFnc = isVariable(dfg, sym) ? getVariable : getFactor
-    return union!(getTags(getFnc(dfg, sym)), tags)
+    return union!(refTags(getFnc(dfg, sym)), tags)
 end
 
 function removeTags!(dfg::InMemoryDFGTypes, sym::Symbol, tags)
     getFnc = isVariable(dfg, sym) ? getVariable : getFactor
-    return setdiff!(getTags(getFnc(dfg, sym)), tags)
+    return setdiff!(refTags(getFnc(dfg, sym)), tags)
 end
 
 function emptyTags!(dfg::InMemoryDFGTypes, sym::Symbol)
     getFnc = isVariable(dfg, sym) ? getVariable : getFactor
-    return empty!(getTags(getFnc(dfg, sym)))
+    return empty!(refTags(getFnc(dfg, sym)))
 end
 
 ##------------------------------------------------------------------------------
@@ -134,23 +134,5 @@ Determine if the variable or factor neighbors have the `tags:;Vector{Symbol}`, a
 function hasTags(dfg::AbstractDFG, sym::Symbol, tags::Vector{Symbol}; matchAll::Bool = true)
     #
     alltags = listTags(dfg, sym)
-    return length(filter(x -> x in alltags, tags)) >= (matchAll ? length(tags) : 1)
-end
-
-"""
-    $SIGNATURES
-
-Determine if the variable or factor neighbors have the `tags:;Vector{Symbol}`, and `matchAll::Bool`.
-"""
-function hasTagsNeighbors(
-    dfg::AbstractDFG,
-    sym::Symbol,
-    tags::Vector{Symbol};
-    matchAll::Bool = true,
-)
-    #
-    # assume only variables or factors are neighbors
-    getNeiFnc = isVariable(dfg, sym) ? getFactor : getVariable
-    alltags = union((ls(dfg, sym) .|> x -> getTags(getNeiFnc(dfg, x)))...)
-    return length(filter(x -> x in alltags, tags)) >= (matchAll ? length(tags) : 1)
+    return length(alltags ∩ tags) >= (matchAll ? length(tags) : 1)
 end

test/testBlocks.jl

@@ -556,8 +556,14 @@ function tagsTestBlock!(fg, v1, v1_tags)
     @test hasTags(fg, :b, [v2Tags...])
     @test hasTags(fg, :b, [:LANDMARK, :TAG], matchAll = false)
 
-    @test hasTagsNeighbors(fg, :abf1, [:LANDMARK])
-    @test !hasTagsNeighbors(fg, :abf1, [:LANDMARK, :TAG])
+    #TODO can be simplified but require julia v1.11
+    # @test listNeighbors(fg, :abf1; tagsFilter = ⊇([:LANDMARK])) == [:b]
+    # @test isempty(listNeighbors(fg, :abf1; tagsFilter = ⊇([:LANDMARK, :TAG])))
+
+    @test listNeighbors(fg, :abf1; tagsFilter = Base.Fix1(issubset, [:LANDMARK])) == [:b]
+    @test isempty(
+        listNeighbors(fg, :abf1; tagsFilter = Base.Fix1(issubset, [:LANDMARK, :TAG])),
+    )
 end
 
 function VSDTestBlock!(fg, v1)