< Summary

Class:Azure.ResourceManager.Network.RouteFiltersRestOperations
Assembly:Azure.ResourceManager.Network
File(s):C:\Git\azure-sdk-for-net\sdk\network\Azure.ResourceManager.Network\src\Generated\RouteFiltersRestOperations.cs
Covered lines:79
Uncovered lines:248
Coverable lines:327
Total lines:732
Line coverage:24.1% (79 of 327)
Covered branches:19
Total branches:126
Branch coverage:15% (19 of 126)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-88.89%50%
CreateDeleteRequest(...)-0%100%
DeleteAsync()-0%0%
Delete(...)-0%0%
CreateGetRequest(...)-93.75%50%
GetAsync()-73.33%50%
Get(...)-73.33%50%
CreateCreateOrUpdateRequest(...)-100%100%
CreateOrUpdateAsync()-66.67%50%
CreateOrUpdate(...)-66.67%50%
CreateUpdateTagsRequest(...)-0%100%
UpdateTagsAsync()-0%0%
UpdateTags(...)-0%0%
CreateListByResourceGroupRequest(...)-0%100%
ListByResourceGroupAsync()-0%0%
ListByResourceGroup(...)-0%0%
CreateListRequest()-0%100%
ListAsync()-0%0%
List(...)-0%0%
CreateListByResourceGroupNextPageRequest(...)-0%100%
ListByResourceGroupNextPageAsync()-0%0%
ListByResourceGroupNextPage(...)-0%0%
CreateListNextPageRequest(...)-0%100%
ListNextPageAsync()-0%0%
ListNextPage(...)-0%0%

File(s)

