@azure-typespec/http-client-csharp-provisioning 1.0.0-alpha.20260313.4

package/dist/generator/net10.0/Shared/Core/RawRequestUriBuilder.cs

@@ -0,0 +1,229 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace Azure.Core
+{
+    internal class RawRequestUriBuilder : RequestUriBuilder
+    {
+        private const string SchemeSeparator = "://";
+        private const char HostSeparator = '/';
+        private const char PortSeparator = ':';
+        private static readonly char[] HostOrPort = { HostSeparator, PortSeparator };
+        private const char QueryBeginSeparator = '?';
+        private const char QueryContinueSeparator = '&';
+        private const char QueryValueSeparator = '=';
+
+        private RawWritingPosition? _position;
+
+        private static void GetQueryParts(ReadOnlySpan<char> queryUnparsed, out ReadOnlySpan<char> name, out ReadOnlySpan<char> value)
+        {
+            int separatorIndex = queryUnparsed.IndexOf(QueryValueSeparator);
+            if (separatorIndex == -1)
+            {
+                name = queryUnparsed;
+                value = ReadOnlySpan<char>.Empty;
+            }
+            else
+            {
+                name = queryUnparsed.Slice(0, separatorIndex);
+                value = queryUnparsed.Slice(separatorIndex + 1);
+            }
+        }
+
+        public void AppendRaw(string value, bool escape)
+        {
+            AppendRaw(value.AsSpan(), escape);
+        }
+
+        private void AppendRaw(ReadOnlySpan<char> value, bool escape)
+        {
+            if (_position == null)
+            {
+                if (HasQuery)
+                {
+                    _position = RawWritingPosition.Query;
+                }
+                else if (HasPath)
+                {
+                    _position = RawWritingPosition.Path;
+                }
+                else if (!string.IsNullOrEmpty(Host))
+                {
+                    _position = RawWritingPosition.Host;
+                }
+                else
+                {
+                    _position = RawWritingPosition.Scheme;
+                }
+            }
+
+            while (!value.IsEmpty)
+            {
+                if (_position == RawWritingPosition.Scheme)
+                {
+                    int separator = value.IndexOf(SchemeSeparator.AsSpan(), StringComparison.InvariantCultureIgnoreCase);
+                    if (separator == -1)
+                    {
+                        Scheme += value.ToString();
+                        value = ReadOnlySpan<char>.Empty;
+                    }
+                    else
+                    {
+                        Scheme += value.Slice(0, separator).ToString();
+                        // TODO: Find a better way to map schemes to default ports
+                        Port = string.Equals(Scheme, "https", StringComparison.OrdinalIgnoreCase) ? 443 : 80;
+                        value = value.Slice(separator + SchemeSeparator.Length);
+                        _position = RawWritingPosition.Host;
+                    }
+                }
+                else if (_position == RawWritingPosition.Host)
+                {
+                    int separator = value.IndexOfAny(HostOrPort);
+                    if (separator == -1)
+                    {
+                        if (!HasPath)
+                        {
+                            Host += value.ToString();
+                            value = ReadOnlySpan<char>.Empty;
+                        }
+                        else
+                        {
+                            // All Host information must be written before Path information
+                            // If Path already has information, we transition to writing Path
+                            _position = RawWritingPosition.Path;
+                        }
+                    }
+                    else
+                    {
+                        Host += value.Slice(0, separator).ToString();
+                        _position = value[separator] == HostSeparator ? RawWritingPosition.Path : RawWritingPosition.Port;
+                        value = value.Slice(separator + 1);
+                    }
+                }
+                else if (_position == RawWritingPosition.Port)
+                {
+                    int separator = value.IndexOf(HostSeparator);
+                    if (separator == -1)
+                    {
+#if NETCOREAPP2_1_OR_GREATER
+                        Port = int.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture);
+#else
+                        Port = int.Parse(value.ToString(), CultureInfo.InvariantCulture);
+#endif
+                        value = ReadOnlySpan<char>.Empty;
+                    }
+                    else
+                    {
+#if NETCOREAPP2_1_OR_GREATER
+                        Port = int.Parse(value.Slice(0, separator), NumberStyles.Integer, CultureInfo.InvariantCulture);
+#else
+                        Port = int.Parse(value.Slice(0, separator).ToString(), CultureInfo.InvariantCulture);
+#endif
+                        value = value.Slice(separator + 1);
+                    }
+                    // Port cannot be split (like Host), so always transition to Path when Port is parsed
+                    _position = RawWritingPosition.Path;
+                }
+                else if (_position == RawWritingPosition.Path)
+                {
+                    int separator = value.IndexOf(QueryBeginSeparator);
+                    if (separator == -1)
+                    {
+                        AppendPath(value, escape);
+                        value = ReadOnlySpan<char>.Empty;
+                    }
+                    else
+                    {
+                        AppendPath(value.Slice(0, separator), escape);
+                        value = value.Slice(separator + 1);
+                        _position = RawWritingPosition.Query;
+                    }
+                }
+                else if (_position == RawWritingPosition.Query)
+                {
+                    int separator = value.IndexOf(QueryContinueSeparator);
+                    if (separator == 0)
+                    {
+                        value = value.Slice(1);
+                    }
+                    else if (separator == -1)
+                    {
+                        GetQueryParts(value, out var queryName, out var queryValue);
+                        AppendQuery(queryName, queryValue, escape);
+                        value = ReadOnlySpan<char>.Empty;
+                    }
+                    else
+                    {
+                        GetQueryParts(value.Slice(0, separator), out var queryName, out var queryValue);
+                        AppendQuery(queryName, queryValue, escape);
+                        value = value.Slice(separator + 1);
+                    }
+                }
+            }
+        }
+
+        private enum RawWritingPosition
+        {
+            Scheme,
+            Host,
+            Port,
+            Path,
+            Query
+        }
+
+        public void AppendRawNextLink(string nextLink, bool escape)
+        {
+            // If it is an absolute link, we use the nextLink as the entire url
+            if (nextLink.StartsWith(Uri.UriSchemeHttp, StringComparison.InvariantCultureIgnoreCase))
+            {
+                Reset(new Uri(nextLink));
+                return;
+            }
+
+            AppendRaw(nextLink, escape);
+        }
+
+        public void AppendQuery(string name, bool value, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value), escape);
+
+        public void AppendQuery(string name, float value, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value), escape);
+
+        public void AppendQuery(string name, DateTimeOffset value, string format, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value, format), escape);
+
+        public void AppendQuery(string name, TimeSpan value, string format, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value, format), escape);
+
+        public void AppendQuery(string name, double value, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value), escape);
+
+        public void AppendQuery(string name, decimal value, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value), escape);
+
+        public void AppendQuery(string name, int value, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value), escape);
+
+        public void AppendQuery(string name, long value, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value), escape);
+
+        public void AppendQuery(string name, TimeSpan value, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value), escape);
+
+        public void AppendQuery(string name, byte[] value, string format, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value, format), escape);
+
+        public void AppendQuery(string name, Guid value, bool escape = true) => AppendQuery(name, TypeFormatters.ConvertToString(value), escape);
+
+        public void AppendQueryDelimited<T>(string name, IEnumerable<T> value, string delimiter, string? format = null, bool escape = true)
+        {
+            delimiter ??= ",";
+            IEnumerable<string> stringValues = value.Select(v => TypeFormatters.ConvertToString(v, format));
+            AppendQuery(name, string.Join(delimiter, stringValues), escape);
+        }
+
+        public void AppendPathDelimited<T>(IEnumerable<T> value, string delimiter, string? format = null, bool escape = true)
+        {
+            delimiter ??= ",";
+            IEnumerable<string> stringValues = value.Select(v => TypeFormatters.ConvertToString(v, format));
+            AppendPath(string.Join(delimiter, stringValues), escape);
+        }
+    }
+}

