Export of internal Abseil changes

--
bffb14058bb46137d42c7a113a36b6b582997cda by Xiaoyi Zhang <zhangxy@google.com>:

Add ABSL_MUST_USE_RESULT to Status.

PiperOrigin-RevId: 296272498

--
b426fdd3b3f687d7a8aeb644925923bbab503778 by CJ Johnson <johnsoncj@google.com>:

Optimizes absl::InlinedVector::clear() by not deallocating the data, if allocated. This allows allocations to be reused.

This matches the behavior of std::vector::clear()

PiperOrigin-RevId: 296197235

--
8cb9fbfe20e749816065c1a042e84f72dac9bfc0 by CJ Johnson <johnsoncj@google.com>:

Optimizes absl::InlinedVector::clear() by not deallocating the data, if allocated. This allows allocations to be reused.

This matches the behavior of std::vector::clear()

PiperOrigin-RevId: 296058092

--
2558d3369a482879919155b6f46317ccafe0ca13 by Matthew Brown <matthewbr@google.com>:

Internal cleanup

PiperOrigin-RevId: 296025806

--
cf7ee57228534021c15ed7421df92acf6c27c9c7 by Gennadiy Rozental <rogeeff@google.com>:

Make FlagOps enum class.

We also add comments to all the functions used to invoke flag ops.

PiperOrigin-RevId: 295975809

--
74bbdbd12fbc54e9c4ebcb3005e727becf0e509d by Xiaoyi Zhang <zhangxy@google.com>:

Release `absl::Status`.

PiperOrigin-RevId: 295777662

--
3dbc622b4e2227863525da2f7de7ecbeb3ede21f by Xiaoyi Zhang <zhangxy@google.com>:

Internal change.

PiperOrigin-RevId: 295733658

--
48d74aa0ab01d611da6012b377f038d8b26c712e by Abseil Team <absl-team@google.com>:

Fix typo in container/CMakeLists.txt for container_common

PiperOrigin-RevId: 295491438
GitOrigin-RevId: bffb14058bb46137d42c7a113a36b6b582997cda
Change-Id: Ia966857b07fa7412cd6489ac37b5fa26640e4141

absl/container/CMakeLists.txt

@@ -633,7 +633,7 @@ absl_cc_library(
   NAME
     container_common
   HDRS
-    "internal/commom.h"
+    "internal/common.h"
   COPTS
     ${ABSL_DEFAULT_COPTS}
   DEPS

absl/flags/internal/flag.h

@@ -43,10 +43,10 @@ template <typename T>
 class Flag;
 
 ///////////////////////////////////////////////////////////////////////////////
-// Type-specific operations, eg., parsing, copying, etc. are provided
+// Flag value type operations, eg., parsing, copying, etc. are provided
 // by function specific to that type with a signature matching FlagOpFn.
 
-enum FlagOp {
+enum class FlagOp {
   kDelete,
   kClone,
   kCopy,
@@ -58,26 +58,26 @@ enum FlagOp {
 };
 using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*);
 
-// The per-type function
+// Flag value specific operations routine.
 template <typename T>
 void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
   switch (op) {
-    case flags_internal::kDelete:
+    case FlagOp::kDelete:
       delete static_cast<const T*>(v1);
       return nullptr;
-    case flags_internal::kClone:
+    case FlagOp::kClone:
       return new T(*static_cast<const T*>(v1));
-    case flags_internal::kCopy:
+    case FlagOp::kCopy:
       *static_cast<T*>(v2) = *static_cast<const T*>(v1);
       return nullptr;
-    case flags_internal::kCopyConstruct:
+    case FlagOp::kCopyConstruct:
       new (v2) T(*static_cast<const T*>(v1));
       return nullptr;
-    case flags_internal::kSizeof:
+    case FlagOp::kSizeof:
       return reinterpret_cast<void*>(sizeof(T));
-    case flags_internal::kStaticTypeId:
+    case FlagOp::kStaticTypeId:
       return reinterpret_cast<void*>(&FlagStaticTypeIdGen<T>);
-    case flags_internal::kParse: {
+    case FlagOp::kParse: {
       // Initialize the temporary instance of type T based on current value in
       // destination (which is going to be flag's default value).
       T temp(*static_cast<T*>(v2));
@@ -88,7 +88,7 @@ void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
       *static_cast<T*>(v2) = std::move(temp);
       return v2;
     }
-    case flags_internal::kUnparse:
+    case FlagOp::kUnparse:
       *static_cast<std::string*>(v2) =
           absl::UnparseFlag<T>(*static_cast<const T*>(v1));
       return nullptr;
@@ -97,37 +97,45 @@ void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
   }
 }
 
-// Functions that invoke flag-type-specific operations.
+// Deletes memory interpreting obj as flag value type pointer.
 inline void Delete(FlagOpFn op, const void* obj) {
-  op(flags_internal::kDelete, obj, nullptr, nullptr);
+  op(FlagOp::kDelete, obj, nullptr, nullptr);
 }
+// Makes a copy of flag value pointed by obj.
 inline void* Clone(FlagOpFn op, const void* obj) {
-  return op(flags_internal::kClone, obj, nullptr, nullptr);
+  return op(FlagOp::kClone, obj, nullptr, nullptr);
 }
+// Copies src to dst interpreting as flag value type pointers.
 inline void Copy(FlagOpFn op, const void* src, void* dst) {
-  op(flags_internal::kCopy, src, dst, nullptr);
+  op(FlagOp::kCopy, src, dst, nullptr);
 }
+// Construct a copy of flag value in a location pointed by dst
+// based on src - pointer to the flag's value.
 inline void CopyConstruct(FlagOpFn op, const void* src, void* dst) {
-  op(flags_internal::kCopyConstruct, src, dst, nullptr);
+  op(FlagOp::kCopyConstruct, src, dst, nullptr);
 }
+// Returns true if parsing of input text is successfull.
 inline bool Parse(FlagOpFn op, absl::string_view text, void* dst,
                   std::string* error) {
-  return op(flags_internal::kParse, &text, dst, error) != nullptr;
+  return op(FlagOp::kParse, &text, dst, error) != nullptr;
 }
+// Returns string representing supplied value.
 inline std::string Unparse(FlagOpFn op, const void* val) {
   std::string result;
-  op(flags_internal::kUnparse, val, &result, nullptr);
+  op(FlagOp::kUnparse, val, &result, nullptr);
   return result;
 }
+// Returns size of flag value type.
 inline size_t Sizeof(FlagOpFn op) {
   // This sequence of casts reverses the sequence from
   // `flags_internal::FlagOps()`
   return static_cast<size_t>(reinterpret_cast<intptr_t>(
-      op(flags_internal::kSizeof, nullptr, nullptr, nullptr)));
+      op(FlagOp::kSizeof, nullptr, nullptr, nullptr)));
 }
