feat(planning): support soft (preferred) tasks & subtasks (1st attemp…

…t, very basic)

For all tasks and/or subtasks marked as "soft", simply add a new empty ("noop") template method chronicle

planning/grpc/api/src/unified_planning.proto

@@ -310,6 +310,9 @@ message Task {
     //  - robot    (a parameter from an outer scope)
     //  - KITCHEN  (a constant symbol in the problem)
     repeated Expression parameters = 3;
+
+    // TODO
+    bool soft = 4;
 }
 
 // A method describes one possible way of achieving a task.

planning/grpc/api/src/unified_planning.rs

@@ -374,6 +374,9 @@ pub struct Task {
     ///   - KITCHEN  (a constant symbol in the problem)
     #[prost(message, repeated, tag = "3")]
     pub parameters: ::prost::alloc::vec::Vec<Expression>,
+    /// TODO
+    #[prost(bool, tag = "4")]
+    pub soft: bool,
 }
 /// A method describes one possible way of achieving a task.
 ///

planning/grpc/server/src/chronicles.rs

@@ -918,6 +918,7 @@ impl<'a> ChronicleFactory<'a> {
         }
         self.chronicle.subtasks.push(SubTask {
             id: Some(subtask.id.clone()),
+            soft: subtask.soft,
             start,
             end,
             task_name,

planning/planning/src/chronicles/concrete.rs

@@ -423,6 +423,8 @@ pub type Task = Vec<Atom>;
 pub struct SubTask {
     /// An optional identifier for the task that allows referring to it unambiguously.
     pub id: Option<String>,
+    /// TODO
+    pub soft: bool,
     /// Time reference at which the task must start
     pub start: Time,
     /// Time reference at which the task must end
@@ -434,6 +436,7 @@ impl Substitute for SubTask {
     fn substitute(&self, s: &impl Substitution) -> Self {
         SubTask {
             id: self.id.clone(),
+            soft: self.soft,
             start: s.fsub(self.start),
             end: s.fsub(self.end),
             task_name: self.task_name.substitute(s),

planning/planning/src/parsing/mod.rs

@@ -202,6 +202,8 @@ pub fn pddl_to_chronicles(dom: &pddl::Domain, prob: &pddl::Problem) -> Result<Pb
         });
     }
 
+    let mut templates = Vec::new();
+
     if let Some(ref task_network) = &prob.task_network {
         read_task_network(
             init_container,
@@ -211,6 +213,14 @@ pub fn pddl_to_chronicles(dom: &pddl::Domain, prob: &pddl::Problem) -> Result<Pb
             None,
             &mut context,
         )?;
+        for t in task_network.ordered_tasks.iter().chain(&task_network.ordered_tasks) {
+            if !t.soft {
+                continue;
+            }
+            let cont = Container::Template(templates.len());
+            let template = read_chronicle_template(cont, &pddl::Method::new_noop_for(t.clone()), &mut context)?;
+            templates.push(template);
+        }
     }
 
     let init_ch = ChronicleInstance {
@@ -219,7 +229,6 @@ pub fn pddl_to_chronicles(dom: &pddl::Domain, prob: &pddl::Problem) -> Result<Pb
         chronicle: init_ch,
     };
 
-    let mut templates = Vec::new();
     for a in &dom.actions {
         let cont = Container::Template(templates.len());
         let template = read_chronicle_template(cont, a, &mut context)?;
@@ -766,6 +775,7 @@ fn read_task_network(
         }
         Ok(SubTask {
             id,
+            soft: t.soft,
             start,
             end,
             task_name,

planning/planning/src/parsing/pddl.rs

@@ -246,6 +246,7 @@ pub struct Task {
     /// Optional identifier of the task. This identifier is typically used to
     /// refer to the task in ordering constraints.
     pub id: Option<TaskId>,
+    pub soft: bool,
     pub name: Sym,
     pub arguments: Vec<Sym>,
     source: Option<Loc>,
@@ -268,6 +269,19 @@ pub struct Method {
     source: Option<Loc>,
 }
 
+impl Method {
+    pub fn new_noop_for(task: Task) -> Self {
+        Method {
+            name: Sym::new(format!("m-noop-{}", task.name)),
+            parameters: vec![],
+            task,
+            precondition: vec![],
+            subtask_network: TaskNetwork::default(),
+            source: None,
+        }
+    }
+}
+
 impl std::fmt::Display for Method {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.name)
@@ -635,6 +649,7 @@ fn parse_task(e: &SExpr, allow_id: bool) -> std::result::Result<Task, ErrLoc> {
             }
             Ok(Task {
                 id: None,
+                soft: false, // FIXME: hard by default, for now
                 name: head,
                 arguments: args,
                 source: Some(e.loc()),
@@ -654,6 +669,7 @@ fn parse_task(e: &SExpr, allow_id: bool) -> std::result::Result<Task, ErrLoc> {
             // this is a parameter-less task
             Ok(Task {
                 id: None,
+                soft: false, // FIXME: hard by default, for now
                 name: head,
                 arguments: vec![],
                 source: Some(e.loc()),