@azure-typespec/http-client-csharp-mgmt 1.0.0-alpha.20250409.15

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

@@ -0,0 +1,192 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#nullable enable
+
+using System;
+using System.Globalization;
+using System.IO;
+
+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);
+        }
+    }
+}

package/dist/generator/net8.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];
+        }
+    }
+}

package/dist/generator/net8.0/Shared/Core/TaskExtensions.cs

@@ -0,0 +1,313 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#nullable disable
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Azure.Core.Pipeline
+{
+    internal static class TaskExtensions
+    {
+        public static WithCancellationTaskAwaitable AwaitWithCancellation(this Task task, CancellationToken cancellationToken)
+            => new WithCancellationTaskAwaitable(task, cancellationToken);
+
+        public static WithCancellationTaskAwaitable<T> AwaitWithCancellation<T>(this Task<T> task, CancellationToken cancellationToken)
+            => new WithCancellationTaskAwaitable<T>(task, cancellationToken);
+
+        public static WithCancellationValueTaskAwaitable<T> AwaitWithCancellation<T>(this ValueTask<T> task, CancellationToken cancellationToken)
+            => new WithCancellationValueTaskAwaitable<T>(task, cancellationToken);
+
+        public static T EnsureCompleted<T>(this Task<T> task)
+        {
+#if DEBUG
+            VerifyTaskCompleted(task.IsCompleted);
+#endif
+#pragma warning disable AZC0102 // Do not use GetAwaiter().GetResult(). Use the TaskExtensions.EnsureCompleted() extension method instead.
+            return task.GetAwaiter().GetResult();
+#pragma warning restore AZC0102 // Do not use GetAwaiter().GetResult(). Use the TaskExtensions.EnsureCompleted() extension method instead.
+        }
+
+        public static void EnsureCompleted(this Task task)
+        {
+#if DEBUG
+            VerifyTaskCompleted(task.IsCompleted);
+#endif
+#pragma warning disable AZC0102 // Do not use GetAwaiter().GetResult(). Use the TaskExtensions.EnsureCompleted() extension method instead.
+            task.GetAwaiter().GetResult();
+#pragma warning restore AZC0102 // Do not use GetAwaiter().GetResult(). Use the TaskExtensions.EnsureCompleted() extension method instead.
+        }
+
+        public static T EnsureCompleted<T>(this ValueTask<T> task)
+        {
+#if DEBUG
+            VerifyTaskCompleted(task.IsCompleted);
+#endif
+#pragma warning disable AZC0102 // Do not use GetAwaiter().GetResult(). Use the TaskExtensions.EnsureCompleted() extension method instead.
+            return task.GetAwaiter().GetResult();
+#pragma warning restore AZC0102 // Do not use GetAwaiter().GetResult(). Use the TaskExtensions.EnsureCompleted() extension method instead.
+        }
+
+        public static void EnsureCompleted(this ValueTask task)
+        {
+#if DEBUG
+            VerifyTaskCompleted(task.IsCompleted);
+#endif
+#pragma warning disable AZC0102 // Do not use GetAwaiter().GetResult(). Use the TaskExtensions.EnsureCompleted() extension method instead.
+            task.GetAwaiter().GetResult();
+#pragma warning restore AZC0102 // Do not use GetAwaiter().GetResult(). Use the TaskExtensions.EnsureCompleted() extension method instead.
+        }
+
+        public static Enumerable<T> EnsureSyncEnumerable<T>(this IAsyncEnumerable<T> asyncEnumerable) => new Enumerable<T>(asyncEnumerable);
+
+        public static ConfiguredValueTaskAwaitable<T> EnsureCompleted<T>(this ConfiguredValueTaskAwaitable<T> awaitable, bool async)
+        {
+            if (!async)
+            {
+#if DEBUG
+                VerifyTaskCompleted(awaitable.GetAwaiter().IsCompleted);
+#endif
+            }
+            return awaitable;
+        }
+
+        public static ConfiguredValueTaskAwaitable EnsureCompleted(this ConfiguredValueTaskAwaitable awaitable, bool async)
+        {
+            if (!async)
+            {
+#if DEBUG
+                VerifyTaskCompleted(awaitable.GetAwaiter().IsCompleted);
+#endif
+            }
+            return awaitable;
+        }
+
+        [Conditional("DEBUG")]
+        private static void VerifyTaskCompleted(bool isCompleted)
+        {
+            if (!isCompleted)
+            {
+                if (Debugger.IsAttached)
+                {
+                    Debugger.Break();
+                }
+                // Throw an InvalidOperationException instead of using
+                // Debug.Assert because that brings down nUnit immediately
+                throw new InvalidOperationException("Task is not completed");
+            }
+        }
+
+        /// <summary>
+        /// Both <see cref="Enumerable{T}"/> and <see cref="Enumerator{T}"/> are defined as public structs so that foreach can use duck typing
+        /// to call <see cref="Enumerable{T}.GetEnumerator"/> and avoid heap memory allocation.
+        /// Please don't delete this method and don't make these types private.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public readonly struct Enumerable<T> : IEnumerable<T>
+        {
+            private readonly IAsyncEnumerable<T> _asyncEnumerable;
+
+            public Enumerable(IAsyncEnumerable<T> asyncEnumerable) => _asyncEnumerable = asyncEnumerable;
+
+            public Enumerator<T> GetEnumerator() => new Enumerator<T>(_asyncEnumerable.GetAsyncEnumerator());
+
+            IEnumerator<T> IEnumerable<T>.GetEnumerator() => new Enumerator<T>(_asyncEnumerable.GetAsyncEnumerator());
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
+        public readonly struct Enumerator<T> : IEnumerator<T>
+        {
+            private readonly IAsyncEnumerator<T> _asyncEnumerator;
+
+            public Enumerator(IAsyncEnumerator<T> asyncEnumerator) => _asyncEnumerator = asyncEnumerator;
+
+#pragma warning disable AZC0107 // Do not call public asynchronous method in synchronous scope.
+            public bool MoveNext() => _asyncEnumerator.MoveNextAsync().EnsureCompleted();
+#pragma warning restore AZC0107 // Do not call public asynchronous method in synchronous scope.
+
+            public void Reset() => throw new NotSupportedException($"{GetType()} is a synchronous wrapper for {_asyncEnumerator.GetType()} async enumerator, which can't be reset, so IEnumerable.Reset() calls aren't supported.");
+
+            public T Current => _asyncEnumerator.Current;
+
+            object IEnumerator.Current => Current;
+
+#pragma warning disable AZC0107 // Do not call public asynchronous method in synchronous scope.
+            public void Dispose() => _asyncEnumerator.DisposeAsync().EnsureCompleted();
+#pragma warning restore AZC0107 // Do not call public asynchronous method in synchronous scope.
+        }
+
+        public readonly struct WithCancellationTaskAwaitable
+        {
+            private readonly CancellationToken _cancellationToken;
+            private readonly ConfiguredTaskAwaitable _awaitable;
+
+            public WithCancellationTaskAwaitable(Task task, CancellationToken cancellationToken)
+            {
+                _awaitable = task.ConfigureAwait(false);
+                _cancellationToken = cancellationToken;
+            }
+
+            public WithCancellationTaskAwaiter GetAwaiter() => new WithCancellationTaskAwaiter(_awaitable.GetAwaiter(), _cancellationToken);
+        }
+
+        public readonly struct WithCancellationTaskAwaitable<T>
+        {
+            private readonly CancellationToken _cancellationToken;
+            private readonly ConfiguredTaskAwaitable<T> _awaitable;
+
+            public WithCancellationTaskAwaitable(Task<T> task, CancellationToken cancellationToken)
+            {
+                _awaitable = task.ConfigureAwait(false);
+                _cancellationToken = cancellationToken;
+            }
+
+            public WithCancellationTaskAwaiter<T> GetAwaiter() => new WithCancellationTaskAwaiter<T>(_awaitable.GetAwaiter(), _cancellationToken);
+        }
+
+        public readonly struct WithCancellationValueTaskAwaitable<T>
+        {
+            private readonly CancellationToken _cancellationToken;
+            private readonly ConfiguredValueTaskAwaitable<T> _awaitable;
+
+            public WithCancellationValueTaskAwaitable(ValueTask<T> task, CancellationToken cancellationToken)
+            {
+                _awaitable = task.ConfigureAwait(false);
+                _cancellationToken = cancellationToken;
+            }
+
+            public WithCancellationValueTaskAwaiter<T> GetAwaiter() => new WithCancellationValueTaskAwaiter<T>(_awaitable.GetAwaiter(), _cancellationToken);
+        }
+
+        public readonly struct WithCancellationTaskAwaiter : ICriticalNotifyCompletion
+        {
+            private readonly CancellationToken _cancellationToken;
+            private readonly ConfiguredTaskAwaitable.ConfiguredTaskAwaiter _taskAwaiter;
+
+            public WithCancellationTaskAwaiter(ConfiguredTaskAwaitable.ConfiguredTaskAwaiter awaiter, CancellationToken cancellationToken)
+            {
+                _taskAwaiter = awaiter;
+                _cancellationToken = cancellationToken;
+            }
+
+            public bool IsCompleted => _taskAwaiter.IsCompleted || _cancellationToken.IsCancellationRequested;
+
+            public void OnCompleted(Action continuation) => _taskAwaiter.OnCompleted(WrapContinuation(continuation));
+
+            public void UnsafeOnCompleted(Action continuation) => _taskAwaiter.UnsafeOnCompleted(WrapContinuation(continuation));
+
+            public void GetResult()
+            {
+                Debug.Assert(IsCompleted);
+                if (!_taskAwaiter.IsCompleted)
+                {
+                    _cancellationToken.ThrowIfCancellationRequested();
+                }
+                _taskAwaiter.GetResult();
+            }
+
+            private Action WrapContinuation(in Action originalContinuation)
+                => _cancellationToken.CanBeCanceled
+                    ? new WithCancellationContinuationWrapper(originalContinuation, _cancellationToken).Continuation
+                    : originalContinuation;
+        }
+
+        public readonly struct WithCancellationTaskAwaiter<T> : ICriticalNotifyCompletion
+        {
+            private readonly CancellationToken _cancellationToken;
+            private readonly ConfiguredTaskAwaitable<T>.ConfiguredTaskAwaiter _taskAwaiter;
+
+            public WithCancellationTaskAwaiter(ConfiguredTaskAwaitable<T>.ConfiguredTaskAwaiter awaiter, CancellationToken cancellationToken)
+            {
+                _taskAwaiter = awaiter;
+                _cancellationToken = cancellationToken;
+            }
+
+            public bool IsCompleted => _taskAwaiter.IsCompleted || _cancellationToken.IsCancellationRequested;
+
+            public void OnCompleted(Action continuation) => _taskAwaiter.OnCompleted(WrapContinuation(continuation));
+
+            public void UnsafeOnCompleted(Action continuation) => _taskAwaiter.UnsafeOnCompleted(WrapContinuation(continuation));
+
+            public T GetResult()
+            {
+                Debug.Assert(IsCompleted);
+                if (!_taskAwaiter.IsCompleted)
+                {
+                    _cancellationToken.ThrowIfCancellationRequested();
+                }
+                return _taskAwaiter.GetResult();
+            }
+
+            private Action WrapContinuation(in Action originalContinuation)
+                => _cancellationToken.CanBeCanceled
+                    ? new WithCancellationContinuationWrapper(originalContinuation, _cancellationToken).Continuation
+                    : originalContinuation;
+        }
+
+        public readonly struct WithCancellationValueTaskAwaiter<T> : ICriticalNotifyCompletion
+        {
+            private readonly CancellationToken _cancellationToken;
+            private readonly ConfiguredValueTaskAwaitable<T>.ConfiguredValueTaskAwaiter _taskAwaiter;
+
+            public WithCancellationValueTaskAwaiter(ConfiguredValueTaskAwaitable<T>.ConfiguredValueTaskAwaiter awaiter, CancellationToken cancellationToken)
+            {
+                _taskAwaiter = awaiter;
+                _cancellationToken = cancellationToken;
+            }
+
+            public bool IsCompleted => _taskAwaiter.IsCompleted || _cancellationToken.IsCancellationRequested;
+
+            public void OnCompleted(Action continuation) => _taskAwaiter.OnCompleted(WrapContinuation(continuation));
+
+            public void UnsafeOnCompleted(Action continuation) => _taskAwaiter.UnsafeOnCompleted(WrapContinuation(continuation));
+
+            public T GetResult()
+            {
+                Debug.Assert(IsCompleted);
+                if (!_taskAwaiter.IsCompleted)
+                {
+                    _cancellationToken.ThrowIfCancellationRequested();
+                }
+                return _taskAwaiter.GetResult();
+            }
+
+            private Action WrapContinuation(in Action originalContinuation)
+                => _cancellationToken.CanBeCanceled
+                    ? new WithCancellationContinuationWrapper(originalContinuation, _cancellationToken).Continuation
+                    : originalContinuation;
+        }
+
+        private class WithCancellationContinuationWrapper
+        {
+            private Action _originalContinuation;
+            private readonly CancellationTokenRegistration _registration;
+
+            public WithCancellationContinuationWrapper(Action originalContinuation, CancellationToken cancellationToken)
+            {
+                Action continuation = ContinuationImplementation;
+                _originalContinuation = originalContinuation;
+                _registration = cancellationToken.Register(continuation);
+                Continuation = continuation;
+            }
+
+            public Action Continuation { get; }
+
+            private void ContinuationImplementation()
+            {
+                Action originalContinuation = Interlocked.Exchange(ref _originalContinuation, null);
+                if (originalContinuation != null)
+                {
+                    _registration.Dispose();
+                    originalContinuation();
+                }
+            }
+        }
+    }
+}

package/dist/generator/net8.0/Shared/Core/VoidValue.cs

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Text.Json;
+
+namespace Azure.Core
+{
+    internal readonly struct VoidValue { }
+}