Implement ConstraintFunction/ConstraintSet for VariablesContainer

src/Bridges/bridge_optimizer.jl

@@ -1127,8 +1127,8 @@ function MOI.set(
     ci::MOI.ConstraintIndex{F},
     func,
 ) where {F}
-    if typeof(func) != F
-        throw(ArgumentError("Invalid type when setting ConstraintFunction."))
+    if !(func isa F)
+        throw(MOI.FunctionTypeMismatch{F,typeof(func)}())
     end
     if Variable.has_bridges(Variable.bridges(b))
         set = MOI.get(b, MOI.ConstraintSet(), ci)
@@ -1165,8 +1165,8 @@ function MOI.set(
     ci::MOI.ConstraintIndex{MOI.VariableIndex,S},
     value,
 ) where {S<:MOI.AbstractScalarSet}
-    if typeof(value) != S
-        throw(ArgumentError("Invalid type when setting ConstraintSet."))
+    if !(value isa S)
+        throw(MOI.SetTypeMismatch{S,typeof(value)}())
     end
     _set_substituted(b, attr, ci, value)
     return
@@ -1191,8 +1191,8 @@ function MOI.set(
     ci::MOI.ConstraintIndex{<:MOI.AbstractScalarFunction,S},
     set,
 ) where {S<:MOI.AbstractScalarSet}
-    if typeof(set) != S
-        throw(ArgumentError("Invalid type when setting ConstraintSet."))
+    if !(set isa S)
+        throw(MOI.SetTypeMismatch{S,typeof(set)}())
     end
     if Variable.has_bridges(Variable.bridges(b))
         func = MOI.get(b, MOI.ConstraintFunction(), ci)

src/Test/test_modification.jl

@@ -951,10 +951,16 @@ function test_modification_incorrect(model::MOI.ModelLike, ::Config)
         MOI.EqualTo(1.0),
     )
     @test_throws(
-        ArgumentError,
+        MOI.SetTypeMismatch{MOI.EqualTo{Float64},MOI.LessThan{Float64}},
         MOI.set(model, MOI.ConstraintSet(), c, MOI.LessThan(1.0)),
     )
-    @test_throws(ArgumentError, MOI.set(model, MOI.ConstraintFunction(), c, x))
+    @test_throws(
+        MOI.FunctionTypeMismatch{
+            MOI.ScalarAffineFunction{Float64},
+            MOI.VariableIndex,
+        },
+        MOI.set(model, MOI.ConstraintFunction(), c, x),
+    )
     return
 end
 