+// Returns static type id coresponding to the value type.
 inline FlagStaticTypeId StaticTypeId(FlagOpFn op) {
   return reinterpret_cast<FlagStaticTypeId>(
-      op(flags_internal::kStaticTypeId, nullptr, nullptr, nullptr));
+      op(FlagOp::kStaticTypeId, nullptr, nullptr, nullptr));
 }
 
 ///////////////////////////////////////////////////////////////////////////////

absl/status/BUILD.bazel

@@ -0,0 +1,65 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This package contains `absl::Status`.
+# It will expand later to have utilities around `Status` like `StatusOr`,
+# `StatusBuilder` and macros.
+
+load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
+load(
+    "//absl:copts/configure_copts.bzl",
+    "ABSL_DEFAULT_COPTS",
+    "ABSL_TEST_COPTS",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])  # Apache 2.0
+
+cc_library(
+    name = "status",
+    srcs = [
+        "status.cc",
+        "status_payload_printer.cc",
+    ],
+    hdrs = [
+        "status.h",
+        "status_payload_printer.h",
+    ],
+    copts = ABSL_DEFAULT_COPTS,
+    deps = [
+        "//absl/base:config",
+        "//absl/base:core_headers",
+        "//absl/base:raw_logging_internal",
+        "//absl/container:inlined_vector",
+        "//absl/debugging:stacktrace",
+        "//absl/debugging:symbolize",
+        "//absl/strings",
+        "//absl/strings:cord",
+        "//absl/strings:str_format",
+        "//absl/types:optional",
+    ],
+)
+
+cc_test(
+    name = "status_test",
+    srcs = ["status_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    deps = [
+        ":status",
+        "//absl/strings",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

absl/status/CMakeLists.txt

@@ -0,0 +1,52 @@
+#
+# Copyright 2020 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+absl_cc_library(
+  NAME
+    status
+  HDRS
+    "status.h"
+  SRCS
+    "status.cc"
+    "status_payload_printer.h"
+    "status_payload_printer.cc"
+  COPTS
+    ${ABSL_DEFAULT_COPTS}
+  DEPS
+    absl::config
+    absl::core_headers
+    absl::raw_logging_internal
+    absl::inlined_vector
+    absl::stacktrace
+    absl::symbolize
+    absl::strings
+    absl::cord
+    absl::str_format
+    absl::optional
+  PUBLIC
+)
+
+absl_cc_test(
+  NAME
+    status_test
+  HDRS
+   "status_test.cc"
+  COPTS
+    ${ABSL_TEST_COPTS}
+  DEPS
+    absl::status
+    absl::strings
+    gmock_main
+)