package/dist/generator/net10.0/Shared/Core/RequestHeaderExtensions.cs

@@ -0,0 +1,132 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Xml;
+
+namespace Azure.Core
+{
+    internal static class RequestHeaderExtensions
+    {
+        public static void Add(this RequestHeaders headers, string name, bool value)
+        {
+            headers.Add(name, TypeFormatters.ToString(value));
+        }
+
+        public static void Add(this RequestHeaders headers, string name, float value)
+        {
+            headers.Add(name, value.ToString(TypeFormatters.DefaultNumberFormat, CultureInfo.InvariantCulture));
+        }
+
+        public static void Add(this RequestHeaders headers, string name, double value)
+        {
+            headers.Add(name, value.ToString(TypeFormatters.DefaultNumberFormat, CultureInfo.InvariantCulture));
+        }
+
+        public static void Add(this RequestHeaders headers, string name, int value)
+        {
+            headers.Add(name, value.ToString(TypeFormatters.DefaultNumberFormat, CultureInfo.InvariantCulture));
+        }
+
+        public static void Add(this RequestHeaders headers, string name, long value)
+        {
+            headers.Add(name, value.ToString(TypeFormatters.DefaultNumberFormat, CultureInfo.InvariantCulture));
+        }
+
+        public static void Add(this RequestHeaders headers, string name, DateTimeOffset value, string format)
+        {
+            headers.Add(name, TypeFormatters.ToString(value, format));
+        }
+
+        public static void Add(this RequestHeaders headers, string name, TimeSpan value, string format)
+        {
+            headers.Add(name, TypeFormatters.ToString(value, format));
+        }
+
+        public static void Add(this RequestHeaders headers, string name, Guid value)
+        {
+            headers.Add(name, value.ToString());
+        }
+
+        public static void Add(this RequestHeaders headers, string name, byte[] value, string format)
+        {
+            headers.Add(name, TypeFormatters.ToString(value, format));
+        }
+
+        public static void Add(this RequestHeaders headers, string name, BinaryData value, string format)
+        {
+            headers.Add(name, TypeFormatters.ToString(value.ToArray(), format));
+        }
+
+        public static void Add(this RequestHeaders headers, string prefix, IDictionary<string, string> headersToAdd)
+        {
+            foreach (var header in headersToAdd)
+            {
+                headers.Add(prefix + header.Key, header.Value);
+            }
+        }
+
+        public static void Add(this RequestHeaders headers, string name, ETag value)
+        {
+            headers.Add(name, value.ToString("H"));
+        }
+
+        public static void Add(this RequestHeaders headers, MatchConditions conditions)
+        {
+            if (conditions.IfMatch != null)
+            {
+                headers.Add("If-Match", conditions.IfMatch.Value);
+            }
+
+            if (conditions.IfNoneMatch != null)
+            {
+                headers.Add("If-None-Match", conditions.IfNoneMatch.Value);
+            }
+        }
+
+        public static void Add(this RequestHeaders headers, RequestConditions conditions, string format)
+        {
+            if (conditions.IfMatch != null)
+            {
+                headers.Add("If-Match", conditions.IfMatch.Value);
+            }
+
+            if (conditions.IfNoneMatch != null)
+            {
+                headers.Add("If-None-Match", conditions.IfNoneMatch.Value);
+            }
+
+            if (conditions.IfModifiedSince != null)
+            {
+                headers.Add("If-Modified-Since", conditions.IfModifiedSince.Value, format);
+            }
+
+            if (conditions.IfUnmodifiedSince != null)
+            {
+                headers.Add("If-Unmodified-Since", conditions.IfUnmodifiedSince.Value, format);
+            }
+        }
+
+        public static void AddDelimited<T>(this RequestHeaders headers, string name, IEnumerable<T> value, string delimiter)
+        {
+            headers.Add(name, string.Join(delimiter, value));
+        }
+
+        public static void AddDelimited<T>(this RequestHeaders headers, string name, IEnumerable<T> value, string delimiter, string format)
+        {
+            var stringValues = value.Select(v => TypeFormatters.ConvertToString(v, format));
+            headers.Add(name, string.Join(delimiter, stringValues));
+        }
+
+        public static void SetDelimited<T>(this RequestHeaders headers, string name, IEnumerable<T> value, string delimiter, string? format = default)
+        {
+            IEnumerable<string> stringValues = value.Select(v => TypeFormatters.ConvertToString(v, format));
+            headers.SetValue(name, string.Join(delimiter, stringValues));
+        }
+    }
+}

