Replace use of strings with ExchangeName, QueueName, ConsumerTag, and RoutingKey

Author: lukebakken

projects/RabbitMQ.Client/PublicAPI.Unshipped.txt

@@ -35,10 +35,12 @@
 
 namespace RabbitMQ.Client
 {
-    public abstract class AmqpString
+    // TODO lazy string value
+    public abstract class AmqpString : IEquatable<AmqpString>
     {
         private readonly string _value;
         private readonly ReadOnlyMemory<byte> _stringBytes;
+        private readonly int _byteCount;
 
         protected AmqpString()
         {
@@ -77,6 +79,22 @@ public AmqpString(string value, ushort maxLen, Encoding encoding, string validat
 
             _value = value;
             _stringBytes = new ReadOnlyMemory<byte>(encoding.GetBytes(value));
+            _byteCount = _stringBytes.Length;
+        }
+
+        public int ByteCount => _byteCount;
+
+        public bool IsEmpty
+        {
+            get
+            {
+                return _value == string.Empty;
+            }
+        }
+
+        public bool Contains(string value)
+        {
+            return _value.Contains(value);
         }
 
         public override string ToString()
@@ -94,10 +112,66 @@ public static implicit operator ReadOnlyMemory<byte>(AmqpString amqpString)
             return amqpString._stringBytes;
         }
 
+        public static implicit operator ReadOnlySpan<byte>(AmqpString amqpString)
+        {
+            return amqpString._stringBytes.Span;
+        }
+
         private bool isAscii(string value)
         {
             return Encoding.UTF8.GetByteCount(value) == value.Length;
         }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is null)
+            {
+                return false;
+            }
+
+            if (Object.ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            AmqpString amqpStringObj = obj as AmqpString;
+            if (amqpStringObj is null)
+            {
+                return false;
+            }
+
+            return Equals(amqpStringObj);
+        }
+
+        public bool Equals(AmqpString other)
+        {
+            return _value == other._value;
+        }
+
+        public override int GetHashCode()
+        {
+            return _value.GetHashCode();
+        }
+
+        public static bool operator ==(AmqpString exchangeType1, AmqpString exchangeType2)
+        {
+            if (exchangeType1 is null || exchangeType2 is null)
+            {
+                return Object.Equals(exchangeType1, exchangeType2);
+            }
+
+            return exchangeType1.Equals(exchangeType2);
+        }
+
+        public static bool operator !=(AmqpString exchangeType1, AmqpString exchangeType2)
+        {
+            if (exchangeType1 is null || exchangeType2 is null)
+            {
+                return false == Object.Equals(exchangeType1, exchangeType2);
+            }
+
+            return false == exchangeType1.Equals(exchangeType2);
+        }
     }
 
     /*
@@ -121,7 +195,8 @@ public ExchangeName(string exchangeName)
         {
         }
 
-        public static explicit operator ExchangeName(string value)
+        // TODO explicit
+        public static implicit operator ExchangeName(string value)
         {
             return new ExchangeName(value);
         }
@@ -143,15 +218,21 @@ private QueueName() : base()
         {
         }
 
-        public QueueName(string exchangeName)
-            : base(exchangeName, 127, Encoding.ASCII, "^[a-zA-Z0-9-_.:]*$")
+        public QueueName(string queueName)
+            : base(queueName, 127, Encoding.ASCII, "^[a-zA-Z0-9-_.:]*$")
         {
         }
 
-        public static explicit operator QueueName(string value)
+        // TODO explicit
+        public static implicit operator QueueName(string value)
         {
             return new QueueName(value);
         }
+
+        public static explicit operator RoutingKey(QueueName value)
+        {
+            return new RoutingKey(value);
+        }
     }
 
     /*
@@ -174,7 +255,8 @@ public RoutingKey(string exchangeName)
         {
         }
 
-        public static explicit operator RoutingKey(string value)
+        // TODO explicit
+        public static implicit operator RoutingKey(string value)
         {
             return new RoutingKey(value);
         }
@@ -199,7 +281,8 @@ public ConsumerTag(string exchangeName)
         {
         }
 
-        public static explicit operator ConsumerTag(string value)
+        // TODO explicit
+        public static implicit operator ConsumerTag(string value)
         {
             return new ConsumerTag(value);
         }

projects/RabbitMQ.Client/client/api/AmqpString.cs

@@ -29,42 +29,86 @@
 //  Copyright (c) 2007-2020 VMware, Inc.  All rights reserved.
 //---------------------------------------------------------------------------
 
+using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace RabbitMQ.Client
 {
     /// <summary>
-    /// Convenience class providing compile-time names for standard exchange types.
+    /// Convenience struct providing compile-time names for standard exchange types.
     /// </summary>
     /// <remarks>
     /// Use the static members of this class as values for the
     /// "exchangeType" arguments for IChannel methods such as
     /// ExchangeDeclare. The broker may be extended with additional
     /// exchange types that do not appear in this class.
     /// </remarks>
-    public static class ExchangeType
+    public class ExchangeType : IEquatable<ExchangeType>
     {
+        private const string EmptyStr = "";
+        private const string FanoutStr = "fanout";
+        private const string DirectStr = "direct";
+        private const string TopicStr = "topic";
+        private const string HeadersStr = "headers";
+
+        private static readonly string[] s_all = { EmptyStr, FanoutStr, DirectStr, TopicStr, HeadersStr };
+
+        private readonly string _value;
+
+        internal static readonly ExchangeType s_empty = new ExchangeType(string.Empty);
+
         /// <summary>
         /// Exchange type used for AMQP direct exchanges.
         /// </summary>
-        public const string Direct = "direct";
+        public static readonly ExchangeType Direct = new ExchangeType(DirectStr);
 
         /// <summary>
         /// Exchange type used for AMQP fanout exchanges.
         /// </summary>
-        public const string Fanout = "fanout";
+        public static readonly ExchangeType Fanout = new ExchangeType(FanoutStr);
 
         /// <summary>
         /// Exchange type used for AMQP headers exchanges.
         /// </summary>
-        public const string Headers = "headers";
+        public static readonly ExchangeType Headers = new ExchangeType(HeadersStr);
 
         /// <summary>
         /// Exchange type used for AMQP topic exchanges.
         /// </summary>
-        public const string Topic = "topic";
+        public static readonly ExchangeType Topic = new ExchangeType(TopicStr);
+
+        internal ExchangeType(string value)
+        {
+            if (false == s_all.Contains(value))
+            {
+                throw new ArgumentOutOfRangeException(nameof(value));
+            }
+            _value = value;
+        }
 
-        private static readonly string[] s_all = { Fanout, Direct, Topic, Headers };
+        public override string ToString()
+        {
+            return _value;
+        }
+
+        public static implicit operator ExchangeType(string value)
+        {
+            return new ExchangeType(value);
+        }
+
+        public static implicit operator string(ExchangeType exchangeType)
+        {
+            return exchangeType._value;
+        }
+
+        internal int ByteCount
+        {
+            get
+            {
+                return _value.Length;
+            }
+        }
 
         /// <summary>
         /// Retrieve a collection containing all standard exchange types.
@@ -73,5 +117,56 @@ public static ICollection<string> All()
         {
             return s_all;
         }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is null)
+            {
+                return false;
+            }
+
+            if (Object.ReferenceEquals(this, obj))
+            {
+                return true;
+            }
+
+            ExchangeType exchangeTypeObj = obj as ExchangeType;
+            if (exchangeTypeObj is null)
+            {
+                return false;
+            }
+
+            return Equals(exchangeTypeObj);
+        }
+
+        public bool Equals(ExchangeType other)
+        {
+            return _value == other._value;
+        }
+
+        public override int GetHashCode()
+        {
+            return _value.GetHashCode();
+        }
+
+        public static bool operator ==(ExchangeType exchangeType1, ExchangeType exchangeType2)
+        {
+            if (exchangeType1 is null || exchangeType2 is null)
+            {
+                return Object.Equals(exchangeType1, exchangeType2);
+            }
+
+            return exchangeType1.Equals(exchangeType2);
+        }
+
+        public static bool operator !=(ExchangeType exchangeType1, ExchangeType exchangeType2)
+        {
+            if (exchangeType1 is null || exchangeType2 is null)
+            {
+                return false == Object.Equals(exchangeType1, exchangeType2);
+            }
+
+            return false == exchangeType1.Equals(exchangeType2);
+        }
     }
 }