@@ -978,11 +984,11 @@ function test_modification_incorrect_VariableIndex(
     x = MOI.add_variable(model)
     c = MOI.add_constraint(model, x, MOI.GreaterThan(zero(T)))
     @test_throws(
-        ArgumentError,
+        MOI.SetTypeMismatch{MOI.GreaterThan{T},MOI.LessThan{T}},
         MOI.set(model, MOI.ConstraintSet(), c, MOI.LessThan(one(T))),
     )
     @test_throws(
-        ArgumentError,
+        MOI.FunctionTypeMismatch{MOI.VariableIndex,MOI.ScalarAffineFunction{T}},
         MOI.set(model, MOI.ConstraintFunction(), c, one(T) * x),
     )
     y = MOI.add_variable(model)

src/Utilities/model.jl

@@ -107,15 +107,21 @@ function MOI.delete(model::AbstractModel, vis::Vector{MOI.VariableIndex})
     return
 end
 
-function MOI.is_valid(
+# `AbstractModel` fields `.variables` and `.constraints` act like a
+# `StructOfConstraints` where `.variables` contains the `VariableIndex`-in-`S`
+# constraints and `.constraints` contains the other constraints.
+function constraints(
     model::AbstractModel,
-    ci::CI{MOI.VariableIndex,S},
-) where {S}
-    return MOI.is_valid(model.variables, ci)
+    ci::MOI.ConstraintIndex{MOI.VariableIndex},
+)
+    return model.variables
+end
+function constraints(model::AbstractModel, ci::MOI.ConstraintIndex)
+    return model.constraints
 end
 
 function MOI.is_valid(model::AbstractModel, ci::MOI.ConstraintIndex)
-    return MOI.is_valid(model.constraints, ci)
+    return MOI.is_valid(constraints(model, ci), ci)
 end
 
 function MOI.is_valid(model::AbstractModel, x::MOI.VariableIndex)
@@ -375,21 +381,8 @@ function MOI.get(
     return MOI.get(model.constraints, attr, ci)
 end
 
-function _delete_constraint(
-    model::AbstractModel,
-    ci::MOI.ConstraintIndex{MOI.VariableIndex,S},
-) where {S}
-    MOI.throw_if_not_valid(model, ci)
-    MOI.delete(model.variables, ci)
-    return
-end
-
-function _delete_constraint(model::AbstractModel, ci::MOI.ConstraintIndex)
-    return MOI.delete(model.constraints, ci)
-end
-
 function MOI.delete(model::AbstractModel, ci::MOI.ConstraintIndex)
-    _delete_constraint(model, ci)
+    MOI.delete(constraints(model, ci), ci)
     model.name_to_con = nothing
     delete!(model.con_to_name, ci)
     return
@@ -404,43 +397,13 @@ function MOI.modify(
     return
 end
 
-function MOI.set(
-    ::AbstractModel,
-    ::MOI.ConstraintFunction,
-    ::MOI.ConstraintIndex{MOI.VariableIndex,<:MOI.AbstractScalarSet},
-    ::MOI.VariableIndex,
-)
-    return throw(MOI.SettingVariableIndexNotAllowed())
-end
-
-function MOI.set(
-    model::AbstractModel{T},
-    attr::MOI.ConstraintSet,
-    ci::MOI.ConstraintIndex{MOI.VariableIndex,S},
-    set::S,
-) where {T,S<:SUPPORTED_VARIABLE_SCALAR_SETS{T}}
-    MOI.throw_if_not_valid(model, ci)
-    MOI.set(model.variables, attr, ci, set)
-    return
-end
-
-function MOI.set(
-    model::AbstractModel,
-    attr::MOI.ConstraintSet,
-    ci::MOI.ConstraintIndex{<:MOI.AbstractFunction,S},
-    set::S,
-) where {S<:MOI.AbstractSet}
-    MOI.set(model.constraints, attr, ci, set)
-    return
-end
-
 function MOI.set(
     model::AbstractModel,
-    attr::MOI.ConstraintFunction,
-    ci::MOI.ConstraintIndex{F,<:MOI.AbstractSet},
-    func::F,
-) where {F<:MOI.AbstractFunction}
-    MOI.set(model.constraints, attr, ci, func)
+    attr::Union{MOI.ConstraintFunction,MOI.ConstraintSet},
+    ci::MOI.ConstraintIndex,
+    value,
+)
+    MOI.set(constraints(model, ci), attr, ci, value)
     return
 end
 
@@ -482,29 +445,12 @@ function MOI.get(
     return MOI.get(model.constraints, loc)
 end
 
-function MOI.get(
-    model::AbstractModel,
-    ::MOI.ConstraintFunction,
-    ci::CI{MOI.VariableIndex},
-)
-    MOI.throw_if_not_valid(model, ci)
-    return MOI.VariableIndex(ci.value)
-end
 function MOI.get(
     model::AbstractModel,
     attr::Union{MOI.ConstraintFunction,MOI.ConstraintSet},
     ci::MOI.ConstraintIndex,
 )
-    return MOI.get(model.constraints, attr, ci)
-end
-
-function MOI.get(
-    model::AbstractModel,
-    ::MOI.ConstraintSet,
-    ci::CI{MOI.VariableIndex,S},
-) where {S}
-    MOI.throw_if_not_valid(model, ci)
-    return set_from_constants(model.variables, S, ci.value)
+    return MOI.get(constraints(model, ci), attr, ci)
 end
 
 function MOI.is_empty(model::AbstractModel)

src/Utilities/variables_container.jl

@@ -288,22 +288,68 @@ function MOI.is_valid(
     return !iszero(b.set_mask[ci.value] & _single_variable_flag(S))
 end
 
+function MOI.get(
+    model::VariablesContainer,
+    ::MOI.ConstraintFunction,
+    ci::CI{MOI.VariableIndex},
+)
+    MOI.throw_if_not_valid(model, ci)
+    return MOI.VariableIndex(ci.value)
+end
+
 function MOI.set(
-    b::VariablesContainer,
+    ::VariablesContainer,
+    ::MOI.ConstraintFunction,
+    ::MOI.ConstraintIndex{MOI.VariableIndex},
+    ::MOI.VariableIndex,
+)
+    return throw(MOI.SettingVariableIndexNotAllowed())
+end
+
+function MOI.set(
+    ::VariablesContainer,
+    ::MOI.ConstraintFunction,
+    ci::MOI.ConstraintIndex,
+    func,
+)
+    return throw(MOI.FunctionTypeMismatch{MOI.func_type(ci),typeof(func)}())
+end
+
+function MOI.get(
+    model::VariablesContainer,
     ::MOI.ConstraintSet,
     ci::MOI.ConstraintIndex{MOI.VariableIndex,S},
-    set::S,
 ) where {S}
+    MOI.throw_if_not_valid(model, ci)
+    return set_from_constants(model, S, ci.value)
+end
+
+function MOI.set(
+    model::VariablesContainer{T},
+    ::MOI.ConstraintSet,
+    ci::MOI.ConstraintIndex{MOI.VariableIndex,S},
+    set::S,
+) where {T,S<:SUPPORTED_VARIABLE_SCALAR_SETS{T}}
+    MOI.throw_if_not_valid(model, ci)
     flag = _single_variable_flag(S)
     if !iszero(flag & _LOWER_BOUND_MASK)
-        b.lower[ci.value] = _lower_bound(set)
+        model.lower[ci.value] = _lower_bound(set)
     end
     if !iszero(flag & _UPPER_BOUND_MASK)
-        b.upper[ci.value] = _upper_bound(set)
+        model.upper[ci.value] = _upper_bound(set)
     end
     return
 end
 
+function MOI.set(
+    ::VariablesContainer,
+    ::MOI.ConstraintSet,
+    ci::MOI.ConstraintIndex{MOI.VariableIndex},
+    set,
+)
+    return throw(MOI.SetTypeMismatch{MOI.set_type(ci),typeof(set)}())
+end
+
 function MOI.get(
     b::VariablesContainer,
     ::MOI.NumberOfConstraints{MOI.VariableIndex,S},