[Comb] Migrate p4_infra/p4_pdpi/string_encodings to p4_infra/string_encodings.

dvaas/BUILD.bazel

@@ -60,7 +60,7 @@ cc_library(
         "//p4_infra/p4_pdpi:p4_runtime_session_extras",
         "//p4_infra/p4_pdpi:sequencing",
         "//p4_infra/p4_pdpi/packetlib:packetlib_cc_proto",
-        "//p4_infra/p4_pdpi/string_encodings:hex_string",
+        "//p4_infra/string_encodings:hex_string",
         "//p4_symbolic/packet_synthesizer:coverage_goal_cc_proto",
         "//p4_symbolic/packet_synthesizer:packet_synthesizer_cc_proto",
         "//sai_p4/instantiations/google:p4_versions",
@@ -315,7 +315,7 @@ cc_library(
         "//p4_infra/p4_pdpi/packetlib",
         "//p4_infra/p4_pdpi/packetlib:bit_widths",
         "//p4_infra/p4_pdpi/packetlib:packetlib_cc_proto",
-        "//p4_infra/p4_pdpi/string_encodings:hex_string",
+        "//p4_infra/string_encodings:hex_string",
         "@com_google_absl//absl/container:btree",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",

dvaas/dataplane_validation.cc

@@ -69,7 +69,7 @@
 #include "p4_infra/p4_pdpi/p4_runtime_session_extras.h"
 #include "p4_infra/p4_pdpi/packetlib/packetlib.pb.h"
 #include "p4_infra/p4_pdpi/sequencing.h"
-#include "p4_infra/p4_pdpi/string_encodings/hex_string.h"
+#include "p4_infra/string_encodings/hex_string.h"
 #include "p4_symbolic/packet_synthesizer/packet_synthesizer.pb.h"
 #include "proto/gnmi/gnmi.pb.h"
 #include "sai_p4/instantiations/google/versions.h"
@@ -550,9 +550,9 @@ absl::StatusOr<std::string> GetBmv2PacketHex(
       constexpr auto kSubmitToIngressSaiP4PacketOutHeader =
           std::bitset<16>(0b0000'0000'0100'0000);
       return absl::StrCat(
-          absl::StripPrefix(
-              pdpi::BitsetToHexString(kSubmitToIngressSaiP4PacketOutHeader),
-              "0x"),
+          absl::StripPrefix(string_encodings::BitsetToHexString(
+                                kSubmitToIngressSaiP4PacketOutHeader),
+                            "0x"),
           absl::StripPrefix(switch_input.packet().hex(), "0x"));
     }
     case SwitchInput::PACKET_OUT: {

dvaas/test_vector.cc

@@ -28,7 +28,7 @@
 #include "p4_infra/p4_pdpi/packetlib/bit_widths.h"
 #include "p4_infra/p4_pdpi/packetlib/packetlib.h"
 #include "p4_infra/p4_pdpi/packetlib/packetlib.pb.h"
-#include "p4_infra/p4_pdpi/string_encodings/hex_string.h"
+#include "p4_infra/string_encodings/hex_string.h"
 #include "re2/re2.h"
 
 namespace dvaas {
@@ -82,8 +82,9 @@ absl::StatusOr<int> ExtractIdFromTaggedPacket(absl::string_view raw_packet) {
 
 absl::StatusOr<int> ExtractIdFromTaggedPacketInHex(
     absl::string_view packet_hex) {
-  ASSIGN_OR_RETURN(std::string raw_packet,
-                   pdpi::HexStringToByteString(absl::StrCat("0x", packet_hex)));
+  ASSIGN_OR_RETURN(
+      std::string raw_packet,
+      string_encodings::HexStringToByteString(absl::StrCat("0x", packet_hex)));
   return dvaas::ExtractIdFromTaggedPacket(raw_packet);
 }
 

lib/p4rt/BUILD.bazel

@@ -77,9 +77,9 @@ cc_library(
     hdrs = ["p4rt_port.h"],
     deps = [
         "//gutil/gutil:status",
-        "//p4_infra/p4_pdpi/string_encodings:byte_string",
-        "//p4_infra/p4_pdpi/string_encodings:decimal_string",
-	"//p4_infra/p4_pdpi/string_encodings:hex_string",
+        "//p4_infra/string_encodings:byte_string",
+        "//p4_infra/string_encodings:decimal_string",
+        "//p4_infra/string_encodings:hex_string",
         "@com_google_absl//absl/numeric:bits",
         "@com_google_absl//absl/status",
         "@com_google_absl//absl/status:statusor",

lib/p4rt/p4rt_port.cc

@@ -26,16 +26,16 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
 #include "gutil/gutil/status.h"
-#include "p4_infra/p4_pdpi/string_encodings/byte_string.h"
-#include "p4_infra/p4_pdpi/string_encodings/decimal_string.h"
-#include "p4_infra/p4_pdpi/string_encodings/hex_string.h"
+#include "p4_infra/string_encodings/byte_string.h"
+#include "p4_infra/string_encodings/decimal_string.h"
+#include "p4_infra/string_encodings/hex_string.h"
 
 namespace pins_test {
 
 absl::StatusOr<P4rtPortId> P4rtPortId::MakeFromP4rtEncoding(
     absl::string_view p4rt_port_id) {
   ASSIGN_OR_RETURN(uint32_t p4rt_port_id_int,
-                   pdpi::DecimalStringToUint32(p4rt_port_id));
+                   string_encodings::DecimalStringToUint32(p4rt_port_id));
   return P4rtPortId(p4rt_port_id_int);
 }
 
@@ -65,7 +65,7 @@ std::vector<P4rtPortId> P4rtPortId::MakeVectorFromOpenConfigEncodings(
 absl::StatusOr<P4rtPortId> P4rtPortId::MakeFromHexstringEncoding(
     absl::string_view hexstring_encoding) {
   ASSIGN_OR_RETURN(uint32_t p4rt_port_id_int,
-                   pdpi::HexStringToUint32(hexstring_encoding));
+                   string_encodings::HexStringToUint32(hexstring_encoding));
   return P4rtPortId(p4rt_port_id_int);
 }
 
@@ -84,7 +84,8 @@ absl::StatusOr<std::string> P4rtPortId::GetBmv2P4rtEncoding() const {
               "but the present P4RT port ID "
            << p4rt_port_id_ << " has " << width << " bits.";
   }
-  return pdpi::BitsetToP4RuntimeByteString<kBmv2PortBitWidth>(p4rt_port_id_);
+  return string_encodings::BitsetToP4RuntimeByteString<kBmv2PortBitWidth>(
+      p4rt_port_id_);
 }
 
 bool P4rtPortId::operator==(const P4rtPortId& other) const {

p4_fuzzer/BUILD.bazel

@@ -152,8 +152,8 @@ cc_library(
         "//p4_infra/p4_pdpi:references",
         "//p4_infra/p4_pdpi/internal:ordered_map",
         "//p4_infra/p4_pdpi/netaddr:ipv6_address",
-        "//p4_infra/p4_pdpi/string_encodings:byte_string",
         "//p4_infra/p4_pdpi/utils:ir",
+        "//p4_infra/string_encodings:byte_string",
         "@com_github_p4lang_p4_constraints//p4_constraints:ast",
         "@com_github_p4lang_p4_constraints//p4_constraints:ast_cc_proto",
         "@com_github_p4lang_p4_constraints//p4_constraints:constraint_source",

p4_fuzzer/fuzz_util.cc

@@ -57,8 +57,8 @@
 #include "p4_infra/p4_pdpi/ir.pb.h"
 #include "p4_infra/p4_pdpi/netaddr/ipv6_address.h"
 #include "p4_infra/p4_pdpi/references.h"
-#include "p4_infra/p4_pdpi/string_encodings/byte_string.h"
 #include "p4_infra/p4_pdpi/utils/ir.h"
+#include "p4_infra/string_encodings/byte_string.h"
 
 namespace p4_fuzzer {
 
@@ -707,7 +707,8 @@ absl::StatusOr<Replica> FuzzReplica(absl::BitGen* gen,
   if (auto it = reference_map.find(instance_param); it != reference_map.end()) {
     ASSIGN_OR_RETURN(
         auto instance,
-        pdpi::ByteStringToBitset<kReplicaInstanceBitwidth>(it->second));
+        string_encodings::ByteStringToBitset<kReplicaInstanceBitwidth>(
+            it->second));
     replica.set_instance(instance.to_ullong());
   } else {
     replica.set_instance(FuzzUint64(gen, kReplicaInstanceBitwidth));

p4_infra/p4_pdpi/BUILD.bazel

@@ -32,7 +32,7 @@ cc_library(
         "//gutil/gutil:collections",
         "//gutil/gutil:proto",
         "//gutil/gutil:status",
-        "//p4_infra/p4_pdpi/string_encodings:byte_string",
+        "//p4_infra/string_encodings:byte_string",
         "@com_github_p4lang_p4runtime//:p4runtime_cc_proto",
         "@com_google_absl//absl/container:btree",
         "@com_google_absl//absl/container:flat_hash_map",
@@ -209,8 +209,8 @@ cc_library(
         "//gutil/gutil:proto",
         "//gutil/gutil:status",
         "//p4_infra/p4_pdpi/internal:ordered_map",
-        "//p4_infra/p4_pdpi/string_encodings:hex_string",
         "//p4_infra/p4_pdpi/utils:ir",
+        "//p4_infra/string_encodings:hex_string",
         "@com_github_grpc_grpc//:grpc++",
         "@com_github_p4lang_p4runtime//:p4info_cc_proto",
         "@com_github_p4lang_p4runtime//:p4runtime_cc_proto",

p4_infra/p4_pdpi/netaddr/BUILD.bazel

@@ -8,8 +8,8 @@ cc_library(
     hdrs = ["network_address.h"],
     deps = [
         "//gutil/gutil:status",
-        "//p4_infra/p4_pdpi/string_encodings:byte_string",
-        "//p4_infra/p4_pdpi/string_encodings:hex_string",
+        "//p4_infra/string_encodings:byte_string",
+        "//p4_infra/string_encodings:hex_string",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
     ],
@@ -36,7 +36,7 @@ cc_test(
         ":network_address",
         "//gutil/gutil:status",
         "//gutil/gutil:status_matchers",
-        "//p4_infra/p4_pdpi/string_encodings:safe",
+        "//p4_infra/string_encodings:safe",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/strings",
         "@com_google_googletest//:gtest_main",
@@ -50,7 +50,6 @@ cc_library(
     deps = [
         ":network_address",
         "//gutil/gutil:status",
-        "//p4_infra/p4_pdpi/string_encodings:hex_string",
         "@com_google_absl//absl/log",
         "@com_google_absl//absl/numeric:int128",
         "@com_google_absl//absl/status",
@@ -67,7 +66,7 @@ cc_test(
         ":network_address",
         "//gutil/gutil:status",
         "//gutil/gutil:status_matchers",
-        "//p4_infra/p4_pdpi/string_encodings:safe",
+        "//p4_infra/string_encodings:safe",
         "@com_google_absl//absl/numeric:int128",
         "@com_google_absl//absl/strings",
         "@com_google_googletest//:gtest_main",
@@ -82,6 +81,7 @@ cc_library(
         ":ipv6_address",
         ":network_address",
         "//gutil/gutil:status",
+        "//p4_infra/string_encodings:hex_string",
         "@com_google_absl//absl/status:statusor",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings:str_format",
@@ -96,7 +96,7 @@ cc_test(
         ":network_address",
         "//gutil/gutil:status",
         "//gutil/gutil:status_matchers",
-        "//p4_infra/p4_pdpi/string_encodings:safe",
+        "//p4_infra/string_encodings:safe",
         "@com_google_absl//absl/strings",
         "@com_google_googletest//:gtest_main",
     ],

p4_infra/p4_pdpi/netaddr/ipv4_address_and_network_address_test.cc

@@ -27,7 +27,7 @@
 #include "gutil/gutil/status_matchers.h"
 #include "p4_infra/p4_pdpi/netaddr/ipv4_address.h"
 #include "p4_infra/p4_pdpi/netaddr/network_address.h"
-#include "p4_infra/p4_pdpi/string_encodings/safe.h"
+#include "p4_infra/string_encodings/safe.h"
 
 // This file serves double duty, testing both Ipv4Address and the template class
 // NetworkAddress from which Ipv4Address derives.
@@ -40,7 +40,7 @@ namespace {
 
 using ::gutil::IsOk;
 using ::gutil::IsOkAndHolds;
-using ::pdpi::SafeString;
+using ::string_encodings::SafeString;
 using ::testing::Eq;
 using ::testing::Not;
 

p4_infra/p4_pdpi/netaddr/ipv6_address.cc

@@ -28,13 +28,12 @@
 #include "absl/strings/string_view.h"
 #include "gutil/gutil/status.h"
 #include "p4_infra/p4_pdpi/netaddr/network_address.h"
-#include "p4_infra/p4_pdpi/string_encodings/hex_string.h"
 
 namespace netaddr {
 
 absl::StatusOr<Ipv6Address> Ipv6Address::OfString(absl::string_view address) {
   std::string bytes = std::string(128 / 8, '\x0');
-  if (inet_pton(AF_INET6, address.data(), bytes.data()) == 1) {
+  if (inet_pton(AF_INET6, std::string(address).c_str(), bytes.data()) == 1) {
     auto ip = Ipv6Address::OfByteString(bytes);
     if (ip.ok()) return ip;
     LOG(DFATAL) << "failed to parse IPv6 byte string produced by inet_pton: "

p4_infra/p4_pdpi/netaddr/ipv6_address_test.cc

@@ -24,14 +24,14 @@
 #include "gutil/gutil/status.h"
 #include "gutil/gutil/status_matchers.h"
 #include "p4_infra/p4_pdpi/netaddr/network_address.h"
-#include "p4_infra/p4_pdpi/string_encodings/safe.h"
+#include "p4_infra/string_encodings/safe.h"
 
 namespace netaddr {
 namespace {
 
 using ::gutil::IsOk;
 using ::gutil::IsOkAndHolds;
-using ::pdpi::SafeChar;
+using ::string_encodings::SafeChar;
 using ::testing::Eq;
 using ::testing::Not;
 using ::testing::Property;

p4_infra/p4_pdpi/netaddr/mac_address.cc

@@ -17,6 +17,7 @@
 #include <cstdint>
 #include <cstring>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/status/statusor.h"
@@ -27,6 +28,7 @@
 #include "gutil/gutil/status.h"
 #include "p4_infra/p4_pdpi/netaddr/ipv6_address.h"
 #include "p4_infra/p4_pdpi/netaddr/network_address.h"
+#include "p4_infra/string_encodings/hex_string.h"
 
 namespace netaddr {
 
@@ -100,7 +102,8 @@ absl::StatusOr<MacAddress> MacAddress::OfInterfaceId(
   uint64_t id = interface_id.to_ullong();
   if ((id & 0x0000'00FF'FF00'0000) != 0x0000'00FF'FE00'0000) {
     return gutil::InvalidArgumentErrorBuilder()
-           << "invalid interface ID " << pdpi::BitsetToHexString(interface_id)
+           << "invalid interface ID "
+           << string_encodings::BitsetToHexString(interface_id)
            << ": the two middle bytes must be equal to FF FE.";
   }
   std::bitset<48> mac = ((id & 0xFFFF'FF00'0000'0000u) >> 16) |

p4_infra/p4_pdpi/netaddr/mac_address_test.cc

@@ -23,7 +23,7 @@
 #include "gutil/gutil/status.h"
 #include "gutil/gutil/status_matchers.h"
 #include "p4_infra/p4_pdpi/netaddr/network_address.h"
-#include "p4_infra/p4_pdpi/string_encodings/safe.h"
+#include "p4_infra/string_encodings/safe.h"
 
 namespace netaddr {
 namespace {
@@ -50,20 +50,22 @@ std::vector<MacTriple> CorrectMacTriples() {
   triples.push_back(MacTriple{
       .canonical_notation = "00:00:00:00:00:00",
       .alternative_notations = {"00:00:00:00:0:0", "0:0:0:0:0:0"},
-      .byte_string = pdpi::SafeString({0, 0, 0, 0, 0, 0}),
+      .byte_string = string_encodings::SafeString({0, 0, 0, 0, 0, 0}),
       .mac = MacAddress::AllZeros(),
   });
   triples.push_back(MacTriple{
       .canonical_notation = "01:23:45:67:89:ab",
       .alternative_notations = {"01:23:45:67:89:ab", "1:23:45:67:89:ab",
                                 "01:23:45:67:89:Ab"},
-      .byte_string = pdpi::SafeString({0x01, 0x23, 0x45, 0x67, 0x89, 0xab}),
+      .byte_string =
+          string_encodings::SafeString({0x01, 0x23, 0x45, 0x67, 0x89, 0xab}),
       .mac = MacAddress(0x01, 0x23, 0x45, 0x67, 0x89, 0xab),
   });
   triples.push_back(MacTriple{
       .canonical_notation = "ff:ff:ff:ff:ff:ff",
       .alternative_notations = {"ff:ff:ff:FF:fF:ff", "FF:FF:FF:FF:FF:FF"},
-      .byte_string = pdpi::SafeString({0xff, 0xff, 0xff, 0xff, 0xff, 0xff}),
+      .byte_string =
+          string_encodings::SafeString({0xff, 0xff, 0xff, 0xff, 0xff, 0xff}),
       .mac = MacAddress::AllOnes(),
   });
 

p4_infra/p4_pdpi/netaddr/network_address.h

@@ -24,8 +24,8 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 #include "gutil/gutil/status.h"
-#include "p4_infra/p4_pdpi/string_encodings/byte_string.h"
-#include "p4_infra/p4_pdpi/string_encodings/hex_string.h"
+#include "p4_infra/string_encodings/byte_string.h"
+#include "p4_infra/string_encodings/hex_string.h"
 
 namespace netaddr {
 
@@ -82,7 +82,9 @@ template <std::size_t num_bits, typename T> class NetworkAddress {
   // Returns underlying bit representation.
   std::bitset<num_bits> ToBitset() const { return bits_; }
   // Returns hexadecimal representation of the address.
-  std::string ToHexString() const { return pdpi::BitsetToHexString(bits_); }
+  std::string ToHexString() const {
+    return string_encodings::BitsetToHexString(bits_);
+  }
   // Returns big-endian byte string encoding of the address of length exactly
   // ceil(num_bits/8).
   std::string ToPaddedByteString() const;
@@ -170,25 +172,26 @@ absl::StatusOr<T> NetworkAddress<N, T>::MaskForPrefixLength(int prefix_length) {
 
 template <std::size_t N, typename T>
 absl::StatusOr<T> NetworkAddress<N, T>::OfHexString(absl::string_view hex_str) {
-  ASSIGN_OR_RETURN(auto bits, pdpi::HexStringToBitset<N>(hex_str));
+  ASSIGN_OR_RETURN(auto bits, string_encodings::HexStringToBitset<N>(hex_str));
   return T(std::move(bits));
 }
 
 template <std::size_t N, typename T>
-absl::StatusOr<T>
-NetworkAddress<N, T>::OfByteString(absl::string_view byte_str) {
-  ASSIGN_OR_RETURN(auto bits, pdpi::ByteStringToBitset<N>(byte_str));
+absl::StatusOr<T> NetworkAddress<N, T>::OfByteString(
+    absl::string_view byte_str) {
+  ASSIGN_OR_RETURN(auto bits,
+                   string_encodings::ByteStringToBitset<N>(byte_str));
   return T(bits);
 }
 
 template <std::size_t N, typename T>
 std::string NetworkAddress<N, T>::ToPaddedByteString() const {
-  return pdpi::BitsetToPaddedByteString(bits_);
+  return string_encodings::BitsetToPaddedByteString(bits_);
 }
 
 template <std::size_t N, typename T>
 std::string NetworkAddress<N, T>::ToP4RuntimeByteString() const {
-  return pdpi::BitsetToP4RuntimeByteString(bits_);
+  return string_encodings::BitsetToP4RuntimeByteString(bits_);
 }
 
 template <std::size_t N, typename T>