Merge pull request #301 from gtjusila/eventhandlerupdate

Added Coverage For EventHandlerCallback

Author: matbesancon

src/event_handler.jl

@@ -19,6 +19,15 @@ function eventexec(event::T) where {T<:AbstractEventhdlr}
     error("eventexec not implemented for type $(T)")
 end
 
+"""
+Default eventinit function.
+"""
+function eventinit(event::AbstractEventhdlr) end
+
+"""
+Default eventexit function.
+"""
+function eventexit(event::AbstractEventhdlr) end
 """
 This is the function that will be converted to a C function. It signature
 matches the one given in the SCIP documentation for SCIP_DECL_EVENTEXEC.
@@ -30,17 +39,46 @@ function _eventexec(
     eventhdlr::Ptr{SCIP_Eventhdlr},
     event::Ptr{SCIP_Event},
     eventdata::Ptr{SCIP_EventData},
-)
+)::SCIP_RETCODE
     # Get Julia object out of eventhandler data
     data::Ptr{SCIP_EventData} = SCIPeventhdlrGetData(eventhdlr)
     event = unsafe_pointer_to_objref(data)
 
     #call user method
     eventexec(event)
+    return SCIP_OKAY
+end
 
+"""
+Internal function that will be converted to a C function and passed to SCIP as a callback.
+Its signature matches the one given in the SCIP documentation for `SCIP_DECL_EVENTINIT`.
+"""
+function _eventinit(
+    scip::Ptr{SCIP_},
+    eventhdlr::Ptr{SCIP_Eventhdlr},
+)::SCIP_RETCODE
+    # Get Julia object out of eventhandler data
+    data::Ptr{SCIP_EventData} = SCIPeventhdlrGetData(eventhdlr)
+    event = unsafe_pointer_to_objref(data)
+
+    #call user method
+    eventinit(event)
     return SCIP_OKAY
 end
 
+"""
+Internal function that will be converted to a C function passed to SCIP.
+Its signature matches the one given in the SCIP documentation for `SCIP_DECL_EVENTEXIT`.
+"""
+function _eventexit(
+    scip::Ptr{SCIP_},
+    eventhdlr::Ptr{SCIP_Eventhdlr},
+)::SCIP_RETCODE
+    data::Ptr{SCIP_EventData} = SCIPeventhdlrGetData(eventhdlr)
+    event = unsafe_pointer_to_objref(data)
+    eventexit(event)
+    return SCIP_OKAY
+end
 """
     include_event_handler(scipd::SCIP.SCIPData, event_handler::EVENTHDLR; name="", desc="")
 
@@ -59,6 +97,10 @@ function include_event_handler(
     name="",
     desc="",
 ) where {EVENTHDLR<:AbstractEventhdlr}
