var() method for event

Author: mmghannam

src/eventhdlr.rs

@@ -1,5 +1,8 @@
-use crate::{ffi, Model, Solving};
+use crate::scip::ScipPtr;
+use crate::{ffi, Model, Solving, Variable};
+use scip_sys::SCIPeventGetVar;
 use std::ops::{BitOr, BitOrAssign};
+use std::rc::Rc;
 
 /// Trait used to define custom event handlers.
 pub trait Eventhdlr {
@@ -201,6 +204,7 @@ impl SCIPEventhdlr {
 /// Wrapper for the internal SCIP event.
 pub struct Event {
     pub(crate) raw: *mut ffi::SCIP_EVENT,
+    pub(crate) scip: Rc<ScipPtr>,
 }
 
 impl Event {
@@ -214,6 +218,23 @@ impl Event {
         let event_type = unsafe { ffi::SCIPeventGetType(self.raw) };
         EventMask(event_type)
     }
+
+    /// Returns the associated variable for a variable event
+    pub fn var(&self) -> Option<Variable> {
+        if self
+            .event_type()
+            .matches(EventMask::VAR_EVENT | EventMask::VAR_FIXED | EventMask::VAR_DELETED)
+        {
+            let var_ptr = unsafe { SCIPeventGetVar(self.raw) };
+            assert!(!var_ptr.is_null());
+            Some(Variable {
+                raw: var_ptr,
+                scip: self.scip.clone(),
+            })
+        } else {
+            None
+        }
+    }
 }
 
 #[cfg(test)]
@@ -278,6 +299,7 @@ mod tests {
         ) {
             assert!(self.get_type().matches(event.event_type()));
             assert_eq!(eventhdlr.name(), "InternalSCIPEventHdlrTester");
+            assert!(event.var().is_none())
         }
     }
 

src/scip.rs

@@ -640,13 +640,16 @@ impl ScipPtr {
             let data_ptr = unsafe { ffi::SCIPeventhdlrGetData(eventhdlr) };
             assert!(!data_ptr.is_null());
             let eventhdlr_ptr = data_ptr as *mut Box<dyn Eventhdlr>;
-            let scip_ptr = ScipPtr::from_raw(scip, true);
+            let scip_ptr = Rc::new(ScipPtr::from_raw(scip, true));
             let model = Model {
-                scip: Rc::new(scip_ptr),
+                scip: scip_ptr.clone(),
                 state: Solving,
             };
             let eventhdlr = SCIPEventhdlr { raw: eventhdlr };
-            let event = Event { raw: event };
+            let event = Event {
+                raw: event,
+                scip: scip_ptr.clone(),
+            };
             unsafe { (*eventhdlr_ptr).execute(model, eventhdlr, event) };
             Retcode::Okay.into()
         }