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

1 files changed, 28 insertions, 20 deletions

diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index 1c2f15dd7388..ec6734870c7e 100644
--- a/absl/flags/internal/flag.h
+++ b/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));
 }
 
 ///////////////////////////////////////////////////////////////////////////////