+    _eventinit =
+        @cfunction(_eventinit, SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_Eventhdlr}))
+    _eventexit =
+        @cfunction(_eventexit, SCIP_RETCODE, (Ptr{SCIP_}, Ptr{SCIP_Eventhdlr}))
     _eventexec = @cfunction(
         _eventexec,
         SCIP_RETCODE,
@@ -80,7 +122,8 @@ function include_event_handler(
         _eventexec,
         eventhdlr,
     )
-
+    @SCIP_CALL SCIPsetEventhdlrInit(scipd.scip[], eventhdlrptr[], _eventinit)
+    @SCIP_CALL SCIPsetEventhdlrExit(scipd.scip[], eventhdlrptr[], _eventexit)
     @assert eventhdlrptr[] != C_NULL
     #Persist in scip store against GC
     scipd.eventhdlrs[event_handler] = eventhdlrptr[]
@@ -91,6 +134,7 @@ end
 
 Catch an event in SCIP. This function is a wrapper around the SCIPcatchEvent function.
 Warning! This function should only be called after the SCIP has been transformed.
+Use this instead of calling SCIPcatchEvent directly.
 """
 function catch_event(
     scipd::SCIP.SCIPData,
@@ -102,3 +146,21 @@ function catch_event(
     eventhdlrptr = scipd.eventhdlrs[eventhdlr]
     @SCIP_CALL SCIPcatchEvent(scipd, eventtype, eventhdlrptr, C_NULL, C_NULL)
 end
+
+""" 
+    drop_event(scipd::SCIP.SCIPData, eventtype::SCIP_EVENTTYPE, eventhdlr::EVENTHDLR)
+
+Drop an event in SCIP. This function is a wrapper around the SCIPdropEvent function.
+Warning! This function should only be called after the SCIP has been transformed.
+Use this instead of calling SCIPdropEvent directly.
+"""
+function drop_event(
+    scipd::SCIP.SCIPData,
+    eventtype::SCIP_EVENTTYPE,
+    eventhdlr::EVENTHDLR,
+) where {EVENTHDLR<:AbstractEventhdlr}
+    @assert SCIPgetStage(scipd) != SCIP_STAGE_INIT
+    @assert SCIPgetStage(scipd) != SCIP_STAGE_PROBLEM
+    eventhdlrptr = scipd.eventhdlrs[eventhdlr]
+    @SCIP_CALL SCIPdropEvent(scipd, eventtype, eventhdlrptr, C_NULL, -1)
+end

test/eventhdlr.jl

@@ -2,7 +2,7 @@
 # It is assumed that test/sepa_support.jl is already included
 using SCIP
 import MathOptInterface as MOI
-
+using Test
 module FirstLPEventTest
 # A simple event handler that stores the objective value of the first LP solve at the root node
 using SCIP
@@ -21,9 +21,21 @@ function SCIP.eventexec(event::FirstLPEvent)
         event.firstlpobj = SCIP.SCIPgetLPObjval(scip)
     end
 end
+
+function SCIP.eventinit(event::FirstLPEvent)
+    SCIP.catch_event(event.scip, SCIP.SCIP_EVENTTYPE_FIRSTLPSOLVED, event)
+    return
+end
+
+function SCIP.eventexit(event::FirstLPEvent)
+    SCIP.drop_event(event.scip, SCIP.SCIP_EVENTTYPE_FIRSTLPSOLVED, event)
+    return
+end
+
 end
 
 @testset "Listen to first LP solve" begin
+    using .FirstLPEventTest
     # create an empty problem
     optimizer = SCIP.Optimizer()
     inner = optimizer.inner
@@ -60,27 +72,24 @@ end
     SCIP.include_event_handler(
         inner,
         eventhdlr;
-        name="firstlp",
         desc="Store the objective value of the first LP solve at the root node",
     )
 
     # transform the problem into SCIP
     SCIP.@SCIP_CALL SCIP.SCIPtransformProb(inner)
 
-    # catch the event. Again this can only be done after the problem is transformed
-    SCIP.catch_event(inner, SCIP.SCIP_EVENTTYPE_FIRSTLPSOLVED, eventhdlr)
-
     # solve the problem
     SCIP.@SCIP_CALL SCIP.SCIPsolve(inner.scip[])
 
     # test if the event handler worked 
-    @test eventhdlr.firstlpobj != 10
+    @test eventhdlr.firstlpobj != 10.0
 
     # free the problem
     finalize(inner)
 end
 
 @testset "Nameless Event handler" begin
+    using .FirstLPEventTest
     # create an empty problem
     optimizer = SCIP.Optimizer()
     inner = optimizer.inner
@@ -117,21 +126,17 @@ end
     SCIP.include_event_handler(
         inner,
         eventhdlr;
-        name="firstlp",
         desc="Store the objective value of the first LP solve at the root node",
     )
 
     # transform the problem into SCIP
     SCIP.@SCIP_CALL SCIP.SCIPtransformProb(inner)
 
-    # catch the event. Again this can only be done after the problem is transformed
-    SCIP.catch_event(inner, SCIP.SCIP_EVENTTYPE_FIRSTLPSOLVED, eventhdlr)
-
     # solve the problem
     SCIP.@SCIP_CALL SCIP.SCIPsolve(inner.scip[])
 
     # test if the event handler worked 
-    @test eventhdlr.firstlpobj != 10
+    @test eventhdlr.firstlpobj != 10.0
 
     # free the problem
     finalize(inner)