base: export update from google3

Author: Mizux

ortools/base/BUILD.bazel

@@ -145,8 +145,8 @@ cc_library(
         "//conditions:default": [],
     }),
     deps = [
-        ":strong_vector",
-        "@abseil-cpp//absl/container:inlined_vector",
+        ":intops",
+        ":strong_int",
     ],
 )
 
@@ -162,6 +162,7 @@ cc_test(
         ":dump_vars",
         ":strong_int",
         ":strong_vector",
+        "@abseil-cpp//absl/numeric:int128",
         "@googletest//:gtest_main",
     ],
 )
@@ -271,11 +272,6 @@ cc_library(
     ],
 )
 
-cc_library(
-    name = "memfile",
-    hdrs = ["memfile.h"],
-)
-
 cc_library(
     name = "memutil",
     hdrs = ["memutil.h"],
@@ -287,11 +283,6 @@ cc_library(
     deps = ["//ortools/base:hash"],
 )
 
-cc_library(
-    name = "mutable_memfile",
-    hdrs = ["mutable_memfile.h"],
-)
-
 cc_library(
     name = "numbers",
     srcs = ["numbers.cc"],

ortools/base/dump_vars.h

@@ -39,15 +39,18 @@
 #ifndef ORTOOLS_BASE_DUMP_VARS_H_
 #define ORTOOLS_BASE_DUMP_VARS_H_
 
+#include <cstddef>
+#include <iterator>
 #include <optional>
 #include <ostream>
 #include <sstream>
 #include <string>
+#include <string_view>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
-#include "absl/container/inlined_vector.h"
-#include "ortools/base/strong_vector.h"
+#include "ortools/base/strong_int.h"
 
 /* need extra level to force extra eval */
 #define DUMP_FOR_EACH_N0(F)
@@ -110,42 +113,44 @@
 namespace operations_research::base {
 namespace internal_dump_vars {
 
-// needed by routing
 template <typename T>
-std::ostream& operator<<(std::ostream& os,
-                         const ::absl::InlinedVector<T, 8>& vec) {
-  for (T it : vec) {
-    os << ::std::to_string(it) << ',';
+decltype(auto) FormatValue(const T& val) {
+  if constexpr (std::is_floating_point_v<std::remove_cvref_t<T>>) {
+    return ::std::to_string(val);
+  } else {
+    return val;
   }
-  return os;
 }
 
-// needed by algorithms tests
 template <typename T>
-std::ostream& operator<<(std::ostream& os, const ::std::vector<T>& vec) {
-  for (T it : vec) {
-    os << ::std::to_string(it) << ',';
+concept Range = requires(T& t) {
+  { std::begin(t) } -> std::input_iterator;
+  { std::end(t) } -> std::sentinel_for<decltype(std::begin(t))>;
+};
+
+template <typename T>
+  requires Range<T> && (!std::is_convertible_v<T, std::string_view>)
+std::ostream& operator<<(std::ostream& os, const T& t) {
+  for (const auto& value : t) {
+    os << FormatValue(value) << ',';
   }
   return os;
 }
 
 template <typename T>
 std::ostream& operator<<(std::ostream& os, const ::std::optional<T>& opt) {
-  if (opt.has_value())
-    os << ::std::to_string(opt.value());
-  else
+  if (opt.has_value()) {
+    os << FormatValue(opt.value());
+  } else {
     os << "(none)";
+  }
   return os;
 }
 
-// needed by graph tests
 template <typename T, typename U>
 std::ostream& operator<<(std::ostream& os,
-                         const ::util_intops::StrongVector<T, U>& vec) {
-  for (U it : vec) {
-    os << ::std::to_string(it) << ',';
-  }
-  return os;
+                         const util_intops::StrongInt<T, U>& t) {
+  return os << t.value();
 }
 
 using DumpNames = ::std::vector<::std::string>;
@@ -155,12 +160,12 @@ struct print_fields {
 
   template <class T>
   void operator()(const T& t) {
-    os << names[n++] << kv_sep << t;
+    os << names[n++] << kv_sep << FormatValue(t);
   }
 
   template <class T1, class T2, class... Ts>
   void operator()(const T1& t1, const T2& t2, const Ts&... ts) {
-    os << names[n++] << kv_sep << t1 << field_sep;
+    os << names[n++] << kv_sep << FormatValue(t1) << field_sep;
     (*this)(t2, ts...);
   }
 

ortools/base/dump_vars_test.cc

@@ -22,6 +22,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/numeric/int128.h"
 #include "gtest/gtest.h"
 #include "ortools/base/strong_int.h"
 #include "ortools/base/strong_vector.h"
@@ -190,6 +191,19 @@ TEST(DumpVars, LazyEvaluation) {
   }
 }
 
+TEST(DumpVars, Int128) {
+  absl::int128 i128 = 123456789;
+  absl::uint128 ui128 = 987654321;
+  EXPECT_EQ("i128 = 123456789", ToString(DUMP_VARS(i128)));
+  EXPECT_EQ("ui128 = 987654321", ToString(DUMP_VARS(ui128)));
+
+  std::vector<absl::int128> vec = {i128};
+  EXPECT_EQ("vec = 123456789,", ToString(DUMP_VARS(vec)));
+
+  std::optional<absl::uint128> opt = ui128;
+  EXPECT_EQ("opt = 987654321", ToString(DUMP_VARS(opt)));
+}
+
 TEST(DumpVars, TemporaryLifetime) {
   EXPECT_EQ(R"(std::string_view(std::string("hello")) = hello)",
             ToString(DUMP_VARS(std::string_view(std::string("hello")))));

ortools/base/file.cc

@@ -49,10 +49,9 @@ namespace {
 enum class Format { NORMAL_FILE, GZIP_FILE, BZIP2_FILE };
 
 static Format GetFormatFromName(absl::string_view name) {
-  const int size = name.size();
-  if (size > 4 && name.substr(size - 3) == ".gz") {
+  if (name.ends_with(".gz")) {
     return Format::GZIP_FILE;
-  } else if (size > 5 && name.substr(size - 4) == ".bz2") {
+  } else if (name.ends_with(".bz2")) {
     return Format::BZIP2_FILE;
   } else {
     return Format::NORMAL_FILE;
@@ -258,33 +257,29 @@ File* File::OpenOrDie(absl::string_view file_name, absl::string_view mode) {
 }
 
 File* File::Open(absl::string_view file_name, absl::string_view mode) {
-  std::string null_terminated_name = std::string(file_name);
-  std::string null_terminated_mode = std::string(mode);
+  const std::string filename = std::string(file_name);
+  std::string mode_str(mode);
 #if defined(_MSC_VER)
-  if (null_terminated_mode == "r") {
-    null_terminated_mode = "rb";
-  } else if (null_terminated_mode == "w") {
-    null_terminated_mode = "wb";
+  if (mode_str == "r") {
+    mode_str = "rb";
+  } else if (mode_str == "w") {
+    mode_str = "wb";
   }
 #endif
-  const Format format = GetFormatFromName(file_name);
-  switch (format) {
+  switch (GetFormatFromName(file_name)) {
     case Format::NORMAL_FILE: {
-      FILE* c_file =
-          fopen(null_terminated_name.c_str(), null_terminated_mode.c_str());
+      FILE* c_file = fopen(filename.c_str(), mode_str.c_str());
       if (c_file == nullptr) return nullptr;
       return new CFile(c_file, file_name);
     }
     case Format::GZIP_FILE: {
-      gzFile gz_file =
-          gzopen(null_terminated_name.c_str(), null_terminated_mode.c_str());
-      if (!gz_file) return nullptr;
+      gzFile gz_file = gzopen(filename.c_str(), mode_str.c_str());
+      if (gz_file == nullptr) return nullptr;
       return new GzFile(gz_file, file_name);
     }
     case Format::BZIP2_FILE: {
-      BZFILE* bz_file = BZ2_bzopen(null_terminated_name.c_str(),
-                                   null_terminated_mode.c_str());
-      if (!bz_file) return nullptr;
+      BZFILE* bz_file = BZ2_bzopen(filename.c_str(), mode_str.c_str());
+      if (bz_file == nullptr) return nullptr;
       return new Bz2File(bz_file, file_name);
     }
   }
@@ -325,6 +320,7 @@ absl::string_view File::filename() const { return name_; }
 void File::Init() {}
 
 namespace file {
+
 absl::Status Open(absl::string_view file_name, absl::string_view mode, File** f,
                   Options options) {
   if (options == Defaults()) {
@@ -333,7 +329,7 @@ absl::Status Open(absl::string_view file_name, absl::string_view mode, File** f,
       return absl::OkStatus();
     }
   }
-  return absl::Status(absl::StatusCode::kInvalidArgument,
+  return absl::Status(absl::StatusCode::kNotFound,
                       absl::StrCat("Could not open '", file_name, "'"));
 }
 
@@ -371,7 +367,7 @@ absl::Status GetContents(absl::string_view file_name, std::string* output,
 
   file->Close(options).IgnoreError();  // Even if ReadToString() fails!
 
-  return absl::Status(absl::StatusCode::kInvalidArgument,
+  return absl::Status(absl::StatusCode::kNotFound,
                       absl::StrCat("Could not read from '", file_name, "'."));
 }
 
@@ -490,7 +486,7 @@ absl::Status SetBinaryProto(absl::string_view file_name,
 
 absl::Status Delete(absl::string_view path, Options options) {
   if (options == Defaults()) {
-    std::string null_terminated_path = std::string(path);
+    const std::string null_terminated_path = std::string(path);
     if (remove(null_terminated_path.c_str()) == 0) return absl::OkStatus();
   }
   return absl::Status(absl::StatusCode::kInvalidArgument,
@@ -499,7 +495,7 @@ absl::Status Delete(absl::string_view path, Options options) {
 
 absl::Status Exists(absl::string_view path, Options options) {
   if (options == Defaults()) {
-    std::string null_terminated_path = std::string(path);
+    const std::string null_terminated_path = std::string(path);
     if (access(null_terminated_path.c_str(), F_OK) == 0) {
       return absl::OkStatus();
     }

ortools/base/filesystem.cc

@@ -14,6 +14,7 @@
 #include "ortools/base/filesystem.h"
 
 #include <algorithm>
+#include <cstdint>
 #include <exception>   // IWYU pragma: keep
 #include <filesystem>  // NOLINT
 #include <regex>       // NOLINT
@@ -23,25 +24,20 @@
 #include <vector>
 
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_replace.h"
 #include "ortools/base/file.h"
 
 namespace fs = std::filesystem;
 
-// Converts a absl::string_view into an object compatible with std::filesystem.
-#ifdef ABSL_USES_STD_STRING_VIEW
-#define SV_ABSL_TO_STD(X) X
-#else
-#define SV_ABSL_TO_STD(X) std::string(X)
-#endif
-
 namespace file {
 
 absl::Status Match(std::string_view pattern, std::vector<std::string>* result,
                    const file::Options& options) {
   try {
-    const auto search_dir = fs::path(SV_ABSL_TO_STD(pattern)).parent_path();
-    const auto filename = fs::path(SV_ABSL_TO_STD(pattern)).filename().string();
+    const auto search_dir = fs::path(pattern).parent_path();
+    const auto filename = fs::path(pattern).filename().string();
     std::string regexp_filename =
         absl::StrReplaceAll(filename, {{".", "\\."}, {"*", ".*"}, {"?", "."}});
     std::regex regexp_pattern(regexp_filename);
@@ -89,4 +85,34 @@ absl::Status RecursivelyCreateDir(std::string_view path,
   }
 }
 
+absl::StatusOr<int64_t> GetSize(std::string_view path,
+                                const file::Options& options) {
+  (void)options;
+  try {
+    std::filesystem::path p(path);
+    std::error_code ec;
+    const bool is_dir = std::filesystem::is_directory(p, ec);
+    if (ec) {
+      if (ec == std::errc::no_such_file_or_directory) {
+        return absl::NotFoundError(ec.message());
+      }
+      return absl::InvalidArgumentError(ec.message());
+    }
+    if (is_dir) {
+      return absl::FailedPreconditionError(
+          absl::StrCat(path, " is a directory."));
+    }
+    const uint64_t size = std::filesystem::file_size(p, ec);
+    if (ec) {
+      if (ec == std::errc::no_such_file_or_directory) {
+        return absl::NotFoundError(ec.message());
+      }
+      return absl::InvalidArgumentError(ec.message());
+    }
+    return static_cast<int64_t>(size);
+  } catch (const std::exception& e) {
+    return absl::NotFoundError(e.what());
+  }
+}
+
 }  // namespace file

ortools/base/filesystem.h

@@ -19,6 +19,7 @@
 #include <vector>
 
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "ortools/base/file.h"
 
 namespace file {
@@ -31,6 +32,9 @@ absl::Status IsDirectory(std::string_view path, const file::Options& options);
 absl::Status RecursivelyCreateDir(std::string_view path,
                                   const file::Options& options);
 
+absl::StatusOr<int64_t> GetSize(absl::string_view path,
+                                const file::Options& options);
+
 }  // namespace file
 
 #endif  // ORTOOLS_BASE_FILESYSTEM_H_