1// +build go1.13 2 3// Copyright (c) Microsoft Corporation. All rights reserved. 4// Licensed under the MIT License. See License.txt in the project root for license information. 5// Code generated by Microsoft (R) AutoRest Code Generator. 6// Changes may cause incorrect behavior and will be lost if the code is regenerated. 7 8package armnetwork 9 10import ( 11 "context" 12 "github.com/Azure/azure-sdk-for-go/sdk/azcore" 13 "reflect" 14) 15 16// ApplicationGatewayAvailableSSLPredefinedPoliciesPager provides iteration over ApplicationGatewayAvailableSSLPredefinedPolicies pages. 17type ApplicationGatewayAvailableSSLPredefinedPoliciesPager interface { 18 azcore.Pager 19 20 // PageResponse returns the current ApplicationGatewayAvailableSSLPredefinedPoliciesResponse. 21 PageResponse() ApplicationGatewayAvailableSSLPredefinedPoliciesResponse 22} 23 24type applicationGatewayAvailableSSLPredefinedPoliciesCreateRequest func(context.Context) (*azcore.Request, error) 25 26type applicationGatewayAvailableSSLPredefinedPoliciesHandleError func(*azcore.Response) error 27 28type applicationGatewayAvailableSSLPredefinedPoliciesHandleResponse func(*azcore.Response) (ApplicationGatewayAvailableSSLPredefinedPoliciesResponse, error) 29 30type applicationGatewayAvailableSSLPredefinedPoliciesAdvancePage func(context.Context, ApplicationGatewayAvailableSSLPredefinedPoliciesResponse) (*azcore.Request, error) 31 32type applicationGatewayAvailableSSLPredefinedPoliciesPager struct { 33 // the pipeline for making the request 34 pipeline azcore.Pipeline 35 // creates the initial request (non-LRO case) 36 requester applicationGatewayAvailableSSLPredefinedPoliciesCreateRequest 37 // callback for handling response errors 38 errorer applicationGatewayAvailableSSLPredefinedPoliciesHandleError 39 // callback for handling the HTTP response 40 responder applicationGatewayAvailableSSLPredefinedPoliciesHandleResponse 41 // callback for advancing to the next page 42 advancer applicationGatewayAvailableSSLPredefinedPoliciesAdvancePage 43 // contains the current response 44 current ApplicationGatewayAvailableSSLPredefinedPoliciesResponse 45 // status codes for successful retrieval 46 statusCodes []int 47 // any error encountered 48 err error 49} 50 51func (p *applicationGatewayAvailableSSLPredefinedPoliciesPager) Err() error { 52 return p.err 53} 54 55func (p *applicationGatewayAvailableSSLPredefinedPoliciesPager) NextPage(ctx context.Context) bool { 56 var req *azcore.Request 57 var err error 58 if !reflect.ValueOf(p.current).IsZero() { 59 if p.current.ApplicationGatewayAvailableSSLPredefinedPolicies.NextLink == nil || len(*p.current.ApplicationGatewayAvailableSSLPredefinedPolicies.NextLink) == 0 { 60 return false 61 } 62 req, err = p.advancer(ctx, p.current) 63 } else { 64 req, err = p.requester(ctx) 65 } 66 if err != nil { 67 p.err = err 68 return false 69 } 70 resp, err := p.pipeline.Do(req) 71 if err != nil { 72 p.err = err 73 return false 74 } 75 if !resp.HasStatusCode(p.statusCodes...) { 76 p.err = p.errorer(resp) 77 return false 78 } 79 result, err := p.responder(resp) 80 if err != nil { 81 p.err = err 82 return false 83 } 84 p.current = result 85 return true 86} 87 88func (p *applicationGatewayAvailableSSLPredefinedPoliciesPager) PageResponse() ApplicationGatewayAvailableSSLPredefinedPoliciesResponse { 89 return p.current 90} 91 92// ApplicationGatewayListResultPager provides iteration over ApplicationGatewayListResult pages. 93type ApplicationGatewayListResultPager interface { 94 azcore.Pager 95 96 // PageResponse returns the current ApplicationGatewayListResultResponse. 97 PageResponse() ApplicationGatewayListResultResponse 98} 99 100type applicationGatewayListResultCreateRequest func(context.Context) (*azcore.Request, error) 101 102type applicationGatewayListResultHandleError func(*azcore.Response) error 103 104type applicationGatewayListResultHandleResponse func(*azcore.Response) (ApplicationGatewayListResultResponse, error) 105 106type applicationGatewayListResultAdvancePage func(context.Context, ApplicationGatewayListResultResponse) (*azcore.Request, error) 107 108type applicationGatewayListResultPager struct { 109 // the pipeline for making the request 110 pipeline azcore.Pipeline 111 // creates the initial request (non-LRO case) 112 requester applicationGatewayListResultCreateRequest 113 // callback for handling response errors 114 errorer applicationGatewayListResultHandleError 115 // callback for handling the HTTP response 116 responder applicationGatewayListResultHandleResponse 117 // callback for advancing to the next page 118 advancer applicationGatewayListResultAdvancePage 119 // contains the current response 120 current ApplicationGatewayListResultResponse 121 // status codes for successful retrieval 122 statusCodes []int 123 // any error encountered 124 err error 125} 126 127func (p *applicationGatewayListResultPager) Err() error { 128 return p.err 129} 130 131func (p *applicationGatewayListResultPager) NextPage(ctx context.Context) bool { 132 var req *azcore.Request 133 var err error 134 if !reflect.ValueOf(p.current).IsZero() { 135 if p.current.ApplicationGatewayListResult.NextLink == nil || len(*p.current.ApplicationGatewayListResult.NextLink) == 0 { 136 return false 137 } 138 req, err = p.advancer(ctx, p.current) 139 } else { 140 req, err = p.requester(ctx) 141 } 142 if err != nil { 143 p.err = err 144 return false 145 } 146 resp, err := p.pipeline.Do(req) 147 if err != nil { 148 p.err = err 149 return false 150 } 151 if !resp.HasStatusCode(p.statusCodes...) { 152 p.err = p.errorer(resp) 153 return false 154 } 155 result, err := p.responder(resp) 156 if err != nil { 157 p.err = err 158 return false 159 } 160 p.current = result 161 return true 162} 163 164func (p *applicationGatewayListResultPager) PageResponse() ApplicationGatewayListResultResponse { 165 return p.current 166} 167 168// ApplicationGatewayPrivateEndpointConnectionListResultPager provides iteration over ApplicationGatewayPrivateEndpointConnectionListResult pages. 169type ApplicationGatewayPrivateEndpointConnectionListResultPager interface { 170 azcore.Pager 171 172 // PageResponse returns the current ApplicationGatewayPrivateEndpointConnectionListResultResponse. 173 PageResponse() ApplicationGatewayPrivateEndpointConnectionListResultResponse 174} 175 176type applicationGatewayPrivateEndpointConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error) 177 178type applicationGatewayPrivateEndpointConnectionListResultHandleError func(*azcore.Response) error 179 180type applicationGatewayPrivateEndpointConnectionListResultHandleResponse func(*azcore.Response) (ApplicationGatewayPrivateEndpointConnectionListResultResponse, error) 181 182type applicationGatewayPrivateEndpointConnectionListResultAdvancePage func(context.Context, ApplicationGatewayPrivateEndpointConnectionListResultResponse) (*azcore.Request, error) 183 184type applicationGatewayPrivateEndpointConnectionListResultPager struct { 185 // the pipeline for making the request 186 pipeline azcore.Pipeline 187 // creates the initial request (non-LRO case) 188 requester applicationGatewayPrivateEndpointConnectionListResultCreateRequest 189 // callback for handling response errors 190 errorer applicationGatewayPrivateEndpointConnectionListResultHandleError 191 // callback for handling the HTTP response 192 responder applicationGatewayPrivateEndpointConnectionListResultHandleResponse 193 // callback for advancing to the next page 194 advancer applicationGatewayPrivateEndpointConnectionListResultAdvancePage 195 // contains the current response 196 current ApplicationGatewayPrivateEndpointConnectionListResultResponse 197 // status codes for successful retrieval 198 statusCodes []int 199 // any error encountered 200 err error 201} 202 203func (p *applicationGatewayPrivateEndpointConnectionListResultPager) Err() error { 204 return p.err 205} 206 207func (p *applicationGatewayPrivateEndpointConnectionListResultPager) NextPage(ctx context.Context) bool { 208 var req *azcore.Request 209 var err error 210 if !reflect.ValueOf(p.current).IsZero() { 211 if p.current.ApplicationGatewayPrivateEndpointConnectionListResult.NextLink == nil || len(*p.current.ApplicationGatewayPrivateEndpointConnectionListResult.NextLink) == 0 { 212 return false 213 } 214 req, err = p.advancer(ctx, p.current) 215 } else { 216 req, err = p.requester(ctx) 217 } 218 if err != nil { 219 p.err = err 220 return false 221 } 222 resp, err := p.pipeline.Do(req) 223 if err != nil { 224 p.err = err 225 return false 226 } 227 if !resp.HasStatusCode(p.statusCodes...) { 228 p.err = p.errorer(resp) 229 return false 230 } 231 result, err := p.responder(resp) 232 if err != nil { 233 p.err = err 234 return false 235 } 236 p.current = result 237 return true 238} 239 240func (p *applicationGatewayPrivateEndpointConnectionListResultPager) PageResponse() ApplicationGatewayPrivateEndpointConnectionListResultResponse { 241 return p.current 242} 243 244// ApplicationGatewayPrivateLinkResourceListResultPager provides iteration over ApplicationGatewayPrivateLinkResourceListResult pages. 245type ApplicationGatewayPrivateLinkResourceListResultPager interface { 246 azcore.Pager 247 248 // PageResponse returns the current ApplicationGatewayPrivateLinkResourceListResultResponse. 249 PageResponse() ApplicationGatewayPrivateLinkResourceListResultResponse 250} 251 252type applicationGatewayPrivateLinkResourceListResultCreateRequest func(context.Context) (*azcore.Request, error) 253 254type applicationGatewayPrivateLinkResourceListResultHandleError func(*azcore.Response) error 255 256type applicationGatewayPrivateLinkResourceListResultHandleResponse func(*azcore.Response) (ApplicationGatewayPrivateLinkResourceListResultResponse, error) 257 258type applicationGatewayPrivateLinkResourceListResultAdvancePage func(context.Context, ApplicationGatewayPrivateLinkResourceListResultResponse) (*azcore.Request, error) 259 260type applicationGatewayPrivateLinkResourceListResultPager struct { 261 // the pipeline for making the request 262 pipeline azcore.Pipeline 263 // creates the initial request (non-LRO case) 264 requester applicationGatewayPrivateLinkResourceListResultCreateRequest 265 // callback for handling response errors 266 errorer applicationGatewayPrivateLinkResourceListResultHandleError 267 // callback for handling the HTTP response 268 responder applicationGatewayPrivateLinkResourceListResultHandleResponse 269 // callback for advancing to the next page 270 advancer applicationGatewayPrivateLinkResourceListResultAdvancePage 271 // contains the current response 272 current ApplicationGatewayPrivateLinkResourceListResultResponse 273 // status codes for successful retrieval 274 statusCodes []int 275 // any error encountered 276 err error 277} 278 279func (p *applicationGatewayPrivateLinkResourceListResultPager) Err() error { 280 return p.err 281} 282 283func (p *applicationGatewayPrivateLinkResourceListResultPager) NextPage(ctx context.Context) bool { 284 var req *azcore.Request 285 var err error 286 if !reflect.ValueOf(p.current).IsZero() { 287 if p.current.ApplicationGatewayPrivateLinkResourceListResult.NextLink == nil || len(*p.current.ApplicationGatewayPrivateLinkResourceListResult.NextLink) == 0 { 288 return false 289 } 290 req, err = p.advancer(ctx, p.current) 291 } else { 292 req, err = p.requester(ctx) 293 } 294 if err != nil { 295 p.err = err 296 return false 297 } 298 resp, err := p.pipeline.Do(req) 299 if err != nil { 300 p.err = err 301 return false 302 } 303 if !resp.HasStatusCode(p.statusCodes...) { 304 p.err = p.errorer(resp) 305 return false 306 } 307 result, err := p.responder(resp) 308 if err != nil { 309 p.err = err 310 return false 311 } 312 p.current = result 313 return true 314} 315 316func (p *applicationGatewayPrivateLinkResourceListResultPager) PageResponse() ApplicationGatewayPrivateLinkResourceListResultResponse { 317 return p.current 318} 319 320// ApplicationSecurityGroupListResultPager provides iteration over ApplicationSecurityGroupListResult pages. 321type ApplicationSecurityGroupListResultPager interface { 322 azcore.Pager 323 324 // PageResponse returns the current ApplicationSecurityGroupListResultResponse. 325 PageResponse() ApplicationSecurityGroupListResultResponse 326} 327 328type applicationSecurityGroupListResultCreateRequest func(context.Context) (*azcore.Request, error) 329 330type applicationSecurityGroupListResultHandleError func(*azcore.Response) error 331 332type applicationSecurityGroupListResultHandleResponse func(*azcore.Response) (ApplicationSecurityGroupListResultResponse, error) 333 334type applicationSecurityGroupListResultAdvancePage func(context.Context, ApplicationSecurityGroupListResultResponse) (*azcore.Request, error) 335 336type applicationSecurityGroupListResultPager struct { 337 // the pipeline for making the request 338 pipeline azcore.Pipeline 339 // creates the initial request (non-LRO case) 340 requester applicationSecurityGroupListResultCreateRequest 341 // callback for handling response errors 342 errorer applicationSecurityGroupListResultHandleError 343 // callback for handling the HTTP response 344 responder applicationSecurityGroupListResultHandleResponse 345 // callback for advancing to the next page 346 advancer applicationSecurityGroupListResultAdvancePage 347 // contains the current response 348 current ApplicationSecurityGroupListResultResponse 349 // status codes for successful retrieval 350 statusCodes []int 351 // any error encountered 352 err error 353} 354 355func (p *applicationSecurityGroupListResultPager) Err() error { 356 return p.err 357} 358 359func (p *applicationSecurityGroupListResultPager) NextPage(ctx context.Context) bool { 360 var req *azcore.Request 361 var err error 362 if !reflect.ValueOf(p.current).IsZero() { 363 if p.current.ApplicationSecurityGroupListResult.NextLink == nil || len(*p.current.ApplicationSecurityGroupListResult.NextLink) == 0 { 364 return false 365 } 366 req, err = p.advancer(ctx, p.current) 367 } else { 368 req, err = p.requester(ctx) 369 } 370 if err != nil { 371 p.err = err 372 return false 373 } 374 resp, err := p.pipeline.Do(req) 375 if err != nil { 376 p.err = err 377 return false 378 } 379 if !resp.HasStatusCode(p.statusCodes...) { 380 p.err = p.errorer(resp) 381 return false 382 } 383 result, err := p.responder(resp) 384 if err != nil { 385 p.err = err 386 return false 387 } 388 p.current = result 389 return true 390} 391 392func (p *applicationSecurityGroupListResultPager) PageResponse() ApplicationSecurityGroupListResultResponse { 393 return p.current 394} 395 396// AuthorizationListResultPager provides iteration over AuthorizationListResult pages. 397type AuthorizationListResultPager interface { 398 azcore.Pager 399 400 // PageResponse returns the current AuthorizationListResultResponse. 401 PageResponse() AuthorizationListResultResponse 402} 403 404type authorizationListResultCreateRequest func(context.Context) (*azcore.Request, error) 405 406type authorizationListResultHandleError func(*azcore.Response) error 407 408type authorizationListResultHandleResponse func(*azcore.Response) (AuthorizationListResultResponse, error) 409 410type authorizationListResultAdvancePage func(context.Context, AuthorizationListResultResponse) (*azcore.Request, error) 411 412type authorizationListResultPager struct { 413 // the pipeline for making the request 414 pipeline azcore.Pipeline 415 // creates the initial request (non-LRO case) 416 requester authorizationListResultCreateRequest 417 // callback for handling response errors 418 errorer authorizationListResultHandleError 419 // callback for handling the HTTP response 420 responder authorizationListResultHandleResponse 421 // callback for advancing to the next page 422 advancer authorizationListResultAdvancePage 423 // contains the current response 424 current AuthorizationListResultResponse 425 // status codes for successful retrieval 426 statusCodes []int 427 // any error encountered 428 err error 429} 430 431func (p *authorizationListResultPager) Err() error { 432 return p.err 433} 434 435func (p *authorizationListResultPager) NextPage(ctx context.Context) bool { 436 var req *azcore.Request 437 var err error 438 if !reflect.ValueOf(p.current).IsZero() { 439 if p.current.AuthorizationListResult.NextLink == nil || len(*p.current.AuthorizationListResult.NextLink) == 0 { 440 return false 441 } 442 req, err = p.advancer(ctx, p.current) 443 } else { 444 req, err = p.requester(ctx) 445 } 446 if err != nil { 447 p.err = err 448 return false 449 } 450 resp, err := p.pipeline.Do(req) 451 if err != nil { 452 p.err = err 453 return false 454 } 455 if !resp.HasStatusCode(p.statusCodes...) { 456 p.err = p.errorer(resp) 457 return false 458 } 459 result, err := p.responder(resp) 460 if err != nil { 461 p.err = err 462 return false 463 } 464 p.current = result 465 return true 466} 467 468func (p *authorizationListResultPager) PageResponse() AuthorizationListResultResponse { 469 return p.current 470} 471 472// AutoApprovedPrivateLinkServicesResultPager provides iteration over AutoApprovedPrivateLinkServicesResult pages. 473type AutoApprovedPrivateLinkServicesResultPager interface { 474 azcore.Pager 475 476 // PageResponse returns the current AutoApprovedPrivateLinkServicesResultResponse. 477 PageResponse() AutoApprovedPrivateLinkServicesResultResponse 478} 479 480type autoApprovedPrivateLinkServicesResultCreateRequest func(context.Context) (*azcore.Request, error) 481 482type autoApprovedPrivateLinkServicesResultHandleError func(*azcore.Response) error 483 484type autoApprovedPrivateLinkServicesResultHandleResponse func(*azcore.Response) (AutoApprovedPrivateLinkServicesResultResponse, error) 485 486type autoApprovedPrivateLinkServicesResultAdvancePage func(context.Context, AutoApprovedPrivateLinkServicesResultResponse) (*azcore.Request, error) 487 488type autoApprovedPrivateLinkServicesResultPager struct { 489 // the pipeline for making the request 490 pipeline azcore.Pipeline 491 // creates the initial request (non-LRO case) 492 requester autoApprovedPrivateLinkServicesResultCreateRequest 493 // callback for handling response errors 494 errorer autoApprovedPrivateLinkServicesResultHandleError 495 // callback for handling the HTTP response 496 responder autoApprovedPrivateLinkServicesResultHandleResponse 497 // callback for advancing to the next page 498 advancer autoApprovedPrivateLinkServicesResultAdvancePage 499 // contains the current response 500 current AutoApprovedPrivateLinkServicesResultResponse 501 // status codes for successful retrieval 502 statusCodes []int 503 // any error encountered 504 err error 505} 506 507func (p *autoApprovedPrivateLinkServicesResultPager) Err() error { 508 return p.err 509} 510 511func (p *autoApprovedPrivateLinkServicesResultPager) NextPage(ctx context.Context) bool { 512 var req *azcore.Request 513 var err error 514 if !reflect.ValueOf(p.current).IsZero() { 515 if p.current.AutoApprovedPrivateLinkServicesResult.NextLink == nil || len(*p.current.AutoApprovedPrivateLinkServicesResult.NextLink) == 0 { 516 return false 517 } 518 req, err = p.advancer(ctx, p.current) 519 } else { 520 req, err = p.requester(ctx) 521 } 522 if err != nil { 523 p.err = err 524 return false 525 } 526 resp, err := p.pipeline.Do(req) 527 if err != nil { 528 p.err = err 529 return false 530 } 531 if !resp.HasStatusCode(p.statusCodes...) { 532 p.err = p.errorer(resp) 533 return false 534 } 535 result, err := p.responder(resp) 536 if err != nil { 537 p.err = err 538 return false 539 } 540 p.current = result 541 return true 542} 543 544func (p *autoApprovedPrivateLinkServicesResultPager) PageResponse() AutoApprovedPrivateLinkServicesResultResponse { 545 return p.current 546} 547 548// AvailableDelegationsResultPager provides iteration over AvailableDelegationsResult pages. 549type AvailableDelegationsResultPager interface { 550 azcore.Pager 551 552 // PageResponse returns the current AvailableDelegationsResultResponse. 553 PageResponse() AvailableDelegationsResultResponse 554} 555 556type availableDelegationsResultCreateRequest func(context.Context) (*azcore.Request, error) 557 558type availableDelegationsResultHandleError func(*azcore.Response) error 559 560type availableDelegationsResultHandleResponse func(*azcore.Response) (AvailableDelegationsResultResponse, error) 561 562type availableDelegationsResultAdvancePage func(context.Context, AvailableDelegationsResultResponse) (*azcore.Request, error) 563 564type availableDelegationsResultPager struct { 565 // the pipeline for making the request 566 pipeline azcore.Pipeline 567 // creates the initial request (non-LRO case) 568 requester availableDelegationsResultCreateRequest 569 // callback for handling response errors 570 errorer availableDelegationsResultHandleError 571 // callback for handling the HTTP response 572 responder availableDelegationsResultHandleResponse 573 // callback for advancing to the next page 574 advancer availableDelegationsResultAdvancePage 575 // contains the current response 576 current AvailableDelegationsResultResponse 577 // status codes for successful retrieval 578 statusCodes []int 579 // any error encountered 580 err error 581} 582 583func (p *availableDelegationsResultPager) Err() error { 584 return p.err 585} 586 587func (p *availableDelegationsResultPager) NextPage(ctx context.Context) bool { 588 var req *azcore.Request 589 var err error 590 if !reflect.ValueOf(p.current).IsZero() { 591 if p.current.AvailableDelegationsResult.NextLink == nil || len(*p.current.AvailableDelegationsResult.NextLink) == 0 { 592 return false 593 } 594 req, err = p.advancer(ctx, p.current) 595 } else { 596 req, err = p.requester(ctx) 597 } 598 if err != nil { 599 p.err = err 600 return false 601 } 602 resp, err := p.pipeline.Do(req) 603 if err != nil { 604 p.err = err 605 return false 606 } 607 if !resp.HasStatusCode(p.statusCodes...) { 608 p.err = p.errorer(resp) 609 return false 610 } 611 result, err := p.responder(resp) 612 if err != nil { 613 p.err = err 614 return false 615 } 616 p.current = result 617 return true 618} 619 620func (p *availableDelegationsResultPager) PageResponse() AvailableDelegationsResultResponse { 621 return p.current 622} 623 624// AvailablePrivateEndpointTypesResultPager provides iteration over AvailablePrivateEndpointTypesResult pages. 625type AvailablePrivateEndpointTypesResultPager interface { 626 azcore.Pager 627 628 // PageResponse returns the current AvailablePrivateEndpointTypesResultResponse. 629 PageResponse() AvailablePrivateEndpointTypesResultResponse 630} 631 632type availablePrivateEndpointTypesResultCreateRequest func(context.Context) (*azcore.Request, error) 633 634type availablePrivateEndpointTypesResultHandleError func(*azcore.Response) error 635 636type availablePrivateEndpointTypesResultHandleResponse func(*azcore.Response) (AvailablePrivateEndpointTypesResultResponse, error) 637 638type availablePrivateEndpointTypesResultAdvancePage func(context.Context, AvailablePrivateEndpointTypesResultResponse) (*azcore.Request, error) 639 640type availablePrivateEndpointTypesResultPager struct { 641 // the pipeline for making the request 642 pipeline azcore.Pipeline 643 // creates the initial request (non-LRO case) 644 requester availablePrivateEndpointTypesResultCreateRequest 645 // callback for handling response errors 646 errorer availablePrivateEndpointTypesResultHandleError 647 // callback for handling the HTTP response 648 responder availablePrivateEndpointTypesResultHandleResponse 649 // callback for advancing to the next page 650 advancer availablePrivateEndpointTypesResultAdvancePage 651 // contains the current response 652 current AvailablePrivateEndpointTypesResultResponse 653 // status codes for successful retrieval 654 statusCodes []int 655 // any error encountered 656 err error 657} 658 659func (p *availablePrivateEndpointTypesResultPager) Err() error { 660 return p.err 661} 662 663func (p *availablePrivateEndpointTypesResultPager) NextPage(ctx context.Context) bool { 664 var req *azcore.Request 665 var err error 666 if !reflect.ValueOf(p.current).IsZero() { 667 if p.current.AvailablePrivateEndpointTypesResult.NextLink == nil || len(*p.current.AvailablePrivateEndpointTypesResult.NextLink) == 0 { 668 return false 669 } 670 req, err = p.advancer(ctx, p.current) 671 } else { 672 req, err = p.requester(ctx) 673 } 674 if err != nil { 675 p.err = err 676 return false 677 } 678 resp, err := p.pipeline.Do(req) 679 if err != nil { 680 p.err = err 681 return false 682 } 683 if !resp.HasStatusCode(p.statusCodes...) { 684 p.err = p.errorer(resp) 685 return false 686 } 687 result, err := p.responder(resp) 688 if err != nil { 689 p.err = err 690 return false 691 } 692 p.current = result 693 return true 694} 695 696func (p *availablePrivateEndpointTypesResultPager) PageResponse() AvailablePrivateEndpointTypesResultResponse { 697 return p.current 698} 699 700// AvailableServiceAliasesResultPager provides iteration over AvailableServiceAliasesResult pages. 701type AvailableServiceAliasesResultPager interface { 702 azcore.Pager 703 704 // PageResponse returns the current AvailableServiceAliasesResultResponse. 705 PageResponse() AvailableServiceAliasesResultResponse 706} 707 708type availableServiceAliasesResultCreateRequest func(context.Context) (*azcore.Request, error) 709 710type availableServiceAliasesResultHandleError func(*azcore.Response) error 711 712type availableServiceAliasesResultHandleResponse func(*azcore.Response) (AvailableServiceAliasesResultResponse, error) 713 714type availableServiceAliasesResultAdvancePage func(context.Context, AvailableServiceAliasesResultResponse) (*azcore.Request, error) 715 716type availableServiceAliasesResultPager struct { 717 // the pipeline for making the request 718 pipeline azcore.Pipeline 719 // creates the initial request (non-LRO case) 720 requester availableServiceAliasesResultCreateRequest 721 // callback for handling response errors 722 errorer availableServiceAliasesResultHandleError 723 // callback for handling the HTTP response 724 responder availableServiceAliasesResultHandleResponse 725 // callback for advancing to the next page 726 advancer availableServiceAliasesResultAdvancePage 727 // contains the current response 728 current AvailableServiceAliasesResultResponse 729 // status codes for successful retrieval 730 statusCodes []int 731 // any error encountered 732 err error 733} 734 735func (p *availableServiceAliasesResultPager) Err() error { 736 return p.err 737} 738 739func (p *availableServiceAliasesResultPager) NextPage(ctx context.Context) bool { 740 var req *azcore.Request 741 var err error 742 if !reflect.ValueOf(p.current).IsZero() { 743 if p.current.AvailableServiceAliasesResult.NextLink == nil || len(*p.current.AvailableServiceAliasesResult.NextLink) == 0 { 744 return false 745 } 746 req, err = p.advancer(ctx, p.current) 747 } else { 748 req, err = p.requester(ctx) 749 } 750 if err != nil { 751 p.err = err 752 return false 753 } 754 resp, err := p.pipeline.Do(req) 755 if err != nil { 756 p.err = err 757 return false 758 } 759 if !resp.HasStatusCode(p.statusCodes...) { 760 p.err = p.errorer(resp) 761 return false 762 } 763 result, err := p.responder(resp) 764 if err != nil { 765 p.err = err 766 return false 767 } 768 p.current = result 769 return true 770} 771 772func (p *availableServiceAliasesResultPager) PageResponse() AvailableServiceAliasesResultResponse { 773 return p.current 774} 775 776// AzureFirewallFqdnTagListResultPager provides iteration over AzureFirewallFqdnTagListResult pages. 777type AzureFirewallFqdnTagListResultPager interface { 778 azcore.Pager 779 780 // PageResponse returns the current AzureFirewallFqdnTagListResultResponse. 781 PageResponse() AzureFirewallFqdnTagListResultResponse 782} 783 784type azureFirewallFqdnTagListResultCreateRequest func(context.Context) (*azcore.Request, error) 785 786type azureFirewallFqdnTagListResultHandleError func(*azcore.Response) error 787 788type azureFirewallFqdnTagListResultHandleResponse func(*azcore.Response) (AzureFirewallFqdnTagListResultResponse, error) 789 790type azureFirewallFqdnTagListResultAdvancePage func(context.Context, AzureFirewallFqdnTagListResultResponse) (*azcore.Request, error) 791 792type azureFirewallFqdnTagListResultPager struct { 793 // the pipeline for making the request 794 pipeline azcore.Pipeline 795 // creates the initial request (non-LRO case) 796 requester azureFirewallFqdnTagListResultCreateRequest 797 // callback for handling response errors 798 errorer azureFirewallFqdnTagListResultHandleError 799 // callback for handling the HTTP response 800 responder azureFirewallFqdnTagListResultHandleResponse 801 // callback for advancing to the next page 802 advancer azureFirewallFqdnTagListResultAdvancePage 803 // contains the current response 804 current AzureFirewallFqdnTagListResultResponse 805 // status codes for successful retrieval 806 statusCodes []int 807 // any error encountered 808 err error 809} 810 811func (p *azureFirewallFqdnTagListResultPager) Err() error { 812 return p.err 813} 814 815func (p *azureFirewallFqdnTagListResultPager) NextPage(ctx context.Context) bool { 816 var req *azcore.Request 817 var err error 818 if !reflect.ValueOf(p.current).IsZero() { 819 if p.current.AzureFirewallFqdnTagListResult.NextLink == nil || len(*p.current.AzureFirewallFqdnTagListResult.NextLink) == 0 { 820 return false 821 } 822 req, err = p.advancer(ctx, p.current) 823 } else { 824 req, err = p.requester(ctx) 825 } 826 if err != nil { 827 p.err = err 828 return false 829 } 830 resp, err := p.pipeline.Do(req) 831 if err != nil { 832 p.err = err 833 return false 834 } 835 if !resp.HasStatusCode(p.statusCodes...) { 836 p.err = p.errorer(resp) 837 return false 838 } 839 result, err := p.responder(resp) 840 if err != nil { 841 p.err = err 842 return false 843 } 844 p.current = result 845 return true 846} 847 848func (p *azureFirewallFqdnTagListResultPager) PageResponse() AzureFirewallFqdnTagListResultResponse { 849 return p.current 850} 851 852// AzureFirewallListResultPager provides iteration over AzureFirewallListResult pages. 853type AzureFirewallListResultPager interface { 854 azcore.Pager 855 856 // PageResponse returns the current AzureFirewallListResultResponse. 857 PageResponse() AzureFirewallListResultResponse 858} 859 860type azureFirewallListResultCreateRequest func(context.Context) (*azcore.Request, error) 861 862type azureFirewallListResultHandleError func(*azcore.Response) error 863 864type azureFirewallListResultHandleResponse func(*azcore.Response) (AzureFirewallListResultResponse, error) 865 866type azureFirewallListResultAdvancePage func(context.Context, AzureFirewallListResultResponse) (*azcore.Request, error) 867 868type azureFirewallListResultPager struct { 869 // the pipeline for making the request 870 pipeline azcore.Pipeline 871 // creates the initial request (non-LRO case) 872 requester azureFirewallListResultCreateRequest 873 // callback for handling response errors 874 errorer azureFirewallListResultHandleError 875 // callback for handling the HTTP response 876 responder azureFirewallListResultHandleResponse 877 // callback for advancing to the next page 878 advancer azureFirewallListResultAdvancePage 879 // contains the current response 880 current AzureFirewallListResultResponse 881 // status codes for successful retrieval 882 statusCodes []int 883 // any error encountered 884 err error 885} 886 887func (p *azureFirewallListResultPager) Err() error { 888 return p.err 889} 890 891func (p *azureFirewallListResultPager) NextPage(ctx context.Context) bool { 892 var req *azcore.Request 893 var err error 894 if !reflect.ValueOf(p.current).IsZero() { 895 if p.current.AzureFirewallListResult.NextLink == nil || len(*p.current.AzureFirewallListResult.NextLink) == 0 { 896 return false 897 } 898 req, err = p.advancer(ctx, p.current) 899 } else { 900 req, err = p.requester(ctx) 901 } 902 if err != nil { 903 p.err = err 904 return false 905 } 906 resp, err := p.pipeline.Do(req) 907 if err != nil { 908 p.err = err 909 return false 910 } 911 if !resp.HasStatusCode(p.statusCodes...) { 912 p.err = p.errorer(resp) 913 return false 914 } 915 result, err := p.responder(resp) 916 if err != nil { 917 p.err = err 918 return false 919 } 920 p.current = result 921 return true 922} 923 924func (p *azureFirewallListResultPager) PageResponse() AzureFirewallListResultResponse { 925 return p.current 926} 927 928// AzureWebCategoryListResultPager provides iteration over AzureWebCategoryListResult pages. 929type AzureWebCategoryListResultPager interface { 930 azcore.Pager 931 932 // PageResponse returns the current AzureWebCategoryListResultResponse. 933 PageResponse() AzureWebCategoryListResultResponse 934} 935 936type azureWebCategoryListResultCreateRequest func(context.Context) (*azcore.Request, error) 937 938type azureWebCategoryListResultHandleError func(*azcore.Response) error 939 940type azureWebCategoryListResultHandleResponse func(*azcore.Response) (AzureWebCategoryListResultResponse, error) 941 942type azureWebCategoryListResultAdvancePage func(context.Context, AzureWebCategoryListResultResponse) (*azcore.Request, error) 943 944type azureWebCategoryListResultPager struct { 945 // the pipeline for making the request 946 pipeline azcore.Pipeline 947 // creates the initial request (non-LRO case) 948 requester azureWebCategoryListResultCreateRequest 949 // callback for handling response errors 950 errorer azureWebCategoryListResultHandleError 951 // callback for handling the HTTP response 952 responder azureWebCategoryListResultHandleResponse 953 // callback for advancing to the next page 954 advancer azureWebCategoryListResultAdvancePage 955 // contains the current response 956 current AzureWebCategoryListResultResponse 957 // status codes for successful retrieval 958 statusCodes []int 959 // any error encountered 960 err error 961} 962 963func (p *azureWebCategoryListResultPager) Err() error { 964 return p.err 965} 966 967func (p *azureWebCategoryListResultPager) NextPage(ctx context.Context) bool { 968 var req *azcore.Request 969 var err error 970 if !reflect.ValueOf(p.current).IsZero() { 971 if p.current.AzureWebCategoryListResult.NextLink == nil || len(*p.current.AzureWebCategoryListResult.NextLink) == 0 { 972 return false 973 } 974 req, err = p.advancer(ctx, p.current) 975 } else { 976 req, err = p.requester(ctx) 977 } 978 if err != nil { 979 p.err = err 980 return false 981 } 982 resp, err := p.pipeline.Do(req) 983 if err != nil { 984 p.err = err 985 return false 986 } 987 if !resp.HasStatusCode(p.statusCodes...) { 988 p.err = p.errorer(resp) 989 return false 990 } 991 result, err := p.responder(resp) 992 if err != nil { 993 p.err = err 994 return false 995 } 996 p.current = result 997 return true 998} 999 1000func (p *azureWebCategoryListResultPager) PageResponse() AzureWebCategoryListResultResponse { 1001 return p.current 1002} 1003 1004// BastionActiveSessionListResultPager provides iteration over BastionActiveSessionListResult pages. 1005type BastionActiveSessionListResultPager interface { 1006 azcore.Pager 1007 1008 // PageResponse returns the current BastionActiveSessionListResultResponse. 1009 PageResponse() BastionActiveSessionListResultResponse 1010} 1011 1012type bastionActiveSessionListResultCreateRequest func(context.Context) (*azcore.Request, error) 1013 1014type bastionActiveSessionListResultHandleError func(*azcore.Response) error 1015 1016type bastionActiveSessionListResultHandleResponse func(*azcore.Response) (BastionActiveSessionListResultResponse, error) 1017 1018type bastionActiveSessionListResultAdvancePage func(context.Context, BastionActiveSessionListResultResponse) (*azcore.Request, error) 1019 1020type bastionActiveSessionListResultPager struct { 1021 // the pipeline for making the request 1022 pipeline azcore.Pipeline 1023 // creates the initial request (non-LRO case) 1024 requester bastionActiveSessionListResultCreateRequest 1025 // callback for handling response errors 1026 errorer bastionActiveSessionListResultHandleError 1027 // callback for handling the HTTP response 1028 responder bastionActiveSessionListResultHandleResponse 1029 // callback for advancing to the next page 1030 advancer bastionActiveSessionListResultAdvancePage 1031 // contains the current response 1032 current BastionActiveSessionListResultResponse 1033 // status codes for successful retrieval 1034 statusCodes []int 1035 // any error encountered 1036 err error 1037 // previous response from the endpoint (LRO case) 1038 resp *azcore.Response 1039} 1040 1041func (p *bastionActiveSessionListResultPager) Err() error { 1042 return p.err 1043} 1044 1045func (p *bastionActiveSessionListResultPager) NextPage(ctx context.Context) bool { 1046 var req *azcore.Request 1047 var err error 1048 if !reflect.ValueOf(p.current).IsZero() { 1049 if p.current.BastionActiveSessionListResult.NextLink == nil || len(*p.current.BastionActiveSessionListResult.NextLink) == 0 { 1050 return false 1051 } 1052 req, err = p.advancer(ctx, p.current) 1053 } else if p.resp == nil { 1054 req, err = p.requester(ctx) 1055 } 1056 if err != nil { 1057 p.err = err 1058 return false 1059 } 1060 resp := p.resp 1061 if resp == nil { 1062 resp, err = p.pipeline.Do(req) 1063 } else { 1064 p.resp = nil 1065 } 1066 if err != nil { 1067 p.err = err 1068 return false 1069 } 1070 if !resp.HasStatusCode(p.statusCodes...) { 1071 p.err = p.errorer(resp) 1072 return false 1073 } 1074 result, err := p.responder(resp) 1075 if err != nil { 1076 p.err = err 1077 return false 1078 } 1079 p.current = result 1080 return true 1081} 1082 1083func (p *bastionActiveSessionListResultPager) PageResponse() BastionActiveSessionListResultResponse { 1084 return p.current 1085} 1086 1087// BastionHostListResultPager provides iteration over BastionHostListResult pages. 1088type BastionHostListResultPager interface { 1089 azcore.Pager 1090 1091 // PageResponse returns the current BastionHostListResultResponse. 1092 PageResponse() BastionHostListResultResponse 1093} 1094 1095type bastionHostListResultCreateRequest func(context.Context) (*azcore.Request, error) 1096 1097type bastionHostListResultHandleError func(*azcore.Response) error 1098 1099type bastionHostListResultHandleResponse func(*azcore.Response) (BastionHostListResultResponse, error) 1100 1101type bastionHostListResultAdvancePage func(context.Context, BastionHostListResultResponse) (*azcore.Request, error) 1102 1103type bastionHostListResultPager struct { 1104 // the pipeline for making the request 1105 pipeline azcore.Pipeline 1106 // creates the initial request (non-LRO case) 1107 requester bastionHostListResultCreateRequest 1108 // callback for handling response errors 1109 errorer bastionHostListResultHandleError 1110 // callback for handling the HTTP response 1111 responder bastionHostListResultHandleResponse 1112 // callback for advancing to the next page 1113 advancer bastionHostListResultAdvancePage 1114 // contains the current response 1115 current BastionHostListResultResponse 1116 // status codes for successful retrieval 1117 statusCodes []int 1118 // any error encountered 1119 err error 1120} 1121 1122func (p *bastionHostListResultPager) Err() error { 1123 return p.err 1124} 1125 1126func (p *bastionHostListResultPager) NextPage(ctx context.Context) bool { 1127 var req *azcore.Request 1128 var err error 1129 if !reflect.ValueOf(p.current).IsZero() { 1130 if p.current.BastionHostListResult.NextLink == nil || len(*p.current.BastionHostListResult.NextLink) == 0 { 1131 return false 1132 } 1133 req, err = p.advancer(ctx, p.current) 1134 } else { 1135 req, err = p.requester(ctx) 1136 } 1137 if err != nil { 1138 p.err = err 1139 return false 1140 } 1141 resp, err := p.pipeline.Do(req) 1142 if err != nil { 1143 p.err = err 1144 return false 1145 } 1146 if !resp.HasStatusCode(p.statusCodes...) { 1147 p.err = p.errorer(resp) 1148 return false 1149 } 1150 result, err := p.responder(resp) 1151 if err != nil { 1152 p.err = err 1153 return false 1154 } 1155 p.current = result 1156 return true 1157} 1158 1159func (p *bastionHostListResultPager) PageResponse() BastionHostListResultResponse { 1160 return p.current 1161} 1162 1163// BastionSessionDeleteResultPager provides iteration over BastionSessionDeleteResult pages. 1164type BastionSessionDeleteResultPager interface { 1165 azcore.Pager 1166 1167 // PageResponse returns the current BastionSessionDeleteResultResponse. 1168 PageResponse() BastionSessionDeleteResultResponse 1169} 1170 1171type bastionSessionDeleteResultCreateRequest func(context.Context) (*azcore.Request, error) 1172 1173type bastionSessionDeleteResultHandleError func(*azcore.Response) error 1174 1175type bastionSessionDeleteResultHandleResponse func(*azcore.Response) (BastionSessionDeleteResultResponse, error) 1176 1177type bastionSessionDeleteResultAdvancePage func(context.Context, BastionSessionDeleteResultResponse) (*azcore.Request, error) 1178 1179type bastionSessionDeleteResultPager struct { 1180 // the pipeline for making the request 1181 pipeline azcore.Pipeline 1182 // creates the initial request (non-LRO case) 1183 requester bastionSessionDeleteResultCreateRequest 1184 // callback for handling response errors 1185 errorer bastionSessionDeleteResultHandleError 1186 // callback for handling the HTTP response 1187 responder bastionSessionDeleteResultHandleResponse 1188 // callback for advancing to the next page 1189 advancer bastionSessionDeleteResultAdvancePage 1190 // contains the current response 1191 current BastionSessionDeleteResultResponse 1192 // status codes for successful retrieval 1193 statusCodes []int 1194 // any error encountered 1195 err error 1196} 1197 1198func (p *bastionSessionDeleteResultPager) Err() error { 1199 return p.err 1200} 1201 1202func (p *bastionSessionDeleteResultPager) NextPage(ctx context.Context) bool { 1203 var req *azcore.Request 1204 var err error 1205 if !reflect.ValueOf(p.current).IsZero() { 1206 if p.current.BastionSessionDeleteResult.NextLink == nil || len(*p.current.BastionSessionDeleteResult.NextLink) == 0 { 1207 return false 1208 } 1209 req, err = p.advancer(ctx, p.current) 1210 } else { 1211 req, err = p.requester(ctx) 1212 } 1213 if err != nil { 1214 p.err = err 1215 return false 1216 } 1217 resp, err := p.pipeline.Do(req) 1218 if err != nil { 1219 p.err = err 1220 return false 1221 } 1222 if !resp.HasStatusCode(p.statusCodes...) { 1223 p.err = p.errorer(resp) 1224 return false 1225 } 1226 result, err := p.responder(resp) 1227 if err != nil { 1228 p.err = err 1229 return false 1230 } 1231 p.current = result 1232 return true 1233} 1234 1235func (p *bastionSessionDeleteResultPager) PageResponse() BastionSessionDeleteResultResponse { 1236 return p.current 1237} 1238 1239// BastionShareableLinkListResultPager provides iteration over BastionShareableLinkListResult pages. 1240type BastionShareableLinkListResultPager interface { 1241 azcore.Pager 1242 1243 // PageResponse returns the current BastionShareableLinkListResultResponse. 1244 PageResponse() BastionShareableLinkListResultResponse 1245} 1246 1247type bastionShareableLinkListResultCreateRequest func(context.Context) (*azcore.Request, error) 1248 1249type bastionShareableLinkListResultHandleError func(*azcore.Response) error 1250 1251type bastionShareableLinkListResultHandleResponse func(*azcore.Response) (BastionShareableLinkListResultResponse, error) 1252 1253type bastionShareableLinkListResultAdvancePage func(context.Context, BastionShareableLinkListResultResponse) (*azcore.Request, error) 1254 1255type bastionShareableLinkListResultPager struct { 1256 // the pipeline for making the request 1257 pipeline azcore.Pipeline 1258 // creates the initial request (non-LRO case) 1259 requester bastionShareableLinkListResultCreateRequest 1260 // callback for handling response errors 1261 errorer bastionShareableLinkListResultHandleError 1262 // callback for handling the HTTP response 1263 responder bastionShareableLinkListResultHandleResponse 1264 // callback for advancing to the next page 1265 advancer bastionShareableLinkListResultAdvancePage 1266 // contains the current response 1267 current BastionShareableLinkListResultResponse 1268 // status codes for successful retrieval 1269 statusCodes []int 1270 // any error encountered 1271 err error 1272 // previous response from the endpoint (LRO case) 1273 resp *azcore.Response 1274} 1275 1276func (p *bastionShareableLinkListResultPager) Err() error { 1277 return p.err 1278} 1279 1280func (p *bastionShareableLinkListResultPager) NextPage(ctx context.Context) bool { 1281 var req *azcore.Request 1282 var err error 1283 if !reflect.ValueOf(p.current).IsZero() { 1284 if p.current.BastionShareableLinkListResult.NextLink == nil || len(*p.current.BastionShareableLinkListResult.NextLink) == 0 { 1285 return false 1286 } 1287 req, err = p.advancer(ctx, p.current) 1288 } else if p.resp == nil { 1289 req, err = p.requester(ctx) 1290 } 1291 if err != nil { 1292 p.err = err 1293 return false 1294 } 1295 resp := p.resp 1296 if resp == nil { 1297 resp, err = p.pipeline.Do(req) 1298 } else { 1299 p.resp = nil 1300 } 1301 if err != nil { 1302 p.err = err 1303 return false 1304 } 1305 if !resp.HasStatusCode(p.statusCodes...) { 1306 p.err = p.errorer(resp) 1307 return false 1308 } 1309 result, err := p.responder(resp) 1310 if err != nil { 1311 p.err = err 1312 return false 1313 } 1314 p.current = result 1315 return true 1316} 1317 1318func (p *bastionShareableLinkListResultPager) PageResponse() BastionShareableLinkListResultResponse { 1319 return p.current 1320} 1321 1322// BgpServiceCommunityListResultPager provides iteration over BgpServiceCommunityListResult pages. 1323type BgpServiceCommunityListResultPager interface { 1324 azcore.Pager 1325 1326 // PageResponse returns the current BgpServiceCommunityListResultResponse. 1327 PageResponse() BgpServiceCommunityListResultResponse 1328} 1329 1330type bgpServiceCommunityListResultCreateRequest func(context.Context) (*azcore.Request, error) 1331 1332type bgpServiceCommunityListResultHandleError func(*azcore.Response) error 1333 1334type bgpServiceCommunityListResultHandleResponse func(*azcore.Response) (BgpServiceCommunityListResultResponse, error) 1335 1336type bgpServiceCommunityListResultAdvancePage func(context.Context, BgpServiceCommunityListResultResponse) (*azcore.Request, error) 1337 1338type bgpServiceCommunityListResultPager struct { 1339 // the pipeline for making the request 1340 pipeline azcore.Pipeline 1341 // creates the initial request (non-LRO case) 1342 requester bgpServiceCommunityListResultCreateRequest 1343 // callback for handling response errors 1344 errorer bgpServiceCommunityListResultHandleError 1345 // callback for handling the HTTP response 1346 responder bgpServiceCommunityListResultHandleResponse 1347 // callback for advancing to the next page 1348 advancer bgpServiceCommunityListResultAdvancePage 1349 // contains the current response 1350 current BgpServiceCommunityListResultResponse 1351 // status codes for successful retrieval 1352 statusCodes []int 1353 // any error encountered 1354 err error 1355} 1356 1357func (p *bgpServiceCommunityListResultPager) Err() error { 1358 return p.err 1359} 1360 1361func (p *bgpServiceCommunityListResultPager) NextPage(ctx context.Context) bool { 1362 var req *azcore.Request 1363 var err error 1364 if !reflect.ValueOf(p.current).IsZero() { 1365 if p.current.BgpServiceCommunityListResult.NextLink == nil || len(*p.current.BgpServiceCommunityListResult.NextLink) == 0 { 1366 return false 1367 } 1368 req, err = p.advancer(ctx, p.current) 1369 } else { 1370 req, err = p.requester(ctx) 1371 } 1372 if err != nil { 1373 p.err = err 1374 return false 1375 } 1376 resp, err := p.pipeline.Do(req) 1377 if err != nil { 1378 p.err = err 1379 return false 1380 } 1381 if !resp.HasStatusCode(p.statusCodes...) { 1382 p.err = p.errorer(resp) 1383 return false 1384 } 1385 result, err := p.responder(resp) 1386 if err != nil { 1387 p.err = err 1388 return false 1389 } 1390 p.current = result 1391 return true 1392} 1393 1394func (p *bgpServiceCommunityListResultPager) PageResponse() BgpServiceCommunityListResultResponse { 1395 return p.current 1396} 1397 1398// CustomIPPrefixListResultPager provides iteration over CustomIPPrefixListResult pages. 1399type CustomIPPrefixListResultPager interface { 1400 azcore.Pager 1401 1402 // PageResponse returns the current CustomIPPrefixListResultResponse. 1403 PageResponse() CustomIPPrefixListResultResponse 1404} 1405 1406type customIPPrefixListResultCreateRequest func(context.Context) (*azcore.Request, error) 1407 1408type customIPPrefixListResultHandleError func(*azcore.Response) error 1409 1410type customIPPrefixListResultHandleResponse func(*azcore.Response) (CustomIPPrefixListResultResponse, error) 1411 1412type customIPPrefixListResultAdvancePage func(context.Context, CustomIPPrefixListResultResponse) (*azcore.Request, error) 1413 1414type customIPPrefixListResultPager struct { 1415 // the pipeline for making the request 1416 pipeline azcore.Pipeline 1417 // creates the initial request (non-LRO case) 1418 requester customIPPrefixListResultCreateRequest 1419 // callback for handling response errors 1420 errorer customIPPrefixListResultHandleError 1421 // callback for handling the HTTP response 1422 responder customIPPrefixListResultHandleResponse 1423 // callback for advancing to the next page 1424 advancer customIPPrefixListResultAdvancePage 1425 // contains the current response 1426 current CustomIPPrefixListResultResponse 1427 // status codes for successful retrieval 1428 statusCodes []int 1429 // any error encountered 1430 err error 1431} 1432 1433func (p *customIPPrefixListResultPager) Err() error { 1434 return p.err 1435} 1436 1437func (p *customIPPrefixListResultPager) NextPage(ctx context.Context) bool { 1438 var req *azcore.Request 1439 var err error 1440 if !reflect.ValueOf(p.current).IsZero() { 1441 if p.current.CustomIPPrefixListResult.NextLink == nil || len(*p.current.CustomIPPrefixListResult.NextLink) == 0 { 1442 return false 1443 } 1444 req, err = p.advancer(ctx, p.current) 1445 } else { 1446 req, err = p.requester(ctx) 1447 } 1448 if err != nil { 1449 p.err = err 1450 return false 1451 } 1452 resp, err := p.pipeline.Do(req) 1453 if err != nil { 1454 p.err = err 1455 return false 1456 } 1457 if !resp.HasStatusCode(p.statusCodes...) { 1458 p.err = p.errorer(resp) 1459 return false 1460 } 1461 result, err := p.responder(resp) 1462 if err != nil { 1463 p.err = err 1464 return false 1465 } 1466 p.current = result 1467 return true 1468} 1469 1470func (p *customIPPrefixListResultPager) PageResponse() CustomIPPrefixListResultResponse { 1471 return p.current 1472} 1473 1474// DdosProtectionPlanListResultPager provides iteration over DdosProtectionPlanListResult pages. 1475type DdosProtectionPlanListResultPager interface { 1476 azcore.Pager 1477 1478 // PageResponse returns the current DdosProtectionPlanListResultResponse. 1479 PageResponse() DdosProtectionPlanListResultResponse 1480} 1481 1482type ddosProtectionPlanListResultCreateRequest func(context.Context) (*azcore.Request, error) 1483 1484type ddosProtectionPlanListResultHandleError func(*azcore.Response) error 1485 1486type ddosProtectionPlanListResultHandleResponse func(*azcore.Response) (DdosProtectionPlanListResultResponse, error) 1487 1488type ddosProtectionPlanListResultAdvancePage func(context.Context, DdosProtectionPlanListResultResponse) (*azcore.Request, error) 1489 1490type ddosProtectionPlanListResultPager struct { 1491 // the pipeline for making the request 1492 pipeline azcore.Pipeline 1493 // creates the initial request (non-LRO case) 1494 requester ddosProtectionPlanListResultCreateRequest 1495 // callback for handling response errors 1496 errorer ddosProtectionPlanListResultHandleError 1497 // callback for handling the HTTP response 1498 responder ddosProtectionPlanListResultHandleResponse 1499 // callback for advancing to the next page 1500 advancer ddosProtectionPlanListResultAdvancePage 1501 // contains the current response 1502 current DdosProtectionPlanListResultResponse 1503 // status codes for successful retrieval 1504 statusCodes []int 1505 // any error encountered 1506 err error 1507} 1508 1509func (p *ddosProtectionPlanListResultPager) Err() error { 1510 return p.err 1511} 1512 1513func (p *ddosProtectionPlanListResultPager) NextPage(ctx context.Context) bool { 1514 var req *azcore.Request 1515 var err error 1516 if !reflect.ValueOf(p.current).IsZero() { 1517 if p.current.DdosProtectionPlanListResult.NextLink == nil || len(*p.current.DdosProtectionPlanListResult.NextLink) == 0 { 1518 return false 1519 } 1520 req, err = p.advancer(ctx, p.current) 1521 } else { 1522 req, err = p.requester(ctx) 1523 } 1524 if err != nil { 1525 p.err = err 1526 return false 1527 } 1528 resp, err := p.pipeline.Do(req) 1529 if err != nil { 1530 p.err = err 1531 return false 1532 } 1533 if !resp.HasStatusCode(p.statusCodes...) { 1534 p.err = p.errorer(resp) 1535 return false 1536 } 1537 result, err := p.responder(resp) 1538 if err != nil { 1539 p.err = err 1540 return false 1541 } 1542 p.current = result 1543 return true 1544} 1545 1546func (p *ddosProtectionPlanListResultPager) PageResponse() DdosProtectionPlanListResultResponse { 1547 return p.current 1548} 1549 1550// DscpConfigurationListResultPager provides iteration over DscpConfigurationListResult pages. 1551type DscpConfigurationListResultPager interface { 1552 azcore.Pager 1553 1554 // PageResponse returns the current DscpConfigurationListResultResponse. 1555 PageResponse() DscpConfigurationListResultResponse 1556} 1557 1558type dscpConfigurationListResultCreateRequest func(context.Context) (*azcore.Request, error) 1559 1560type dscpConfigurationListResultHandleError func(*azcore.Response) error 1561 1562type dscpConfigurationListResultHandleResponse func(*azcore.Response) (DscpConfigurationListResultResponse, error) 1563 1564type dscpConfigurationListResultAdvancePage func(context.Context, DscpConfigurationListResultResponse) (*azcore.Request, error) 1565 1566type dscpConfigurationListResultPager struct { 1567 // the pipeline for making the request 1568 pipeline azcore.Pipeline 1569 // creates the initial request (non-LRO case) 1570 requester dscpConfigurationListResultCreateRequest 1571 // callback for handling response errors 1572 errorer dscpConfigurationListResultHandleError 1573 // callback for handling the HTTP response 1574 responder dscpConfigurationListResultHandleResponse 1575 // callback for advancing to the next page 1576 advancer dscpConfigurationListResultAdvancePage 1577 // contains the current response 1578 current DscpConfigurationListResultResponse 1579 // status codes for successful retrieval 1580 statusCodes []int 1581 // any error encountered 1582 err error 1583} 1584 1585func (p *dscpConfigurationListResultPager) Err() error { 1586 return p.err 1587} 1588 1589func (p *dscpConfigurationListResultPager) NextPage(ctx context.Context) bool { 1590 var req *azcore.Request 1591 var err error 1592 if !reflect.ValueOf(p.current).IsZero() { 1593 if p.current.DscpConfigurationListResult.NextLink == nil || len(*p.current.DscpConfigurationListResult.NextLink) == 0 { 1594 return false 1595 } 1596 req, err = p.advancer(ctx, p.current) 1597 } else { 1598 req, err = p.requester(ctx) 1599 } 1600 if err != nil { 1601 p.err = err 1602 return false 1603 } 1604 resp, err := p.pipeline.Do(req) 1605 if err != nil { 1606 p.err = err 1607 return false 1608 } 1609 if !resp.HasStatusCode(p.statusCodes...) { 1610 p.err = p.errorer(resp) 1611 return false 1612 } 1613 result, err := p.responder(resp) 1614 if err != nil { 1615 p.err = err 1616 return false 1617 } 1618 p.current = result 1619 return true 1620} 1621 1622func (p *dscpConfigurationListResultPager) PageResponse() DscpConfigurationListResultResponse { 1623 return p.current 1624} 1625 1626// EndpointServicesListResultPager provides iteration over EndpointServicesListResult pages. 1627type EndpointServicesListResultPager interface { 1628 azcore.Pager 1629 1630 // PageResponse returns the current EndpointServicesListResultResponse. 1631 PageResponse() EndpointServicesListResultResponse 1632} 1633 1634type endpointServicesListResultCreateRequest func(context.Context) (*azcore.Request, error) 1635 1636type endpointServicesListResultHandleError func(*azcore.Response) error 1637 1638type endpointServicesListResultHandleResponse func(*azcore.Response) (EndpointServicesListResultResponse, error) 1639 1640type endpointServicesListResultAdvancePage func(context.Context, EndpointServicesListResultResponse) (*azcore.Request, error) 1641 1642type endpointServicesListResultPager struct { 1643 // the pipeline for making the request 1644 pipeline azcore.Pipeline 1645 // creates the initial request (non-LRO case) 1646 requester endpointServicesListResultCreateRequest 1647 // callback for handling response errors 1648 errorer endpointServicesListResultHandleError 1649 // callback for handling the HTTP response 1650 responder endpointServicesListResultHandleResponse 1651 // callback for advancing to the next page 1652 advancer endpointServicesListResultAdvancePage 1653 // contains the current response 1654 current EndpointServicesListResultResponse 1655 // status codes for successful retrieval 1656 statusCodes []int 1657 // any error encountered 1658 err error 1659} 1660 1661func (p *endpointServicesListResultPager) Err() error { 1662 return p.err 1663} 1664 1665func (p *endpointServicesListResultPager) NextPage(ctx context.Context) bool { 1666 var req *azcore.Request 1667 var err error 1668 if !reflect.ValueOf(p.current).IsZero() { 1669 if p.current.EndpointServicesListResult.NextLink == nil || len(*p.current.EndpointServicesListResult.NextLink) == 0 { 1670 return false 1671 } 1672 req, err = p.advancer(ctx, p.current) 1673 } else { 1674 req, err = p.requester(ctx) 1675 } 1676 if err != nil { 1677 p.err = err 1678 return false 1679 } 1680 resp, err := p.pipeline.Do(req) 1681 if err != nil { 1682 p.err = err 1683 return false 1684 } 1685 if !resp.HasStatusCode(p.statusCodes...) { 1686 p.err = p.errorer(resp) 1687 return false 1688 } 1689 result, err := p.responder(resp) 1690 if err != nil { 1691 p.err = err 1692 return false 1693 } 1694 p.current = result 1695 return true 1696} 1697 1698func (p *endpointServicesListResultPager) PageResponse() EndpointServicesListResultResponse { 1699 return p.current 1700} 1701 1702// ExpressRouteCircuitConnectionListResultPager provides iteration over ExpressRouteCircuitConnectionListResult pages. 1703type ExpressRouteCircuitConnectionListResultPager interface { 1704 azcore.Pager 1705 1706 // PageResponse returns the current ExpressRouteCircuitConnectionListResultResponse. 1707 PageResponse() ExpressRouteCircuitConnectionListResultResponse 1708} 1709 1710type expressRouteCircuitConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error) 1711 1712type expressRouteCircuitConnectionListResultHandleError func(*azcore.Response) error 1713 1714type expressRouteCircuitConnectionListResultHandleResponse func(*azcore.Response) (ExpressRouteCircuitConnectionListResultResponse, error) 1715 1716type expressRouteCircuitConnectionListResultAdvancePage func(context.Context, ExpressRouteCircuitConnectionListResultResponse) (*azcore.Request, error) 1717 1718type expressRouteCircuitConnectionListResultPager struct { 1719 // the pipeline for making the request 1720 pipeline azcore.Pipeline 1721 // creates the initial request (non-LRO case) 1722 requester expressRouteCircuitConnectionListResultCreateRequest 1723 // callback for handling response errors 1724 errorer expressRouteCircuitConnectionListResultHandleError 1725 // callback for handling the HTTP response 1726 responder expressRouteCircuitConnectionListResultHandleResponse 1727 // callback for advancing to the next page 1728 advancer expressRouteCircuitConnectionListResultAdvancePage 1729 // contains the current response 1730 current ExpressRouteCircuitConnectionListResultResponse 1731 // status codes for successful retrieval 1732 statusCodes []int 1733 // any error encountered 1734 err error 1735} 1736 1737func (p *expressRouteCircuitConnectionListResultPager) Err() error { 1738 return p.err 1739} 1740 1741func (p *expressRouteCircuitConnectionListResultPager) NextPage(ctx context.Context) bool { 1742 var req *azcore.Request 1743 var err error 1744 if !reflect.ValueOf(p.current).IsZero() { 1745 if p.current.ExpressRouteCircuitConnectionListResult.NextLink == nil || len(*p.current.ExpressRouteCircuitConnectionListResult.NextLink) == 0 { 1746 return false 1747 } 1748 req, err = p.advancer(ctx, p.current) 1749 } else { 1750 req, err = p.requester(ctx) 1751 } 1752 if err != nil { 1753 p.err = err 1754 return false 1755 } 1756 resp, err := p.pipeline.Do(req) 1757 if err != nil { 1758 p.err = err 1759 return false 1760 } 1761 if !resp.HasStatusCode(p.statusCodes...) { 1762 p.err = p.errorer(resp) 1763 return false 1764 } 1765 result, err := p.responder(resp) 1766 if err != nil { 1767 p.err = err 1768 return false 1769 } 1770 p.current = result 1771 return true 1772} 1773 1774func (p *expressRouteCircuitConnectionListResultPager) PageResponse() ExpressRouteCircuitConnectionListResultResponse { 1775 return p.current 1776} 1777 1778// ExpressRouteCircuitListResultPager provides iteration over ExpressRouteCircuitListResult pages. 1779type ExpressRouteCircuitListResultPager interface { 1780 azcore.Pager 1781 1782 // PageResponse returns the current ExpressRouteCircuitListResultResponse. 1783 PageResponse() ExpressRouteCircuitListResultResponse 1784} 1785 1786type expressRouteCircuitListResultCreateRequest func(context.Context) (*azcore.Request, error) 1787 1788type expressRouteCircuitListResultHandleError func(*azcore.Response) error 1789 1790type expressRouteCircuitListResultHandleResponse func(*azcore.Response) (ExpressRouteCircuitListResultResponse, error) 1791 1792type expressRouteCircuitListResultAdvancePage func(context.Context, ExpressRouteCircuitListResultResponse) (*azcore.Request, error) 1793 1794type expressRouteCircuitListResultPager struct { 1795 // the pipeline for making the request 1796 pipeline azcore.Pipeline 1797 // creates the initial request (non-LRO case) 1798 requester expressRouteCircuitListResultCreateRequest 1799 // callback for handling response errors 1800 errorer expressRouteCircuitListResultHandleError 1801 // callback for handling the HTTP response 1802 responder expressRouteCircuitListResultHandleResponse 1803 // callback for advancing to the next page 1804 advancer expressRouteCircuitListResultAdvancePage 1805 // contains the current response 1806 current ExpressRouteCircuitListResultResponse 1807 // status codes for successful retrieval 1808 statusCodes []int 1809 // any error encountered 1810 err error 1811} 1812 1813func (p *expressRouteCircuitListResultPager) Err() error { 1814 return p.err 1815} 1816 1817func (p *expressRouteCircuitListResultPager) NextPage(ctx context.Context) bool { 1818 var req *azcore.Request 1819 var err error 1820 if !reflect.ValueOf(p.current).IsZero() { 1821 if p.current.ExpressRouteCircuitListResult.NextLink == nil || len(*p.current.ExpressRouteCircuitListResult.NextLink) == 0 { 1822 return false 1823 } 1824 req, err = p.advancer(ctx, p.current) 1825 } else { 1826 req, err = p.requester(ctx) 1827 } 1828 if err != nil { 1829 p.err = err 1830 return false 1831 } 1832 resp, err := p.pipeline.Do(req) 1833 if err != nil { 1834 p.err = err 1835 return false 1836 } 1837 if !resp.HasStatusCode(p.statusCodes...) { 1838 p.err = p.errorer(resp) 1839 return false 1840 } 1841 result, err := p.responder(resp) 1842 if err != nil { 1843 p.err = err 1844 return false 1845 } 1846 p.current = result 1847 return true 1848} 1849 1850func (p *expressRouteCircuitListResultPager) PageResponse() ExpressRouteCircuitListResultResponse { 1851 return p.current 1852} 1853 1854// ExpressRouteCircuitPeeringListResultPager provides iteration over ExpressRouteCircuitPeeringListResult pages. 1855type ExpressRouteCircuitPeeringListResultPager interface { 1856 azcore.Pager 1857 1858 // PageResponse returns the current ExpressRouteCircuitPeeringListResultResponse. 1859 PageResponse() ExpressRouteCircuitPeeringListResultResponse 1860} 1861 1862type expressRouteCircuitPeeringListResultCreateRequest func(context.Context) (*azcore.Request, error) 1863 1864type expressRouteCircuitPeeringListResultHandleError func(*azcore.Response) error 1865 1866type expressRouteCircuitPeeringListResultHandleResponse func(*azcore.Response) (ExpressRouteCircuitPeeringListResultResponse, error) 1867 1868type expressRouteCircuitPeeringListResultAdvancePage func(context.Context, ExpressRouteCircuitPeeringListResultResponse) (*azcore.Request, error) 1869 1870type expressRouteCircuitPeeringListResultPager struct { 1871 // the pipeline for making the request 1872 pipeline azcore.Pipeline 1873 // creates the initial request (non-LRO case) 1874 requester expressRouteCircuitPeeringListResultCreateRequest 1875 // callback for handling response errors 1876 errorer expressRouteCircuitPeeringListResultHandleError 1877 // callback for handling the HTTP response 1878 responder expressRouteCircuitPeeringListResultHandleResponse 1879 // callback for advancing to the next page 1880 advancer expressRouteCircuitPeeringListResultAdvancePage 1881 // contains the current response 1882 current ExpressRouteCircuitPeeringListResultResponse 1883 // status codes for successful retrieval 1884 statusCodes []int 1885 // any error encountered 1886 err error 1887} 1888 1889func (p *expressRouteCircuitPeeringListResultPager) Err() error { 1890 return p.err 1891} 1892 1893func (p *expressRouteCircuitPeeringListResultPager) NextPage(ctx context.Context) bool { 1894 var req *azcore.Request 1895 var err error 1896 if !reflect.ValueOf(p.current).IsZero() { 1897 if p.current.ExpressRouteCircuitPeeringListResult.NextLink == nil || len(*p.current.ExpressRouteCircuitPeeringListResult.NextLink) == 0 { 1898 return false 1899 } 1900 req, err = p.advancer(ctx, p.current) 1901 } else { 1902 req, err = p.requester(ctx) 1903 } 1904 if err != nil { 1905 p.err = err 1906 return false 1907 } 1908 resp, err := p.pipeline.Do(req) 1909 if err != nil { 1910 p.err = err 1911 return false 1912 } 1913 if !resp.HasStatusCode(p.statusCodes...) { 1914 p.err = p.errorer(resp) 1915 return false 1916 } 1917 result, err := p.responder(resp) 1918 if err != nil { 1919 p.err = err 1920 return false 1921 } 1922 p.current = result 1923 return true 1924} 1925 1926func (p *expressRouteCircuitPeeringListResultPager) PageResponse() ExpressRouteCircuitPeeringListResultResponse { 1927 return p.current 1928} 1929 1930// ExpressRouteCrossConnectionListResultPager provides iteration over ExpressRouteCrossConnectionListResult pages. 1931type ExpressRouteCrossConnectionListResultPager interface { 1932 azcore.Pager 1933 1934 // PageResponse returns the current ExpressRouteCrossConnectionListResultResponse. 1935 PageResponse() ExpressRouteCrossConnectionListResultResponse 1936} 1937 1938type expressRouteCrossConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error) 1939 1940type expressRouteCrossConnectionListResultHandleError func(*azcore.Response) error 1941 1942type expressRouteCrossConnectionListResultHandleResponse func(*azcore.Response) (ExpressRouteCrossConnectionListResultResponse, error) 1943 1944type expressRouteCrossConnectionListResultAdvancePage func(context.Context, ExpressRouteCrossConnectionListResultResponse) (*azcore.Request, error) 1945 1946type expressRouteCrossConnectionListResultPager struct { 1947 // the pipeline for making the request 1948 pipeline azcore.Pipeline 1949 // creates the initial request (non-LRO case) 1950 requester expressRouteCrossConnectionListResultCreateRequest 1951 // callback for handling response errors 1952 errorer expressRouteCrossConnectionListResultHandleError 1953 // callback for handling the HTTP response 1954 responder expressRouteCrossConnectionListResultHandleResponse 1955 // callback for advancing to the next page 1956 advancer expressRouteCrossConnectionListResultAdvancePage 1957 // contains the current response 1958 current ExpressRouteCrossConnectionListResultResponse 1959 // status codes for successful retrieval 1960 statusCodes []int 1961 // any error encountered 1962 err error 1963} 1964 1965func (p *expressRouteCrossConnectionListResultPager) Err() error { 1966 return p.err 1967} 1968 1969func (p *expressRouteCrossConnectionListResultPager) NextPage(ctx context.Context) bool { 1970 var req *azcore.Request 1971 var err error 1972 if !reflect.ValueOf(p.current).IsZero() { 1973 if p.current.ExpressRouteCrossConnectionListResult.NextLink == nil || len(*p.current.ExpressRouteCrossConnectionListResult.NextLink) == 0 { 1974 return false 1975 } 1976 req, err = p.advancer(ctx, p.current) 1977 } else { 1978 req, err = p.requester(ctx) 1979 } 1980 if err != nil { 1981 p.err = err 1982 return false 1983 } 1984 resp, err := p.pipeline.Do(req) 1985 if err != nil { 1986 p.err = err 1987 return false 1988 } 1989 if !resp.HasStatusCode(p.statusCodes...) { 1990 p.err = p.errorer(resp) 1991 return false 1992 } 1993 result, err := p.responder(resp) 1994 if err != nil { 1995 p.err = err 1996 return false 1997 } 1998 p.current = result 1999 return true 2000} 2001 2002func (p *expressRouteCrossConnectionListResultPager) PageResponse() ExpressRouteCrossConnectionListResultResponse { 2003 return p.current 2004} 2005 2006// ExpressRouteCrossConnectionPeeringListPager provides iteration over ExpressRouteCrossConnectionPeeringList pages. 2007type ExpressRouteCrossConnectionPeeringListPager interface { 2008 azcore.Pager 2009 2010 // PageResponse returns the current ExpressRouteCrossConnectionPeeringListResponse. 2011 PageResponse() ExpressRouteCrossConnectionPeeringListResponse 2012} 2013 2014type expressRouteCrossConnectionPeeringListCreateRequest func(context.Context) (*azcore.Request, error) 2015 2016type expressRouteCrossConnectionPeeringListHandleError func(*azcore.Response) error 2017 2018type expressRouteCrossConnectionPeeringListHandleResponse func(*azcore.Response) (ExpressRouteCrossConnectionPeeringListResponse, error) 2019 2020type expressRouteCrossConnectionPeeringListAdvancePage func(context.Context, ExpressRouteCrossConnectionPeeringListResponse) (*azcore.Request, error) 2021 2022type expressRouteCrossConnectionPeeringListPager struct { 2023 // the pipeline for making the request 2024 pipeline azcore.Pipeline 2025 // creates the initial request (non-LRO case) 2026 requester expressRouteCrossConnectionPeeringListCreateRequest 2027 // callback for handling response errors 2028 errorer expressRouteCrossConnectionPeeringListHandleError 2029 // callback for handling the HTTP response 2030 responder expressRouteCrossConnectionPeeringListHandleResponse 2031 // callback for advancing to the next page 2032 advancer expressRouteCrossConnectionPeeringListAdvancePage 2033 // contains the current response 2034 current ExpressRouteCrossConnectionPeeringListResponse 2035 // status codes for successful retrieval 2036 statusCodes []int 2037 // any error encountered 2038 err error 2039} 2040 2041func (p *expressRouteCrossConnectionPeeringListPager) Err() error { 2042 return p.err 2043} 2044 2045func (p *expressRouteCrossConnectionPeeringListPager) NextPage(ctx context.Context) bool { 2046 var req *azcore.Request 2047 var err error 2048 if !reflect.ValueOf(p.current).IsZero() { 2049 if p.current.ExpressRouteCrossConnectionPeeringList.NextLink == nil || len(*p.current.ExpressRouteCrossConnectionPeeringList.NextLink) == 0 { 2050 return false 2051 } 2052 req, err = p.advancer(ctx, p.current) 2053 } else { 2054 req, err = p.requester(ctx) 2055 } 2056 if err != nil { 2057 p.err = err 2058 return false 2059 } 2060 resp, err := p.pipeline.Do(req) 2061 if err != nil { 2062 p.err = err 2063 return false 2064 } 2065 if !resp.HasStatusCode(p.statusCodes...) { 2066 p.err = p.errorer(resp) 2067 return false 2068 } 2069 result, err := p.responder(resp) 2070 if err != nil { 2071 p.err = err 2072 return false 2073 } 2074 p.current = result 2075 return true 2076} 2077 2078func (p *expressRouteCrossConnectionPeeringListPager) PageResponse() ExpressRouteCrossConnectionPeeringListResponse { 2079 return p.current 2080} 2081 2082// ExpressRouteLinkListResultPager provides iteration over ExpressRouteLinkListResult pages. 2083type ExpressRouteLinkListResultPager interface { 2084 azcore.Pager 2085 2086 // PageResponse returns the current ExpressRouteLinkListResultResponse. 2087 PageResponse() ExpressRouteLinkListResultResponse 2088} 2089 2090type expressRouteLinkListResultCreateRequest func(context.Context) (*azcore.Request, error) 2091 2092type expressRouteLinkListResultHandleError func(*azcore.Response) error 2093 2094type expressRouteLinkListResultHandleResponse func(*azcore.Response) (ExpressRouteLinkListResultResponse, error) 2095 2096type expressRouteLinkListResultAdvancePage func(context.Context, ExpressRouteLinkListResultResponse) (*azcore.Request, error) 2097 2098type expressRouteLinkListResultPager struct { 2099 // the pipeline for making the request 2100 pipeline azcore.Pipeline 2101 // creates the initial request (non-LRO case) 2102 requester expressRouteLinkListResultCreateRequest 2103 // callback for handling response errors 2104 errorer expressRouteLinkListResultHandleError 2105 // callback for handling the HTTP response 2106 responder expressRouteLinkListResultHandleResponse 2107 // callback for advancing to the next page 2108 advancer expressRouteLinkListResultAdvancePage 2109 // contains the current response 2110 current ExpressRouteLinkListResultResponse 2111 // status codes for successful retrieval 2112 statusCodes []int 2113 // any error encountered 2114 err error 2115} 2116 2117func (p *expressRouteLinkListResultPager) Err() error { 2118 return p.err 2119} 2120 2121func (p *expressRouteLinkListResultPager) NextPage(ctx context.Context) bool { 2122 var req *azcore.Request 2123 var err error 2124 if !reflect.ValueOf(p.current).IsZero() { 2125 if p.current.ExpressRouteLinkListResult.NextLink == nil || len(*p.current.ExpressRouteLinkListResult.NextLink) == 0 { 2126 return false 2127 } 2128 req, err = p.advancer(ctx, p.current) 2129 } else { 2130 req, err = p.requester(ctx) 2131 } 2132 if err != nil { 2133 p.err = err 2134 return false 2135 } 2136 resp, err := p.pipeline.Do(req) 2137 if err != nil { 2138 p.err = err 2139 return false 2140 } 2141 if !resp.HasStatusCode(p.statusCodes...) { 2142 p.err = p.errorer(resp) 2143 return false 2144 } 2145 result, err := p.responder(resp) 2146 if err != nil { 2147 p.err = err 2148 return false 2149 } 2150 p.current = result 2151 return true 2152} 2153 2154func (p *expressRouteLinkListResultPager) PageResponse() ExpressRouteLinkListResultResponse { 2155 return p.current 2156} 2157 2158// ExpressRoutePortListResultPager provides iteration over ExpressRoutePortListResult pages. 2159type ExpressRoutePortListResultPager interface { 2160 azcore.Pager 2161 2162 // PageResponse returns the current ExpressRoutePortListResultResponse. 2163 PageResponse() ExpressRoutePortListResultResponse 2164} 2165 2166type expressRoutePortListResultCreateRequest func(context.Context) (*azcore.Request, error) 2167 2168type expressRoutePortListResultHandleError func(*azcore.Response) error 2169 2170type expressRoutePortListResultHandleResponse func(*azcore.Response) (ExpressRoutePortListResultResponse, error) 2171 2172type expressRoutePortListResultAdvancePage func(context.Context, ExpressRoutePortListResultResponse) (*azcore.Request, error) 2173 2174type expressRoutePortListResultPager struct { 2175 // the pipeline for making the request 2176 pipeline azcore.Pipeline 2177 // creates the initial request (non-LRO case) 2178 requester expressRoutePortListResultCreateRequest 2179 // callback for handling response errors 2180 errorer expressRoutePortListResultHandleError 2181 // callback for handling the HTTP response 2182 responder expressRoutePortListResultHandleResponse 2183 // callback for advancing to the next page 2184 advancer expressRoutePortListResultAdvancePage 2185 // contains the current response 2186 current ExpressRoutePortListResultResponse 2187 // status codes for successful retrieval 2188 statusCodes []int 2189 // any error encountered 2190 err error 2191} 2192 2193func (p *expressRoutePortListResultPager) Err() error { 2194 return p.err 2195} 2196 2197func (p *expressRoutePortListResultPager) NextPage(ctx context.Context) bool { 2198 var req *azcore.Request 2199 var err error 2200 if !reflect.ValueOf(p.current).IsZero() { 2201 if p.current.ExpressRoutePortListResult.NextLink == nil || len(*p.current.ExpressRoutePortListResult.NextLink) == 0 { 2202 return false 2203 } 2204 req, err = p.advancer(ctx, p.current) 2205 } else { 2206 req, err = p.requester(ctx) 2207 } 2208 if err != nil { 2209 p.err = err 2210 return false 2211 } 2212 resp, err := p.pipeline.Do(req) 2213 if err != nil { 2214 p.err = err 2215 return false 2216 } 2217 if !resp.HasStatusCode(p.statusCodes...) { 2218 p.err = p.errorer(resp) 2219 return false 2220 } 2221 result, err := p.responder(resp) 2222 if err != nil { 2223 p.err = err 2224 return false 2225 } 2226 p.current = result 2227 return true 2228} 2229 2230func (p *expressRoutePortListResultPager) PageResponse() ExpressRoutePortListResultResponse { 2231 return p.current 2232} 2233 2234// ExpressRoutePortsLocationListResultPager provides iteration over ExpressRoutePortsLocationListResult pages. 2235type ExpressRoutePortsLocationListResultPager interface { 2236 azcore.Pager 2237 2238 // PageResponse returns the current ExpressRoutePortsLocationListResultResponse. 2239 PageResponse() ExpressRoutePortsLocationListResultResponse 2240} 2241 2242type expressRoutePortsLocationListResultCreateRequest func(context.Context) (*azcore.Request, error) 2243 2244type expressRoutePortsLocationListResultHandleError func(*azcore.Response) error 2245 2246type expressRoutePortsLocationListResultHandleResponse func(*azcore.Response) (ExpressRoutePortsLocationListResultResponse, error) 2247 2248type expressRoutePortsLocationListResultAdvancePage func(context.Context, ExpressRoutePortsLocationListResultResponse) (*azcore.Request, error) 2249 2250type expressRoutePortsLocationListResultPager struct { 2251 // the pipeline for making the request 2252 pipeline azcore.Pipeline 2253 // creates the initial request (non-LRO case) 2254 requester expressRoutePortsLocationListResultCreateRequest 2255 // callback for handling response errors 2256 errorer expressRoutePortsLocationListResultHandleError 2257 // callback for handling the HTTP response 2258 responder expressRoutePortsLocationListResultHandleResponse 2259 // callback for advancing to the next page 2260 advancer expressRoutePortsLocationListResultAdvancePage 2261 // contains the current response 2262 current ExpressRoutePortsLocationListResultResponse 2263 // status codes for successful retrieval 2264 statusCodes []int 2265 // any error encountered 2266 err error 2267} 2268 2269func (p *expressRoutePortsLocationListResultPager) Err() error { 2270 return p.err 2271} 2272 2273func (p *expressRoutePortsLocationListResultPager) NextPage(ctx context.Context) bool { 2274 var req *azcore.Request 2275 var err error 2276 if !reflect.ValueOf(p.current).IsZero() { 2277 if p.current.ExpressRoutePortsLocationListResult.NextLink == nil || len(*p.current.ExpressRoutePortsLocationListResult.NextLink) == 0 { 2278 return false 2279 } 2280 req, err = p.advancer(ctx, p.current) 2281 } else { 2282 req, err = p.requester(ctx) 2283 } 2284 if err != nil { 2285 p.err = err 2286 return false 2287 } 2288 resp, err := p.pipeline.Do(req) 2289 if err != nil { 2290 p.err = err 2291 return false 2292 } 2293 if !resp.HasStatusCode(p.statusCodes...) { 2294 p.err = p.errorer(resp) 2295 return false 2296 } 2297 result, err := p.responder(resp) 2298 if err != nil { 2299 p.err = err 2300 return false 2301 } 2302 p.current = result 2303 return true 2304} 2305 2306func (p *expressRoutePortsLocationListResultPager) PageResponse() ExpressRoutePortsLocationListResultResponse { 2307 return p.current 2308} 2309 2310// ExpressRouteServiceProviderListResultPager provides iteration over ExpressRouteServiceProviderListResult pages. 2311type ExpressRouteServiceProviderListResultPager interface { 2312 azcore.Pager 2313 2314 // PageResponse returns the current ExpressRouteServiceProviderListResultResponse. 2315 PageResponse() ExpressRouteServiceProviderListResultResponse 2316} 2317 2318type expressRouteServiceProviderListResultCreateRequest func(context.Context) (*azcore.Request, error) 2319 2320type expressRouteServiceProviderListResultHandleError func(*azcore.Response) error 2321 2322type expressRouteServiceProviderListResultHandleResponse func(*azcore.Response) (ExpressRouteServiceProviderListResultResponse, error) 2323 2324type expressRouteServiceProviderListResultAdvancePage func(context.Context, ExpressRouteServiceProviderListResultResponse) (*azcore.Request, error) 2325 2326type expressRouteServiceProviderListResultPager struct { 2327 // the pipeline for making the request 2328 pipeline azcore.Pipeline 2329 // creates the initial request (non-LRO case) 2330 requester expressRouteServiceProviderListResultCreateRequest 2331 // callback for handling response errors 2332 errorer expressRouteServiceProviderListResultHandleError 2333 // callback for handling the HTTP response 2334 responder expressRouteServiceProviderListResultHandleResponse 2335 // callback for advancing to the next page 2336 advancer expressRouteServiceProviderListResultAdvancePage 2337 // contains the current response 2338 current ExpressRouteServiceProviderListResultResponse 2339 // status codes for successful retrieval 2340 statusCodes []int 2341 // any error encountered 2342 err error 2343} 2344 2345func (p *expressRouteServiceProviderListResultPager) Err() error { 2346 return p.err 2347} 2348 2349func (p *expressRouteServiceProviderListResultPager) NextPage(ctx context.Context) bool { 2350 var req *azcore.Request 2351 var err error 2352 if !reflect.ValueOf(p.current).IsZero() { 2353 if p.current.ExpressRouteServiceProviderListResult.NextLink == nil || len(*p.current.ExpressRouteServiceProviderListResult.NextLink) == 0 { 2354 return false 2355 } 2356 req, err = p.advancer(ctx, p.current) 2357 } else { 2358 req, err = p.requester(ctx) 2359 } 2360 if err != nil { 2361 p.err = err 2362 return false 2363 } 2364 resp, err := p.pipeline.Do(req) 2365 if err != nil { 2366 p.err = err 2367 return false 2368 } 2369 if !resp.HasStatusCode(p.statusCodes...) { 2370 p.err = p.errorer(resp) 2371 return false 2372 } 2373 result, err := p.responder(resp) 2374 if err != nil { 2375 p.err = err 2376 return false 2377 } 2378 p.current = result 2379 return true 2380} 2381 2382func (p *expressRouteServiceProviderListResultPager) PageResponse() ExpressRouteServiceProviderListResultResponse { 2383 return p.current 2384} 2385 2386// FirewallPolicyListResultPager provides iteration over FirewallPolicyListResult pages. 2387type FirewallPolicyListResultPager interface { 2388 azcore.Pager 2389 2390 // PageResponse returns the current FirewallPolicyListResultResponse. 2391 PageResponse() FirewallPolicyListResultResponse 2392} 2393 2394type firewallPolicyListResultCreateRequest func(context.Context) (*azcore.Request, error) 2395 2396type firewallPolicyListResultHandleError func(*azcore.Response) error 2397 2398type firewallPolicyListResultHandleResponse func(*azcore.Response) (FirewallPolicyListResultResponse, error) 2399 2400type firewallPolicyListResultAdvancePage func(context.Context, FirewallPolicyListResultResponse) (*azcore.Request, error) 2401 2402type firewallPolicyListResultPager struct { 2403 // the pipeline for making the request 2404 pipeline azcore.Pipeline 2405 // creates the initial request (non-LRO case) 2406 requester firewallPolicyListResultCreateRequest 2407 // callback for handling response errors 2408 errorer firewallPolicyListResultHandleError 2409 // callback for handling the HTTP response 2410 responder firewallPolicyListResultHandleResponse 2411 // callback for advancing to the next page 2412 advancer firewallPolicyListResultAdvancePage 2413 // contains the current response 2414 current FirewallPolicyListResultResponse 2415 // status codes for successful retrieval 2416 statusCodes []int 2417 // any error encountered 2418 err error 2419} 2420 2421func (p *firewallPolicyListResultPager) Err() error { 2422 return p.err 2423} 2424 2425func (p *firewallPolicyListResultPager) NextPage(ctx context.Context) bool { 2426 var req *azcore.Request 2427 var err error 2428 if !reflect.ValueOf(p.current).IsZero() { 2429 if p.current.FirewallPolicyListResult.NextLink == nil || len(*p.current.FirewallPolicyListResult.NextLink) == 0 { 2430 return false 2431 } 2432 req, err = p.advancer(ctx, p.current) 2433 } else { 2434 req, err = p.requester(ctx) 2435 } 2436 if err != nil { 2437 p.err = err 2438 return false 2439 } 2440 resp, err := p.pipeline.Do(req) 2441 if err != nil { 2442 p.err = err 2443 return false 2444 } 2445 if !resp.HasStatusCode(p.statusCodes...) { 2446 p.err = p.errorer(resp) 2447 return false 2448 } 2449 result, err := p.responder(resp) 2450 if err != nil { 2451 p.err = err 2452 return false 2453 } 2454 p.current = result 2455 return true 2456} 2457 2458func (p *firewallPolicyListResultPager) PageResponse() FirewallPolicyListResultResponse { 2459 return p.current 2460} 2461 2462// FirewallPolicyRuleCollectionGroupListResultPager provides iteration over FirewallPolicyRuleCollectionGroupListResult pages. 2463type FirewallPolicyRuleCollectionGroupListResultPager interface { 2464 azcore.Pager 2465 2466 // PageResponse returns the current FirewallPolicyRuleCollectionGroupListResultResponse. 2467 PageResponse() FirewallPolicyRuleCollectionGroupListResultResponse 2468} 2469 2470type firewallPolicyRuleCollectionGroupListResultCreateRequest func(context.Context) (*azcore.Request, error) 2471 2472type firewallPolicyRuleCollectionGroupListResultHandleError func(*azcore.Response) error 2473 2474type firewallPolicyRuleCollectionGroupListResultHandleResponse func(*azcore.Response) (FirewallPolicyRuleCollectionGroupListResultResponse, error) 2475 2476type firewallPolicyRuleCollectionGroupListResultAdvancePage func(context.Context, FirewallPolicyRuleCollectionGroupListResultResponse) (*azcore.Request, error) 2477 2478type firewallPolicyRuleCollectionGroupListResultPager struct { 2479 // the pipeline for making the request 2480 pipeline azcore.Pipeline 2481 // creates the initial request (non-LRO case) 2482 requester firewallPolicyRuleCollectionGroupListResultCreateRequest 2483 // callback for handling response errors 2484 errorer firewallPolicyRuleCollectionGroupListResultHandleError 2485 // callback for handling the HTTP response 2486 responder firewallPolicyRuleCollectionGroupListResultHandleResponse 2487 // callback for advancing to the next page 2488 advancer firewallPolicyRuleCollectionGroupListResultAdvancePage 2489 // contains the current response 2490 current FirewallPolicyRuleCollectionGroupListResultResponse 2491 // status codes for successful retrieval 2492 statusCodes []int 2493 // any error encountered 2494 err error 2495} 2496 2497func (p *firewallPolicyRuleCollectionGroupListResultPager) Err() error { 2498 return p.err 2499} 2500 2501func (p *firewallPolicyRuleCollectionGroupListResultPager) NextPage(ctx context.Context) bool { 2502 var req *azcore.Request 2503 var err error 2504 if !reflect.ValueOf(p.current).IsZero() { 2505 if p.current.FirewallPolicyRuleCollectionGroupListResult.NextLink == nil || len(*p.current.FirewallPolicyRuleCollectionGroupListResult.NextLink) == 0 { 2506 return false 2507 } 2508 req, err = p.advancer(ctx, p.current) 2509 } else { 2510 req, err = p.requester(ctx) 2511 } 2512 if err != nil { 2513 p.err = err 2514 return false 2515 } 2516 resp, err := p.pipeline.Do(req) 2517 if err != nil { 2518 p.err = err 2519 return false 2520 } 2521 if !resp.HasStatusCode(p.statusCodes...) { 2522 p.err = p.errorer(resp) 2523 return false 2524 } 2525 result, err := p.responder(resp) 2526 if err != nil { 2527 p.err = err 2528 return false 2529 } 2530 p.current = result 2531 return true 2532} 2533 2534func (p *firewallPolicyRuleCollectionGroupListResultPager) PageResponse() FirewallPolicyRuleCollectionGroupListResultResponse { 2535 return p.current 2536} 2537 2538// FlowLogListResultPager provides iteration over FlowLogListResult pages. 2539type FlowLogListResultPager interface { 2540 azcore.Pager 2541 2542 // PageResponse returns the current FlowLogListResultResponse. 2543 PageResponse() FlowLogListResultResponse 2544} 2545 2546type flowLogListResultCreateRequest func(context.Context) (*azcore.Request, error) 2547 2548type flowLogListResultHandleError func(*azcore.Response) error 2549 2550type flowLogListResultHandleResponse func(*azcore.Response) (FlowLogListResultResponse, error) 2551 2552type flowLogListResultAdvancePage func(context.Context, FlowLogListResultResponse) (*azcore.Request, error) 2553 2554type flowLogListResultPager struct { 2555 // the pipeline for making the request 2556 pipeline azcore.Pipeline 2557 // creates the initial request (non-LRO case) 2558 requester flowLogListResultCreateRequest 2559 // callback for handling response errors 2560 errorer flowLogListResultHandleError 2561 // callback for handling the HTTP response 2562 responder flowLogListResultHandleResponse 2563 // callback for advancing to the next page 2564 advancer flowLogListResultAdvancePage 2565 // contains the current response 2566 current FlowLogListResultResponse 2567 // status codes for successful retrieval 2568 statusCodes []int 2569 // any error encountered 2570 err error 2571} 2572 2573func (p *flowLogListResultPager) Err() error { 2574 return p.err 2575} 2576 2577func (p *flowLogListResultPager) NextPage(ctx context.Context) bool { 2578 var req *azcore.Request 2579 var err error 2580 if !reflect.ValueOf(p.current).IsZero() { 2581 if p.current.FlowLogListResult.NextLink == nil || len(*p.current.FlowLogListResult.NextLink) == 0 { 2582 return false 2583 } 2584 req, err = p.advancer(ctx, p.current) 2585 } else { 2586 req, err = p.requester(ctx) 2587 } 2588 if err != nil { 2589 p.err = err 2590 return false 2591 } 2592 resp, err := p.pipeline.Do(req) 2593 if err != nil { 2594 p.err = err 2595 return false 2596 } 2597 if !resp.HasStatusCode(p.statusCodes...) { 2598 p.err = p.errorer(resp) 2599 return false 2600 } 2601 result, err := p.responder(resp) 2602 if err != nil { 2603 p.err = err 2604 return false 2605 } 2606 p.current = result 2607 return true 2608} 2609 2610func (p *flowLogListResultPager) PageResponse() FlowLogListResultResponse { 2611 return p.current 2612} 2613 2614// IPAllocationListResultPager provides iteration over IPAllocationListResult pages. 2615type IPAllocationListResultPager interface { 2616 azcore.Pager 2617 2618 // PageResponse returns the current IPAllocationListResultResponse. 2619 PageResponse() IPAllocationListResultResponse 2620} 2621 2622type ipAllocationListResultCreateRequest func(context.Context) (*azcore.Request, error) 2623 2624type ipAllocationListResultHandleError func(*azcore.Response) error 2625 2626type ipAllocationListResultHandleResponse func(*azcore.Response) (IPAllocationListResultResponse, error) 2627 2628type ipAllocationListResultAdvancePage func(context.Context, IPAllocationListResultResponse) (*azcore.Request, error) 2629 2630type ipAllocationListResultPager struct { 2631 // the pipeline for making the request 2632 pipeline azcore.Pipeline 2633 // creates the initial request (non-LRO case) 2634 requester ipAllocationListResultCreateRequest 2635 // callback for handling response errors 2636 errorer ipAllocationListResultHandleError 2637 // callback for handling the HTTP response 2638 responder ipAllocationListResultHandleResponse 2639 // callback for advancing to the next page 2640 advancer ipAllocationListResultAdvancePage 2641 // contains the current response 2642 current IPAllocationListResultResponse 2643 // status codes for successful retrieval 2644 statusCodes []int 2645 // any error encountered 2646 err error 2647} 2648 2649func (p *ipAllocationListResultPager) Err() error { 2650 return p.err 2651} 2652 2653func (p *ipAllocationListResultPager) NextPage(ctx context.Context) bool { 2654 var req *azcore.Request 2655 var err error 2656 if !reflect.ValueOf(p.current).IsZero() { 2657 if p.current.IPAllocationListResult.NextLink == nil || len(*p.current.IPAllocationListResult.NextLink) == 0 { 2658 return false 2659 } 2660 req, err = p.advancer(ctx, p.current) 2661 } else { 2662 req, err = p.requester(ctx) 2663 } 2664 if err != nil { 2665 p.err = err 2666 return false 2667 } 2668 resp, err := p.pipeline.Do(req) 2669 if err != nil { 2670 p.err = err 2671 return false 2672 } 2673 if !resp.HasStatusCode(p.statusCodes...) { 2674 p.err = p.errorer(resp) 2675 return false 2676 } 2677 result, err := p.responder(resp) 2678 if err != nil { 2679 p.err = err 2680 return false 2681 } 2682 p.current = result 2683 return true 2684} 2685 2686func (p *ipAllocationListResultPager) PageResponse() IPAllocationListResultResponse { 2687 return p.current 2688} 2689 2690// IPGroupListResultPager provides iteration over IPGroupListResult pages. 2691type IPGroupListResultPager interface { 2692 azcore.Pager 2693 2694 // PageResponse returns the current IPGroupListResultResponse. 2695 PageResponse() IPGroupListResultResponse 2696} 2697 2698type ipGroupListResultCreateRequest func(context.Context) (*azcore.Request, error) 2699 2700type ipGroupListResultHandleError func(*azcore.Response) error 2701 2702type ipGroupListResultHandleResponse func(*azcore.Response) (IPGroupListResultResponse, error) 2703 2704type ipGroupListResultAdvancePage func(context.Context, IPGroupListResultResponse) (*azcore.Request, error) 2705 2706type ipGroupListResultPager struct { 2707 // the pipeline for making the request 2708 pipeline azcore.Pipeline 2709 // creates the initial request (non-LRO case) 2710 requester ipGroupListResultCreateRequest 2711 // callback for handling response errors 2712 errorer ipGroupListResultHandleError 2713 // callback for handling the HTTP response 2714 responder ipGroupListResultHandleResponse 2715 // callback for advancing to the next page 2716 advancer ipGroupListResultAdvancePage 2717 // contains the current response 2718 current IPGroupListResultResponse 2719 // status codes for successful retrieval 2720 statusCodes []int 2721 // any error encountered 2722 err error 2723} 2724 2725func (p *ipGroupListResultPager) Err() error { 2726 return p.err 2727} 2728 2729func (p *ipGroupListResultPager) NextPage(ctx context.Context) bool { 2730 var req *azcore.Request 2731 var err error 2732 if !reflect.ValueOf(p.current).IsZero() { 2733 if p.current.IPGroupListResult.NextLink == nil || len(*p.current.IPGroupListResult.NextLink) == 0 { 2734 return false 2735 } 2736 req, err = p.advancer(ctx, p.current) 2737 } else { 2738 req, err = p.requester(ctx) 2739 } 2740 if err != nil { 2741 p.err = err 2742 return false 2743 } 2744 resp, err := p.pipeline.Do(req) 2745 if err != nil { 2746 p.err = err 2747 return false 2748 } 2749 if !resp.HasStatusCode(p.statusCodes...) { 2750 p.err = p.errorer(resp) 2751 return false 2752 } 2753 result, err := p.responder(resp) 2754 if err != nil { 2755 p.err = err 2756 return false 2757 } 2758 p.current = result 2759 return true 2760} 2761 2762func (p *ipGroupListResultPager) PageResponse() IPGroupListResultResponse { 2763 return p.current 2764} 2765 2766// InboundNatRuleListResultPager provides iteration over InboundNatRuleListResult pages. 2767type InboundNatRuleListResultPager interface { 2768 azcore.Pager 2769 2770 // PageResponse returns the current InboundNatRuleListResultResponse. 2771 PageResponse() InboundNatRuleListResultResponse 2772} 2773 2774type inboundNatRuleListResultCreateRequest func(context.Context) (*azcore.Request, error) 2775 2776type inboundNatRuleListResultHandleError func(*azcore.Response) error 2777 2778type inboundNatRuleListResultHandleResponse func(*azcore.Response) (InboundNatRuleListResultResponse, error) 2779 2780type inboundNatRuleListResultAdvancePage func(context.Context, InboundNatRuleListResultResponse) (*azcore.Request, error) 2781 2782type inboundNatRuleListResultPager struct { 2783 // the pipeline for making the request 2784 pipeline azcore.Pipeline 2785 // creates the initial request (non-LRO case) 2786 requester inboundNatRuleListResultCreateRequest 2787 // callback for handling response errors 2788 errorer inboundNatRuleListResultHandleError 2789 // callback for handling the HTTP response 2790 responder inboundNatRuleListResultHandleResponse 2791 // callback for advancing to the next page 2792 advancer inboundNatRuleListResultAdvancePage 2793 // contains the current response 2794 current InboundNatRuleListResultResponse 2795 // status codes for successful retrieval 2796 statusCodes []int 2797 // any error encountered 2798 err error 2799} 2800 2801func (p *inboundNatRuleListResultPager) Err() error { 2802 return p.err 2803} 2804 2805func (p *inboundNatRuleListResultPager) NextPage(ctx context.Context) bool { 2806 var req *azcore.Request 2807 var err error 2808 if !reflect.ValueOf(p.current).IsZero() { 2809 if p.current.InboundNatRuleListResult.NextLink == nil || len(*p.current.InboundNatRuleListResult.NextLink) == 0 { 2810 return false 2811 } 2812 req, err = p.advancer(ctx, p.current) 2813 } else { 2814 req, err = p.requester(ctx) 2815 } 2816 if err != nil { 2817 p.err = err 2818 return false 2819 } 2820 resp, err := p.pipeline.Do(req) 2821 if err != nil { 2822 p.err = err 2823 return false 2824 } 2825 if !resp.HasStatusCode(p.statusCodes...) { 2826 p.err = p.errorer(resp) 2827 return false 2828 } 2829 result, err := p.responder(resp) 2830 if err != nil { 2831 p.err = err 2832 return false 2833 } 2834 p.current = result 2835 return true 2836} 2837 2838func (p *inboundNatRuleListResultPager) PageResponse() InboundNatRuleListResultResponse { 2839 return p.current 2840} 2841 2842// ListHubRouteTablesResultPager provides iteration over ListHubRouteTablesResult pages. 2843type ListHubRouteTablesResultPager interface { 2844 azcore.Pager 2845 2846 // PageResponse returns the current ListHubRouteTablesResultResponse. 2847 PageResponse() ListHubRouteTablesResultResponse 2848} 2849 2850type listHubRouteTablesResultCreateRequest func(context.Context) (*azcore.Request, error) 2851 2852type listHubRouteTablesResultHandleError func(*azcore.Response) error 2853 2854type listHubRouteTablesResultHandleResponse func(*azcore.Response) (ListHubRouteTablesResultResponse, error) 2855 2856type listHubRouteTablesResultAdvancePage func(context.Context, ListHubRouteTablesResultResponse) (*azcore.Request, error) 2857 2858type listHubRouteTablesResultPager struct { 2859 // the pipeline for making the request 2860 pipeline azcore.Pipeline 2861 // creates the initial request (non-LRO case) 2862 requester listHubRouteTablesResultCreateRequest 2863 // callback for handling response errors 2864 errorer listHubRouteTablesResultHandleError 2865 // callback for handling the HTTP response 2866 responder listHubRouteTablesResultHandleResponse 2867 // callback for advancing to the next page 2868 advancer listHubRouteTablesResultAdvancePage 2869 // contains the current response 2870 current ListHubRouteTablesResultResponse 2871 // status codes for successful retrieval 2872 statusCodes []int 2873 // any error encountered 2874 err error 2875} 2876 2877func (p *listHubRouteTablesResultPager) Err() error { 2878 return p.err 2879} 2880 2881func (p *listHubRouteTablesResultPager) NextPage(ctx context.Context) bool { 2882 var req *azcore.Request 2883 var err error 2884 if !reflect.ValueOf(p.current).IsZero() { 2885 if p.current.ListHubRouteTablesResult.NextLink == nil || len(*p.current.ListHubRouteTablesResult.NextLink) == 0 { 2886 return false 2887 } 2888 req, err = p.advancer(ctx, p.current) 2889 } else { 2890 req, err = p.requester(ctx) 2891 } 2892 if err != nil { 2893 p.err = err 2894 return false 2895 } 2896 resp, err := p.pipeline.Do(req) 2897 if err != nil { 2898 p.err = err 2899 return false 2900 } 2901 if !resp.HasStatusCode(p.statusCodes...) { 2902 p.err = p.errorer(resp) 2903 return false 2904 } 2905 result, err := p.responder(resp) 2906 if err != nil { 2907 p.err = err 2908 return false 2909 } 2910 p.current = result 2911 return true 2912} 2913 2914func (p *listHubRouteTablesResultPager) PageResponse() ListHubRouteTablesResultResponse { 2915 return p.current 2916} 2917 2918// ListHubVirtualNetworkConnectionsResultPager provides iteration over ListHubVirtualNetworkConnectionsResult pages. 2919type ListHubVirtualNetworkConnectionsResultPager interface { 2920 azcore.Pager 2921 2922 // PageResponse returns the current ListHubVirtualNetworkConnectionsResultResponse. 2923 PageResponse() ListHubVirtualNetworkConnectionsResultResponse 2924} 2925 2926type listHubVirtualNetworkConnectionsResultCreateRequest func(context.Context) (*azcore.Request, error) 2927 2928type listHubVirtualNetworkConnectionsResultHandleError func(*azcore.Response) error 2929 2930type listHubVirtualNetworkConnectionsResultHandleResponse func(*azcore.Response) (ListHubVirtualNetworkConnectionsResultResponse, error) 2931 2932type listHubVirtualNetworkConnectionsResultAdvancePage func(context.Context, ListHubVirtualNetworkConnectionsResultResponse) (*azcore.Request, error) 2933 2934type listHubVirtualNetworkConnectionsResultPager struct { 2935 // the pipeline for making the request 2936 pipeline azcore.Pipeline 2937 // creates the initial request (non-LRO case) 2938 requester listHubVirtualNetworkConnectionsResultCreateRequest 2939 // callback for handling response errors 2940 errorer listHubVirtualNetworkConnectionsResultHandleError 2941 // callback for handling the HTTP response 2942 responder listHubVirtualNetworkConnectionsResultHandleResponse 2943 // callback for advancing to the next page 2944 advancer listHubVirtualNetworkConnectionsResultAdvancePage 2945 // contains the current response 2946 current ListHubVirtualNetworkConnectionsResultResponse 2947 // status codes for successful retrieval 2948 statusCodes []int 2949 // any error encountered 2950 err error 2951} 2952 2953func (p *listHubVirtualNetworkConnectionsResultPager) Err() error { 2954 return p.err 2955} 2956 2957func (p *listHubVirtualNetworkConnectionsResultPager) NextPage(ctx context.Context) bool { 2958 var req *azcore.Request 2959 var err error 2960 if !reflect.ValueOf(p.current).IsZero() { 2961 if p.current.ListHubVirtualNetworkConnectionsResult.NextLink == nil || len(*p.current.ListHubVirtualNetworkConnectionsResult.NextLink) == 0 { 2962 return false 2963 } 2964 req, err = p.advancer(ctx, p.current) 2965 } else { 2966 req, err = p.requester(ctx) 2967 } 2968 if err != nil { 2969 p.err = err 2970 return false 2971 } 2972 resp, err := p.pipeline.Do(req) 2973 if err != nil { 2974 p.err = err 2975 return false 2976 } 2977 if !resp.HasStatusCode(p.statusCodes...) { 2978 p.err = p.errorer(resp) 2979 return false 2980 } 2981 result, err := p.responder(resp) 2982 if err != nil { 2983 p.err = err 2984 return false 2985 } 2986 p.current = result 2987 return true 2988} 2989 2990func (p *listHubVirtualNetworkConnectionsResultPager) PageResponse() ListHubVirtualNetworkConnectionsResultResponse { 2991 return p.current 2992} 2993 2994// ListP2SVPNGatewaysResultPager provides iteration over ListP2SVPNGatewaysResult pages. 2995type ListP2SVPNGatewaysResultPager interface { 2996 azcore.Pager 2997 2998 // PageResponse returns the current ListP2SVPNGatewaysResultResponse. 2999 PageResponse() ListP2SVPNGatewaysResultResponse 3000} 3001 3002type listP2SVPNGatewaysResultCreateRequest func(context.Context) (*azcore.Request, error) 3003 3004type listP2SVPNGatewaysResultHandleError func(*azcore.Response) error 3005 3006type listP2SVPNGatewaysResultHandleResponse func(*azcore.Response) (ListP2SVPNGatewaysResultResponse, error) 3007 3008type listP2SVPNGatewaysResultAdvancePage func(context.Context, ListP2SVPNGatewaysResultResponse) (*azcore.Request, error) 3009 3010type listP2SVPNGatewaysResultPager struct { 3011 // the pipeline for making the request 3012 pipeline azcore.Pipeline 3013 // creates the initial request (non-LRO case) 3014 requester listP2SVPNGatewaysResultCreateRequest 3015 // callback for handling response errors 3016 errorer listP2SVPNGatewaysResultHandleError 3017 // callback for handling the HTTP response 3018 responder listP2SVPNGatewaysResultHandleResponse 3019 // callback for advancing to the next page 3020 advancer listP2SVPNGatewaysResultAdvancePage 3021 // contains the current response 3022 current ListP2SVPNGatewaysResultResponse 3023 // status codes for successful retrieval 3024 statusCodes []int 3025 // any error encountered 3026 err error 3027} 3028 3029func (p *listP2SVPNGatewaysResultPager) Err() error { 3030 return p.err 3031} 3032 3033func (p *listP2SVPNGatewaysResultPager) NextPage(ctx context.Context) bool { 3034 var req *azcore.Request 3035 var err error 3036 if !reflect.ValueOf(p.current).IsZero() { 3037 if p.current.ListP2SVPNGatewaysResult.NextLink == nil || len(*p.current.ListP2SVPNGatewaysResult.NextLink) == 0 { 3038 return false 3039 } 3040 req, err = p.advancer(ctx, p.current) 3041 } else { 3042 req, err = p.requester(ctx) 3043 } 3044 if err != nil { 3045 p.err = err 3046 return false 3047 } 3048 resp, err := p.pipeline.Do(req) 3049 if err != nil { 3050 p.err = err 3051 return false 3052 } 3053 if !resp.HasStatusCode(p.statusCodes...) { 3054 p.err = p.errorer(resp) 3055 return false 3056 } 3057 result, err := p.responder(resp) 3058 if err != nil { 3059 p.err = err 3060 return false 3061 } 3062 p.current = result 3063 return true 3064} 3065 3066func (p *listP2SVPNGatewaysResultPager) PageResponse() ListP2SVPNGatewaysResultResponse { 3067 return p.current 3068} 3069 3070// ListVPNConnectionsResultPager provides iteration over ListVPNConnectionsResult pages. 3071type ListVPNConnectionsResultPager interface { 3072 azcore.Pager 3073 3074 // PageResponse returns the current ListVPNConnectionsResultResponse. 3075 PageResponse() ListVPNConnectionsResultResponse 3076} 3077 3078type listVPNConnectionsResultCreateRequest func(context.Context) (*azcore.Request, error) 3079 3080type listVPNConnectionsResultHandleError func(*azcore.Response) error 3081 3082type listVPNConnectionsResultHandleResponse func(*azcore.Response) (ListVPNConnectionsResultResponse, error) 3083 3084type listVPNConnectionsResultAdvancePage func(context.Context, ListVPNConnectionsResultResponse) (*azcore.Request, error) 3085 3086type listVPNConnectionsResultPager struct { 3087 // the pipeline for making the request 3088 pipeline azcore.Pipeline 3089 // creates the initial request (non-LRO case) 3090 requester listVPNConnectionsResultCreateRequest 3091 // callback for handling response errors 3092 errorer listVPNConnectionsResultHandleError 3093 // callback for handling the HTTP response 3094 responder listVPNConnectionsResultHandleResponse 3095 // callback for advancing to the next page 3096 advancer listVPNConnectionsResultAdvancePage 3097 // contains the current response 3098 current ListVPNConnectionsResultResponse 3099 // status codes for successful retrieval 3100 statusCodes []int 3101 // any error encountered 3102 err error 3103} 3104 3105func (p *listVPNConnectionsResultPager) Err() error { 3106 return p.err 3107} 3108 3109func (p *listVPNConnectionsResultPager) NextPage(ctx context.Context) bool { 3110 var req *azcore.Request 3111 var err error 3112 if !reflect.ValueOf(p.current).IsZero() { 3113 if p.current.ListVPNConnectionsResult.NextLink == nil || len(*p.current.ListVPNConnectionsResult.NextLink) == 0 { 3114 return false 3115 } 3116 req, err = p.advancer(ctx, p.current) 3117 } else { 3118 req, err = p.requester(ctx) 3119 } 3120 if err != nil { 3121 p.err = err 3122 return false 3123 } 3124 resp, err := p.pipeline.Do(req) 3125 if err != nil { 3126 p.err = err 3127 return false 3128 } 3129 if !resp.HasStatusCode(p.statusCodes...) { 3130 p.err = p.errorer(resp) 3131 return false 3132 } 3133 result, err := p.responder(resp) 3134 if err != nil { 3135 p.err = err 3136 return false 3137 } 3138 p.current = result 3139 return true 3140} 3141 3142func (p *listVPNConnectionsResultPager) PageResponse() ListVPNConnectionsResultResponse { 3143 return p.current 3144} 3145 3146// ListVPNGatewayNatRulesResultPager provides iteration over ListVPNGatewayNatRulesResult pages. 3147type ListVPNGatewayNatRulesResultPager interface { 3148 azcore.Pager 3149 3150 // PageResponse returns the current ListVPNGatewayNatRulesResultResponse. 3151 PageResponse() ListVPNGatewayNatRulesResultResponse 3152} 3153 3154type listVPNGatewayNatRulesResultCreateRequest func(context.Context) (*azcore.Request, error) 3155 3156type listVPNGatewayNatRulesResultHandleError func(*azcore.Response) error 3157 3158type listVPNGatewayNatRulesResultHandleResponse func(*azcore.Response) (ListVPNGatewayNatRulesResultResponse, error) 3159 3160type listVPNGatewayNatRulesResultAdvancePage func(context.Context, ListVPNGatewayNatRulesResultResponse) (*azcore.Request, error) 3161 3162type listVPNGatewayNatRulesResultPager struct { 3163 // the pipeline for making the request 3164 pipeline azcore.Pipeline 3165 // creates the initial request (non-LRO case) 3166 requester listVPNGatewayNatRulesResultCreateRequest 3167 // callback for handling response errors 3168 errorer listVPNGatewayNatRulesResultHandleError 3169 // callback for handling the HTTP response 3170 responder listVPNGatewayNatRulesResultHandleResponse 3171 // callback for advancing to the next page 3172 advancer listVPNGatewayNatRulesResultAdvancePage 3173 // contains the current response 3174 current ListVPNGatewayNatRulesResultResponse 3175 // status codes for successful retrieval 3176 statusCodes []int 3177 // any error encountered 3178 err error 3179} 3180 3181func (p *listVPNGatewayNatRulesResultPager) Err() error { 3182 return p.err 3183} 3184 3185func (p *listVPNGatewayNatRulesResultPager) NextPage(ctx context.Context) bool { 3186 var req *azcore.Request 3187 var err error 3188 if !reflect.ValueOf(p.current).IsZero() { 3189 if p.current.ListVPNGatewayNatRulesResult.NextLink == nil || len(*p.current.ListVPNGatewayNatRulesResult.NextLink) == 0 { 3190 return false 3191 } 3192 req, err = p.advancer(ctx, p.current) 3193 } else { 3194 req, err = p.requester(ctx) 3195 } 3196 if err != nil { 3197 p.err = err 3198 return false 3199 } 3200 resp, err := p.pipeline.Do(req) 3201 if err != nil { 3202 p.err = err 3203 return false 3204 } 3205 if !resp.HasStatusCode(p.statusCodes...) { 3206 p.err = p.errorer(resp) 3207 return false 3208 } 3209 result, err := p.responder(resp) 3210 if err != nil { 3211 p.err = err 3212 return false 3213 } 3214 p.current = result 3215 return true 3216} 3217 3218func (p *listVPNGatewayNatRulesResultPager) PageResponse() ListVPNGatewayNatRulesResultResponse { 3219 return p.current 3220} 3221 3222// ListVPNGatewaysResultPager provides iteration over ListVPNGatewaysResult pages. 3223type ListVPNGatewaysResultPager interface { 3224 azcore.Pager 3225 3226 // PageResponse returns the current ListVPNGatewaysResultResponse. 3227 PageResponse() ListVPNGatewaysResultResponse 3228} 3229 3230type listVPNGatewaysResultCreateRequest func(context.Context) (*azcore.Request, error) 3231 3232type listVPNGatewaysResultHandleError func(*azcore.Response) error 3233 3234type listVPNGatewaysResultHandleResponse func(*azcore.Response) (ListVPNGatewaysResultResponse, error) 3235 3236type listVPNGatewaysResultAdvancePage func(context.Context, ListVPNGatewaysResultResponse) (*azcore.Request, error) 3237 3238type listVPNGatewaysResultPager struct { 3239 // the pipeline for making the request 3240 pipeline azcore.Pipeline 3241 // creates the initial request (non-LRO case) 3242 requester listVPNGatewaysResultCreateRequest 3243 // callback for handling response errors 3244 errorer listVPNGatewaysResultHandleError 3245 // callback for handling the HTTP response 3246 responder listVPNGatewaysResultHandleResponse 3247 // callback for advancing to the next page 3248 advancer listVPNGatewaysResultAdvancePage 3249 // contains the current response 3250 current ListVPNGatewaysResultResponse 3251 // status codes for successful retrieval 3252 statusCodes []int 3253 // any error encountered 3254 err error 3255} 3256 3257func (p *listVPNGatewaysResultPager) Err() error { 3258 return p.err 3259} 3260 3261func (p *listVPNGatewaysResultPager) NextPage(ctx context.Context) bool { 3262 var req *azcore.Request 3263 var err error 3264 if !reflect.ValueOf(p.current).IsZero() { 3265 if p.current.ListVPNGatewaysResult.NextLink == nil || len(*p.current.ListVPNGatewaysResult.NextLink) == 0 { 3266 return false 3267 } 3268 req, err = p.advancer(ctx, p.current) 3269 } else { 3270 req, err = p.requester(ctx) 3271 } 3272 if err != nil { 3273 p.err = err 3274 return false 3275 } 3276 resp, err := p.pipeline.Do(req) 3277 if err != nil { 3278 p.err = err 3279 return false 3280 } 3281 if !resp.HasStatusCode(p.statusCodes...) { 3282 p.err = p.errorer(resp) 3283 return false 3284 } 3285 result, err := p.responder(resp) 3286 if err != nil { 3287 p.err = err 3288 return false 3289 } 3290 p.current = result 3291 return true 3292} 3293 3294func (p *listVPNGatewaysResultPager) PageResponse() ListVPNGatewaysResultResponse { 3295 return p.current 3296} 3297 3298// ListVPNServerConfigurationsResultPager provides iteration over ListVPNServerConfigurationsResult pages. 3299type ListVPNServerConfigurationsResultPager interface { 3300 azcore.Pager 3301 3302 // PageResponse returns the current ListVPNServerConfigurationsResultResponse. 3303 PageResponse() ListVPNServerConfigurationsResultResponse 3304} 3305 3306type listVPNServerConfigurationsResultCreateRequest func(context.Context) (*azcore.Request, error) 3307 3308type listVPNServerConfigurationsResultHandleError func(*azcore.Response) error 3309 3310type listVPNServerConfigurationsResultHandleResponse func(*azcore.Response) (ListVPNServerConfigurationsResultResponse, error) 3311 3312type listVPNServerConfigurationsResultAdvancePage func(context.Context, ListVPNServerConfigurationsResultResponse) (*azcore.Request, error) 3313 3314type listVPNServerConfigurationsResultPager struct { 3315 // the pipeline for making the request 3316 pipeline azcore.Pipeline 3317 // creates the initial request (non-LRO case) 3318 requester listVPNServerConfigurationsResultCreateRequest 3319 // callback for handling response errors 3320 errorer listVPNServerConfigurationsResultHandleError 3321 // callback for handling the HTTP response 3322 responder listVPNServerConfigurationsResultHandleResponse 3323 // callback for advancing to the next page 3324 advancer listVPNServerConfigurationsResultAdvancePage 3325 // contains the current response 3326 current ListVPNServerConfigurationsResultResponse 3327 // status codes for successful retrieval 3328 statusCodes []int 3329 // any error encountered 3330 err error 3331} 3332 3333func (p *listVPNServerConfigurationsResultPager) Err() error { 3334 return p.err 3335} 3336 3337func (p *listVPNServerConfigurationsResultPager) NextPage(ctx context.Context) bool { 3338 var req *azcore.Request 3339 var err error 3340 if !reflect.ValueOf(p.current).IsZero() { 3341 if p.current.ListVPNServerConfigurationsResult.NextLink == nil || len(*p.current.ListVPNServerConfigurationsResult.NextLink) == 0 { 3342 return false 3343 } 3344 req, err = p.advancer(ctx, p.current) 3345 } else { 3346 req, err = p.requester(ctx) 3347 } 3348 if err != nil { 3349 p.err = err 3350 return false 3351 } 3352 resp, err := p.pipeline.Do(req) 3353 if err != nil { 3354 p.err = err 3355 return false 3356 } 3357 if !resp.HasStatusCode(p.statusCodes...) { 3358 p.err = p.errorer(resp) 3359 return false 3360 } 3361 result, err := p.responder(resp) 3362 if err != nil { 3363 p.err = err 3364 return false 3365 } 3366 p.current = result 3367 return true 3368} 3369 3370func (p *listVPNServerConfigurationsResultPager) PageResponse() ListVPNServerConfigurationsResultResponse { 3371 return p.current 3372} 3373 3374// ListVPNSiteLinkConnectionsResultPager provides iteration over ListVPNSiteLinkConnectionsResult pages. 3375type ListVPNSiteLinkConnectionsResultPager interface { 3376 azcore.Pager 3377 3378 // PageResponse returns the current ListVPNSiteLinkConnectionsResultResponse. 3379 PageResponse() ListVPNSiteLinkConnectionsResultResponse 3380} 3381 3382type listVPNSiteLinkConnectionsResultCreateRequest func(context.Context) (*azcore.Request, error) 3383 3384type listVPNSiteLinkConnectionsResultHandleError func(*azcore.Response) error 3385 3386type listVPNSiteLinkConnectionsResultHandleResponse func(*azcore.Response) (ListVPNSiteLinkConnectionsResultResponse, error) 3387 3388type listVPNSiteLinkConnectionsResultAdvancePage func(context.Context, ListVPNSiteLinkConnectionsResultResponse) (*azcore.Request, error) 3389 3390type listVPNSiteLinkConnectionsResultPager struct { 3391 // the pipeline for making the request 3392 pipeline azcore.Pipeline 3393 // creates the initial request (non-LRO case) 3394 requester listVPNSiteLinkConnectionsResultCreateRequest 3395 // callback for handling response errors 3396 errorer listVPNSiteLinkConnectionsResultHandleError 3397 // callback for handling the HTTP response 3398 responder listVPNSiteLinkConnectionsResultHandleResponse 3399 // callback for advancing to the next page 3400 advancer listVPNSiteLinkConnectionsResultAdvancePage 3401 // contains the current response 3402 current ListVPNSiteLinkConnectionsResultResponse 3403 // status codes for successful retrieval 3404 statusCodes []int 3405 // any error encountered 3406 err error 3407} 3408 3409func (p *listVPNSiteLinkConnectionsResultPager) Err() error { 3410 return p.err 3411} 3412 3413func (p *listVPNSiteLinkConnectionsResultPager) NextPage(ctx context.Context) bool { 3414 var req *azcore.Request 3415 var err error 3416 if !reflect.ValueOf(p.current).IsZero() { 3417 if p.current.ListVPNSiteLinkConnectionsResult.NextLink == nil || len(*p.current.ListVPNSiteLinkConnectionsResult.NextLink) == 0 { 3418 return false 3419 } 3420 req, err = p.advancer(ctx, p.current) 3421 } else { 3422 req, err = p.requester(ctx) 3423 } 3424 if err != nil { 3425 p.err = err 3426 return false 3427 } 3428 resp, err := p.pipeline.Do(req) 3429 if err != nil { 3430 p.err = err 3431 return false 3432 } 3433 if !resp.HasStatusCode(p.statusCodes...) { 3434 p.err = p.errorer(resp) 3435 return false 3436 } 3437 result, err := p.responder(resp) 3438 if err != nil { 3439 p.err = err 3440 return false 3441 } 3442 p.current = result 3443 return true 3444} 3445 3446func (p *listVPNSiteLinkConnectionsResultPager) PageResponse() ListVPNSiteLinkConnectionsResultResponse { 3447 return p.current 3448} 3449 3450// ListVPNSiteLinksResultPager provides iteration over ListVPNSiteLinksResult pages. 3451type ListVPNSiteLinksResultPager interface { 3452 azcore.Pager 3453 3454 // PageResponse returns the current ListVPNSiteLinksResultResponse. 3455 PageResponse() ListVPNSiteLinksResultResponse 3456} 3457 3458type listVPNSiteLinksResultCreateRequest func(context.Context) (*azcore.Request, error) 3459 3460type listVPNSiteLinksResultHandleError func(*azcore.Response) error 3461 3462type listVPNSiteLinksResultHandleResponse func(*azcore.Response) (ListVPNSiteLinksResultResponse, error) 3463 3464type listVPNSiteLinksResultAdvancePage func(context.Context, ListVPNSiteLinksResultResponse) (*azcore.Request, error) 3465 3466type listVPNSiteLinksResultPager struct { 3467 // the pipeline for making the request 3468 pipeline azcore.Pipeline 3469 // creates the initial request (non-LRO case) 3470 requester listVPNSiteLinksResultCreateRequest 3471 // callback for handling response errors 3472 errorer listVPNSiteLinksResultHandleError 3473 // callback for handling the HTTP response 3474 responder listVPNSiteLinksResultHandleResponse 3475 // callback for advancing to the next page 3476 advancer listVPNSiteLinksResultAdvancePage 3477 // contains the current response 3478 current ListVPNSiteLinksResultResponse 3479 // status codes for successful retrieval 3480 statusCodes []int 3481 // any error encountered 3482 err error 3483} 3484 3485func (p *listVPNSiteLinksResultPager) Err() error { 3486 return p.err 3487} 3488 3489func (p *listVPNSiteLinksResultPager) NextPage(ctx context.Context) bool { 3490 var req *azcore.Request 3491 var err error 3492 if !reflect.ValueOf(p.current).IsZero() { 3493 if p.current.ListVPNSiteLinksResult.NextLink == nil || len(*p.current.ListVPNSiteLinksResult.NextLink) == 0 { 3494 return false 3495 } 3496 req, err = p.advancer(ctx, p.current) 3497 } else { 3498 req, err = p.requester(ctx) 3499 } 3500 if err != nil { 3501 p.err = err 3502 return false 3503 } 3504 resp, err := p.pipeline.Do(req) 3505 if err != nil { 3506 p.err = err 3507 return false 3508 } 3509 if !resp.HasStatusCode(p.statusCodes...) { 3510 p.err = p.errorer(resp) 3511 return false 3512 } 3513 result, err := p.responder(resp) 3514 if err != nil { 3515 p.err = err 3516 return false 3517 } 3518 p.current = result 3519 return true 3520} 3521 3522func (p *listVPNSiteLinksResultPager) PageResponse() ListVPNSiteLinksResultResponse { 3523 return p.current 3524} 3525 3526// ListVPNSitesResultPager provides iteration over ListVPNSitesResult pages. 3527type ListVPNSitesResultPager interface { 3528 azcore.Pager 3529 3530 // PageResponse returns the current ListVPNSitesResultResponse. 3531 PageResponse() ListVPNSitesResultResponse 3532} 3533 3534type listVPNSitesResultCreateRequest func(context.Context) (*azcore.Request, error) 3535 3536type listVPNSitesResultHandleError func(*azcore.Response) error 3537 3538type listVPNSitesResultHandleResponse func(*azcore.Response) (ListVPNSitesResultResponse, error) 3539 3540type listVPNSitesResultAdvancePage func(context.Context, ListVPNSitesResultResponse) (*azcore.Request, error) 3541 3542type listVPNSitesResultPager struct { 3543 // the pipeline for making the request 3544 pipeline azcore.Pipeline 3545 // creates the initial request (non-LRO case) 3546 requester listVPNSitesResultCreateRequest 3547 // callback for handling response errors 3548 errorer listVPNSitesResultHandleError 3549 // callback for handling the HTTP response 3550 responder listVPNSitesResultHandleResponse 3551 // callback for advancing to the next page 3552 advancer listVPNSitesResultAdvancePage 3553 // contains the current response 3554 current ListVPNSitesResultResponse 3555 // status codes for successful retrieval 3556 statusCodes []int 3557 // any error encountered 3558 err error 3559} 3560 3561func (p *listVPNSitesResultPager) Err() error { 3562 return p.err 3563} 3564 3565func (p *listVPNSitesResultPager) NextPage(ctx context.Context) bool { 3566 var req *azcore.Request 3567 var err error 3568 if !reflect.ValueOf(p.current).IsZero() { 3569 if p.current.ListVPNSitesResult.NextLink == nil || len(*p.current.ListVPNSitesResult.NextLink) == 0 { 3570 return false 3571 } 3572 req, err = p.advancer(ctx, p.current) 3573 } else { 3574 req, err = p.requester(ctx) 3575 } 3576 if err != nil { 3577 p.err = err 3578 return false 3579 } 3580 resp, err := p.pipeline.Do(req) 3581 if err != nil { 3582 p.err = err 3583 return false 3584 } 3585 if !resp.HasStatusCode(p.statusCodes...) { 3586 p.err = p.errorer(resp) 3587 return false 3588 } 3589 result, err := p.responder(resp) 3590 if err != nil { 3591 p.err = err 3592 return false 3593 } 3594 p.current = result 3595 return true 3596} 3597 3598func (p *listVPNSitesResultPager) PageResponse() ListVPNSitesResultResponse { 3599 return p.current 3600} 3601 3602// ListVirtualHubBgpConnectionResultsPager provides iteration over ListVirtualHubBgpConnectionResults pages. 3603type ListVirtualHubBgpConnectionResultsPager interface { 3604 azcore.Pager 3605 3606 // PageResponse returns the current ListVirtualHubBgpConnectionResultsResponse. 3607 PageResponse() ListVirtualHubBgpConnectionResultsResponse 3608} 3609 3610type listVirtualHubBgpConnectionResultsCreateRequest func(context.Context) (*azcore.Request, error) 3611 3612type listVirtualHubBgpConnectionResultsHandleError func(*azcore.Response) error 3613 3614type listVirtualHubBgpConnectionResultsHandleResponse func(*azcore.Response) (ListVirtualHubBgpConnectionResultsResponse, error) 3615 3616type listVirtualHubBgpConnectionResultsAdvancePage func(context.Context, ListVirtualHubBgpConnectionResultsResponse) (*azcore.Request, error) 3617 3618type listVirtualHubBgpConnectionResultsPager struct { 3619 // the pipeline for making the request 3620 pipeline azcore.Pipeline 3621 // creates the initial request (non-LRO case) 3622 requester listVirtualHubBgpConnectionResultsCreateRequest 3623 // callback for handling response errors 3624 errorer listVirtualHubBgpConnectionResultsHandleError 3625 // callback for handling the HTTP response 3626 responder listVirtualHubBgpConnectionResultsHandleResponse 3627 // callback for advancing to the next page 3628 advancer listVirtualHubBgpConnectionResultsAdvancePage 3629 // contains the current response 3630 current ListVirtualHubBgpConnectionResultsResponse 3631 // status codes for successful retrieval 3632 statusCodes []int 3633 // any error encountered 3634 err error 3635} 3636 3637func (p *listVirtualHubBgpConnectionResultsPager) Err() error { 3638 return p.err 3639} 3640 3641func (p *listVirtualHubBgpConnectionResultsPager) NextPage(ctx context.Context) bool { 3642 var req *azcore.Request 3643 var err error 3644 if !reflect.ValueOf(p.current).IsZero() { 3645 if p.current.ListVirtualHubBgpConnectionResults.NextLink == nil || len(*p.current.ListVirtualHubBgpConnectionResults.NextLink) == 0 { 3646 return false 3647 } 3648 req, err = p.advancer(ctx, p.current) 3649 } else { 3650 req, err = p.requester(ctx) 3651 } 3652 if err != nil { 3653 p.err = err 3654 return false 3655 } 3656 resp, err := p.pipeline.Do(req) 3657 if err != nil { 3658 p.err = err 3659 return false 3660 } 3661 if !resp.HasStatusCode(p.statusCodes...) { 3662 p.err = p.errorer(resp) 3663 return false 3664 } 3665 result, err := p.responder(resp) 3666 if err != nil { 3667 p.err = err 3668 return false 3669 } 3670 p.current = result 3671 return true 3672} 3673 3674func (p *listVirtualHubBgpConnectionResultsPager) PageResponse() ListVirtualHubBgpConnectionResultsResponse { 3675 return p.current 3676} 3677 3678// ListVirtualHubIPConfigurationResultsPager provides iteration over ListVirtualHubIPConfigurationResults pages. 3679type ListVirtualHubIPConfigurationResultsPager interface { 3680 azcore.Pager 3681 3682 // PageResponse returns the current ListVirtualHubIPConfigurationResultsResponse. 3683 PageResponse() ListVirtualHubIPConfigurationResultsResponse 3684} 3685 3686type listVirtualHubIPConfigurationResultsCreateRequest func(context.Context) (*azcore.Request, error) 3687 3688type listVirtualHubIPConfigurationResultsHandleError func(*azcore.Response) error 3689 3690type listVirtualHubIPConfigurationResultsHandleResponse func(*azcore.Response) (ListVirtualHubIPConfigurationResultsResponse, error) 3691 3692type listVirtualHubIPConfigurationResultsAdvancePage func(context.Context, ListVirtualHubIPConfigurationResultsResponse) (*azcore.Request, error) 3693 3694type listVirtualHubIPConfigurationResultsPager struct { 3695 // the pipeline for making the request 3696 pipeline azcore.Pipeline 3697 // creates the initial request (non-LRO case) 3698 requester listVirtualHubIPConfigurationResultsCreateRequest 3699 // callback for handling response errors 3700 errorer listVirtualHubIPConfigurationResultsHandleError 3701 // callback for handling the HTTP response 3702 responder listVirtualHubIPConfigurationResultsHandleResponse 3703 // callback for advancing to the next page 3704 advancer listVirtualHubIPConfigurationResultsAdvancePage 3705 // contains the current response 3706 current ListVirtualHubIPConfigurationResultsResponse 3707 // status codes for successful retrieval 3708 statusCodes []int 3709 // any error encountered 3710 err error 3711} 3712 3713func (p *listVirtualHubIPConfigurationResultsPager) Err() error { 3714 return p.err 3715} 3716 3717func (p *listVirtualHubIPConfigurationResultsPager) NextPage(ctx context.Context) bool { 3718 var req *azcore.Request 3719 var err error 3720 if !reflect.ValueOf(p.current).IsZero() { 3721 if p.current.ListVirtualHubIPConfigurationResults.NextLink == nil || len(*p.current.ListVirtualHubIPConfigurationResults.NextLink) == 0 { 3722 return false 3723 } 3724 req, err = p.advancer(ctx, p.current) 3725 } else { 3726 req, err = p.requester(ctx) 3727 } 3728 if err != nil { 3729 p.err = err 3730 return false 3731 } 3732 resp, err := p.pipeline.Do(req) 3733 if err != nil { 3734 p.err = err 3735 return false 3736 } 3737 if !resp.HasStatusCode(p.statusCodes...) { 3738 p.err = p.errorer(resp) 3739 return false 3740 } 3741 result, err := p.responder(resp) 3742 if err != nil { 3743 p.err = err 3744 return false 3745 } 3746 p.current = result 3747 return true 3748} 3749 3750func (p *listVirtualHubIPConfigurationResultsPager) PageResponse() ListVirtualHubIPConfigurationResultsResponse { 3751 return p.current 3752} 3753 3754// ListVirtualHubRouteTableV2SResultPager provides iteration over ListVirtualHubRouteTableV2SResult pages. 3755type ListVirtualHubRouteTableV2SResultPager interface { 3756 azcore.Pager 3757 3758 // PageResponse returns the current ListVirtualHubRouteTableV2SResultResponse. 3759 PageResponse() ListVirtualHubRouteTableV2SResultResponse 3760} 3761 3762type listVirtualHubRouteTableV2SResultCreateRequest func(context.Context) (*azcore.Request, error) 3763 3764type listVirtualHubRouteTableV2SResultHandleError func(*azcore.Response) error 3765 3766type listVirtualHubRouteTableV2SResultHandleResponse func(*azcore.Response) (ListVirtualHubRouteTableV2SResultResponse, error) 3767 3768type listVirtualHubRouteTableV2SResultAdvancePage func(context.Context, ListVirtualHubRouteTableV2SResultResponse) (*azcore.Request, error) 3769 3770type listVirtualHubRouteTableV2SResultPager struct { 3771 // the pipeline for making the request 3772 pipeline azcore.Pipeline 3773 // creates the initial request (non-LRO case) 3774 requester listVirtualHubRouteTableV2SResultCreateRequest 3775 // callback for handling response errors 3776 errorer listVirtualHubRouteTableV2SResultHandleError 3777 // callback for handling the HTTP response 3778 responder listVirtualHubRouteTableV2SResultHandleResponse 3779 // callback for advancing to the next page 3780 advancer listVirtualHubRouteTableV2SResultAdvancePage 3781 // contains the current response 3782 current ListVirtualHubRouteTableV2SResultResponse 3783 // status codes for successful retrieval 3784 statusCodes []int 3785 // any error encountered 3786 err error 3787} 3788 3789func (p *listVirtualHubRouteTableV2SResultPager) Err() error { 3790 return p.err 3791} 3792 3793func (p *listVirtualHubRouteTableV2SResultPager) NextPage(ctx context.Context) bool { 3794 var req *azcore.Request 3795 var err error 3796 if !reflect.ValueOf(p.current).IsZero() { 3797 if p.current.ListVirtualHubRouteTableV2SResult.NextLink == nil || len(*p.current.ListVirtualHubRouteTableV2SResult.NextLink) == 0 { 3798 return false 3799 } 3800 req, err = p.advancer(ctx, p.current) 3801 } else { 3802 req, err = p.requester(ctx) 3803 } 3804 if err != nil { 3805 p.err = err 3806 return false 3807 } 3808 resp, err := p.pipeline.Do(req) 3809 if err != nil { 3810 p.err = err 3811 return false 3812 } 3813 if !resp.HasStatusCode(p.statusCodes...) { 3814 p.err = p.errorer(resp) 3815 return false 3816 } 3817 result, err := p.responder(resp) 3818 if err != nil { 3819 p.err = err 3820 return false 3821 } 3822 p.current = result 3823 return true 3824} 3825 3826func (p *listVirtualHubRouteTableV2SResultPager) PageResponse() ListVirtualHubRouteTableV2SResultResponse { 3827 return p.current 3828} 3829 3830// ListVirtualHubsResultPager provides iteration over ListVirtualHubsResult pages. 3831type ListVirtualHubsResultPager interface { 3832 azcore.Pager 3833 3834 // PageResponse returns the current ListVirtualHubsResultResponse. 3835 PageResponse() ListVirtualHubsResultResponse 3836} 3837 3838type listVirtualHubsResultCreateRequest func(context.Context) (*azcore.Request, error) 3839 3840type listVirtualHubsResultHandleError func(*azcore.Response) error 3841 3842type listVirtualHubsResultHandleResponse func(*azcore.Response) (ListVirtualHubsResultResponse, error) 3843 3844type listVirtualHubsResultAdvancePage func(context.Context, ListVirtualHubsResultResponse) (*azcore.Request, error) 3845 3846type listVirtualHubsResultPager struct { 3847 // the pipeline for making the request 3848 pipeline azcore.Pipeline 3849 // creates the initial request (non-LRO case) 3850 requester listVirtualHubsResultCreateRequest 3851 // callback for handling response errors 3852 errorer listVirtualHubsResultHandleError 3853 // callback for handling the HTTP response 3854 responder listVirtualHubsResultHandleResponse 3855 // callback for advancing to the next page 3856 advancer listVirtualHubsResultAdvancePage 3857 // contains the current response 3858 current ListVirtualHubsResultResponse 3859 // status codes for successful retrieval 3860 statusCodes []int 3861 // any error encountered 3862 err error 3863} 3864 3865func (p *listVirtualHubsResultPager) Err() error { 3866 return p.err 3867} 3868 3869func (p *listVirtualHubsResultPager) NextPage(ctx context.Context) bool { 3870 var req *azcore.Request 3871 var err error 3872 if !reflect.ValueOf(p.current).IsZero() { 3873 if p.current.ListVirtualHubsResult.NextLink == nil || len(*p.current.ListVirtualHubsResult.NextLink) == 0 { 3874 return false 3875 } 3876 req, err = p.advancer(ctx, p.current) 3877 } else { 3878 req, err = p.requester(ctx) 3879 } 3880 if err != nil { 3881 p.err = err 3882 return false 3883 } 3884 resp, err := p.pipeline.Do(req) 3885 if err != nil { 3886 p.err = err 3887 return false 3888 } 3889 if !resp.HasStatusCode(p.statusCodes...) { 3890 p.err = p.errorer(resp) 3891 return false 3892 } 3893 result, err := p.responder(resp) 3894 if err != nil { 3895 p.err = err 3896 return false 3897 } 3898 p.current = result 3899 return true 3900} 3901 3902func (p *listVirtualHubsResultPager) PageResponse() ListVirtualHubsResultResponse { 3903 return p.current 3904} 3905 3906// ListVirtualNetworkGatewayNatRulesResultPager provides iteration over ListVirtualNetworkGatewayNatRulesResult pages. 3907type ListVirtualNetworkGatewayNatRulesResultPager interface { 3908 azcore.Pager 3909 3910 // PageResponse returns the current ListVirtualNetworkGatewayNatRulesResultResponse. 3911 PageResponse() ListVirtualNetworkGatewayNatRulesResultResponse 3912} 3913 3914type listVirtualNetworkGatewayNatRulesResultCreateRequest func(context.Context) (*azcore.Request, error) 3915 3916type listVirtualNetworkGatewayNatRulesResultHandleError func(*azcore.Response) error 3917 3918type listVirtualNetworkGatewayNatRulesResultHandleResponse func(*azcore.Response) (ListVirtualNetworkGatewayNatRulesResultResponse, error) 3919 3920type listVirtualNetworkGatewayNatRulesResultAdvancePage func(context.Context, ListVirtualNetworkGatewayNatRulesResultResponse) (*azcore.Request, error) 3921 3922type listVirtualNetworkGatewayNatRulesResultPager struct { 3923 // the pipeline for making the request 3924 pipeline azcore.Pipeline 3925 // creates the initial request (non-LRO case) 3926 requester listVirtualNetworkGatewayNatRulesResultCreateRequest 3927 // callback for handling response errors 3928 errorer listVirtualNetworkGatewayNatRulesResultHandleError 3929 // callback for handling the HTTP response 3930 responder listVirtualNetworkGatewayNatRulesResultHandleResponse 3931 // callback for advancing to the next page 3932 advancer listVirtualNetworkGatewayNatRulesResultAdvancePage 3933 // contains the current response 3934 current ListVirtualNetworkGatewayNatRulesResultResponse 3935 // status codes for successful retrieval 3936 statusCodes []int 3937 // any error encountered 3938 err error 3939} 3940 3941func (p *listVirtualNetworkGatewayNatRulesResultPager) Err() error { 3942 return p.err 3943} 3944 3945func (p *listVirtualNetworkGatewayNatRulesResultPager) NextPage(ctx context.Context) bool { 3946 var req *azcore.Request 3947 var err error 3948 if !reflect.ValueOf(p.current).IsZero() { 3949 if p.current.ListVirtualNetworkGatewayNatRulesResult.NextLink == nil || len(*p.current.ListVirtualNetworkGatewayNatRulesResult.NextLink) == 0 { 3950 return false 3951 } 3952 req, err = p.advancer(ctx, p.current) 3953 } else { 3954 req, err = p.requester(ctx) 3955 } 3956 if err != nil { 3957 p.err = err 3958 return false 3959 } 3960 resp, err := p.pipeline.Do(req) 3961 if err != nil { 3962 p.err = err 3963 return false 3964 } 3965 if !resp.HasStatusCode(p.statusCodes...) { 3966 p.err = p.errorer(resp) 3967 return false 3968 } 3969 result, err := p.responder(resp) 3970 if err != nil { 3971 p.err = err 3972 return false 3973 } 3974 p.current = result 3975 return true 3976} 3977 3978func (p *listVirtualNetworkGatewayNatRulesResultPager) PageResponse() ListVirtualNetworkGatewayNatRulesResultResponse { 3979 return p.current 3980} 3981 3982// ListVirtualWANsResultPager provides iteration over ListVirtualWANsResult pages. 3983type ListVirtualWANsResultPager interface { 3984 azcore.Pager 3985 3986 // PageResponse returns the current ListVirtualWANsResultResponse. 3987 PageResponse() ListVirtualWANsResultResponse 3988} 3989 3990type listVirtualWANsResultCreateRequest func(context.Context) (*azcore.Request, error) 3991 3992type listVirtualWANsResultHandleError func(*azcore.Response) error 3993 3994type listVirtualWANsResultHandleResponse func(*azcore.Response) (ListVirtualWANsResultResponse, error) 3995 3996type listVirtualWANsResultAdvancePage func(context.Context, ListVirtualWANsResultResponse) (*azcore.Request, error) 3997 3998type listVirtualWANsResultPager struct { 3999 // the pipeline for making the request 4000 pipeline azcore.Pipeline 4001 // creates the initial request (non-LRO case) 4002 requester listVirtualWANsResultCreateRequest 4003 // callback for handling response errors 4004 errorer listVirtualWANsResultHandleError 4005 // callback for handling the HTTP response 4006 responder listVirtualWANsResultHandleResponse 4007 // callback for advancing to the next page 4008 advancer listVirtualWANsResultAdvancePage 4009 // contains the current response 4010 current ListVirtualWANsResultResponse 4011 // status codes for successful retrieval 4012 statusCodes []int 4013 // any error encountered 4014 err error 4015} 4016 4017func (p *listVirtualWANsResultPager) Err() error { 4018 return p.err 4019} 4020 4021func (p *listVirtualWANsResultPager) NextPage(ctx context.Context) bool { 4022 var req *azcore.Request 4023 var err error 4024 if !reflect.ValueOf(p.current).IsZero() { 4025 if p.current.ListVirtualWANsResult.NextLink == nil || len(*p.current.ListVirtualWANsResult.NextLink) == 0 { 4026 return false 4027 } 4028 req, err = p.advancer(ctx, p.current) 4029 } else { 4030 req, err = p.requester(ctx) 4031 } 4032 if err != nil { 4033 p.err = err 4034 return false 4035 } 4036 resp, err := p.pipeline.Do(req) 4037 if err != nil { 4038 p.err = err 4039 return false 4040 } 4041 if !resp.HasStatusCode(p.statusCodes...) { 4042 p.err = p.errorer(resp) 4043 return false 4044 } 4045 result, err := p.responder(resp) 4046 if err != nil { 4047 p.err = err 4048 return false 4049 } 4050 p.current = result 4051 return true 4052} 4053 4054func (p *listVirtualWANsResultPager) PageResponse() ListVirtualWANsResultResponse { 4055 return p.current 4056} 4057 4058// LoadBalancerBackendAddressPoolListResultPager provides iteration over LoadBalancerBackendAddressPoolListResult pages. 4059type LoadBalancerBackendAddressPoolListResultPager interface { 4060 azcore.Pager 4061 4062 // PageResponse returns the current LoadBalancerBackendAddressPoolListResultResponse. 4063 PageResponse() LoadBalancerBackendAddressPoolListResultResponse 4064} 4065 4066type loadBalancerBackendAddressPoolListResultCreateRequest func(context.Context) (*azcore.Request, error) 4067 4068type loadBalancerBackendAddressPoolListResultHandleError func(*azcore.Response) error 4069 4070type loadBalancerBackendAddressPoolListResultHandleResponse func(*azcore.Response) (LoadBalancerBackendAddressPoolListResultResponse, error) 4071 4072type loadBalancerBackendAddressPoolListResultAdvancePage func(context.Context, LoadBalancerBackendAddressPoolListResultResponse) (*azcore.Request, error) 4073 4074type loadBalancerBackendAddressPoolListResultPager struct { 4075 // the pipeline for making the request 4076 pipeline azcore.Pipeline 4077 // creates the initial request (non-LRO case) 4078 requester loadBalancerBackendAddressPoolListResultCreateRequest 4079 // callback for handling response errors 4080 errorer loadBalancerBackendAddressPoolListResultHandleError 4081 // callback for handling the HTTP response 4082 responder loadBalancerBackendAddressPoolListResultHandleResponse 4083 // callback for advancing to the next page 4084 advancer loadBalancerBackendAddressPoolListResultAdvancePage 4085 // contains the current response 4086 current LoadBalancerBackendAddressPoolListResultResponse 4087 // status codes for successful retrieval 4088 statusCodes []int 4089 // any error encountered 4090 err error 4091} 4092 4093func (p *loadBalancerBackendAddressPoolListResultPager) Err() error { 4094 return p.err 4095} 4096 4097func (p *loadBalancerBackendAddressPoolListResultPager) NextPage(ctx context.Context) bool { 4098 var req *azcore.Request 4099 var err error 4100 if !reflect.ValueOf(p.current).IsZero() { 4101 if p.current.LoadBalancerBackendAddressPoolListResult.NextLink == nil || len(*p.current.LoadBalancerBackendAddressPoolListResult.NextLink) == 0 { 4102 return false 4103 } 4104 req, err = p.advancer(ctx, p.current) 4105 } else { 4106 req, err = p.requester(ctx) 4107 } 4108 if err != nil { 4109 p.err = err 4110 return false 4111 } 4112 resp, err := p.pipeline.Do(req) 4113 if err != nil { 4114 p.err = err 4115 return false 4116 } 4117 if !resp.HasStatusCode(p.statusCodes...) { 4118 p.err = p.errorer(resp) 4119 return false 4120 } 4121 result, err := p.responder(resp) 4122 if err != nil { 4123 p.err = err 4124 return false 4125 } 4126 p.current = result 4127 return true 4128} 4129 4130func (p *loadBalancerBackendAddressPoolListResultPager) PageResponse() LoadBalancerBackendAddressPoolListResultResponse { 4131 return p.current 4132} 4133 4134// LoadBalancerFrontendIPConfigurationListResultPager provides iteration over LoadBalancerFrontendIPConfigurationListResult pages. 4135type LoadBalancerFrontendIPConfigurationListResultPager interface { 4136 azcore.Pager 4137 4138 // PageResponse returns the current LoadBalancerFrontendIPConfigurationListResultResponse. 4139 PageResponse() LoadBalancerFrontendIPConfigurationListResultResponse 4140} 4141 4142type loadBalancerFrontendIPConfigurationListResultCreateRequest func(context.Context) (*azcore.Request, error) 4143 4144type loadBalancerFrontendIPConfigurationListResultHandleError func(*azcore.Response) error 4145 4146type loadBalancerFrontendIPConfigurationListResultHandleResponse func(*azcore.Response) (LoadBalancerFrontendIPConfigurationListResultResponse, error) 4147 4148type loadBalancerFrontendIPConfigurationListResultAdvancePage func(context.Context, LoadBalancerFrontendIPConfigurationListResultResponse) (*azcore.Request, error) 4149 4150type loadBalancerFrontendIPConfigurationListResultPager struct { 4151 // the pipeline for making the request 4152 pipeline azcore.Pipeline 4153 // creates the initial request (non-LRO case) 4154 requester loadBalancerFrontendIPConfigurationListResultCreateRequest 4155 // callback for handling response errors 4156 errorer loadBalancerFrontendIPConfigurationListResultHandleError 4157 // callback for handling the HTTP response 4158 responder loadBalancerFrontendIPConfigurationListResultHandleResponse 4159 // callback for advancing to the next page 4160 advancer loadBalancerFrontendIPConfigurationListResultAdvancePage 4161 // contains the current response 4162 current LoadBalancerFrontendIPConfigurationListResultResponse 4163 // status codes for successful retrieval 4164 statusCodes []int 4165 // any error encountered 4166 err error 4167} 4168 4169func (p *loadBalancerFrontendIPConfigurationListResultPager) Err() error { 4170 return p.err 4171} 4172 4173func (p *loadBalancerFrontendIPConfigurationListResultPager) NextPage(ctx context.Context) bool { 4174 var req *azcore.Request 4175 var err error 4176 if !reflect.ValueOf(p.current).IsZero() { 4177 if p.current.LoadBalancerFrontendIPConfigurationListResult.NextLink == nil || len(*p.current.LoadBalancerFrontendIPConfigurationListResult.NextLink) == 0 { 4178 return false 4179 } 4180 req, err = p.advancer(ctx, p.current) 4181 } else { 4182 req, err = p.requester(ctx) 4183 } 4184 if err != nil { 4185 p.err = err 4186 return false 4187 } 4188 resp, err := p.pipeline.Do(req) 4189 if err != nil { 4190 p.err = err 4191 return false 4192 } 4193 if !resp.HasStatusCode(p.statusCodes...) { 4194 p.err = p.errorer(resp) 4195 return false 4196 } 4197 result, err := p.responder(resp) 4198 if err != nil { 4199 p.err = err 4200 return false 4201 } 4202 p.current = result 4203 return true 4204} 4205 4206func (p *loadBalancerFrontendIPConfigurationListResultPager) PageResponse() LoadBalancerFrontendIPConfigurationListResultResponse { 4207 return p.current 4208} 4209 4210// LoadBalancerListResultPager provides iteration over LoadBalancerListResult pages. 4211type LoadBalancerListResultPager interface { 4212 azcore.Pager 4213 4214 // PageResponse returns the current LoadBalancerListResultResponse. 4215 PageResponse() LoadBalancerListResultResponse 4216} 4217 4218type loadBalancerListResultCreateRequest func(context.Context) (*azcore.Request, error) 4219 4220type loadBalancerListResultHandleError func(*azcore.Response) error 4221 4222type loadBalancerListResultHandleResponse func(*azcore.Response) (LoadBalancerListResultResponse, error) 4223 4224type loadBalancerListResultAdvancePage func(context.Context, LoadBalancerListResultResponse) (*azcore.Request, error) 4225 4226type loadBalancerListResultPager struct { 4227 // the pipeline for making the request 4228 pipeline azcore.Pipeline 4229 // creates the initial request (non-LRO case) 4230 requester loadBalancerListResultCreateRequest 4231 // callback for handling response errors 4232 errorer loadBalancerListResultHandleError 4233 // callback for handling the HTTP response 4234 responder loadBalancerListResultHandleResponse 4235 // callback for advancing to the next page 4236 advancer loadBalancerListResultAdvancePage 4237 // contains the current response 4238 current LoadBalancerListResultResponse 4239 // status codes for successful retrieval 4240 statusCodes []int 4241 // any error encountered 4242 err error 4243} 4244 4245func (p *loadBalancerListResultPager) Err() error { 4246 return p.err 4247} 4248 4249func (p *loadBalancerListResultPager) NextPage(ctx context.Context) bool { 4250 var req *azcore.Request 4251 var err error 4252 if !reflect.ValueOf(p.current).IsZero() { 4253 if p.current.LoadBalancerListResult.NextLink == nil || len(*p.current.LoadBalancerListResult.NextLink) == 0 { 4254 return false 4255 } 4256 req, err = p.advancer(ctx, p.current) 4257 } else { 4258 req, err = p.requester(ctx) 4259 } 4260 if err != nil { 4261 p.err = err 4262 return false 4263 } 4264 resp, err := p.pipeline.Do(req) 4265 if err != nil { 4266 p.err = err 4267 return false 4268 } 4269 if !resp.HasStatusCode(p.statusCodes...) { 4270 p.err = p.errorer(resp) 4271 return false 4272 } 4273 result, err := p.responder(resp) 4274 if err != nil { 4275 p.err = err 4276 return false 4277 } 4278 p.current = result 4279 return true 4280} 4281 4282func (p *loadBalancerListResultPager) PageResponse() LoadBalancerListResultResponse { 4283 return p.current 4284} 4285 4286// LoadBalancerLoadBalancingRuleListResultPager provides iteration over LoadBalancerLoadBalancingRuleListResult pages. 4287type LoadBalancerLoadBalancingRuleListResultPager interface { 4288 azcore.Pager 4289 4290 // PageResponse returns the current LoadBalancerLoadBalancingRuleListResultResponse. 4291 PageResponse() LoadBalancerLoadBalancingRuleListResultResponse 4292} 4293 4294type loadBalancerLoadBalancingRuleListResultCreateRequest func(context.Context) (*azcore.Request, error) 4295 4296type loadBalancerLoadBalancingRuleListResultHandleError func(*azcore.Response) error 4297 4298type loadBalancerLoadBalancingRuleListResultHandleResponse func(*azcore.Response) (LoadBalancerLoadBalancingRuleListResultResponse, error) 4299 4300type loadBalancerLoadBalancingRuleListResultAdvancePage func(context.Context, LoadBalancerLoadBalancingRuleListResultResponse) (*azcore.Request, error) 4301 4302type loadBalancerLoadBalancingRuleListResultPager struct { 4303 // the pipeline for making the request 4304 pipeline azcore.Pipeline 4305 // creates the initial request (non-LRO case) 4306 requester loadBalancerLoadBalancingRuleListResultCreateRequest 4307 // callback for handling response errors 4308 errorer loadBalancerLoadBalancingRuleListResultHandleError 4309 // callback for handling the HTTP response 4310 responder loadBalancerLoadBalancingRuleListResultHandleResponse 4311 // callback for advancing to the next page 4312 advancer loadBalancerLoadBalancingRuleListResultAdvancePage 4313 // contains the current response 4314 current LoadBalancerLoadBalancingRuleListResultResponse 4315 // status codes for successful retrieval 4316 statusCodes []int 4317 // any error encountered 4318 err error 4319} 4320 4321func (p *loadBalancerLoadBalancingRuleListResultPager) Err() error { 4322 return p.err 4323} 4324 4325func (p *loadBalancerLoadBalancingRuleListResultPager) NextPage(ctx context.Context) bool { 4326 var req *azcore.Request 4327 var err error 4328 if !reflect.ValueOf(p.current).IsZero() { 4329 if p.current.LoadBalancerLoadBalancingRuleListResult.NextLink == nil || len(*p.current.LoadBalancerLoadBalancingRuleListResult.NextLink) == 0 { 4330 return false 4331 } 4332 req, err = p.advancer(ctx, p.current) 4333 } else { 4334 req, err = p.requester(ctx) 4335 } 4336 if err != nil { 4337 p.err = err 4338 return false 4339 } 4340 resp, err := p.pipeline.Do(req) 4341 if err != nil { 4342 p.err = err 4343 return false 4344 } 4345 if !resp.HasStatusCode(p.statusCodes...) { 4346 p.err = p.errorer(resp) 4347 return false 4348 } 4349 result, err := p.responder(resp) 4350 if err != nil { 4351 p.err = err 4352 return false 4353 } 4354 p.current = result 4355 return true 4356} 4357 4358func (p *loadBalancerLoadBalancingRuleListResultPager) PageResponse() LoadBalancerLoadBalancingRuleListResultResponse { 4359 return p.current 4360} 4361 4362// LoadBalancerOutboundRuleListResultPager provides iteration over LoadBalancerOutboundRuleListResult pages. 4363type LoadBalancerOutboundRuleListResultPager interface { 4364 azcore.Pager 4365 4366 // PageResponse returns the current LoadBalancerOutboundRuleListResultResponse. 4367 PageResponse() LoadBalancerOutboundRuleListResultResponse 4368} 4369 4370type loadBalancerOutboundRuleListResultCreateRequest func(context.Context) (*azcore.Request, error) 4371 4372type loadBalancerOutboundRuleListResultHandleError func(*azcore.Response) error 4373 4374type loadBalancerOutboundRuleListResultHandleResponse func(*azcore.Response) (LoadBalancerOutboundRuleListResultResponse, error) 4375 4376type loadBalancerOutboundRuleListResultAdvancePage func(context.Context, LoadBalancerOutboundRuleListResultResponse) (*azcore.Request, error) 4377 4378type loadBalancerOutboundRuleListResultPager struct { 4379 // the pipeline for making the request 4380 pipeline azcore.Pipeline 4381 // creates the initial request (non-LRO case) 4382 requester loadBalancerOutboundRuleListResultCreateRequest 4383 // callback for handling response errors 4384 errorer loadBalancerOutboundRuleListResultHandleError 4385 // callback for handling the HTTP response 4386 responder loadBalancerOutboundRuleListResultHandleResponse 4387 // callback for advancing to the next page 4388 advancer loadBalancerOutboundRuleListResultAdvancePage 4389 // contains the current response 4390 current LoadBalancerOutboundRuleListResultResponse 4391 // status codes for successful retrieval 4392 statusCodes []int 4393 // any error encountered 4394 err error 4395} 4396 4397func (p *loadBalancerOutboundRuleListResultPager) Err() error { 4398 return p.err 4399} 4400 4401func (p *loadBalancerOutboundRuleListResultPager) NextPage(ctx context.Context) bool { 4402 var req *azcore.Request 4403 var err error 4404 if !reflect.ValueOf(p.current).IsZero() { 4405 if p.current.LoadBalancerOutboundRuleListResult.NextLink == nil || len(*p.current.LoadBalancerOutboundRuleListResult.NextLink) == 0 { 4406 return false 4407 } 4408 req, err = p.advancer(ctx, p.current) 4409 } else { 4410 req, err = p.requester(ctx) 4411 } 4412 if err != nil { 4413 p.err = err 4414 return false 4415 } 4416 resp, err := p.pipeline.Do(req) 4417 if err != nil { 4418 p.err = err 4419 return false 4420 } 4421 if !resp.HasStatusCode(p.statusCodes...) { 4422 p.err = p.errorer(resp) 4423 return false 4424 } 4425 result, err := p.responder(resp) 4426 if err != nil { 4427 p.err = err 4428 return false 4429 } 4430 p.current = result 4431 return true 4432} 4433 4434func (p *loadBalancerOutboundRuleListResultPager) PageResponse() LoadBalancerOutboundRuleListResultResponse { 4435 return p.current 4436} 4437 4438// LoadBalancerProbeListResultPager provides iteration over LoadBalancerProbeListResult pages. 4439type LoadBalancerProbeListResultPager interface { 4440 azcore.Pager 4441 4442 // PageResponse returns the current LoadBalancerProbeListResultResponse. 4443 PageResponse() LoadBalancerProbeListResultResponse 4444} 4445 4446type loadBalancerProbeListResultCreateRequest func(context.Context) (*azcore.Request, error) 4447 4448type loadBalancerProbeListResultHandleError func(*azcore.Response) error 4449 4450type loadBalancerProbeListResultHandleResponse func(*azcore.Response) (LoadBalancerProbeListResultResponse, error) 4451 4452type loadBalancerProbeListResultAdvancePage func(context.Context, LoadBalancerProbeListResultResponse) (*azcore.Request, error) 4453 4454type loadBalancerProbeListResultPager struct { 4455 // the pipeline for making the request 4456 pipeline azcore.Pipeline 4457 // creates the initial request (non-LRO case) 4458 requester loadBalancerProbeListResultCreateRequest 4459 // callback for handling response errors 4460 errorer loadBalancerProbeListResultHandleError 4461 // callback for handling the HTTP response 4462 responder loadBalancerProbeListResultHandleResponse 4463 // callback for advancing to the next page 4464 advancer loadBalancerProbeListResultAdvancePage 4465 // contains the current response 4466 current LoadBalancerProbeListResultResponse 4467 // status codes for successful retrieval 4468 statusCodes []int 4469 // any error encountered 4470 err error 4471} 4472 4473func (p *loadBalancerProbeListResultPager) Err() error { 4474 return p.err 4475} 4476 4477func (p *loadBalancerProbeListResultPager) NextPage(ctx context.Context) bool { 4478 var req *azcore.Request 4479 var err error 4480 if !reflect.ValueOf(p.current).IsZero() { 4481 if p.current.LoadBalancerProbeListResult.NextLink == nil || len(*p.current.LoadBalancerProbeListResult.NextLink) == 0 { 4482 return false 4483 } 4484 req, err = p.advancer(ctx, p.current) 4485 } else { 4486 req, err = p.requester(ctx) 4487 } 4488 if err != nil { 4489 p.err = err 4490 return false 4491 } 4492 resp, err := p.pipeline.Do(req) 4493 if err != nil { 4494 p.err = err 4495 return false 4496 } 4497 if !resp.HasStatusCode(p.statusCodes...) { 4498 p.err = p.errorer(resp) 4499 return false 4500 } 4501 result, err := p.responder(resp) 4502 if err != nil { 4503 p.err = err 4504 return false 4505 } 4506 p.current = result 4507 return true 4508} 4509 4510func (p *loadBalancerProbeListResultPager) PageResponse() LoadBalancerProbeListResultResponse { 4511 return p.current 4512} 4513 4514// LocalNetworkGatewayListResultPager provides iteration over LocalNetworkGatewayListResult pages. 4515type LocalNetworkGatewayListResultPager interface { 4516 azcore.Pager 4517 4518 // PageResponse returns the current LocalNetworkGatewayListResultResponse. 4519 PageResponse() LocalNetworkGatewayListResultResponse 4520} 4521 4522type localNetworkGatewayListResultCreateRequest func(context.Context) (*azcore.Request, error) 4523 4524type localNetworkGatewayListResultHandleError func(*azcore.Response) error 4525 4526type localNetworkGatewayListResultHandleResponse func(*azcore.Response) (LocalNetworkGatewayListResultResponse, error) 4527 4528type localNetworkGatewayListResultAdvancePage func(context.Context, LocalNetworkGatewayListResultResponse) (*azcore.Request, error) 4529 4530type localNetworkGatewayListResultPager struct { 4531 // the pipeline for making the request 4532 pipeline azcore.Pipeline 4533 // creates the initial request (non-LRO case) 4534 requester localNetworkGatewayListResultCreateRequest 4535 // callback for handling response errors 4536 errorer localNetworkGatewayListResultHandleError 4537 // callback for handling the HTTP response 4538 responder localNetworkGatewayListResultHandleResponse 4539 // callback for advancing to the next page 4540 advancer localNetworkGatewayListResultAdvancePage 4541 // contains the current response 4542 current LocalNetworkGatewayListResultResponse 4543 // status codes for successful retrieval 4544 statusCodes []int 4545 // any error encountered 4546 err error 4547} 4548 4549func (p *localNetworkGatewayListResultPager) Err() error { 4550 return p.err 4551} 4552 4553func (p *localNetworkGatewayListResultPager) NextPage(ctx context.Context) bool { 4554 var req *azcore.Request 4555 var err error 4556 if !reflect.ValueOf(p.current).IsZero() { 4557 if p.current.LocalNetworkGatewayListResult.NextLink == nil || len(*p.current.LocalNetworkGatewayListResult.NextLink) == 0 { 4558 return false 4559 } 4560 req, err = p.advancer(ctx, p.current) 4561 } else { 4562 req, err = p.requester(ctx) 4563 } 4564 if err != nil { 4565 p.err = err 4566 return false 4567 } 4568 resp, err := p.pipeline.Do(req) 4569 if err != nil { 4570 p.err = err 4571 return false 4572 } 4573 if !resp.HasStatusCode(p.statusCodes...) { 4574 p.err = p.errorer(resp) 4575 return false 4576 } 4577 result, err := p.responder(resp) 4578 if err != nil { 4579 p.err = err 4580 return false 4581 } 4582 p.current = result 4583 return true 4584} 4585 4586func (p *localNetworkGatewayListResultPager) PageResponse() LocalNetworkGatewayListResultResponse { 4587 return p.current 4588} 4589 4590// NatGatewayListResultPager provides iteration over NatGatewayListResult pages. 4591type NatGatewayListResultPager interface { 4592 azcore.Pager 4593 4594 // PageResponse returns the current NatGatewayListResultResponse. 4595 PageResponse() NatGatewayListResultResponse 4596} 4597 4598type natGatewayListResultCreateRequest func(context.Context) (*azcore.Request, error) 4599 4600type natGatewayListResultHandleError func(*azcore.Response) error 4601 4602type natGatewayListResultHandleResponse func(*azcore.Response) (NatGatewayListResultResponse, error) 4603 4604type natGatewayListResultAdvancePage func(context.Context, NatGatewayListResultResponse) (*azcore.Request, error) 4605 4606type natGatewayListResultPager struct { 4607 // the pipeline for making the request 4608 pipeline azcore.Pipeline 4609 // creates the initial request (non-LRO case) 4610 requester natGatewayListResultCreateRequest 4611 // callback for handling response errors 4612 errorer natGatewayListResultHandleError 4613 // callback for handling the HTTP response 4614 responder natGatewayListResultHandleResponse 4615 // callback for advancing to the next page 4616 advancer natGatewayListResultAdvancePage 4617 // contains the current response 4618 current NatGatewayListResultResponse 4619 // status codes for successful retrieval 4620 statusCodes []int 4621 // any error encountered 4622 err error 4623} 4624 4625func (p *natGatewayListResultPager) Err() error { 4626 return p.err 4627} 4628 4629func (p *natGatewayListResultPager) NextPage(ctx context.Context) bool { 4630 var req *azcore.Request 4631 var err error 4632 if !reflect.ValueOf(p.current).IsZero() { 4633 if p.current.NatGatewayListResult.NextLink == nil || len(*p.current.NatGatewayListResult.NextLink) == 0 { 4634 return false 4635 } 4636 req, err = p.advancer(ctx, p.current) 4637 } else { 4638 req, err = p.requester(ctx) 4639 } 4640 if err != nil { 4641 p.err = err 4642 return false 4643 } 4644 resp, err := p.pipeline.Do(req) 4645 if err != nil { 4646 p.err = err 4647 return false 4648 } 4649 if !resp.HasStatusCode(p.statusCodes...) { 4650 p.err = p.errorer(resp) 4651 return false 4652 } 4653 result, err := p.responder(resp) 4654 if err != nil { 4655 p.err = err 4656 return false 4657 } 4658 p.current = result 4659 return true 4660} 4661 4662func (p *natGatewayListResultPager) PageResponse() NatGatewayListResultResponse { 4663 return p.current 4664} 4665 4666// NetworkInterfaceIPConfigurationListResultPager provides iteration over NetworkInterfaceIPConfigurationListResult pages. 4667type NetworkInterfaceIPConfigurationListResultPager interface { 4668 azcore.Pager 4669 4670 // PageResponse returns the current NetworkInterfaceIPConfigurationListResultResponse. 4671 PageResponse() NetworkInterfaceIPConfigurationListResultResponse 4672} 4673 4674type networkInterfaceIPConfigurationListResultCreateRequest func(context.Context) (*azcore.Request, error) 4675 4676type networkInterfaceIPConfigurationListResultHandleError func(*azcore.Response) error 4677 4678type networkInterfaceIPConfigurationListResultHandleResponse func(*azcore.Response) (NetworkInterfaceIPConfigurationListResultResponse, error) 4679 4680type networkInterfaceIPConfigurationListResultAdvancePage func(context.Context, NetworkInterfaceIPConfigurationListResultResponse) (*azcore.Request, error) 4681 4682type networkInterfaceIPConfigurationListResultPager struct { 4683 // the pipeline for making the request 4684 pipeline azcore.Pipeline 4685 // creates the initial request (non-LRO case) 4686 requester networkInterfaceIPConfigurationListResultCreateRequest 4687 // callback for handling response errors 4688 errorer networkInterfaceIPConfigurationListResultHandleError 4689 // callback for handling the HTTP response 4690 responder networkInterfaceIPConfigurationListResultHandleResponse 4691 // callback for advancing to the next page 4692 advancer networkInterfaceIPConfigurationListResultAdvancePage 4693 // contains the current response 4694 current NetworkInterfaceIPConfigurationListResultResponse 4695 // status codes for successful retrieval 4696 statusCodes []int 4697 // any error encountered 4698 err error 4699} 4700 4701func (p *networkInterfaceIPConfigurationListResultPager) Err() error { 4702 return p.err 4703} 4704 4705func (p *networkInterfaceIPConfigurationListResultPager) NextPage(ctx context.Context) bool { 4706 var req *azcore.Request 4707 var err error 4708 if !reflect.ValueOf(p.current).IsZero() { 4709 if p.current.NetworkInterfaceIPConfigurationListResult.NextLink == nil || len(*p.current.NetworkInterfaceIPConfigurationListResult.NextLink) == 0 { 4710 return false 4711 } 4712 req, err = p.advancer(ctx, p.current) 4713 } else { 4714 req, err = p.requester(ctx) 4715 } 4716 if err != nil { 4717 p.err = err 4718 return false 4719 } 4720 resp, err := p.pipeline.Do(req) 4721 if err != nil { 4722 p.err = err 4723 return false 4724 } 4725 if !resp.HasStatusCode(p.statusCodes...) { 4726 p.err = p.errorer(resp) 4727 return false 4728 } 4729 result, err := p.responder(resp) 4730 if err != nil { 4731 p.err = err 4732 return false 4733 } 4734 p.current = result 4735 return true 4736} 4737 4738func (p *networkInterfaceIPConfigurationListResultPager) PageResponse() NetworkInterfaceIPConfigurationListResultResponse { 4739 return p.current 4740} 4741 4742// NetworkInterfaceListResultPager provides iteration over NetworkInterfaceListResult pages. 4743type NetworkInterfaceListResultPager interface { 4744 azcore.Pager 4745 4746 // PageResponse returns the current NetworkInterfaceListResultResponse. 4747 PageResponse() NetworkInterfaceListResultResponse 4748} 4749 4750type networkInterfaceListResultCreateRequest func(context.Context) (*azcore.Request, error) 4751 4752type networkInterfaceListResultHandleError func(*azcore.Response) error 4753 4754type networkInterfaceListResultHandleResponse func(*azcore.Response) (NetworkInterfaceListResultResponse, error) 4755 4756type networkInterfaceListResultAdvancePage func(context.Context, NetworkInterfaceListResultResponse) (*azcore.Request, error) 4757 4758type networkInterfaceListResultPager struct { 4759 // the pipeline for making the request 4760 pipeline azcore.Pipeline 4761 // creates the initial request (non-LRO case) 4762 requester networkInterfaceListResultCreateRequest 4763 // callback for handling response errors 4764 errorer networkInterfaceListResultHandleError 4765 // callback for handling the HTTP response 4766 responder networkInterfaceListResultHandleResponse 4767 // callback for advancing to the next page 4768 advancer networkInterfaceListResultAdvancePage 4769 // contains the current response 4770 current NetworkInterfaceListResultResponse 4771 // status codes for successful retrieval 4772 statusCodes []int 4773 // any error encountered 4774 err error 4775} 4776 4777func (p *networkInterfaceListResultPager) Err() error { 4778 return p.err 4779} 4780 4781func (p *networkInterfaceListResultPager) NextPage(ctx context.Context) bool { 4782 var req *azcore.Request 4783 var err error 4784 if !reflect.ValueOf(p.current).IsZero() { 4785 if p.current.NetworkInterfaceListResult.NextLink == nil || len(*p.current.NetworkInterfaceListResult.NextLink) == 0 { 4786 return false 4787 } 4788 req, err = p.advancer(ctx, p.current) 4789 } else { 4790 req, err = p.requester(ctx) 4791 } 4792 if err != nil { 4793 p.err = err 4794 return false 4795 } 4796 resp, err := p.pipeline.Do(req) 4797 if err != nil { 4798 p.err = err 4799 return false 4800 } 4801 if !resp.HasStatusCode(p.statusCodes...) { 4802 p.err = p.errorer(resp) 4803 return false 4804 } 4805 result, err := p.responder(resp) 4806 if err != nil { 4807 p.err = err 4808 return false 4809 } 4810 p.current = result 4811 return true 4812} 4813 4814func (p *networkInterfaceListResultPager) PageResponse() NetworkInterfaceListResultResponse { 4815 return p.current 4816} 4817 4818// NetworkInterfaceLoadBalancerListResultPager provides iteration over NetworkInterfaceLoadBalancerListResult pages. 4819type NetworkInterfaceLoadBalancerListResultPager interface { 4820 azcore.Pager 4821 4822 // PageResponse returns the current NetworkInterfaceLoadBalancerListResultResponse. 4823 PageResponse() NetworkInterfaceLoadBalancerListResultResponse 4824} 4825 4826type networkInterfaceLoadBalancerListResultCreateRequest func(context.Context) (*azcore.Request, error) 4827 4828type networkInterfaceLoadBalancerListResultHandleError func(*azcore.Response) error 4829 4830type networkInterfaceLoadBalancerListResultHandleResponse func(*azcore.Response) (NetworkInterfaceLoadBalancerListResultResponse, error) 4831 4832type networkInterfaceLoadBalancerListResultAdvancePage func(context.Context, NetworkInterfaceLoadBalancerListResultResponse) (*azcore.Request, error) 4833 4834type networkInterfaceLoadBalancerListResultPager struct { 4835 // the pipeline for making the request 4836 pipeline azcore.Pipeline 4837 // creates the initial request (non-LRO case) 4838 requester networkInterfaceLoadBalancerListResultCreateRequest 4839 // callback for handling response errors 4840 errorer networkInterfaceLoadBalancerListResultHandleError 4841 // callback for handling the HTTP response 4842 responder networkInterfaceLoadBalancerListResultHandleResponse 4843 // callback for advancing to the next page 4844 advancer networkInterfaceLoadBalancerListResultAdvancePage 4845 // contains the current response 4846 current NetworkInterfaceLoadBalancerListResultResponse 4847 // status codes for successful retrieval 4848 statusCodes []int 4849 // any error encountered 4850 err error 4851} 4852 4853func (p *networkInterfaceLoadBalancerListResultPager) Err() error { 4854 return p.err 4855} 4856 4857func (p *networkInterfaceLoadBalancerListResultPager) NextPage(ctx context.Context) bool { 4858 var req *azcore.Request 4859 var err error 4860 if !reflect.ValueOf(p.current).IsZero() { 4861 if p.current.NetworkInterfaceLoadBalancerListResult.NextLink == nil || len(*p.current.NetworkInterfaceLoadBalancerListResult.NextLink) == 0 { 4862 return false 4863 } 4864 req, err = p.advancer(ctx, p.current) 4865 } else { 4866 req, err = p.requester(ctx) 4867 } 4868 if err != nil { 4869 p.err = err 4870 return false 4871 } 4872 resp, err := p.pipeline.Do(req) 4873 if err != nil { 4874 p.err = err 4875 return false 4876 } 4877 if !resp.HasStatusCode(p.statusCodes...) { 4878 p.err = p.errorer(resp) 4879 return false 4880 } 4881 result, err := p.responder(resp) 4882 if err != nil { 4883 p.err = err 4884 return false 4885 } 4886 p.current = result 4887 return true 4888} 4889 4890func (p *networkInterfaceLoadBalancerListResultPager) PageResponse() NetworkInterfaceLoadBalancerListResultResponse { 4891 return p.current 4892} 4893 4894// NetworkInterfaceTapConfigurationListResultPager provides iteration over NetworkInterfaceTapConfigurationListResult pages. 4895type NetworkInterfaceTapConfigurationListResultPager interface { 4896 azcore.Pager 4897 4898 // PageResponse returns the current NetworkInterfaceTapConfigurationListResultResponse. 4899 PageResponse() NetworkInterfaceTapConfigurationListResultResponse 4900} 4901 4902type networkInterfaceTapConfigurationListResultCreateRequest func(context.Context) (*azcore.Request, error) 4903 4904type networkInterfaceTapConfigurationListResultHandleError func(*azcore.Response) error 4905 4906type networkInterfaceTapConfigurationListResultHandleResponse func(*azcore.Response) (NetworkInterfaceTapConfigurationListResultResponse, error) 4907 4908type networkInterfaceTapConfigurationListResultAdvancePage func(context.Context, NetworkInterfaceTapConfigurationListResultResponse) (*azcore.Request, error) 4909 4910type networkInterfaceTapConfigurationListResultPager struct { 4911 // the pipeline for making the request 4912 pipeline azcore.Pipeline 4913 // creates the initial request (non-LRO case) 4914 requester networkInterfaceTapConfigurationListResultCreateRequest 4915 // callback for handling response errors 4916 errorer networkInterfaceTapConfigurationListResultHandleError 4917 // callback for handling the HTTP response 4918 responder networkInterfaceTapConfigurationListResultHandleResponse 4919 // callback for advancing to the next page 4920 advancer networkInterfaceTapConfigurationListResultAdvancePage 4921 // contains the current response 4922 current NetworkInterfaceTapConfigurationListResultResponse 4923 // status codes for successful retrieval 4924 statusCodes []int 4925 // any error encountered 4926 err error 4927} 4928 4929func (p *networkInterfaceTapConfigurationListResultPager) Err() error { 4930 return p.err 4931} 4932 4933func (p *networkInterfaceTapConfigurationListResultPager) NextPage(ctx context.Context) bool { 4934 var req *azcore.Request 4935 var err error 4936 if !reflect.ValueOf(p.current).IsZero() { 4937 if p.current.NetworkInterfaceTapConfigurationListResult.NextLink == nil || len(*p.current.NetworkInterfaceTapConfigurationListResult.NextLink) == 0 { 4938 return false 4939 } 4940 req, err = p.advancer(ctx, p.current) 4941 } else { 4942 req, err = p.requester(ctx) 4943 } 4944 if err != nil { 4945 p.err = err 4946 return false 4947 } 4948 resp, err := p.pipeline.Do(req) 4949 if err != nil { 4950 p.err = err 4951 return false 4952 } 4953 if !resp.HasStatusCode(p.statusCodes...) { 4954 p.err = p.errorer(resp) 4955 return false 4956 } 4957 result, err := p.responder(resp) 4958 if err != nil { 4959 p.err = err 4960 return false 4961 } 4962 p.current = result 4963 return true 4964} 4965 4966func (p *networkInterfaceTapConfigurationListResultPager) PageResponse() NetworkInterfaceTapConfigurationListResultResponse { 4967 return p.current 4968} 4969 4970// NetworkProfileListResultPager provides iteration over NetworkProfileListResult pages. 4971type NetworkProfileListResultPager interface { 4972 azcore.Pager 4973 4974 // PageResponse returns the current NetworkProfileListResultResponse. 4975 PageResponse() NetworkProfileListResultResponse 4976} 4977 4978type networkProfileListResultCreateRequest func(context.Context) (*azcore.Request, error) 4979 4980type networkProfileListResultHandleError func(*azcore.Response) error 4981 4982type networkProfileListResultHandleResponse func(*azcore.Response) (NetworkProfileListResultResponse, error) 4983 4984type networkProfileListResultAdvancePage func(context.Context, NetworkProfileListResultResponse) (*azcore.Request, error) 4985 4986type networkProfileListResultPager struct { 4987 // the pipeline for making the request 4988 pipeline azcore.Pipeline 4989 // creates the initial request (non-LRO case) 4990 requester networkProfileListResultCreateRequest 4991 // callback for handling response errors 4992 errorer networkProfileListResultHandleError 4993 // callback for handling the HTTP response 4994 responder networkProfileListResultHandleResponse 4995 // callback for advancing to the next page 4996 advancer networkProfileListResultAdvancePage 4997 // contains the current response 4998 current NetworkProfileListResultResponse 4999 // status codes for successful retrieval 5000 statusCodes []int 5001 // any error encountered 5002 err error 5003} 5004 5005func (p *networkProfileListResultPager) Err() error { 5006 return p.err 5007} 5008 5009func (p *networkProfileListResultPager) NextPage(ctx context.Context) bool { 5010 var req *azcore.Request 5011 var err error 5012 if !reflect.ValueOf(p.current).IsZero() { 5013 if p.current.NetworkProfileListResult.NextLink == nil || len(*p.current.NetworkProfileListResult.NextLink) == 0 { 5014 return false 5015 } 5016 req, err = p.advancer(ctx, p.current) 5017 } else { 5018 req, err = p.requester(ctx) 5019 } 5020 if err != nil { 5021 p.err = err 5022 return false 5023 } 5024 resp, err := p.pipeline.Do(req) 5025 if err != nil { 5026 p.err = err 5027 return false 5028 } 5029 if !resp.HasStatusCode(p.statusCodes...) { 5030 p.err = p.errorer(resp) 5031 return false 5032 } 5033 result, err := p.responder(resp) 5034 if err != nil { 5035 p.err = err 5036 return false 5037 } 5038 p.current = result 5039 return true 5040} 5041 5042func (p *networkProfileListResultPager) PageResponse() NetworkProfileListResultResponse { 5043 return p.current 5044} 5045 5046// NetworkSecurityGroupListResultPager provides iteration over NetworkSecurityGroupListResult pages. 5047type NetworkSecurityGroupListResultPager interface { 5048 azcore.Pager 5049 5050 // PageResponse returns the current NetworkSecurityGroupListResultResponse. 5051 PageResponse() NetworkSecurityGroupListResultResponse 5052} 5053 5054type networkSecurityGroupListResultCreateRequest func(context.Context) (*azcore.Request, error) 5055 5056type networkSecurityGroupListResultHandleError func(*azcore.Response) error 5057 5058type networkSecurityGroupListResultHandleResponse func(*azcore.Response) (NetworkSecurityGroupListResultResponse, error) 5059 5060type networkSecurityGroupListResultAdvancePage func(context.Context, NetworkSecurityGroupListResultResponse) (*azcore.Request, error) 5061 5062type networkSecurityGroupListResultPager struct { 5063 // the pipeline for making the request 5064 pipeline azcore.Pipeline 5065 // creates the initial request (non-LRO case) 5066 requester networkSecurityGroupListResultCreateRequest 5067 // callback for handling response errors 5068 errorer networkSecurityGroupListResultHandleError 5069 // callback for handling the HTTP response 5070 responder networkSecurityGroupListResultHandleResponse 5071 // callback for advancing to the next page 5072 advancer networkSecurityGroupListResultAdvancePage 5073 // contains the current response 5074 current NetworkSecurityGroupListResultResponse 5075 // status codes for successful retrieval 5076 statusCodes []int 5077 // any error encountered 5078 err error 5079} 5080 5081func (p *networkSecurityGroupListResultPager) Err() error { 5082 return p.err 5083} 5084 5085func (p *networkSecurityGroupListResultPager) NextPage(ctx context.Context) bool { 5086 var req *azcore.Request 5087 var err error 5088 if !reflect.ValueOf(p.current).IsZero() { 5089 if p.current.NetworkSecurityGroupListResult.NextLink == nil || len(*p.current.NetworkSecurityGroupListResult.NextLink) == 0 { 5090 return false 5091 } 5092 req, err = p.advancer(ctx, p.current) 5093 } else { 5094 req, err = p.requester(ctx) 5095 } 5096 if err != nil { 5097 p.err = err 5098 return false 5099 } 5100 resp, err := p.pipeline.Do(req) 5101 if err != nil { 5102 p.err = err 5103 return false 5104 } 5105 if !resp.HasStatusCode(p.statusCodes...) { 5106 p.err = p.errorer(resp) 5107 return false 5108 } 5109 result, err := p.responder(resp) 5110 if err != nil { 5111 p.err = err 5112 return false 5113 } 5114 p.current = result 5115 return true 5116} 5117 5118func (p *networkSecurityGroupListResultPager) PageResponse() NetworkSecurityGroupListResultResponse { 5119 return p.current 5120} 5121 5122// NetworkVirtualApplianceListResultPager provides iteration over NetworkVirtualApplianceListResult pages. 5123type NetworkVirtualApplianceListResultPager interface { 5124 azcore.Pager 5125 5126 // PageResponse returns the current NetworkVirtualApplianceListResultResponse. 5127 PageResponse() NetworkVirtualApplianceListResultResponse 5128} 5129 5130type networkVirtualApplianceListResultCreateRequest func(context.Context) (*azcore.Request, error) 5131 5132type networkVirtualApplianceListResultHandleError func(*azcore.Response) error 5133 5134type networkVirtualApplianceListResultHandleResponse func(*azcore.Response) (NetworkVirtualApplianceListResultResponse, error) 5135 5136type networkVirtualApplianceListResultAdvancePage func(context.Context, NetworkVirtualApplianceListResultResponse) (*azcore.Request, error) 5137 5138type networkVirtualApplianceListResultPager struct { 5139 // the pipeline for making the request 5140 pipeline azcore.Pipeline 5141 // creates the initial request (non-LRO case) 5142 requester networkVirtualApplianceListResultCreateRequest 5143 // callback for handling response errors 5144 errorer networkVirtualApplianceListResultHandleError 5145 // callback for handling the HTTP response 5146 responder networkVirtualApplianceListResultHandleResponse 5147 // callback for advancing to the next page 5148 advancer networkVirtualApplianceListResultAdvancePage 5149 // contains the current response 5150 current NetworkVirtualApplianceListResultResponse 5151 // status codes for successful retrieval 5152 statusCodes []int 5153 // any error encountered 5154 err error 5155} 5156 5157func (p *networkVirtualApplianceListResultPager) Err() error { 5158 return p.err 5159} 5160 5161func (p *networkVirtualApplianceListResultPager) NextPage(ctx context.Context) bool { 5162 var req *azcore.Request 5163 var err error 5164 if !reflect.ValueOf(p.current).IsZero() { 5165 if p.current.NetworkVirtualApplianceListResult.NextLink == nil || len(*p.current.NetworkVirtualApplianceListResult.NextLink) == 0 { 5166 return false 5167 } 5168 req, err = p.advancer(ctx, p.current) 5169 } else { 5170 req, err = p.requester(ctx) 5171 } 5172 if err != nil { 5173 p.err = err 5174 return false 5175 } 5176 resp, err := p.pipeline.Do(req) 5177 if err != nil { 5178 p.err = err 5179 return false 5180 } 5181 if !resp.HasStatusCode(p.statusCodes...) { 5182 p.err = p.errorer(resp) 5183 return false 5184 } 5185 result, err := p.responder(resp) 5186 if err != nil { 5187 p.err = err 5188 return false 5189 } 5190 p.current = result 5191 return true 5192} 5193 5194func (p *networkVirtualApplianceListResultPager) PageResponse() NetworkVirtualApplianceListResultResponse { 5195 return p.current 5196} 5197 5198// NetworkVirtualApplianceSKUListResultPager provides iteration over NetworkVirtualApplianceSKUListResult pages. 5199type NetworkVirtualApplianceSKUListResultPager interface { 5200 azcore.Pager 5201 5202 // PageResponse returns the current NetworkVirtualApplianceSKUListResultResponse. 5203 PageResponse() NetworkVirtualApplianceSKUListResultResponse 5204} 5205 5206type networkVirtualApplianceSKUListResultCreateRequest func(context.Context) (*azcore.Request, error) 5207 5208type networkVirtualApplianceSKUListResultHandleError func(*azcore.Response) error 5209 5210type networkVirtualApplianceSKUListResultHandleResponse func(*azcore.Response) (NetworkVirtualApplianceSKUListResultResponse, error) 5211 5212type networkVirtualApplianceSKUListResultAdvancePage func(context.Context, NetworkVirtualApplianceSKUListResultResponse) (*azcore.Request, error) 5213 5214type networkVirtualApplianceSKUListResultPager struct { 5215 // the pipeline for making the request 5216 pipeline azcore.Pipeline 5217 // creates the initial request (non-LRO case) 5218 requester networkVirtualApplianceSKUListResultCreateRequest 5219 // callback for handling response errors 5220 errorer networkVirtualApplianceSKUListResultHandleError 5221 // callback for handling the HTTP response 5222 responder networkVirtualApplianceSKUListResultHandleResponse 5223 // callback for advancing to the next page 5224 advancer networkVirtualApplianceSKUListResultAdvancePage 5225 // contains the current response 5226 current NetworkVirtualApplianceSKUListResultResponse 5227 // status codes for successful retrieval 5228 statusCodes []int 5229 // any error encountered 5230 err error 5231} 5232 5233func (p *networkVirtualApplianceSKUListResultPager) Err() error { 5234 return p.err 5235} 5236 5237func (p *networkVirtualApplianceSKUListResultPager) NextPage(ctx context.Context) bool { 5238 var req *azcore.Request 5239 var err error 5240 if !reflect.ValueOf(p.current).IsZero() { 5241 if p.current.NetworkVirtualApplianceSKUListResult.NextLink == nil || len(*p.current.NetworkVirtualApplianceSKUListResult.NextLink) == 0 { 5242 return false 5243 } 5244 req, err = p.advancer(ctx, p.current) 5245 } else { 5246 req, err = p.requester(ctx) 5247 } 5248 if err != nil { 5249 p.err = err 5250 return false 5251 } 5252 resp, err := p.pipeline.Do(req) 5253 if err != nil { 5254 p.err = err 5255 return false 5256 } 5257 if !resp.HasStatusCode(p.statusCodes...) { 5258 p.err = p.errorer(resp) 5259 return false 5260 } 5261 result, err := p.responder(resp) 5262 if err != nil { 5263 p.err = err 5264 return false 5265 } 5266 p.current = result 5267 return true 5268} 5269 5270func (p *networkVirtualApplianceSKUListResultPager) PageResponse() NetworkVirtualApplianceSKUListResultResponse { 5271 return p.current 5272} 5273 5274// NetworkVirtualApplianceSiteListResultPager provides iteration over NetworkVirtualApplianceSiteListResult pages. 5275type NetworkVirtualApplianceSiteListResultPager interface { 5276 azcore.Pager 5277 5278 // PageResponse returns the current NetworkVirtualApplianceSiteListResultResponse. 5279 PageResponse() NetworkVirtualApplianceSiteListResultResponse 5280} 5281 5282type networkVirtualApplianceSiteListResultCreateRequest func(context.Context) (*azcore.Request, error) 5283 5284type networkVirtualApplianceSiteListResultHandleError func(*azcore.Response) error 5285 5286type networkVirtualApplianceSiteListResultHandleResponse func(*azcore.Response) (NetworkVirtualApplianceSiteListResultResponse, error) 5287 5288type networkVirtualApplianceSiteListResultAdvancePage func(context.Context, NetworkVirtualApplianceSiteListResultResponse) (*azcore.Request, error) 5289 5290type networkVirtualApplianceSiteListResultPager struct { 5291 // the pipeline for making the request 5292 pipeline azcore.Pipeline 5293 // creates the initial request (non-LRO case) 5294 requester networkVirtualApplianceSiteListResultCreateRequest 5295 // callback for handling response errors 5296 errorer networkVirtualApplianceSiteListResultHandleError 5297 // callback for handling the HTTP response 5298 responder networkVirtualApplianceSiteListResultHandleResponse 5299 // callback for advancing to the next page 5300 advancer networkVirtualApplianceSiteListResultAdvancePage 5301 // contains the current response 5302 current NetworkVirtualApplianceSiteListResultResponse 5303 // status codes for successful retrieval 5304 statusCodes []int 5305 // any error encountered 5306 err error 5307} 5308 5309func (p *networkVirtualApplianceSiteListResultPager) Err() error { 5310 return p.err 5311} 5312 5313func (p *networkVirtualApplianceSiteListResultPager) NextPage(ctx context.Context) bool { 5314 var req *azcore.Request 5315 var err error 5316 if !reflect.ValueOf(p.current).IsZero() { 5317 if p.current.NetworkVirtualApplianceSiteListResult.NextLink == nil || len(*p.current.NetworkVirtualApplianceSiteListResult.NextLink) == 0 { 5318 return false 5319 } 5320 req, err = p.advancer(ctx, p.current) 5321 } else { 5322 req, err = p.requester(ctx) 5323 } 5324 if err != nil { 5325 p.err = err 5326 return false 5327 } 5328 resp, err := p.pipeline.Do(req) 5329 if err != nil { 5330 p.err = err 5331 return false 5332 } 5333 if !resp.HasStatusCode(p.statusCodes...) { 5334 p.err = p.errorer(resp) 5335 return false 5336 } 5337 result, err := p.responder(resp) 5338 if err != nil { 5339 p.err = err 5340 return false 5341 } 5342 p.current = result 5343 return true 5344} 5345 5346func (p *networkVirtualApplianceSiteListResultPager) PageResponse() NetworkVirtualApplianceSiteListResultResponse { 5347 return p.current 5348} 5349 5350// OperationListResultPager provides iteration over OperationListResult pages. 5351type OperationListResultPager interface { 5352 azcore.Pager 5353 5354 // PageResponse returns the current OperationListResultResponse. 5355 PageResponse() OperationListResultResponse 5356} 5357 5358type operationListResultCreateRequest func(context.Context) (*azcore.Request, error) 5359 5360type operationListResultHandleError func(*azcore.Response) error 5361 5362type operationListResultHandleResponse func(*azcore.Response) (OperationListResultResponse, error) 5363 5364type operationListResultAdvancePage func(context.Context, OperationListResultResponse) (*azcore.Request, error) 5365 5366type operationListResultPager struct { 5367 // the pipeline for making the request 5368 pipeline azcore.Pipeline 5369 // creates the initial request (non-LRO case) 5370 requester operationListResultCreateRequest 5371 // callback for handling response errors 5372 errorer operationListResultHandleError 5373 // callback for handling the HTTP response 5374 responder operationListResultHandleResponse 5375 // callback for advancing to the next page 5376 advancer operationListResultAdvancePage 5377 // contains the current response 5378 current OperationListResultResponse 5379 // status codes for successful retrieval 5380 statusCodes []int 5381 // any error encountered 5382 err error 5383} 5384 5385func (p *operationListResultPager) Err() error { 5386 return p.err 5387} 5388 5389func (p *operationListResultPager) NextPage(ctx context.Context) bool { 5390 var req *azcore.Request 5391 var err error 5392 if !reflect.ValueOf(p.current).IsZero() { 5393 if p.current.OperationListResult.NextLink == nil || len(*p.current.OperationListResult.NextLink) == 0 { 5394 return false 5395 } 5396 req, err = p.advancer(ctx, p.current) 5397 } else { 5398 req, err = p.requester(ctx) 5399 } 5400 if err != nil { 5401 p.err = err 5402 return false 5403 } 5404 resp, err := p.pipeline.Do(req) 5405 if err != nil { 5406 p.err = err 5407 return false 5408 } 5409 if !resp.HasStatusCode(p.statusCodes...) { 5410 p.err = p.errorer(resp) 5411 return false 5412 } 5413 result, err := p.responder(resp) 5414 if err != nil { 5415 p.err = err 5416 return false 5417 } 5418 p.current = result 5419 return true 5420} 5421 5422func (p *operationListResultPager) PageResponse() OperationListResultResponse { 5423 return p.current 5424} 5425 5426// PeerExpressRouteCircuitConnectionListResultPager provides iteration over PeerExpressRouteCircuitConnectionListResult pages. 5427type PeerExpressRouteCircuitConnectionListResultPager interface { 5428 azcore.Pager 5429 5430 // PageResponse returns the current PeerExpressRouteCircuitConnectionListResultResponse. 5431 PageResponse() PeerExpressRouteCircuitConnectionListResultResponse 5432} 5433 5434type peerExpressRouteCircuitConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error) 5435 5436type peerExpressRouteCircuitConnectionListResultHandleError func(*azcore.Response) error 5437 5438type peerExpressRouteCircuitConnectionListResultHandleResponse func(*azcore.Response) (PeerExpressRouteCircuitConnectionListResultResponse, error) 5439 5440type peerExpressRouteCircuitConnectionListResultAdvancePage func(context.Context, PeerExpressRouteCircuitConnectionListResultResponse) (*azcore.Request, error) 5441 5442type peerExpressRouteCircuitConnectionListResultPager struct { 5443 // the pipeline for making the request 5444 pipeline azcore.Pipeline 5445 // creates the initial request (non-LRO case) 5446 requester peerExpressRouteCircuitConnectionListResultCreateRequest 5447 // callback for handling response errors 5448 errorer peerExpressRouteCircuitConnectionListResultHandleError 5449 // callback for handling the HTTP response 5450 responder peerExpressRouteCircuitConnectionListResultHandleResponse 5451 // callback for advancing to the next page 5452 advancer peerExpressRouteCircuitConnectionListResultAdvancePage 5453 // contains the current response 5454 current PeerExpressRouteCircuitConnectionListResultResponse 5455 // status codes for successful retrieval 5456 statusCodes []int 5457 // any error encountered 5458 err error 5459} 5460 5461func (p *peerExpressRouteCircuitConnectionListResultPager) Err() error { 5462 return p.err 5463} 5464 5465func (p *peerExpressRouteCircuitConnectionListResultPager) NextPage(ctx context.Context) bool { 5466 var req *azcore.Request 5467 var err error 5468 if !reflect.ValueOf(p.current).IsZero() { 5469 if p.current.PeerExpressRouteCircuitConnectionListResult.NextLink == nil || len(*p.current.PeerExpressRouteCircuitConnectionListResult.NextLink) == 0 { 5470 return false 5471 } 5472 req, err = p.advancer(ctx, p.current) 5473 } else { 5474 req, err = p.requester(ctx) 5475 } 5476 if err != nil { 5477 p.err = err 5478 return false 5479 } 5480 resp, err := p.pipeline.Do(req) 5481 if err != nil { 5482 p.err = err 5483 return false 5484 } 5485 if !resp.HasStatusCode(p.statusCodes...) { 5486 p.err = p.errorer(resp) 5487 return false 5488 } 5489 result, err := p.responder(resp) 5490 if err != nil { 5491 p.err = err 5492 return false 5493 } 5494 p.current = result 5495 return true 5496} 5497 5498func (p *peerExpressRouteCircuitConnectionListResultPager) PageResponse() PeerExpressRouteCircuitConnectionListResultResponse { 5499 return p.current 5500} 5501 5502// PrivateDNSZoneGroupListResultPager provides iteration over PrivateDNSZoneGroupListResult pages. 5503type PrivateDNSZoneGroupListResultPager interface { 5504 azcore.Pager 5505 5506 // PageResponse returns the current PrivateDNSZoneGroupListResultResponse. 5507 PageResponse() PrivateDNSZoneGroupListResultResponse 5508} 5509 5510type privateDNSZoneGroupListResultCreateRequest func(context.Context) (*azcore.Request, error) 5511 5512type privateDNSZoneGroupListResultHandleError func(*azcore.Response) error 5513 5514type privateDNSZoneGroupListResultHandleResponse func(*azcore.Response) (PrivateDNSZoneGroupListResultResponse, error) 5515 5516type privateDNSZoneGroupListResultAdvancePage func(context.Context, PrivateDNSZoneGroupListResultResponse) (*azcore.Request, error) 5517 5518type privateDNSZoneGroupListResultPager struct { 5519 // the pipeline for making the request 5520 pipeline azcore.Pipeline 5521 // creates the initial request (non-LRO case) 5522 requester privateDNSZoneGroupListResultCreateRequest 5523 // callback for handling response errors 5524 errorer privateDNSZoneGroupListResultHandleError 5525 // callback for handling the HTTP response 5526 responder privateDNSZoneGroupListResultHandleResponse 5527 // callback for advancing to the next page 5528 advancer privateDNSZoneGroupListResultAdvancePage 5529 // contains the current response 5530 current PrivateDNSZoneGroupListResultResponse 5531 // status codes for successful retrieval 5532 statusCodes []int 5533 // any error encountered 5534 err error 5535} 5536 5537func (p *privateDNSZoneGroupListResultPager) Err() error { 5538 return p.err 5539} 5540 5541func (p *privateDNSZoneGroupListResultPager) NextPage(ctx context.Context) bool { 5542 var req *azcore.Request 5543 var err error 5544 if !reflect.ValueOf(p.current).IsZero() { 5545 if p.current.PrivateDNSZoneGroupListResult.NextLink == nil || len(*p.current.PrivateDNSZoneGroupListResult.NextLink) == 0 { 5546 return false 5547 } 5548 req, err = p.advancer(ctx, p.current) 5549 } else { 5550 req, err = p.requester(ctx) 5551 } 5552 if err != nil { 5553 p.err = err 5554 return false 5555 } 5556 resp, err := p.pipeline.Do(req) 5557 if err != nil { 5558 p.err = err 5559 return false 5560 } 5561 if !resp.HasStatusCode(p.statusCodes...) { 5562 p.err = p.errorer(resp) 5563 return false 5564 } 5565 result, err := p.responder(resp) 5566 if err != nil { 5567 p.err = err 5568 return false 5569 } 5570 p.current = result 5571 return true 5572} 5573 5574func (p *privateDNSZoneGroupListResultPager) PageResponse() PrivateDNSZoneGroupListResultResponse { 5575 return p.current 5576} 5577 5578// PrivateEndpointConnectionListResultPager provides iteration over PrivateEndpointConnectionListResult pages. 5579type PrivateEndpointConnectionListResultPager interface { 5580 azcore.Pager 5581 5582 // PageResponse returns the current PrivateEndpointConnectionListResultResponse. 5583 PageResponse() PrivateEndpointConnectionListResultResponse 5584} 5585 5586type privateEndpointConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error) 5587 5588type privateEndpointConnectionListResultHandleError func(*azcore.Response) error 5589 5590type privateEndpointConnectionListResultHandleResponse func(*azcore.Response) (PrivateEndpointConnectionListResultResponse, error) 5591 5592type privateEndpointConnectionListResultAdvancePage func(context.Context, PrivateEndpointConnectionListResultResponse) (*azcore.Request, error) 5593 5594type privateEndpointConnectionListResultPager struct { 5595 // the pipeline for making the request 5596 pipeline azcore.Pipeline 5597 // creates the initial request (non-LRO case) 5598 requester privateEndpointConnectionListResultCreateRequest 5599 // callback for handling response errors 5600 errorer privateEndpointConnectionListResultHandleError 5601 // callback for handling the HTTP response 5602 responder privateEndpointConnectionListResultHandleResponse 5603 // callback for advancing to the next page 5604 advancer privateEndpointConnectionListResultAdvancePage 5605 // contains the current response 5606 current PrivateEndpointConnectionListResultResponse 5607 // status codes for successful retrieval 5608 statusCodes []int 5609 // any error encountered 5610 err error 5611} 5612 5613func (p *privateEndpointConnectionListResultPager) Err() error { 5614 return p.err 5615} 5616 5617func (p *privateEndpointConnectionListResultPager) NextPage(ctx context.Context) bool { 5618 var req *azcore.Request 5619 var err error 5620 if !reflect.ValueOf(p.current).IsZero() { 5621 if p.current.PrivateEndpointConnectionListResult.NextLink == nil || len(*p.current.PrivateEndpointConnectionListResult.NextLink) == 0 { 5622 return false 5623 } 5624 req, err = p.advancer(ctx, p.current) 5625 } else { 5626 req, err = p.requester(ctx) 5627 } 5628 if err != nil { 5629 p.err = err 5630 return false 5631 } 5632 resp, err := p.pipeline.Do(req) 5633 if err != nil { 5634 p.err = err 5635 return false 5636 } 5637 if !resp.HasStatusCode(p.statusCodes...) { 5638 p.err = p.errorer(resp) 5639 return false 5640 } 5641 result, err := p.responder(resp) 5642 if err != nil { 5643 p.err = err 5644 return false 5645 } 5646 p.current = result 5647 return true 5648} 5649 5650func (p *privateEndpointConnectionListResultPager) PageResponse() PrivateEndpointConnectionListResultResponse { 5651 return p.current 5652} 5653 5654// PrivateEndpointListResultPager provides iteration over PrivateEndpointListResult pages. 5655type PrivateEndpointListResultPager interface { 5656 azcore.Pager 5657 5658 // PageResponse returns the current PrivateEndpointListResultResponse. 5659 PageResponse() PrivateEndpointListResultResponse 5660} 5661 5662type privateEndpointListResultCreateRequest func(context.Context) (*azcore.Request, error) 5663 5664type privateEndpointListResultHandleError func(*azcore.Response) error 5665 5666type privateEndpointListResultHandleResponse func(*azcore.Response) (PrivateEndpointListResultResponse, error) 5667 5668type privateEndpointListResultAdvancePage func(context.Context, PrivateEndpointListResultResponse) (*azcore.Request, error) 5669 5670type privateEndpointListResultPager struct { 5671 // the pipeline for making the request 5672 pipeline azcore.Pipeline 5673 // creates the initial request (non-LRO case) 5674 requester privateEndpointListResultCreateRequest 5675 // callback for handling response errors 5676 errorer privateEndpointListResultHandleError 5677 // callback for handling the HTTP response 5678 responder privateEndpointListResultHandleResponse 5679 // callback for advancing to the next page 5680 advancer privateEndpointListResultAdvancePage 5681 // contains the current response 5682 current PrivateEndpointListResultResponse 5683 // status codes for successful retrieval 5684 statusCodes []int 5685 // any error encountered 5686 err error 5687} 5688 5689func (p *privateEndpointListResultPager) Err() error { 5690 return p.err 5691} 5692 5693func (p *privateEndpointListResultPager) NextPage(ctx context.Context) bool { 5694 var req *azcore.Request 5695 var err error 5696 if !reflect.ValueOf(p.current).IsZero() { 5697 if p.current.PrivateEndpointListResult.NextLink == nil || len(*p.current.PrivateEndpointListResult.NextLink) == 0 { 5698 return false 5699 } 5700 req, err = p.advancer(ctx, p.current) 5701 } else { 5702 req, err = p.requester(ctx) 5703 } 5704 if err != nil { 5705 p.err = err 5706 return false 5707 } 5708 resp, err := p.pipeline.Do(req) 5709 if err != nil { 5710 p.err = err 5711 return false 5712 } 5713 if !resp.HasStatusCode(p.statusCodes...) { 5714 p.err = p.errorer(resp) 5715 return false 5716 } 5717 result, err := p.responder(resp) 5718 if err != nil { 5719 p.err = err 5720 return false 5721 } 5722 p.current = result 5723 return true 5724} 5725 5726func (p *privateEndpointListResultPager) PageResponse() PrivateEndpointListResultResponse { 5727 return p.current 5728} 5729 5730// PrivateLinkServiceListResultPager provides iteration over PrivateLinkServiceListResult pages. 5731type PrivateLinkServiceListResultPager interface { 5732 azcore.Pager 5733 5734 // PageResponse returns the current PrivateLinkServiceListResultResponse. 5735 PageResponse() PrivateLinkServiceListResultResponse 5736} 5737 5738type privateLinkServiceListResultCreateRequest func(context.Context) (*azcore.Request, error) 5739 5740type privateLinkServiceListResultHandleError func(*azcore.Response) error 5741 5742type privateLinkServiceListResultHandleResponse func(*azcore.Response) (PrivateLinkServiceListResultResponse, error) 5743 5744type privateLinkServiceListResultAdvancePage func(context.Context, PrivateLinkServiceListResultResponse) (*azcore.Request, error) 5745 5746type privateLinkServiceListResultPager struct { 5747 // the pipeline for making the request 5748 pipeline azcore.Pipeline 5749 // creates the initial request (non-LRO case) 5750 requester privateLinkServiceListResultCreateRequest 5751 // callback for handling response errors 5752 errorer privateLinkServiceListResultHandleError 5753 // callback for handling the HTTP response 5754 responder privateLinkServiceListResultHandleResponse 5755 // callback for advancing to the next page 5756 advancer privateLinkServiceListResultAdvancePage 5757 // contains the current response 5758 current PrivateLinkServiceListResultResponse 5759 // status codes for successful retrieval 5760 statusCodes []int 5761 // any error encountered 5762 err error 5763} 5764 5765func (p *privateLinkServiceListResultPager) Err() error { 5766 return p.err 5767} 5768 5769func (p *privateLinkServiceListResultPager) NextPage(ctx context.Context) bool { 5770 var req *azcore.Request 5771 var err error 5772 if !reflect.ValueOf(p.current).IsZero() { 5773 if p.current.PrivateLinkServiceListResult.NextLink == nil || len(*p.current.PrivateLinkServiceListResult.NextLink) == 0 { 5774 return false 5775 } 5776 req, err = p.advancer(ctx, p.current) 5777 } else { 5778 req, err = p.requester(ctx) 5779 } 5780 if err != nil { 5781 p.err = err 5782 return false 5783 } 5784 resp, err := p.pipeline.Do(req) 5785 if err != nil { 5786 p.err = err 5787 return false 5788 } 5789 if !resp.HasStatusCode(p.statusCodes...) { 5790 p.err = p.errorer(resp) 5791 return false 5792 } 5793 result, err := p.responder(resp) 5794 if err != nil { 5795 p.err = err 5796 return false 5797 } 5798 p.current = result 5799 return true 5800} 5801 5802func (p *privateLinkServiceListResultPager) PageResponse() PrivateLinkServiceListResultResponse { 5803 return p.current 5804} 5805 5806// PublicIPAddressListResultPager provides iteration over PublicIPAddressListResult pages. 5807type PublicIPAddressListResultPager interface { 5808 azcore.Pager 5809 5810 // PageResponse returns the current PublicIPAddressListResultResponse. 5811 PageResponse() PublicIPAddressListResultResponse 5812} 5813 5814type publicIPAddressListResultCreateRequest func(context.Context) (*azcore.Request, error) 5815 5816type publicIPAddressListResultHandleError func(*azcore.Response) error 5817 5818type publicIPAddressListResultHandleResponse func(*azcore.Response) (PublicIPAddressListResultResponse, error) 5819 5820type publicIPAddressListResultAdvancePage func(context.Context, PublicIPAddressListResultResponse) (*azcore.Request, error) 5821 5822type publicIPAddressListResultPager struct { 5823 // the pipeline for making the request 5824 pipeline azcore.Pipeline 5825 // creates the initial request (non-LRO case) 5826 requester publicIPAddressListResultCreateRequest 5827 // callback for handling response errors 5828 errorer publicIPAddressListResultHandleError 5829 // callback for handling the HTTP response 5830 responder publicIPAddressListResultHandleResponse 5831 // callback for advancing to the next page 5832 advancer publicIPAddressListResultAdvancePage 5833 // contains the current response 5834 current PublicIPAddressListResultResponse 5835 // status codes for successful retrieval 5836 statusCodes []int 5837 // any error encountered 5838 err error 5839} 5840 5841func (p *publicIPAddressListResultPager) Err() error { 5842 return p.err 5843} 5844 5845func (p *publicIPAddressListResultPager) NextPage(ctx context.Context) bool { 5846 var req *azcore.Request 5847 var err error 5848 if !reflect.ValueOf(p.current).IsZero() { 5849 if p.current.PublicIPAddressListResult.NextLink == nil || len(*p.current.PublicIPAddressListResult.NextLink) == 0 { 5850 return false 5851 } 5852 req, err = p.advancer(ctx, p.current) 5853 } else { 5854 req, err = p.requester(ctx) 5855 } 5856 if err != nil { 5857 p.err = err 5858 return false 5859 } 5860 resp, err := p.pipeline.Do(req) 5861 if err != nil { 5862 p.err = err 5863 return false 5864 } 5865 if !resp.HasStatusCode(p.statusCodes...) { 5866 p.err = p.errorer(resp) 5867 return false 5868 } 5869 result, err := p.responder(resp) 5870 if err != nil { 5871 p.err = err 5872 return false 5873 } 5874 p.current = result 5875 return true 5876} 5877 5878func (p *publicIPAddressListResultPager) PageResponse() PublicIPAddressListResultResponse { 5879 return p.current 5880} 5881 5882// PublicIPPrefixListResultPager provides iteration over PublicIPPrefixListResult pages. 5883type PublicIPPrefixListResultPager interface { 5884 azcore.Pager 5885 5886 // PageResponse returns the current PublicIPPrefixListResultResponse. 5887 PageResponse() PublicIPPrefixListResultResponse 5888} 5889 5890type publicIPPrefixListResultCreateRequest func(context.Context) (*azcore.Request, error) 5891 5892type publicIPPrefixListResultHandleError func(*azcore.Response) error 5893 5894type publicIPPrefixListResultHandleResponse func(*azcore.Response) (PublicIPPrefixListResultResponse, error) 5895 5896type publicIPPrefixListResultAdvancePage func(context.Context, PublicIPPrefixListResultResponse) (*azcore.Request, error) 5897 5898type publicIPPrefixListResultPager struct { 5899 // the pipeline for making the request 5900 pipeline azcore.Pipeline 5901 // creates the initial request (non-LRO case) 5902 requester publicIPPrefixListResultCreateRequest 5903 // callback for handling response errors 5904 errorer publicIPPrefixListResultHandleError 5905 // callback for handling the HTTP response 5906 responder publicIPPrefixListResultHandleResponse 5907 // callback for advancing to the next page 5908 advancer publicIPPrefixListResultAdvancePage 5909 // contains the current response 5910 current PublicIPPrefixListResultResponse 5911 // status codes for successful retrieval 5912 statusCodes []int 5913 // any error encountered 5914 err error 5915} 5916 5917func (p *publicIPPrefixListResultPager) Err() error { 5918 return p.err 5919} 5920 5921func (p *publicIPPrefixListResultPager) NextPage(ctx context.Context) bool { 5922 var req *azcore.Request 5923 var err error 5924 if !reflect.ValueOf(p.current).IsZero() { 5925 if p.current.PublicIPPrefixListResult.NextLink == nil || len(*p.current.PublicIPPrefixListResult.NextLink) == 0 { 5926 return false 5927 } 5928 req, err = p.advancer(ctx, p.current) 5929 } else { 5930 req, err = p.requester(ctx) 5931 } 5932 if err != nil { 5933 p.err = err 5934 return false 5935 } 5936 resp, err := p.pipeline.Do(req) 5937 if err != nil { 5938 p.err = err 5939 return false 5940 } 5941 if !resp.HasStatusCode(p.statusCodes...) { 5942 p.err = p.errorer(resp) 5943 return false 5944 } 5945 result, err := p.responder(resp) 5946 if err != nil { 5947 p.err = err 5948 return false 5949 } 5950 p.current = result 5951 return true 5952} 5953 5954func (p *publicIPPrefixListResultPager) PageResponse() PublicIPPrefixListResultResponse { 5955 return p.current 5956} 5957 5958// RouteFilterListResultPager provides iteration over RouteFilterListResult pages. 5959type RouteFilterListResultPager interface { 5960 azcore.Pager 5961 5962 // PageResponse returns the current RouteFilterListResultResponse. 5963 PageResponse() RouteFilterListResultResponse 5964} 5965 5966type routeFilterListResultCreateRequest func(context.Context) (*azcore.Request, error) 5967 5968type routeFilterListResultHandleError func(*azcore.Response) error 5969 5970type routeFilterListResultHandleResponse func(*azcore.Response) (RouteFilterListResultResponse, error) 5971 5972type routeFilterListResultAdvancePage func(context.Context, RouteFilterListResultResponse) (*azcore.Request, error) 5973 5974type routeFilterListResultPager struct { 5975 // the pipeline for making the request 5976 pipeline azcore.Pipeline 5977 // creates the initial request (non-LRO case) 5978 requester routeFilterListResultCreateRequest 5979 // callback for handling response errors 5980 errorer routeFilterListResultHandleError 5981 // callback for handling the HTTP response 5982 responder routeFilterListResultHandleResponse 5983 // callback for advancing to the next page 5984 advancer routeFilterListResultAdvancePage 5985 // contains the current response 5986 current RouteFilterListResultResponse 5987 // status codes for successful retrieval 5988 statusCodes []int 5989 // any error encountered 5990 err error 5991} 5992 5993func (p *routeFilterListResultPager) Err() error { 5994 return p.err 5995} 5996 5997func (p *routeFilterListResultPager) NextPage(ctx context.Context) bool { 5998 var req *azcore.Request 5999 var err error 6000 if !reflect.ValueOf(p.current).IsZero() { 6001 if p.current.RouteFilterListResult.NextLink == nil || len(*p.current.RouteFilterListResult.NextLink) == 0 { 6002 return false 6003 } 6004 req, err = p.advancer(ctx, p.current) 6005 } else { 6006 req, err = p.requester(ctx) 6007 } 6008 if err != nil { 6009 p.err = err 6010 return false 6011 } 6012 resp, err := p.pipeline.Do(req) 6013 if err != nil { 6014 p.err = err 6015 return false 6016 } 6017 if !resp.HasStatusCode(p.statusCodes...) { 6018 p.err = p.errorer(resp) 6019 return false 6020 } 6021 result, err := p.responder(resp) 6022 if err != nil { 6023 p.err = err 6024 return false 6025 } 6026 p.current = result 6027 return true 6028} 6029 6030func (p *routeFilterListResultPager) PageResponse() RouteFilterListResultResponse { 6031 return p.current 6032} 6033 6034// RouteFilterRuleListResultPager provides iteration over RouteFilterRuleListResult pages. 6035type RouteFilterRuleListResultPager interface { 6036 azcore.Pager 6037 6038 // PageResponse returns the current RouteFilterRuleListResultResponse. 6039 PageResponse() RouteFilterRuleListResultResponse 6040} 6041 6042type routeFilterRuleListResultCreateRequest func(context.Context) (*azcore.Request, error) 6043 6044type routeFilterRuleListResultHandleError func(*azcore.Response) error 6045 6046type routeFilterRuleListResultHandleResponse func(*azcore.Response) (RouteFilterRuleListResultResponse, error) 6047 6048type routeFilterRuleListResultAdvancePage func(context.Context, RouteFilterRuleListResultResponse) (*azcore.Request, error) 6049 6050type routeFilterRuleListResultPager struct { 6051 // the pipeline for making the request 6052 pipeline azcore.Pipeline 6053 // creates the initial request (non-LRO case) 6054 requester routeFilterRuleListResultCreateRequest 6055 // callback for handling response errors 6056 errorer routeFilterRuleListResultHandleError 6057 // callback for handling the HTTP response 6058 responder routeFilterRuleListResultHandleResponse 6059 // callback for advancing to the next page 6060 advancer routeFilterRuleListResultAdvancePage 6061 // contains the current response 6062 current RouteFilterRuleListResultResponse 6063 // status codes for successful retrieval 6064 statusCodes []int 6065 // any error encountered 6066 err error 6067} 6068 6069func (p *routeFilterRuleListResultPager) Err() error { 6070 return p.err 6071} 6072 6073func (p *routeFilterRuleListResultPager) NextPage(ctx context.Context) bool { 6074 var req *azcore.Request 6075 var err error 6076 if !reflect.ValueOf(p.current).IsZero() { 6077 if p.current.RouteFilterRuleListResult.NextLink == nil || len(*p.current.RouteFilterRuleListResult.NextLink) == 0 { 6078 return false 6079 } 6080 req, err = p.advancer(ctx, p.current) 6081 } else { 6082 req, err = p.requester(ctx) 6083 } 6084 if err != nil { 6085 p.err = err 6086 return false 6087 } 6088 resp, err := p.pipeline.Do(req) 6089 if err != nil { 6090 p.err = err 6091 return false 6092 } 6093 if !resp.HasStatusCode(p.statusCodes...) { 6094 p.err = p.errorer(resp) 6095 return false 6096 } 6097 result, err := p.responder(resp) 6098 if err != nil { 6099 p.err = err 6100 return false 6101 } 6102 p.current = result 6103 return true 6104} 6105 6106func (p *routeFilterRuleListResultPager) PageResponse() RouteFilterRuleListResultResponse { 6107 return p.current 6108} 6109 6110// RouteListResultPager provides iteration over RouteListResult pages. 6111type RouteListResultPager interface { 6112 azcore.Pager 6113 6114 // PageResponse returns the current RouteListResultResponse. 6115 PageResponse() RouteListResultResponse 6116} 6117 6118type routeListResultCreateRequest func(context.Context) (*azcore.Request, error) 6119 6120type routeListResultHandleError func(*azcore.Response) error 6121 6122type routeListResultHandleResponse func(*azcore.Response) (RouteListResultResponse, error) 6123 6124type routeListResultAdvancePage func(context.Context, RouteListResultResponse) (*azcore.Request, error) 6125 6126type routeListResultPager struct { 6127 // the pipeline for making the request 6128 pipeline azcore.Pipeline 6129 // creates the initial request (non-LRO case) 6130 requester routeListResultCreateRequest 6131 // callback for handling response errors 6132 errorer routeListResultHandleError 6133 // callback for handling the HTTP response 6134 responder routeListResultHandleResponse 6135 // callback for advancing to the next page 6136 advancer routeListResultAdvancePage 6137 // contains the current response 6138 current RouteListResultResponse 6139 // status codes for successful retrieval 6140 statusCodes []int 6141 // any error encountered 6142 err error 6143} 6144 6145func (p *routeListResultPager) Err() error { 6146 return p.err 6147} 6148 6149func (p *routeListResultPager) NextPage(ctx context.Context) bool { 6150 var req *azcore.Request 6151 var err error 6152 if !reflect.ValueOf(p.current).IsZero() { 6153 if p.current.RouteListResult.NextLink == nil || len(*p.current.RouteListResult.NextLink) == 0 { 6154 return false 6155 } 6156 req, err = p.advancer(ctx, p.current) 6157 } else { 6158 req, err = p.requester(ctx) 6159 } 6160 if err != nil { 6161 p.err = err 6162 return false 6163 } 6164 resp, err := p.pipeline.Do(req) 6165 if err != nil { 6166 p.err = err 6167 return false 6168 } 6169 if !resp.HasStatusCode(p.statusCodes...) { 6170 p.err = p.errorer(resp) 6171 return false 6172 } 6173 result, err := p.responder(resp) 6174 if err != nil { 6175 p.err = err 6176 return false 6177 } 6178 p.current = result 6179 return true 6180} 6181 6182func (p *routeListResultPager) PageResponse() RouteListResultResponse { 6183 return p.current 6184} 6185 6186// RouteTableListResultPager provides iteration over RouteTableListResult pages. 6187type RouteTableListResultPager interface { 6188 azcore.Pager 6189 6190 // PageResponse returns the current RouteTableListResultResponse. 6191 PageResponse() RouteTableListResultResponse 6192} 6193 6194type routeTableListResultCreateRequest func(context.Context) (*azcore.Request, error) 6195 6196type routeTableListResultHandleError func(*azcore.Response) error 6197 6198type routeTableListResultHandleResponse func(*azcore.Response) (RouteTableListResultResponse, error) 6199 6200type routeTableListResultAdvancePage func(context.Context, RouteTableListResultResponse) (*azcore.Request, error) 6201 6202type routeTableListResultPager struct { 6203 // the pipeline for making the request 6204 pipeline azcore.Pipeline 6205 // creates the initial request (non-LRO case) 6206 requester routeTableListResultCreateRequest 6207 // callback for handling response errors 6208 errorer routeTableListResultHandleError 6209 // callback for handling the HTTP response 6210 responder routeTableListResultHandleResponse 6211 // callback for advancing to the next page 6212 advancer routeTableListResultAdvancePage 6213 // contains the current response 6214 current RouteTableListResultResponse 6215 // status codes for successful retrieval 6216 statusCodes []int 6217 // any error encountered 6218 err error 6219} 6220 6221func (p *routeTableListResultPager) Err() error { 6222 return p.err 6223} 6224 6225func (p *routeTableListResultPager) NextPage(ctx context.Context) bool { 6226 var req *azcore.Request 6227 var err error 6228 if !reflect.ValueOf(p.current).IsZero() { 6229 if p.current.RouteTableListResult.NextLink == nil || len(*p.current.RouteTableListResult.NextLink) == 0 { 6230 return false 6231 } 6232 req, err = p.advancer(ctx, p.current) 6233 } else { 6234 req, err = p.requester(ctx) 6235 } 6236 if err != nil { 6237 p.err = err 6238 return false 6239 } 6240 resp, err := p.pipeline.Do(req) 6241 if err != nil { 6242 p.err = err 6243 return false 6244 } 6245 if !resp.HasStatusCode(p.statusCodes...) { 6246 p.err = p.errorer(resp) 6247 return false 6248 } 6249 result, err := p.responder(resp) 6250 if err != nil { 6251 p.err = err 6252 return false 6253 } 6254 p.current = result 6255 return true 6256} 6257 6258func (p *routeTableListResultPager) PageResponse() RouteTableListResultResponse { 6259 return p.current 6260} 6261 6262// SecurityPartnerProviderListResultPager provides iteration over SecurityPartnerProviderListResult pages. 6263type SecurityPartnerProviderListResultPager interface { 6264 azcore.Pager 6265 6266 // PageResponse returns the current SecurityPartnerProviderListResultResponse. 6267 PageResponse() SecurityPartnerProviderListResultResponse 6268} 6269 6270type securityPartnerProviderListResultCreateRequest func(context.Context) (*azcore.Request, error) 6271 6272type securityPartnerProviderListResultHandleError func(*azcore.Response) error 6273 6274type securityPartnerProviderListResultHandleResponse func(*azcore.Response) (SecurityPartnerProviderListResultResponse, error) 6275 6276type securityPartnerProviderListResultAdvancePage func(context.Context, SecurityPartnerProviderListResultResponse) (*azcore.Request, error) 6277 6278type securityPartnerProviderListResultPager struct { 6279 // the pipeline for making the request 6280 pipeline azcore.Pipeline 6281 // creates the initial request (non-LRO case) 6282 requester securityPartnerProviderListResultCreateRequest 6283 // callback for handling response errors 6284 errorer securityPartnerProviderListResultHandleError 6285 // callback for handling the HTTP response 6286 responder securityPartnerProviderListResultHandleResponse 6287 // callback for advancing to the next page 6288 advancer securityPartnerProviderListResultAdvancePage 6289 // contains the current response 6290 current SecurityPartnerProviderListResultResponse 6291 // status codes for successful retrieval 6292 statusCodes []int 6293 // any error encountered 6294 err error 6295} 6296 6297func (p *securityPartnerProviderListResultPager) Err() error { 6298 return p.err 6299} 6300 6301func (p *securityPartnerProviderListResultPager) NextPage(ctx context.Context) bool { 6302 var req *azcore.Request 6303 var err error 6304 if !reflect.ValueOf(p.current).IsZero() { 6305 if p.current.SecurityPartnerProviderListResult.NextLink == nil || len(*p.current.SecurityPartnerProviderListResult.NextLink) == 0 { 6306 return false 6307 } 6308 req, err = p.advancer(ctx, p.current) 6309 } else { 6310 req, err = p.requester(ctx) 6311 } 6312 if err != nil { 6313 p.err = err 6314 return false 6315 } 6316 resp, err := p.pipeline.Do(req) 6317 if err != nil { 6318 p.err = err 6319 return false 6320 } 6321 if !resp.HasStatusCode(p.statusCodes...) { 6322 p.err = p.errorer(resp) 6323 return false 6324 } 6325 result, err := p.responder(resp) 6326 if err != nil { 6327 p.err = err 6328 return false 6329 } 6330 p.current = result 6331 return true 6332} 6333 6334func (p *securityPartnerProviderListResultPager) PageResponse() SecurityPartnerProviderListResultResponse { 6335 return p.current 6336} 6337 6338// SecurityRuleListResultPager provides iteration over SecurityRuleListResult pages. 6339type SecurityRuleListResultPager interface { 6340 azcore.Pager 6341 6342 // PageResponse returns the current SecurityRuleListResultResponse. 6343 PageResponse() SecurityRuleListResultResponse 6344} 6345 6346type securityRuleListResultCreateRequest func(context.Context) (*azcore.Request, error) 6347 6348type securityRuleListResultHandleError func(*azcore.Response) error 6349 6350type securityRuleListResultHandleResponse func(*azcore.Response) (SecurityRuleListResultResponse, error) 6351 6352type securityRuleListResultAdvancePage func(context.Context, SecurityRuleListResultResponse) (*azcore.Request, error) 6353 6354type securityRuleListResultPager struct { 6355 // the pipeline for making the request 6356 pipeline azcore.Pipeline 6357 // creates the initial request (non-LRO case) 6358 requester securityRuleListResultCreateRequest 6359 // callback for handling response errors 6360 errorer securityRuleListResultHandleError 6361 // callback for handling the HTTP response 6362 responder securityRuleListResultHandleResponse 6363 // callback for advancing to the next page 6364 advancer securityRuleListResultAdvancePage 6365 // contains the current response 6366 current SecurityRuleListResultResponse 6367 // status codes for successful retrieval 6368 statusCodes []int 6369 // any error encountered 6370 err error 6371} 6372 6373func (p *securityRuleListResultPager) Err() error { 6374 return p.err 6375} 6376 6377func (p *securityRuleListResultPager) NextPage(ctx context.Context) bool { 6378 var req *azcore.Request 6379 var err error 6380 if !reflect.ValueOf(p.current).IsZero() { 6381 if p.current.SecurityRuleListResult.NextLink == nil || len(*p.current.SecurityRuleListResult.NextLink) == 0 { 6382 return false 6383 } 6384 req, err = p.advancer(ctx, p.current) 6385 } else { 6386 req, err = p.requester(ctx) 6387 } 6388 if err != nil { 6389 p.err = err 6390 return false 6391 } 6392 resp, err := p.pipeline.Do(req) 6393 if err != nil { 6394 p.err = err 6395 return false 6396 } 6397 if !resp.HasStatusCode(p.statusCodes...) { 6398 p.err = p.errorer(resp) 6399 return false 6400 } 6401 result, err := p.responder(resp) 6402 if err != nil { 6403 p.err = err 6404 return false 6405 } 6406 p.current = result 6407 return true 6408} 6409 6410func (p *securityRuleListResultPager) PageResponse() SecurityRuleListResultResponse { 6411 return p.current 6412} 6413 6414// ServiceEndpointPolicyDefinitionListResultPager provides iteration over ServiceEndpointPolicyDefinitionListResult pages. 6415type ServiceEndpointPolicyDefinitionListResultPager interface { 6416 azcore.Pager 6417 6418 // PageResponse returns the current ServiceEndpointPolicyDefinitionListResultResponse. 6419 PageResponse() ServiceEndpointPolicyDefinitionListResultResponse 6420} 6421 6422type serviceEndpointPolicyDefinitionListResultCreateRequest func(context.Context) (*azcore.Request, error) 6423 6424type serviceEndpointPolicyDefinitionListResultHandleError func(*azcore.Response) error 6425 6426type serviceEndpointPolicyDefinitionListResultHandleResponse func(*azcore.Response) (ServiceEndpointPolicyDefinitionListResultResponse, error) 6427 6428type serviceEndpointPolicyDefinitionListResultAdvancePage func(context.Context, ServiceEndpointPolicyDefinitionListResultResponse) (*azcore.Request, error) 6429 6430type serviceEndpointPolicyDefinitionListResultPager struct { 6431 // the pipeline for making the request 6432 pipeline azcore.Pipeline 6433 // creates the initial request (non-LRO case) 6434 requester serviceEndpointPolicyDefinitionListResultCreateRequest 6435 // callback for handling response errors 6436 errorer serviceEndpointPolicyDefinitionListResultHandleError 6437 // callback for handling the HTTP response 6438 responder serviceEndpointPolicyDefinitionListResultHandleResponse 6439 // callback for advancing to the next page 6440 advancer serviceEndpointPolicyDefinitionListResultAdvancePage 6441 // contains the current response 6442 current ServiceEndpointPolicyDefinitionListResultResponse 6443 // status codes for successful retrieval 6444 statusCodes []int 6445 // any error encountered 6446 err error 6447} 6448 6449func (p *serviceEndpointPolicyDefinitionListResultPager) Err() error { 6450 return p.err 6451} 6452 6453func (p *serviceEndpointPolicyDefinitionListResultPager) NextPage(ctx context.Context) bool { 6454 var req *azcore.Request 6455 var err error 6456 if !reflect.ValueOf(p.current).IsZero() { 6457 if p.current.ServiceEndpointPolicyDefinitionListResult.NextLink == nil || len(*p.current.ServiceEndpointPolicyDefinitionListResult.NextLink) == 0 { 6458 return false 6459 } 6460 req, err = p.advancer(ctx, p.current) 6461 } else { 6462 req, err = p.requester(ctx) 6463 } 6464 if err != nil { 6465 p.err = err 6466 return false 6467 } 6468 resp, err := p.pipeline.Do(req) 6469 if err != nil { 6470 p.err = err 6471 return false 6472 } 6473 if !resp.HasStatusCode(p.statusCodes...) { 6474 p.err = p.errorer(resp) 6475 return false 6476 } 6477 result, err := p.responder(resp) 6478 if err != nil { 6479 p.err = err 6480 return false 6481 } 6482 p.current = result 6483 return true 6484} 6485 6486func (p *serviceEndpointPolicyDefinitionListResultPager) PageResponse() ServiceEndpointPolicyDefinitionListResultResponse { 6487 return p.current 6488} 6489 6490// ServiceEndpointPolicyListResultPager provides iteration over ServiceEndpointPolicyListResult pages. 6491type ServiceEndpointPolicyListResultPager interface { 6492 azcore.Pager 6493 6494 // PageResponse returns the current ServiceEndpointPolicyListResultResponse. 6495 PageResponse() ServiceEndpointPolicyListResultResponse 6496} 6497 6498type serviceEndpointPolicyListResultCreateRequest func(context.Context) (*azcore.Request, error) 6499 6500type serviceEndpointPolicyListResultHandleError func(*azcore.Response) error 6501 6502type serviceEndpointPolicyListResultHandleResponse func(*azcore.Response) (ServiceEndpointPolicyListResultResponse, error) 6503 6504type serviceEndpointPolicyListResultAdvancePage func(context.Context, ServiceEndpointPolicyListResultResponse) (*azcore.Request, error) 6505 6506type serviceEndpointPolicyListResultPager struct { 6507 // the pipeline for making the request 6508 pipeline azcore.Pipeline 6509 // creates the initial request (non-LRO case) 6510 requester serviceEndpointPolicyListResultCreateRequest 6511 // callback for handling response errors 6512 errorer serviceEndpointPolicyListResultHandleError 6513 // callback for handling the HTTP response 6514 responder serviceEndpointPolicyListResultHandleResponse 6515 // callback for advancing to the next page 6516 advancer serviceEndpointPolicyListResultAdvancePage 6517 // contains the current response 6518 current ServiceEndpointPolicyListResultResponse 6519 // status codes for successful retrieval 6520 statusCodes []int 6521 // any error encountered 6522 err error 6523} 6524 6525func (p *serviceEndpointPolicyListResultPager) Err() error { 6526 return p.err 6527} 6528 6529func (p *serviceEndpointPolicyListResultPager) NextPage(ctx context.Context) bool { 6530 var req *azcore.Request 6531 var err error 6532 if !reflect.ValueOf(p.current).IsZero() { 6533 if p.current.ServiceEndpointPolicyListResult.NextLink == nil || len(*p.current.ServiceEndpointPolicyListResult.NextLink) == 0 { 6534 return false 6535 } 6536 req, err = p.advancer(ctx, p.current) 6537 } else { 6538 req, err = p.requester(ctx) 6539 } 6540 if err != nil { 6541 p.err = err 6542 return false 6543 } 6544 resp, err := p.pipeline.Do(req) 6545 if err != nil { 6546 p.err = err 6547 return false 6548 } 6549 if !resp.HasStatusCode(p.statusCodes...) { 6550 p.err = p.errorer(resp) 6551 return false 6552 } 6553 result, err := p.responder(resp) 6554 if err != nil { 6555 p.err = err 6556 return false 6557 } 6558 p.current = result 6559 return true 6560} 6561 6562func (p *serviceEndpointPolicyListResultPager) PageResponse() ServiceEndpointPolicyListResultResponse { 6563 return p.current 6564} 6565 6566// SubnetListResultPager provides iteration over SubnetListResult pages. 6567type SubnetListResultPager interface { 6568 azcore.Pager 6569 6570 // PageResponse returns the current SubnetListResultResponse. 6571 PageResponse() SubnetListResultResponse 6572} 6573 6574type subnetListResultCreateRequest func(context.Context) (*azcore.Request, error) 6575 6576type subnetListResultHandleError func(*azcore.Response) error 6577 6578type subnetListResultHandleResponse func(*azcore.Response) (SubnetListResultResponse, error) 6579 6580type subnetListResultAdvancePage func(context.Context, SubnetListResultResponse) (*azcore.Request, error) 6581 6582type subnetListResultPager struct { 6583 // the pipeline for making the request 6584 pipeline azcore.Pipeline 6585 // creates the initial request (non-LRO case) 6586 requester subnetListResultCreateRequest 6587 // callback for handling response errors 6588 errorer subnetListResultHandleError 6589 // callback for handling the HTTP response 6590 responder subnetListResultHandleResponse 6591 // callback for advancing to the next page 6592 advancer subnetListResultAdvancePage 6593 // contains the current response 6594 current SubnetListResultResponse 6595 // status codes for successful retrieval 6596 statusCodes []int 6597 // any error encountered 6598 err error 6599} 6600 6601func (p *subnetListResultPager) Err() error { 6602 return p.err 6603} 6604 6605func (p *subnetListResultPager) NextPage(ctx context.Context) bool { 6606 var req *azcore.Request 6607 var err error 6608 if !reflect.ValueOf(p.current).IsZero() { 6609 if p.current.SubnetListResult.NextLink == nil || len(*p.current.SubnetListResult.NextLink) == 0 { 6610 return false 6611 } 6612 req, err = p.advancer(ctx, p.current) 6613 } else { 6614 req, err = p.requester(ctx) 6615 } 6616 if err != nil { 6617 p.err = err 6618 return false 6619 } 6620 resp, err := p.pipeline.Do(req) 6621 if err != nil { 6622 p.err = err 6623 return false 6624 } 6625 if !resp.HasStatusCode(p.statusCodes...) { 6626 p.err = p.errorer(resp) 6627 return false 6628 } 6629 result, err := p.responder(resp) 6630 if err != nil { 6631 p.err = err 6632 return false 6633 } 6634 p.current = result 6635 return true 6636} 6637 6638func (p *subnetListResultPager) PageResponse() SubnetListResultResponse { 6639 return p.current 6640} 6641 6642// UsagesListResultPager provides iteration over UsagesListResult pages. 6643type UsagesListResultPager interface { 6644 azcore.Pager 6645 6646 // PageResponse returns the current UsagesListResultResponse. 6647 PageResponse() UsagesListResultResponse 6648} 6649 6650type usagesListResultCreateRequest func(context.Context) (*azcore.Request, error) 6651 6652type usagesListResultHandleError func(*azcore.Response) error 6653 6654type usagesListResultHandleResponse func(*azcore.Response) (UsagesListResultResponse, error) 6655 6656type usagesListResultAdvancePage func(context.Context, UsagesListResultResponse) (*azcore.Request, error) 6657 6658type usagesListResultPager struct { 6659 // the pipeline for making the request 6660 pipeline azcore.Pipeline 6661 // creates the initial request (non-LRO case) 6662 requester usagesListResultCreateRequest 6663 // callback for handling response errors 6664 errorer usagesListResultHandleError 6665 // callback for handling the HTTP response 6666 responder usagesListResultHandleResponse 6667 // callback for advancing to the next page 6668 advancer usagesListResultAdvancePage 6669 // contains the current response 6670 current UsagesListResultResponse 6671 // status codes for successful retrieval 6672 statusCodes []int 6673 // any error encountered 6674 err error 6675} 6676 6677func (p *usagesListResultPager) Err() error { 6678 return p.err 6679} 6680 6681func (p *usagesListResultPager) NextPage(ctx context.Context) bool { 6682 var req *azcore.Request 6683 var err error 6684 if !reflect.ValueOf(p.current).IsZero() { 6685 if p.current.UsagesListResult.NextLink == nil || len(*p.current.UsagesListResult.NextLink) == 0 { 6686 return false 6687 } 6688 req, err = p.advancer(ctx, p.current) 6689 } else { 6690 req, err = p.requester(ctx) 6691 } 6692 if err != nil { 6693 p.err = err 6694 return false 6695 } 6696 resp, err := p.pipeline.Do(req) 6697 if err != nil { 6698 p.err = err 6699 return false 6700 } 6701 if !resp.HasStatusCode(p.statusCodes...) { 6702 p.err = p.errorer(resp) 6703 return false 6704 } 6705 result, err := p.responder(resp) 6706 if err != nil { 6707 p.err = err 6708 return false 6709 } 6710 p.current = result 6711 return true 6712} 6713 6714func (p *usagesListResultPager) PageResponse() UsagesListResultResponse { 6715 return p.current 6716} 6717 6718// VirtualNetworkGatewayConnectionListResultPager provides iteration over VirtualNetworkGatewayConnectionListResult pages. 6719type VirtualNetworkGatewayConnectionListResultPager interface { 6720 azcore.Pager 6721 6722 // PageResponse returns the current VirtualNetworkGatewayConnectionListResultResponse. 6723 PageResponse() VirtualNetworkGatewayConnectionListResultResponse 6724} 6725 6726type virtualNetworkGatewayConnectionListResultCreateRequest func(context.Context) (*azcore.Request, error) 6727 6728type virtualNetworkGatewayConnectionListResultHandleError func(*azcore.Response) error 6729 6730type virtualNetworkGatewayConnectionListResultHandleResponse func(*azcore.Response) (VirtualNetworkGatewayConnectionListResultResponse, error) 6731 6732type virtualNetworkGatewayConnectionListResultAdvancePage func(context.Context, VirtualNetworkGatewayConnectionListResultResponse) (*azcore.Request, error) 6733 6734type virtualNetworkGatewayConnectionListResultPager struct { 6735 // the pipeline for making the request 6736 pipeline azcore.Pipeline 6737 // creates the initial request (non-LRO case) 6738 requester virtualNetworkGatewayConnectionListResultCreateRequest 6739 // callback for handling response errors 6740 errorer virtualNetworkGatewayConnectionListResultHandleError 6741 // callback for handling the HTTP response 6742 responder virtualNetworkGatewayConnectionListResultHandleResponse 6743 // callback for advancing to the next page 6744 advancer virtualNetworkGatewayConnectionListResultAdvancePage 6745 // contains the current response 6746 current VirtualNetworkGatewayConnectionListResultResponse 6747 // status codes for successful retrieval 6748 statusCodes []int 6749 // any error encountered 6750 err error 6751} 6752 6753func (p *virtualNetworkGatewayConnectionListResultPager) Err() error { 6754 return p.err 6755} 6756 6757func (p *virtualNetworkGatewayConnectionListResultPager) NextPage(ctx context.Context) bool { 6758 var req *azcore.Request 6759 var err error 6760 if !reflect.ValueOf(p.current).IsZero() { 6761 if p.current.VirtualNetworkGatewayConnectionListResult.NextLink == nil || len(*p.current.VirtualNetworkGatewayConnectionListResult.NextLink) == 0 { 6762 return false 6763 } 6764 req, err = p.advancer(ctx, p.current) 6765 } else { 6766 req, err = p.requester(ctx) 6767 } 6768 if err != nil { 6769 p.err = err 6770 return false 6771 } 6772 resp, err := p.pipeline.Do(req) 6773 if err != nil { 6774 p.err = err 6775 return false 6776 } 6777 if !resp.HasStatusCode(p.statusCodes...) { 6778 p.err = p.errorer(resp) 6779 return false 6780 } 6781 result, err := p.responder(resp) 6782 if err != nil { 6783 p.err = err 6784 return false 6785 } 6786 p.current = result 6787 return true 6788} 6789 6790func (p *virtualNetworkGatewayConnectionListResultPager) PageResponse() VirtualNetworkGatewayConnectionListResultResponse { 6791 return p.current 6792} 6793 6794// VirtualNetworkGatewayListConnectionsResultPager provides iteration over VirtualNetworkGatewayListConnectionsResult pages. 6795type VirtualNetworkGatewayListConnectionsResultPager interface { 6796 azcore.Pager 6797 6798 // PageResponse returns the current VirtualNetworkGatewayListConnectionsResultResponse. 6799 PageResponse() VirtualNetworkGatewayListConnectionsResultResponse 6800} 6801 6802type virtualNetworkGatewayListConnectionsResultCreateRequest func(context.Context) (*azcore.Request, error) 6803 6804type virtualNetworkGatewayListConnectionsResultHandleError func(*azcore.Response) error 6805 6806type virtualNetworkGatewayListConnectionsResultHandleResponse func(*azcore.Response) (VirtualNetworkGatewayListConnectionsResultResponse, error) 6807 6808type virtualNetworkGatewayListConnectionsResultAdvancePage func(context.Context, VirtualNetworkGatewayListConnectionsResultResponse) (*azcore.Request, error) 6809 6810type virtualNetworkGatewayListConnectionsResultPager struct { 6811 // the pipeline for making the request 6812 pipeline azcore.Pipeline 6813 // creates the initial request (non-LRO case) 6814 requester virtualNetworkGatewayListConnectionsResultCreateRequest 6815 // callback for handling response errors 6816 errorer virtualNetworkGatewayListConnectionsResultHandleError 6817 // callback for handling the HTTP response 6818 responder virtualNetworkGatewayListConnectionsResultHandleResponse 6819 // callback for advancing to the next page 6820 advancer virtualNetworkGatewayListConnectionsResultAdvancePage 6821 // contains the current response 6822 current VirtualNetworkGatewayListConnectionsResultResponse 6823 // status codes for successful retrieval 6824 statusCodes []int 6825 // any error encountered 6826 err error 6827} 6828 6829func (p *virtualNetworkGatewayListConnectionsResultPager) Err() error { 6830 return p.err 6831} 6832 6833func (p *virtualNetworkGatewayListConnectionsResultPager) NextPage(ctx context.Context) bool { 6834 var req *azcore.Request 6835 var err error 6836 if !reflect.ValueOf(p.current).IsZero() { 6837 if p.current.VirtualNetworkGatewayListConnectionsResult.NextLink == nil || len(*p.current.VirtualNetworkGatewayListConnectionsResult.NextLink) == 0 { 6838 return false 6839 } 6840 req, err = p.advancer(ctx, p.current) 6841 } else { 6842 req, err = p.requester(ctx) 6843 } 6844 if err != nil { 6845 p.err = err 6846 return false 6847 } 6848 resp, err := p.pipeline.Do(req) 6849 if err != nil { 6850 p.err = err 6851 return false 6852 } 6853 if !resp.HasStatusCode(p.statusCodes...) { 6854 p.err = p.errorer(resp) 6855 return false 6856 } 6857 result, err := p.responder(resp) 6858 if err != nil { 6859 p.err = err 6860 return false 6861 } 6862 p.current = result 6863 return true 6864} 6865 6866func (p *virtualNetworkGatewayListConnectionsResultPager) PageResponse() VirtualNetworkGatewayListConnectionsResultResponse { 6867 return p.current 6868} 6869 6870// VirtualNetworkGatewayListResultPager provides iteration over VirtualNetworkGatewayListResult pages. 6871type VirtualNetworkGatewayListResultPager interface { 6872 azcore.Pager 6873 6874 // PageResponse returns the current VirtualNetworkGatewayListResultResponse. 6875 PageResponse() VirtualNetworkGatewayListResultResponse 6876} 6877 6878type virtualNetworkGatewayListResultCreateRequest func(context.Context) (*azcore.Request, error) 6879 6880type virtualNetworkGatewayListResultHandleError func(*azcore.Response) error 6881 6882type virtualNetworkGatewayListResultHandleResponse func(*azcore.Response) (VirtualNetworkGatewayListResultResponse, error) 6883 6884type virtualNetworkGatewayListResultAdvancePage func(context.Context, VirtualNetworkGatewayListResultResponse) (*azcore.Request, error) 6885 6886type virtualNetworkGatewayListResultPager struct { 6887 // the pipeline for making the request 6888 pipeline azcore.Pipeline 6889 // creates the initial request (non-LRO case) 6890 requester virtualNetworkGatewayListResultCreateRequest 6891 // callback for handling response errors 6892 errorer virtualNetworkGatewayListResultHandleError 6893 // callback for handling the HTTP response 6894 responder virtualNetworkGatewayListResultHandleResponse 6895 // callback for advancing to the next page 6896 advancer virtualNetworkGatewayListResultAdvancePage 6897 // contains the current response 6898 current VirtualNetworkGatewayListResultResponse 6899 // status codes for successful retrieval 6900 statusCodes []int 6901 // any error encountered 6902 err error 6903} 6904 6905func (p *virtualNetworkGatewayListResultPager) Err() error { 6906 return p.err 6907} 6908 6909func (p *virtualNetworkGatewayListResultPager) NextPage(ctx context.Context) bool { 6910 var req *azcore.Request 6911 var err error 6912 if !reflect.ValueOf(p.current).IsZero() { 6913 if p.current.VirtualNetworkGatewayListResult.NextLink == nil || len(*p.current.VirtualNetworkGatewayListResult.NextLink) == 0 { 6914 return false 6915 } 6916 req, err = p.advancer(ctx, p.current) 6917 } else { 6918 req, err = p.requester(ctx) 6919 } 6920 if err != nil { 6921 p.err = err 6922 return false 6923 } 6924 resp, err := p.pipeline.Do(req) 6925 if err != nil { 6926 p.err = err 6927 return false 6928 } 6929 if !resp.HasStatusCode(p.statusCodes...) { 6930 p.err = p.errorer(resp) 6931 return false 6932 } 6933 result, err := p.responder(resp) 6934 if err != nil { 6935 p.err = err 6936 return false 6937 } 6938 p.current = result 6939 return true 6940} 6941 6942func (p *virtualNetworkGatewayListResultPager) PageResponse() VirtualNetworkGatewayListResultResponse { 6943 return p.current 6944} 6945 6946// VirtualNetworkListResultPager provides iteration over VirtualNetworkListResult pages. 6947type VirtualNetworkListResultPager interface { 6948 azcore.Pager 6949 6950 // PageResponse returns the current VirtualNetworkListResultResponse. 6951 PageResponse() VirtualNetworkListResultResponse 6952} 6953 6954type virtualNetworkListResultCreateRequest func(context.Context) (*azcore.Request, error) 6955 6956type virtualNetworkListResultHandleError func(*azcore.Response) error 6957 6958type virtualNetworkListResultHandleResponse func(*azcore.Response) (VirtualNetworkListResultResponse, error) 6959 6960type virtualNetworkListResultAdvancePage func(context.Context, VirtualNetworkListResultResponse) (*azcore.Request, error) 6961 6962type virtualNetworkListResultPager struct { 6963 // the pipeline for making the request 6964 pipeline azcore.Pipeline 6965 // creates the initial request (non-LRO case) 6966 requester virtualNetworkListResultCreateRequest 6967 // callback for handling response errors 6968 errorer virtualNetworkListResultHandleError 6969 // callback for handling the HTTP response 6970 responder virtualNetworkListResultHandleResponse 6971 // callback for advancing to the next page 6972 advancer virtualNetworkListResultAdvancePage 6973 // contains the current response 6974 current VirtualNetworkListResultResponse 6975 // status codes for successful retrieval 6976 statusCodes []int 6977 // any error encountered 6978 err error 6979} 6980 6981func (p *virtualNetworkListResultPager) Err() error { 6982 return p.err 6983} 6984 6985func (p *virtualNetworkListResultPager) NextPage(ctx context.Context) bool { 6986 var req *azcore.Request 6987 var err error 6988 if !reflect.ValueOf(p.current).IsZero() { 6989 if p.current.VirtualNetworkListResult.NextLink == nil || len(*p.current.VirtualNetworkListResult.NextLink) == 0 { 6990 return false 6991 } 6992 req, err = p.advancer(ctx, p.current) 6993 } else { 6994 req, err = p.requester(ctx) 6995 } 6996 if err != nil { 6997 p.err = err 6998 return false 6999 } 7000 resp, err := p.pipeline.Do(req) 7001 if err != nil { 7002 p.err = err 7003 return false 7004 } 7005 if !resp.HasStatusCode(p.statusCodes...) { 7006 p.err = p.errorer(resp) 7007 return false 7008 } 7009 result, err := p.responder(resp) 7010 if err != nil { 7011 p.err = err 7012 return false 7013 } 7014 p.current = result 7015 return true 7016} 7017 7018func (p *virtualNetworkListResultPager) PageResponse() VirtualNetworkListResultResponse { 7019 return p.current 7020} 7021 7022// VirtualNetworkListUsageResultPager provides iteration over VirtualNetworkListUsageResult pages. 7023type VirtualNetworkListUsageResultPager interface { 7024 azcore.Pager 7025 7026 // PageResponse returns the current VirtualNetworkListUsageResultResponse. 7027 PageResponse() VirtualNetworkListUsageResultResponse 7028} 7029 7030type virtualNetworkListUsageResultCreateRequest func(context.Context) (*azcore.Request, error) 7031 7032type virtualNetworkListUsageResultHandleError func(*azcore.Response) error 7033 7034type virtualNetworkListUsageResultHandleResponse func(*azcore.Response) (VirtualNetworkListUsageResultResponse, error) 7035 7036type virtualNetworkListUsageResultAdvancePage func(context.Context, VirtualNetworkListUsageResultResponse) (*azcore.Request, error) 7037 7038type virtualNetworkListUsageResultPager struct { 7039 // the pipeline for making the request 7040 pipeline azcore.Pipeline 7041 // creates the initial request (non-LRO case) 7042 requester virtualNetworkListUsageResultCreateRequest 7043 // callback for handling response errors 7044 errorer virtualNetworkListUsageResultHandleError 7045 // callback for handling the HTTP response 7046 responder virtualNetworkListUsageResultHandleResponse 7047 // callback for advancing to the next page 7048 advancer virtualNetworkListUsageResultAdvancePage 7049 // contains the current response 7050 current VirtualNetworkListUsageResultResponse 7051 // status codes for successful retrieval 7052 statusCodes []int 7053 // any error encountered 7054 err error 7055} 7056 7057func (p *virtualNetworkListUsageResultPager) Err() error { 7058 return p.err 7059} 7060 7061func (p *virtualNetworkListUsageResultPager) NextPage(ctx context.Context) bool { 7062 var req *azcore.Request 7063 var err error 7064 if !reflect.ValueOf(p.current).IsZero() { 7065 if p.current.VirtualNetworkListUsageResult.NextLink == nil || len(*p.current.VirtualNetworkListUsageResult.NextLink) == 0 { 7066 return false 7067 } 7068 req, err = p.advancer(ctx, p.current) 7069 } else { 7070 req, err = p.requester(ctx) 7071 } 7072 if err != nil { 7073 p.err = err 7074 return false 7075 } 7076 resp, err := p.pipeline.Do(req) 7077 if err != nil { 7078 p.err = err 7079 return false 7080 } 7081 if !resp.HasStatusCode(p.statusCodes...) { 7082 p.err = p.errorer(resp) 7083 return false 7084 } 7085 result, err := p.responder(resp) 7086 if err != nil { 7087 p.err = err 7088 return false 7089 } 7090 p.current = result 7091 return true 7092} 7093 7094func (p *virtualNetworkListUsageResultPager) PageResponse() VirtualNetworkListUsageResultResponse { 7095 return p.current 7096} 7097 7098// VirtualNetworkPeeringListResultPager provides iteration over VirtualNetworkPeeringListResult pages. 7099type VirtualNetworkPeeringListResultPager interface { 7100 azcore.Pager 7101 7102 // PageResponse returns the current VirtualNetworkPeeringListResultResponse. 7103 PageResponse() VirtualNetworkPeeringListResultResponse 7104} 7105 7106type virtualNetworkPeeringListResultCreateRequest func(context.Context) (*azcore.Request, error) 7107 7108type virtualNetworkPeeringListResultHandleError func(*azcore.Response) error 7109 7110type virtualNetworkPeeringListResultHandleResponse func(*azcore.Response) (VirtualNetworkPeeringListResultResponse, error) 7111 7112type virtualNetworkPeeringListResultAdvancePage func(context.Context, VirtualNetworkPeeringListResultResponse) (*azcore.Request, error) 7113 7114type virtualNetworkPeeringListResultPager struct { 7115 // the pipeline for making the request 7116 pipeline azcore.Pipeline 7117 // creates the initial request (non-LRO case) 7118 requester virtualNetworkPeeringListResultCreateRequest 7119 // callback for handling response errors 7120 errorer virtualNetworkPeeringListResultHandleError 7121 // callback for handling the HTTP response 7122 responder virtualNetworkPeeringListResultHandleResponse 7123 // callback for advancing to the next page 7124 advancer virtualNetworkPeeringListResultAdvancePage 7125 // contains the current response 7126 current VirtualNetworkPeeringListResultResponse 7127 // status codes for successful retrieval 7128 statusCodes []int 7129 // any error encountered 7130 err error 7131} 7132 7133func (p *virtualNetworkPeeringListResultPager) Err() error { 7134 return p.err 7135} 7136 7137func (p *virtualNetworkPeeringListResultPager) NextPage(ctx context.Context) bool { 7138 var req *azcore.Request 7139 var err error 7140 if !reflect.ValueOf(p.current).IsZero() { 7141 if p.current.VirtualNetworkPeeringListResult.NextLink == nil || len(*p.current.VirtualNetworkPeeringListResult.NextLink) == 0 { 7142 return false 7143 } 7144 req, err = p.advancer(ctx, p.current) 7145 } else { 7146 req, err = p.requester(ctx) 7147 } 7148 if err != nil { 7149 p.err = err 7150 return false 7151 } 7152 resp, err := p.pipeline.Do(req) 7153 if err != nil { 7154 p.err = err 7155 return false 7156 } 7157 if !resp.HasStatusCode(p.statusCodes...) { 7158 p.err = p.errorer(resp) 7159 return false 7160 } 7161 result, err := p.responder(resp) 7162 if err != nil { 7163 p.err = err 7164 return false 7165 } 7166 p.current = result 7167 return true 7168} 7169 7170func (p *virtualNetworkPeeringListResultPager) PageResponse() VirtualNetworkPeeringListResultResponse { 7171 return p.current 7172} 7173 7174// VirtualNetworkTapListResultPager provides iteration over VirtualNetworkTapListResult pages. 7175type VirtualNetworkTapListResultPager interface { 7176 azcore.Pager 7177 7178 // PageResponse returns the current VirtualNetworkTapListResultResponse. 7179 PageResponse() VirtualNetworkTapListResultResponse 7180} 7181 7182type virtualNetworkTapListResultCreateRequest func(context.Context) (*azcore.Request, error) 7183 7184type virtualNetworkTapListResultHandleError func(*azcore.Response) error 7185 7186type virtualNetworkTapListResultHandleResponse func(*azcore.Response) (VirtualNetworkTapListResultResponse, error) 7187 7188type virtualNetworkTapListResultAdvancePage func(context.Context, VirtualNetworkTapListResultResponse) (*azcore.Request, error) 7189 7190type virtualNetworkTapListResultPager struct { 7191 // the pipeline for making the request 7192 pipeline azcore.Pipeline 7193 // creates the initial request (non-LRO case) 7194 requester virtualNetworkTapListResultCreateRequest 7195 // callback for handling response errors 7196 errorer virtualNetworkTapListResultHandleError 7197 // callback for handling the HTTP response 7198 responder virtualNetworkTapListResultHandleResponse 7199 // callback for advancing to the next page 7200 advancer virtualNetworkTapListResultAdvancePage 7201 // contains the current response 7202 current VirtualNetworkTapListResultResponse 7203 // status codes for successful retrieval 7204 statusCodes []int 7205 // any error encountered 7206 err error 7207} 7208 7209func (p *virtualNetworkTapListResultPager) Err() error { 7210 return p.err 7211} 7212 7213func (p *virtualNetworkTapListResultPager) NextPage(ctx context.Context) bool { 7214 var req *azcore.Request 7215 var err error 7216 if !reflect.ValueOf(p.current).IsZero() { 7217 if p.current.VirtualNetworkTapListResult.NextLink == nil || len(*p.current.VirtualNetworkTapListResult.NextLink) == 0 { 7218 return false 7219 } 7220 req, err = p.advancer(ctx, p.current) 7221 } else { 7222 req, err = p.requester(ctx) 7223 } 7224 if err != nil { 7225 p.err = err 7226 return false 7227 } 7228 resp, err := p.pipeline.Do(req) 7229 if err != nil { 7230 p.err = err 7231 return false 7232 } 7233 if !resp.HasStatusCode(p.statusCodes...) { 7234 p.err = p.errorer(resp) 7235 return false 7236 } 7237 result, err := p.responder(resp) 7238 if err != nil { 7239 p.err = err 7240 return false 7241 } 7242 p.current = result 7243 return true 7244} 7245 7246func (p *virtualNetworkTapListResultPager) PageResponse() VirtualNetworkTapListResultResponse { 7247 return p.current 7248} 7249 7250// VirtualRouterListResultPager provides iteration over VirtualRouterListResult pages. 7251type VirtualRouterListResultPager interface { 7252 azcore.Pager 7253 7254 // PageResponse returns the current VirtualRouterListResultResponse. 7255 PageResponse() VirtualRouterListResultResponse 7256} 7257 7258type virtualRouterListResultCreateRequest func(context.Context) (*azcore.Request, error) 7259 7260type virtualRouterListResultHandleError func(*azcore.Response) error 7261 7262type virtualRouterListResultHandleResponse func(*azcore.Response) (VirtualRouterListResultResponse, error) 7263 7264type virtualRouterListResultAdvancePage func(context.Context, VirtualRouterListResultResponse) (*azcore.Request, error) 7265 7266type virtualRouterListResultPager struct { 7267 // the pipeline for making the request 7268 pipeline azcore.Pipeline 7269 // creates the initial request (non-LRO case) 7270 requester virtualRouterListResultCreateRequest 7271 // callback for handling response errors 7272 errorer virtualRouterListResultHandleError 7273 // callback for handling the HTTP response 7274 responder virtualRouterListResultHandleResponse 7275 // callback for advancing to the next page 7276 advancer virtualRouterListResultAdvancePage 7277 // contains the current response 7278 current VirtualRouterListResultResponse 7279 // status codes for successful retrieval 7280 statusCodes []int 7281 // any error encountered 7282 err error 7283} 7284 7285func (p *virtualRouterListResultPager) Err() error { 7286 return p.err 7287} 7288 7289func (p *virtualRouterListResultPager) NextPage(ctx context.Context) bool { 7290 var req *azcore.Request 7291 var err error 7292 if !reflect.ValueOf(p.current).IsZero() { 7293 if p.current.VirtualRouterListResult.NextLink == nil || len(*p.current.VirtualRouterListResult.NextLink) == 0 { 7294 return false 7295 } 7296 req, err = p.advancer(ctx, p.current) 7297 } else { 7298 req, err = p.requester(ctx) 7299 } 7300 if err != nil { 7301 p.err = err 7302 return false 7303 } 7304 resp, err := p.pipeline.Do(req) 7305 if err != nil { 7306 p.err = err 7307 return false 7308 } 7309 if !resp.HasStatusCode(p.statusCodes...) { 7310 p.err = p.errorer(resp) 7311 return false 7312 } 7313 result, err := p.responder(resp) 7314 if err != nil { 7315 p.err = err 7316 return false 7317 } 7318 p.current = result 7319 return true 7320} 7321 7322func (p *virtualRouterListResultPager) PageResponse() VirtualRouterListResultResponse { 7323 return p.current 7324} 7325 7326// VirtualRouterPeeringListResultPager provides iteration over VirtualRouterPeeringListResult pages. 7327type VirtualRouterPeeringListResultPager interface { 7328 azcore.Pager 7329 7330 // PageResponse returns the current VirtualRouterPeeringListResultResponse. 7331 PageResponse() VirtualRouterPeeringListResultResponse 7332} 7333 7334type virtualRouterPeeringListResultCreateRequest func(context.Context) (*azcore.Request, error) 7335 7336type virtualRouterPeeringListResultHandleError func(*azcore.Response) error 7337 7338type virtualRouterPeeringListResultHandleResponse func(*azcore.Response) (VirtualRouterPeeringListResultResponse, error) 7339 7340type virtualRouterPeeringListResultAdvancePage func(context.Context, VirtualRouterPeeringListResultResponse) (*azcore.Request, error) 7341 7342type virtualRouterPeeringListResultPager struct { 7343 // the pipeline for making the request 7344 pipeline azcore.Pipeline 7345 // creates the initial request (non-LRO case) 7346 requester virtualRouterPeeringListResultCreateRequest 7347 // callback for handling response errors 7348 errorer virtualRouterPeeringListResultHandleError 7349 // callback for handling the HTTP response 7350 responder virtualRouterPeeringListResultHandleResponse 7351 // callback for advancing to the next page 7352 advancer virtualRouterPeeringListResultAdvancePage 7353 // contains the current response 7354 current VirtualRouterPeeringListResultResponse 7355 // status codes for successful retrieval 7356 statusCodes []int 7357 // any error encountered 7358 err error 7359} 7360 7361func (p *virtualRouterPeeringListResultPager) Err() error { 7362 return p.err 7363} 7364 7365func (p *virtualRouterPeeringListResultPager) NextPage(ctx context.Context) bool { 7366 var req *azcore.Request 7367 var err error 7368 if !reflect.ValueOf(p.current).IsZero() { 7369 if p.current.VirtualRouterPeeringListResult.NextLink == nil || len(*p.current.VirtualRouterPeeringListResult.NextLink) == 0 { 7370 return false 7371 } 7372 req, err = p.advancer(ctx, p.current) 7373 } else { 7374 req, err = p.requester(ctx) 7375 } 7376 if err != nil { 7377 p.err = err 7378 return false 7379 } 7380 resp, err := p.pipeline.Do(req) 7381 if err != nil { 7382 p.err = err 7383 return false 7384 } 7385 if !resp.HasStatusCode(p.statusCodes...) { 7386 p.err = p.errorer(resp) 7387 return false 7388 } 7389 result, err := p.responder(resp) 7390 if err != nil { 7391 p.err = err 7392 return false 7393 } 7394 p.current = result 7395 return true 7396} 7397 7398func (p *virtualRouterPeeringListResultPager) PageResponse() VirtualRouterPeeringListResultResponse { 7399 return p.current 7400} 7401 7402// WebApplicationFirewallPolicyListResultPager provides iteration over WebApplicationFirewallPolicyListResult pages. 7403type WebApplicationFirewallPolicyListResultPager interface { 7404 azcore.Pager 7405 7406 // PageResponse returns the current WebApplicationFirewallPolicyListResultResponse. 7407 PageResponse() WebApplicationFirewallPolicyListResultResponse 7408} 7409 7410type webApplicationFirewallPolicyListResultCreateRequest func(context.Context) (*azcore.Request, error) 7411 7412type webApplicationFirewallPolicyListResultHandleError func(*azcore.Response) error 7413 7414type webApplicationFirewallPolicyListResultHandleResponse func(*azcore.Response) (WebApplicationFirewallPolicyListResultResponse, error) 7415 7416type webApplicationFirewallPolicyListResultAdvancePage func(context.Context, WebApplicationFirewallPolicyListResultResponse) (*azcore.Request, error) 7417 7418type webApplicationFirewallPolicyListResultPager struct { 7419 // the pipeline for making the request 7420 pipeline azcore.Pipeline 7421 // creates the initial request (non-LRO case) 7422 requester webApplicationFirewallPolicyListResultCreateRequest 7423 // callback for handling response errors 7424 errorer webApplicationFirewallPolicyListResultHandleError 7425 // callback for handling the HTTP response 7426 responder webApplicationFirewallPolicyListResultHandleResponse 7427 // callback for advancing to the next page 7428 advancer webApplicationFirewallPolicyListResultAdvancePage 7429 // contains the current response 7430 current WebApplicationFirewallPolicyListResultResponse 7431 // status codes for successful retrieval 7432 statusCodes []int 7433 // any error encountered 7434 err error 7435} 7436 7437func (p *webApplicationFirewallPolicyListResultPager) Err() error { 7438 return p.err 7439} 7440 7441func (p *webApplicationFirewallPolicyListResultPager) NextPage(ctx context.Context) bool { 7442 var req *azcore.Request 7443 var err error 7444 if !reflect.ValueOf(p.current).IsZero() { 7445 if p.current.WebApplicationFirewallPolicyListResult.NextLink == nil || len(*p.current.WebApplicationFirewallPolicyListResult.NextLink) == 0 { 7446 return false 7447 } 7448 req, err = p.advancer(ctx, p.current) 7449 } else { 7450 req, err = p.requester(ctx) 7451 } 7452 if err != nil { 7453 p.err = err 7454 return false 7455 } 7456 resp, err := p.pipeline.Do(req) 7457 if err != nil { 7458 p.err = err 7459 return false 7460 } 7461 if !resp.HasStatusCode(p.statusCodes...) { 7462 p.err = p.errorer(resp) 7463 return false 7464 } 7465 result, err := p.responder(resp) 7466 if err != nil { 7467 p.err = err 7468 return false 7469 } 7470 p.current = result 7471 return true 7472} 7473 7474func (p *webApplicationFirewallPolicyListResultPager) PageResponse() WebApplicationFirewallPolicyListResultResponse { 7475 return p.current 7476} 7477