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