Use more concise `UnsignedClamp()` instead of a combination of `UnsignedMax()` with `UnsignedMin()`. PiperOrigin-RevId: 893969157

diff --git a/riegeli/base/arithmetic.h b/riegeli/base/arithmetic.h
index 14d2c8e..1f0479c 100644
--- a/riegeli/base/arithmetic.h
+++ b/riegeli/base/arithmetic.h

@@ -244,6 +244,9 @@
 
 // `UnsignedClamp(value, min_value, max_value)` is at least `min_value`,
 // at most `max(max_value, min_value)`, preferably `value`.
+//
+// If `min_value <= max_value`, then it is equivalent to `std::clamp()`,
+// otherwise `min_value` wins.
 template <
     typename Value, typename Min, typename Max,
     std::enable_if_t<std::conjunction_v<IsUnsignedInt<Value>,

diff --git a/riegeli/base/sized_shared_buffer.cc b/riegeli/base/sized_shared_buffer.cc
index 4aff4ce..32add9d 100644
--- a/riegeli/base/sized_shared_buffer.cc
+++ b/riegeli/base/sized_shared_buffer.cc

@@ -75,10 +75,9 @@
       data_ = new_data;
       return true;
     }
-    min_length_if_not = UnsignedMin(
-        UnsignedMax(length, SaturatingAdd(empty() ? capacity() : space_after(),
-                                          capacity() / 2)),
-        std::numeric_limits<size_t>::max() - size_);
+    min_length_if_not = UnsignedClamp(
+        SaturatingAdd(empty() ? capacity() : space_after(), capacity() / 2),
+        length, std::numeric_limits<size_t>::max() - size_);
   } else {
     min_length_if_not = length;
   }
@@ -104,10 +103,9 @@
       data_ = new_data;
       return true;
     }
-    min_length_if_not = UnsignedMin(
-        UnsignedMax(length, SaturatingAdd(empty() ? capacity() : space_before(),
-                                          capacity() / 2)),
-        std::numeric_limits<size_t>::max() - size_);
+    min_length_if_not = UnsignedClamp(
+        SaturatingAdd(empty() ? capacity() : space_before(), capacity() / 2),
+        length, std::numeric_limits<size_t>::max() - size_);
     space_after_if_not =
         UnsignedMin(space_after(), std::numeric_limits<size_t>::max() - size_ -
                                        min_length_if_not);

diff --git a/riegeli/base/string_utils.cc b/riegeli/base/string_utils.cc
index ea77059..c5d627d 100644
--- a/riegeli/base/string_utils.cc
+++ b/riegeli/base/string_utils.cc

@@ -28,9 +28,8 @@
 void ReserveAmortized(std::string& dest, size_t new_size) {
   dest.reserve(dest.capacity() == std::string().capacity()
                    ? new_size
-                   : UnsignedMax(new_size, UnsignedMin(dest.capacity() +
-                                                           dest.capacity() / 2,
-                                                       dest.max_size())));
+                   : UnsignedClamp(dest.capacity() + dest.capacity() / 2,
+                                   new_size, dest.max_size()));
 }
 
 }  // namespace riegeli::string_utils_internal

diff --git a/riegeli/bytes/cfile_reader.cc b/riegeli/bytes/cfile_reader.cc
index 3caa3e8..84082cc 100644
--- a/riegeli/bytes/cfile_reader.cc
+++ b/riegeli/bytes/cfile_reader.cc

@@ -308,7 +308,7 @@
       return FailOverflow();
     }
     const size_t length_to_read = UnsignedMin(
-        UnsignedMax(min_length, AvailableLength(src)), max_length,
+        UnsignedClamp(AvailableLength(src), min_length, max_length),
         Position{std::numeric_limits<cfile_internal::Offset>::max()} -
             limit_pos());
     const size_t length_read = fread(dest, 1, length_to_read, src);

diff --git a/riegeli/bytes/resizable_writer.h b/riegeli/bytes/resizable_writer.h
index 206f49e..5eb5181 100644
--- a/riegeli/bytes/resizable_writer.h
+++ b/riegeli/bytes/resizable_writer.h

@@ -364,12 +364,10 @@
       // because `Resizable` is not necessarily default-constructible. They are
       // normally the same, and even if they are not, this is a matter of
       // performance tuning, not correctness.
-      dest.reserve(
-          dest.capacity() <= std::string().capacity()
-              ? new_size
-              : UnsignedMax(new_size,
-                            UnsignedMin(dest.capacity() + dest.capacity() / 2,
-                                        dest.max_size())));
+      dest.reserve(dest.capacity() <= std::string().capacity()
+                       ? new_size
+                       : UnsignedClamp(dest.capacity() + dest.capacity() / 2,
+                                       new_size, dest.max_size()));
     }
   }
 };

diff --git a/riegeli/bytes/vector_writer.h b/riegeli/bytes/vector_writer.h
index 974d27c..e17742d 100644
--- a/riegeli/bytes/vector_writer.h
+++ b/riegeli/bytes/vector_writer.h

@@ -105,17 +105,13 @@
     if (new_num_elements > dest.capacity()) {
       dest.erase(dest.begin() + SizeToNumElements(used_size), dest.end());
       if constexpr (std::is_default_constructible_v<Resizable>) {
-        dest.reserve(
-            dest.capacity() <= Resizable().capacity()
-                ? new_num_elements
-                : UnsignedMax(new_num_elements,
-                              UnsignedMin(dest.capacity() + dest.capacity() / 2,
-                                          dest.max_size())));
-      } else {
-        dest.reserve(UnsignedMax(
-            new_num_elements, UnsignedMin(dest.capacity() + dest.capacity() / 2,
-                                          dest.max_size())));
+        if (dest.capacity() <= Resizable().capacity()) {
+          dest.reserve(new_num_elements);
+          return;
+        }
       }
+      dest.reserve(UnsignedClamp(dest.capacity() + dest.capacity() / 2,
+                                 new_num_elements, dest.max_size()));
     }
   }
 };

diff --git a/riegeli/tensorflow/io/tstring_writer.h b/riegeli/tensorflow/io/tstring_writer.h
index 76cc993..469274b 100644
--- a/riegeli/tensorflow/io/tstring_writer.h
+++ b/riegeli/tensorflow/io/tstring_writer.h

@@ -70,7 +70,7 @@
       dest.reserve(
           dest.capacity() <= tsl::tstring().capacity()
               ? new_size
-              : UnsignedMax(new_size, dest.capacity() + dest.capacity() / 2));
+              : UnsignedMax(dest.capacity() + dest.capacity() / 2, new_size));
     }
   }
 };