Add variable constraint watcher bridges

Author: blegat

src/Bridges/Constraint/single_bridge_optimizer.jl

@@ -8,13 +8,15 @@ even if they are supported by one of its bridges.
 """
 mutable struct SingleBridgeOptimizer{BT<:AbstractBridge, OT<:MOI.ModelLike} <: MOIB.AbstractBridgeOptimizer
     model::OT
+    watchers::Dict{MOI.VariableIndex, Set{MOIB.AbstractBridge}}
     map::Map # index of bridged constraint -> constraint bridge
     con_to_name::Dict{MOI.ConstraintIndex, String}
     name_to_con::Union{Dict{String, MOI.ConstraintIndex}, Nothing}
 end
 function SingleBridgeOptimizer{BT}(model::OT) where {BT, OT <: MOI.ModelLike}
     SingleBridgeOptimizer{BT, OT}(
-        model, Map(), Dict{MOI.ConstraintIndex, String}(), nothing)
+        model, Dict{MOI.VariableIndex, Set{MOIB.AbstractBridge}}(),
+        Map(), Dict{MOI.ConstraintIndex, String}(), nothing)
 end
 
 function bridges(bridge::MOI.Bridges.AbstractBridgeOptimizer)

src/Bridges/bridge.jl

@@ -78,25 +78,47 @@ function MOI.set(model::MOI.ModelLike, attr::MOI.AbstractConstraintAttribute,
 end
 
 """
-    added_constrained_variable_types(BT::Type{<:Variable.AbstractBridge})::Vector{Tuple{DataType}}
+    added_constrained_variable_types(BT::Type{<:AbstractBridge})::Vector{Tuple{DataType}}
 
 Return a list of the types of constrained variables that bridges of concrete
 type `BT` add. This is used by the [`LazyBridgeOptimizer`](@ref).
 """
 function added_constrained_variable_types end
 
 """
-    added_constraint_types(BT::Type{<:Constraint.AbstractBridge})::Vector{Tuple{DataType, DataType}}
+    added_constraint_types(BT::Type{<:AbstractBridge})::Vector{Tuple{DataType, DataType}}
 
 Return a list of the types of constraints that bridges of concrete type `BT`
 add. This is used by the [`LazyBridgeOptimizer`](@ref).
 """
 function added_constraint_types end
 
 """
