Issue997 (changing iterators to return ints from state[i])

.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/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

@@ -52,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());
 }
 

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;
 

src/search/landmarks/landmark.cc

@@ -7,7 +7,7 @@ using namespace std;
 namespace landmarks {
 bool Landmark::is_true_in_state(const State &state) const {
     auto is_atom_true_in_state = [&](const FactPair &atom) {
-            return state[atom.var].get_value() == atom.value;
+            return state[atom.var] == atom.value;
         };
     if (type == DISJUNCTIVE) {
         return ranges::any_of(atoms, is_atom_true_in_state);

src/search/landmarks/landmark_factory_rpg_sasp.cc

@@ -120,12 +120,12 @@ static void add_binary_variable_conditions(
             effect_atom.get_variable().get_domain_size() == 2) {
             for (const FactPair &atom : landmark.atoms) {
                 if (atom.var == var_id &&
-                    initial_state[var_id].get_value() != atom.value) {
+                    initial_state[var_id] != atom.value) {
                     assert(ranges::none_of(result,
                                            [&](const FactPair &result_atom) {
                                                return result_atom.var == var_id;
                                            }));
-                    result.insert(initial_state[var_id].get_pair());
+                    result.insert(initial_state.get_fact(var_id).get_pair());
                     break;
                 }
             }
@@ -530,7 +530,7 @@ void LandmarkFactoryRpgSasp::generate_disjunctive_precondition_landmarks(
            they should not hold in the initial state. */
         if (preconditions.size() < 5 && ranges::none_of(
                 preconditions, [&](const FactPair &atom) {
-                    return initial_state[atom.var].get_value() == atom.value;
+                    return initial_state[atom.var] == atom.value;
                 })) {
             add_disjunctive_landmark_and_ordering(
                 preconditions, *node, OrderingType::GREEDY_NECESSARY);
@@ -654,7 +654,7 @@ void LandmarkFactoryRpgSasp::approximate_lookahead_orderings(
 
     const FactPair landmark_atom = landmark.atoms[0];
     const FactPair init_atom =
-        task_proxy.get_initial_state()[landmark_atom.var].get_pair();
+        task_proxy.get_initial_state().get_fact(landmark_atom.var).get_pair();
     vector<int> critical_predecessors = get_critical_dtg_predecessors(
         init_atom.value, landmark_atom.value,
         reached[landmark_atom.var], dtg_successors[landmark_atom.var]);

src/search/merge_and_shrink/fts_factory.cc

@@ -118,7 +118,7 @@ unique_ptr<Labels> FTSFactory::create_labels() {
 void FTSFactory::build_state_data(VariableProxy var) {
     int var_id = var.get_id();
     TransitionSystemData &ts_data = transition_system_data_by_var[var_id];
-    ts_data.init_state = task_proxy.get_initial_state()[var_id].get_value();
+    ts_data.init_state = task_proxy.get_initial_state()[var_id];
 
     int range = task_proxy.get_variables()[var_id].get_domain_size();
     ts_data.num_states = range;

src/search/merge_and_shrink/merge_and_shrink_representation.cc

@@ -58,7 +58,7 @@ void MergeAndShrinkRepresentationLeaf::apply_abstraction_to_lookup_table(
 }
 
 int MergeAndShrinkRepresentationLeaf::get_value(const State &state) const {
-    int value = state[var_id].get_value();
+    int value = state[var_id];
     return lookup_table[value];
 }
 

src/search/operator_counting/state_equation_constraints.cc

@@ -103,7 +103,7 @@ bool StateEquationConstraints::update_constraints(const State &state,
                 double lower_bound = 0;
                 /* If we consider the current value of var, there must be an
                    additional consumer. */
-                if (state[var].get_value() == value) {
+                if (state[var] == value) {
                     --lower_bound;
                 }
                 /* If we consider the goal value of var, there must be an

src/search/pdbs/cegar.cc

@@ -387,7 +387,7 @@ bool CEGAR::get_flaws_for_pattern(
             bool raise_goal_flaw = false;
             for (const FactPair &goal : goals) {
                 int goal_var_id = goal.var;
-                if (final_state[goal_var_id].get_value() != goal.value &&
+                if (final_state[goal_var_id] != goal.value &&
                     !blacklisted_variables.count(goal_var_id)) {
                     flaws.emplace_back(collection_index, goal_var_id);
                     raise_goal_flaw = true;

src/search/pruning/stubborn_sets.h

@@ -62,7 +62,7 @@ class StubbornSets : public PruningMethod {
 inline FactPair find_unsatisfied_condition(
     const std::vector<FactPair> &conditions, const State &state) {
     for (const FactPair &condition : conditions) {
-        if (state[condition.var].get_value() != condition.value)
+        if (state[condition.var] != condition.value)
             return condition;
     }
     return FactPair::no_fact;

src/search/pruning/stubborn_sets_atom_centric.cc

@@ -138,7 +138,7 @@ FactPair StubbornSetsAtomCentric::select_fact(
           choose it. Otherwise, choose the first unsatisfied fact.
         */
         for (const FactPair &condition : facts) {
-            if (state[condition.var].get_value() != condition.value) {
+            if (state[condition.var] != condition.value) {
                 if (marked_producers[condition.var][condition.value]) {
                     fact = condition;
                     break;
@@ -150,7 +150,7 @@ FactPair StubbornSetsAtomCentric::select_fact(
     } else if (atom_selection_strategy == AtomSelectionStrategy::STATIC_SMALL) {
         int min_count = numeric_limits<int>::max();
         for (const FactPair &condition : facts) {
-            if (state[condition.var].get_value() != condition.value) {
+            if (state[condition.var] != condition.value) {
                 int count = achievers[condition.var][condition.value].size();
                 if (count < min_count) {
                     fact = condition;
@@ -161,7 +161,7 @@ FactPair StubbornSetsAtomCentric::select_fact(
     } else if (atom_selection_strategy == AtomSelectionStrategy::DYNAMIC_SMALL) {
         int min_count = numeric_limits<int>::max();
         for (const FactPair &condition : facts) {
-            if (state[condition.var].get_value() != condition.value) {
+            if (state[condition.var] != condition.value) {
                 const vector<int> &ops = achievers[condition.var][condition.value];
                 int count = count_if(
                     ops.begin(), ops.end(), [&](int op) {return !stubborn[op];});

src/search/pruning/stubborn_sets_ec.cc

@@ -18,7 +18,7 @@ static inline bool is_v_applicable(int var,
                                    const State &state,
                                    vector<vector<int>> &preconditions) {
     int precondition_on_var = preconditions[op_no][var];
-    return precondition_on_var == -1 || precondition_on_var == state[var].get_value();
+    return precondition_on_var == -1 || precondition_on_var == state[var];
 }
 
 static vector<StubbornDTG> build_dtgs(TaskProxy task_proxy) {
@@ -164,7 +164,7 @@ void StubbornSetsEC::compute_active_operators(const State &state) {
 
         for (const FactPair &precondition : sorted_op_preconditions[op_no]) {
             int var_id = precondition.var;
-            int current_value = state[var_id].get_value();
+            int current_value = state[var_id];
             const vector<bool> &reachable_values =
                 reachability_map[var_id][current_value];
             if (!reachable_values[precondition.value]) {
@@ -258,7 +258,7 @@ void StubbornSetsEC::get_disabled_vars(
 void StubbornSetsEC::apply_s5(int op_no, const State &state) {
     // Find a violated state variable and check if stubborn contains a writer for this variable.
     for (const FactPair &pre : sorted_op_preconditions[op_no]) {
-        if (state[pre.var].get_value() != pre.value && written_vars[pre.var]) {
+        if (state[pre.var] != pre.value && written_vars[pre.var]) {
             if (!nes_computed[pre.var][pre.value]) {
                 add_nes_for_fact(pre, state);
             }

src/search/state_registry.cc

@@ -56,7 +56,7 @@ const State &StateRegistry::get_initial_state() {
 
         State initial_state = task_proxy.get_initial_state();
         for (size_t i = 0; i < initial_state.size(); ++i) {
-            state_packer.set(buffer.get(), i, initial_state[i].get_value());
+            state_packer.set(buffer.get(), i, initial_state[i]);
         }
         state_data_pool.push_back(buffer.get());
         StateID id = insert_id_or_pop_state();