TEST [issue992]

.uncrustify.cfg

@@ -98,7 +98,7 @@ eat_blanks_after_open_brace=true
 eat_blanks_before_close_brace=true
 mod_pawn_semicolon=false
 mod_full_paren_if_bool=false
-mod_remove_extra_semicolon=true
+mod_remove_extra_semicolon=false
 mod_sort_import=false
 mod_sort_using=false
 mod_sort_include=false

src/search/CMakeLists.txt

@@ -849,7 +849,7 @@ create_fast_downward_library(
         landmarks/landmark_cost_partitioning_algorithms
         landmarks/landmark_cost_partitioning_heuristic
         landmarks/landmark_factory
-        landmarks/landmark_factory_h_m
+        landmarks/landmark_factory_hm
         landmarks/landmark_factory_reasonable_orders_hps
         landmarks/landmark_factory_merged
         landmarks/landmark_factory_relaxation

src/search/cartesian_abstractions/refinement_hierarchy.cc

@@ -60,7 +60,7 @@ NodeID RefinementHierarchy::get_node_id(const State &state) const {
     NodeID id = 0;
     while (nodes[id].is_split()) {
         const Node &node = nodes[id];
-        id = node.get_child(state[node.get_var()].get_value());
+        id = node.get_child(state[node.get_var()]);
     }
     return id;
 }

src/search/cartesian_abstractions/subtask_generators.cc

@@ -18,7 +18,6 @@
 #include <cassert>
 #include <iostream>
 #include <string>
-#include <unordered_set>
 #include <vector>
 
 using namespace std;
@@ -53,7 +52,7 @@ static void remove_initial_state_facts(
     const TaskProxy &task_proxy, Facts &facts) {
     State initial_state = task_proxy.get_initial_state();
     facts.erase(remove_if(facts.begin(), facts.end(), [&](FactPair fact) {
-                              return initial_state[fact.var].get_value() == fact.value;
+                              return initial_state[fact.var] == fact.value;
                           }), facts.end());
 }
 
@@ -158,16 +157,16 @@ SharedTasks LandmarkDecomposition::get_subtasks(
     SharedTasks subtasks;
     const shared_ptr<landmarks::LandmarkGraph> landmark_graph =
         get_landmark_graph(task);
-    utils::HashMap<FactPair, landmarks::LandmarkNode *> fact_to_landmark_map =
-        get_fact_to_landmark_map(landmark_graph);
-    Facts landmark_facts = get_fact_landmarks(*landmark_graph);
+    utils::HashMap<FactPair, landmarks::LandmarkNode *> atom_to_landmark_map =
+        get_atom_to_landmark_map(landmark_graph);
+    Facts landmark_facts = get_atom_landmarks(*landmark_graph);
     filter_and_order_facts(task, fact_order, landmark_facts, *rng, log);
     for (const FactPair &landmark : landmark_facts) {
         shared_ptr<AbstractTask> subtask =
             make_shared<extra_tasks::ModifiedGoalsTask>(task, Facts {landmark});
         if (combine_facts) {
             subtask = build_domain_abstracted_task(
-                subtask, fact_to_landmark_map[landmark]);
+                subtask, atom_to_landmark_map[landmark]);
         }
         subtasks.push_back(subtask);
     }

src/search/cartesian_abstractions/utils_landmarks.cc

@@ -2,74 +2,75 @@
 
 #include "../plugins/plugin.h"
 #include "../landmarks/landmark.h"
-#include "../landmarks/landmark_factory_h_m.h"
+#include "../landmarks/landmark_factory_hm.h"
 #include "../landmarks/landmark_graph.h"
 #include "../utils/logging.h"
 
 #include <algorithm>
+#include <ranges>
+#include <unordered_set>
 
 using namespace std;
 using namespace landmarks;
 
 namespace cartesian_abstractions {
-static FactPair get_fact(const Landmark &landmark) {
+static FactPair get_atom(const Landmark &landmark) {
     // We assume that the given Landmarks are from an h^m landmark graph with m=1.
-    assert(landmark.facts.size() == 1);
-    return landmark.facts[0];
+    assert(landmark.type == ATOMIC);
+    assert(landmark.atoms.size() == 1);
+    return landmark.atoms[0];
 }
 
 shared_ptr<LandmarkGraph> get_landmark_graph(
     const shared_ptr<AbstractTask> &task) {
-    LandmarkFactoryHM lm_graph_factory(
+    LandmarkFactoryHM landmark_graph_factory(
         1, false, true, utils::Verbosity::SILENT);
 
-    return lm_graph_factory.compute_lm_graph(task);
+    return landmark_graph_factory.compute_landmark_graph(task);
 }
 
-vector<FactPair> get_fact_landmarks(const LandmarkGraph &graph) {
-    vector<FactPair> facts;
-    const LandmarkGraph::Nodes &nodes = graph.get_nodes();
-    facts.reserve(nodes.size());
-    for (auto &node : nodes) {
-        facts.push_back(get_fact(node->get_landmark()));
+vector<FactPair> get_atom_landmarks(const LandmarkGraph &graph) {
+    vector<FactPair> atoms;
+    atoms.reserve(graph.get_num_landmarks());
+    for (const auto &node : graph) {
+        atoms.push_back(get_atom(node->get_landmark()));
     }
-    sort(facts.begin(), facts.end());
-    return facts;
+    sort(atoms.begin(), atoms.end());
+    return atoms;
 }
 
-utils::HashMap<FactPair, LandmarkNode *> get_fact_to_landmark_map(
+utils::HashMap<FactPair, LandmarkNode *> get_atom_to_landmark_map(
     const shared_ptr<LandmarkGraph> &graph) {
-    const LandmarkGraph::Nodes &nodes = graph->get_nodes();
-    // All landmarks are simple, i.e., each has exactly one fact.
-    assert(all_of(nodes.begin(), nodes.end(), [](auto &node) {
-                      return node->get_landmark().facts.size() == 1;
+    // All landmarks are atomic, i.e., each has exactly one atom.
+    assert(all_of(graph->begin(), graph->end(), [](auto &node) {
+                      return node->get_landmark().atoms.size() == 1;
                   }));
-    utils::HashMap<FactPair, landmarks::LandmarkNode *> fact_to_landmark_map;
-    for (auto &node : nodes) {
-        const FactPair &fact = node->get_landmark().facts[0];
-        fact_to_landmark_map[fact] = node.get();
+    utils::HashMap<FactPair, landmarks::LandmarkNode *> atom_to_landmark_map;
+    for (const auto &node : *graph) {
+        const FactPair &atom = node->get_landmark().atoms[0];
+        atom_to_landmark_map[atom] = node.get();
     }
-    return fact_to_landmark_map;
+    return atom_to_landmark_map;
 }
 
 VarToValues get_prev_landmarks(const LandmarkNode *node) {
     VarToValues groups;
     vector<const LandmarkNode *> open;
     unordered_set<const LandmarkNode *> closed;
-    for (const auto &parent_and_edge : node->parents) {
-        const LandmarkNode *parent = parent_and_edge.first;
+    open.reserve(node->parents.size());
+    for (const LandmarkNode *parent : views::keys(node->parents)) {
         open.push_back(parent);
     }
     while (!open.empty()) {
         const LandmarkNode *ancestor = open.back();
         open.pop_back();
-        if (closed.find(ancestor) != closed.end())
+        if (closed.contains(ancestor)) {
             continue;
+        }
         closed.insert(ancestor);
-        FactPair ancestor_fact = get_fact(ancestor->get_landmark());
-        groups[ancestor_fact.var].push_back(ancestor_fact.value);
-        for (const auto &parent_and_edge : ancestor->parents) {
-            const LandmarkNode *parent = parent_and_edge.first;
+        FactPair ancestor_atom = get_atom(ancestor->get_landmark());
+        groups[ancestor_atom.var].push_back(ancestor_atom.value);
+        for (const LandmarkNode *parent : views::keys(ancestor->parents)) {
             open.push_back(parent);
         }
     }

src/search/cartesian_abstractions/utils_landmarks.h

@@ -20,16 +20,16 @@ using VarToValues = std::unordered_map<int, std::vector<int>>;
 
 extern std::shared_ptr<landmarks::LandmarkGraph> get_landmark_graph(
     const std::shared_ptr<AbstractTask> &task);
-extern std::vector<FactPair> get_fact_landmarks(
+extern std::vector<FactPair> get_atom_landmarks(
     const landmarks::LandmarkGraph &graph);
 
-extern utils::HashMap<FactPair, landmarks::LandmarkNode *> get_fact_to_landmark_map(
+extern utils::HashMap<FactPair, landmarks::LandmarkNode *> get_atom_to_landmark_map(
     const std::shared_ptr<landmarks::LandmarkGraph> &graph);
 
 /*
   Do a breadth-first search through the landmark graph ignoring
   duplicates. Start at the given node and collect for each variable the
-  facts that have to be made true before the given node can be true for
+  atoms that have to be made true before the given node can be true for
   the first time.
 */
 extern VarToValues get_prev_landmarks(

src/search/heuristics/cea_heuristic.cc

@@ -228,7 +228,7 @@ void ContextEnhancedAdditiveHeuristic::set_up_local_problem(
     LocalProblemNode *start = &problem->nodes[start_value];
     start->cost = 0;
     for (size_t i = 0; i < problem->context_variables->size(); ++i)
-        start->context[i] = state[(*problem->context_variables)[i]].get_value();
+        start->context[i] = static_cast<short>(state[(*problem->context_variables)[i]]);
 
     add_to_heap(start);
 }
@@ -379,10 +379,10 @@ void ContextEnhancedAdditiveHeuristic::mark_helpful_transitions(
                 int precond_value = assignment.value;
                 int local_var = assignment.local_var;
                 int precond_var_no = context_vars[local_var];
-                if (state[precond_var_no].get_value() == precond_value)
+                if (state[precond_var_no] == precond_value)
                     continue;
                 LocalProblem *subproblem = get_local_problem(
-                    precond_var_no, state[precond_var_no].get_value());
+                    precond_var_no, state[precond_var_no]);
                 LocalProblemNode *subnode = &subproblem->nodes[precond_value];
                 mark_helpful_transitions(subproblem, subnode, state);
             }

src/search/heuristics/cg_cache.cc

@@ -119,7 +119,7 @@ int CGCache::get_index(int var, const State &state,
     int index = from_val;
     int multiplier = task_proxy.get_variables()[var].get_domain_size();
     for (int dep_var : depends_on[var]) {
-        index += state[dep_var].get_value() * multiplier;
+        index += state[dep_var] * multiplier;
         multiplier *= task_proxy.get_variables()[dep_var].get_domain_size();
     }
     if (to_val > from_val)

src/search/heuristics/cg_heuristic.cc

@@ -58,7 +58,7 @@ int CGHeuristic::compute_heuristic(const State &ancestor_state) {
     for (FactProxy goal : task_proxy.get_goals()) {
         const VariableProxy var = goal.get_variable();
         int var_no = var.get_id();
-        int from = state[var_no].get_value(), to = goal.get_value();
+        int from = state[var_no], to = goal.get_value();
         DomainTransitionGraph *dtg = transition_graphs[var_no].get();
         int cost_for_goal = get_transition_cost(state, dtg, from, to);
         if (cost_for_goal == numeric_limits<int>::max()) {
@@ -114,7 +114,7 @@ int CGHeuristic::get_transition_cost(const State &state,
         start->children_state.resize(dtg->local_to_global_child.size());
         for (size_t i = 0; i < dtg->local_to_global_child.size(); ++i) {
             start->children_state[i] =
-                state[dtg->local_to_global_child[i]].get_value();
+                state[dtg->local_to_global_child[i]];
         }
 
         // Initialize Heap for Dijkstra's algorithm.
@@ -226,7 +226,7 @@ int CGHeuristic::get_transition_cost(const State &state,
 void CGHeuristic::mark_helpful_transitions(const State &state,
                                            DomainTransitionGraph *dtg, int to) {
     int var_no = dtg->var;
-    int from = state[var_no].get_value();
+    int from = state[var_no];
     if (from == to)
         return;