Use custom type for ProtocolName (#12172)

* Add ProtocolName custom type

* Use new ProtocolName in sc_network_common

* Use new ProtocolName in sc_network

* Use new ProtocolName for BEEFY and GRANDPA

* Use new ProtocolName for notifications

* Use new ProtocolName in sc_network (part 2)

* Use new ProtocolName in sc_network_gossip

* Use new ProtocolName in sc_offchain

* Remove unused imports

* Some more fixes

* Add tests

* Fix minor import issues

* Re-export ProtocolName in sc_network

* Revert "Re-export ProtocolName in sc_network"

This reverts commit 8d8ff71927e7750757f29c9bbd88dc0ba181d214.

* Re-export ProtocolName in sc_network

* Remove dependency on sc-network-common from beefy-gadget

substrate/client/network/common/src/protocol.rs

@@ -16,4 +16,131 @@
 // You should have received a copy of the GNU General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
+use std::{
+	borrow::Borrow,
+	fmt,
+	hash::{Hash, Hasher},
+	ops::Deref,
+	sync::Arc,
+};
+
+use libp2p::core::upgrade;
+
 pub mod event;
+
+/// The protocol name transmitted on the wire.
+#[derive(Debug, Clone)]
+pub enum ProtocolName {
+	/// The protocol name as a static string.
+	Static(&'static str),
+	/// The protocol name as a dynamically allocated string.
+	OnHeap(Arc<str>),
+}
+
+impl From<&'static str> for ProtocolName {
+	fn from(name: &'static str) -> Self {
+		Self::Static(name)
+	}
+}
+
+impl From<Arc<str>> for ProtocolName {
+	fn from(name: Arc<str>) -> Self {
+		Self::OnHeap(name)
+	}
+}
+
+impl From<String> for ProtocolName {
+	fn from(name: String) -> Self {
+		Self::OnHeap(Arc::from(name))
+	}
+}
+
+impl Deref for ProtocolName {
+	type Target = str;
+
+	fn deref(&self) -> &str {
+		match self {
+			Self::Static(name) => name,
+			Self::OnHeap(name) => &name,
+		}
+	}
+}
+
+impl Borrow<str> for ProtocolName {
+	fn borrow(&self) -> &str {
+		self
+	}
+}
+
+impl PartialEq for ProtocolName {
+	fn eq(&self, other: &Self) -> bool {
+		(self as &str) == (other as &str)
+	}
+}
+
+impl Eq for ProtocolName {}
+
+impl Hash for ProtocolName {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		(self as &str).hash(state)
+	}
+}
+
+impl fmt::Display for ProtocolName {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.write_str(self)
+	}
+}
+
+impl upgrade::ProtocolName for ProtocolName {
+	fn protocol_name(&self) -> &[u8] {
+		(self as &str).as_bytes()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::ProtocolName;
+	use std::{
+		borrow::Borrow,
+		collections::hash_map::DefaultHasher,
+		hash::{Hash, Hasher},
+	};
+
+	#[test]
+	fn protocol_name_keys_are_equivalent_to_str_keys() {
+		const PROTOCOL: &'static str = "/some/protocol/1";
+		let static_protocol_name = ProtocolName::from(PROTOCOL);
+		let on_heap_protocol_name = ProtocolName::from(String::from(PROTOCOL));
+
+		assert_eq!(<ProtocolName as Borrow<str>>::borrow(&static_protocol_name), PROTOCOL);
+		assert_eq!(<ProtocolName as Borrow<str>>::borrow(&on_heap_protocol_name), PROTOCOL);
+		assert_eq!(static_protocol_name, on_heap_protocol_name);
+
+		assert_eq!(hash(static_protocol_name), hash(PROTOCOL));
+		assert_eq!(hash(on_heap_protocol_name), hash(PROTOCOL));
+	}
+
+	#[test]
+	fn different_protocol_names_do_not_compare_equal() {
+		const PROTOCOL1: &'static str = "/some/protocol/1";
+		let static_protocol_name1 = ProtocolName::from(PROTOCOL1);
+		let on_heap_protocol_name1 = ProtocolName::from(String::from(PROTOCOL1));
+
+		const PROTOCOL2: &'static str = "/some/protocol/2";
+		let static_protocol_name2 = ProtocolName::from(PROTOCOL2);
+		let on_heap_protocol_name2 = ProtocolName::from(String::from(PROTOCOL2));
+
+		assert_ne!(<ProtocolName as Borrow<str>>::borrow(&static_protocol_name1), PROTOCOL2);
+		assert_ne!(<ProtocolName as Borrow<str>>::borrow(&on_heap_protocol_name1), PROTOCOL2);
+		assert_ne!(static_protocol_name1, static_protocol_name2);
+		assert_ne!(static_protocol_name1, on_heap_protocol_name2);
+		assert_ne!(on_heap_protocol_name1, on_heap_protocol_name2);
+	}
+
+	fn hash<T: Hash>(x: T) -> u64 {
+		let mut hasher = DefaultHasher::new();
+		x.hash(&mut hasher);
+		hasher.finish()
+	}
+}