package/dist/generator/net10.0/Shared/Core/SequentialDelayStrategy.cs

@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+
+#nullable enable
+
+namespace Azure.Core
+{
+    /// <summary>
+    /// A delay strategy that uses a fixed sequence of delays with no jitter applied. This is used by management LROs.
+    /// </summary>
+    internal class SequentialDelayStrategy : DelayStrategy
+    {
+        private static readonly TimeSpan[] _pollingSequence = new TimeSpan[]
+        {
+            TimeSpan.FromSeconds(1),
+            TimeSpan.FromSeconds(1),
+            TimeSpan.FromSeconds(1),
+            TimeSpan.FromSeconds(2),
+            TimeSpan.FromSeconds(4),
+            TimeSpan.FromSeconds(8),
+            TimeSpan.FromSeconds(16),
+            TimeSpan.FromSeconds(32)
+        };
+        private static readonly TimeSpan _maxDelay = _pollingSequence[_pollingSequence.Length - 1];
+
+        public SequentialDelayStrategy() : base(_maxDelay, 0)
+        {
+        }
+
+        protected override TimeSpan GetNextDelayCore(Response? response, int retryNumber)
+        {
+            int index = retryNumber - 1;
+            return index >= _pollingSequence.Length ? _maxDelay : _pollingSequence[index];
+        }
+    }
+}