cleanup

Author: lperron

ortools/graph/BUILD.bazel

@@ -144,12 +144,12 @@ cc_library(
     hdrs = ["cliques.h"],
     visibility = ["//visibility:public"],
     deps = [
-        "//ortools/base",
-        "//ortools/base:int_type",
+        "//ortools/base:intops",
         "//ortools/base:strong_vector",
         "//ortools/util:bitset",
         "//ortools/util:time_limit",
         "@abseil-cpp//absl/container:flat_hash_set",
+        "@abseil-cpp//absl/log",
         "@abseil-cpp//absl/log:check",
         "@abseil-cpp//absl/strings",
     ],

ortools/graph/cliques.cc

@@ -188,11 +188,9 @@ void Search(std::function<bool(int, int)> graph,
 
 class FindAndEliminate {
  public:
-  FindAndEliminate(std::function<bool(int, int)> graph, int node_count,
+  FindAndEliminate(std::function<bool(int, int)> graph,
                    std::function<bool(const std::vector<int>&)> callback)
-      : graph_(std::move(graph)),
-        node_count_(node_count),
-        callback_(std::move(callback)) {}
+      : graph_(std::move(graph)), callback_(std::move(callback)) {}
 
   bool GraphCallback(int node1, int node2) {
     if (visited_.find(
@@ -219,7 +217,6 @@ class FindAndEliminate {
 
  private:
   std::function<bool(int, int)> graph_;
-  int node_count_;
   std::function<bool(const std::vector<int>&)> callback_;
   absl::flat_hash_set<std::pair<int, int>> visited_;
 };
@@ -243,7 +240,7 @@ void FindCliques(std::function<bool(int, int)> graph, int node_count,
 
 void CoverArcsByCliques(std::function<bool(int, int)> graph, int node_count,
                         std::function<bool(const std::vector<int>&)> callback) {
-  FindAndEliminate cache(std::move(graph), node_count, std::move(callback));
+  FindAndEliminate cache(std::move(graph), std::move(callback));
   std::unique_ptr<int[]> initial_candidates(new int[node_count]);
   std::vector<int> actual;
 

ortools/graph/cliques.h

@@ -32,9 +32,10 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
-#include "ortools/base/int_type.h"
-#include "ortools/base/logging.h"
+#include "ortools/base/strong_int.h"
 #include "ortools/base/strong_vector.h"
 #include "ortools/util/bitset.h"
 #include "ortools/util/time_limit.h"
@@ -211,7 +212,7 @@ class BronKerboschAlgorithm {
   }
 
  private:
-  DEFINE_INT_TYPE(CandidateIndex, ptrdiff_t);
+  DEFINE_STRONG_INT_TYPE(CandidateIndex, ptrdiff_t);
 
   // A data structure that maintains the variables of one "iteration" of the
   // search algorithm. These are the variables that would normally be allocated
@@ -253,8 +254,8 @@ class BronKerboschAlgorithm {
       absl::StrAppend(&buffer, "pivot = ", pivot,
                       "\nnum_remaining_candidates = ", num_remaining_candidates,
                       "\ncandidates = [");
-      for (CandidateIndex i(0); i < candidates.size(); ++i) {
-        if (i > 0) buffer += ", ";
+      for (CandidateIndex i(0); i < CandidateIndex(candidates.size()); ++i) {
+        if (i > CandidateIndex(0)) buffer += ", ";
         absl::StrAppend(&buffer, candidates[i]);
       }
       absl::StrAppend(
@@ -443,8 +444,9 @@ class WeightedBronKerboschBitsetAlgorithm {
 template <typename NodeIndex>
 void BronKerboschAlgorithm<NodeIndex>::InitializeState(State* state) {
   DCHECK(state != nullptr);
-  const int num_candidates = state->candidates.size();
-  int num_disconnected_candidates = num_candidates;
+  const CandidateIndex num_candidates =
+      CandidateIndex(state->candidates.size());
+  int num_disconnected_candidates = num_candidates.value();
   state->pivot = 0;
   CandidateIndex pivot_index(-1);
   for (CandidateIndex pivot_candidate_index(0);
@@ -480,7 +482,7 @@ BronKerboschAlgorithm<NodeIndex>::SelectCandidateIndexForRecursion(
   DCHECK(state != nullptr);
   CandidateIndex disconnected_node_index =
       std::max(state->first_candidate_index, state->candidate_for_recursion);
-  while (disconnected_node_index < state->candidates.size() &&
+  while (disconnected_node_index < CandidateIndex(state->candidates.size()) &&
          state->candidates[disconnected_node_index] != state->pivot &&
          IsArc(state->pivot, state->candidates[disconnected_node_index])) {
     ++disconnected_node_index;
@@ -496,8 +498,8 @@ void BronKerboschAlgorithm<NodeIndex>::Initialize() {
   states_.emplace_back();
 
   State* const root_state = &states_.back();
-  root_state->first_candidate_index = 0;
-  root_state->candidate_for_recursion = 0;
+  root_state->first_candidate_index = CandidateIndex(0);
+  root_state->candidate_for_recursion = CandidateIndex(0);
   root_state->candidates.resize(num_nodes_, 0);
   std::iota(root_state->candidates.begin(), root_state->candidates.end(), 0);
   root_state->num_remaining_candidates = num_nodes_;
@@ -555,8 +557,9 @@ void BronKerboschAlgorithm<NodeIndex>::PushState(NodeIndex selected) {
     }
   }
   const CandidateIndex new_first_candidate_index(new_candidates.size());
-  for (CandidateIndex i = previous_state->first_candidate_index + 1;
-       i < previous_state->candidates.size(); ++i) {
+  for (CandidateIndex i =
+           previous_state->first_candidate_index + CandidateIndex(1);
+       i < CandidateIndex(previous_state->candidates.size()); ++i) {
     const NodeIndex candidate = previous_state->candidates[i];
     if (IsArc(selected, candidate)) {
       new_candidates.push_back(candidate);