C:\Git\azure-sdk-for-net\sdk\network\Azure.ResourceManager.Network\src\Generated\RouteFiltersRestOperations.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4// <auto-generated/>
 5
 6#nullable disable
 7
 8using System;
 9using System.Text.Json;
 10using System.Threading;
 11using System.Threading.Tasks;
 12using Azure;
 13using Azure.Core;
 14using Azure.Core.Pipeline;
 15using Azure.ResourceManager.Network.Models;
 16
 17namespace Azure.ResourceManager.Network
 18{
 19    internal partial class RouteFiltersRestOperations
 20    {
 21        private string subscriptionId;
 22        private Uri endpoint;
 23        private ClientDiagnostics _clientDiagnostics;
 24        private HttpPipeline _pipeline;
 25
 26        /// <summary> Initializes a new instance of RouteFiltersRestOperations. </summary>
 27        /// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
 28        /// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
 29        /// <param name="subscriptionId"> The subscription credentials which uniquely identify the Microsoft Azure subsc
 30        /// <param name="endpoint"> server parameter. </param>
 31        /// <exception cref="ArgumentNullException"> This occurs when one of the required arguments is null. </exception
 2832        public RouteFiltersRestOperations(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string subscriptio
 33        {
 2834            if (subscriptionId == null)
 35            {
 036                throw new ArgumentNullException(nameof(subscriptionId));
 37            }
 2838            endpoint ??= new Uri("https://management.azure.com");
 39
 2840            this.subscriptionId = subscriptionId;
 2841            this.endpoint = endpoint;
 2842            _clientDiagnostics = clientDiagnostics;
 2843            _pipeline = pipeline;
 2844        }
 45
 46        internal HttpMessage CreateDeleteRequest(string resourceGroupName, string routeFilterName)
 47        {
 048            var message = _pipeline.CreateMessage();
 049            var request = message.Request;
 050            request.Method = RequestMethod.Delete;
 051            var uri = new RawRequestUriBuilder();
 052            uri.Reset(endpoint);
 053            uri.AppendPath("/subscriptions/", false);
 054            uri.AppendPath(subscriptionId, true);
 055            uri.AppendPath("/resourceGroups/", false);
 056            uri.AppendPath(resourceGroupName, true);
 057            uri.AppendPath("/providers/Microsoft.Network/routeFilters/", false);
 058            uri.AppendPath(routeFilterName, true);
 059            uri.AppendQuery("api-version", "2020-04-01", true);
 060            request.Uri = uri;
 061            return message;
 62        }
 63
 64        /// <summary> Deletes the specified route filter. </summary>
 65        /// <param name="resourceGroupName"> The name of the resource group. </param>
 66        /// <param name="routeFilterName"> The name of the route filter. </param>
 67        /// <param name="cancellationToken"> The cancellation token to use. </param>
 68        public async Task<Response> DeleteAsync(string resourceGroupName, string routeFilterName, CancellationToken canc
 69        {
 070            if (resourceGroupName == null)
 71            {
 072                throw new ArgumentNullException(nameof(resourceGroupName));
 73            }
 074            if (routeFilterName == null)
 75            {
 076                throw new ArgumentNullException(nameof(routeFilterName));
 77            }
 78
 079            using var message = CreateDeleteRequest(resourceGroupName, routeFilterName);
 080            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 081            switch (message.Response.Status)
 82            {
 83                case 200:
 84                case 202:
 85                case 204:
 086                    return message.Response;
 87                default:
 088                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 89            }
 090        }
 91
 92        /// <summary> Deletes the specified route filter. </summary>
 93        /// <param name="resourceGroupName"> The name of the resource group. </param>
 94        /// <param name="routeFilterName"> The name of the route filter. </param>
 95        /// <param name="cancellationToken"> The cancellation token to use. </param>
 96        public Response Delete(string resourceGroupName, string routeFilterName, CancellationToken cancellationToken = d
 97        {
 098            if (resourceGroupName == null)
 99            {
 0100                throw new ArgumentNullException(nameof(resourceGroupName));
 101            }
 0102            if (routeFilterName == null)
 103            {
 0104                throw new ArgumentNullException(nameof(routeFilterName));
 105            }
 106
 0107            using var message = CreateDeleteRequest(resourceGroupName, routeFilterName);
 0108            _pipeline.Send(message, cancellationToken);
 0109            switch (message.Response.Status)
 110            {
 111                case 200:
 112                case 202:
 113                case 204:
 0114                    return message.Response;
 115                default:
 0116                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 117            }
 0118        }
 119
 120        internal HttpMessage CreateGetRequest(string resourceGroupName, string routeFilterName, string expand)
 121        {
 16122            var message = _pipeline.CreateMessage();
 16123            var request = message.Request;
 16124            request.Method = RequestMethod.Get;
 16125            var uri = new RawRequestUriBuilder();
 16126            uri.Reset(endpoint);
 16127            uri.AppendPath("/subscriptions/", false);
 16128            uri.AppendPath(subscriptionId, true);
 16129            uri.AppendPath("/resourceGroups/", false);
 16130            uri.AppendPath(resourceGroupName, true);
 16131            uri.AppendPath("/providers/Microsoft.Network/routeFilters/", false);
 16132            uri.AppendPath(routeFilterName, true);
 16133            uri.AppendQuery("api-version", "2020-04-01", true);
 16134            if (expand != null)
 135            {
 0136                uri.AppendQuery("$expand", expand, true);
 137            }
 16138            request.Uri = uri;
 16139            return message;
 140        }
 141
 142        /// <summary> Gets the specified route filter. </summary>
 143        /// <param name="resourceGroupName"> The name of the resource group. </param>
 144        /// <param name="routeFilterName"> The name of the route filter. </param>
 145        /// <param name="expand"> Expands referenced express route bgp peering resources. </param>
 146        /// <param name="cancellationToken"> The cancellation token to use. </param>
 147        public async Task<Response<RouteFilter>> GetAsync(string resourceGroupName, string routeFilterName, string expan
 148        {
 8149            if (resourceGroupName == null)
 150            {
 0151                throw new ArgumentNullException(nameof(resourceGroupName));
 152            }
 8153            if (routeFilterName == null)
 154            {
 0155                throw new ArgumentNullException(nameof(routeFilterName));
 156            }
 157
 8158            using var message = CreateGetRequest(resourceGroupName, routeFilterName, expand);
 8159            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 8160            switch (message.Response.Status)
 161            {
 162                case 200:
 163                    {
 8164                        RouteFilter value = default;
 8165                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 8166                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 167                        {
 0168                            value = null;
 169                        }
 170                        else
 171                        {
 8172                            value = RouteFilter.DeserializeRouteFilter(document.RootElement);
 173                        }
 8174                        return Response.FromValue(value, message.Response);
 175                    }
 176                default:
 0177                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 178            }
 8179        }
 180
 181        /// <summary> Gets the specified route filter. </summary>
 182        /// <param name="resourceGroupName"> The name of the resource group. </param>
 183        /// <param name="routeFilterName"> The name of the route filter. </param>
 184        /// <param name="expand"> Expands referenced express route bgp peering resources. </param>
 185        /// <param name="cancellationToken"> The cancellation token to use. </param>
 186        public Response<RouteFilter> Get(string resourceGroupName, string routeFilterName, string expand = null, Cancell
 187        {
 8188            if (resourceGroupName == null)
 189            {
 0190                throw new ArgumentNullException(nameof(resourceGroupName));
 191            }
 8192            if (routeFilterName == null)
 193            {
 0194                throw new ArgumentNullException(nameof(routeFilterName));
 195            }
 196
 8197            using var message = CreateGetRequest(resourceGroupName, routeFilterName, expand);
 8198            _pipeline.Send(message, cancellationToken);
 8199            switch (message.Response.Status)
 200            {
 201                case 200:
 202                    {
 8203                        RouteFilter value = default;
 8204                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 8205                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 206                        {
 0207                            value = null;
 208                        }
 209                        else
 210                        {
 8211                            value = RouteFilter.DeserializeRouteFilter(document.RootElement);
 212                        }
 8213                        return Response.FromValue(value, message.Response);
 214                    }
 215                default:
 0216                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 217            }
 8218        }
 219
 220        internal HttpMessage CreateCreateOrUpdateRequest(string resourceGroupName, string routeFilterName, RouteFilter r
 221        {
 24222            var message = _pipeline.CreateMessage();
 24223            var request = message.Request;
 24224            request.Method = RequestMethod.Put;
 24225            var uri = new RawRequestUriBuilder();
 24226            uri.Reset(endpoint);
 24227            uri.AppendPath("/subscriptions/", false);
 24228            uri.AppendPath(subscriptionId, true);
 24229            uri.AppendPath("/resourceGroups/", false);
 24230            uri.AppendPath(resourceGroupName, true);
 24231            uri.AppendPath("/providers/Microsoft.Network/routeFilters/", false);
 24232            uri.AppendPath(routeFilterName, true);
 24233            uri.AppendQuery("api-version", "2020-04-01", true);
 24234            request.Uri = uri;
 24235            request.Headers.Add("Content-Type", "application/json");
 24236            var content = new Utf8JsonRequestContent();
 24237            content.JsonWriter.WriteObjectValue(routeFilterParameters);
 24238            request.Content = content;
 24239            return message;
 240        }
 241
 242        /// <summary> Creates or updates a route filter in a specified resource group. </summary>
 243        /// <param name="resourceGroupName"> The name of the resource group. </param>
 244        /// <param name="routeFilterName"> The name of the route filter. </param>
 245        /// <param name="routeFilterParameters"> Parameters supplied to the create or update route filter operation. </p
 246        /// <param name="cancellationToken"> The cancellation token to use. </param>
 247        public async Task<Response> CreateOrUpdateAsync(string resourceGroupName, string routeFilterName, RouteFilter ro
 248        {
 6249            if (resourceGroupName == null)
 250            {
 0251                throw new ArgumentNullException(nameof(resourceGroupName));
 252            }
 6253            if (routeFilterName == null)
 254            {
 0255                throw new ArgumentNullException(nameof(routeFilterName));
 256            }
 6257            if (routeFilterParameters == null)
 258            {
 0259                throw new ArgumentNullException(nameof(routeFilterParameters));
 260            }
 261
 6262            using var message = CreateCreateOrUpdateRequest(resourceGroupName, routeFilterName, routeFilterParameters);
 6263            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 6264            switch (message.Response.Status)
 265            {
 266                case 200:
 267                case 201:
 6268                    return message.Response;
 269                default:
 0270                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 271            }
 6272        }
 273
 274        /// <summary> Creates or updates a route filter in a specified resource group. </summary>
 275        /// <param name="resourceGroupName"> The name of the resource group. </param>
 276        /// <param name="routeFilterName"> The name of the route filter. </param>
 277        /// <param name="routeFilterParameters"> Parameters supplied to the create or update route filter operation. </p
 278        /// <param name="cancellationToken"> The cancellation token to use. </param>
 279        public Response CreateOrUpdate(string resourceGroupName, string routeFilterName, RouteFilter routeFilterParamete
 280        {
 6281            if (resourceGroupName == null)
 282            {
 0283                throw new ArgumentNullException(nameof(resourceGroupName));
 284            }
 6285            if (routeFilterName == null)
 286            {
 0287                throw new ArgumentNullException(nameof(routeFilterName));
 288            }
 6289            if (routeFilterParameters == null)
 290            {
 0291                throw new ArgumentNullException(nameof(routeFilterParameters));
 292            }
 293
 6294            using var message = CreateCreateOrUpdateRequest(resourceGroupName, routeFilterName, routeFilterParameters);
 6295            _pipeline.Send(message, cancellationToken);
 6296            switch (message.Response.Status)
 297            {
 298                case 200:
 299                case 201:
 6300                    return message.Response;
 301                default:
 0302                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 303            }
 6304        }
 305
 306        internal HttpMessage CreateUpdateTagsRequest(string resourceGroupName, string routeFilterName, TagsObject parame
 307        {
 0308            var message = _pipeline.CreateMessage();
 0309            var request = message.Request;
 0310            request.Method = RequestMethod.Patch;
 0311            var uri = new RawRequestUriBuilder();
 0312            uri.Reset(endpoint);
 0313            uri.AppendPath("/subscriptions/", false);
 0314            uri.AppendPath(subscriptionId, true);
 0315            uri.AppendPath("/resourceGroups/", false);
 0316            uri.AppendPath(resourceGroupName, true);
 0317            uri.AppendPath("/providers/Microsoft.Network/routeFilters/", false);
 0318            uri.AppendPath(routeFilterName, true);
 0319            uri.AppendQuery("api-version", "2020-04-01", true);
 0320            request.Uri = uri;
 0321            request.Headers.Add("Content-Type", "application/json");
 0322            var content = new Utf8JsonRequestContent();
 0323            content.JsonWriter.WriteObjectValue(parameters);
 0324            request.Content = content;
 0325            return message;
 326        }
 327
 328        /// <summary> Updates tags of a route filter. </summary>
 329        /// <param name="resourceGroupName"> The name of the resource group. </param>
 330        /// <param name="routeFilterName"> The name of the route filter. </param>
 331        /// <param name="parameters"> Parameters supplied to update route filter tags. </param>
 332        /// <param name="cancellationToken"> The cancellation token to use. </param>
 333        public async Task<Response<RouteFilter>> UpdateTagsAsync(string resourceGroupName, string routeFilterName, TagsO
 334        {
 0335            if (resourceGroupName == null)
 336            {
 0337                throw new ArgumentNullException(nameof(resourceGroupName));
 338            }
 0339            if (routeFilterName == null)
 340            {
 0341                throw new ArgumentNullException(nameof(routeFilterName));
 342            }
 0343            if (parameters == null)
 344            {
 0345                throw new ArgumentNullException(nameof(parameters));
 346            }
 347
 0348            using var message = CreateUpdateTagsRequest(resourceGroupName, routeFilterName, parameters);
 0349            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0350            switch (message.Response.Status)
 351            {
 352                case 200:
 353                    {
 0354                        RouteFilter value = default;
 0355                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0356                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 357                        {
 0358                            value = null;
 359                        }
 360                        else
 361                        {
 0362                            value = RouteFilter.DeserializeRouteFilter(document.RootElement);
 363                        }
 0364                        return Response.FromValue(value, message.Response);
 365                    }
 366                default:
 0367                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 368            }
 0369        }
 370
 371        /// <summary> Updates tags of a route filter. </summary>
 372        /// <param name="resourceGroupName"> The name of the resource group. </param>
 373        /// <param name="routeFilterName"> The name of the route filter. </param>
 374        /// <param name="parameters"> Parameters supplied to update route filter tags. </param>
 375        /// <param name="cancellationToken"> The cancellation token to use. </param>
 376        public Response<RouteFilter> UpdateTags(string resourceGroupName, string routeFilterName, TagsObject parameters,
 377        {
 0378            if (resourceGroupName == null)
 379            {
 0380                throw new ArgumentNullException(nameof(resourceGroupName));
 381            }
 0382            if (routeFilterName == null)
 383            {
 0384                throw new ArgumentNullException(nameof(routeFilterName));
 385            }
 0386            if (parameters == null)
 387            {
 0388                throw new ArgumentNullException(nameof(parameters));
 389            }
 390
 0391            using var message = CreateUpdateTagsRequest(resourceGroupName, routeFilterName, parameters);
 0392            _pipeline.Send(message, cancellationToken);
 0393            switch (message.Response.Status)
 394            {
 395                case 200:
 396                    {
 0397                        RouteFilter value = default;
 0398                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0399                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 400                        {
 0401                            value = null;
 402                        }
 403                        else
 404                        {
 0405                            value = RouteFilter.DeserializeRouteFilter(document.RootElement);
 406                        }
 0407                        return Response.FromValue(value, message.Response);
 408                    }
 409                default:
 0410                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 411            }
 0412        }
 413
 414        internal HttpMessage CreateListByResourceGroupRequest(string resourceGroupName)
 415        {
 0416            var message = _pipeline.CreateMessage();
 0417            var request = message.Request;
 0418            request.Method = RequestMethod.Get;
 0419            var uri = new RawRequestUriBuilder();
 0420            uri.Reset(endpoint);
 0421            uri.AppendPath("/subscriptions/", false);
 0422            uri.AppendPath(subscriptionId, true);
 0423            uri.AppendPath("/resourceGroups/", false);
 0424            uri.AppendPath(resourceGroupName, true);
 0425            uri.AppendPath("/providers/Microsoft.Network/routeFilters", false);
 0426            uri.AppendQuery("api-version", "2020-04-01", true);
 0427            request.Uri = uri;
 0428            return message;
 429        }
 430
 431        /// <summary> Gets all route filters in a resource group. </summary>
 432        /// <param name="resourceGroupName"> The name of the resource group. </param>
 433        /// <param name="cancellationToken"> The cancellation token to use. </param>
 434        public async Task<Response<RouteFilterListResult>> ListByResourceGroupAsync(string resourceGroupName, Cancellati
 435        {
 0436            if (resourceGroupName == null)
 437            {
 0438                throw new ArgumentNullException(nameof(resourceGroupName));
 439            }
 440
 0441            using var message = CreateListByResourceGroupRequest(resourceGroupName);
 0442            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0443            switch (message.Response.Status)
 444            {
 445                case 200:
 446                    {
 0447                        RouteFilterListResult value = default;
 0448                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0449                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 450                        {
 0451                            value = null;
 452                        }
 453                        else
 454                        {
 0455                            value = RouteFilterListResult.DeserializeRouteFilterListResult(document.RootElement);
 456                        }
 0457                        return Response.FromValue(value, message.Response);
 458                    }
 459                default:
 0460                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 461            }
 0462        }
 463
 464        /// <summary> Gets all route filters in a resource group. </summary>
 465        /// <param name="resourceGroupName"> The name of the resource group. </param>
 466        /// <param name="cancellationToken"> The cancellation token to use. </param>
 467        public Response<RouteFilterListResult> ListByResourceGroup(string resourceGroupName, CancellationToken cancellat
 468        {
 0469            if (resourceGroupName == null)
 470            {
 0471                throw new ArgumentNullException(nameof(resourceGroupName));
 472            }
 473
 0474            using var message = CreateListByResourceGroupRequest(resourceGroupName);
 0475            _pipeline.Send(message, cancellationToken);
 0476            switch (message.Response.Status)
 477            {
 478                case 200:
 479                    {
 0480                        RouteFilterListResult value = default;
 0481                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0482                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 483                        {
 0484                            value = null;
 485                        }
 486                        else
 487                        {
 0488                            value = RouteFilterListResult.DeserializeRouteFilterListResult(document.RootElement);
 489                        }
 0490                        return Response.FromValue(value, message.Response);
 491                    }
 492                default:
 0493                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 494            }
 0495        }
 496
 497        internal HttpMessage CreateListRequest()
 498        {
 0499            var message = _pipeline.CreateMessage();
 0500            var request = message.Request;
 0501            request.Method = RequestMethod.Get;
 0502            var uri = new RawRequestUriBuilder();
 0503            uri.Reset(endpoint);
 0504            uri.AppendPath("/subscriptions/", false);
 0505            uri.AppendPath(subscriptionId, true);
 0506            uri.AppendPath("/providers/Microsoft.Network/routeFilters", false);
 0507            uri.AppendQuery("api-version", "2020-04-01", true);
 0508            request.Uri = uri;
 0509            return message;
 510        }
 511
 512        /// <summary> Gets all route filters in a subscription. </summary>
 513        /// <param name="cancellationToken"> The cancellation token to use. </param>
 514        public async Task<Response<RouteFilterListResult>> ListAsync(CancellationToken cancellationToken = default)
 515        {
 0516            using var message = CreateListRequest();
 0517            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0518            switch (message.Response.Status)
 519            {
 520                case 200:
 521                    {
 0522                        RouteFilterListResult value = default;
 0523                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0524                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 525                        {
 0526                            value = null;
 527                        }
 528                        else
 529                        {
 0530                            value = RouteFilterListResult.DeserializeRouteFilterListResult(document.RootElement);
 531                        }
 0532                        return Response.FromValue(value, message.Response);
 533                    }
 534                default:
 0535                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 536            }
 0537        }
 538
 539        /// <summary> Gets all route filters in a subscription. </summary>
 540        /// <param name="cancellationToken"> The cancellation token to use. </param>
 541        public Response<RouteFilterListResult> List(CancellationToken cancellationToken = default)
 542        {
 0543            using var message = CreateListRequest();
 0544            _pipeline.Send(message, cancellationToken);
 0545            switch (message.Response.Status)
 546            {
 547                case 200:
 548                    {
 0549                        RouteFilterListResult value = default;
 0550                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0551                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 552                        {
 0553                            value = null;
 554                        }
 555                        else
 556                        {
 0557                            value = RouteFilterListResult.DeserializeRouteFilterListResult(document.RootElement);
 558                        }
 0559                        return Response.FromValue(value, message.Response);
 560                    }
 561                default:
 0562                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 563            }
 0564        }
 565
 566        internal HttpMessage CreateListByResourceGroupNextPageRequest(string nextLink, string resourceGroupName)
 567        {
 0568            var message = _pipeline.CreateMessage();
 0569            var request = message.Request;
 0570            request.Method = RequestMethod.Get;
 0571            var uri = new RawRequestUriBuilder();
 0572            uri.Reset(endpoint);
 0573            uri.AppendRawNextLink(nextLink, false);
 0574            request.Uri = uri;
 0575            return message;
 576        }
 577
 578        /// <summary> Gets all route filters in a resource group. </summary>
 579        /// <param name="nextLink"> The URL to the next page of results. </param>
 580        /// <param name="resourceGroupName"> The name of the resource group. </param>
 581        /// <param name="cancellationToken"> The cancellation token to use. </param>
 582        public async Task<Response<RouteFilterListResult>> ListByResourceGroupNextPageAsync(string nextLink, string reso
 583        {
 0584            if (nextLink == null)
 585            {
 0586                throw new ArgumentNullException(nameof(nextLink));
 587            }
 0588            if (resourceGroupName == null)
 589            {
 0590                throw new ArgumentNullException(nameof(resourceGroupName));
 591            }
 592
 0593            using var message = CreateListByResourceGroupNextPageRequest(nextLink, resourceGroupName);
 0594            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0595            switch (message.Response.Status)
 596            {
 597                case 200:
 598                    {
 0599                        RouteFilterListResult value = default;
 0600                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0601                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 602                        {
 0603                            value = null;
 604                        }
 605                        else
 606                        {
 0607                            value = RouteFilterListResult.DeserializeRouteFilterListResult(document.RootElement);
 608                        }
 0609                        return Response.FromValue(value, message.Response);
 610                    }
 611                default:
 0612                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 613            }
 0614        }
 615
 616        /// <summary> Gets all route filters in a resource group. </summary>
 617        /// <param name="nextLink"> The URL to the next page of results. </param>
 618        /// <param name="resourceGroupName"> The name of the resource group. </param>
 619        /// <param name="cancellationToken"> The cancellation token to use. </param>
 620        public Response<RouteFilterListResult> ListByResourceGroupNextPage(string nextLink, string resourceGroupName, Ca
 621        {
 0622            if (nextLink == null)
 623            {
 0624                throw new ArgumentNullException(nameof(nextLink));
 625            }
 0626            if (resourceGroupName == null)
 627            {
 0628                throw new ArgumentNullException(nameof(resourceGroupName));
 629            }
 630
 0631            using var message = CreateListByResourceGroupNextPageRequest(nextLink, resourceGroupName);
 0632            _pipeline.Send(message, cancellationToken);
 0633            switch (message.Response.Status)
 634            {
 635                case 200:
 636                    {
 0637                        RouteFilterListResult value = default;
 0638                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0639                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 640                        {
 0641                            value = null;
 642                        }
 643                        else
 644                        {
 0645                            value = RouteFilterListResult.DeserializeRouteFilterListResult(document.RootElement);
 646                        }
 0647                        return Response.FromValue(value, message.Response);
 648                    }
 649                default:
 0650                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 651            }
 0652        }
 653
 654        internal HttpMessage CreateListNextPageRequest(string nextLink)
 655        {
 0656            var message = _pipeline.CreateMessage();
 0657            var request = message.Request;
 0658            request.Method = RequestMethod.Get;
 0659            var uri = new RawRequestUriBuilder();
 0660            uri.Reset(endpoint);
 0661            uri.AppendRawNextLink(nextLink, false);
 0662            request.Uri = uri;
 0663            return message;
 664        }
 665
 666        /// <summary> Gets all route filters in a subscription. </summary>
 667        /// <param name="nextLink"> The URL to the next page of results. </param>
 668        /// <param name="cancellationToken"> The cancellation token to use. </param>
 669        public async Task<Response<RouteFilterListResult>> ListNextPageAsync(string nextLink, CancellationToken cancella
 670        {
 0671            if (nextLink == null)
 672            {
 0673                throw new ArgumentNullException(nameof(nextLink));
 674            }
 675
 0676            using var message = CreateListNextPageRequest(nextLink);
 0677            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0678            switch (message.Response.Status)
 679            {
 680                case 200:
 681                    {
 0682                        RouteFilterListResult value = default;
 0683                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0684                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 685                        {
 0686                            value = null;
 687                        }
 688                        else
 689                        {
 0690                            value = RouteFilterListResult.DeserializeRouteFilterListResult(document.RootElement);
 691                        }
 0692                        return Response.FromValue(value, message.Response);
 693                    }
 694                default:
 0695                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 696            }
 0697        }
 698
 699        /// <summary> Gets all route filters in a subscription. </summary>
 700        /// <param name="nextLink"> The URL to the next page of results. </param>
 701        /// <param name="cancellationToken"> The cancellation token to use. </param>
 702        public Response<RouteFilterListResult> ListNextPage(string nextLink, CancellationToken cancellationToken = defau
 703        {
 0704            if (nextLink == null)
 705            {
 0706                throw new ArgumentNullException(nameof(nextLink));
 707            }
 708
 0709            using var message = CreateListNextPageRequest(nextLink);
 0710            _pipeline.Send(message, cancellationToken);
 0711            switch (message.Response.Status)
 712            {
 713                case 200:
 714                    {
 0715                        RouteFilterListResult value = default;
 0716                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0717                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 718                        {
 0719                            value = null;
 720                        }
 721                        else
 722                        {
 0723                            value = RouteFilterListResult.DeserializeRouteFilterListResult(document.RootElement);
 724                        }
 0725                        return Response.FromValue(value, message.Response);
 726                    }
 727                default:
 0728                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 729            }
 0730        }
 731    }
 732}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:49 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
CreateDeleteRequest(...)
DeleteAsync()
Delete(...)
CreateGetRequest(...)
GetAsync()
Get(...)
CreateCreateOrUpdateRequest(...)
CreateOrUpdateAsync()
CreateOrUpdate(...)
CreateUpdateTagsRequest(...)
UpdateTagsAsync()
UpdateTags(...)
CreateListByResourceGroupRequest(...)
ListByResourceGroupAsync()
ListByResourceGroup(...)
CreateListRequest()
ListAsync()
List(...)
CreateListByResourceGroupNextPageRequest(...)
ListByResourceGroupNextPageAsync()
ListByResourceGroupNextPage(...)
CreateListNextPageRequest(...)
ListNextPageAsync()
ListNextPage(...)