MB-69894: Add cb::human2size

Convert a textual representation of a size (generated from
cb::size2human) back to a numeric value

Change-Id: I12a68a27667e25e4cfdfa4f2cfd36e62e01fd1f5
Reviewed-on: https://review.couchbase.org/c/platform/+/237825
Tested-by: Build Bot <build@couchbase.com>
Reviewed-by: Paolo Cocchi <paolo.cocchi@couchbase.com>

Author: trondn

include/platform/string_utilities.h

@@ -19,10 +19,20 @@ namespace cb {
  * "k", "M" etc
  *
  * @param value the value to convert
- * @param an optional "suffix" to add to the string. By default adding 'b' to
- *                    return sizes like: 10Mb etc
+ * @param suffix n optional "suffix" to add to the string. By default adding
+ *                 'b' to return sizes like: 10Mb etc
  * @return the size in a format easier to read for a human
  */
 std::string size2human(std::size_t value,
                        const std::optional<std::string>& suffix = "B");
+
+/**
+ * Convert a human readable size (with an optional suffix) into a size_t.
+ * Suffix may be one of: k, M, G, T, P (case insensitive) with an optional
+ * 'b'/'B'
+ *
+ * @param text The textual representation to convert
+ * @return the value in bytes
+ */
+std::size_t human2size(std::string_view text);
 } // namespace cb

src/string_utilities.cc

@@ -8,8 +8,10 @@
  *   the file licenses/APL2.txt.
  */
 #include <fmt/format.h>
+#include <platform/byte_literals.h>
 #include <platform/string_utilities.h>
 #include <array>
+#include <charconv>
 
 std::string cb::size2human(std::size_t value,
                            const std::optional<std::string>& suffix) {
@@ -24,3 +26,57 @@ std::string cb::size2human(std::size_t value,
                        size_suffix[index],
                        suffix.has_value() ? *suffix : "");
 }
+
+std::size_t cb::human2size(std::string_view text) {
+    size_t value = 0;
+
+    const auto [ptr, ec]{
+            std::from_chars(text.data(), text.data() + text.size(), value)};
+    if (ec != std::errc()) {
+        if (ec == std::errc::invalid_argument) {
+            throw std::invalid_argument("human2size: no conversion");
+        }
+        if (ec == std::errc::result_out_of_range) {
+            throw std::out_of_range("human2size: value exceeds std::size_t");
+        }
+        throw std::system_error(std::make_error_code(ec));
+    }
+
+    // trim off what we've parsed
+    text.remove_prefix(ptr - text.data());
+    if (!text.empty()) {
+        switch (std::toupper(text.front())) {
+        case 'P':
+            value *= 1024_TiB;
+            break;
+        case 'T':
+            value *= 1_TiB;
+            break;
+        case 'G':
+            value *= 1_GiB;
+            break;
+        case 'M':
+            value *= 1_MiB;
+            break;
+        case 'K':
+            value *= 1_KiB;
+            break;
+        case 'B':
+            break;
+        default:
+            throw std::invalid_argument("human2size: invalid size specifier");
+        }
+        text.remove_prefix(1);
+        if (!text.empty()) {
+            if (text.front() == 'b' || text.front() == 'B') {
+                text.remove_prefix(1);
+            }
+            if (!text.empty()) {
+                throw std::invalid_argument(
+                        "human2size: Additional characters found");
+            }
+        }
+    }
+
+    return value;
+}

tests/unit_tests/string_utilities_test.cc

@@ -8,6 +8,7 @@
  *   the file licenses/APL2.txt.
  */
 #include <folly/portability/GTest.h>
+#include <platform/byte_literals.h>
 #include <platform/string_utilities.h>
 
 TEST(Size2Human, NoConversion) {
@@ -18,3 +19,16 @@ TEST(Size2Human, NoConversion) {
 TEST(Size2Human, Conversion) {
     EXPECT_EQ("20MB", cb::size2human(20 * 1024 * 1024));
 }
+
+TEST(Human2Size, NoConversion) {
+    EXPECT_EQ(2, cb::human2size("2"));
+    EXPECT_EQ(2, cb::human2size("2B"));
+}
+
+TEST(Human2Size, Conversion) {
+    EXPECT_EQ(32_KiB, cb::human2size("32k"));
+    EXPECT_EQ(20_MiB, cb::human2size("20Mb"));
+    EXPECT_EQ(3_GiB, cb::human2size("3G"));
+    EXPECT_EQ(7_TiB, cb::human2size("7T"));
+    EXPECT_EQ(8_TiB * 1024, cb::human2size("8PB"));
+}