Use std::less<void> in the ParseKeyEqualsValue return type

This allows callers to use `.find` and `.count` functions with a
`std::string_view`, saving an allocation of a `std::string`.

Bug: b/472379698

Author: Databean

base/cvd/cuttlefish/common/libs/key_equals_value/key_equals_value.cc

@@ -19,6 +19,7 @@
 #include <map>
 #include <sstream>
 #include <string>
+#include <string_view>
 #include <utility>
 
 #include "absl/strings/ascii.h"
@@ -59,9 +60,9 @@ Result<void> GenericWriteKeyEqualsValue(
 
 }  // namespace
 
-Result<std::map<std::string, std::string>> ParseKeyEqualsValue(
+Result<std::map<std::string, std::string, std::less<void>>> ParseKeyEqualsValue(
     const std::string& contents) {
-  std::map<std::string, std::string> key_equals_value;
+  std::map<std::string, std::string, std::less<void>> key_equals_value;
   for (std::string_view line : absl::StrSplit(contents, '\n')) {
     std::pair<std::string_view, std::string_view> key_value =
         absl::StrSplit(line, absl::MaxSplits('=', 1));

base/cvd/cuttlefish/common/libs/key_equals_value/key_equals_value.h

@@ -23,7 +23,7 @@
 
 namespace cuttlefish {
 
-Result<std::map<std::string, std::string>> ParseKeyEqualsValue(
+Result<std::map<std::string, std::string, std::less<void>>> ParseKeyEqualsValue(
     const std::string&);
 
 std::string SerializeKeyEqualsValue(const std::map<std::string, std::string>&);

base/cvd/cuttlefish/common/libs/key_equals_value/key_equals_value_test.cc

@@ -20,7 +20,6 @@
 #include "gmock/gmock-matchers.h"
 #include "gtest/gtest.h"
 
-#include "cuttlefish/result/result.h"
 #include "cuttlefish/result/result_matchers.h"
 
 namespace cuttlefish {
@@ -29,21 +28,21 @@ namespace {
 TEST(KeyEqualsValue, Deserialize) {
   std::string serialized = "key1 = value1 \n key2 = value2";
 
-  std::map<std::string, std::string> expected = {{"key1", "value1"},
-                                                 {"key2", "value2"}};
+  std::map<std::string, std::string, std::less<void>> expected = {
+      {"key1", "value1"}, {"key2", "value2"}};
   ASSERT_THAT(ParseKeyEqualsValue(serialized), IsOkAndValue(expected));
 }
 
 TEST(KeyEqualsValue, Serialize) {
-  std::map<std::string, std::string> misc_info = {{"key1", "value1"},
-                                                  {"key2", "value2"}};
+  std::map<std::string, std::string, std::less<void>> misc_info = {
+      {"key1", "value1"}, {"key2", "value2"}};
 
   EXPECT_EQ(SerializeKeyEqualsValue(misc_info), "key1=value1\nkey2=value2\n");
 }
 
 TEST(KeyEqualsValue, SerializeDeserialize) {
-  std::map<std::string, std::string> misc_info = {{"key1", "value1"},
-                                                  {"key2", "value2"}};
+  std::map<std::string, std::string, std::less<void>> misc_info = {
+      {"key1", "value1"}, {"key2", "value2"}};
 
   std::string serialized = SerializeKeyEqualsValue(misc_info);
 
@@ -53,7 +52,8 @@ TEST(KeyEqualsValue, SerializeDeserialize) {
 TEST(KeyEqualsValue, DeserializeDuplicateKeySameValue) {
   std::string serialized = "key1=value1\nkey1=value1";
 
-  std::map<std::string, std::string> expected = {{"key1", "value1"}};
+  std::map<std::string, std::string, std::less<void>> expected = {
+      {"key1", "value1"}};
   ASSERT_THAT(ParseKeyEqualsValue(serialized), IsOkAndValue(expected));
 }
 
@@ -66,8 +66,9 @@ TEST(KeyEqualsValue, DeserializeDuplicateKeyDifferentValue) {
 TEST(KeyEqualsValue, EmptyLines) {
   std::string serialized = "\n\n\n\n\n\n";
 
-  ASSERT_THAT(ParseKeyEqualsValue(serialized),
-              IsOkAndValue(std::map<std::string, std::string>()));
+  ASSERT_THAT(
+      ParseKeyEqualsValue(serialized),
+      IsOkAndValue(std::map<std::string, std::string, std::less<void>>()));
 }
 
 }  // namespace

base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/img_zip.cc

@@ -76,7 +76,7 @@ class ImgZipImpl : public AndroidBuild {
   }
 
   // TODO: schuffelen - put in AndroidBuild
-  Result<std::map<std::string, std::string>> AndroidInfoTxt() {
+  Result<std::map<std::string, std::string, std::less<void>>> AndroidInfoTxt() {
     std::string contents =
         CF_EXPECT(archive_.MemberContents("android-info.txt"));
     return CF_EXPECT(ParseKeyEqualsValue(contents));

base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/misc_info_metadata.cc

@@ -37,7 +37,8 @@ namespace {
 
 class MetadataFromMiscInfo : public AndroidBuild {
  public:
-  MetadataFromMiscInfo(std::map<std::string, std::string> misc_info)
+  MetadataFromMiscInfo(
+      std::map<std::string, std::string, std::less<void>> misc_info)
       : misc_info_(std::move(misc_info)) {}
 
   Result<std::set<std::string, std::less<void>>> SystemPartitions() override {
@@ -90,13 +91,13 @@ class MetadataFromMiscInfo : public AndroidBuild {
     return out << "}";
   }
 
-  std::map<std::string, std::string> misc_info_;
+  std::map<std::string, std::string, std::less<void>> misc_info_;
 };
 
 }  // namespace
 
 Result<std::unique_ptr<AndroidBuild>> AndroidBuildFromMiscInfo(
-    std::map<std::string, std::string> misc_info) {
+    std::map<std::string, std::string, std::less<void>> misc_info) {
   auto build = std::make_unique<MetadataFromMiscInfo>(std::move(misc_info));
 
   std::set<std::string, std::less<void>> system =

base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/misc_info_metadata.h

@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <functional>
 #include <map>
 #include <memory>
 #include <string>
@@ -34,6 +35,6 @@ namespace cuttlefish {
  * "vendor" side logical partitions.
  */
 Result<std::unique_ptr<AndroidBuild>> AndroidBuildFromMiscInfo(
-    std::map<std::string, std::string>);
+    std::map<std::string, std::string, std::less<void>>);
 
 }  // namespace cuttlefish

base/cvd/cuttlefish/host/commands/assemble_cvd/android_build/target_files.cc

@@ -58,7 +58,7 @@ class TargetFilesImpl : public AndroidBuild {
     return std::make_unique<TargetFilesImpl>(std::move(target_files));
   }
 
-  Result<std::map<std::string, std::string>> MiscInfo() {
+  Result<std::map<std::string, std::string, std::less<void>>> MiscInfo() {
     static constexpr std::string_view kMiscInfoTxt = "META/misc_info.txt";
     std::string contents = CF_EXPECT(archive_.MemberContents(kMiscInfoTxt));
     return CF_EXPECT(ParseKeyEqualsValue(contents));
@@ -110,7 +110,8 @@ Result<std::unique_ptr<AndroidBuild>> TargetFiles(BuildArchive archive) {
   std::unique_ptr<TargetFilesImpl> target =
       CF_EXPECT(TargetFilesImpl::FromBuildArchive(std::move(archive)));
 
-  std::map<std::string, std::string> misc_info = CF_EXPECT(target->MiscInfo());
+  std::map<std::string, std::string, std::less<void>> misc_info =
+      CF_EXPECT(target->MiscInfo());
 
   std::unique_ptr<AndroidBuild> misc_info_build =
       CF_EXPECT(AndroidBuildFromMiscInfo(std::move(misc_info)));

base/cvd/cuttlefish/host/commands/assemble_cvd/misc_info.h

@@ -15,6 +15,7 @@
 
 #pragma once
 
+#include <functional>
 #include <map>
 #include <set>
 #include <string>
@@ -24,7 +25,7 @@
 
 namespace cuttlefish {
 
-using MiscInfo = std::map<std::string, std::string>;
+using MiscInfo = std::map<std::string, std::string, std::less<void>>;
 
 struct VbmetaArgs {
   std::string algorithm;

base/cvd/cuttlefish/host/commands/defaults/defaults.cpp

@@ -13,17 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <string.h>
 #include <unistd.h>
 
+#include <functional>
 #include <string_view>
 
-#include <android-base/logging.h>
-#include <android-base/macros.h>
-#include "absl/cleanup/cleanup.h"
 #include "absl/flags/flag.h"
 #include "absl/flags/parse.h"
 #include "absl/strings/str_format.h"
+#include "android-base/logging.h"
 
 #include "cuttlefish/common/libs/key_equals_value/key_equals_value.h"
 #include "cuttlefish/host/libs/web/http_client/curl_http_client.h"
@@ -51,8 +49,8 @@ Result<std::string> MetadataValue(std::string_view key) {
 
 Result<std::pair<std::string, std::string>> ParseKeyValueFlag(
     const std::string &flag) {
-  std::map<std::string, std::string> kvs = CF_EXPECT(
-      ParseKeyEqualsValue(flag));
+  std::map<std::string, std::string, std::less<void>> kvs =
+      CF_EXPECT(ParseKeyEqualsValue(flag));
   CF_EXPECT(kvs.size() == 1);
   return *(kvs.begin());
 }
@@ -93,7 +91,8 @@ Result<bool> UseStaticDefaults(const std::optional<std::string> &flag) {
   return actual == expected;
 }
 
-Result<std::map<std::string, std::string>> DefaultsFromMetadata() {
+Result<std::map<std::string, std::string, std::less<void>>>
+DefaultsFromMetadata() {
   std::string data =
       CF_EXPECT(MetadataValue("instance/attributes/cf-defaults"));
   return ParseKeyEqualsValue(data);
@@ -119,7 +118,8 @@ Result<int> DefaultsMain(int argc, char *argv[]) {
     return 0;
   }
 
-  Result<std::map<std::string, std::string>> m = DefaultsFromMetadata();
+  Result<std::map<std::string, std::string, std::less<void>>> m =
+      DefaultsFromMetadata();
   if (!m.ok()) {
     LOG(INFO) << "Couldn't get defaults from metadata.";
     // Not necessarily an error, so don't report it.

base/cvd/cuttlefish/host/libs/config/config_flag.cpp

@@ -18,6 +18,7 @@
 
 #include <stddef.h>
 
+#include <functional>
 #include <map>
 #include <optional>
 #include <ostream>
@@ -196,7 +197,7 @@ class ConfigFlagImpl : public ConfigFlag {
     if (!ReadFileToString(info_path, &android_info)) {
       return {};
     }
-    Result<std::map<std::string, std::string>> parsed_config =
+    Result<std::map<std::string, std::string, std::less<void>>> parsed_config =
         ParseKeyEqualsValue(android_info);
     if (!parsed_config.ok()) {
       return {};