SolveHandle::model() returns now Result<Option<&Model>, Error>

to distinguish Errors and nomore models=None
potassco · Dec 13, 2018 · 0755505 · 0755505
1 parent bf06f1b
commit 0755505
Show file tree

Hide file tree

Showing 12 changed files with 118 additions and 89 deletions.
diff --git a/clingo-sys/build.rs b/clingo-sys/build.rs
@@ -30,6 +30,7 @@ fn main() {
     gcc::Build::new()
         .cpp(true)
         .flag("-std=c++11")
+        .flag("-O3")
         .warnings(false)
         .define("NDEBUG", Some("1"))
         .file("clingo/clasp/libpotassco/src/application.cpp")

diff --git a/src/examples/ast.rs b/src/examples/ast.rs
@@ -76,17 +76,19 @@ fn print_model(model: &Model) {
 
 fn solve(ctl: &mut Control) {
     // get a solve handle
-    let mut handle = ctl.solve(&SolveMode::YIELD, &[])
+    let mut handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed retrieving solve handle.");
 
     // loop over all models
     loop {
         handle.resume().expect("Failed resume on solve handle.");
         match handle.model() {
             // print the model
-            Ok(model) => print_model(model),
+            Ok(Some(model)) => print_model(model),
             // stop if there are no more models
-            Err(_) => break,
+            Ok(None) => break,
+            Err(e) => panic!("Error: {}", e.as_fail()),
         }
     }
 

diff --git a/src/examples/backend.rs b/src/examples/backend.rs
@@ -20,17 +20,19 @@ fn print_model(model: &Model) {
 
 fn solve(ctl: &mut Control) {
     // get a solve handle
-    let mut handle = ctl.solve(&SolveMode::YIELD, &[])
+    let mut handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed retrieving solve handle.");
 
     // loop over all models
     loop {
         handle.resume().expect("Failed resume on solve handle.");
         match handle.model() {
             // print the model
-            Ok(model) => print_model(model),
+            Ok(Some(model)) => print_model(model),
             // stop if there are no more models
-            Err(_) => break,
+            Ok(None) => break,
+            Err(e) => panic!("Error: {}", e.as_fail()),
         }
     }
 

diff --git a/src/examples/configuration.rs b/src/examples/configuration.rs
@@ -20,17 +20,19 @@ fn print_model(model: &Model) {
 
 fn solve(ctl: &mut Control) {
     // get a solve handle
-    let mut handle = ctl.solve(&SolveMode::YIELD, &[])
+    let mut handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed retrieving solve handle.");
 
     // loop over all models
     loop {
         handle.resume().expect("Failed resume on solve handle.");
         match handle.model() {
-            // stop if there are no more models
-            Err(_) => break,
             // print the model
-            Ok(model) => print_model(model),
+            Ok(Some(model)) => print_model(model),
+            // stop if there are no more models
+            Ok(None) => break,
+            Err(e) => panic!("Error: {}", e.as_fail()),
         }
     }
 

diff --git a/src/examples/control.rs b/src/examples/control.rs
@@ -20,17 +20,19 @@ fn print_model(model: &Model) {
 
 fn solve(ctl: &mut Control) {
     // get a solve handle
-    let mut handle = ctl.solve(&SolveMode::YIELD, &[])
+    let mut handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed retrieving solve handle.");
 
     // loop over all models
     loop {
         handle.resume().expect("Failed resume on solve handle.");
         match handle.model() {
             // print the model
-            Ok(model) => print_model(model),
+            Ok(Some(model)) => print_model(model),
             // stop if there are no more models
-            Err(_) => break,
+            Ok(None) => break,
+            Err(e) => panic!("Error: {}", e.as_fail()),
         }
     }
 

diff --git a/src/examples/inject-terms.rs b/src/examples/inject-terms.rs
@@ -60,10 +60,11 @@ fn main() {
         });
 
     // solve
-    let handle = ctl.solve(&SolveMode::YIELD, &[])
+    let handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed to retrieve solve handle.");
 
-    print_model(handle.model().unwrap());
+    print_model(handle.model().unwrap().unwrap());
 
     handle.close().expect("Failed to close solve handle.");
 }
diff --git a/src/examples/model.rs b/src/examples/model.rs
@@ -20,41 +20,45 @@ fn print_model(model: &Model, label: &str, show: &ShowType) {
 
 fn solve(ctl: &mut Control) {
     // get a solve handle
-    let mut handle = ctl.solve(&SolveMode::YIELD, &[])
+    let mut handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed retrieving solve handle.");
 
     // loop over all models
     loop {
         handle.resume().expect("Failed resume on solve handle.");
-        if let Ok(model) = handle.model() {
-            // get model type
-            let model_type = model.model_type().unwrap();
-
-            let mut type_string = match model_type {
-                ModelType::StableModel => "Stable model",
-                ModelType::BraveConsequences => "Brave consequences",
-                ModelType::CautiousConsequences => "Cautious consequences",
-            };
-
-            // get running number of model
-            let number = model.number().unwrap();
-
-            println!("{}: {}", type_string, number);
-
-            print_model(model, "  shown", &ShowType::SHOWN);
-            print_model(model, "  atoms", &ShowType::ATOMS);
-            print_model(model, "  terms", &ShowType::TERMS);
-            print_model(model, " ~atoms", &(ShowType::COMPLEMENT | ShowType::ATOMS));
-        } else {
-            // stop if there are no more models
-            break;
+        match handle.model() {
+            Ok(Some(model)) => {
+                // get model type
+                let model_type = model.model_type().unwrap();
+
+                let type_string = match model_type {
+                    ModelType::StableModel => "Stable model",
+                    ModelType::BraveConsequences => "Brave consequences",
+                    ModelType::CautiousConsequences => "Cautious consequences",
+                };
+
+                // get running number of model
+                let number = model.number().unwrap();
+
+                println!("{}: {}", type_string, number);
+
+                print_model(model, "  shown", &ShowType::SHOWN);
+                print_model(model, "  atoms", &ShowType::ATOMS);
+                print_model(model, "  terms", &ShowType::TERMS);
+                print_model(model, " ~atoms", &(ShowType::COMPLEMENT | ShowType::ATOMS));
+            }
+            Ok(None) => {
+                // stop if there are no more models
+                break;
+            }
+            Err(e) => {
+                panic!("Error: {}", e);
+            }
         }
     }
 
     // close the solve handle
-    handle
-        .get()
-        .expect("Failed to get result from solve handle.");
     handle.close().expect("Failed to close solve handle.");
 }
 
@@ -66,8 +70,13 @@ fn main() {
     let mut ctl = Control::new(options).expect("Failed creating clingo_control.");
 
     // add a logic program to the base part
-    ctl.add("base", &[], "1 {a; b} 1. #show c : b. #show a/0.")
-        .expect("Failed to add a logic program.");
+    //     ctl.add("base", &[], "1 {a; b} 1. #show c : b. #show a/0.")
+    ctl.add(
+        "base",
+        &[],
+        "a(1..100). 1{b(X):a(X)}1. #maximize { V@2 : b(V) }.",
+    )
+    .expect("Failed to add a logic program.");
 
     // ground the base part
     let part = Part::new("base", &[]).unwrap();

diff --git a/src/examples/propagator.rs b/src/examples/propagator.rs
@@ -23,24 +23,23 @@ fn print_model(model: &Model) {
 
 fn solve(ctl: &mut Control) {
     // get a solve handle
-    let mut handle = ctl.solve(&SolveMode::YIELD, &[])
+    let mut handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed to retrieve solve handle.");
 
     // loop over all models
     loop {
         handle.resume().expect("Failed resume on solve handle.");
         match handle.model() {
             // print the model
-            Ok(model) => print_model(model),
+            Ok(Some(model)) => print_model(model),
             // stop if there are no more models
-            Err(_) => break,
+            Ok(None) => break,
+            Err(e) => panic!("Error: {}", e.as_fail()),
         }
     }
 
     // close the solve handle
-    handle
-        .get()
-        .expect("Failed to get result from solve handle.");
     handle.close().expect("Failed to close solve handle.");
 }
 
@@ -249,7 +248,8 @@ fn main() {
                 "pigeon",
                 &vec!["h", "p"],
                 "1 { place(P,H) : H = 1..h } 1 :- P = 1..p.",
-            ).expect("Failed to add a logic program.");
+            )
+            .expect("Failed to add a logic program.");
 
             // ground the pigeon part
 
@@ -270,7 +270,7 @@ fn main() {
             solve(&mut ctl);
         }
         Err(e) => {
-            println!("Error: {}", e.cause());
+            panic!("Error: {}", e.as_fail());
         }
     }
 }
diff --git a/src/examples/solve-async.rs b/src/examples/solve-async.rs
@@ -33,7 +33,8 @@ fn main() {
          1 { p(X); q(X) } 1 :- X = 1..n.\
          :- not n+1 { p(1..n); \
          q(1..n) }.",
-    ).expect("Failed to add a logic program.");
+    )
+    .expect("Failed to add a logic program.");
 
     // ground the base part
     let part = Part::new("base", &[]).unwrap();
@@ -46,9 +47,9 @@ fn main() {
     };
 
     // create a solve handle with an attached event handler
-    let mut handle =
-        ctl.solve_with_event_handler(&(SolveMode::ASYNC | SolveMode::YIELD), &[], &mut running)
-            .expect("Failed to retrieve solve handle.");
+    let mut handle = ctl
+        .solve_with_event_handler(&(SolveMode::ASYNC | SolveMode::YIELD), &[], &mut running)
+        .expect("Failed to retrieve solve handle.");
 
     // let's approximate pi
     let mut samples = 0.;

diff --git a/src/examples/statistics.rs b/src/examples/statistics.rs
@@ -84,17 +84,19 @@ fn print_model(model: &Model) {
 
 fn solve(ctl: &mut Control) {
     // get a solve handle
-    let mut handle = ctl.solve(&SolveMode::YIELD, &[])
+    let mut handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed retrieving solve handle.");
 
     // loop over all models
     loop {
         handle.resume().expect("Failed resume on solve handle.");
         match handle.model() {
             // print the model
-            Ok(model) => print_model(model),
+            Ok(Some(model)) => print_model(model),
             // stop if there are no more models
-            Err(_) => break,
+            Ok(None) => break,
+            Err(e) => panic!("Error: {}", e.as_fail()),
         }
     }
 

diff --git a/src/examples/theory-atoms.rs b/src/examples/theory-atoms.rs
@@ -20,17 +20,19 @@ fn print_model(model: &Model) {
 
 fn solve(ctl: &mut Control) {
     // get a solve handle
-    let mut handle = ctl.solve(&SolveMode::YIELD, &[])
+    let mut handle = ctl
+        .solve(&SolveMode::YIELD, &[])
         .expect("Failed retrieving solve handle.");
 
     // loop over all models
     loop {
         handle.resume().expect("Failed resume on solve handle.");
         match handle.model() {
             // print the model
-            Ok(model) => print_model(model),
+            Ok(Some(model)) => print_model(model),
             // stop if there are no more models
-            Err(_) => break,
+            Ok(None) => break,
+            Err(e) => panic!("Error: {}", e.as_fail()),
         }
     }
 
@@ -90,7 +92,8 @@ fn main() {
          }.\
          x :- &a { 1+2 }.\
          y :- &b(3) { } = 17.",
-    ).expect("Failed to add a logic program.");
+    )
+    .expect("Failed to add a logic program.");
 
     // ground the base part
     let part = Part::new("base", &[]).unwrap();