-    set_objective_function_type(BT::Type{<:Objective.AbstractBridge})::Type{<:MOI.AbstractScalarFunction}
+    set_objective_function_type(BT::Type{<:AbstractBridge})::Type{<:MOI.AbstractScalarFunction}
 
 Return the type of objective function that bridges of concrete type `BT`
 set. This is used by the [`LazyBridgeOptimizer`](@ref).
 """
 function set_objective_function_type end
+
+"""
+    watched_variables(::AbstractBridge)::AbstractVector{MOI.VariableIndex}
+
+Return a list of variable indices. For any `S<:MOI.AbstractScalarSet`, whenever
+a `MOI.SingleVariable`-in-`S` constraint is added to the model for one variable
+of this list, the bridge is notified with [`notify_constraint`]`(@ref) just before
+adding the constraint.
+If this method is not implemented, it fallbacks to returning
+`MOI.Utilities.EmptyVector{MOI.VariableIndex}()`.
+"""
+watched_variables(::AbstractBridge) = MOIU.EmptyVector{MOI.VariableIndex}()
+
+"""
+    notify_constraint(bridge::AbstractBridge, model::Model, func::SingleVariable, set::MOI.AbstractScalarSet)::AbstractVector{MOI.VariableIndex}
+
+Notifies `bridge` that the `func`-in-`set` constraint will be might be added to
+`model`. The bridge can throw an error if that should not be allowed or add
+variables or add/modify constraints due to this change.
+See [`watched_variables`](@ref) for being notified when variables are modified.
+"""
+function notify_constraint end

src/Bridges/bridge_optimizer.jl

@@ -245,6 +245,7 @@ function MOI.is_empty(b::AbstractBridgeOptimizer)
 end
 function MOI.empty!(b::AbstractBridgeOptimizer)
     MOI.empty!(b.model)
+    empty!(b.watchers)
     if Variable.has_bridges(Variable.bridges(b))
         empty!(b.var_to_name)
         b.name_to_var = nothing
@@ -391,6 +392,7 @@ function MOI.delete(b::AbstractBridgeOptimizer, ci::MOI.ConstraintIndex)
         else
             delete!(Constraint.bridges(b), ci)
         end
+        remove_watchers(b, br)
         Variable.call_in_context(Variable.bridges(b), ci, () -> MOI.delete(b, br))
         b.name_to_con = nothing
         delete!(b.con_to_name, ci)
@@ -988,6 +990,23 @@ function MOI.get(b::AbstractBridgeOptimizer,
         IdxT, ci_bridged, MOI.get(b.model, IdxT, name), name)
 end
 
+function add_watchers(b::AbstractBridgeOptimizer, bridge::AbstractBridge)
+    for variable in watched_variables(bridge)
+        bridges = get(b.watchers, variable, nothing)
+        if bridges === nothing
+            bridges = Set{AbstractBridge}()
+            b.watchers[variable] = bridges
+        end
+        push!(bridges, bridge)
+    end
+end
+function remove_watchers(b::AbstractBridgeOptimizer, bridge::AbstractBridge)
+    for variable in watched_variables(bridge)
+        bridges = get(b.watchers, variable, nothing)
+        delete!(bridges, bridge)
+    end
+end
+
 # Constraints
 function MOI.supports_constraint(b::AbstractBridgeOptimizer,
                                  F::Type{<:MOI.AbstractFunction},
@@ -1004,12 +1023,21 @@ function MOI.supports_constraint(b::AbstractBridgeOptimizer,
 end
 function add_bridged_constraint(b, BridgeType, f, s)
     bridge = Constraint.bridge_constraint(BridgeType, b, f, s)
+    add_watchers(b, bridge)
     ci = Constraint.add_key_for_bridge(Constraint.bridges(b), bridge, f, s)
     Variable.register_context(Variable.bridges(b), ci)
     return ci
 end
 function MOI.add_constraint(b::AbstractBridgeOptimizer, f::MOI.AbstractFunction,
                             s::MOI.AbstractSet)
+    if f isa MOI.SingleVariable
+        watchers = get(b.watchers, f.variable, nothing)
+        if watchers !== nothing
+            for watcher in watchers
+                notify_constraint(watcher, b, f, s)
+            end
+        end
+    end
     if Variable.has_bridges(Variable.bridges(b))
         if f isa MOI.SingleVariable
             if is_bridged(b, f.variable)

src/Bridges/lazy_bridge_optimizer.jl

@@ -16,6 +16,7 @@ it will choose bridge 1 as it allows to bridge `F`-in-`S` using only one bridge
 mutable struct LazyBridgeOptimizer{OT<:MOI.ModelLike} <: AbstractBridgeOptimizer
     # Internal model
     model::OT
+    watchers::Dict{MOI.VariableIndex, Set{AbstractBridge}}
     # Bridged variables
     variable_map::Variable.Map
     var_to_name::Dict{MOI.VariableIndex, String}
@@ -44,7 +45,7 @@ mutable struct LazyBridgeOptimizer{OT<:MOI.ModelLike} <: AbstractBridgeOptimizer
 end
 function LazyBridgeOptimizer(model::MOI.ModelLike)
     return LazyBridgeOptimizer{typeof(model)}(
-        model,
+        model, Dict{MOI.VariableIndex, Set{AbstractBridge}}(),
         Variable.Map(), Dict{MOI.VariableIndex, String}(), nothing,
         Constraint.Map(), Dict{MOI.ConstraintIndex, String}(), nothing,
         Objective.Map(),