1 /* 2 * Copyright 2020 Google LLC 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * https://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 // Generated by the protocol buffer compiler. DO NOT EDIT! 17 // source: google/cloud/compute/v1/compute.proto 18 19 package com.google.cloud.compute.v1; 20 21 /** 22 * 23 * 24 * <pre> 25 * Represents a Forwarding Rule resource. Forwarding rule resources in Google Cloud can be either regional or global in scope: * [Global](https://cloud.google.com/compute/docs/reference/rest/v1/globalForwardingRules) * [Regional](https://cloud.google.com/compute/docs/reference/rest/v1/forwardingRules) A forwarding rule and its corresponding IP address represent the frontend configuration of a Google Cloud Platform load balancer. Forwarding rules can also reference target instances and Cloud VPN Classic gateways (targetVpnGateway). For more information, read Forwarding rule concepts and Using protocol forwarding. 26 * </pre> 27 * 28 * Protobuf type {@code google.cloud.compute.v1.ForwardingRule} 29 */ 30 public final class ForwardingRule extends com.google.protobuf.GeneratedMessageV3 31 implements 32 // @@protoc_insertion_point(message_implements:google.cloud.compute.v1.ForwardingRule) 33 ForwardingRuleOrBuilder { 34 private static final long serialVersionUID = 0L; 35 // Use ForwardingRule.newBuilder() to construct. ForwardingRule(com.google.protobuf.GeneratedMessageV3.Builder<?> builder)36 private ForwardingRule(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) { 37 super(builder); 38 } 39 ForwardingRule()40 private ForwardingRule() { 41 iPAddress_ = ""; 42 iPProtocol_ = ""; 43 backendService_ = ""; 44 baseForwardingRule_ = ""; 45 creationTimestamp_ = ""; 46 description_ = ""; 47 fingerprint_ = ""; 48 ipVersion_ = ""; 49 kind_ = ""; 50 labelFingerprint_ = ""; 51 loadBalancingScheme_ = ""; 52 metadataFilters_ = java.util.Collections.emptyList(); 53 name_ = ""; 54 network_ = ""; 55 networkTier_ = ""; 56 portRange_ = ""; 57 ports_ = com.google.protobuf.LazyStringArrayList.EMPTY; 58 pscConnectionStatus_ = ""; 59 region_ = ""; 60 selfLink_ = ""; 61 serviceDirectoryRegistrations_ = java.util.Collections.emptyList(); 62 serviceLabel_ = ""; 63 serviceName_ = ""; 64 sourceIpRanges_ = com.google.protobuf.LazyStringArrayList.EMPTY; 65 subnetwork_ = ""; 66 target_ = ""; 67 } 68 69 @java.lang.Override 70 @SuppressWarnings({"unused"}) newInstance(UnusedPrivateParameter unused)71 protected java.lang.Object newInstance(UnusedPrivateParameter unused) { 72 return new ForwardingRule(); 73 } 74 75 @java.lang.Override getUnknownFields()76 public final com.google.protobuf.UnknownFieldSet getUnknownFields() { 77 return this.unknownFields; 78 } 79 getDescriptor()80 public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { 81 return com.google.cloud.compute.v1.Compute 82 .internal_static_google_cloud_compute_v1_ForwardingRule_descriptor; 83 } 84 85 @SuppressWarnings({"rawtypes"}) 86 @java.lang.Override internalGetMapField(int number)87 protected com.google.protobuf.MapField internalGetMapField(int number) { 88 switch (number) { 89 case 500195327: 90 return internalGetLabels(); 91 default: 92 throw new RuntimeException("Invalid map field number: " + number); 93 } 94 } 95 96 @java.lang.Override 97 protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()98 internalGetFieldAccessorTable() { 99 return com.google.cloud.compute.v1.Compute 100 .internal_static_google_cloud_compute_v1_ForwardingRule_fieldAccessorTable 101 .ensureFieldAccessorsInitialized( 102 com.google.cloud.compute.v1.ForwardingRule.class, 103 com.google.cloud.compute.v1.ForwardingRule.Builder.class); 104 } 105 106 /** 107 * 108 * 109 * <pre> 110 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 111 * </pre> 112 * 113 * Protobuf enum {@code google.cloud.compute.v1.ForwardingRule.IPProtocolEnum} 114 */ 115 public enum IPProtocolEnum implements com.google.protobuf.ProtocolMessageEnum { 116 /** 117 * 118 * 119 * <pre> 120 * A value indicating that the enum field is not set. 121 * </pre> 122 * 123 * <code>UNDEFINED_I_P_PROTOCOL_ENUM = 0;</code> 124 */ 125 UNDEFINED_I_P_PROTOCOL_ENUM(0), 126 /** <code>AH = 2087;</code> */ 127 AH(2087), 128 /** <code>ESP = 68962;</code> */ 129 ESP(68962), 130 /** <code>ICMP = 2241597;</code> */ 131 ICMP(2241597), 132 /** <code>L3_DEFAULT = 48151369;</code> */ 133 L3_DEFAULT(48151369), 134 /** <code>SCTP = 2539724;</code> */ 135 SCTP(2539724), 136 /** <code>TCP = 82881;</code> */ 137 TCP(82881), 138 /** <code>UDP = 83873;</code> */ 139 UDP(83873), 140 UNRECOGNIZED(-1), 141 ; 142 143 /** 144 * 145 * 146 * <pre> 147 * A value indicating that the enum field is not set. 148 * </pre> 149 * 150 * <code>UNDEFINED_I_P_PROTOCOL_ENUM = 0;</code> 151 */ 152 public static final int UNDEFINED_I_P_PROTOCOL_ENUM_VALUE = 0; 153 /** <code>AH = 2087;</code> */ 154 public static final int AH_VALUE = 2087; 155 /** <code>ESP = 68962;</code> */ 156 public static final int ESP_VALUE = 68962; 157 /** <code>ICMP = 2241597;</code> */ 158 public static final int ICMP_VALUE = 2241597; 159 /** <code>L3_DEFAULT = 48151369;</code> */ 160 public static final int L3_DEFAULT_VALUE = 48151369; 161 /** <code>SCTP = 2539724;</code> */ 162 public static final int SCTP_VALUE = 2539724; 163 /** <code>TCP = 82881;</code> */ 164 public static final int TCP_VALUE = 82881; 165 /** <code>UDP = 83873;</code> */ 166 public static final int UDP_VALUE = 83873; 167 getNumber()168 public final int getNumber() { 169 if (this == UNRECOGNIZED) { 170 throw new java.lang.IllegalArgumentException( 171 "Can't get the number of an unknown enum value."); 172 } 173 return value; 174 } 175 176 /** 177 * @param value The numeric wire value of the corresponding enum entry. 178 * @return The enum associated with the given numeric wire value. 179 * @deprecated Use {@link #forNumber(int)} instead. 180 */ 181 @java.lang.Deprecated valueOf(int value)182 public static IPProtocolEnum valueOf(int value) { 183 return forNumber(value); 184 } 185 186 /** 187 * @param value The numeric wire value of the corresponding enum entry. 188 * @return The enum associated with the given numeric wire value. 189 */ forNumber(int value)190 public static IPProtocolEnum forNumber(int value) { 191 switch (value) { 192 case 0: 193 return UNDEFINED_I_P_PROTOCOL_ENUM; 194 case 2087: 195 return AH; 196 case 68962: 197 return ESP; 198 case 2241597: 199 return ICMP; 200 case 48151369: 201 return L3_DEFAULT; 202 case 2539724: 203 return SCTP; 204 case 82881: 205 return TCP; 206 case 83873: 207 return UDP; 208 default: 209 return null; 210 } 211 } 212 internalGetValueMap()213 public static com.google.protobuf.Internal.EnumLiteMap<IPProtocolEnum> internalGetValueMap() { 214 return internalValueMap; 215 } 216 217 private static final com.google.protobuf.Internal.EnumLiteMap<IPProtocolEnum> internalValueMap = 218 new com.google.protobuf.Internal.EnumLiteMap<IPProtocolEnum>() { 219 public IPProtocolEnum findValueByNumber(int number) { 220 return IPProtocolEnum.forNumber(number); 221 } 222 }; 223 getValueDescriptor()224 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 225 if (this == UNRECOGNIZED) { 226 throw new java.lang.IllegalStateException( 227 "Can't get the descriptor of an unrecognized enum value."); 228 } 229 return getDescriptor().getValues().get(ordinal()); 230 } 231 getDescriptorForType()232 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 233 return getDescriptor(); 234 } 235 getDescriptor()236 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 237 return com.google.cloud.compute.v1.ForwardingRule.getDescriptor().getEnumTypes().get(0); 238 } 239 240 private static final IPProtocolEnum[] VALUES = values(); 241 valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc)242 public static IPProtocolEnum valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 243 if (desc.getType() != getDescriptor()) { 244 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 245 } 246 if (desc.getIndex() == -1) { 247 return UNRECOGNIZED; 248 } 249 return VALUES[desc.getIndex()]; 250 } 251 252 private final int value; 253 IPProtocolEnum(int value)254 private IPProtocolEnum(int value) { 255 this.value = value; 256 } 257 258 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.ForwardingRule.IPProtocolEnum) 259 } 260 261 /** 262 * 263 * 264 * <pre> 265 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 266 * </pre> 267 * 268 * Protobuf enum {@code google.cloud.compute.v1.ForwardingRule.IpVersion} 269 */ 270 public enum IpVersion implements com.google.protobuf.ProtocolMessageEnum { 271 /** 272 * 273 * 274 * <pre> 275 * A value indicating that the enum field is not set. 276 * </pre> 277 * 278 * <code>UNDEFINED_IP_VERSION = 0;</code> 279 */ 280 UNDEFINED_IP_VERSION(0), 281 /** <code>IPV4 = 2254341;</code> */ 282 IPV4(2254341), 283 /** <code>IPV6 = 2254343;</code> */ 284 IPV6(2254343), 285 /** <code>UNSPECIFIED_VERSION = 21850000;</code> */ 286 UNSPECIFIED_VERSION(21850000), 287 UNRECOGNIZED(-1), 288 ; 289 290 /** 291 * 292 * 293 * <pre> 294 * A value indicating that the enum field is not set. 295 * </pre> 296 * 297 * <code>UNDEFINED_IP_VERSION = 0;</code> 298 */ 299 public static final int UNDEFINED_IP_VERSION_VALUE = 0; 300 /** <code>IPV4 = 2254341;</code> */ 301 public static final int IPV4_VALUE = 2254341; 302 /** <code>IPV6 = 2254343;</code> */ 303 public static final int IPV6_VALUE = 2254343; 304 /** <code>UNSPECIFIED_VERSION = 21850000;</code> */ 305 public static final int UNSPECIFIED_VERSION_VALUE = 21850000; 306 getNumber()307 public final int getNumber() { 308 if (this == UNRECOGNIZED) { 309 throw new java.lang.IllegalArgumentException( 310 "Can't get the number of an unknown enum value."); 311 } 312 return value; 313 } 314 315 /** 316 * @param value The numeric wire value of the corresponding enum entry. 317 * @return The enum associated with the given numeric wire value. 318 * @deprecated Use {@link #forNumber(int)} instead. 319 */ 320 @java.lang.Deprecated valueOf(int value)321 public static IpVersion valueOf(int value) { 322 return forNumber(value); 323 } 324 325 /** 326 * @param value The numeric wire value of the corresponding enum entry. 327 * @return The enum associated with the given numeric wire value. 328 */ forNumber(int value)329 public static IpVersion forNumber(int value) { 330 switch (value) { 331 case 0: 332 return UNDEFINED_IP_VERSION; 333 case 2254341: 334 return IPV4; 335 case 2254343: 336 return IPV6; 337 case 21850000: 338 return UNSPECIFIED_VERSION; 339 default: 340 return null; 341 } 342 } 343 internalGetValueMap()344 public static com.google.protobuf.Internal.EnumLiteMap<IpVersion> internalGetValueMap() { 345 return internalValueMap; 346 } 347 348 private static final com.google.protobuf.Internal.EnumLiteMap<IpVersion> internalValueMap = 349 new com.google.protobuf.Internal.EnumLiteMap<IpVersion>() { 350 public IpVersion findValueByNumber(int number) { 351 return IpVersion.forNumber(number); 352 } 353 }; 354 getValueDescriptor()355 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 356 if (this == UNRECOGNIZED) { 357 throw new java.lang.IllegalStateException( 358 "Can't get the descriptor of an unrecognized enum value."); 359 } 360 return getDescriptor().getValues().get(ordinal()); 361 } 362 getDescriptorForType()363 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 364 return getDescriptor(); 365 } 366 getDescriptor()367 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 368 return com.google.cloud.compute.v1.ForwardingRule.getDescriptor().getEnumTypes().get(1); 369 } 370 371 private static final IpVersion[] VALUES = values(); 372 valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc)373 public static IpVersion valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 374 if (desc.getType() != getDescriptor()) { 375 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 376 } 377 if (desc.getIndex() == -1) { 378 return UNRECOGNIZED; 379 } 380 return VALUES[desc.getIndex()]; 381 } 382 383 private final int value; 384 IpVersion(int value)385 private IpVersion(int value) { 386 this.value = value; 387 } 388 389 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.ForwardingRule.IpVersion) 390 } 391 392 /** 393 * 394 * 395 * <pre> 396 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 397 * </pre> 398 * 399 * Protobuf enum {@code google.cloud.compute.v1.ForwardingRule.LoadBalancingScheme} 400 */ 401 public enum LoadBalancingScheme implements com.google.protobuf.ProtocolMessageEnum { 402 /** 403 * 404 * 405 * <pre> 406 * A value indicating that the enum field is not set. 407 * </pre> 408 * 409 * <code>UNDEFINED_LOAD_BALANCING_SCHEME = 0;</code> 410 */ 411 UNDEFINED_LOAD_BALANCING_SCHEME(0), 412 /** <code>EXTERNAL = 35607499;</code> */ 413 EXTERNAL(35607499), 414 /** <code>EXTERNAL_MANAGED = 512006923;</code> */ 415 EXTERNAL_MANAGED(512006923), 416 /** <code>INTERNAL = 279295677;</code> */ 417 INTERNAL(279295677), 418 /** <code>INTERNAL_MANAGED = 37350397;</code> */ 419 INTERNAL_MANAGED(37350397), 420 /** <code>INTERNAL_SELF_MANAGED = 236211150;</code> */ 421 INTERNAL_SELF_MANAGED(236211150), 422 /** <code>INVALID = 530283991;</code> */ 423 INVALID(530283991), 424 UNRECOGNIZED(-1), 425 ; 426 427 /** 428 * 429 * 430 * <pre> 431 * A value indicating that the enum field is not set. 432 * </pre> 433 * 434 * <code>UNDEFINED_LOAD_BALANCING_SCHEME = 0;</code> 435 */ 436 public static final int UNDEFINED_LOAD_BALANCING_SCHEME_VALUE = 0; 437 /** <code>EXTERNAL = 35607499;</code> */ 438 public static final int EXTERNAL_VALUE = 35607499; 439 /** <code>EXTERNAL_MANAGED = 512006923;</code> */ 440 public static final int EXTERNAL_MANAGED_VALUE = 512006923; 441 /** <code>INTERNAL = 279295677;</code> */ 442 public static final int INTERNAL_VALUE = 279295677; 443 /** <code>INTERNAL_MANAGED = 37350397;</code> */ 444 public static final int INTERNAL_MANAGED_VALUE = 37350397; 445 /** <code>INTERNAL_SELF_MANAGED = 236211150;</code> */ 446 public static final int INTERNAL_SELF_MANAGED_VALUE = 236211150; 447 /** <code>INVALID = 530283991;</code> */ 448 public static final int INVALID_VALUE = 530283991; 449 getNumber()450 public final int getNumber() { 451 if (this == UNRECOGNIZED) { 452 throw new java.lang.IllegalArgumentException( 453 "Can't get the number of an unknown enum value."); 454 } 455 return value; 456 } 457 458 /** 459 * @param value The numeric wire value of the corresponding enum entry. 460 * @return The enum associated with the given numeric wire value. 461 * @deprecated Use {@link #forNumber(int)} instead. 462 */ 463 @java.lang.Deprecated valueOf(int value)464 public static LoadBalancingScheme valueOf(int value) { 465 return forNumber(value); 466 } 467 468 /** 469 * @param value The numeric wire value of the corresponding enum entry. 470 * @return The enum associated with the given numeric wire value. 471 */ forNumber(int value)472 public static LoadBalancingScheme forNumber(int value) { 473 switch (value) { 474 case 0: 475 return UNDEFINED_LOAD_BALANCING_SCHEME; 476 case 35607499: 477 return EXTERNAL; 478 case 512006923: 479 return EXTERNAL_MANAGED; 480 case 279295677: 481 return INTERNAL; 482 case 37350397: 483 return INTERNAL_MANAGED; 484 case 236211150: 485 return INTERNAL_SELF_MANAGED; 486 case 530283991: 487 return INVALID; 488 default: 489 return null; 490 } 491 } 492 493 public static com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme> internalGetValueMap()494 internalGetValueMap() { 495 return internalValueMap; 496 } 497 498 private static final com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme> 499 internalValueMap = 500 new com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme>() { 501 public LoadBalancingScheme findValueByNumber(int number) { 502 return LoadBalancingScheme.forNumber(number); 503 } 504 }; 505 getValueDescriptor()506 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 507 if (this == UNRECOGNIZED) { 508 throw new java.lang.IllegalStateException( 509 "Can't get the descriptor of an unrecognized enum value."); 510 } 511 return getDescriptor().getValues().get(ordinal()); 512 } 513 getDescriptorForType()514 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 515 return getDescriptor(); 516 } 517 getDescriptor()518 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 519 return com.google.cloud.compute.v1.ForwardingRule.getDescriptor().getEnumTypes().get(2); 520 } 521 522 private static final LoadBalancingScheme[] VALUES = values(); 523 valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)524 public static LoadBalancingScheme valueOf( 525 com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 526 if (desc.getType() != getDescriptor()) { 527 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 528 } 529 if (desc.getIndex() == -1) { 530 return UNRECOGNIZED; 531 } 532 return VALUES[desc.getIndex()]; 533 } 534 535 private final int value; 536 LoadBalancingScheme(int value)537 private LoadBalancingScheme(int value) { 538 this.value = value; 539 } 540 541 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.ForwardingRule.LoadBalancingScheme) 542 } 543 544 /** 545 * 546 * 547 * <pre> 548 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 549 * </pre> 550 * 551 * Protobuf enum {@code google.cloud.compute.v1.ForwardingRule.NetworkTier} 552 */ 553 public enum NetworkTier implements com.google.protobuf.ProtocolMessageEnum { 554 /** 555 * 556 * 557 * <pre> 558 * A value indicating that the enum field is not set. 559 * </pre> 560 * 561 * <code>UNDEFINED_NETWORK_TIER = 0;</code> 562 */ 563 UNDEFINED_NETWORK_TIER(0), 564 /** 565 * 566 * 567 * <pre> 568 * Public internet quality with fixed bandwidth. 569 * </pre> 570 * 571 * <code>FIXED_STANDARD = 310464328;</code> 572 */ 573 FIXED_STANDARD(310464328), 574 /** 575 * 576 * 577 * <pre> 578 * High quality, Google-grade network tier, support for all networking products. 579 * </pre> 580 * 581 * <code>PREMIUM = 399530551;</code> 582 */ 583 PREMIUM(399530551), 584 /** 585 * 586 * 587 * <pre> 588 * Public internet quality, only limited support for other networking products. 589 * </pre> 590 * 591 * <code>STANDARD = 484642493;</code> 592 */ 593 STANDARD(484642493), 594 /** 595 * 596 * 597 * <pre> 598 * (Output only) Temporary tier for FIXED_STANDARD when fixed standard tier is expired or not configured. 599 * </pre> 600 * 601 * <code>STANDARD_OVERRIDES_FIXED_STANDARD = 465847234;</code> 602 */ 603 STANDARD_OVERRIDES_FIXED_STANDARD(465847234), 604 UNRECOGNIZED(-1), 605 ; 606 607 /** 608 * 609 * 610 * <pre> 611 * A value indicating that the enum field is not set. 612 * </pre> 613 * 614 * <code>UNDEFINED_NETWORK_TIER = 0;</code> 615 */ 616 public static final int UNDEFINED_NETWORK_TIER_VALUE = 0; 617 /** 618 * 619 * 620 * <pre> 621 * Public internet quality with fixed bandwidth. 622 * </pre> 623 * 624 * <code>FIXED_STANDARD = 310464328;</code> 625 */ 626 public static final int FIXED_STANDARD_VALUE = 310464328; 627 /** 628 * 629 * 630 * <pre> 631 * High quality, Google-grade network tier, support for all networking products. 632 * </pre> 633 * 634 * <code>PREMIUM = 399530551;</code> 635 */ 636 public static final int PREMIUM_VALUE = 399530551; 637 /** 638 * 639 * 640 * <pre> 641 * Public internet quality, only limited support for other networking products. 642 * </pre> 643 * 644 * <code>STANDARD = 484642493;</code> 645 */ 646 public static final int STANDARD_VALUE = 484642493; 647 /** 648 * 649 * 650 * <pre> 651 * (Output only) Temporary tier for FIXED_STANDARD when fixed standard tier is expired or not configured. 652 * </pre> 653 * 654 * <code>STANDARD_OVERRIDES_FIXED_STANDARD = 465847234;</code> 655 */ 656 public static final int STANDARD_OVERRIDES_FIXED_STANDARD_VALUE = 465847234; 657 getNumber()658 public final int getNumber() { 659 if (this == UNRECOGNIZED) { 660 throw new java.lang.IllegalArgumentException( 661 "Can't get the number of an unknown enum value."); 662 } 663 return value; 664 } 665 666 /** 667 * @param value The numeric wire value of the corresponding enum entry. 668 * @return The enum associated with the given numeric wire value. 669 * @deprecated Use {@link #forNumber(int)} instead. 670 */ 671 @java.lang.Deprecated valueOf(int value)672 public static NetworkTier valueOf(int value) { 673 return forNumber(value); 674 } 675 676 /** 677 * @param value The numeric wire value of the corresponding enum entry. 678 * @return The enum associated with the given numeric wire value. 679 */ forNumber(int value)680 public static NetworkTier forNumber(int value) { 681 switch (value) { 682 case 0: 683 return UNDEFINED_NETWORK_TIER; 684 case 310464328: 685 return FIXED_STANDARD; 686 case 399530551: 687 return PREMIUM; 688 case 484642493: 689 return STANDARD; 690 case 465847234: 691 return STANDARD_OVERRIDES_FIXED_STANDARD; 692 default: 693 return null; 694 } 695 } 696 internalGetValueMap()697 public static com.google.protobuf.Internal.EnumLiteMap<NetworkTier> internalGetValueMap() { 698 return internalValueMap; 699 } 700 701 private static final com.google.protobuf.Internal.EnumLiteMap<NetworkTier> internalValueMap = 702 new com.google.protobuf.Internal.EnumLiteMap<NetworkTier>() { 703 public NetworkTier findValueByNumber(int number) { 704 return NetworkTier.forNumber(number); 705 } 706 }; 707 getValueDescriptor()708 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 709 if (this == UNRECOGNIZED) { 710 throw new java.lang.IllegalStateException( 711 "Can't get the descriptor of an unrecognized enum value."); 712 } 713 return getDescriptor().getValues().get(ordinal()); 714 } 715 getDescriptorForType()716 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 717 return getDescriptor(); 718 } 719 getDescriptor()720 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 721 return com.google.cloud.compute.v1.ForwardingRule.getDescriptor().getEnumTypes().get(3); 722 } 723 724 private static final NetworkTier[] VALUES = values(); 725 valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc)726 public static NetworkTier valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 727 if (desc.getType() != getDescriptor()) { 728 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 729 } 730 if (desc.getIndex() == -1) { 731 return UNRECOGNIZED; 732 } 733 return VALUES[desc.getIndex()]; 734 } 735 736 private final int value; 737 NetworkTier(int value)738 private NetworkTier(int value) { 739 this.value = value; 740 } 741 742 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.ForwardingRule.NetworkTier) 743 } 744 745 /** 746 * 747 * 748 * <pre> 749 * </pre> 750 * 751 * Protobuf enum {@code google.cloud.compute.v1.ForwardingRule.PscConnectionStatus} 752 */ 753 public enum PscConnectionStatus implements com.google.protobuf.ProtocolMessageEnum { 754 /** 755 * 756 * 757 * <pre> 758 * A value indicating that the enum field is not set. 759 * </pre> 760 * 761 * <code>UNDEFINED_PSC_CONNECTION_STATUS = 0;</code> 762 */ 763 UNDEFINED_PSC_CONNECTION_STATUS(0), 764 /** 765 * 766 * 767 * <pre> 768 * The connection has been accepted by the producer. 769 * </pre> 770 * 771 * <code>ACCEPTED = 246714279;</code> 772 */ 773 ACCEPTED(246714279), 774 /** 775 * 776 * 777 * <pre> 778 * The connection has been closed by the producer and will not serve traffic going forward. 779 * </pre> 780 * 781 * <code>CLOSED = 380163436;</code> 782 */ 783 CLOSED(380163436), 784 /** 785 * 786 * 787 * <pre> 788 * The connection has been accepted by the producer, but the producer needs to take further action before the forwarding rule can serve traffic. 789 * </pre> 790 * 791 * <code>NEEDS_ATTENTION = 344491452;</code> 792 */ 793 NEEDS_ATTENTION(344491452), 794 /** 795 * 796 * 797 * <pre> 798 * The connection is pending acceptance by the producer. 799 * </pre> 800 * 801 * <code>PENDING = 35394935;</code> 802 */ 803 PENDING(35394935), 804 /** 805 * 806 * 807 * <pre> 808 * The connection has been rejected by the producer. 809 * </pre> 810 * 811 * <code>REJECTED = 174130302;</code> 812 */ 813 REJECTED(174130302), 814 /** <code>STATUS_UNSPECIFIED = 42133066;</code> */ 815 STATUS_UNSPECIFIED(42133066), 816 UNRECOGNIZED(-1), 817 ; 818 819 /** 820 * 821 * 822 * <pre> 823 * A value indicating that the enum field is not set. 824 * </pre> 825 * 826 * <code>UNDEFINED_PSC_CONNECTION_STATUS = 0;</code> 827 */ 828 public static final int UNDEFINED_PSC_CONNECTION_STATUS_VALUE = 0; 829 /** 830 * 831 * 832 * <pre> 833 * The connection has been accepted by the producer. 834 * </pre> 835 * 836 * <code>ACCEPTED = 246714279;</code> 837 */ 838 public static final int ACCEPTED_VALUE = 246714279; 839 /** 840 * 841 * 842 * <pre> 843 * The connection has been closed by the producer and will not serve traffic going forward. 844 * </pre> 845 * 846 * <code>CLOSED = 380163436;</code> 847 */ 848 public static final int CLOSED_VALUE = 380163436; 849 /** 850 * 851 * 852 * <pre> 853 * The connection has been accepted by the producer, but the producer needs to take further action before the forwarding rule can serve traffic. 854 * </pre> 855 * 856 * <code>NEEDS_ATTENTION = 344491452;</code> 857 */ 858 public static final int NEEDS_ATTENTION_VALUE = 344491452; 859 /** 860 * 861 * 862 * <pre> 863 * The connection is pending acceptance by the producer. 864 * </pre> 865 * 866 * <code>PENDING = 35394935;</code> 867 */ 868 public static final int PENDING_VALUE = 35394935; 869 /** 870 * 871 * 872 * <pre> 873 * The connection has been rejected by the producer. 874 * </pre> 875 * 876 * <code>REJECTED = 174130302;</code> 877 */ 878 public static final int REJECTED_VALUE = 174130302; 879 /** <code>STATUS_UNSPECIFIED = 42133066;</code> */ 880 public static final int STATUS_UNSPECIFIED_VALUE = 42133066; 881 getNumber()882 public final int getNumber() { 883 if (this == UNRECOGNIZED) { 884 throw new java.lang.IllegalArgumentException( 885 "Can't get the number of an unknown enum value."); 886 } 887 return value; 888 } 889 890 /** 891 * @param value The numeric wire value of the corresponding enum entry. 892 * @return The enum associated with the given numeric wire value. 893 * @deprecated Use {@link #forNumber(int)} instead. 894 */ 895 @java.lang.Deprecated valueOf(int value)896 public static PscConnectionStatus valueOf(int value) { 897 return forNumber(value); 898 } 899 900 /** 901 * @param value The numeric wire value of the corresponding enum entry. 902 * @return The enum associated with the given numeric wire value. 903 */ forNumber(int value)904 public static PscConnectionStatus forNumber(int value) { 905 switch (value) { 906 case 0: 907 return UNDEFINED_PSC_CONNECTION_STATUS; 908 case 246714279: 909 return ACCEPTED; 910 case 380163436: 911 return CLOSED; 912 case 344491452: 913 return NEEDS_ATTENTION; 914 case 35394935: 915 return PENDING; 916 case 174130302: 917 return REJECTED; 918 case 42133066: 919 return STATUS_UNSPECIFIED; 920 default: 921 return null; 922 } 923 } 924 925 public static com.google.protobuf.Internal.EnumLiteMap<PscConnectionStatus> internalGetValueMap()926 internalGetValueMap() { 927 return internalValueMap; 928 } 929 930 private static final com.google.protobuf.Internal.EnumLiteMap<PscConnectionStatus> 931 internalValueMap = 932 new com.google.protobuf.Internal.EnumLiteMap<PscConnectionStatus>() { 933 public PscConnectionStatus findValueByNumber(int number) { 934 return PscConnectionStatus.forNumber(number); 935 } 936 }; 937 getValueDescriptor()938 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 939 if (this == UNRECOGNIZED) { 940 throw new java.lang.IllegalStateException( 941 "Can't get the descriptor of an unrecognized enum value."); 942 } 943 return getDescriptor().getValues().get(ordinal()); 944 } 945 getDescriptorForType()946 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 947 return getDescriptor(); 948 } 949 getDescriptor()950 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 951 return com.google.cloud.compute.v1.ForwardingRule.getDescriptor().getEnumTypes().get(4); 952 } 953 954 private static final PscConnectionStatus[] VALUES = values(); 955 valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)956 public static PscConnectionStatus valueOf( 957 com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 958 if (desc.getType() != getDescriptor()) { 959 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 960 } 961 if (desc.getIndex() == -1) { 962 return UNRECOGNIZED; 963 } 964 return VALUES[desc.getIndex()]; 965 } 966 967 private final int value; 968 PscConnectionStatus(int value)969 private PscConnectionStatus(int value) { 970 this.value = value; 971 } 972 973 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.ForwardingRule.PscConnectionStatus) 974 } 975 976 private int bitField0_; 977 public static final int I_P_ADDRESS_FIELD_NUMBER = 42976943; 978 979 @SuppressWarnings("serial") 980 private volatile java.lang.Object iPAddress_ = ""; 981 /** 982 * 983 * 984 * <pre> 985 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 986 * </pre> 987 * 988 * <code>optional string I_p_address = 42976943;</code> 989 * 990 * @return Whether the iPAddress field is set. 991 */ 992 @java.lang.Override hasIPAddress()993 public boolean hasIPAddress() { 994 return ((bitField0_ & 0x00000001) != 0); 995 } 996 /** 997 * 998 * 999 * <pre> 1000 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 1001 * </pre> 1002 * 1003 * <code>optional string I_p_address = 42976943;</code> 1004 * 1005 * @return The iPAddress. 1006 */ 1007 @java.lang.Override getIPAddress()1008 public java.lang.String getIPAddress() { 1009 java.lang.Object ref = iPAddress_; 1010 if (ref instanceof java.lang.String) { 1011 return (java.lang.String) ref; 1012 } else { 1013 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1014 java.lang.String s = bs.toStringUtf8(); 1015 iPAddress_ = s; 1016 return s; 1017 } 1018 } 1019 /** 1020 * 1021 * 1022 * <pre> 1023 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 1024 * </pre> 1025 * 1026 * <code>optional string I_p_address = 42976943;</code> 1027 * 1028 * @return The bytes for iPAddress. 1029 */ 1030 @java.lang.Override getIPAddressBytes()1031 public com.google.protobuf.ByteString getIPAddressBytes() { 1032 java.lang.Object ref = iPAddress_; 1033 if (ref instanceof java.lang.String) { 1034 com.google.protobuf.ByteString b = 1035 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1036 iPAddress_ = b; 1037 return b; 1038 } else { 1039 return (com.google.protobuf.ByteString) ref; 1040 } 1041 } 1042 1043 public static final int I_P_PROTOCOL_FIELD_NUMBER = 488094525; 1044 1045 @SuppressWarnings("serial") 1046 private volatile java.lang.Object iPProtocol_ = ""; 1047 /** 1048 * 1049 * 1050 * <pre> 1051 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 1052 * Check the IPProtocolEnum enum for the list of possible values. 1053 * </pre> 1054 * 1055 * <code>optional string I_p_protocol = 488094525;</code> 1056 * 1057 * @return Whether the iPProtocol field is set. 1058 */ 1059 @java.lang.Override hasIPProtocol()1060 public boolean hasIPProtocol() { 1061 return ((bitField0_ & 0x00000002) != 0); 1062 } 1063 /** 1064 * 1065 * 1066 * <pre> 1067 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 1068 * Check the IPProtocolEnum enum for the list of possible values. 1069 * </pre> 1070 * 1071 * <code>optional string I_p_protocol = 488094525;</code> 1072 * 1073 * @return The iPProtocol. 1074 */ 1075 @java.lang.Override getIPProtocol()1076 public java.lang.String getIPProtocol() { 1077 java.lang.Object ref = iPProtocol_; 1078 if (ref instanceof java.lang.String) { 1079 return (java.lang.String) ref; 1080 } else { 1081 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1082 java.lang.String s = bs.toStringUtf8(); 1083 iPProtocol_ = s; 1084 return s; 1085 } 1086 } 1087 /** 1088 * 1089 * 1090 * <pre> 1091 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 1092 * Check the IPProtocolEnum enum for the list of possible values. 1093 * </pre> 1094 * 1095 * <code>optional string I_p_protocol = 488094525;</code> 1096 * 1097 * @return The bytes for iPProtocol. 1098 */ 1099 @java.lang.Override getIPProtocolBytes()1100 public com.google.protobuf.ByteString getIPProtocolBytes() { 1101 java.lang.Object ref = iPProtocol_; 1102 if (ref instanceof java.lang.String) { 1103 com.google.protobuf.ByteString b = 1104 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1105 iPProtocol_ = b; 1106 return b; 1107 } else { 1108 return (com.google.protobuf.ByteString) ref; 1109 } 1110 } 1111 1112 public static final int ALL_PORTS_FIELD_NUMBER = 445175796; 1113 private boolean allPorts_ = false; 1114 /** 1115 * 1116 * 1117 * <pre> 1118 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal and external protocol forwarding. Set this field to true to allow packets addressed to any port or packets lacking destination port information (for example, UDP fragments after the first fragment) to be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. 1119 * </pre> 1120 * 1121 * <code>optional bool all_ports = 445175796;</code> 1122 * 1123 * @return Whether the allPorts field is set. 1124 */ 1125 @java.lang.Override hasAllPorts()1126 public boolean hasAllPorts() { 1127 return ((bitField0_ & 0x00000004) != 0); 1128 } 1129 /** 1130 * 1131 * 1132 * <pre> 1133 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal and external protocol forwarding. Set this field to true to allow packets addressed to any port or packets lacking destination port information (for example, UDP fragments after the first fragment) to be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. 1134 * </pre> 1135 * 1136 * <code>optional bool all_ports = 445175796;</code> 1137 * 1138 * @return The allPorts. 1139 */ 1140 @java.lang.Override getAllPorts()1141 public boolean getAllPorts() { 1142 return allPorts_; 1143 } 1144 1145 public static final int ALLOW_GLOBAL_ACCESS_FIELD_NUMBER = 499409674; 1146 private boolean allowGlobalAccess_ = false; 1147 /** 1148 * 1149 * 1150 * <pre> 1151 * This field is used along with the backend_service field for internal load balancing or with the target field for internal TargetInstance. If the field is set to TRUE, clients can access ILB from all regions. Otherwise only allows access from clients in the same region as the internal load balancer. 1152 * </pre> 1153 * 1154 * <code>optional bool allow_global_access = 499409674;</code> 1155 * 1156 * @return Whether the allowGlobalAccess field is set. 1157 */ 1158 @java.lang.Override hasAllowGlobalAccess()1159 public boolean hasAllowGlobalAccess() { 1160 return ((bitField0_ & 0x00000008) != 0); 1161 } 1162 /** 1163 * 1164 * 1165 * <pre> 1166 * This field is used along with the backend_service field for internal load balancing or with the target field for internal TargetInstance. If the field is set to TRUE, clients can access ILB from all regions. Otherwise only allows access from clients in the same region as the internal load balancer. 1167 * </pre> 1168 * 1169 * <code>optional bool allow_global_access = 499409674;</code> 1170 * 1171 * @return The allowGlobalAccess. 1172 */ 1173 @java.lang.Override getAllowGlobalAccess()1174 public boolean getAllowGlobalAccess() { 1175 return allowGlobalAccess_; 1176 } 1177 1178 public static final int BACKEND_SERVICE_FIELD_NUMBER = 306946058; 1179 1180 @SuppressWarnings("serial") 1181 private volatile java.lang.Object backendService_ = ""; 1182 /** 1183 * 1184 * 1185 * <pre> 1186 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 1187 * </pre> 1188 * 1189 * <code>optional string backend_service = 306946058;</code> 1190 * 1191 * @return Whether the backendService field is set. 1192 */ 1193 @java.lang.Override hasBackendService()1194 public boolean hasBackendService() { 1195 return ((bitField0_ & 0x00000010) != 0); 1196 } 1197 /** 1198 * 1199 * 1200 * <pre> 1201 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 1202 * </pre> 1203 * 1204 * <code>optional string backend_service = 306946058;</code> 1205 * 1206 * @return The backendService. 1207 */ 1208 @java.lang.Override getBackendService()1209 public java.lang.String getBackendService() { 1210 java.lang.Object ref = backendService_; 1211 if (ref instanceof java.lang.String) { 1212 return (java.lang.String) ref; 1213 } else { 1214 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1215 java.lang.String s = bs.toStringUtf8(); 1216 backendService_ = s; 1217 return s; 1218 } 1219 } 1220 /** 1221 * 1222 * 1223 * <pre> 1224 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 1225 * </pre> 1226 * 1227 * <code>optional string backend_service = 306946058;</code> 1228 * 1229 * @return The bytes for backendService. 1230 */ 1231 @java.lang.Override getBackendServiceBytes()1232 public com.google.protobuf.ByteString getBackendServiceBytes() { 1233 java.lang.Object ref = backendService_; 1234 if (ref instanceof java.lang.String) { 1235 com.google.protobuf.ByteString b = 1236 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1237 backendService_ = b; 1238 return b; 1239 } else { 1240 return (com.google.protobuf.ByteString) ref; 1241 } 1242 } 1243 1244 public static final int BASE_FORWARDING_RULE_FIELD_NUMBER = 524873104; 1245 1246 @SuppressWarnings("serial") 1247 private volatile java.lang.Object baseForwardingRule_ = ""; 1248 /** 1249 * 1250 * 1251 * <pre> 1252 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 1253 * </pre> 1254 * 1255 * <code>optional string base_forwarding_rule = 524873104;</code> 1256 * 1257 * @return Whether the baseForwardingRule field is set. 1258 */ 1259 @java.lang.Override hasBaseForwardingRule()1260 public boolean hasBaseForwardingRule() { 1261 return ((bitField0_ & 0x00000020) != 0); 1262 } 1263 /** 1264 * 1265 * 1266 * <pre> 1267 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 1268 * </pre> 1269 * 1270 * <code>optional string base_forwarding_rule = 524873104;</code> 1271 * 1272 * @return The baseForwardingRule. 1273 */ 1274 @java.lang.Override getBaseForwardingRule()1275 public java.lang.String getBaseForwardingRule() { 1276 java.lang.Object ref = baseForwardingRule_; 1277 if (ref instanceof java.lang.String) { 1278 return (java.lang.String) ref; 1279 } else { 1280 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1281 java.lang.String s = bs.toStringUtf8(); 1282 baseForwardingRule_ = s; 1283 return s; 1284 } 1285 } 1286 /** 1287 * 1288 * 1289 * <pre> 1290 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 1291 * </pre> 1292 * 1293 * <code>optional string base_forwarding_rule = 524873104;</code> 1294 * 1295 * @return The bytes for baseForwardingRule. 1296 */ 1297 @java.lang.Override getBaseForwardingRuleBytes()1298 public com.google.protobuf.ByteString getBaseForwardingRuleBytes() { 1299 java.lang.Object ref = baseForwardingRule_; 1300 if (ref instanceof java.lang.String) { 1301 com.google.protobuf.ByteString b = 1302 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1303 baseForwardingRule_ = b; 1304 return b; 1305 } else { 1306 return (com.google.protobuf.ByteString) ref; 1307 } 1308 } 1309 1310 public static final int CREATION_TIMESTAMP_FIELD_NUMBER = 30525366; 1311 1312 @SuppressWarnings("serial") 1313 private volatile java.lang.Object creationTimestamp_ = ""; 1314 /** 1315 * 1316 * 1317 * <pre> 1318 * [Output Only] Creation timestamp in RFC3339 text format. 1319 * </pre> 1320 * 1321 * <code>optional string creation_timestamp = 30525366;</code> 1322 * 1323 * @return Whether the creationTimestamp field is set. 1324 */ 1325 @java.lang.Override hasCreationTimestamp()1326 public boolean hasCreationTimestamp() { 1327 return ((bitField0_ & 0x00000040) != 0); 1328 } 1329 /** 1330 * 1331 * 1332 * <pre> 1333 * [Output Only] Creation timestamp in RFC3339 text format. 1334 * </pre> 1335 * 1336 * <code>optional string creation_timestamp = 30525366;</code> 1337 * 1338 * @return The creationTimestamp. 1339 */ 1340 @java.lang.Override getCreationTimestamp()1341 public java.lang.String getCreationTimestamp() { 1342 java.lang.Object ref = creationTimestamp_; 1343 if (ref instanceof java.lang.String) { 1344 return (java.lang.String) ref; 1345 } else { 1346 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1347 java.lang.String s = bs.toStringUtf8(); 1348 creationTimestamp_ = s; 1349 return s; 1350 } 1351 } 1352 /** 1353 * 1354 * 1355 * <pre> 1356 * [Output Only] Creation timestamp in RFC3339 text format. 1357 * </pre> 1358 * 1359 * <code>optional string creation_timestamp = 30525366;</code> 1360 * 1361 * @return The bytes for creationTimestamp. 1362 */ 1363 @java.lang.Override getCreationTimestampBytes()1364 public com.google.protobuf.ByteString getCreationTimestampBytes() { 1365 java.lang.Object ref = creationTimestamp_; 1366 if (ref instanceof java.lang.String) { 1367 com.google.protobuf.ByteString b = 1368 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1369 creationTimestamp_ = b; 1370 return b; 1371 } else { 1372 return (com.google.protobuf.ByteString) ref; 1373 } 1374 } 1375 1376 public static final int DESCRIPTION_FIELD_NUMBER = 422937596; 1377 1378 @SuppressWarnings("serial") 1379 private volatile java.lang.Object description_ = ""; 1380 /** 1381 * 1382 * 1383 * <pre> 1384 * An optional description of this resource. Provide this property when you create the resource. 1385 * </pre> 1386 * 1387 * <code>optional string description = 422937596;</code> 1388 * 1389 * @return Whether the description field is set. 1390 */ 1391 @java.lang.Override hasDescription()1392 public boolean hasDescription() { 1393 return ((bitField0_ & 0x00000080) != 0); 1394 } 1395 /** 1396 * 1397 * 1398 * <pre> 1399 * An optional description of this resource. Provide this property when you create the resource. 1400 * </pre> 1401 * 1402 * <code>optional string description = 422937596;</code> 1403 * 1404 * @return The description. 1405 */ 1406 @java.lang.Override getDescription()1407 public java.lang.String getDescription() { 1408 java.lang.Object ref = description_; 1409 if (ref instanceof java.lang.String) { 1410 return (java.lang.String) ref; 1411 } else { 1412 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1413 java.lang.String s = bs.toStringUtf8(); 1414 description_ = s; 1415 return s; 1416 } 1417 } 1418 /** 1419 * 1420 * 1421 * <pre> 1422 * An optional description of this resource. Provide this property when you create the resource. 1423 * </pre> 1424 * 1425 * <code>optional string description = 422937596;</code> 1426 * 1427 * @return The bytes for description. 1428 */ 1429 @java.lang.Override getDescriptionBytes()1430 public com.google.protobuf.ByteString getDescriptionBytes() { 1431 java.lang.Object ref = description_; 1432 if (ref instanceof java.lang.String) { 1433 com.google.protobuf.ByteString b = 1434 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1435 description_ = b; 1436 return b; 1437 } else { 1438 return (com.google.protobuf.ByteString) ref; 1439 } 1440 } 1441 1442 public static final int FINGERPRINT_FIELD_NUMBER = 234678500; 1443 1444 @SuppressWarnings("serial") 1445 private volatile java.lang.Object fingerprint_ = ""; 1446 /** 1447 * 1448 * 1449 * <pre> 1450 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 1451 * </pre> 1452 * 1453 * <code>optional string fingerprint = 234678500;</code> 1454 * 1455 * @return Whether the fingerprint field is set. 1456 */ 1457 @java.lang.Override hasFingerprint()1458 public boolean hasFingerprint() { 1459 return ((bitField0_ & 0x00000100) != 0); 1460 } 1461 /** 1462 * 1463 * 1464 * <pre> 1465 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 1466 * </pre> 1467 * 1468 * <code>optional string fingerprint = 234678500;</code> 1469 * 1470 * @return The fingerprint. 1471 */ 1472 @java.lang.Override getFingerprint()1473 public java.lang.String getFingerprint() { 1474 java.lang.Object ref = fingerprint_; 1475 if (ref instanceof java.lang.String) { 1476 return (java.lang.String) ref; 1477 } else { 1478 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1479 java.lang.String s = bs.toStringUtf8(); 1480 fingerprint_ = s; 1481 return s; 1482 } 1483 } 1484 /** 1485 * 1486 * 1487 * <pre> 1488 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 1489 * </pre> 1490 * 1491 * <code>optional string fingerprint = 234678500;</code> 1492 * 1493 * @return The bytes for fingerprint. 1494 */ 1495 @java.lang.Override getFingerprintBytes()1496 public com.google.protobuf.ByteString getFingerprintBytes() { 1497 java.lang.Object ref = fingerprint_; 1498 if (ref instanceof java.lang.String) { 1499 com.google.protobuf.ByteString b = 1500 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1501 fingerprint_ = b; 1502 return b; 1503 } else { 1504 return (com.google.protobuf.ByteString) ref; 1505 } 1506 } 1507 1508 public static final int ID_FIELD_NUMBER = 3355; 1509 private long id_ = 0L; 1510 /** 1511 * 1512 * 1513 * <pre> 1514 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 1515 * </pre> 1516 * 1517 * <code>optional uint64 id = 3355;</code> 1518 * 1519 * @return Whether the id field is set. 1520 */ 1521 @java.lang.Override hasId()1522 public boolean hasId() { 1523 return ((bitField0_ & 0x00000200) != 0); 1524 } 1525 /** 1526 * 1527 * 1528 * <pre> 1529 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 1530 * </pre> 1531 * 1532 * <code>optional uint64 id = 3355;</code> 1533 * 1534 * @return The id. 1535 */ 1536 @java.lang.Override getId()1537 public long getId() { 1538 return id_; 1539 } 1540 1541 public static final int IP_VERSION_FIELD_NUMBER = 294959552; 1542 1543 @SuppressWarnings("serial") 1544 private volatile java.lang.Object ipVersion_ = ""; 1545 /** 1546 * 1547 * 1548 * <pre> 1549 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 1550 * Check the IpVersion enum for the list of possible values. 1551 * </pre> 1552 * 1553 * <code>optional string ip_version = 294959552;</code> 1554 * 1555 * @return Whether the ipVersion field is set. 1556 */ 1557 @java.lang.Override hasIpVersion()1558 public boolean hasIpVersion() { 1559 return ((bitField0_ & 0x00000400) != 0); 1560 } 1561 /** 1562 * 1563 * 1564 * <pre> 1565 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 1566 * Check the IpVersion enum for the list of possible values. 1567 * </pre> 1568 * 1569 * <code>optional string ip_version = 294959552;</code> 1570 * 1571 * @return The ipVersion. 1572 */ 1573 @java.lang.Override getIpVersion()1574 public java.lang.String getIpVersion() { 1575 java.lang.Object ref = ipVersion_; 1576 if (ref instanceof java.lang.String) { 1577 return (java.lang.String) ref; 1578 } else { 1579 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1580 java.lang.String s = bs.toStringUtf8(); 1581 ipVersion_ = s; 1582 return s; 1583 } 1584 } 1585 /** 1586 * 1587 * 1588 * <pre> 1589 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 1590 * Check the IpVersion enum for the list of possible values. 1591 * </pre> 1592 * 1593 * <code>optional string ip_version = 294959552;</code> 1594 * 1595 * @return The bytes for ipVersion. 1596 */ 1597 @java.lang.Override getIpVersionBytes()1598 public com.google.protobuf.ByteString getIpVersionBytes() { 1599 java.lang.Object ref = ipVersion_; 1600 if (ref instanceof java.lang.String) { 1601 com.google.protobuf.ByteString b = 1602 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1603 ipVersion_ = b; 1604 return b; 1605 } else { 1606 return (com.google.protobuf.ByteString) ref; 1607 } 1608 } 1609 1610 public static final int IS_MIRRORING_COLLECTOR_FIELD_NUMBER = 119255164; 1611 private boolean isMirroringCollector_ = false; 1612 /** 1613 * 1614 * 1615 * <pre> 1616 * Indicates whether or not this load balancer can be used as a collector for packet mirroring. To prevent mirroring loops, instances behind this load balancer will not have their traffic mirrored even if a PacketMirroring rule applies to them. This can only be set to true for load balancers that have their loadBalancingScheme set to INTERNAL. 1617 * </pre> 1618 * 1619 * <code>optional bool is_mirroring_collector = 119255164;</code> 1620 * 1621 * @return Whether the isMirroringCollector field is set. 1622 */ 1623 @java.lang.Override hasIsMirroringCollector()1624 public boolean hasIsMirroringCollector() { 1625 return ((bitField0_ & 0x00000800) != 0); 1626 } 1627 /** 1628 * 1629 * 1630 * <pre> 1631 * Indicates whether or not this load balancer can be used as a collector for packet mirroring. To prevent mirroring loops, instances behind this load balancer will not have their traffic mirrored even if a PacketMirroring rule applies to them. This can only be set to true for load balancers that have their loadBalancingScheme set to INTERNAL. 1632 * </pre> 1633 * 1634 * <code>optional bool is_mirroring_collector = 119255164;</code> 1635 * 1636 * @return The isMirroringCollector. 1637 */ 1638 @java.lang.Override getIsMirroringCollector()1639 public boolean getIsMirroringCollector() { 1640 return isMirroringCollector_; 1641 } 1642 1643 public static final int KIND_FIELD_NUMBER = 3292052; 1644 1645 @SuppressWarnings("serial") 1646 private volatile java.lang.Object kind_ = ""; 1647 /** 1648 * 1649 * 1650 * <pre> 1651 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 1652 * </pre> 1653 * 1654 * <code>optional string kind = 3292052;</code> 1655 * 1656 * @return Whether the kind field is set. 1657 */ 1658 @java.lang.Override hasKind()1659 public boolean hasKind() { 1660 return ((bitField0_ & 0x00001000) != 0); 1661 } 1662 /** 1663 * 1664 * 1665 * <pre> 1666 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 1667 * </pre> 1668 * 1669 * <code>optional string kind = 3292052;</code> 1670 * 1671 * @return The kind. 1672 */ 1673 @java.lang.Override getKind()1674 public java.lang.String getKind() { 1675 java.lang.Object ref = kind_; 1676 if (ref instanceof java.lang.String) { 1677 return (java.lang.String) ref; 1678 } else { 1679 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1680 java.lang.String s = bs.toStringUtf8(); 1681 kind_ = s; 1682 return s; 1683 } 1684 } 1685 /** 1686 * 1687 * 1688 * <pre> 1689 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 1690 * </pre> 1691 * 1692 * <code>optional string kind = 3292052;</code> 1693 * 1694 * @return The bytes for kind. 1695 */ 1696 @java.lang.Override getKindBytes()1697 public com.google.protobuf.ByteString getKindBytes() { 1698 java.lang.Object ref = kind_; 1699 if (ref instanceof java.lang.String) { 1700 com.google.protobuf.ByteString b = 1701 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1702 kind_ = b; 1703 return b; 1704 } else { 1705 return (com.google.protobuf.ByteString) ref; 1706 } 1707 } 1708 1709 public static final int LABEL_FINGERPRINT_FIELD_NUMBER = 178124825; 1710 1711 @SuppressWarnings("serial") 1712 private volatile java.lang.Object labelFingerprint_ = ""; 1713 /** 1714 * 1715 * 1716 * <pre> 1717 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 1718 * </pre> 1719 * 1720 * <code>optional string label_fingerprint = 178124825;</code> 1721 * 1722 * @return Whether the labelFingerprint field is set. 1723 */ 1724 @java.lang.Override hasLabelFingerprint()1725 public boolean hasLabelFingerprint() { 1726 return ((bitField0_ & 0x00002000) != 0); 1727 } 1728 /** 1729 * 1730 * 1731 * <pre> 1732 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 1733 * </pre> 1734 * 1735 * <code>optional string label_fingerprint = 178124825;</code> 1736 * 1737 * @return The labelFingerprint. 1738 */ 1739 @java.lang.Override getLabelFingerprint()1740 public java.lang.String getLabelFingerprint() { 1741 java.lang.Object ref = labelFingerprint_; 1742 if (ref instanceof java.lang.String) { 1743 return (java.lang.String) ref; 1744 } else { 1745 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1746 java.lang.String s = bs.toStringUtf8(); 1747 labelFingerprint_ = s; 1748 return s; 1749 } 1750 } 1751 /** 1752 * 1753 * 1754 * <pre> 1755 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 1756 * </pre> 1757 * 1758 * <code>optional string label_fingerprint = 178124825;</code> 1759 * 1760 * @return The bytes for labelFingerprint. 1761 */ 1762 @java.lang.Override getLabelFingerprintBytes()1763 public com.google.protobuf.ByteString getLabelFingerprintBytes() { 1764 java.lang.Object ref = labelFingerprint_; 1765 if (ref instanceof java.lang.String) { 1766 com.google.protobuf.ByteString b = 1767 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1768 labelFingerprint_ = b; 1769 return b; 1770 } else { 1771 return (com.google.protobuf.ByteString) ref; 1772 } 1773 } 1774 1775 public static final int LABELS_FIELD_NUMBER = 500195327; 1776 1777 private static final class LabelsDefaultEntryHolder { 1778 static final com.google.protobuf.MapEntry<java.lang.String, java.lang.String> defaultEntry = 1779 com.google.protobuf.MapEntry.<java.lang.String, java.lang.String>newDefaultInstance( 1780 com.google.cloud.compute.v1.Compute 1781 .internal_static_google_cloud_compute_v1_ForwardingRule_LabelsEntry_descriptor, 1782 com.google.protobuf.WireFormat.FieldType.STRING, 1783 "", 1784 com.google.protobuf.WireFormat.FieldType.STRING, 1785 ""); 1786 } 1787 1788 @SuppressWarnings("serial") 1789 private com.google.protobuf.MapField<java.lang.String, java.lang.String> labels_; 1790 internalGetLabels()1791 private com.google.protobuf.MapField<java.lang.String, java.lang.String> internalGetLabels() { 1792 if (labels_ == null) { 1793 return com.google.protobuf.MapField.emptyMapField(LabelsDefaultEntryHolder.defaultEntry); 1794 } 1795 return labels_; 1796 } 1797 getLabelsCount()1798 public int getLabelsCount() { 1799 return internalGetLabels().getMap().size(); 1800 } 1801 /** 1802 * 1803 * 1804 * <pre> 1805 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 1806 * </pre> 1807 * 1808 * <code>map<string, string> labels = 500195327;</code> 1809 */ 1810 @java.lang.Override containsLabels(java.lang.String key)1811 public boolean containsLabels(java.lang.String key) { 1812 if (key == null) { 1813 throw new NullPointerException("map key"); 1814 } 1815 return internalGetLabels().getMap().containsKey(key); 1816 } 1817 /** Use {@link #getLabelsMap()} instead. */ 1818 @java.lang.Override 1819 @java.lang.Deprecated getLabels()1820 public java.util.Map<java.lang.String, java.lang.String> getLabels() { 1821 return getLabelsMap(); 1822 } 1823 /** 1824 * 1825 * 1826 * <pre> 1827 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 1828 * </pre> 1829 * 1830 * <code>map<string, string> labels = 500195327;</code> 1831 */ 1832 @java.lang.Override getLabelsMap()1833 public java.util.Map<java.lang.String, java.lang.String> getLabelsMap() { 1834 return internalGetLabels().getMap(); 1835 } 1836 /** 1837 * 1838 * 1839 * <pre> 1840 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 1841 * </pre> 1842 * 1843 * <code>map<string, string> labels = 500195327;</code> 1844 */ 1845 @java.lang.Override getLabelsOrDefault( java.lang.String key, java.lang.String defaultValue)1846 public /* nullable */ java.lang.String getLabelsOrDefault( 1847 java.lang.String key, 1848 /* nullable */ 1849 java.lang.String defaultValue) { 1850 if (key == null) { 1851 throw new NullPointerException("map key"); 1852 } 1853 java.util.Map<java.lang.String, java.lang.String> map = internalGetLabels().getMap(); 1854 return map.containsKey(key) ? map.get(key) : defaultValue; 1855 } 1856 /** 1857 * 1858 * 1859 * <pre> 1860 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 1861 * </pre> 1862 * 1863 * <code>map<string, string> labels = 500195327;</code> 1864 */ 1865 @java.lang.Override getLabelsOrThrow(java.lang.String key)1866 public java.lang.String getLabelsOrThrow(java.lang.String key) { 1867 if (key == null) { 1868 throw new NullPointerException("map key"); 1869 } 1870 java.util.Map<java.lang.String, java.lang.String> map = internalGetLabels().getMap(); 1871 if (!map.containsKey(key)) { 1872 throw new java.lang.IllegalArgumentException(); 1873 } 1874 return map.get(key); 1875 } 1876 1877 public static final int LOAD_BALANCING_SCHEME_FIELD_NUMBER = 363890244; 1878 1879 @SuppressWarnings("serial") 1880 private volatile java.lang.Object loadBalancingScheme_ = ""; 1881 /** 1882 * 1883 * 1884 * <pre> 1885 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 1886 * Check the LoadBalancingScheme enum for the list of possible values. 1887 * </pre> 1888 * 1889 * <code>optional string load_balancing_scheme = 363890244;</code> 1890 * 1891 * @return Whether the loadBalancingScheme field is set. 1892 */ 1893 @java.lang.Override hasLoadBalancingScheme()1894 public boolean hasLoadBalancingScheme() { 1895 return ((bitField0_ & 0x00004000) != 0); 1896 } 1897 /** 1898 * 1899 * 1900 * <pre> 1901 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 1902 * Check the LoadBalancingScheme enum for the list of possible values. 1903 * </pre> 1904 * 1905 * <code>optional string load_balancing_scheme = 363890244;</code> 1906 * 1907 * @return The loadBalancingScheme. 1908 */ 1909 @java.lang.Override getLoadBalancingScheme()1910 public java.lang.String getLoadBalancingScheme() { 1911 java.lang.Object ref = loadBalancingScheme_; 1912 if (ref instanceof java.lang.String) { 1913 return (java.lang.String) ref; 1914 } else { 1915 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1916 java.lang.String s = bs.toStringUtf8(); 1917 loadBalancingScheme_ = s; 1918 return s; 1919 } 1920 } 1921 /** 1922 * 1923 * 1924 * <pre> 1925 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 1926 * Check the LoadBalancingScheme enum for the list of possible values. 1927 * </pre> 1928 * 1929 * <code>optional string load_balancing_scheme = 363890244;</code> 1930 * 1931 * @return The bytes for loadBalancingScheme. 1932 */ 1933 @java.lang.Override getLoadBalancingSchemeBytes()1934 public com.google.protobuf.ByteString getLoadBalancingSchemeBytes() { 1935 java.lang.Object ref = loadBalancingScheme_; 1936 if (ref instanceof java.lang.String) { 1937 com.google.protobuf.ByteString b = 1938 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1939 loadBalancingScheme_ = b; 1940 return b; 1941 } else { 1942 return (com.google.protobuf.ByteString) ref; 1943 } 1944 } 1945 1946 public static final int METADATA_FILTERS_FIELD_NUMBER = 464725739; 1947 1948 @SuppressWarnings("serial") 1949 private java.util.List<com.google.cloud.compute.v1.MetadataFilter> metadataFilters_; 1950 /** 1951 * 1952 * 1953 * <pre> 1954 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 1955 * </pre> 1956 * 1957 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 1958 */ 1959 @java.lang.Override getMetadataFiltersList()1960 public java.util.List<com.google.cloud.compute.v1.MetadataFilter> getMetadataFiltersList() { 1961 return metadataFilters_; 1962 } 1963 /** 1964 * 1965 * 1966 * <pre> 1967 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 1968 * </pre> 1969 * 1970 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 1971 */ 1972 @java.lang.Override 1973 public java.util.List<? extends com.google.cloud.compute.v1.MetadataFilterOrBuilder> getMetadataFiltersOrBuilderList()1974 getMetadataFiltersOrBuilderList() { 1975 return metadataFilters_; 1976 } 1977 /** 1978 * 1979 * 1980 * <pre> 1981 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 1982 * </pre> 1983 * 1984 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 1985 */ 1986 @java.lang.Override getMetadataFiltersCount()1987 public int getMetadataFiltersCount() { 1988 return metadataFilters_.size(); 1989 } 1990 /** 1991 * 1992 * 1993 * <pre> 1994 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 1995 * </pre> 1996 * 1997 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 1998 */ 1999 @java.lang.Override getMetadataFilters(int index)2000 public com.google.cloud.compute.v1.MetadataFilter getMetadataFilters(int index) { 2001 return metadataFilters_.get(index); 2002 } 2003 /** 2004 * 2005 * 2006 * <pre> 2007 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 2008 * </pre> 2009 * 2010 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 2011 */ 2012 @java.lang.Override getMetadataFiltersOrBuilder( int index)2013 public com.google.cloud.compute.v1.MetadataFilterOrBuilder getMetadataFiltersOrBuilder( 2014 int index) { 2015 return metadataFilters_.get(index); 2016 } 2017 2018 public static final int NAME_FIELD_NUMBER = 3373707; 2019 2020 @SuppressWarnings("serial") 2021 private volatile java.lang.Object name_ = ""; 2022 /** 2023 * 2024 * 2025 * <pre> 2026 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 2027 * </pre> 2028 * 2029 * <code>optional string name = 3373707;</code> 2030 * 2031 * @return Whether the name field is set. 2032 */ 2033 @java.lang.Override hasName()2034 public boolean hasName() { 2035 return ((bitField0_ & 0x00008000) != 0); 2036 } 2037 /** 2038 * 2039 * 2040 * <pre> 2041 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 2042 * </pre> 2043 * 2044 * <code>optional string name = 3373707;</code> 2045 * 2046 * @return The name. 2047 */ 2048 @java.lang.Override getName()2049 public java.lang.String getName() { 2050 java.lang.Object ref = name_; 2051 if (ref instanceof java.lang.String) { 2052 return (java.lang.String) ref; 2053 } else { 2054 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2055 java.lang.String s = bs.toStringUtf8(); 2056 name_ = s; 2057 return s; 2058 } 2059 } 2060 /** 2061 * 2062 * 2063 * <pre> 2064 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 2065 * </pre> 2066 * 2067 * <code>optional string name = 3373707;</code> 2068 * 2069 * @return The bytes for name. 2070 */ 2071 @java.lang.Override getNameBytes()2072 public com.google.protobuf.ByteString getNameBytes() { 2073 java.lang.Object ref = name_; 2074 if (ref instanceof java.lang.String) { 2075 com.google.protobuf.ByteString b = 2076 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2077 name_ = b; 2078 return b; 2079 } else { 2080 return (com.google.protobuf.ByteString) ref; 2081 } 2082 } 2083 2084 public static final int NETWORK_FIELD_NUMBER = 232872494; 2085 2086 @SuppressWarnings("serial") 2087 private volatile java.lang.Object network_ = ""; 2088 /** 2089 * 2090 * 2091 * <pre> 2092 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 2093 * </pre> 2094 * 2095 * <code>optional string network = 232872494;</code> 2096 * 2097 * @return Whether the network field is set. 2098 */ 2099 @java.lang.Override hasNetwork()2100 public boolean hasNetwork() { 2101 return ((bitField0_ & 0x00010000) != 0); 2102 } 2103 /** 2104 * 2105 * 2106 * <pre> 2107 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 2108 * </pre> 2109 * 2110 * <code>optional string network = 232872494;</code> 2111 * 2112 * @return The network. 2113 */ 2114 @java.lang.Override getNetwork()2115 public java.lang.String getNetwork() { 2116 java.lang.Object ref = network_; 2117 if (ref instanceof java.lang.String) { 2118 return (java.lang.String) ref; 2119 } else { 2120 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2121 java.lang.String s = bs.toStringUtf8(); 2122 network_ = s; 2123 return s; 2124 } 2125 } 2126 /** 2127 * 2128 * 2129 * <pre> 2130 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 2131 * </pre> 2132 * 2133 * <code>optional string network = 232872494;</code> 2134 * 2135 * @return The bytes for network. 2136 */ 2137 @java.lang.Override getNetworkBytes()2138 public com.google.protobuf.ByteString getNetworkBytes() { 2139 java.lang.Object ref = network_; 2140 if (ref instanceof java.lang.String) { 2141 com.google.protobuf.ByteString b = 2142 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2143 network_ = b; 2144 return b; 2145 } else { 2146 return (com.google.protobuf.ByteString) ref; 2147 } 2148 } 2149 2150 public static final int NETWORK_TIER_FIELD_NUMBER = 517397843; 2151 2152 @SuppressWarnings("serial") 2153 private volatile java.lang.Object networkTier_ = ""; 2154 /** 2155 * 2156 * 2157 * <pre> 2158 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 2159 * Check the NetworkTier enum for the list of possible values. 2160 * </pre> 2161 * 2162 * <code>optional string network_tier = 517397843;</code> 2163 * 2164 * @return Whether the networkTier field is set. 2165 */ 2166 @java.lang.Override hasNetworkTier()2167 public boolean hasNetworkTier() { 2168 return ((bitField0_ & 0x00020000) != 0); 2169 } 2170 /** 2171 * 2172 * 2173 * <pre> 2174 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 2175 * Check the NetworkTier enum for the list of possible values. 2176 * </pre> 2177 * 2178 * <code>optional string network_tier = 517397843;</code> 2179 * 2180 * @return The networkTier. 2181 */ 2182 @java.lang.Override getNetworkTier()2183 public java.lang.String getNetworkTier() { 2184 java.lang.Object ref = networkTier_; 2185 if (ref instanceof java.lang.String) { 2186 return (java.lang.String) ref; 2187 } else { 2188 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2189 java.lang.String s = bs.toStringUtf8(); 2190 networkTier_ = s; 2191 return s; 2192 } 2193 } 2194 /** 2195 * 2196 * 2197 * <pre> 2198 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 2199 * Check the NetworkTier enum for the list of possible values. 2200 * </pre> 2201 * 2202 * <code>optional string network_tier = 517397843;</code> 2203 * 2204 * @return The bytes for networkTier. 2205 */ 2206 @java.lang.Override getNetworkTierBytes()2207 public com.google.protobuf.ByteString getNetworkTierBytes() { 2208 java.lang.Object ref = networkTier_; 2209 if (ref instanceof java.lang.String) { 2210 com.google.protobuf.ByteString b = 2211 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2212 networkTier_ = b; 2213 return b; 2214 } else { 2215 return (com.google.protobuf.ByteString) ref; 2216 } 2217 } 2218 2219 public static final int NO_AUTOMATE_DNS_ZONE_FIELD_NUMBER = 64546991; 2220 private boolean noAutomateDnsZone_ = false; 2221 /** 2222 * 2223 * 2224 * <pre> 2225 * This is used in PSC consumer ForwardingRule to control whether it should try to auto-generate a DNS zone or not. Non-PSC forwarding rules do not use this field. 2226 * </pre> 2227 * 2228 * <code>optional bool no_automate_dns_zone = 64546991;</code> 2229 * 2230 * @return Whether the noAutomateDnsZone field is set. 2231 */ 2232 @java.lang.Override hasNoAutomateDnsZone()2233 public boolean hasNoAutomateDnsZone() { 2234 return ((bitField0_ & 0x00040000) != 0); 2235 } 2236 /** 2237 * 2238 * 2239 * <pre> 2240 * This is used in PSC consumer ForwardingRule to control whether it should try to auto-generate a DNS zone or not. Non-PSC forwarding rules do not use this field. 2241 * </pre> 2242 * 2243 * <code>optional bool no_automate_dns_zone = 64546991;</code> 2244 * 2245 * @return The noAutomateDnsZone. 2246 */ 2247 @java.lang.Override getNoAutomateDnsZone()2248 public boolean getNoAutomateDnsZone() { 2249 return noAutomateDnsZone_; 2250 } 2251 2252 public static final int PORT_RANGE_FIELD_NUMBER = 217518079; 2253 2254 @SuppressWarnings("serial") 2255 private volatile java.lang.Object portRange_ = ""; 2256 /** 2257 * 2258 * 2259 * <pre> 2260 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 2261 * </pre> 2262 * 2263 * <code>optional string port_range = 217518079;</code> 2264 * 2265 * @return Whether the portRange field is set. 2266 */ 2267 @java.lang.Override hasPortRange()2268 public boolean hasPortRange() { 2269 return ((bitField0_ & 0x00080000) != 0); 2270 } 2271 /** 2272 * 2273 * 2274 * <pre> 2275 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 2276 * </pre> 2277 * 2278 * <code>optional string port_range = 217518079;</code> 2279 * 2280 * @return The portRange. 2281 */ 2282 @java.lang.Override getPortRange()2283 public java.lang.String getPortRange() { 2284 java.lang.Object ref = portRange_; 2285 if (ref instanceof java.lang.String) { 2286 return (java.lang.String) ref; 2287 } else { 2288 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2289 java.lang.String s = bs.toStringUtf8(); 2290 portRange_ = s; 2291 return s; 2292 } 2293 } 2294 /** 2295 * 2296 * 2297 * <pre> 2298 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 2299 * </pre> 2300 * 2301 * <code>optional string port_range = 217518079;</code> 2302 * 2303 * @return The bytes for portRange. 2304 */ 2305 @java.lang.Override getPortRangeBytes()2306 public com.google.protobuf.ByteString getPortRangeBytes() { 2307 java.lang.Object ref = portRange_; 2308 if (ref instanceof java.lang.String) { 2309 com.google.protobuf.ByteString b = 2310 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2311 portRange_ = b; 2312 return b; 2313 } else { 2314 return (com.google.protobuf.ByteString) ref; 2315 } 2316 } 2317 2318 public static final int PORTS_FIELD_NUMBER = 106854418; 2319 2320 @SuppressWarnings("serial") 2321 private com.google.protobuf.LazyStringList ports_; 2322 /** 2323 * 2324 * 2325 * <pre> 2326 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 2327 * </pre> 2328 * 2329 * <code>repeated string ports = 106854418;</code> 2330 * 2331 * @return A list containing the ports. 2332 */ getPortsList()2333 public com.google.protobuf.ProtocolStringList getPortsList() { 2334 return ports_; 2335 } 2336 /** 2337 * 2338 * 2339 * <pre> 2340 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 2341 * </pre> 2342 * 2343 * <code>repeated string ports = 106854418;</code> 2344 * 2345 * @return The count of ports. 2346 */ getPortsCount()2347 public int getPortsCount() { 2348 return ports_.size(); 2349 } 2350 /** 2351 * 2352 * 2353 * <pre> 2354 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 2355 * </pre> 2356 * 2357 * <code>repeated string ports = 106854418;</code> 2358 * 2359 * @param index The index of the element to return. 2360 * @return The ports at the given index. 2361 */ getPorts(int index)2362 public java.lang.String getPorts(int index) { 2363 return ports_.get(index); 2364 } 2365 /** 2366 * 2367 * 2368 * <pre> 2369 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 2370 * </pre> 2371 * 2372 * <code>repeated string ports = 106854418;</code> 2373 * 2374 * @param index The index of the value to return. 2375 * @return The bytes of the ports at the given index. 2376 */ getPortsBytes(int index)2377 public com.google.protobuf.ByteString getPortsBytes(int index) { 2378 return ports_.getByteString(index); 2379 } 2380 2381 public static final int PSC_CONNECTION_ID_FIELD_NUMBER = 292082397; 2382 private long pscConnectionId_ = 0L; 2383 /** 2384 * 2385 * 2386 * <pre> 2387 * [Output Only] The PSC connection id of the PSC Forwarding Rule. 2388 * </pre> 2389 * 2390 * <code>optional uint64 psc_connection_id = 292082397;</code> 2391 * 2392 * @return Whether the pscConnectionId field is set. 2393 */ 2394 @java.lang.Override hasPscConnectionId()2395 public boolean hasPscConnectionId() { 2396 return ((bitField0_ & 0x00100000) != 0); 2397 } 2398 /** 2399 * 2400 * 2401 * <pre> 2402 * [Output Only] The PSC connection id of the PSC Forwarding Rule. 2403 * </pre> 2404 * 2405 * <code>optional uint64 psc_connection_id = 292082397;</code> 2406 * 2407 * @return The pscConnectionId. 2408 */ 2409 @java.lang.Override getPscConnectionId()2410 public long getPscConnectionId() { 2411 return pscConnectionId_; 2412 } 2413 2414 public static final int PSC_CONNECTION_STATUS_FIELD_NUMBER = 184149172; 2415 2416 @SuppressWarnings("serial") 2417 private volatile java.lang.Object pscConnectionStatus_ = ""; 2418 /** 2419 * 2420 * 2421 * <pre> 2422 * 2423 * Check the PscConnectionStatus enum for the list of possible values. 2424 * </pre> 2425 * 2426 * <code>optional string psc_connection_status = 184149172;</code> 2427 * 2428 * @return Whether the pscConnectionStatus field is set. 2429 */ 2430 @java.lang.Override hasPscConnectionStatus()2431 public boolean hasPscConnectionStatus() { 2432 return ((bitField0_ & 0x00200000) != 0); 2433 } 2434 /** 2435 * 2436 * 2437 * <pre> 2438 * 2439 * Check the PscConnectionStatus enum for the list of possible values. 2440 * </pre> 2441 * 2442 * <code>optional string psc_connection_status = 184149172;</code> 2443 * 2444 * @return The pscConnectionStatus. 2445 */ 2446 @java.lang.Override getPscConnectionStatus()2447 public java.lang.String getPscConnectionStatus() { 2448 java.lang.Object ref = pscConnectionStatus_; 2449 if (ref instanceof java.lang.String) { 2450 return (java.lang.String) ref; 2451 } else { 2452 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2453 java.lang.String s = bs.toStringUtf8(); 2454 pscConnectionStatus_ = s; 2455 return s; 2456 } 2457 } 2458 /** 2459 * 2460 * 2461 * <pre> 2462 * 2463 * Check the PscConnectionStatus enum for the list of possible values. 2464 * </pre> 2465 * 2466 * <code>optional string psc_connection_status = 184149172;</code> 2467 * 2468 * @return The bytes for pscConnectionStatus. 2469 */ 2470 @java.lang.Override getPscConnectionStatusBytes()2471 public com.google.protobuf.ByteString getPscConnectionStatusBytes() { 2472 java.lang.Object ref = pscConnectionStatus_; 2473 if (ref instanceof java.lang.String) { 2474 com.google.protobuf.ByteString b = 2475 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2476 pscConnectionStatus_ = b; 2477 return b; 2478 } else { 2479 return (com.google.protobuf.ByteString) ref; 2480 } 2481 } 2482 2483 public static final int REGION_FIELD_NUMBER = 138946292; 2484 2485 @SuppressWarnings("serial") 2486 private volatile java.lang.Object region_ = ""; 2487 /** 2488 * 2489 * 2490 * <pre> 2491 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 2492 * </pre> 2493 * 2494 * <code>optional string region = 138946292;</code> 2495 * 2496 * @return Whether the region field is set. 2497 */ 2498 @java.lang.Override hasRegion()2499 public boolean hasRegion() { 2500 return ((bitField0_ & 0x00400000) != 0); 2501 } 2502 /** 2503 * 2504 * 2505 * <pre> 2506 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 2507 * </pre> 2508 * 2509 * <code>optional string region = 138946292;</code> 2510 * 2511 * @return The region. 2512 */ 2513 @java.lang.Override getRegion()2514 public java.lang.String getRegion() { 2515 java.lang.Object ref = region_; 2516 if (ref instanceof java.lang.String) { 2517 return (java.lang.String) ref; 2518 } else { 2519 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2520 java.lang.String s = bs.toStringUtf8(); 2521 region_ = s; 2522 return s; 2523 } 2524 } 2525 /** 2526 * 2527 * 2528 * <pre> 2529 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 2530 * </pre> 2531 * 2532 * <code>optional string region = 138946292;</code> 2533 * 2534 * @return The bytes for region. 2535 */ 2536 @java.lang.Override getRegionBytes()2537 public com.google.protobuf.ByteString getRegionBytes() { 2538 java.lang.Object ref = region_; 2539 if (ref instanceof java.lang.String) { 2540 com.google.protobuf.ByteString b = 2541 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2542 region_ = b; 2543 return b; 2544 } else { 2545 return (com.google.protobuf.ByteString) ref; 2546 } 2547 } 2548 2549 public static final int SELF_LINK_FIELD_NUMBER = 456214797; 2550 2551 @SuppressWarnings("serial") 2552 private volatile java.lang.Object selfLink_ = ""; 2553 /** 2554 * 2555 * 2556 * <pre> 2557 * [Output Only] Server-defined URL for the resource. 2558 * </pre> 2559 * 2560 * <code>optional string self_link = 456214797;</code> 2561 * 2562 * @return Whether the selfLink field is set. 2563 */ 2564 @java.lang.Override hasSelfLink()2565 public boolean hasSelfLink() { 2566 return ((bitField0_ & 0x00800000) != 0); 2567 } 2568 /** 2569 * 2570 * 2571 * <pre> 2572 * [Output Only] Server-defined URL for the resource. 2573 * </pre> 2574 * 2575 * <code>optional string self_link = 456214797;</code> 2576 * 2577 * @return The selfLink. 2578 */ 2579 @java.lang.Override getSelfLink()2580 public java.lang.String getSelfLink() { 2581 java.lang.Object ref = selfLink_; 2582 if (ref instanceof java.lang.String) { 2583 return (java.lang.String) ref; 2584 } else { 2585 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2586 java.lang.String s = bs.toStringUtf8(); 2587 selfLink_ = s; 2588 return s; 2589 } 2590 } 2591 /** 2592 * 2593 * 2594 * <pre> 2595 * [Output Only] Server-defined URL for the resource. 2596 * </pre> 2597 * 2598 * <code>optional string self_link = 456214797;</code> 2599 * 2600 * @return The bytes for selfLink. 2601 */ 2602 @java.lang.Override getSelfLinkBytes()2603 public com.google.protobuf.ByteString getSelfLinkBytes() { 2604 java.lang.Object ref = selfLink_; 2605 if (ref instanceof java.lang.String) { 2606 com.google.protobuf.ByteString b = 2607 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2608 selfLink_ = b; 2609 return b; 2610 } else { 2611 return (com.google.protobuf.ByteString) ref; 2612 } 2613 } 2614 2615 public static final int SERVICE_DIRECTORY_REGISTRATIONS_FIELD_NUMBER = 223549694; 2616 2617 @SuppressWarnings("serial") 2618 private java.util.List<com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration> 2619 serviceDirectoryRegistrations_; 2620 /** 2621 * 2622 * 2623 * <pre> 2624 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 2625 * </pre> 2626 * 2627 * <code> 2628 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 2629 * </code> 2630 */ 2631 @java.lang.Override 2632 public java.util.List<com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration> getServiceDirectoryRegistrationsList()2633 getServiceDirectoryRegistrationsList() { 2634 return serviceDirectoryRegistrations_; 2635 } 2636 /** 2637 * 2638 * 2639 * <pre> 2640 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 2641 * </pre> 2642 * 2643 * <code> 2644 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 2645 * </code> 2646 */ 2647 @java.lang.Override 2648 public java.util.List< 2649 ? extends com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistrationOrBuilder> getServiceDirectoryRegistrationsOrBuilderList()2650 getServiceDirectoryRegistrationsOrBuilderList() { 2651 return serviceDirectoryRegistrations_; 2652 } 2653 /** 2654 * 2655 * 2656 * <pre> 2657 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 2658 * </pre> 2659 * 2660 * <code> 2661 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 2662 * </code> 2663 */ 2664 @java.lang.Override getServiceDirectoryRegistrationsCount()2665 public int getServiceDirectoryRegistrationsCount() { 2666 return serviceDirectoryRegistrations_.size(); 2667 } 2668 /** 2669 * 2670 * 2671 * <pre> 2672 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 2673 * </pre> 2674 * 2675 * <code> 2676 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 2677 * </code> 2678 */ 2679 @java.lang.Override 2680 public com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration getServiceDirectoryRegistrations(int index)2681 getServiceDirectoryRegistrations(int index) { 2682 return serviceDirectoryRegistrations_.get(index); 2683 } 2684 /** 2685 * 2686 * 2687 * <pre> 2688 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 2689 * </pre> 2690 * 2691 * <code> 2692 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 2693 * </code> 2694 */ 2695 @java.lang.Override 2696 public com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistrationOrBuilder getServiceDirectoryRegistrationsOrBuilder(int index)2697 getServiceDirectoryRegistrationsOrBuilder(int index) { 2698 return serviceDirectoryRegistrations_.get(index); 2699 } 2700 2701 public static final int SERVICE_LABEL_FIELD_NUMBER = 417008874; 2702 2703 @SuppressWarnings("serial") 2704 private volatile java.lang.Object serviceLabel_ = ""; 2705 /** 2706 * 2707 * 2708 * <pre> 2709 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 2710 * </pre> 2711 * 2712 * <code>optional string service_label = 417008874;</code> 2713 * 2714 * @return Whether the serviceLabel field is set. 2715 */ 2716 @java.lang.Override hasServiceLabel()2717 public boolean hasServiceLabel() { 2718 return ((bitField0_ & 0x01000000) != 0); 2719 } 2720 /** 2721 * 2722 * 2723 * <pre> 2724 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 2725 * </pre> 2726 * 2727 * <code>optional string service_label = 417008874;</code> 2728 * 2729 * @return The serviceLabel. 2730 */ 2731 @java.lang.Override getServiceLabel()2732 public java.lang.String getServiceLabel() { 2733 java.lang.Object ref = serviceLabel_; 2734 if (ref instanceof java.lang.String) { 2735 return (java.lang.String) ref; 2736 } else { 2737 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2738 java.lang.String s = bs.toStringUtf8(); 2739 serviceLabel_ = s; 2740 return s; 2741 } 2742 } 2743 /** 2744 * 2745 * 2746 * <pre> 2747 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 2748 * </pre> 2749 * 2750 * <code>optional string service_label = 417008874;</code> 2751 * 2752 * @return The bytes for serviceLabel. 2753 */ 2754 @java.lang.Override getServiceLabelBytes()2755 public com.google.protobuf.ByteString getServiceLabelBytes() { 2756 java.lang.Object ref = serviceLabel_; 2757 if (ref instanceof java.lang.String) { 2758 com.google.protobuf.ByteString b = 2759 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2760 serviceLabel_ = b; 2761 return b; 2762 } else { 2763 return (com.google.protobuf.ByteString) ref; 2764 } 2765 } 2766 2767 public static final int SERVICE_NAME_FIELD_NUMBER = 359880149; 2768 2769 @SuppressWarnings("serial") 2770 private volatile java.lang.Object serviceName_ = ""; 2771 /** 2772 * 2773 * 2774 * <pre> 2775 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 2776 * </pre> 2777 * 2778 * <code>optional string service_name = 359880149;</code> 2779 * 2780 * @return Whether the serviceName field is set. 2781 */ 2782 @java.lang.Override hasServiceName()2783 public boolean hasServiceName() { 2784 return ((bitField0_ & 0x02000000) != 0); 2785 } 2786 /** 2787 * 2788 * 2789 * <pre> 2790 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 2791 * </pre> 2792 * 2793 * <code>optional string service_name = 359880149;</code> 2794 * 2795 * @return The serviceName. 2796 */ 2797 @java.lang.Override getServiceName()2798 public java.lang.String getServiceName() { 2799 java.lang.Object ref = serviceName_; 2800 if (ref instanceof java.lang.String) { 2801 return (java.lang.String) ref; 2802 } else { 2803 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2804 java.lang.String s = bs.toStringUtf8(); 2805 serviceName_ = s; 2806 return s; 2807 } 2808 } 2809 /** 2810 * 2811 * 2812 * <pre> 2813 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 2814 * </pre> 2815 * 2816 * <code>optional string service_name = 359880149;</code> 2817 * 2818 * @return The bytes for serviceName. 2819 */ 2820 @java.lang.Override getServiceNameBytes()2821 public com.google.protobuf.ByteString getServiceNameBytes() { 2822 java.lang.Object ref = serviceName_; 2823 if (ref instanceof java.lang.String) { 2824 com.google.protobuf.ByteString b = 2825 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2826 serviceName_ = b; 2827 return b; 2828 } else { 2829 return (com.google.protobuf.ByteString) ref; 2830 } 2831 } 2832 2833 public static final int SOURCE_IP_RANGES_FIELD_NUMBER = 111563210; 2834 2835 @SuppressWarnings("serial") 2836 private com.google.protobuf.LazyStringList sourceIpRanges_; 2837 /** 2838 * 2839 * 2840 * <pre> 2841 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 2842 * </pre> 2843 * 2844 * <code>repeated string source_ip_ranges = 111563210;</code> 2845 * 2846 * @return A list containing the sourceIpRanges. 2847 */ getSourceIpRangesList()2848 public com.google.protobuf.ProtocolStringList getSourceIpRangesList() { 2849 return sourceIpRanges_; 2850 } 2851 /** 2852 * 2853 * 2854 * <pre> 2855 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 2856 * </pre> 2857 * 2858 * <code>repeated string source_ip_ranges = 111563210;</code> 2859 * 2860 * @return The count of sourceIpRanges. 2861 */ getSourceIpRangesCount()2862 public int getSourceIpRangesCount() { 2863 return sourceIpRanges_.size(); 2864 } 2865 /** 2866 * 2867 * 2868 * <pre> 2869 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 2870 * </pre> 2871 * 2872 * <code>repeated string source_ip_ranges = 111563210;</code> 2873 * 2874 * @param index The index of the element to return. 2875 * @return The sourceIpRanges at the given index. 2876 */ getSourceIpRanges(int index)2877 public java.lang.String getSourceIpRanges(int index) { 2878 return sourceIpRanges_.get(index); 2879 } 2880 /** 2881 * 2882 * 2883 * <pre> 2884 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 2885 * </pre> 2886 * 2887 * <code>repeated string source_ip_ranges = 111563210;</code> 2888 * 2889 * @param index The index of the value to return. 2890 * @return The bytes of the sourceIpRanges at the given index. 2891 */ getSourceIpRangesBytes(int index)2892 public com.google.protobuf.ByteString getSourceIpRangesBytes(int index) { 2893 return sourceIpRanges_.getByteString(index); 2894 } 2895 2896 public static final int SUBNETWORK_FIELD_NUMBER = 307827694; 2897 2898 @SuppressWarnings("serial") 2899 private volatile java.lang.Object subnetwork_ = ""; 2900 /** 2901 * 2902 * 2903 * <pre> 2904 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 2905 * </pre> 2906 * 2907 * <code>optional string subnetwork = 307827694;</code> 2908 * 2909 * @return Whether the subnetwork field is set. 2910 */ 2911 @java.lang.Override hasSubnetwork()2912 public boolean hasSubnetwork() { 2913 return ((bitField0_ & 0x04000000) != 0); 2914 } 2915 /** 2916 * 2917 * 2918 * <pre> 2919 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 2920 * </pre> 2921 * 2922 * <code>optional string subnetwork = 307827694;</code> 2923 * 2924 * @return The subnetwork. 2925 */ 2926 @java.lang.Override getSubnetwork()2927 public java.lang.String getSubnetwork() { 2928 java.lang.Object ref = subnetwork_; 2929 if (ref instanceof java.lang.String) { 2930 return (java.lang.String) ref; 2931 } else { 2932 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2933 java.lang.String s = bs.toStringUtf8(); 2934 subnetwork_ = s; 2935 return s; 2936 } 2937 } 2938 /** 2939 * 2940 * 2941 * <pre> 2942 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 2943 * </pre> 2944 * 2945 * <code>optional string subnetwork = 307827694;</code> 2946 * 2947 * @return The bytes for subnetwork. 2948 */ 2949 @java.lang.Override getSubnetworkBytes()2950 public com.google.protobuf.ByteString getSubnetworkBytes() { 2951 java.lang.Object ref = subnetwork_; 2952 if (ref instanceof java.lang.String) { 2953 com.google.protobuf.ByteString b = 2954 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2955 subnetwork_ = b; 2956 return b; 2957 } else { 2958 return (com.google.protobuf.ByteString) ref; 2959 } 2960 } 2961 2962 public static final int TARGET_FIELD_NUMBER = 192835985; 2963 2964 @SuppressWarnings("serial") 2965 private volatile java.lang.Object target_ = ""; 2966 /** 2967 * 2968 * 2969 * <pre> 2970 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 2971 * </pre> 2972 * 2973 * <code>optional string target = 192835985;</code> 2974 * 2975 * @return Whether the target field is set. 2976 */ 2977 @java.lang.Override hasTarget()2978 public boolean hasTarget() { 2979 return ((bitField0_ & 0x08000000) != 0); 2980 } 2981 /** 2982 * 2983 * 2984 * <pre> 2985 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 2986 * </pre> 2987 * 2988 * <code>optional string target = 192835985;</code> 2989 * 2990 * @return The target. 2991 */ 2992 @java.lang.Override getTarget()2993 public java.lang.String getTarget() { 2994 java.lang.Object ref = target_; 2995 if (ref instanceof java.lang.String) { 2996 return (java.lang.String) ref; 2997 } else { 2998 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2999 java.lang.String s = bs.toStringUtf8(); 3000 target_ = s; 3001 return s; 3002 } 3003 } 3004 /** 3005 * 3006 * 3007 * <pre> 3008 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 3009 * </pre> 3010 * 3011 * <code>optional string target = 192835985;</code> 3012 * 3013 * @return The bytes for target. 3014 */ 3015 @java.lang.Override getTargetBytes()3016 public com.google.protobuf.ByteString getTargetBytes() { 3017 java.lang.Object ref = target_; 3018 if (ref instanceof java.lang.String) { 3019 com.google.protobuf.ByteString b = 3020 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 3021 target_ = b; 3022 return b; 3023 } else { 3024 return (com.google.protobuf.ByteString) ref; 3025 } 3026 } 3027 3028 private byte memoizedIsInitialized = -1; 3029 3030 @java.lang.Override isInitialized()3031 public final boolean isInitialized() { 3032 byte isInitialized = memoizedIsInitialized; 3033 if (isInitialized == 1) return true; 3034 if (isInitialized == 0) return false; 3035 3036 memoizedIsInitialized = 1; 3037 return true; 3038 } 3039 3040 @java.lang.Override writeTo(com.google.protobuf.CodedOutputStream output)3041 public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException { 3042 if (((bitField0_ & 0x00000200) != 0)) { 3043 output.writeUInt64(3355, id_); 3044 } 3045 if (((bitField0_ & 0x00001000) != 0)) { 3046 com.google.protobuf.GeneratedMessageV3.writeString(output, 3292052, kind_); 3047 } 3048 if (((bitField0_ & 0x00008000) != 0)) { 3049 com.google.protobuf.GeneratedMessageV3.writeString(output, 3373707, name_); 3050 } 3051 if (((bitField0_ & 0x00000040) != 0)) { 3052 com.google.protobuf.GeneratedMessageV3.writeString(output, 30525366, creationTimestamp_); 3053 } 3054 if (((bitField0_ & 0x00000001) != 0)) { 3055 com.google.protobuf.GeneratedMessageV3.writeString(output, 42976943, iPAddress_); 3056 } 3057 if (((bitField0_ & 0x00040000) != 0)) { 3058 output.writeBool(64546991, noAutomateDnsZone_); 3059 } 3060 for (int i = 0; i < ports_.size(); i++) { 3061 com.google.protobuf.GeneratedMessageV3.writeString(output, 106854418, ports_.getRaw(i)); 3062 } 3063 for (int i = 0; i < sourceIpRanges_.size(); i++) { 3064 com.google.protobuf.GeneratedMessageV3.writeString( 3065 output, 111563210, sourceIpRanges_.getRaw(i)); 3066 } 3067 if (((bitField0_ & 0x00000800) != 0)) { 3068 output.writeBool(119255164, isMirroringCollector_); 3069 } 3070 if (((bitField0_ & 0x00400000) != 0)) { 3071 com.google.protobuf.GeneratedMessageV3.writeString(output, 138946292, region_); 3072 } 3073 if (((bitField0_ & 0x00002000) != 0)) { 3074 com.google.protobuf.GeneratedMessageV3.writeString(output, 178124825, labelFingerprint_); 3075 } 3076 if (((bitField0_ & 0x00200000) != 0)) { 3077 com.google.protobuf.GeneratedMessageV3.writeString(output, 184149172, pscConnectionStatus_); 3078 } 3079 if (((bitField0_ & 0x08000000) != 0)) { 3080 com.google.protobuf.GeneratedMessageV3.writeString(output, 192835985, target_); 3081 } 3082 if (((bitField0_ & 0x00080000) != 0)) { 3083 com.google.protobuf.GeneratedMessageV3.writeString(output, 217518079, portRange_); 3084 } 3085 for (int i = 0; i < serviceDirectoryRegistrations_.size(); i++) { 3086 output.writeMessage(223549694, serviceDirectoryRegistrations_.get(i)); 3087 } 3088 if (((bitField0_ & 0x00010000) != 0)) { 3089 com.google.protobuf.GeneratedMessageV3.writeString(output, 232872494, network_); 3090 } 3091 if (((bitField0_ & 0x00000100) != 0)) { 3092 com.google.protobuf.GeneratedMessageV3.writeString(output, 234678500, fingerprint_); 3093 } 3094 if (((bitField0_ & 0x00100000) != 0)) { 3095 output.writeUInt64(292082397, pscConnectionId_); 3096 } 3097 if (((bitField0_ & 0x00000400) != 0)) { 3098 com.google.protobuf.GeneratedMessageV3.writeString(output, 294959552, ipVersion_); 3099 } 3100 if (((bitField0_ & 0x00000010) != 0)) { 3101 com.google.protobuf.GeneratedMessageV3.writeString(output, 306946058, backendService_); 3102 } 3103 if (((bitField0_ & 0x04000000) != 0)) { 3104 com.google.protobuf.GeneratedMessageV3.writeString(output, 307827694, subnetwork_); 3105 } 3106 if (((bitField0_ & 0x02000000) != 0)) { 3107 com.google.protobuf.GeneratedMessageV3.writeString(output, 359880149, serviceName_); 3108 } 3109 if (((bitField0_ & 0x00004000) != 0)) { 3110 com.google.protobuf.GeneratedMessageV3.writeString(output, 363890244, loadBalancingScheme_); 3111 } 3112 if (((bitField0_ & 0x01000000) != 0)) { 3113 com.google.protobuf.GeneratedMessageV3.writeString(output, 417008874, serviceLabel_); 3114 } 3115 if (((bitField0_ & 0x00000080) != 0)) { 3116 com.google.protobuf.GeneratedMessageV3.writeString(output, 422937596, description_); 3117 } 3118 if (((bitField0_ & 0x00000004) != 0)) { 3119 output.writeBool(445175796, allPorts_); 3120 } 3121 if (((bitField0_ & 0x00800000) != 0)) { 3122 com.google.protobuf.GeneratedMessageV3.writeString(output, 456214797, selfLink_); 3123 } 3124 for (int i = 0; i < metadataFilters_.size(); i++) { 3125 output.writeMessage(464725739, metadataFilters_.get(i)); 3126 } 3127 if (((bitField0_ & 0x00000002) != 0)) { 3128 com.google.protobuf.GeneratedMessageV3.writeString(output, 488094525, iPProtocol_); 3129 } 3130 if (((bitField0_ & 0x00000008) != 0)) { 3131 output.writeBool(499409674, allowGlobalAccess_); 3132 } 3133 com.google.protobuf.GeneratedMessageV3.serializeStringMapTo( 3134 output, internalGetLabels(), LabelsDefaultEntryHolder.defaultEntry, 500195327); 3135 if (((bitField0_ & 0x00020000) != 0)) { 3136 com.google.protobuf.GeneratedMessageV3.writeString(output, 517397843, networkTier_); 3137 } 3138 if (((bitField0_ & 0x00000020) != 0)) { 3139 com.google.protobuf.GeneratedMessageV3.writeString(output, 524873104, baseForwardingRule_); 3140 } 3141 getUnknownFields().writeTo(output); 3142 } 3143 3144 @java.lang.Override getSerializedSize()3145 public int getSerializedSize() { 3146 int size = memoizedSize; 3147 if (size != -1) return size; 3148 3149 size = 0; 3150 if (((bitField0_ & 0x00000200) != 0)) { 3151 size += com.google.protobuf.CodedOutputStream.computeUInt64Size(3355, id_); 3152 } 3153 if (((bitField0_ & 0x00001000) != 0)) { 3154 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3292052, kind_); 3155 } 3156 if (((bitField0_ & 0x00008000) != 0)) { 3157 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3373707, name_); 3158 } 3159 if (((bitField0_ & 0x00000040) != 0)) { 3160 size += 3161 com.google.protobuf.GeneratedMessageV3.computeStringSize(30525366, creationTimestamp_); 3162 } 3163 if (((bitField0_ & 0x00000001) != 0)) { 3164 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(42976943, iPAddress_); 3165 } 3166 if (((bitField0_ & 0x00040000) != 0)) { 3167 size += com.google.protobuf.CodedOutputStream.computeBoolSize(64546991, noAutomateDnsZone_); 3168 } 3169 { 3170 int dataSize = 0; 3171 for (int i = 0; i < ports_.size(); i++) { 3172 dataSize += computeStringSizeNoTag(ports_.getRaw(i)); 3173 } 3174 size += dataSize; 3175 size += 5 * getPortsList().size(); 3176 } 3177 { 3178 int dataSize = 0; 3179 for (int i = 0; i < sourceIpRanges_.size(); i++) { 3180 dataSize += computeStringSizeNoTag(sourceIpRanges_.getRaw(i)); 3181 } 3182 size += dataSize; 3183 size += 5 * getSourceIpRangesList().size(); 3184 } 3185 if (((bitField0_ & 0x00000800) != 0)) { 3186 size += 3187 com.google.protobuf.CodedOutputStream.computeBoolSize(119255164, isMirroringCollector_); 3188 } 3189 if (((bitField0_ & 0x00400000) != 0)) { 3190 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(138946292, region_); 3191 } 3192 if (((bitField0_ & 0x00002000) != 0)) { 3193 size += 3194 com.google.protobuf.GeneratedMessageV3.computeStringSize(178124825, labelFingerprint_); 3195 } 3196 if (((bitField0_ & 0x00200000) != 0)) { 3197 size += 3198 com.google.protobuf.GeneratedMessageV3.computeStringSize(184149172, pscConnectionStatus_); 3199 } 3200 if (((bitField0_ & 0x08000000) != 0)) { 3201 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(192835985, target_); 3202 } 3203 if (((bitField0_ & 0x00080000) != 0)) { 3204 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(217518079, portRange_); 3205 } 3206 for (int i = 0; i < serviceDirectoryRegistrations_.size(); i++) { 3207 size += 3208 com.google.protobuf.CodedOutputStream.computeMessageSize( 3209 223549694, serviceDirectoryRegistrations_.get(i)); 3210 } 3211 if (((bitField0_ & 0x00010000) != 0)) { 3212 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(232872494, network_); 3213 } 3214 if (((bitField0_ & 0x00000100) != 0)) { 3215 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(234678500, fingerprint_); 3216 } 3217 if (((bitField0_ & 0x00100000) != 0)) { 3218 size += com.google.protobuf.CodedOutputStream.computeUInt64Size(292082397, pscConnectionId_); 3219 } 3220 if (((bitField0_ & 0x00000400) != 0)) { 3221 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(294959552, ipVersion_); 3222 } 3223 if (((bitField0_ & 0x00000010) != 0)) { 3224 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(306946058, backendService_); 3225 } 3226 if (((bitField0_ & 0x04000000) != 0)) { 3227 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(307827694, subnetwork_); 3228 } 3229 if (((bitField0_ & 0x02000000) != 0)) { 3230 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(359880149, serviceName_); 3231 } 3232 if (((bitField0_ & 0x00004000) != 0)) { 3233 size += 3234 com.google.protobuf.GeneratedMessageV3.computeStringSize(363890244, loadBalancingScheme_); 3235 } 3236 if (((bitField0_ & 0x01000000) != 0)) { 3237 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(417008874, serviceLabel_); 3238 } 3239 if (((bitField0_ & 0x00000080) != 0)) { 3240 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(422937596, description_); 3241 } 3242 if (((bitField0_ & 0x00000004) != 0)) { 3243 size += com.google.protobuf.CodedOutputStream.computeBoolSize(445175796, allPorts_); 3244 } 3245 if (((bitField0_ & 0x00800000) != 0)) { 3246 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(456214797, selfLink_); 3247 } 3248 for (int i = 0; i < metadataFilters_.size(); i++) { 3249 size += 3250 com.google.protobuf.CodedOutputStream.computeMessageSize( 3251 464725739, metadataFilters_.get(i)); 3252 } 3253 if (((bitField0_ & 0x00000002) != 0)) { 3254 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(488094525, iPProtocol_); 3255 } 3256 if (((bitField0_ & 0x00000008) != 0)) { 3257 size += com.google.protobuf.CodedOutputStream.computeBoolSize(499409674, allowGlobalAccess_); 3258 } 3259 for (java.util.Map.Entry<java.lang.String, java.lang.String> entry : 3260 internalGetLabels().getMap().entrySet()) { 3261 com.google.protobuf.MapEntry<java.lang.String, java.lang.String> labels__ = 3262 LabelsDefaultEntryHolder.defaultEntry 3263 .newBuilderForType() 3264 .setKey(entry.getKey()) 3265 .setValue(entry.getValue()) 3266 .build(); 3267 size += com.google.protobuf.CodedOutputStream.computeMessageSize(500195327, labels__); 3268 } 3269 if (((bitField0_ & 0x00020000) != 0)) { 3270 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(517397843, networkTier_); 3271 } 3272 if (((bitField0_ & 0x00000020) != 0)) { 3273 size += 3274 com.google.protobuf.GeneratedMessageV3.computeStringSize(524873104, baseForwardingRule_); 3275 } 3276 size += getUnknownFields().getSerializedSize(); 3277 memoizedSize = size; 3278 return size; 3279 } 3280 3281 @java.lang.Override equals(final java.lang.Object obj)3282 public boolean equals(final java.lang.Object obj) { 3283 if (obj == this) { 3284 return true; 3285 } 3286 if (!(obj instanceof com.google.cloud.compute.v1.ForwardingRule)) { 3287 return super.equals(obj); 3288 } 3289 com.google.cloud.compute.v1.ForwardingRule other = 3290 (com.google.cloud.compute.v1.ForwardingRule) obj; 3291 3292 if (hasIPAddress() != other.hasIPAddress()) return false; 3293 if (hasIPAddress()) { 3294 if (!getIPAddress().equals(other.getIPAddress())) return false; 3295 } 3296 if (hasIPProtocol() != other.hasIPProtocol()) return false; 3297 if (hasIPProtocol()) { 3298 if (!getIPProtocol().equals(other.getIPProtocol())) return false; 3299 } 3300 if (hasAllPorts() != other.hasAllPorts()) return false; 3301 if (hasAllPorts()) { 3302 if (getAllPorts() != other.getAllPorts()) return false; 3303 } 3304 if (hasAllowGlobalAccess() != other.hasAllowGlobalAccess()) return false; 3305 if (hasAllowGlobalAccess()) { 3306 if (getAllowGlobalAccess() != other.getAllowGlobalAccess()) return false; 3307 } 3308 if (hasBackendService() != other.hasBackendService()) return false; 3309 if (hasBackendService()) { 3310 if (!getBackendService().equals(other.getBackendService())) return false; 3311 } 3312 if (hasBaseForwardingRule() != other.hasBaseForwardingRule()) return false; 3313 if (hasBaseForwardingRule()) { 3314 if (!getBaseForwardingRule().equals(other.getBaseForwardingRule())) return false; 3315 } 3316 if (hasCreationTimestamp() != other.hasCreationTimestamp()) return false; 3317 if (hasCreationTimestamp()) { 3318 if (!getCreationTimestamp().equals(other.getCreationTimestamp())) return false; 3319 } 3320 if (hasDescription() != other.hasDescription()) return false; 3321 if (hasDescription()) { 3322 if (!getDescription().equals(other.getDescription())) return false; 3323 } 3324 if (hasFingerprint() != other.hasFingerprint()) return false; 3325 if (hasFingerprint()) { 3326 if (!getFingerprint().equals(other.getFingerprint())) return false; 3327 } 3328 if (hasId() != other.hasId()) return false; 3329 if (hasId()) { 3330 if (getId() != other.getId()) return false; 3331 } 3332 if (hasIpVersion() != other.hasIpVersion()) return false; 3333 if (hasIpVersion()) { 3334 if (!getIpVersion().equals(other.getIpVersion())) return false; 3335 } 3336 if (hasIsMirroringCollector() != other.hasIsMirroringCollector()) return false; 3337 if (hasIsMirroringCollector()) { 3338 if (getIsMirroringCollector() != other.getIsMirroringCollector()) return false; 3339 } 3340 if (hasKind() != other.hasKind()) return false; 3341 if (hasKind()) { 3342 if (!getKind().equals(other.getKind())) return false; 3343 } 3344 if (hasLabelFingerprint() != other.hasLabelFingerprint()) return false; 3345 if (hasLabelFingerprint()) { 3346 if (!getLabelFingerprint().equals(other.getLabelFingerprint())) return false; 3347 } 3348 if (!internalGetLabels().equals(other.internalGetLabels())) return false; 3349 if (hasLoadBalancingScheme() != other.hasLoadBalancingScheme()) return false; 3350 if (hasLoadBalancingScheme()) { 3351 if (!getLoadBalancingScheme().equals(other.getLoadBalancingScheme())) return false; 3352 } 3353 if (!getMetadataFiltersList().equals(other.getMetadataFiltersList())) return false; 3354 if (hasName() != other.hasName()) return false; 3355 if (hasName()) { 3356 if (!getName().equals(other.getName())) return false; 3357 } 3358 if (hasNetwork() != other.hasNetwork()) return false; 3359 if (hasNetwork()) { 3360 if (!getNetwork().equals(other.getNetwork())) return false; 3361 } 3362 if (hasNetworkTier() != other.hasNetworkTier()) return false; 3363 if (hasNetworkTier()) { 3364 if (!getNetworkTier().equals(other.getNetworkTier())) return false; 3365 } 3366 if (hasNoAutomateDnsZone() != other.hasNoAutomateDnsZone()) return false; 3367 if (hasNoAutomateDnsZone()) { 3368 if (getNoAutomateDnsZone() != other.getNoAutomateDnsZone()) return false; 3369 } 3370 if (hasPortRange() != other.hasPortRange()) return false; 3371 if (hasPortRange()) { 3372 if (!getPortRange().equals(other.getPortRange())) return false; 3373 } 3374 if (!getPortsList().equals(other.getPortsList())) return false; 3375 if (hasPscConnectionId() != other.hasPscConnectionId()) return false; 3376 if (hasPscConnectionId()) { 3377 if (getPscConnectionId() != other.getPscConnectionId()) return false; 3378 } 3379 if (hasPscConnectionStatus() != other.hasPscConnectionStatus()) return false; 3380 if (hasPscConnectionStatus()) { 3381 if (!getPscConnectionStatus().equals(other.getPscConnectionStatus())) return false; 3382 } 3383 if (hasRegion() != other.hasRegion()) return false; 3384 if (hasRegion()) { 3385 if (!getRegion().equals(other.getRegion())) return false; 3386 } 3387 if (hasSelfLink() != other.hasSelfLink()) return false; 3388 if (hasSelfLink()) { 3389 if (!getSelfLink().equals(other.getSelfLink())) return false; 3390 } 3391 if (!getServiceDirectoryRegistrationsList() 3392 .equals(other.getServiceDirectoryRegistrationsList())) return false; 3393 if (hasServiceLabel() != other.hasServiceLabel()) return false; 3394 if (hasServiceLabel()) { 3395 if (!getServiceLabel().equals(other.getServiceLabel())) return false; 3396 } 3397 if (hasServiceName() != other.hasServiceName()) return false; 3398 if (hasServiceName()) { 3399 if (!getServiceName().equals(other.getServiceName())) return false; 3400 } 3401 if (!getSourceIpRangesList().equals(other.getSourceIpRangesList())) return false; 3402 if (hasSubnetwork() != other.hasSubnetwork()) return false; 3403 if (hasSubnetwork()) { 3404 if (!getSubnetwork().equals(other.getSubnetwork())) return false; 3405 } 3406 if (hasTarget() != other.hasTarget()) return false; 3407 if (hasTarget()) { 3408 if (!getTarget().equals(other.getTarget())) return false; 3409 } 3410 if (!getUnknownFields().equals(other.getUnknownFields())) return false; 3411 return true; 3412 } 3413 3414 @java.lang.Override hashCode()3415 public int hashCode() { 3416 if (memoizedHashCode != 0) { 3417 return memoizedHashCode; 3418 } 3419 int hash = 41; 3420 hash = (19 * hash) + getDescriptor().hashCode(); 3421 if (hasIPAddress()) { 3422 hash = (37 * hash) + I_P_ADDRESS_FIELD_NUMBER; 3423 hash = (53 * hash) + getIPAddress().hashCode(); 3424 } 3425 if (hasIPProtocol()) { 3426 hash = (37 * hash) + I_P_PROTOCOL_FIELD_NUMBER; 3427 hash = (53 * hash) + getIPProtocol().hashCode(); 3428 } 3429 if (hasAllPorts()) { 3430 hash = (37 * hash) + ALL_PORTS_FIELD_NUMBER; 3431 hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(getAllPorts()); 3432 } 3433 if (hasAllowGlobalAccess()) { 3434 hash = (37 * hash) + ALLOW_GLOBAL_ACCESS_FIELD_NUMBER; 3435 hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(getAllowGlobalAccess()); 3436 } 3437 if (hasBackendService()) { 3438 hash = (37 * hash) + BACKEND_SERVICE_FIELD_NUMBER; 3439 hash = (53 * hash) + getBackendService().hashCode(); 3440 } 3441 if (hasBaseForwardingRule()) { 3442 hash = (37 * hash) + BASE_FORWARDING_RULE_FIELD_NUMBER; 3443 hash = (53 * hash) + getBaseForwardingRule().hashCode(); 3444 } 3445 if (hasCreationTimestamp()) { 3446 hash = (37 * hash) + CREATION_TIMESTAMP_FIELD_NUMBER; 3447 hash = (53 * hash) + getCreationTimestamp().hashCode(); 3448 } 3449 if (hasDescription()) { 3450 hash = (37 * hash) + DESCRIPTION_FIELD_NUMBER; 3451 hash = (53 * hash) + getDescription().hashCode(); 3452 } 3453 if (hasFingerprint()) { 3454 hash = (37 * hash) + FINGERPRINT_FIELD_NUMBER; 3455 hash = (53 * hash) + getFingerprint().hashCode(); 3456 } 3457 if (hasId()) { 3458 hash = (37 * hash) + ID_FIELD_NUMBER; 3459 hash = (53 * hash) + com.google.protobuf.Internal.hashLong(getId()); 3460 } 3461 if (hasIpVersion()) { 3462 hash = (37 * hash) + IP_VERSION_FIELD_NUMBER; 3463 hash = (53 * hash) + getIpVersion().hashCode(); 3464 } 3465 if (hasIsMirroringCollector()) { 3466 hash = (37 * hash) + IS_MIRRORING_COLLECTOR_FIELD_NUMBER; 3467 hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(getIsMirroringCollector()); 3468 } 3469 if (hasKind()) { 3470 hash = (37 * hash) + KIND_FIELD_NUMBER; 3471 hash = (53 * hash) + getKind().hashCode(); 3472 } 3473 if (hasLabelFingerprint()) { 3474 hash = (37 * hash) + LABEL_FINGERPRINT_FIELD_NUMBER; 3475 hash = (53 * hash) + getLabelFingerprint().hashCode(); 3476 } 3477 if (!internalGetLabels().getMap().isEmpty()) { 3478 hash = (37 * hash) + LABELS_FIELD_NUMBER; 3479 hash = (53 * hash) + internalGetLabels().hashCode(); 3480 } 3481 if (hasLoadBalancingScheme()) { 3482 hash = (37 * hash) + LOAD_BALANCING_SCHEME_FIELD_NUMBER; 3483 hash = (53 * hash) + getLoadBalancingScheme().hashCode(); 3484 } 3485 if (getMetadataFiltersCount() > 0) { 3486 hash = (37 * hash) + METADATA_FILTERS_FIELD_NUMBER; 3487 hash = (53 * hash) + getMetadataFiltersList().hashCode(); 3488 } 3489 if (hasName()) { 3490 hash = (37 * hash) + NAME_FIELD_NUMBER; 3491 hash = (53 * hash) + getName().hashCode(); 3492 } 3493 if (hasNetwork()) { 3494 hash = (37 * hash) + NETWORK_FIELD_NUMBER; 3495 hash = (53 * hash) + getNetwork().hashCode(); 3496 } 3497 if (hasNetworkTier()) { 3498 hash = (37 * hash) + NETWORK_TIER_FIELD_NUMBER; 3499 hash = (53 * hash) + getNetworkTier().hashCode(); 3500 } 3501 if (hasNoAutomateDnsZone()) { 3502 hash = (37 * hash) + NO_AUTOMATE_DNS_ZONE_FIELD_NUMBER; 3503 hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(getNoAutomateDnsZone()); 3504 } 3505 if (hasPortRange()) { 3506 hash = (37 * hash) + PORT_RANGE_FIELD_NUMBER; 3507 hash = (53 * hash) + getPortRange().hashCode(); 3508 } 3509 if (getPortsCount() > 0) { 3510 hash = (37 * hash) + PORTS_FIELD_NUMBER; 3511 hash = (53 * hash) + getPortsList().hashCode(); 3512 } 3513 if (hasPscConnectionId()) { 3514 hash = (37 * hash) + PSC_CONNECTION_ID_FIELD_NUMBER; 3515 hash = (53 * hash) + com.google.protobuf.Internal.hashLong(getPscConnectionId()); 3516 } 3517 if (hasPscConnectionStatus()) { 3518 hash = (37 * hash) + PSC_CONNECTION_STATUS_FIELD_NUMBER; 3519 hash = (53 * hash) + getPscConnectionStatus().hashCode(); 3520 } 3521 if (hasRegion()) { 3522 hash = (37 * hash) + REGION_FIELD_NUMBER; 3523 hash = (53 * hash) + getRegion().hashCode(); 3524 } 3525 if (hasSelfLink()) { 3526 hash = (37 * hash) + SELF_LINK_FIELD_NUMBER; 3527 hash = (53 * hash) + getSelfLink().hashCode(); 3528 } 3529 if (getServiceDirectoryRegistrationsCount() > 0) { 3530 hash = (37 * hash) + SERVICE_DIRECTORY_REGISTRATIONS_FIELD_NUMBER; 3531 hash = (53 * hash) + getServiceDirectoryRegistrationsList().hashCode(); 3532 } 3533 if (hasServiceLabel()) { 3534 hash = (37 * hash) + SERVICE_LABEL_FIELD_NUMBER; 3535 hash = (53 * hash) + getServiceLabel().hashCode(); 3536 } 3537 if (hasServiceName()) { 3538 hash = (37 * hash) + SERVICE_NAME_FIELD_NUMBER; 3539 hash = (53 * hash) + getServiceName().hashCode(); 3540 } 3541 if (getSourceIpRangesCount() > 0) { 3542 hash = (37 * hash) + SOURCE_IP_RANGES_FIELD_NUMBER; 3543 hash = (53 * hash) + getSourceIpRangesList().hashCode(); 3544 } 3545 if (hasSubnetwork()) { 3546 hash = (37 * hash) + SUBNETWORK_FIELD_NUMBER; 3547 hash = (53 * hash) + getSubnetwork().hashCode(); 3548 } 3549 if (hasTarget()) { 3550 hash = (37 * hash) + TARGET_FIELD_NUMBER; 3551 hash = (53 * hash) + getTarget().hashCode(); 3552 } 3553 hash = (29 * hash) + getUnknownFields().hashCode(); 3554 memoizedHashCode = hash; 3555 return hash; 3556 } 3557 parseFrom(java.nio.ByteBuffer data)3558 public static com.google.cloud.compute.v1.ForwardingRule parseFrom(java.nio.ByteBuffer data) 3559 throws com.google.protobuf.InvalidProtocolBufferException { 3560 return PARSER.parseFrom(data); 3561 } 3562 parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)3563 public static com.google.cloud.compute.v1.ForwardingRule parseFrom( 3564 java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) 3565 throws com.google.protobuf.InvalidProtocolBufferException { 3566 return PARSER.parseFrom(data, extensionRegistry); 3567 } 3568 parseFrom( com.google.protobuf.ByteString data)3569 public static com.google.cloud.compute.v1.ForwardingRule parseFrom( 3570 com.google.protobuf.ByteString data) 3571 throws com.google.protobuf.InvalidProtocolBufferException { 3572 return PARSER.parseFrom(data); 3573 } 3574 parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)3575 public static com.google.cloud.compute.v1.ForwardingRule parseFrom( 3576 com.google.protobuf.ByteString data, 3577 com.google.protobuf.ExtensionRegistryLite extensionRegistry) 3578 throws com.google.protobuf.InvalidProtocolBufferException { 3579 return PARSER.parseFrom(data, extensionRegistry); 3580 } 3581 parseFrom(byte[] data)3582 public static com.google.cloud.compute.v1.ForwardingRule parseFrom(byte[] data) 3583 throws com.google.protobuf.InvalidProtocolBufferException { 3584 return PARSER.parseFrom(data); 3585 } 3586 parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)3587 public static com.google.cloud.compute.v1.ForwardingRule parseFrom( 3588 byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) 3589 throws com.google.protobuf.InvalidProtocolBufferException { 3590 return PARSER.parseFrom(data, extensionRegistry); 3591 } 3592 parseFrom(java.io.InputStream input)3593 public static com.google.cloud.compute.v1.ForwardingRule parseFrom(java.io.InputStream input) 3594 throws java.io.IOException { 3595 return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input); 3596 } 3597 parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)3598 public static com.google.cloud.compute.v1.ForwardingRule parseFrom( 3599 java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) 3600 throws java.io.IOException { 3601 return com.google.protobuf.GeneratedMessageV3.parseWithIOException( 3602 PARSER, input, extensionRegistry); 3603 } 3604 parseDelimitedFrom( java.io.InputStream input)3605 public static com.google.cloud.compute.v1.ForwardingRule parseDelimitedFrom( 3606 java.io.InputStream input) throws java.io.IOException { 3607 return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(PARSER, input); 3608 } 3609 parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)3610 public static com.google.cloud.compute.v1.ForwardingRule parseDelimitedFrom( 3611 java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) 3612 throws java.io.IOException { 3613 return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException( 3614 PARSER, input, extensionRegistry); 3615 } 3616 parseFrom( com.google.protobuf.CodedInputStream input)3617 public static com.google.cloud.compute.v1.ForwardingRule parseFrom( 3618 com.google.protobuf.CodedInputStream input) throws java.io.IOException { 3619 return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input); 3620 } 3621 parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)3622 public static com.google.cloud.compute.v1.ForwardingRule parseFrom( 3623 com.google.protobuf.CodedInputStream input, 3624 com.google.protobuf.ExtensionRegistryLite extensionRegistry) 3625 throws java.io.IOException { 3626 return com.google.protobuf.GeneratedMessageV3.parseWithIOException( 3627 PARSER, input, extensionRegistry); 3628 } 3629 3630 @java.lang.Override newBuilderForType()3631 public Builder newBuilderForType() { 3632 return newBuilder(); 3633 } 3634 newBuilder()3635 public static Builder newBuilder() { 3636 return DEFAULT_INSTANCE.toBuilder(); 3637 } 3638 newBuilder(com.google.cloud.compute.v1.ForwardingRule prototype)3639 public static Builder newBuilder(com.google.cloud.compute.v1.ForwardingRule prototype) { 3640 return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); 3641 } 3642 3643 @java.lang.Override toBuilder()3644 public Builder toBuilder() { 3645 return this == DEFAULT_INSTANCE ? new Builder() : new Builder().mergeFrom(this); 3646 } 3647 3648 @java.lang.Override newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent)3649 protected Builder newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { 3650 Builder builder = new Builder(parent); 3651 return builder; 3652 } 3653 /** 3654 * 3655 * 3656 * <pre> 3657 * Represents a Forwarding Rule resource. Forwarding rule resources in Google Cloud can be either regional or global in scope: * [Global](https://cloud.google.com/compute/docs/reference/rest/v1/globalForwardingRules) * [Regional](https://cloud.google.com/compute/docs/reference/rest/v1/forwardingRules) A forwarding rule and its corresponding IP address represent the frontend configuration of a Google Cloud Platform load balancer. Forwarding rules can also reference target instances and Cloud VPN Classic gateways (targetVpnGateway). For more information, read Forwarding rule concepts and Using protocol forwarding. 3658 * </pre> 3659 * 3660 * Protobuf type {@code google.cloud.compute.v1.ForwardingRule} 3661 */ 3662 public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder<Builder> 3663 implements 3664 // @@protoc_insertion_point(builder_implements:google.cloud.compute.v1.ForwardingRule) 3665 com.google.cloud.compute.v1.ForwardingRuleOrBuilder { getDescriptor()3666 public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { 3667 return com.google.cloud.compute.v1.Compute 3668 .internal_static_google_cloud_compute_v1_ForwardingRule_descriptor; 3669 } 3670 3671 @SuppressWarnings({"rawtypes"}) internalGetMapField(int number)3672 protected com.google.protobuf.MapField internalGetMapField(int number) { 3673 switch (number) { 3674 case 500195327: 3675 return internalGetLabels(); 3676 default: 3677 throw new RuntimeException("Invalid map field number: " + number); 3678 } 3679 } 3680 3681 @SuppressWarnings({"rawtypes"}) internalGetMutableMapField(int number)3682 protected com.google.protobuf.MapField internalGetMutableMapField(int number) { 3683 switch (number) { 3684 case 500195327: 3685 return internalGetMutableLabels(); 3686 default: 3687 throw new RuntimeException("Invalid map field number: " + number); 3688 } 3689 } 3690 3691 @java.lang.Override 3692 protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()3693 internalGetFieldAccessorTable() { 3694 return com.google.cloud.compute.v1.Compute 3695 .internal_static_google_cloud_compute_v1_ForwardingRule_fieldAccessorTable 3696 .ensureFieldAccessorsInitialized( 3697 com.google.cloud.compute.v1.ForwardingRule.class, 3698 com.google.cloud.compute.v1.ForwardingRule.Builder.class); 3699 } 3700 3701 // Construct using com.google.cloud.compute.v1.ForwardingRule.newBuilder() Builder()3702 private Builder() {} 3703 Builder(com.google.protobuf.GeneratedMessageV3.BuilderParent parent)3704 private Builder(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { 3705 super(parent); 3706 } 3707 3708 @java.lang.Override clear()3709 public Builder clear() { 3710 super.clear(); 3711 bitField0_ = 0; 3712 bitField1_ = 0; 3713 iPAddress_ = ""; 3714 iPProtocol_ = ""; 3715 allPorts_ = false; 3716 allowGlobalAccess_ = false; 3717 backendService_ = ""; 3718 baseForwardingRule_ = ""; 3719 creationTimestamp_ = ""; 3720 description_ = ""; 3721 fingerprint_ = ""; 3722 id_ = 0L; 3723 ipVersion_ = ""; 3724 isMirroringCollector_ = false; 3725 kind_ = ""; 3726 labelFingerprint_ = ""; 3727 internalGetMutableLabels().clear(); 3728 loadBalancingScheme_ = ""; 3729 if (metadataFiltersBuilder_ == null) { 3730 metadataFilters_ = java.util.Collections.emptyList(); 3731 } else { 3732 metadataFilters_ = null; 3733 metadataFiltersBuilder_.clear(); 3734 } 3735 bitField0_ = (bitField0_ & ~0x00010000); 3736 name_ = ""; 3737 network_ = ""; 3738 networkTier_ = ""; 3739 noAutomateDnsZone_ = false; 3740 portRange_ = ""; 3741 ports_ = com.google.protobuf.LazyStringArrayList.EMPTY; 3742 bitField0_ = (bitField0_ & ~0x00400000); 3743 pscConnectionId_ = 0L; 3744 pscConnectionStatus_ = ""; 3745 region_ = ""; 3746 selfLink_ = ""; 3747 if (serviceDirectoryRegistrationsBuilder_ == null) { 3748 serviceDirectoryRegistrations_ = java.util.Collections.emptyList(); 3749 } else { 3750 serviceDirectoryRegistrations_ = null; 3751 serviceDirectoryRegistrationsBuilder_.clear(); 3752 } 3753 bitField0_ = (bitField0_ & ~0x08000000); 3754 serviceLabel_ = ""; 3755 serviceName_ = ""; 3756 sourceIpRanges_ = com.google.protobuf.LazyStringArrayList.EMPTY; 3757 bitField0_ = (bitField0_ & ~0x40000000); 3758 subnetwork_ = ""; 3759 target_ = ""; 3760 return this; 3761 } 3762 3763 @java.lang.Override getDescriptorForType()3764 public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { 3765 return com.google.cloud.compute.v1.Compute 3766 .internal_static_google_cloud_compute_v1_ForwardingRule_descriptor; 3767 } 3768 3769 @java.lang.Override getDefaultInstanceForType()3770 public com.google.cloud.compute.v1.ForwardingRule getDefaultInstanceForType() { 3771 return com.google.cloud.compute.v1.ForwardingRule.getDefaultInstance(); 3772 } 3773 3774 @java.lang.Override build()3775 public com.google.cloud.compute.v1.ForwardingRule build() { 3776 com.google.cloud.compute.v1.ForwardingRule result = buildPartial(); 3777 if (!result.isInitialized()) { 3778 throw newUninitializedMessageException(result); 3779 } 3780 return result; 3781 } 3782 3783 @java.lang.Override buildPartial()3784 public com.google.cloud.compute.v1.ForwardingRule buildPartial() { 3785 com.google.cloud.compute.v1.ForwardingRule result = 3786 new com.google.cloud.compute.v1.ForwardingRule(this); 3787 buildPartialRepeatedFields(result); 3788 if (bitField0_ != 0) { 3789 buildPartial0(result); 3790 } 3791 if (bitField1_ != 0) { 3792 buildPartial1(result); 3793 } 3794 onBuilt(); 3795 return result; 3796 } 3797 buildPartialRepeatedFields(com.google.cloud.compute.v1.ForwardingRule result)3798 private void buildPartialRepeatedFields(com.google.cloud.compute.v1.ForwardingRule result) { 3799 if (metadataFiltersBuilder_ == null) { 3800 if (((bitField0_ & 0x00010000) != 0)) { 3801 metadataFilters_ = java.util.Collections.unmodifiableList(metadataFilters_); 3802 bitField0_ = (bitField0_ & ~0x00010000); 3803 } 3804 result.metadataFilters_ = metadataFilters_; 3805 } else { 3806 result.metadataFilters_ = metadataFiltersBuilder_.build(); 3807 } 3808 if (((bitField0_ & 0x00400000) != 0)) { 3809 ports_ = ports_.getUnmodifiableView(); 3810 bitField0_ = (bitField0_ & ~0x00400000); 3811 } 3812 result.ports_ = ports_; 3813 if (serviceDirectoryRegistrationsBuilder_ == null) { 3814 if (((bitField0_ & 0x08000000) != 0)) { 3815 serviceDirectoryRegistrations_ = 3816 java.util.Collections.unmodifiableList(serviceDirectoryRegistrations_); 3817 bitField0_ = (bitField0_ & ~0x08000000); 3818 } 3819 result.serviceDirectoryRegistrations_ = serviceDirectoryRegistrations_; 3820 } else { 3821 result.serviceDirectoryRegistrations_ = serviceDirectoryRegistrationsBuilder_.build(); 3822 } 3823 if (((bitField0_ & 0x40000000) != 0)) { 3824 sourceIpRanges_ = sourceIpRanges_.getUnmodifiableView(); 3825 bitField0_ = (bitField0_ & ~0x40000000); 3826 } 3827 result.sourceIpRanges_ = sourceIpRanges_; 3828 } 3829 buildPartial0(com.google.cloud.compute.v1.ForwardingRule result)3830 private void buildPartial0(com.google.cloud.compute.v1.ForwardingRule result) { 3831 int from_bitField0_ = bitField0_; 3832 int to_bitField0_ = 0; 3833 if (((from_bitField0_ & 0x00000001) != 0)) { 3834 result.iPAddress_ = iPAddress_; 3835 to_bitField0_ |= 0x00000001; 3836 } 3837 if (((from_bitField0_ & 0x00000002) != 0)) { 3838 result.iPProtocol_ = iPProtocol_; 3839 to_bitField0_ |= 0x00000002; 3840 } 3841 if (((from_bitField0_ & 0x00000004) != 0)) { 3842 result.allPorts_ = allPorts_; 3843 to_bitField0_ |= 0x00000004; 3844 } 3845 if (((from_bitField0_ & 0x00000008) != 0)) { 3846 result.allowGlobalAccess_ = allowGlobalAccess_; 3847 to_bitField0_ |= 0x00000008; 3848 } 3849 if (((from_bitField0_ & 0x00000010) != 0)) { 3850 result.backendService_ = backendService_; 3851 to_bitField0_ |= 0x00000010; 3852 } 3853 if (((from_bitField0_ & 0x00000020) != 0)) { 3854 result.baseForwardingRule_ = baseForwardingRule_; 3855 to_bitField0_ |= 0x00000020; 3856 } 3857 if (((from_bitField0_ & 0x00000040) != 0)) { 3858 result.creationTimestamp_ = creationTimestamp_; 3859 to_bitField0_ |= 0x00000040; 3860 } 3861 if (((from_bitField0_ & 0x00000080) != 0)) { 3862 result.description_ = description_; 3863 to_bitField0_ |= 0x00000080; 3864 } 3865 if (((from_bitField0_ & 0x00000100) != 0)) { 3866 result.fingerprint_ = fingerprint_; 3867 to_bitField0_ |= 0x00000100; 3868 } 3869 if (((from_bitField0_ & 0x00000200) != 0)) { 3870 result.id_ = id_; 3871 to_bitField0_ |= 0x00000200; 3872 } 3873 if (((from_bitField0_ & 0x00000400) != 0)) { 3874 result.ipVersion_ = ipVersion_; 3875 to_bitField0_ |= 0x00000400; 3876 } 3877 if (((from_bitField0_ & 0x00000800) != 0)) { 3878 result.isMirroringCollector_ = isMirroringCollector_; 3879 to_bitField0_ |= 0x00000800; 3880 } 3881 if (((from_bitField0_ & 0x00001000) != 0)) { 3882 result.kind_ = kind_; 3883 to_bitField0_ |= 0x00001000; 3884 } 3885 if (((from_bitField0_ & 0x00002000) != 0)) { 3886 result.labelFingerprint_ = labelFingerprint_; 3887 to_bitField0_ |= 0x00002000; 3888 } 3889 if (((from_bitField0_ & 0x00004000) != 0)) { 3890 result.labels_ = internalGetLabels(); 3891 result.labels_.makeImmutable(); 3892 } 3893 if (((from_bitField0_ & 0x00008000) != 0)) { 3894 result.loadBalancingScheme_ = loadBalancingScheme_; 3895 to_bitField0_ |= 0x00004000; 3896 } 3897 if (((from_bitField0_ & 0x00020000) != 0)) { 3898 result.name_ = name_; 3899 to_bitField0_ |= 0x00008000; 3900 } 3901 if (((from_bitField0_ & 0x00040000) != 0)) { 3902 result.network_ = network_; 3903 to_bitField0_ |= 0x00010000; 3904 } 3905 if (((from_bitField0_ & 0x00080000) != 0)) { 3906 result.networkTier_ = networkTier_; 3907 to_bitField0_ |= 0x00020000; 3908 } 3909 if (((from_bitField0_ & 0x00100000) != 0)) { 3910 result.noAutomateDnsZone_ = noAutomateDnsZone_; 3911 to_bitField0_ |= 0x00040000; 3912 } 3913 if (((from_bitField0_ & 0x00200000) != 0)) { 3914 result.portRange_ = portRange_; 3915 to_bitField0_ |= 0x00080000; 3916 } 3917 if (((from_bitField0_ & 0x00800000) != 0)) { 3918 result.pscConnectionId_ = pscConnectionId_; 3919 to_bitField0_ |= 0x00100000; 3920 } 3921 if (((from_bitField0_ & 0x01000000) != 0)) { 3922 result.pscConnectionStatus_ = pscConnectionStatus_; 3923 to_bitField0_ |= 0x00200000; 3924 } 3925 if (((from_bitField0_ & 0x02000000) != 0)) { 3926 result.region_ = region_; 3927 to_bitField0_ |= 0x00400000; 3928 } 3929 if (((from_bitField0_ & 0x04000000) != 0)) { 3930 result.selfLink_ = selfLink_; 3931 to_bitField0_ |= 0x00800000; 3932 } 3933 if (((from_bitField0_ & 0x10000000) != 0)) { 3934 result.serviceLabel_ = serviceLabel_; 3935 to_bitField0_ |= 0x01000000; 3936 } 3937 if (((from_bitField0_ & 0x20000000) != 0)) { 3938 result.serviceName_ = serviceName_; 3939 to_bitField0_ |= 0x02000000; 3940 } 3941 if (((from_bitField0_ & 0x80000000) != 0)) { 3942 result.subnetwork_ = subnetwork_; 3943 to_bitField0_ |= 0x04000000; 3944 } 3945 result.bitField0_ |= to_bitField0_; 3946 } 3947 buildPartial1(com.google.cloud.compute.v1.ForwardingRule result)3948 private void buildPartial1(com.google.cloud.compute.v1.ForwardingRule result) { 3949 int from_bitField1_ = bitField1_; 3950 int to_bitField0_ = 0; 3951 if (((from_bitField1_ & 0x00000001) != 0)) { 3952 result.target_ = target_; 3953 to_bitField0_ |= 0x08000000; 3954 } 3955 result.bitField0_ |= to_bitField0_; 3956 } 3957 3958 @java.lang.Override clone()3959 public Builder clone() { 3960 return super.clone(); 3961 } 3962 3963 @java.lang.Override setField( com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)3964 public Builder setField( 3965 com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) { 3966 return super.setField(field, value); 3967 } 3968 3969 @java.lang.Override clearField(com.google.protobuf.Descriptors.FieldDescriptor field)3970 public Builder clearField(com.google.protobuf.Descriptors.FieldDescriptor field) { 3971 return super.clearField(field); 3972 } 3973 3974 @java.lang.Override clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof)3975 public Builder clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof) { 3976 return super.clearOneof(oneof); 3977 } 3978 3979 @java.lang.Override setRepeatedField( com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value)3980 public Builder setRepeatedField( 3981 com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value) { 3982 return super.setRepeatedField(field, index, value); 3983 } 3984 3985 @java.lang.Override addRepeatedField( com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)3986 public Builder addRepeatedField( 3987 com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) { 3988 return super.addRepeatedField(field, value); 3989 } 3990 3991 @java.lang.Override mergeFrom(com.google.protobuf.Message other)3992 public Builder mergeFrom(com.google.protobuf.Message other) { 3993 if (other instanceof com.google.cloud.compute.v1.ForwardingRule) { 3994 return mergeFrom((com.google.cloud.compute.v1.ForwardingRule) other); 3995 } else { 3996 super.mergeFrom(other); 3997 return this; 3998 } 3999 } 4000 mergeFrom(com.google.cloud.compute.v1.ForwardingRule other)4001 public Builder mergeFrom(com.google.cloud.compute.v1.ForwardingRule other) { 4002 if (other == com.google.cloud.compute.v1.ForwardingRule.getDefaultInstance()) return this; 4003 if (other.hasIPAddress()) { 4004 iPAddress_ = other.iPAddress_; 4005 bitField0_ |= 0x00000001; 4006 onChanged(); 4007 } 4008 if (other.hasIPProtocol()) { 4009 iPProtocol_ = other.iPProtocol_; 4010 bitField0_ |= 0x00000002; 4011 onChanged(); 4012 } 4013 if (other.hasAllPorts()) { 4014 setAllPorts(other.getAllPorts()); 4015 } 4016 if (other.hasAllowGlobalAccess()) { 4017 setAllowGlobalAccess(other.getAllowGlobalAccess()); 4018 } 4019 if (other.hasBackendService()) { 4020 backendService_ = other.backendService_; 4021 bitField0_ |= 0x00000010; 4022 onChanged(); 4023 } 4024 if (other.hasBaseForwardingRule()) { 4025 baseForwardingRule_ = other.baseForwardingRule_; 4026 bitField0_ |= 0x00000020; 4027 onChanged(); 4028 } 4029 if (other.hasCreationTimestamp()) { 4030 creationTimestamp_ = other.creationTimestamp_; 4031 bitField0_ |= 0x00000040; 4032 onChanged(); 4033 } 4034 if (other.hasDescription()) { 4035 description_ = other.description_; 4036 bitField0_ |= 0x00000080; 4037 onChanged(); 4038 } 4039 if (other.hasFingerprint()) { 4040 fingerprint_ = other.fingerprint_; 4041 bitField0_ |= 0x00000100; 4042 onChanged(); 4043 } 4044 if (other.hasId()) { 4045 setId(other.getId()); 4046 } 4047 if (other.hasIpVersion()) { 4048 ipVersion_ = other.ipVersion_; 4049 bitField0_ |= 0x00000400; 4050 onChanged(); 4051 } 4052 if (other.hasIsMirroringCollector()) { 4053 setIsMirroringCollector(other.getIsMirroringCollector()); 4054 } 4055 if (other.hasKind()) { 4056 kind_ = other.kind_; 4057 bitField0_ |= 0x00001000; 4058 onChanged(); 4059 } 4060 if (other.hasLabelFingerprint()) { 4061 labelFingerprint_ = other.labelFingerprint_; 4062 bitField0_ |= 0x00002000; 4063 onChanged(); 4064 } 4065 internalGetMutableLabels().mergeFrom(other.internalGetLabels()); 4066 bitField0_ |= 0x00004000; 4067 if (other.hasLoadBalancingScheme()) { 4068 loadBalancingScheme_ = other.loadBalancingScheme_; 4069 bitField0_ |= 0x00008000; 4070 onChanged(); 4071 } 4072 if (metadataFiltersBuilder_ == null) { 4073 if (!other.metadataFilters_.isEmpty()) { 4074 if (metadataFilters_.isEmpty()) { 4075 metadataFilters_ = other.metadataFilters_; 4076 bitField0_ = (bitField0_ & ~0x00010000); 4077 } else { 4078 ensureMetadataFiltersIsMutable(); 4079 metadataFilters_.addAll(other.metadataFilters_); 4080 } 4081 onChanged(); 4082 } 4083 } else { 4084 if (!other.metadataFilters_.isEmpty()) { 4085 if (metadataFiltersBuilder_.isEmpty()) { 4086 metadataFiltersBuilder_.dispose(); 4087 metadataFiltersBuilder_ = null; 4088 metadataFilters_ = other.metadataFilters_; 4089 bitField0_ = (bitField0_ & ~0x00010000); 4090 metadataFiltersBuilder_ = 4091 com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders 4092 ? getMetadataFiltersFieldBuilder() 4093 : null; 4094 } else { 4095 metadataFiltersBuilder_.addAllMessages(other.metadataFilters_); 4096 } 4097 } 4098 } 4099 if (other.hasName()) { 4100 name_ = other.name_; 4101 bitField0_ |= 0x00020000; 4102 onChanged(); 4103 } 4104 if (other.hasNetwork()) { 4105 network_ = other.network_; 4106 bitField0_ |= 0x00040000; 4107 onChanged(); 4108 } 4109 if (other.hasNetworkTier()) { 4110 networkTier_ = other.networkTier_; 4111 bitField0_ |= 0x00080000; 4112 onChanged(); 4113 } 4114 if (other.hasNoAutomateDnsZone()) { 4115 setNoAutomateDnsZone(other.getNoAutomateDnsZone()); 4116 } 4117 if (other.hasPortRange()) { 4118 portRange_ = other.portRange_; 4119 bitField0_ |= 0x00200000; 4120 onChanged(); 4121 } 4122 if (!other.ports_.isEmpty()) { 4123 if (ports_.isEmpty()) { 4124 ports_ = other.ports_; 4125 bitField0_ = (bitField0_ & ~0x00400000); 4126 } else { 4127 ensurePortsIsMutable(); 4128 ports_.addAll(other.ports_); 4129 } 4130 onChanged(); 4131 } 4132 if (other.hasPscConnectionId()) { 4133 setPscConnectionId(other.getPscConnectionId()); 4134 } 4135 if (other.hasPscConnectionStatus()) { 4136 pscConnectionStatus_ = other.pscConnectionStatus_; 4137 bitField0_ |= 0x01000000; 4138 onChanged(); 4139 } 4140 if (other.hasRegion()) { 4141 region_ = other.region_; 4142 bitField0_ |= 0x02000000; 4143 onChanged(); 4144 } 4145 if (other.hasSelfLink()) { 4146 selfLink_ = other.selfLink_; 4147 bitField0_ |= 0x04000000; 4148 onChanged(); 4149 } 4150 if (serviceDirectoryRegistrationsBuilder_ == null) { 4151 if (!other.serviceDirectoryRegistrations_.isEmpty()) { 4152 if (serviceDirectoryRegistrations_.isEmpty()) { 4153 serviceDirectoryRegistrations_ = other.serviceDirectoryRegistrations_; 4154 bitField0_ = (bitField0_ & ~0x08000000); 4155 } else { 4156 ensureServiceDirectoryRegistrationsIsMutable(); 4157 serviceDirectoryRegistrations_.addAll(other.serviceDirectoryRegistrations_); 4158 } 4159 onChanged(); 4160 } 4161 } else { 4162 if (!other.serviceDirectoryRegistrations_.isEmpty()) { 4163 if (serviceDirectoryRegistrationsBuilder_.isEmpty()) { 4164 serviceDirectoryRegistrationsBuilder_.dispose(); 4165 serviceDirectoryRegistrationsBuilder_ = null; 4166 serviceDirectoryRegistrations_ = other.serviceDirectoryRegistrations_; 4167 bitField0_ = (bitField0_ & ~0x08000000); 4168 serviceDirectoryRegistrationsBuilder_ = 4169 com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders 4170 ? getServiceDirectoryRegistrationsFieldBuilder() 4171 : null; 4172 } else { 4173 serviceDirectoryRegistrationsBuilder_.addAllMessages( 4174 other.serviceDirectoryRegistrations_); 4175 } 4176 } 4177 } 4178 if (other.hasServiceLabel()) { 4179 serviceLabel_ = other.serviceLabel_; 4180 bitField0_ |= 0x10000000; 4181 onChanged(); 4182 } 4183 if (other.hasServiceName()) { 4184 serviceName_ = other.serviceName_; 4185 bitField0_ |= 0x20000000; 4186 onChanged(); 4187 } 4188 if (!other.sourceIpRanges_.isEmpty()) { 4189 if (sourceIpRanges_.isEmpty()) { 4190 sourceIpRanges_ = other.sourceIpRanges_; 4191 bitField0_ = (bitField0_ & ~0x40000000); 4192 } else { 4193 ensureSourceIpRangesIsMutable(); 4194 sourceIpRanges_.addAll(other.sourceIpRanges_); 4195 } 4196 onChanged(); 4197 } 4198 if (other.hasSubnetwork()) { 4199 subnetwork_ = other.subnetwork_; 4200 bitField0_ |= 0x80000000; 4201 onChanged(); 4202 } 4203 if (other.hasTarget()) { 4204 target_ = other.target_; 4205 bitField1_ |= 0x00000001; 4206 onChanged(); 4207 } 4208 this.mergeUnknownFields(other.getUnknownFields()); 4209 onChanged(); 4210 return this; 4211 } 4212 4213 @java.lang.Override isInitialized()4214 public final boolean isInitialized() { 4215 return true; 4216 } 4217 4218 @java.lang.Override mergeFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4219 public Builder mergeFrom( 4220 com.google.protobuf.CodedInputStream input, 4221 com.google.protobuf.ExtensionRegistryLite extensionRegistry) 4222 throws java.io.IOException { 4223 if (extensionRegistry == null) { 4224 throw new java.lang.NullPointerException(); 4225 } 4226 try { 4227 boolean done = false; 4228 while (!done) { 4229 int tag = input.readTag(); 4230 switch (tag) { 4231 case 0: 4232 done = true; 4233 break; 4234 case 26840: 4235 { 4236 id_ = input.readUInt64(); 4237 bitField0_ |= 0x00000200; 4238 break; 4239 } // case 26840 4240 case 26336418: 4241 { 4242 kind_ = input.readStringRequireUtf8(); 4243 bitField0_ |= 0x00001000; 4244 break; 4245 } // case 26336418 4246 case 26989658: 4247 { 4248 name_ = input.readStringRequireUtf8(); 4249 bitField0_ |= 0x00020000; 4250 break; 4251 } // case 26989658 4252 case 244202930: 4253 { 4254 creationTimestamp_ = input.readStringRequireUtf8(); 4255 bitField0_ |= 0x00000040; 4256 break; 4257 } // case 244202930 4258 case 343815546: 4259 { 4260 iPAddress_ = input.readStringRequireUtf8(); 4261 bitField0_ |= 0x00000001; 4262 break; 4263 } // case 343815546 4264 case 516375928: 4265 { 4266 noAutomateDnsZone_ = input.readBool(); 4267 bitField0_ |= 0x00100000; 4268 break; 4269 } // case 516375928 4270 case 854835346: 4271 { 4272 java.lang.String s = input.readStringRequireUtf8(); 4273 ensurePortsIsMutable(); 4274 ports_.add(s); 4275 break; 4276 } // case 854835346 4277 case 892505682: 4278 { 4279 java.lang.String s = input.readStringRequireUtf8(); 4280 ensureSourceIpRangesIsMutable(); 4281 sourceIpRanges_.add(s); 4282 break; 4283 } // case 892505682 4284 case 954041312: 4285 { 4286 isMirroringCollector_ = input.readBool(); 4287 bitField0_ |= 0x00000800; 4288 break; 4289 } // case 954041312 4290 case 1111570338: 4291 { 4292 region_ = input.readStringRequireUtf8(); 4293 bitField0_ |= 0x02000000; 4294 break; 4295 } // case 1111570338 4296 case 1424998602: 4297 { 4298 labelFingerprint_ = input.readStringRequireUtf8(); 4299 bitField0_ |= 0x00002000; 4300 break; 4301 } // case 1424998602 4302 case 1473193378: 4303 { 4304 pscConnectionStatus_ = input.readStringRequireUtf8(); 4305 bitField0_ |= 0x01000000; 4306 break; 4307 } // case 1473193378 4308 case 1542687882: 4309 { 4310 target_ = input.readStringRequireUtf8(); 4311 bitField1_ |= 0x00000001; 4312 break; 4313 } // case 1542687882 4314 case 1740144634: 4315 { 4316 portRange_ = input.readStringRequireUtf8(); 4317 bitField0_ |= 0x00200000; 4318 break; 4319 } // case 1740144634 4320 case 1788397554: 4321 { 4322 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration m = 4323 input.readMessage( 4324 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration 4325 .parser(), 4326 extensionRegistry); 4327 if (serviceDirectoryRegistrationsBuilder_ == null) { 4328 ensureServiceDirectoryRegistrationsIsMutable(); 4329 serviceDirectoryRegistrations_.add(m); 4330 } else { 4331 serviceDirectoryRegistrationsBuilder_.addMessage(m); 4332 } 4333 break; 4334 } // case 1788397554 4335 case 1862979954: 4336 { 4337 network_ = input.readStringRequireUtf8(); 4338 bitField0_ |= 0x00040000; 4339 break; 4340 } // case 1862979954 4341 case 1877428002: 4342 { 4343 fingerprint_ = input.readStringRequireUtf8(); 4344 bitField0_ |= 0x00000100; 4345 break; 4346 } // case 1877428002 4347 case -1958308120: 4348 { 4349 pscConnectionId_ = input.readUInt64(); 4350 bitField0_ |= 0x00800000; 4351 break; 4352 } // case -1958308120 4353 case -1935290878: 4354 { 4355 ipVersion_ = input.readStringRequireUtf8(); 4356 bitField0_ |= 0x00000400; 4357 break; 4358 } // case -1935290878 4359 case -1839398830: 4360 { 4361 backendService_ = input.readStringRequireUtf8(); 4362 bitField0_ |= 0x00000010; 4363 break; 4364 } // case -1839398830 4365 case -1832345742: 4366 { 4367 subnetwork_ = input.readStringRequireUtf8(); 4368 bitField0_ |= 0x80000000; 4369 break; 4370 } // case -1832345742 4371 case -1415926102: 4372 { 4373 serviceName_ = input.readStringRequireUtf8(); 4374 bitField0_ |= 0x20000000; 4375 break; 4376 } // case -1415926102 4377 case -1383845342: 4378 { 4379 loadBalancingScheme_ = input.readStringRequireUtf8(); 4380 bitField0_ |= 0x00008000; 4381 break; 4382 } // case -1383845342 4383 case -958896302: 4384 { 4385 serviceLabel_ = input.readStringRequireUtf8(); 4386 bitField0_ |= 0x10000000; 4387 break; 4388 } // case -958896302 4389 case -911466526: 4390 { 4391 description_ = input.readStringRequireUtf8(); 4392 bitField0_ |= 0x00000080; 4393 break; 4394 } // case -911466526 4395 case -733560928: 4396 { 4397 allPorts_ = input.readBool(); 4398 bitField0_ |= 0x00000004; 4399 break; 4400 } // case -733560928 4401 case -645248918: 4402 { 4403 selfLink_ = input.readStringRequireUtf8(); 4404 bitField0_ |= 0x04000000; 4405 break; 4406 } // case -645248918 4407 case -577161382: 4408 { 4409 com.google.cloud.compute.v1.MetadataFilter m = 4410 input.readMessage( 4411 com.google.cloud.compute.v1.MetadataFilter.parser(), extensionRegistry); 4412 if (metadataFiltersBuilder_ == null) { 4413 ensureMetadataFiltersIsMutable(); 4414 metadataFilters_.add(m); 4415 } else { 4416 metadataFiltersBuilder_.addMessage(m); 4417 } 4418 break; 4419 } // case -577161382 4420 case -390211094: 4421 { 4422 iPProtocol_ = input.readStringRequireUtf8(); 4423 bitField0_ |= 0x00000002; 4424 break; 4425 } // case -390211094 4426 case -299689904: 4427 { 4428 allowGlobalAccess_ = input.readBool(); 4429 bitField0_ |= 0x00000008; 4430 break; 4431 } // case -299689904 4432 case -293404678: 4433 { 4434 com.google.protobuf.MapEntry<java.lang.String, java.lang.String> labels__ = 4435 input.readMessage( 4436 LabelsDefaultEntryHolder.defaultEntry.getParserForType(), 4437 extensionRegistry); 4438 internalGetMutableLabels() 4439 .getMutableMap() 4440 .put(labels__.getKey(), labels__.getValue()); 4441 bitField0_ |= 0x00004000; 4442 break; 4443 } // case -293404678 4444 case -155784550: 4445 { 4446 networkTier_ = input.readStringRequireUtf8(); 4447 bitField0_ |= 0x00080000; 4448 break; 4449 } // case -155784550 4450 case -95982462: 4451 { 4452 baseForwardingRule_ = input.readStringRequireUtf8(); 4453 bitField0_ |= 0x00000020; 4454 break; 4455 } // case -95982462 4456 default: 4457 { 4458 if (!super.parseUnknownField(input, extensionRegistry, tag)) { 4459 done = true; // was an endgroup tag 4460 } 4461 break; 4462 } // default: 4463 } // switch (tag) 4464 } // while (!done) 4465 } catch (com.google.protobuf.InvalidProtocolBufferException e) { 4466 throw e.unwrapIOException(); 4467 } finally { 4468 onChanged(); 4469 } // finally 4470 return this; 4471 } 4472 4473 private int bitField0_; 4474 private int bitField1_; 4475 4476 private java.lang.Object iPAddress_ = ""; 4477 /** 4478 * 4479 * 4480 * <pre> 4481 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 4482 * </pre> 4483 * 4484 * <code>optional string I_p_address = 42976943;</code> 4485 * 4486 * @return Whether the iPAddress field is set. 4487 */ hasIPAddress()4488 public boolean hasIPAddress() { 4489 return ((bitField0_ & 0x00000001) != 0); 4490 } 4491 /** 4492 * 4493 * 4494 * <pre> 4495 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 4496 * </pre> 4497 * 4498 * <code>optional string I_p_address = 42976943;</code> 4499 * 4500 * @return The iPAddress. 4501 */ getIPAddress()4502 public java.lang.String getIPAddress() { 4503 java.lang.Object ref = iPAddress_; 4504 if (!(ref instanceof java.lang.String)) { 4505 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 4506 java.lang.String s = bs.toStringUtf8(); 4507 iPAddress_ = s; 4508 return s; 4509 } else { 4510 return (java.lang.String) ref; 4511 } 4512 } 4513 /** 4514 * 4515 * 4516 * <pre> 4517 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 4518 * </pre> 4519 * 4520 * <code>optional string I_p_address = 42976943;</code> 4521 * 4522 * @return The bytes for iPAddress. 4523 */ getIPAddressBytes()4524 public com.google.protobuf.ByteString getIPAddressBytes() { 4525 java.lang.Object ref = iPAddress_; 4526 if (ref instanceof String) { 4527 com.google.protobuf.ByteString b = 4528 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 4529 iPAddress_ = b; 4530 return b; 4531 } else { 4532 return (com.google.protobuf.ByteString) ref; 4533 } 4534 } 4535 /** 4536 * 4537 * 4538 * <pre> 4539 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 4540 * </pre> 4541 * 4542 * <code>optional string I_p_address = 42976943;</code> 4543 * 4544 * @param value The iPAddress to set. 4545 * @return This builder for chaining. 4546 */ setIPAddress(java.lang.String value)4547 public Builder setIPAddress(java.lang.String value) { 4548 if (value == null) { 4549 throw new NullPointerException(); 4550 } 4551 iPAddress_ = value; 4552 bitField0_ |= 0x00000001; 4553 onChanged(); 4554 return this; 4555 } 4556 /** 4557 * 4558 * 4559 * <pre> 4560 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 4561 * </pre> 4562 * 4563 * <code>optional string I_p_address = 42976943;</code> 4564 * 4565 * @return This builder for chaining. 4566 */ clearIPAddress()4567 public Builder clearIPAddress() { 4568 iPAddress_ = getDefaultInstance().getIPAddress(); 4569 bitField0_ = (bitField0_ & ~0x00000001); 4570 onChanged(); 4571 return this; 4572 } 4573 /** 4574 * 4575 * 4576 * <pre> 4577 * IP address for which this forwarding rule accepts traffic. When a client sends traffic to this IP address, the forwarding rule directs the traffic to the referenced target or backendService. While creating a forwarding rule, specifying an IPAddress is required under the following circumstances: - When the target is set to targetGrpcProxy and validateForProxyless is set to true, the IPAddress should be set to 0.0.0.0. - When the target is a Private Service Connect Google APIs bundle, you must specify an IPAddress. Otherwise, you can optionally specify an IP address that references an existing static (reserved) IP address resource. When omitted, Google Cloud assigns an ephemeral IP address. Use one of the following formats to specify an IP address while creating a forwarding rule: * IP address number, as in `100.1.2.3` * IPv6 address range, as in `2600:1234::/96` * Full resource URL, as in https://www.googleapis.com/compute/v1/projects/ project_id/regions/region/addresses/address-name * Partial URL or by name, as in: - projects/project_id/regions/region/addresses/address-name - regions/region/addresses/address-name - global/addresses/address-name - address-name The forwarding rule's target or backendService, and in most cases, also the loadBalancingScheme, determine the type of IP address that you can use. For detailed information, see [IP address specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). When reading an IPAddress, the API always returns the IP address number. 4578 * </pre> 4579 * 4580 * <code>optional string I_p_address = 42976943;</code> 4581 * 4582 * @param value The bytes for iPAddress to set. 4583 * @return This builder for chaining. 4584 */ setIPAddressBytes(com.google.protobuf.ByteString value)4585 public Builder setIPAddressBytes(com.google.protobuf.ByteString value) { 4586 if (value == null) { 4587 throw new NullPointerException(); 4588 } 4589 checkByteStringIsUtf8(value); 4590 iPAddress_ = value; 4591 bitField0_ |= 0x00000001; 4592 onChanged(); 4593 return this; 4594 } 4595 4596 private java.lang.Object iPProtocol_ = ""; 4597 /** 4598 * 4599 * 4600 * <pre> 4601 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 4602 * Check the IPProtocolEnum enum for the list of possible values. 4603 * </pre> 4604 * 4605 * <code>optional string I_p_protocol = 488094525;</code> 4606 * 4607 * @return Whether the iPProtocol field is set. 4608 */ hasIPProtocol()4609 public boolean hasIPProtocol() { 4610 return ((bitField0_ & 0x00000002) != 0); 4611 } 4612 /** 4613 * 4614 * 4615 * <pre> 4616 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 4617 * Check the IPProtocolEnum enum for the list of possible values. 4618 * </pre> 4619 * 4620 * <code>optional string I_p_protocol = 488094525;</code> 4621 * 4622 * @return The iPProtocol. 4623 */ getIPProtocol()4624 public java.lang.String getIPProtocol() { 4625 java.lang.Object ref = iPProtocol_; 4626 if (!(ref instanceof java.lang.String)) { 4627 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 4628 java.lang.String s = bs.toStringUtf8(); 4629 iPProtocol_ = s; 4630 return s; 4631 } else { 4632 return (java.lang.String) ref; 4633 } 4634 } 4635 /** 4636 * 4637 * 4638 * <pre> 4639 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 4640 * Check the IPProtocolEnum enum for the list of possible values. 4641 * </pre> 4642 * 4643 * <code>optional string I_p_protocol = 488094525;</code> 4644 * 4645 * @return The bytes for iPProtocol. 4646 */ getIPProtocolBytes()4647 public com.google.protobuf.ByteString getIPProtocolBytes() { 4648 java.lang.Object ref = iPProtocol_; 4649 if (ref instanceof String) { 4650 com.google.protobuf.ByteString b = 4651 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 4652 iPProtocol_ = b; 4653 return b; 4654 } else { 4655 return (com.google.protobuf.ByteString) ref; 4656 } 4657 } 4658 /** 4659 * 4660 * 4661 * <pre> 4662 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 4663 * Check the IPProtocolEnum enum for the list of possible values. 4664 * </pre> 4665 * 4666 * <code>optional string I_p_protocol = 488094525;</code> 4667 * 4668 * @param value The iPProtocol to set. 4669 * @return This builder for chaining. 4670 */ setIPProtocol(java.lang.String value)4671 public Builder setIPProtocol(java.lang.String value) { 4672 if (value == null) { 4673 throw new NullPointerException(); 4674 } 4675 iPProtocol_ = value; 4676 bitField0_ |= 0x00000002; 4677 onChanged(); 4678 return this; 4679 } 4680 /** 4681 * 4682 * 4683 * <pre> 4684 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 4685 * Check the IPProtocolEnum enum for the list of possible values. 4686 * </pre> 4687 * 4688 * <code>optional string I_p_protocol = 488094525;</code> 4689 * 4690 * @return This builder for chaining. 4691 */ clearIPProtocol()4692 public Builder clearIPProtocol() { 4693 iPProtocol_ = getDefaultInstance().getIPProtocol(); 4694 bitField0_ = (bitField0_ & ~0x00000002); 4695 onChanged(); 4696 return this; 4697 } 4698 /** 4699 * 4700 * 4701 * <pre> 4702 * The IP protocol to which this rule applies. For protocol forwarding, valid options are TCP, UDP, ESP, AH, SCTP, ICMP and L3_DEFAULT. The valid IP protocols are different for different load balancing products as described in [Load balancing features](https://cloud.google.com/load-balancing/docs/features#protocols_from_the_load_balancer_to_the_backends). 4703 * Check the IPProtocolEnum enum for the list of possible values. 4704 * </pre> 4705 * 4706 * <code>optional string I_p_protocol = 488094525;</code> 4707 * 4708 * @param value The bytes for iPProtocol to set. 4709 * @return This builder for chaining. 4710 */ setIPProtocolBytes(com.google.protobuf.ByteString value)4711 public Builder setIPProtocolBytes(com.google.protobuf.ByteString value) { 4712 if (value == null) { 4713 throw new NullPointerException(); 4714 } 4715 checkByteStringIsUtf8(value); 4716 iPProtocol_ = value; 4717 bitField0_ |= 0x00000002; 4718 onChanged(); 4719 return this; 4720 } 4721 4722 private boolean allPorts_; 4723 /** 4724 * 4725 * 4726 * <pre> 4727 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal and external protocol forwarding. Set this field to true to allow packets addressed to any port or packets lacking destination port information (for example, UDP fragments after the first fragment) to be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. 4728 * </pre> 4729 * 4730 * <code>optional bool all_ports = 445175796;</code> 4731 * 4732 * @return Whether the allPorts field is set. 4733 */ 4734 @java.lang.Override hasAllPorts()4735 public boolean hasAllPorts() { 4736 return ((bitField0_ & 0x00000004) != 0); 4737 } 4738 /** 4739 * 4740 * 4741 * <pre> 4742 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal and external protocol forwarding. Set this field to true to allow packets addressed to any port or packets lacking destination port information (for example, UDP fragments after the first fragment) to be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. 4743 * </pre> 4744 * 4745 * <code>optional bool all_ports = 445175796;</code> 4746 * 4747 * @return The allPorts. 4748 */ 4749 @java.lang.Override getAllPorts()4750 public boolean getAllPorts() { 4751 return allPorts_; 4752 } 4753 /** 4754 * 4755 * 4756 * <pre> 4757 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal and external protocol forwarding. Set this field to true to allow packets addressed to any port or packets lacking destination port information (for example, UDP fragments after the first fragment) to be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. 4758 * </pre> 4759 * 4760 * <code>optional bool all_ports = 445175796;</code> 4761 * 4762 * @param value The allPorts to set. 4763 * @return This builder for chaining. 4764 */ setAllPorts(boolean value)4765 public Builder setAllPorts(boolean value) { 4766 4767 allPorts_ = value; 4768 bitField0_ |= 0x00000004; 4769 onChanged(); 4770 return this; 4771 } 4772 /** 4773 * 4774 * 4775 * <pre> 4776 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal and external protocol forwarding. Set this field to true to allow packets addressed to any port or packets lacking destination port information (for example, UDP fragments after the first fragment) to be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. 4777 * </pre> 4778 * 4779 * <code>optional bool all_ports = 445175796;</code> 4780 * 4781 * @return This builder for chaining. 4782 */ clearAllPorts()4783 public Builder clearAllPorts() { 4784 bitField0_ = (bitField0_ & ~0x00000004); 4785 allPorts_ = false; 4786 onChanged(); 4787 return this; 4788 } 4789 4790 private boolean allowGlobalAccess_; 4791 /** 4792 * 4793 * 4794 * <pre> 4795 * This field is used along with the backend_service field for internal load balancing or with the target field for internal TargetInstance. If the field is set to TRUE, clients can access ILB from all regions. Otherwise only allows access from clients in the same region as the internal load balancer. 4796 * </pre> 4797 * 4798 * <code>optional bool allow_global_access = 499409674;</code> 4799 * 4800 * @return Whether the allowGlobalAccess field is set. 4801 */ 4802 @java.lang.Override hasAllowGlobalAccess()4803 public boolean hasAllowGlobalAccess() { 4804 return ((bitField0_ & 0x00000008) != 0); 4805 } 4806 /** 4807 * 4808 * 4809 * <pre> 4810 * This field is used along with the backend_service field for internal load balancing or with the target field for internal TargetInstance. If the field is set to TRUE, clients can access ILB from all regions. Otherwise only allows access from clients in the same region as the internal load balancer. 4811 * </pre> 4812 * 4813 * <code>optional bool allow_global_access = 499409674;</code> 4814 * 4815 * @return The allowGlobalAccess. 4816 */ 4817 @java.lang.Override getAllowGlobalAccess()4818 public boolean getAllowGlobalAccess() { 4819 return allowGlobalAccess_; 4820 } 4821 /** 4822 * 4823 * 4824 * <pre> 4825 * This field is used along with the backend_service field for internal load balancing or with the target field for internal TargetInstance. If the field is set to TRUE, clients can access ILB from all regions. Otherwise only allows access from clients in the same region as the internal load balancer. 4826 * </pre> 4827 * 4828 * <code>optional bool allow_global_access = 499409674;</code> 4829 * 4830 * @param value The allowGlobalAccess to set. 4831 * @return This builder for chaining. 4832 */ setAllowGlobalAccess(boolean value)4833 public Builder setAllowGlobalAccess(boolean value) { 4834 4835 allowGlobalAccess_ = value; 4836 bitField0_ |= 0x00000008; 4837 onChanged(); 4838 return this; 4839 } 4840 /** 4841 * 4842 * 4843 * <pre> 4844 * This field is used along with the backend_service field for internal load balancing or with the target field for internal TargetInstance. If the field is set to TRUE, clients can access ILB from all regions. Otherwise only allows access from clients in the same region as the internal load balancer. 4845 * </pre> 4846 * 4847 * <code>optional bool allow_global_access = 499409674;</code> 4848 * 4849 * @return This builder for chaining. 4850 */ clearAllowGlobalAccess()4851 public Builder clearAllowGlobalAccess() { 4852 bitField0_ = (bitField0_ & ~0x00000008); 4853 allowGlobalAccess_ = false; 4854 onChanged(); 4855 return this; 4856 } 4857 4858 private java.lang.Object backendService_ = ""; 4859 /** 4860 * 4861 * 4862 * <pre> 4863 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 4864 * </pre> 4865 * 4866 * <code>optional string backend_service = 306946058;</code> 4867 * 4868 * @return Whether the backendService field is set. 4869 */ hasBackendService()4870 public boolean hasBackendService() { 4871 return ((bitField0_ & 0x00000010) != 0); 4872 } 4873 /** 4874 * 4875 * 4876 * <pre> 4877 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 4878 * </pre> 4879 * 4880 * <code>optional string backend_service = 306946058;</code> 4881 * 4882 * @return The backendService. 4883 */ getBackendService()4884 public java.lang.String getBackendService() { 4885 java.lang.Object ref = backendService_; 4886 if (!(ref instanceof java.lang.String)) { 4887 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 4888 java.lang.String s = bs.toStringUtf8(); 4889 backendService_ = s; 4890 return s; 4891 } else { 4892 return (java.lang.String) ref; 4893 } 4894 } 4895 /** 4896 * 4897 * 4898 * <pre> 4899 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 4900 * </pre> 4901 * 4902 * <code>optional string backend_service = 306946058;</code> 4903 * 4904 * @return The bytes for backendService. 4905 */ getBackendServiceBytes()4906 public com.google.protobuf.ByteString getBackendServiceBytes() { 4907 java.lang.Object ref = backendService_; 4908 if (ref instanceof String) { 4909 com.google.protobuf.ByteString b = 4910 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 4911 backendService_ = b; 4912 return b; 4913 } else { 4914 return (com.google.protobuf.ByteString) ref; 4915 } 4916 } 4917 /** 4918 * 4919 * 4920 * <pre> 4921 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 4922 * </pre> 4923 * 4924 * <code>optional string backend_service = 306946058;</code> 4925 * 4926 * @param value The backendService to set. 4927 * @return This builder for chaining. 4928 */ setBackendService(java.lang.String value)4929 public Builder setBackendService(java.lang.String value) { 4930 if (value == null) { 4931 throw new NullPointerException(); 4932 } 4933 backendService_ = value; 4934 bitField0_ |= 0x00000010; 4935 onChanged(); 4936 return this; 4937 } 4938 /** 4939 * 4940 * 4941 * <pre> 4942 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 4943 * </pre> 4944 * 4945 * <code>optional string backend_service = 306946058;</code> 4946 * 4947 * @return This builder for chaining. 4948 */ clearBackendService()4949 public Builder clearBackendService() { 4950 backendService_ = getDefaultInstance().getBackendService(); 4951 bitField0_ = (bitField0_ & ~0x00000010); 4952 onChanged(); 4953 return this; 4954 } 4955 /** 4956 * 4957 * 4958 * <pre> 4959 * Identifies the backend service to which the forwarding rule sends traffic. Required for Internal TCP/UDP Load Balancing and Network Load Balancing; must be omitted for all other load balancer types. 4960 * </pre> 4961 * 4962 * <code>optional string backend_service = 306946058;</code> 4963 * 4964 * @param value The bytes for backendService to set. 4965 * @return This builder for chaining. 4966 */ setBackendServiceBytes(com.google.protobuf.ByteString value)4967 public Builder setBackendServiceBytes(com.google.protobuf.ByteString value) { 4968 if (value == null) { 4969 throw new NullPointerException(); 4970 } 4971 checkByteStringIsUtf8(value); 4972 backendService_ = value; 4973 bitField0_ |= 0x00000010; 4974 onChanged(); 4975 return this; 4976 } 4977 4978 private java.lang.Object baseForwardingRule_ = ""; 4979 /** 4980 * 4981 * 4982 * <pre> 4983 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 4984 * </pre> 4985 * 4986 * <code>optional string base_forwarding_rule = 524873104;</code> 4987 * 4988 * @return Whether the baseForwardingRule field is set. 4989 */ hasBaseForwardingRule()4990 public boolean hasBaseForwardingRule() { 4991 return ((bitField0_ & 0x00000020) != 0); 4992 } 4993 /** 4994 * 4995 * 4996 * <pre> 4997 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 4998 * </pre> 4999 * 5000 * <code>optional string base_forwarding_rule = 524873104;</code> 5001 * 5002 * @return The baseForwardingRule. 5003 */ getBaseForwardingRule()5004 public java.lang.String getBaseForwardingRule() { 5005 java.lang.Object ref = baseForwardingRule_; 5006 if (!(ref instanceof java.lang.String)) { 5007 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 5008 java.lang.String s = bs.toStringUtf8(); 5009 baseForwardingRule_ = s; 5010 return s; 5011 } else { 5012 return (java.lang.String) ref; 5013 } 5014 } 5015 /** 5016 * 5017 * 5018 * <pre> 5019 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 5020 * </pre> 5021 * 5022 * <code>optional string base_forwarding_rule = 524873104;</code> 5023 * 5024 * @return The bytes for baseForwardingRule. 5025 */ getBaseForwardingRuleBytes()5026 public com.google.protobuf.ByteString getBaseForwardingRuleBytes() { 5027 java.lang.Object ref = baseForwardingRule_; 5028 if (ref instanceof String) { 5029 com.google.protobuf.ByteString b = 5030 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 5031 baseForwardingRule_ = b; 5032 return b; 5033 } else { 5034 return (com.google.protobuf.ByteString) ref; 5035 } 5036 } 5037 /** 5038 * 5039 * 5040 * <pre> 5041 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 5042 * </pre> 5043 * 5044 * <code>optional string base_forwarding_rule = 524873104;</code> 5045 * 5046 * @param value The baseForwardingRule to set. 5047 * @return This builder for chaining. 5048 */ setBaseForwardingRule(java.lang.String value)5049 public Builder setBaseForwardingRule(java.lang.String value) { 5050 if (value == null) { 5051 throw new NullPointerException(); 5052 } 5053 baseForwardingRule_ = value; 5054 bitField0_ |= 0x00000020; 5055 onChanged(); 5056 return this; 5057 } 5058 /** 5059 * 5060 * 5061 * <pre> 5062 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 5063 * </pre> 5064 * 5065 * <code>optional string base_forwarding_rule = 524873104;</code> 5066 * 5067 * @return This builder for chaining. 5068 */ clearBaseForwardingRule()5069 public Builder clearBaseForwardingRule() { 5070 baseForwardingRule_ = getDefaultInstance().getBaseForwardingRule(); 5071 bitField0_ = (bitField0_ & ~0x00000020); 5072 onChanged(); 5073 return this; 5074 } 5075 /** 5076 * 5077 * 5078 * <pre> 5079 * [Output Only] The URL for the corresponding base Forwarding Rule. By base Forwarding Rule, we mean the Forwarding Rule that has the same IP address, protocol, and port settings with the current Forwarding Rule, but without sourceIPRanges specified. Always empty if the current Forwarding Rule does not have sourceIPRanges specified. 5080 * </pre> 5081 * 5082 * <code>optional string base_forwarding_rule = 524873104;</code> 5083 * 5084 * @param value The bytes for baseForwardingRule to set. 5085 * @return This builder for chaining. 5086 */ setBaseForwardingRuleBytes(com.google.protobuf.ByteString value)5087 public Builder setBaseForwardingRuleBytes(com.google.protobuf.ByteString value) { 5088 if (value == null) { 5089 throw new NullPointerException(); 5090 } 5091 checkByteStringIsUtf8(value); 5092 baseForwardingRule_ = value; 5093 bitField0_ |= 0x00000020; 5094 onChanged(); 5095 return this; 5096 } 5097 5098 private java.lang.Object creationTimestamp_ = ""; 5099 /** 5100 * 5101 * 5102 * <pre> 5103 * [Output Only] Creation timestamp in RFC3339 text format. 5104 * </pre> 5105 * 5106 * <code>optional string creation_timestamp = 30525366;</code> 5107 * 5108 * @return Whether the creationTimestamp field is set. 5109 */ hasCreationTimestamp()5110 public boolean hasCreationTimestamp() { 5111 return ((bitField0_ & 0x00000040) != 0); 5112 } 5113 /** 5114 * 5115 * 5116 * <pre> 5117 * [Output Only] Creation timestamp in RFC3339 text format. 5118 * </pre> 5119 * 5120 * <code>optional string creation_timestamp = 30525366;</code> 5121 * 5122 * @return The creationTimestamp. 5123 */ getCreationTimestamp()5124 public java.lang.String getCreationTimestamp() { 5125 java.lang.Object ref = creationTimestamp_; 5126 if (!(ref instanceof java.lang.String)) { 5127 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 5128 java.lang.String s = bs.toStringUtf8(); 5129 creationTimestamp_ = s; 5130 return s; 5131 } else { 5132 return (java.lang.String) ref; 5133 } 5134 } 5135 /** 5136 * 5137 * 5138 * <pre> 5139 * [Output Only] Creation timestamp in RFC3339 text format. 5140 * </pre> 5141 * 5142 * <code>optional string creation_timestamp = 30525366;</code> 5143 * 5144 * @return The bytes for creationTimestamp. 5145 */ getCreationTimestampBytes()5146 public com.google.protobuf.ByteString getCreationTimestampBytes() { 5147 java.lang.Object ref = creationTimestamp_; 5148 if (ref instanceof String) { 5149 com.google.protobuf.ByteString b = 5150 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 5151 creationTimestamp_ = b; 5152 return b; 5153 } else { 5154 return (com.google.protobuf.ByteString) ref; 5155 } 5156 } 5157 /** 5158 * 5159 * 5160 * <pre> 5161 * [Output Only] Creation timestamp in RFC3339 text format. 5162 * </pre> 5163 * 5164 * <code>optional string creation_timestamp = 30525366;</code> 5165 * 5166 * @param value The creationTimestamp to set. 5167 * @return This builder for chaining. 5168 */ setCreationTimestamp(java.lang.String value)5169 public Builder setCreationTimestamp(java.lang.String value) { 5170 if (value == null) { 5171 throw new NullPointerException(); 5172 } 5173 creationTimestamp_ = value; 5174 bitField0_ |= 0x00000040; 5175 onChanged(); 5176 return this; 5177 } 5178 /** 5179 * 5180 * 5181 * <pre> 5182 * [Output Only] Creation timestamp in RFC3339 text format. 5183 * </pre> 5184 * 5185 * <code>optional string creation_timestamp = 30525366;</code> 5186 * 5187 * @return This builder for chaining. 5188 */ clearCreationTimestamp()5189 public Builder clearCreationTimestamp() { 5190 creationTimestamp_ = getDefaultInstance().getCreationTimestamp(); 5191 bitField0_ = (bitField0_ & ~0x00000040); 5192 onChanged(); 5193 return this; 5194 } 5195 /** 5196 * 5197 * 5198 * <pre> 5199 * [Output Only] Creation timestamp in RFC3339 text format. 5200 * </pre> 5201 * 5202 * <code>optional string creation_timestamp = 30525366;</code> 5203 * 5204 * @param value The bytes for creationTimestamp to set. 5205 * @return This builder for chaining. 5206 */ setCreationTimestampBytes(com.google.protobuf.ByteString value)5207 public Builder setCreationTimestampBytes(com.google.protobuf.ByteString value) { 5208 if (value == null) { 5209 throw new NullPointerException(); 5210 } 5211 checkByteStringIsUtf8(value); 5212 creationTimestamp_ = value; 5213 bitField0_ |= 0x00000040; 5214 onChanged(); 5215 return this; 5216 } 5217 5218 private java.lang.Object description_ = ""; 5219 /** 5220 * 5221 * 5222 * <pre> 5223 * An optional description of this resource. Provide this property when you create the resource. 5224 * </pre> 5225 * 5226 * <code>optional string description = 422937596;</code> 5227 * 5228 * @return Whether the description field is set. 5229 */ hasDescription()5230 public boolean hasDescription() { 5231 return ((bitField0_ & 0x00000080) != 0); 5232 } 5233 /** 5234 * 5235 * 5236 * <pre> 5237 * An optional description of this resource. Provide this property when you create the resource. 5238 * </pre> 5239 * 5240 * <code>optional string description = 422937596;</code> 5241 * 5242 * @return The description. 5243 */ getDescription()5244 public java.lang.String getDescription() { 5245 java.lang.Object ref = description_; 5246 if (!(ref instanceof java.lang.String)) { 5247 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 5248 java.lang.String s = bs.toStringUtf8(); 5249 description_ = s; 5250 return s; 5251 } else { 5252 return (java.lang.String) ref; 5253 } 5254 } 5255 /** 5256 * 5257 * 5258 * <pre> 5259 * An optional description of this resource. Provide this property when you create the resource. 5260 * </pre> 5261 * 5262 * <code>optional string description = 422937596;</code> 5263 * 5264 * @return The bytes for description. 5265 */ getDescriptionBytes()5266 public com.google.protobuf.ByteString getDescriptionBytes() { 5267 java.lang.Object ref = description_; 5268 if (ref instanceof String) { 5269 com.google.protobuf.ByteString b = 5270 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 5271 description_ = b; 5272 return b; 5273 } else { 5274 return (com.google.protobuf.ByteString) ref; 5275 } 5276 } 5277 /** 5278 * 5279 * 5280 * <pre> 5281 * An optional description of this resource. Provide this property when you create the resource. 5282 * </pre> 5283 * 5284 * <code>optional string description = 422937596;</code> 5285 * 5286 * @param value The description to set. 5287 * @return This builder for chaining. 5288 */ setDescription(java.lang.String value)5289 public Builder setDescription(java.lang.String value) { 5290 if (value == null) { 5291 throw new NullPointerException(); 5292 } 5293 description_ = value; 5294 bitField0_ |= 0x00000080; 5295 onChanged(); 5296 return this; 5297 } 5298 /** 5299 * 5300 * 5301 * <pre> 5302 * An optional description of this resource. Provide this property when you create the resource. 5303 * </pre> 5304 * 5305 * <code>optional string description = 422937596;</code> 5306 * 5307 * @return This builder for chaining. 5308 */ clearDescription()5309 public Builder clearDescription() { 5310 description_ = getDefaultInstance().getDescription(); 5311 bitField0_ = (bitField0_ & ~0x00000080); 5312 onChanged(); 5313 return this; 5314 } 5315 /** 5316 * 5317 * 5318 * <pre> 5319 * An optional description of this resource. Provide this property when you create the resource. 5320 * </pre> 5321 * 5322 * <code>optional string description = 422937596;</code> 5323 * 5324 * @param value The bytes for description to set. 5325 * @return This builder for chaining. 5326 */ setDescriptionBytes(com.google.protobuf.ByteString value)5327 public Builder setDescriptionBytes(com.google.protobuf.ByteString value) { 5328 if (value == null) { 5329 throw new NullPointerException(); 5330 } 5331 checkByteStringIsUtf8(value); 5332 description_ = value; 5333 bitField0_ |= 0x00000080; 5334 onChanged(); 5335 return this; 5336 } 5337 5338 private java.lang.Object fingerprint_ = ""; 5339 /** 5340 * 5341 * 5342 * <pre> 5343 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5344 * </pre> 5345 * 5346 * <code>optional string fingerprint = 234678500;</code> 5347 * 5348 * @return Whether the fingerprint field is set. 5349 */ hasFingerprint()5350 public boolean hasFingerprint() { 5351 return ((bitField0_ & 0x00000100) != 0); 5352 } 5353 /** 5354 * 5355 * 5356 * <pre> 5357 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5358 * </pre> 5359 * 5360 * <code>optional string fingerprint = 234678500;</code> 5361 * 5362 * @return The fingerprint. 5363 */ getFingerprint()5364 public java.lang.String getFingerprint() { 5365 java.lang.Object ref = fingerprint_; 5366 if (!(ref instanceof java.lang.String)) { 5367 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 5368 java.lang.String s = bs.toStringUtf8(); 5369 fingerprint_ = s; 5370 return s; 5371 } else { 5372 return (java.lang.String) ref; 5373 } 5374 } 5375 /** 5376 * 5377 * 5378 * <pre> 5379 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5380 * </pre> 5381 * 5382 * <code>optional string fingerprint = 234678500;</code> 5383 * 5384 * @return The bytes for fingerprint. 5385 */ getFingerprintBytes()5386 public com.google.protobuf.ByteString getFingerprintBytes() { 5387 java.lang.Object ref = fingerprint_; 5388 if (ref instanceof String) { 5389 com.google.protobuf.ByteString b = 5390 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 5391 fingerprint_ = b; 5392 return b; 5393 } else { 5394 return (com.google.protobuf.ByteString) ref; 5395 } 5396 } 5397 /** 5398 * 5399 * 5400 * <pre> 5401 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5402 * </pre> 5403 * 5404 * <code>optional string fingerprint = 234678500;</code> 5405 * 5406 * @param value The fingerprint to set. 5407 * @return This builder for chaining. 5408 */ setFingerprint(java.lang.String value)5409 public Builder setFingerprint(java.lang.String value) { 5410 if (value == null) { 5411 throw new NullPointerException(); 5412 } 5413 fingerprint_ = value; 5414 bitField0_ |= 0x00000100; 5415 onChanged(); 5416 return this; 5417 } 5418 /** 5419 * 5420 * 5421 * <pre> 5422 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5423 * </pre> 5424 * 5425 * <code>optional string fingerprint = 234678500;</code> 5426 * 5427 * @return This builder for chaining. 5428 */ clearFingerprint()5429 public Builder clearFingerprint() { 5430 fingerprint_ = getDefaultInstance().getFingerprint(); 5431 bitField0_ = (bitField0_ & ~0x00000100); 5432 onChanged(); 5433 return this; 5434 } 5435 /** 5436 * 5437 * 5438 * <pre> 5439 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a ForwardingRule. Include the fingerprint in patch request to ensure that you do not overwrite changes that were applied from another concurrent request. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5440 * </pre> 5441 * 5442 * <code>optional string fingerprint = 234678500;</code> 5443 * 5444 * @param value The bytes for fingerprint to set. 5445 * @return This builder for chaining. 5446 */ setFingerprintBytes(com.google.protobuf.ByteString value)5447 public Builder setFingerprintBytes(com.google.protobuf.ByteString value) { 5448 if (value == null) { 5449 throw new NullPointerException(); 5450 } 5451 checkByteStringIsUtf8(value); 5452 fingerprint_ = value; 5453 bitField0_ |= 0x00000100; 5454 onChanged(); 5455 return this; 5456 } 5457 5458 private long id_; 5459 /** 5460 * 5461 * 5462 * <pre> 5463 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 5464 * </pre> 5465 * 5466 * <code>optional uint64 id = 3355;</code> 5467 * 5468 * @return Whether the id field is set. 5469 */ 5470 @java.lang.Override hasId()5471 public boolean hasId() { 5472 return ((bitField0_ & 0x00000200) != 0); 5473 } 5474 /** 5475 * 5476 * 5477 * <pre> 5478 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 5479 * </pre> 5480 * 5481 * <code>optional uint64 id = 3355;</code> 5482 * 5483 * @return The id. 5484 */ 5485 @java.lang.Override getId()5486 public long getId() { 5487 return id_; 5488 } 5489 /** 5490 * 5491 * 5492 * <pre> 5493 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 5494 * </pre> 5495 * 5496 * <code>optional uint64 id = 3355;</code> 5497 * 5498 * @param value The id to set. 5499 * @return This builder for chaining. 5500 */ setId(long value)5501 public Builder setId(long value) { 5502 5503 id_ = value; 5504 bitField0_ |= 0x00000200; 5505 onChanged(); 5506 return this; 5507 } 5508 /** 5509 * 5510 * 5511 * <pre> 5512 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 5513 * </pre> 5514 * 5515 * <code>optional uint64 id = 3355;</code> 5516 * 5517 * @return This builder for chaining. 5518 */ clearId()5519 public Builder clearId() { 5520 bitField0_ = (bitField0_ & ~0x00000200); 5521 id_ = 0L; 5522 onChanged(); 5523 return this; 5524 } 5525 5526 private java.lang.Object ipVersion_ = ""; 5527 /** 5528 * 5529 * 5530 * <pre> 5531 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 5532 * Check the IpVersion enum for the list of possible values. 5533 * </pre> 5534 * 5535 * <code>optional string ip_version = 294959552;</code> 5536 * 5537 * @return Whether the ipVersion field is set. 5538 */ hasIpVersion()5539 public boolean hasIpVersion() { 5540 return ((bitField0_ & 0x00000400) != 0); 5541 } 5542 /** 5543 * 5544 * 5545 * <pre> 5546 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 5547 * Check the IpVersion enum for the list of possible values. 5548 * </pre> 5549 * 5550 * <code>optional string ip_version = 294959552;</code> 5551 * 5552 * @return The ipVersion. 5553 */ getIpVersion()5554 public java.lang.String getIpVersion() { 5555 java.lang.Object ref = ipVersion_; 5556 if (!(ref instanceof java.lang.String)) { 5557 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 5558 java.lang.String s = bs.toStringUtf8(); 5559 ipVersion_ = s; 5560 return s; 5561 } else { 5562 return (java.lang.String) ref; 5563 } 5564 } 5565 /** 5566 * 5567 * 5568 * <pre> 5569 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 5570 * Check the IpVersion enum for the list of possible values. 5571 * </pre> 5572 * 5573 * <code>optional string ip_version = 294959552;</code> 5574 * 5575 * @return The bytes for ipVersion. 5576 */ getIpVersionBytes()5577 public com.google.protobuf.ByteString getIpVersionBytes() { 5578 java.lang.Object ref = ipVersion_; 5579 if (ref instanceof String) { 5580 com.google.protobuf.ByteString b = 5581 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 5582 ipVersion_ = b; 5583 return b; 5584 } else { 5585 return (com.google.protobuf.ByteString) ref; 5586 } 5587 } 5588 /** 5589 * 5590 * 5591 * <pre> 5592 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 5593 * Check the IpVersion enum for the list of possible values. 5594 * </pre> 5595 * 5596 * <code>optional string ip_version = 294959552;</code> 5597 * 5598 * @param value The ipVersion to set. 5599 * @return This builder for chaining. 5600 */ setIpVersion(java.lang.String value)5601 public Builder setIpVersion(java.lang.String value) { 5602 if (value == null) { 5603 throw new NullPointerException(); 5604 } 5605 ipVersion_ = value; 5606 bitField0_ |= 0x00000400; 5607 onChanged(); 5608 return this; 5609 } 5610 /** 5611 * 5612 * 5613 * <pre> 5614 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 5615 * Check the IpVersion enum for the list of possible values. 5616 * </pre> 5617 * 5618 * <code>optional string ip_version = 294959552;</code> 5619 * 5620 * @return This builder for chaining. 5621 */ clearIpVersion()5622 public Builder clearIpVersion() { 5623 ipVersion_ = getDefaultInstance().getIpVersion(); 5624 bitField0_ = (bitField0_ & ~0x00000400); 5625 onChanged(); 5626 return this; 5627 } 5628 /** 5629 * 5630 * 5631 * <pre> 5632 * The IP Version that will be used by this forwarding rule. Valid options are IPV4 or IPV6. 5633 * Check the IpVersion enum for the list of possible values. 5634 * </pre> 5635 * 5636 * <code>optional string ip_version = 294959552;</code> 5637 * 5638 * @param value The bytes for ipVersion to set. 5639 * @return This builder for chaining. 5640 */ setIpVersionBytes(com.google.protobuf.ByteString value)5641 public Builder setIpVersionBytes(com.google.protobuf.ByteString value) { 5642 if (value == null) { 5643 throw new NullPointerException(); 5644 } 5645 checkByteStringIsUtf8(value); 5646 ipVersion_ = value; 5647 bitField0_ |= 0x00000400; 5648 onChanged(); 5649 return this; 5650 } 5651 5652 private boolean isMirroringCollector_; 5653 /** 5654 * 5655 * 5656 * <pre> 5657 * Indicates whether or not this load balancer can be used as a collector for packet mirroring. To prevent mirroring loops, instances behind this load balancer will not have their traffic mirrored even if a PacketMirroring rule applies to them. This can only be set to true for load balancers that have their loadBalancingScheme set to INTERNAL. 5658 * </pre> 5659 * 5660 * <code>optional bool is_mirroring_collector = 119255164;</code> 5661 * 5662 * @return Whether the isMirroringCollector field is set. 5663 */ 5664 @java.lang.Override hasIsMirroringCollector()5665 public boolean hasIsMirroringCollector() { 5666 return ((bitField0_ & 0x00000800) != 0); 5667 } 5668 /** 5669 * 5670 * 5671 * <pre> 5672 * Indicates whether or not this load balancer can be used as a collector for packet mirroring. To prevent mirroring loops, instances behind this load balancer will not have their traffic mirrored even if a PacketMirroring rule applies to them. This can only be set to true for load balancers that have their loadBalancingScheme set to INTERNAL. 5673 * </pre> 5674 * 5675 * <code>optional bool is_mirroring_collector = 119255164;</code> 5676 * 5677 * @return The isMirroringCollector. 5678 */ 5679 @java.lang.Override getIsMirroringCollector()5680 public boolean getIsMirroringCollector() { 5681 return isMirroringCollector_; 5682 } 5683 /** 5684 * 5685 * 5686 * <pre> 5687 * Indicates whether or not this load balancer can be used as a collector for packet mirroring. To prevent mirroring loops, instances behind this load balancer will not have their traffic mirrored even if a PacketMirroring rule applies to them. This can only be set to true for load balancers that have their loadBalancingScheme set to INTERNAL. 5688 * </pre> 5689 * 5690 * <code>optional bool is_mirroring_collector = 119255164;</code> 5691 * 5692 * @param value The isMirroringCollector to set. 5693 * @return This builder for chaining. 5694 */ setIsMirroringCollector(boolean value)5695 public Builder setIsMirroringCollector(boolean value) { 5696 5697 isMirroringCollector_ = value; 5698 bitField0_ |= 0x00000800; 5699 onChanged(); 5700 return this; 5701 } 5702 /** 5703 * 5704 * 5705 * <pre> 5706 * Indicates whether or not this load balancer can be used as a collector for packet mirroring. To prevent mirroring loops, instances behind this load balancer will not have their traffic mirrored even if a PacketMirroring rule applies to them. This can only be set to true for load balancers that have their loadBalancingScheme set to INTERNAL. 5707 * </pre> 5708 * 5709 * <code>optional bool is_mirroring_collector = 119255164;</code> 5710 * 5711 * @return This builder for chaining. 5712 */ clearIsMirroringCollector()5713 public Builder clearIsMirroringCollector() { 5714 bitField0_ = (bitField0_ & ~0x00000800); 5715 isMirroringCollector_ = false; 5716 onChanged(); 5717 return this; 5718 } 5719 5720 private java.lang.Object kind_ = ""; 5721 /** 5722 * 5723 * 5724 * <pre> 5725 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 5726 * </pre> 5727 * 5728 * <code>optional string kind = 3292052;</code> 5729 * 5730 * @return Whether the kind field is set. 5731 */ hasKind()5732 public boolean hasKind() { 5733 return ((bitField0_ & 0x00001000) != 0); 5734 } 5735 /** 5736 * 5737 * 5738 * <pre> 5739 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 5740 * </pre> 5741 * 5742 * <code>optional string kind = 3292052;</code> 5743 * 5744 * @return The kind. 5745 */ getKind()5746 public java.lang.String getKind() { 5747 java.lang.Object ref = kind_; 5748 if (!(ref instanceof java.lang.String)) { 5749 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 5750 java.lang.String s = bs.toStringUtf8(); 5751 kind_ = s; 5752 return s; 5753 } else { 5754 return (java.lang.String) ref; 5755 } 5756 } 5757 /** 5758 * 5759 * 5760 * <pre> 5761 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 5762 * </pre> 5763 * 5764 * <code>optional string kind = 3292052;</code> 5765 * 5766 * @return The bytes for kind. 5767 */ getKindBytes()5768 public com.google.protobuf.ByteString getKindBytes() { 5769 java.lang.Object ref = kind_; 5770 if (ref instanceof String) { 5771 com.google.protobuf.ByteString b = 5772 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 5773 kind_ = b; 5774 return b; 5775 } else { 5776 return (com.google.protobuf.ByteString) ref; 5777 } 5778 } 5779 /** 5780 * 5781 * 5782 * <pre> 5783 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 5784 * </pre> 5785 * 5786 * <code>optional string kind = 3292052;</code> 5787 * 5788 * @param value The kind to set. 5789 * @return This builder for chaining. 5790 */ setKind(java.lang.String value)5791 public Builder setKind(java.lang.String value) { 5792 if (value == null) { 5793 throw new NullPointerException(); 5794 } 5795 kind_ = value; 5796 bitField0_ |= 0x00001000; 5797 onChanged(); 5798 return this; 5799 } 5800 /** 5801 * 5802 * 5803 * <pre> 5804 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 5805 * </pre> 5806 * 5807 * <code>optional string kind = 3292052;</code> 5808 * 5809 * @return This builder for chaining. 5810 */ clearKind()5811 public Builder clearKind() { 5812 kind_ = getDefaultInstance().getKind(); 5813 bitField0_ = (bitField0_ & ~0x00001000); 5814 onChanged(); 5815 return this; 5816 } 5817 /** 5818 * 5819 * 5820 * <pre> 5821 * [Output Only] Type of the resource. Always compute#forwardingRule for Forwarding Rule resources. 5822 * </pre> 5823 * 5824 * <code>optional string kind = 3292052;</code> 5825 * 5826 * @param value The bytes for kind to set. 5827 * @return This builder for chaining. 5828 */ setKindBytes(com.google.protobuf.ByteString value)5829 public Builder setKindBytes(com.google.protobuf.ByteString value) { 5830 if (value == null) { 5831 throw new NullPointerException(); 5832 } 5833 checkByteStringIsUtf8(value); 5834 kind_ = value; 5835 bitField0_ |= 0x00001000; 5836 onChanged(); 5837 return this; 5838 } 5839 5840 private java.lang.Object labelFingerprint_ = ""; 5841 /** 5842 * 5843 * 5844 * <pre> 5845 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5846 * </pre> 5847 * 5848 * <code>optional string label_fingerprint = 178124825;</code> 5849 * 5850 * @return Whether the labelFingerprint field is set. 5851 */ hasLabelFingerprint()5852 public boolean hasLabelFingerprint() { 5853 return ((bitField0_ & 0x00002000) != 0); 5854 } 5855 /** 5856 * 5857 * 5858 * <pre> 5859 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5860 * </pre> 5861 * 5862 * <code>optional string label_fingerprint = 178124825;</code> 5863 * 5864 * @return The labelFingerprint. 5865 */ getLabelFingerprint()5866 public java.lang.String getLabelFingerprint() { 5867 java.lang.Object ref = labelFingerprint_; 5868 if (!(ref instanceof java.lang.String)) { 5869 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 5870 java.lang.String s = bs.toStringUtf8(); 5871 labelFingerprint_ = s; 5872 return s; 5873 } else { 5874 return (java.lang.String) ref; 5875 } 5876 } 5877 /** 5878 * 5879 * 5880 * <pre> 5881 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5882 * </pre> 5883 * 5884 * <code>optional string label_fingerprint = 178124825;</code> 5885 * 5886 * @return The bytes for labelFingerprint. 5887 */ getLabelFingerprintBytes()5888 public com.google.protobuf.ByteString getLabelFingerprintBytes() { 5889 java.lang.Object ref = labelFingerprint_; 5890 if (ref instanceof String) { 5891 com.google.protobuf.ByteString b = 5892 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 5893 labelFingerprint_ = b; 5894 return b; 5895 } else { 5896 return (com.google.protobuf.ByteString) ref; 5897 } 5898 } 5899 /** 5900 * 5901 * 5902 * <pre> 5903 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5904 * </pre> 5905 * 5906 * <code>optional string label_fingerprint = 178124825;</code> 5907 * 5908 * @param value The labelFingerprint to set. 5909 * @return This builder for chaining. 5910 */ setLabelFingerprint(java.lang.String value)5911 public Builder setLabelFingerprint(java.lang.String value) { 5912 if (value == null) { 5913 throw new NullPointerException(); 5914 } 5915 labelFingerprint_ = value; 5916 bitField0_ |= 0x00002000; 5917 onChanged(); 5918 return this; 5919 } 5920 /** 5921 * 5922 * 5923 * <pre> 5924 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5925 * </pre> 5926 * 5927 * <code>optional string label_fingerprint = 178124825;</code> 5928 * 5929 * @return This builder for chaining. 5930 */ clearLabelFingerprint()5931 public Builder clearLabelFingerprint() { 5932 labelFingerprint_ = getDefaultInstance().getLabelFingerprint(); 5933 bitField0_ = (bitField0_ & ~0x00002000); 5934 onChanged(); 5935 return this; 5936 } 5937 /** 5938 * 5939 * 5940 * <pre> 5941 * A fingerprint for the labels being applied to this resource, which is essentially a hash of the labels set used for optimistic locking. The fingerprint is initially generated by Compute Engine and changes after every request to modify or update labels. You must always provide an up-to-date fingerprint hash in order to update or change labels, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a ForwardingRule. 5942 * </pre> 5943 * 5944 * <code>optional string label_fingerprint = 178124825;</code> 5945 * 5946 * @param value The bytes for labelFingerprint to set. 5947 * @return This builder for chaining. 5948 */ setLabelFingerprintBytes(com.google.protobuf.ByteString value)5949 public Builder setLabelFingerprintBytes(com.google.protobuf.ByteString value) { 5950 if (value == null) { 5951 throw new NullPointerException(); 5952 } 5953 checkByteStringIsUtf8(value); 5954 labelFingerprint_ = value; 5955 bitField0_ |= 0x00002000; 5956 onChanged(); 5957 return this; 5958 } 5959 5960 private com.google.protobuf.MapField<java.lang.String, java.lang.String> labels_; 5961 internalGetLabels()5962 private com.google.protobuf.MapField<java.lang.String, java.lang.String> internalGetLabels() { 5963 if (labels_ == null) { 5964 return com.google.protobuf.MapField.emptyMapField(LabelsDefaultEntryHolder.defaultEntry); 5965 } 5966 return labels_; 5967 } 5968 5969 private com.google.protobuf.MapField<java.lang.String, java.lang.String> internalGetMutableLabels()5970 internalGetMutableLabels() { 5971 if (labels_ == null) { 5972 labels_ = com.google.protobuf.MapField.newMapField(LabelsDefaultEntryHolder.defaultEntry); 5973 } 5974 if (!labels_.isMutable()) { 5975 labels_ = labels_.copy(); 5976 } 5977 bitField0_ |= 0x00004000; 5978 onChanged(); 5979 return labels_; 5980 } 5981 getLabelsCount()5982 public int getLabelsCount() { 5983 return internalGetLabels().getMap().size(); 5984 } 5985 /** 5986 * 5987 * 5988 * <pre> 5989 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 5990 * </pre> 5991 * 5992 * <code>map<string, string> labels = 500195327;</code> 5993 */ 5994 @java.lang.Override containsLabels(java.lang.String key)5995 public boolean containsLabels(java.lang.String key) { 5996 if (key == null) { 5997 throw new NullPointerException("map key"); 5998 } 5999 return internalGetLabels().getMap().containsKey(key); 6000 } 6001 /** Use {@link #getLabelsMap()} instead. */ 6002 @java.lang.Override 6003 @java.lang.Deprecated getLabels()6004 public java.util.Map<java.lang.String, java.lang.String> getLabels() { 6005 return getLabelsMap(); 6006 } 6007 /** 6008 * 6009 * 6010 * <pre> 6011 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 6012 * </pre> 6013 * 6014 * <code>map<string, string> labels = 500195327;</code> 6015 */ 6016 @java.lang.Override getLabelsMap()6017 public java.util.Map<java.lang.String, java.lang.String> getLabelsMap() { 6018 return internalGetLabels().getMap(); 6019 } 6020 /** 6021 * 6022 * 6023 * <pre> 6024 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 6025 * </pre> 6026 * 6027 * <code>map<string, string> labels = 500195327;</code> 6028 */ 6029 @java.lang.Override getLabelsOrDefault( java.lang.String key, java.lang.String defaultValue)6030 public /* nullable */ java.lang.String getLabelsOrDefault( 6031 java.lang.String key, 6032 /* nullable */ 6033 java.lang.String defaultValue) { 6034 if (key == null) { 6035 throw new NullPointerException("map key"); 6036 } 6037 java.util.Map<java.lang.String, java.lang.String> map = internalGetLabels().getMap(); 6038 return map.containsKey(key) ? map.get(key) : defaultValue; 6039 } 6040 /** 6041 * 6042 * 6043 * <pre> 6044 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 6045 * </pre> 6046 * 6047 * <code>map<string, string> labels = 500195327;</code> 6048 */ 6049 @java.lang.Override getLabelsOrThrow(java.lang.String key)6050 public java.lang.String getLabelsOrThrow(java.lang.String key) { 6051 if (key == null) { 6052 throw new NullPointerException("map key"); 6053 } 6054 java.util.Map<java.lang.String, java.lang.String> map = internalGetLabels().getMap(); 6055 if (!map.containsKey(key)) { 6056 throw new java.lang.IllegalArgumentException(); 6057 } 6058 return map.get(key); 6059 } 6060 clearLabels()6061 public Builder clearLabels() { 6062 bitField0_ = (bitField0_ & ~0x00004000); 6063 internalGetMutableLabels().getMutableMap().clear(); 6064 return this; 6065 } 6066 /** 6067 * 6068 * 6069 * <pre> 6070 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 6071 * </pre> 6072 * 6073 * <code>map<string, string> labels = 500195327;</code> 6074 */ removeLabels(java.lang.String key)6075 public Builder removeLabels(java.lang.String key) { 6076 if (key == null) { 6077 throw new NullPointerException("map key"); 6078 } 6079 internalGetMutableLabels().getMutableMap().remove(key); 6080 return this; 6081 } 6082 /** Use alternate mutation accessors instead. */ 6083 @java.lang.Deprecated getMutableLabels()6084 public java.util.Map<java.lang.String, java.lang.String> getMutableLabels() { 6085 bitField0_ |= 0x00004000; 6086 return internalGetMutableLabels().getMutableMap(); 6087 } 6088 /** 6089 * 6090 * 6091 * <pre> 6092 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 6093 * </pre> 6094 * 6095 * <code>map<string, string> labels = 500195327;</code> 6096 */ putLabels(java.lang.String key, java.lang.String value)6097 public Builder putLabels(java.lang.String key, java.lang.String value) { 6098 if (key == null) { 6099 throw new NullPointerException("map key"); 6100 } 6101 if (value == null) { 6102 throw new NullPointerException("map value"); 6103 } 6104 internalGetMutableLabels().getMutableMap().put(key, value); 6105 bitField0_ |= 0x00004000; 6106 return this; 6107 } 6108 /** 6109 * 6110 * 6111 * <pre> 6112 * Labels for this resource. These can only be added or modified by the setLabels method. Each label key/value pair must comply with RFC1035. Label values may be empty. 6113 * </pre> 6114 * 6115 * <code>map<string, string> labels = 500195327;</code> 6116 */ putAllLabels(java.util.Map<java.lang.String, java.lang.String> values)6117 public Builder putAllLabels(java.util.Map<java.lang.String, java.lang.String> values) { 6118 internalGetMutableLabels().getMutableMap().putAll(values); 6119 bitField0_ |= 0x00004000; 6120 return this; 6121 } 6122 6123 private java.lang.Object loadBalancingScheme_ = ""; 6124 /** 6125 * 6126 * 6127 * <pre> 6128 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 6129 * Check the LoadBalancingScheme enum for the list of possible values. 6130 * </pre> 6131 * 6132 * <code>optional string load_balancing_scheme = 363890244;</code> 6133 * 6134 * @return Whether the loadBalancingScheme field is set. 6135 */ hasLoadBalancingScheme()6136 public boolean hasLoadBalancingScheme() { 6137 return ((bitField0_ & 0x00008000) != 0); 6138 } 6139 /** 6140 * 6141 * 6142 * <pre> 6143 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 6144 * Check the LoadBalancingScheme enum for the list of possible values. 6145 * </pre> 6146 * 6147 * <code>optional string load_balancing_scheme = 363890244;</code> 6148 * 6149 * @return The loadBalancingScheme. 6150 */ getLoadBalancingScheme()6151 public java.lang.String getLoadBalancingScheme() { 6152 java.lang.Object ref = loadBalancingScheme_; 6153 if (!(ref instanceof java.lang.String)) { 6154 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 6155 java.lang.String s = bs.toStringUtf8(); 6156 loadBalancingScheme_ = s; 6157 return s; 6158 } else { 6159 return (java.lang.String) ref; 6160 } 6161 } 6162 /** 6163 * 6164 * 6165 * <pre> 6166 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 6167 * Check the LoadBalancingScheme enum for the list of possible values. 6168 * </pre> 6169 * 6170 * <code>optional string load_balancing_scheme = 363890244;</code> 6171 * 6172 * @return The bytes for loadBalancingScheme. 6173 */ getLoadBalancingSchemeBytes()6174 public com.google.protobuf.ByteString getLoadBalancingSchemeBytes() { 6175 java.lang.Object ref = loadBalancingScheme_; 6176 if (ref instanceof String) { 6177 com.google.protobuf.ByteString b = 6178 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 6179 loadBalancingScheme_ = b; 6180 return b; 6181 } else { 6182 return (com.google.protobuf.ByteString) ref; 6183 } 6184 } 6185 /** 6186 * 6187 * 6188 * <pre> 6189 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 6190 * Check the LoadBalancingScheme enum for the list of possible values. 6191 * </pre> 6192 * 6193 * <code>optional string load_balancing_scheme = 363890244;</code> 6194 * 6195 * @param value The loadBalancingScheme to set. 6196 * @return This builder for chaining. 6197 */ setLoadBalancingScheme(java.lang.String value)6198 public Builder setLoadBalancingScheme(java.lang.String value) { 6199 if (value == null) { 6200 throw new NullPointerException(); 6201 } 6202 loadBalancingScheme_ = value; 6203 bitField0_ |= 0x00008000; 6204 onChanged(); 6205 return this; 6206 } 6207 /** 6208 * 6209 * 6210 * <pre> 6211 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 6212 * Check the LoadBalancingScheme enum for the list of possible values. 6213 * </pre> 6214 * 6215 * <code>optional string load_balancing_scheme = 363890244;</code> 6216 * 6217 * @return This builder for chaining. 6218 */ clearLoadBalancingScheme()6219 public Builder clearLoadBalancingScheme() { 6220 loadBalancingScheme_ = getDefaultInstance().getLoadBalancingScheme(); 6221 bitField0_ = (bitField0_ & ~0x00008000); 6222 onChanged(); 6223 return this; 6224 } 6225 /** 6226 * 6227 * 6228 * <pre> 6229 * Specifies the forwarding rule type. For more information about forwarding rules, refer to Forwarding rule concepts. 6230 * Check the LoadBalancingScheme enum for the list of possible values. 6231 * </pre> 6232 * 6233 * <code>optional string load_balancing_scheme = 363890244;</code> 6234 * 6235 * @param value The bytes for loadBalancingScheme to set. 6236 * @return This builder for chaining. 6237 */ setLoadBalancingSchemeBytes(com.google.protobuf.ByteString value)6238 public Builder setLoadBalancingSchemeBytes(com.google.protobuf.ByteString value) { 6239 if (value == null) { 6240 throw new NullPointerException(); 6241 } 6242 checkByteStringIsUtf8(value); 6243 loadBalancingScheme_ = value; 6244 bitField0_ |= 0x00008000; 6245 onChanged(); 6246 return this; 6247 } 6248 6249 private java.util.List<com.google.cloud.compute.v1.MetadataFilter> metadataFilters_ = 6250 java.util.Collections.emptyList(); 6251 ensureMetadataFiltersIsMutable()6252 private void ensureMetadataFiltersIsMutable() { 6253 if (!((bitField0_ & 0x00010000) != 0)) { 6254 metadataFilters_ = 6255 new java.util.ArrayList<com.google.cloud.compute.v1.MetadataFilter>(metadataFilters_); 6256 bitField0_ |= 0x00010000; 6257 } 6258 } 6259 6260 private com.google.protobuf.RepeatedFieldBuilderV3< 6261 com.google.cloud.compute.v1.MetadataFilter, 6262 com.google.cloud.compute.v1.MetadataFilter.Builder, 6263 com.google.cloud.compute.v1.MetadataFilterOrBuilder> 6264 metadataFiltersBuilder_; 6265 6266 /** 6267 * 6268 * 6269 * <pre> 6270 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6271 * </pre> 6272 * 6273 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6274 */ getMetadataFiltersList()6275 public java.util.List<com.google.cloud.compute.v1.MetadataFilter> getMetadataFiltersList() { 6276 if (metadataFiltersBuilder_ == null) { 6277 return java.util.Collections.unmodifiableList(metadataFilters_); 6278 } else { 6279 return metadataFiltersBuilder_.getMessageList(); 6280 } 6281 } 6282 /** 6283 * 6284 * 6285 * <pre> 6286 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6287 * </pre> 6288 * 6289 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6290 */ getMetadataFiltersCount()6291 public int getMetadataFiltersCount() { 6292 if (metadataFiltersBuilder_ == null) { 6293 return metadataFilters_.size(); 6294 } else { 6295 return metadataFiltersBuilder_.getCount(); 6296 } 6297 } 6298 /** 6299 * 6300 * 6301 * <pre> 6302 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6303 * </pre> 6304 * 6305 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6306 */ getMetadataFilters(int index)6307 public com.google.cloud.compute.v1.MetadataFilter getMetadataFilters(int index) { 6308 if (metadataFiltersBuilder_ == null) { 6309 return metadataFilters_.get(index); 6310 } else { 6311 return metadataFiltersBuilder_.getMessage(index); 6312 } 6313 } 6314 /** 6315 * 6316 * 6317 * <pre> 6318 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6319 * </pre> 6320 * 6321 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6322 */ setMetadataFilters(int index, com.google.cloud.compute.v1.MetadataFilter value)6323 public Builder setMetadataFilters(int index, com.google.cloud.compute.v1.MetadataFilter value) { 6324 if (metadataFiltersBuilder_ == null) { 6325 if (value == null) { 6326 throw new NullPointerException(); 6327 } 6328 ensureMetadataFiltersIsMutable(); 6329 metadataFilters_.set(index, value); 6330 onChanged(); 6331 } else { 6332 metadataFiltersBuilder_.setMessage(index, value); 6333 } 6334 return this; 6335 } 6336 /** 6337 * 6338 * 6339 * <pre> 6340 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6341 * </pre> 6342 * 6343 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6344 */ setMetadataFilters( int index, com.google.cloud.compute.v1.MetadataFilter.Builder builderForValue)6345 public Builder setMetadataFilters( 6346 int index, com.google.cloud.compute.v1.MetadataFilter.Builder builderForValue) { 6347 if (metadataFiltersBuilder_ == null) { 6348 ensureMetadataFiltersIsMutable(); 6349 metadataFilters_.set(index, builderForValue.build()); 6350 onChanged(); 6351 } else { 6352 metadataFiltersBuilder_.setMessage(index, builderForValue.build()); 6353 } 6354 return this; 6355 } 6356 /** 6357 * 6358 * 6359 * <pre> 6360 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6361 * </pre> 6362 * 6363 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6364 */ addMetadataFilters(com.google.cloud.compute.v1.MetadataFilter value)6365 public Builder addMetadataFilters(com.google.cloud.compute.v1.MetadataFilter value) { 6366 if (metadataFiltersBuilder_ == null) { 6367 if (value == null) { 6368 throw new NullPointerException(); 6369 } 6370 ensureMetadataFiltersIsMutable(); 6371 metadataFilters_.add(value); 6372 onChanged(); 6373 } else { 6374 metadataFiltersBuilder_.addMessage(value); 6375 } 6376 return this; 6377 } 6378 /** 6379 * 6380 * 6381 * <pre> 6382 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6383 * </pre> 6384 * 6385 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6386 */ addMetadataFilters(int index, com.google.cloud.compute.v1.MetadataFilter value)6387 public Builder addMetadataFilters(int index, com.google.cloud.compute.v1.MetadataFilter value) { 6388 if (metadataFiltersBuilder_ == null) { 6389 if (value == null) { 6390 throw new NullPointerException(); 6391 } 6392 ensureMetadataFiltersIsMutable(); 6393 metadataFilters_.add(index, value); 6394 onChanged(); 6395 } else { 6396 metadataFiltersBuilder_.addMessage(index, value); 6397 } 6398 return this; 6399 } 6400 /** 6401 * 6402 * 6403 * <pre> 6404 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6405 * </pre> 6406 * 6407 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6408 */ addMetadataFilters( com.google.cloud.compute.v1.MetadataFilter.Builder builderForValue)6409 public Builder addMetadataFilters( 6410 com.google.cloud.compute.v1.MetadataFilter.Builder builderForValue) { 6411 if (metadataFiltersBuilder_ == null) { 6412 ensureMetadataFiltersIsMutable(); 6413 metadataFilters_.add(builderForValue.build()); 6414 onChanged(); 6415 } else { 6416 metadataFiltersBuilder_.addMessage(builderForValue.build()); 6417 } 6418 return this; 6419 } 6420 /** 6421 * 6422 * 6423 * <pre> 6424 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6425 * </pre> 6426 * 6427 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6428 */ addMetadataFilters( int index, com.google.cloud.compute.v1.MetadataFilter.Builder builderForValue)6429 public Builder addMetadataFilters( 6430 int index, com.google.cloud.compute.v1.MetadataFilter.Builder builderForValue) { 6431 if (metadataFiltersBuilder_ == null) { 6432 ensureMetadataFiltersIsMutable(); 6433 metadataFilters_.add(index, builderForValue.build()); 6434 onChanged(); 6435 } else { 6436 metadataFiltersBuilder_.addMessage(index, builderForValue.build()); 6437 } 6438 return this; 6439 } 6440 /** 6441 * 6442 * 6443 * <pre> 6444 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6445 * </pre> 6446 * 6447 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6448 */ addAllMetadataFilters( java.lang.Iterable<? extends com.google.cloud.compute.v1.MetadataFilter> values)6449 public Builder addAllMetadataFilters( 6450 java.lang.Iterable<? extends com.google.cloud.compute.v1.MetadataFilter> values) { 6451 if (metadataFiltersBuilder_ == null) { 6452 ensureMetadataFiltersIsMutable(); 6453 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, metadataFilters_); 6454 onChanged(); 6455 } else { 6456 metadataFiltersBuilder_.addAllMessages(values); 6457 } 6458 return this; 6459 } 6460 /** 6461 * 6462 * 6463 * <pre> 6464 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6465 * </pre> 6466 * 6467 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6468 */ clearMetadataFilters()6469 public Builder clearMetadataFilters() { 6470 if (metadataFiltersBuilder_ == null) { 6471 metadataFilters_ = java.util.Collections.emptyList(); 6472 bitField0_ = (bitField0_ & ~0x00010000); 6473 onChanged(); 6474 } else { 6475 metadataFiltersBuilder_.clear(); 6476 } 6477 return this; 6478 } 6479 /** 6480 * 6481 * 6482 * <pre> 6483 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6484 * </pre> 6485 * 6486 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6487 */ removeMetadataFilters(int index)6488 public Builder removeMetadataFilters(int index) { 6489 if (metadataFiltersBuilder_ == null) { 6490 ensureMetadataFiltersIsMutable(); 6491 metadataFilters_.remove(index); 6492 onChanged(); 6493 } else { 6494 metadataFiltersBuilder_.remove(index); 6495 } 6496 return this; 6497 } 6498 /** 6499 * 6500 * 6501 * <pre> 6502 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6503 * </pre> 6504 * 6505 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6506 */ getMetadataFiltersBuilder(int index)6507 public com.google.cloud.compute.v1.MetadataFilter.Builder getMetadataFiltersBuilder(int index) { 6508 return getMetadataFiltersFieldBuilder().getBuilder(index); 6509 } 6510 /** 6511 * 6512 * 6513 * <pre> 6514 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6515 * </pre> 6516 * 6517 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6518 */ getMetadataFiltersOrBuilder( int index)6519 public com.google.cloud.compute.v1.MetadataFilterOrBuilder getMetadataFiltersOrBuilder( 6520 int index) { 6521 if (metadataFiltersBuilder_ == null) { 6522 return metadataFilters_.get(index); 6523 } else { 6524 return metadataFiltersBuilder_.getMessageOrBuilder(index); 6525 } 6526 } 6527 /** 6528 * 6529 * 6530 * <pre> 6531 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6532 * </pre> 6533 * 6534 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6535 */ 6536 public java.util.List<? extends com.google.cloud.compute.v1.MetadataFilterOrBuilder> getMetadataFiltersOrBuilderList()6537 getMetadataFiltersOrBuilderList() { 6538 if (metadataFiltersBuilder_ != null) { 6539 return metadataFiltersBuilder_.getMessageOrBuilderList(); 6540 } else { 6541 return java.util.Collections.unmodifiableList(metadataFilters_); 6542 } 6543 } 6544 /** 6545 * 6546 * 6547 * <pre> 6548 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6549 * </pre> 6550 * 6551 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6552 */ addMetadataFiltersBuilder()6553 public com.google.cloud.compute.v1.MetadataFilter.Builder addMetadataFiltersBuilder() { 6554 return getMetadataFiltersFieldBuilder() 6555 .addBuilder(com.google.cloud.compute.v1.MetadataFilter.getDefaultInstance()); 6556 } 6557 /** 6558 * 6559 * 6560 * <pre> 6561 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6562 * </pre> 6563 * 6564 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6565 */ addMetadataFiltersBuilder(int index)6566 public com.google.cloud.compute.v1.MetadataFilter.Builder addMetadataFiltersBuilder(int index) { 6567 return getMetadataFiltersFieldBuilder() 6568 .addBuilder(index, com.google.cloud.compute.v1.MetadataFilter.getDefaultInstance()); 6569 } 6570 /** 6571 * 6572 * 6573 * <pre> 6574 * Opaque filter criteria used by load balancer to restrict routing configuration to a limited set of xDS compliant clients. In their xDS requests to load balancer, xDS clients present node metadata. When there is a match, the relevant configuration is made available to those proxies. Otherwise, all the resources (e.g. TargetHttpProxy, UrlMap) referenced by the ForwardingRule are not visible to those proxies. For each metadataFilter in this list, if its filterMatchCriteria is set to MATCH_ANY, at least one of the filterLabels must match the corresponding label provided in the metadata. If its filterMatchCriteria is set to MATCH_ALL, then all of its filterLabels must match with corresponding labels provided in the metadata. If multiple metadataFilters are specified, all of them need to be satisfied in order to be considered a match. metadataFilters specified here will be applifed before those specified in the UrlMap that this ForwardingRule references. metadataFilters only applies to Loadbalancers that have their loadBalancingScheme set to INTERNAL_SELF_MANAGED. 6575 * </pre> 6576 * 6577 * <code>repeated .google.cloud.compute.v1.MetadataFilter metadata_filters = 464725739;</code> 6578 */ 6579 public java.util.List<com.google.cloud.compute.v1.MetadataFilter.Builder> getMetadataFiltersBuilderList()6580 getMetadataFiltersBuilderList() { 6581 return getMetadataFiltersFieldBuilder().getBuilderList(); 6582 } 6583 6584 private com.google.protobuf.RepeatedFieldBuilderV3< 6585 com.google.cloud.compute.v1.MetadataFilter, 6586 com.google.cloud.compute.v1.MetadataFilter.Builder, 6587 com.google.cloud.compute.v1.MetadataFilterOrBuilder> getMetadataFiltersFieldBuilder()6588 getMetadataFiltersFieldBuilder() { 6589 if (metadataFiltersBuilder_ == null) { 6590 metadataFiltersBuilder_ = 6591 new com.google.protobuf.RepeatedFieldBuilderV3< 6592 com.google.cloud.compute.v1.MetadataFilter, 6593 com.google.cloud.compute.v1.MetadataFilter.Builder, 6594 com.google.cloud.compute.v1.MetadataFilterOrBuilder>( 6595 metadataFilters_, 6596 ((bitField0_ & 0x00010000) != 0), 6597 getParentForChildren(), 6598 isClean()); 6599 metadataFilters_ = null; 6600 } 6601 return metadataFiltersBuilder_; 6602 } 6603 6604 private java.lang.Object name_ = ""; 6605 /** 6606 * 6607 * 6608 * <pre> 6609 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 6610 * </pre> 6611 * 6612 * <code>optional string name = 3373707;</code> 6613 * 6614 * @return Whether the name field is set. 6615 */ hasName()6616 public boolean hasName() { 6617 return ((bitField0_ & 0x00020000) != 0); 6618 } 6619 /** 6620 * 6621 * 6622 * <pre> 6623 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 6624 * </pre> 6625 * 6626 * <code>optional string name = 3373707;</code> 6627 * 6628 * @return The name. 6629 */ getName()6630 public java.lang.String getName() { 6631 java.lang.Object ref = name_; 6632 if (!(ref instanceof java.lang.String)) { 6633 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 6634 java.lang.String s = bs.toStringUtf8(); 6635 name_ = s; 6636 return s; 6637 } else { 6638 return (java.lang.String) ref; 6639 } 6640 } 6641 /** 6642 * 6643 * 6644 * <pre> 6645 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 6646 * </pre> 6647 * 6648 * <code>optional string name = 3373707;</code> 6649 * 6650 * @return The bytes for name. 6651 */ getNameBytes()6652 public com.google.protobuf.ByteString getNameBytes() { 6653 java.lang.Object ref = name_; 6654 if (ref instanceof String) { 6655 com.google.protobuf.ByteString b = 6656 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 6657 name_ = b; 6658 return b; 6659 } else { 6660 return (com.google.protobuf.ByteString) ref; 6661 } 6662 } 6663 /** 6664 * 6665 * 6666 * <pre> 6667 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 6668 * </pre> 6669 * 6670 * <code>optional string name = 3373707;</code> 6671 * 6672 * @param value The name to set. 6673 * @return This builder for chaining. 6674 */ setName(java.lang.String value)6675 public Builder setName(java.lang.String value) { 6676 if (value == null) { 6677 throw new NullPointerException(); 6678 } 6679 name_ = value; 6680 bitField0_ |= 0x00020000; 6681 onChanged(); 6682 return this; 6683 } 6684 /** 6685 * 6686 * 6687 * <pre> 6688 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 6689 * </pre> 6690 * 6691 * <code>optional string name = 3373707;</code> 6692 * 6693 * @return This builder for chaining. 6694 */ clearName()6695 public Builder clearName() { 6696 name_ = getDefaultInstance().getName(); 6697 bitField0_ = (bitField0_ & ~0x00020000); 6698 onChanged(); 6699 return this; 6700 } 6701 /** 6702 * 6703 * 6704 * <pre> 6705 * Name of the resource; provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. For Private Service Connect forwarding rules that forward traffic to Google APIs, the forwarding rule name must be a 1-20 characters string with lowercase letters and numbers and must start with a letter. 6706 * </pre> 6707 * 6708 * <code>optional string name = 3373707;</code> 6709 * 6710 * @param value The bytes for name to set. 6711 * @return This builder for chaining. 6712 */ setNameBytes(com.google.protobuf.ByteString value)6713 public Builder setNameBytes(com.google.protobuf.ByteString value) { 6714 if (value == null) { 6715 throw new NullPointerException(); 6716 } 6717 checkByteStringIsUtf8(value); 6718 name_ = value; 6719 bitField0_ |= 0x00020000; 6720 onChanged(); 6721 return this; 6722 } 6723 6724 private java.lang.Object network_ = ""; 6725 /** 6726 * 6727 * 6728 * <pre> 6729 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 6730 * </pre> 6731 * 6732 * <code>optional string network = 232872494;</code> 6733 * 6734 * @return Whether the network field is set. 6735 */ hasNetwork()6736 public boolean hasNetwork() { 6737 return ((bitField0_ & 0x00040000) != 0); 6738 } 6739 /** 6740 * 6741 * 6742 * <pre> 6743 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 6744 * </pre> 6745 * 6746 * <code>optional string network = 232872494;</code> 6747 * 6748 * @return The network. 6749 */ getNetwork()6750 public java.lang.String getNetwork() { 6751 java.lang.Object ref = network_; 6752 if (!(ref instanceof java.lang.String)) { 6753 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 6754 java.lang.String s = bs.toStringUtf8(); 6755 network_ = s; 6756 return s; 6757 } else { 6758 return (java.lang.String) ref; 6759 } 6760 } 6761 /** 6762 * 6763 * 6764 * <pre> 6765 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 6766 * </pre> 6767 * 6768 * <code>optional string network = 232872494;</code> 6769 * 6770 * @return The bytes for network. 6771 */ getNetworkBytes()6772 public com.google.protobuf.ByteString getNetworkBytes() { 6773 java.lang.Object ref = network_; 6774 if (ref instanceof String) { 6775 com.google.protobuf.ByteString b = 6776 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 6777 network_ = b; 6778 return b; 6779 } else { 6780 return (com.google.protobuf.ByteString) ref; 6781 } 6782 } 6783 /** 6784 * 6785 * 6786 * <pre> 6787 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 6788 * </pre> 6789 * 6790 * <code>optional string network = 232872494;</code> 6791 * 6792 * @param value The network to set. 6793 * @return This builder for chaining. 6794 */ setNetwork(java.lang.String value)6795 public Builder setNetwork(java.lang.String value) { 6796 if (value == null) { 6797 throw new NullPointerException(); 6798 } 6799 network_ = value; 6800 bitField0_ |= 0x00040000; 6801 onChanged(); 6802 return this; 6803 } 6804 /** 6805 * 6806 * 6807 * <pre> 6808 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 6809 * </pre> 6810 * 6811 * <code>optional string network = 232872494;</code> 6812 * 6813 * @return This builder for chaining. 6814 */ clearNetwork()6815 public Builder clearNetwork() { 6816 network_ = getDefaultInstance().getNetwork(); 6817 bitField0_ = (bitField0_ & ~0x00040000); 6818 onChanged(); 6819 return this; 6820 } 6821 /** 6822 * 6823 * 6824 * <pre> 6825 * This field is not used for external load balancing. For Internal TCP/UDP Load Balancing, this field identifies the network that the load balanced IP should belong to for this Forwarding Rule. If this field is not specified, the default network will be used. For Private Service Connect forwarding rules that forward traffic to Google APIs, a network must be provided. 6826 * </pre> 6827 * 6828 * <code>optional string network = 232872494;</code> 6829 * 6830 * @param value The bytes for network to set. 6831 * @return This builder for chaining. 6832 */ setNetworkBytes(com.google.protobuf.ByteString value)6833 public Builder setNetworkBytes(com.google.protobuf.ByteString value) { 6834 if (value == null) { 6835 throw new NullPointerException(); 6836 } 6837 checkByteStringIsUtf8(value); 6838 network_ = value; 6839 bitField0_ |= 0x00040000; 6840 onChanged(); 6841 return this; 6842 } 6843 6844 private java.lang.Object networkTier_ = ""; 6845 /** 6846 * 6847 * 6848 * <pre> 6849 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 6850 * Check the NetworkTier enum for the list of possible values. 6851 * </pre> 6852 * 6853 * <code>optional string network_tier = 517397843;</code> 6854 * 6855 * @return Whether the networkTier field is set. 6856 */ hasNetworkTier()6857 public boolean hasNetworkTier() { 6858 return ((bitField0_ & 0x00080000) != 0); 6859 } 6860 /** 6861 * 6862 * 6863 * <pre> 6864 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 6865 * Check the NetworkTier enum for the list of possible values. 6866 * </pre> 6867 * 6868 * <code>optional string network_tier = 517397843;</code> 6869 * 6870 * @return The networkTier. 6871 */ getNetworkTier()6872 public java.lang.String getNetworkTier() { 6873 java.lang.Object ref = networkTier_; 6874 if (!(ref instanceof java.lang.String)) { 6875 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 6876 java.lang.String s = bs.toStringUtf8(); 6877 networkTier_ = s; 6878 return s; 6879 } else { 6880 return (java.lang.String) ref; 6881 } 6882 } 6883 /** 6884 * 6885 * 6886 * <pre> 6887 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 6888 * Check the NetworkTier enum for the list of possible values. 6889 * </pre> 6890 * 6891 * <code>optional string network_tier = 517397843;</code> 6892 * 6893 * @return The bytes for networkTier. 6894 */ getNetworkTierBytes()6895 public com.google.protobuf.ByteString getNetworkTierBytes() { 6896 java.lang.Object ref = networkTier_; 6897 if (ref instanceof String) { 6898 com.google.protobuf.ByteString b = 6899 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 6900 networkTier_ = b; 6901 return b; 6902 } else { 6903 return (com.google.protobuf.ByteString) ref; 6904 } 6905 } 6906 /** 6907 * 6908 * 6909 * <pre> 6910 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 6911 * Check the NetworkTier enum for the list of possible values. 6912 * </pre> 6913 * 6914 * <code>optional string network_tier = 517397843;</code> 6915 * 6916 * @param value The networkTier to set. 6917 * @return This builder for chaining. 6918 */ setNetworkTier(java.lang.String value)6919 public Builder setNetworkTier(java.lang.String value) { 6920 if (value == null) { 6921 throw new NullPointerException(); 6922 } 6923 networkTier_ = value; 6924 bitField0_ |= 0x00080000; 6925 onChanged(); 6926 return this; 6927 } 6928 /** 6929 * 6930 * 6931 * <pre> 6932 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 6933 * Check the NetworkTier enum for the list of possible values. 6934 * </pre> 6935 * 6936 * <code>optional string network_tier = 517397843;</code> 6937 * 6938 * @return This builder for chaining. 6939 */ clearNetworkTier()6940 public Builder clearNetworkTier() { 6941 networkTier_ = getDefaultInstance().getNetworkTier(); 6942 bitField0_ = (bitField0_ & ~0x00080000); 6943 onChanged(); 6944 return this; 6945 } 6946 /** 6947 * 6948 * 6949 * <pre> 6950 * This signifies the networking tier used for configuring this load balancer and can only take the following values: PREMIUM, STANDARD. For regional ForwardingRule, the valid values are PREMIUM and STANDARD. For GlobalForwardingRule, the valid value is PREMIUM. If this field is not specified, it is assumed to be PREMIUM. If IPAddress is specified, this value must be equal to the networkTier of the Address. 6951 * Check the NetworkTier enum for the list of possible values. 6952 * </pre> 6953 * 6954 * <code>optional string network_tier = 517397843;</code> 6955 * 6956 * @param value The bytes for networkTier to set. 6957 * @return This builder for chaining. 6958 */ setNetworkTierBytes(com.google.protobuf.ByteString value)6959 public Builder setNetworkTierBytes(com.google.protobuf.ByteString value) { 6960 if (value == null) { 6961 throw new NullPointerException(); 6962 } 6963 checkByteStringIsUtf8(value); 6964 networkTier_ = value; 6965 bitField0_ |= 0x00080000; 6966 onChanged(); 6967 return this; 6968 } 6969 6970 private boolean noAutomateDnsZone_; 6971 /** 6972 * 6973 * 6974 * <pre> 6975 * This is used in PSC consumer ForwardingRule to control whether it should try to auto-generate a DNS zone or not. Non-PSC forwarding rules do not use this field. 6976 * </pre> 6977 * 6978 * <code>optional bool no_automate_dns_zone = 64546991;</code> 6979 * 6980 * @return Whether the noAutomateDnsZone field is set. 6981 */ 6982 @java.lang.Override hasNoAutomateDnsZone()6983 public boolean hasNoAutomateDnsZone() { 6984 return ((bitField0_ & 0x00100000) != 0); 6985 } 6986 /** 6987 * 6988 * 6989 * <pre> 6990 * This is used in PSC consumer ForwardingRule to control whether it should try to auto-generate a DNS zone or not. Non-PSC forwarding rules do not use this field. 6991 * </pre> 6992 * 6993 * <code>optional bool no_automate_dns_zone = 64546991;</code> 6994 * 6995 * @return The noAutomateDnsZone. 6996 */ 6997 @java.lang.Override getNoAutomateDnsZone()6998 public boolean getNoAutomateDnsZone() { 6999 return noAutomateDnsZone_; 7000 } 7001 /** 7002 * 7003 * 7004 * <pre> 7005 * This is used in PSC consumer ForwardingRule to control whether it should try to auto-generate a DNS zone or not. Non-PSC forwarding rules do not use this field. 7006 * </pre> 7007 * 7008 * <code>optional bool no_automate_dns_zone = 64546991;</code> 7009 * 7010 * @param value The noAutomateDnsZone to set. 7011 * @return This builder for chaining. 7012 */ setNoAutomateDnsZone(boolean value)7013 public Builder setNoAutomateDnsZone(boolean value) { 7014 7015 noAutomateDnsZone_ = value; 7016 bitField0_ |= 0x00100000; 7017 onChanged(); 7018 return this; 7019 } 7020 /** 7021 * 7022 * 7023 * <pre> 7024 * This is used in PSC consumer ForwardingRule to control whether it should try to auto-generate a DNS zone or not. Non-PSC forwarding rules do not use this field. 7025 * </pre> 7026 * 7027 * <code>optional bool no_automate_dns_zone = 64546991;</code> 7028 * 7029 * @return This builder for chaining. 7030 */ clearNoAutomateDnsZone()7031 public Builder clearNoAutomateDnsZone() { 7032 bitField0_ = (bitField0_ & ~0x00100000); 7033 noAutomateDnsZone_ = false; 7034 onChanged(); 7035 return this; 7036 } 7037 7038 private java.lang.Object portRange_ = ""; 7039 /** 7040 * 7041 * 7042 * <pre> 7043 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 7044 * </pre> 7045 * 7046 * <code>optional string port_range = 217518079;</code> 7047 * 7048 * @return Whether the portRange field is set. 7049 */ hasPortRange()7050 public boolean hasPortRange() { 7051 return ((bitField0_ & 0x00200000) != 0); 7052 } 7053 /** 7054 * 7055 * 7056 * <pre> 7057 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 7058 * </pre> 7059 * 7060 * <code>optional string port_range = 217518079;</code> 7061 * 7062 * @return The portRange. 7063 */ getPortRange()7064 public java.lang.String getPortRange() { 7065 java.lang.Object ref = portRange_; 7066 if (!(ref instanceof java.lang.String)) { 7067 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 7068 java.lang.String s = bs.toStringUtf8(); 7069 portRange_ = s; 7070 return s; 7071 } else { 7072 return (java.lang.String) ref; 7073 } 7074 } 7075 /** 7076 * 7077 * 7078 * <pre> 7079 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 7080 * </pre> 7081 * 7082 * <code>optional string port_range = 217518079;</code> 7083 * 7084 * @return The bytes for portRange. 7085 */ getPortRangeBytes()7086 public com.google.protobuf.ByteString getPortRangeBytes() { 7087 java.lang.Object ref = portRange_; 7088 if (ref instanceof String) { 7089 com.google.protobuf.ByteString b = 7090 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 7091 portRange_ = b; 7092 return b; 7093 } else { 7094 return (com.google.protobuf.ByteString) ref; 7095 } 7096 } 7097 /** 7098 * 7099 * 7100 * <pre> 7101 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 7102 * </pre> 7103 * 7104 * <code>optional string port_range = 217518079;</code> 7105 * 7106 * @param value The portRange to set. 7107 * @return This builder for chaining. 7108 */ setPortRange(java.lang.String value)7109 public Builder setPortRange(java.lang.String value) { 7110 if (value == null) { 7111 throw new NullPointerException(); 7112 } 7113 portRange_ = value; 7114 bitField0_ |= 0x00200000; 7115 onChanged(); 7116 return this; 7117 } 7118 /** 7119 * 7120 * 7121 * <pre> 7122 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 7123 * </pre> 7124 * 7125 * <code>optional string port_range = 217518079;</code> 7126 * 7127 * @return This builder for chaining. 7128 */ clearPortRange()7129 public Builder clearPortRange() { 7130 portRange_ = getDefaultInstance().getPortRange(); 7131 bitField0_ = (bitField0_ & ~0x00200000); 7132 onChanged(); 7133 return this; 7134 } 7135 /** 7136 * 7137 * 7138 * <pre> 7139 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By backend service-based network load balancers, target pool-based network load balancers, internal proxy load balancers, external proxy load balancers, Traffic Director, external protocol forwarding, and Classic VPN. Some products have restrictions on what ports can be used. See port specifications for details. Only packets addressed to ports in the specified range will be forwarded to the backends configured with this forwarding rule. The ports, port_range, and allPorts fields are mutually exclusive. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot have overlapping portRanges. @pattern: \\d+(?:-\\d+)? 7140 * </pre> 7141 * 7142 * <code>optional string port_range = 217518079;</code> 7143 * 7144 * @param value The bytes for portRange to set. 7145 * @return This builder for chaining. 7146 */ setPortRangeBytes(com.google.protobuf.ByteString value)7147 public Builder setPortRangeBytes(com.google.protobuf.ByteString value) { 7148 if (value == null) { 7149 throw new NullPointerException(); 7150 } 7151 checkByteStringIsUtf8(value); 7152 portRange_ = value; 7153 bitField0_ |= 0x00200000; 7154 onChanged(); 7155 return this; 7156 } 7157 7158 private com.google.protobuf.LazyStringList ports_ = 7159 com.google.protobuf.LazyStringArrayList.EMPTY; 7160 ensurePortsIsMutable()7161 private void ensurePortsIsMutable() { 7162 if (!((bitField0_ & 0x00400000) != 0)) { 7163 ports_ = new com.google.protobuf.LazyStringArrayList(ports_); 7164 bitField0_ |= 0x00400000; 7165 } 7166 } 7167 /** 7168 * 7169 * 7170 * <pre> 7171 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7172 * </pre> 7173 * 7174 * <code>repeated string ports = 106854418;</code> 7175 * 7176 * @return A list containing the ports. 7177 */ getPortsList()7178 public com.google.protobuf.ProtocolStringList getPortsList() { 7179 return ports_.getUnmodifiableView(); 7180 } 7181 /** 7182 * 7183 * 7184 * <pre> 7185 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7186 * </pre> 7187 * 7188 * <code>repeated string ports = 106854418;</code> 7189 * 7190 * @return The count of ports. 7191 */ getPortsCount()7192 public int getPortsCount() { 7193 return ports_.size(); 7194 } 7195 /** 7196 * 7197 * 7198 * <pre> 7199 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7200 * </pre> 7201 * 7202 * <code>repeated string ports = 106854418;</code> 7203 * 7204 * @param index The index of the element to return. 7205 * @return The ports at the given index. 7206 */ getPorts(int index)7207 public java.lang.String getPorts(int index) { 7208 return ports_.get(index); 7209 } 7210 /** 7211 * 7212 * 7213 * <pre> 7214 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7215 * </pre> 7216 * 7217 * <code>repeated string ports = 106854418;</code> 7218 * 7219 * @param index The index of the value to return. 7220 * @return The bytes of the ports at the given index. 7221 */ getPortsBytes(int index)7222 public com.google.protobuf.ByteString getPortsBytes(int index) { 7223 return ports_.getByteString(index); 7224 } 7225 /** 7226 * 7227 * 7228 * <pre> 7229 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7230 * </pre> 7231 * 7232 * <code>repeated string ports = 106854418;</code> 7233 * 7234 * @param index The index to set the value at. 7235 * @param value The ports to set. 7236 * @return This builder for chaining. 7237 */ setPorts(int index, java.lang.String value)7238 public Builder setPorts(int index, java.lang.String value) { 7239 if (value == null) { 7240 throw new NullPointerException(); 7241 } 7242 ensurePortsIsMutable(); 7243 ports_.set(index, value); 7244 onChanged(); 7245 return this; 7246 } 7247 /** 7248 * 7249 * 7250 * <pre> 7251 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7252 * </pre> 7253 * 7254 * <code>repeated string ports = 106854418;</code> 7255 * 7256 * @param value The ports to add. 7257 * @return This builder for chaining. 7258 */ addPorts(java.lang.String value)7259 public Builder addPorts(java.lang.String value) { 7260 if (value == null) { 7261 throw new NullPointerException(); 7262 } 7263 ensurePortsIsMutable(); 7264 ports_.add(value); 7265 onChanged(); 7266 return this; 7267 } 7268 /** 7269 * 7270 * 7271 * <pre> 7272 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7273 * </pre> 7274 * 7275 * <code>repeated string ports = 106854418;</code> 7276 * 7277 * @param values The ports to add. 7278 * @return This builder for chaining. 7279 */ addAllPorts(java.lang.Iterable<java.lang.String> values)7280 public Builder addAllPorts(java.lang.Iterable<java.lang.String> values) { 7281 ensurePortsIsMutable(); 7282 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, ports_); 7283 onChanged(); 7284 return this; 7285 } 7286 /** 7287 * 7288 * 7289 * <pre> 7290 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7291 * </pre> 7292 * 7293 * <code>repeated string ports = 106854418;</code> 7294 * 7295 * @return This builder for chaining. 7296 */ clearPorts()7297 public Builder clearPorts() { 7298 ports_ = com.google.protobuf.LazyStringArrayList.EMPTY; 7299 bitField0_ = (bitField0_ & ~0x00400000); 7300 onChanged(); 7301 return this; 7302 } 7303 /** 7304 * 7305 * 7306 * <pre> 7307 * This field can only be used: - If IPProtocol is one of TCP, UDP, or SCTP. - By internal TCP/UDP load balancers, backend service-based network load balancers, and internal protocol forwarding. You can specify a list of up to five ports by number, separated by commas. The ports can be contiguous or discontiguous. Only packets addressed to these ports will be forwarded to the backends configured with this forwarding rule. For external forwarding rules, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. For internal forwarding rules within the same VPC network, two or more forwarding rules cannot use the same [IPAddress, IPProtocol] pair, and cannot share any values defined in ports. The ports, port_range, and allPorts fields are mutually exclusive. @pattern: \\d+(?:-\\d+)? 7308 * </pre> 7309 * 7310 * <code>repeated string ports = 106854418;</code> 7311 * 7312 * @param value The bytes of the ports to add. 7313 * @return This builder for chaining. 7314 */ addPortsBytes(com.google.protobuf.ByteString value)7315 public Builder addPortsBytes(com.google.protobuf.ByteString value) { 7316 if (value == null) { 7317 throw new NullPointerException(); 7318 } 7319 checkByteStringIsUtf8(value); 7320 ensurePortsIsMutable(); 7321 ports_.add(value); 7322 onChanged(); 7323 return this; 7324 } 7325 7326 private long pscConnectionId_; 7327 /** 7328 * 7329 * 7330 * <pre> 7331 * [Output Only] The PSC connection id of the PSC Forwarding Rule. 7332 * </pre> 7333 * 7334 * <code>optional uint64 psc_connection_id = 292082397;</code> 7335 * 7336 * @return Whether the pscConnectionId field is set. 7337 */ 7338 @java.lang.Override hasPscConnectionId()7339 public boolean hasPscConnectionId() { 7340 return ((bitField0_ & 0x00800000) != 0); 7341 } 7342 /** 7343 * 7344 * 7345 * <pre> 7346 * [Output Only] The PSC connection id of the PSC Forwarding Rule. 7347 * </pre> 7348 * 7349 * <code>optional uint64 psc_connection_id = 292082397;</code> 7350 * 7351 * @return The pscConnectionId. 7352 */ 7353 @java.lang.Override getPscConnectionId()7354 public long getPscConnectionId() { 7355 return pscConnectionId_; 7356 } 7357 /** 7358 * 7359 * 7360 * <pre> 7361 * [Output Only] The PSC connection id of the PSC Forwarding Rule. 7362 * </pre> 7363 * 7364 * <code>optional uint64 psc_connection_id = 292082397;</code> 7365 * 7366 * @param value The pscConnectionId to set. 7367 * @return This builder for chaining. 7368 */ setPscConnectionId(long value)7369 public Builder setPscConnectionId(long value) { 7370 7371 pscConnectionId_ = value; 7372 bitField0_ |= 0x00800000; 7373 onChanged(); 7374 return this; 7375 } 7376 /** 7377 * 7378 * 7379 * <pre> 7380 * [Output Only] The PSC connection id of the PSC Forwarding Rule. 7381 * </pre> 7382 * 7383 * <code>optional uint64 psc_connection_id = 292082397;</code> 7384 * 7385 * @return This builder for chaining. 7386 */ clearPscConnectionId()7387 public Builder clearPscConnectionId() { 7388 bitField0_ = (bitField0_ & ~0x00800000); 7389 pscConnectionId_ = 0L; 7390 onChanged(); 7391 return this; 7392 } 7393 7394 private java.lang.Object pscConnectionStatus_ = ""; 7395 /** 7396 * 7397 * 7398 * <pre> 7399 * 7400 * Check the PscConnectionStatus enum for the list of possible values. 7401 * </pre> 7402 * 7403 * <code>optional string psc_connection_status = 184149172;</code> 7404 * 7405 * @return Whether the pscConnectionStatus field is set. 7406 */ hasPscConnectionStatus()7407 public boolean hasPscConnectionStatus() { 7408 return ((bitField0_ & 0x01000000) != 0); 7409 } 7410 /** 7411 * 7412 * 7413 * <pre> 7414 * 7415 * Check the PscConnectionStatus enum for the list of possible values. 7416 * </pre> 7417 * 7418 * <code>optional string psc_connection_status = 184149172;</code> 7419 * 7420 * @return The pscConnectionStatus. 7421 */ getPscConnectionStatus()7422 public java.lang.String getPscConnectionStatus() { 7423 java.lang.Object ref = pscConnectionStatus_; 7424 if (!(ref instanceof java.lang.String)) { 7425 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 7426 java.lang.String s = bs.toStringUtf8(); 7427 pscConnectionStatus_ = s; 7428 return s; 7429 } else { 7430 return (java.lang.String) ref; 7431 } 7432 } 7433 /** 7434 * 7435 * 7436 * <pre> 7437 * 7438 * Check the PscConnectionStatus enum for the list of possible values. 7439 * </pre> 7440 * 7441 * <code>optional string psc_connection_status = 184149172;</code> 7442 * 7443 * @return The bytes for pscConnectionStatus. 7444 */ getPscConnectionStatusBytes()7445 public com.google.protobuf.ByteString getPscConnectionStatusBytes() { 7446 java.lang.Object ref = pscConnectionStatus_; 7447 if (ref instanceof String) { 7448 com.google.protobuf.ByteString b = 7449 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 7450 pscConnectionStatus_ = b; 7451 return b; 7452 } else { 7453 return (com.google.protobuf.ByteString) ref; 7454 } 7455 } 7456 /** 7457 * 7458 * 7459 * <pre> 7460 * 7461 * Check the PscConnectionStatus enum for the list of possible values. 7462 * </pre> 7463 * 7464 * <code>optional string psc_connection_status = 184149172;</code> 7465 * 7466 * @param value The pscConnectionStatus to set. 7467 * @return This builder for chaining. 7468 */ setPscConnectionStatus(java.lang.String value)7469 public Builder setPscConnectionStatus(java.lang.String value) { 7470 if (value == null) { 7471 throw new NullPointerException(); 7472 } 7473 pscConnectionStatus_ = value; 7474 bitField0_ |= 0x01000000; 7475 onChanged(); 7476 return this; 7477 } 7478 /** 7479 * 7480 * 7481 * <pre> 7482 * 7483 * Check the PscConnectionStatus enum for the list of possible values. 7484 * </pre> 7485 * 7486 * <code>optional string psc_connection_status = 184149172;</code> 7487 * 7488 * @return This builder for chaining. 7489 */ clearPscConnectionStatus()7490 public Builder clearPscConnectionStatus() { 7491 pscConnectionStatus_ = getDefaultInstance().getPscConnectionStatus(); 7492 bitField0_ = (bitField0_ & ~0x01000000); 7493 onChanged(); 7494 return this; 7495 } 7496 /** 7497 * 7498 * 7499 * <pre> 7500 * 7501 * Check the PscConnectionStatus enum for the list of possible values. 7502 * </pre> 7503 * 7504 * <code>optional string psc_connection_status = 184149172;</code> 7505 * 7506 * @param value The bytes for pscConnectionStatus to set. 7507 * @return This builder for chaining. 7508 */ setPscConnectionStatusBytes(com.google.protobuf.ByteString value)7509 public Builder setPscConnectionStatusBytes(com.google.protobuf.ByteString value) { 7510 if (value == null) { 7511 throw new NullPointerException(); 7512 } 7513 checkByteStringIsUtf8(value); 7514 pscConnectionStatus_ = value; 7515 bitField0_ |= 0x01000000; 7516 onChanged(); 7517 return this; 7518 } 7519 7520 private java.lang.Object region_ = ""; 7521 /** 7522 * 7523 * 7524 * <pre> 7525 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 7526 * </pre> 7527 * 7528 * <code>optional string region = 138946292;</code> 7529 * 7530 * @return Whether the region field is set. 7531 */ hasRegion()7532 public boolean hasRegion() { 7533 return ((bitField0_ & 0x02000000) != 0); 7534 } 7535 /** 7536 * 7537 * 7538 * <pre> 7539 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 7540 * </pre> 7541 * 7542 * <code>optional string region = 138946292;</code> 7543 * 7544 * @return The region. 7545 */ getRegion()7546 public java.lang.String getRegion() { 7547 java.lang.Object ref = region_; 7548 if (!(ref instanceof java.lang.String)) { 7549 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 7550 java.lang.String s = bs.toStringUtf8(); 7551 region_ = s; 7552 return s; 7553 } else { 7554 return (java.lang.String) ref; 7555 } 7556 } 7557 /** 7558 * 7559 * 7560 * <pre> 7561 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 7562 * </pre> 7563 * 7564 * <code>optional string region = 138946292;</code> 7565 * 7566 * @return The bytes for region. 7567 */ getRegionBytes()7568 public com.google.protobuf.ByteString getRegionBytes() { 7569 java.lang.Object ref = region_; 7570 if (ref instanceof String) { 7571 com.google.protobuf.ByteString b = 7572 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 7573 region_ = b; 7574 return b; 7575 } else { 7576 return (com.google.protobuf.ByteString) ref; 7577 } 7578 } 7579 /** 7580 * 7581 * 7582 * <pre> 7583 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 7584 * </pre> 7585 * 7586 * <code>optional string region = 138946292;</code> 7587 * 7588 * @param value The region to set. 7589 * @return This builder for chaining. 7590 */ setRegion(java.lang.String value)7591 public Builder setRegion(java.lang.String value) { 7592 if (value == null) { 7593 throw new NullPointerException(); 7594 } 7595 region_ = value; 7596 bitField0_ |= 0x02000000; 7597 onChanged(); 7598 return this; 7599 } 7600 /** 7601 * 7602 * 7603 * <pre> 7604 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 7605 * </pre> 7606 * 7607 * <code>optional string region = 138946292;</code> 7608 * 7609 * @return This builder for chaining. 7610 */ clearRegion()7611 public Builder clearRegion() { 7612 region_ = getDefaultInstance().getRegion(); 7613 bitField0_ = (bitField0_ & ~0x02000000); 7614 onChanged(); 7615 return this; 7616 } 7617 /** 7618 * 7619 * 7620 * <pre> 7621 * [Output Only] URL of the region where the regional forwarding rule resides. This field is not applicable to global forwarding rules. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 7622 * </pre> 7623 * 7624 * <code>optional string region = 138946292;</code> 7625 * 7626 * @param value The bytes for region to set. 7627 * @return This builder for chaining. 7628 */ setRegionBytes(com.google.protobuf.ByteString value)7629 public Builder setRegionBytes(com.google.protobuf.ByteString value) { 7630 if (value == null) { 7631 throw new NullPointerException(); 7632 } 7633 checkByteStringIsUtf8(value); 7634 region_ = value; 7635 bitField0_ |= 0x02000000; 7636 onChanged(); 7637 return this; 7638 } 7639 7640 private java.lang.Object selfLink_ = ""; 7641 /** 7642 * 7643 * 7644 * <pre> 7645 * [Output Only] Server-defined URL for the resource. 7646 * </pre> 7647 * 7648 * <code>optional string self_link = 456214797;</code> 7649 * 7650 * @return Whether the selfLink field is set. 7651 */ hasSelfLink()7652 public boolean hasSelfLink() { 7653 return ((bitField0_ & 0x04000000) != 0); 7654 } 7655 /** 7656 * 7657 * 7658 * <pre> 7659 * [Output Only] Server-defined URL for the resource. 7660 * </pre> 7661 * 7662 * <code>optional string self_link = 456214797;</code> 7663 * 7664 * @return The selfLink. 7665 */ getSelfLink()7666 public java.lang.String getSelfLink() { 7667 java.lang.Object ref = selfLink_; 7668 if (!(ref instanceof java.lang.String)) { 7669 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 7670 java.lang.String s = bs.toStringUtf8(); 7671 selfLink_ = s; 7672 return s; 7673 } else { 7674 return (java.lang.String) ref; 7675 } 7676 } 7677 /** 7678 * 7679 * 7680 * <pre> 7681 * [Output Only] Server-defined URL for the resource. 7682 * </pre> 7683 * 7684 * <code>optional string self_link = 456214797;</code> 7685 * 7686 * @return The bytes for selfLink. 7687 */ getSelfLinkBytes()7688 public com.google.protobuf.ByteString getSelfLinkBytes() { 7689 java.lang.Object ref = selfLink_; 7690 if (ref instanceof String) { 7691 com.google.protobuf.ByteString b = 7692 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 7693 selfLink_ = b; 7694 return b; 7695 } else { 7696 return (com.google.protobuf.ByteString) ref; 7697 } 7698 } 7699 /** 7700 * 7701 * 7702 * <pre> 7703 * [Output Only] Server-defined URL for the resource. 7704 * </pre> 7705 * 7706 * <code>optional string self_link = 456214797;</code> 7707 * 7708 * @param value The selfLink to set. 7709 * @return This builder for chaining. 7710 */ setSelfLink(java.lang.String value)7711 public Builder setSelfLink(java.lang.String value) { 7712 if (value == null) { 7713 throw new NullPointerException(); 7714 } 7715 selfLink_ = value; 7716 bitField0_ |= 0x04000000; 7717 onChanged(); 7718 return this; 7719 } 7720 /** 7721 * 7722 * 7723 * <pre> 7724 * [Output Only] Server-defined URL for the resource. 7725 * </pre> 7726 * 7727 * <code>optional string self_link = 456214797;</code> 7728 * 7729 * @return This builder for chaining. 7730 */ clearSelfLink()7731 public Builder clearSelfLink() { 7732 selfLink_ = getDefaultInstance().getSelfLink(); 7733 bitField0_ = (bitField0_ & ~0x04000000); 7734 onChanged(); 7735 return this; 7736 } 7737 /** 7738 * 7739 * 7740 * <pre> 7741 * [Output Only] Server-defined URL for the resource. 7742 * </pre> 7743 * 7744 * <code>optional string self_link = 456214797;</code> 7745 * 7746 * @param value The bytes for selfLink to set. 7747 * @return This builder for chaining. 7748 */ setSelfLinkBytes(com.google.protobuf.ByteString value)7749 public Builder setSelfLinkBytes(com.google.protobuf.ByteString value) { 7750 if (value == null) { 7751 throw new NullPointerException(); 7752 } 7753 checkByteStringIsUtf8(value); 7754 selfLink_ = value; 7755 bitField0_ |= 0x04000000; 7756 onChanged(); 7757 return this; 7758 } 7759 7760 private java.util.List<com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration> 7761 serviceDirectoryRegistrations_ = java.util.Collections.emptyList(); 7762 ensureServiceDirectoryRegistrationsIsMutable()7763 private void ensureServiceDirectoryRegistrationsIsMutable() { 7764 if (!((bitField0_ & 0x08000000) != 0)) { 7765 serviceDirectoryRegistrations_ = 7766 new java.util.ArrayList< 7767 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration>( 7768 serviceDirectoryRegistrations_); 7769 bitField0_ |= 0x08000000; 7770 } 7771 } 7772 7773 private com.google.protobuf.RepeatedFieldBuilderV3< 7774 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration, 7775 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder, 7776 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistrationOrBuilder> 7777 serviceDirectoryRegistrationsBuilder_; 7778 7779 /** 7780 * 7781 * 7782 * <pre> 7783 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7784 * </pre> 7785 * 7786 * <code> 7787 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7788 * </code> 7789 */ 7790 public java.util.List<com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration> getServiceDirectoryRegistrationsList()7791 getServiceDirectoryRegistrationsList() { 7792 if (serviceDirectoryRegistrationsBuilder_ == null) { 7793 return java.util.Collections.unmodifiableList(serviceDirectoryRegistrations_); 7794 } else { 7795 return serviceDirectoryRegistrationsBuilder_.getMessageList(); 7796 } 7797 } 7798 /** 7799 * 7800 * 7801 * <pre> 7802 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7803 * </pre> 7804 * 7805 * <code> 7806 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7807 * </code> 7808 */ getServiceDirectoryRegistrationsCount()7809 public int getServiceDirectoryRegistrationsCount() { 7810 if (serviceDirectoryRegistrationsBuilder_ == null) { 7811 return serviceDirectoryRegistrations_.size(); 7812 } else { 7813 return serviceDirectoryRegistrationsBuilder_.getCount(); 7814 } 7815 } 7816 /** 7817 * 7818 * 7819 * <pre> 7820 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7821 * </pre> 7822 * 7823 * <code> 7824 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7825 * </code> 7826 */ 7827 public com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration getServiceDirectoryRegistrations(int index)7828 getServiceDirectoryRegistrations(int index) { 7829 if (serviceDirectoryRegistrationsBuilder_ == null) { 7830 return serviceDirectoryRegistrations_.get(index); 7831 } else { 7832 return serviceDirectoryRegistrationsBuilder_.getMessage(index); 7833 } 7834 } 7835 /** 7836 * 7837 * 7838 * <pre> 7839 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7840 * </pre> 7841 * 7842 * <code> 7843 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7844 * </code> 7845 */ setServiceDirectoryRegistrations( int index, com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration value)7846 public Builder setServiceDirectoryRegistrations( 7847 int index, com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration value) { 7848 if (serviceDirectoryRegistrationsBuilder_ == null) { 7849 if (value == null) { 7850 throw new NullPointerException(); 7851 } 7852 ensureServiceDirectoryRegistrationsIsMutable(); 7853 serviceDirectoryRegistrations_.set(index, value); 7854 onChanged(); 7855 } else { 7856 serviceDirectoryRegistrationsBuilder_.setMessage(index, value); 7857 } 7858 return this; 7859 } 7860 /** 7861 * 7862 * 7863 * <pre> 7864 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7865 * </pre> 7866 * 7867 * <code> 7868 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7869 * </code> 7870 */ setServiceDirectoryRegistrations( int index, com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder builderForValue)7871 public Builder setServiceDirectoryRegistrations( 7872 int index, 7873 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder 7874 builderForValue) { 7875 if (serviceDirectoryRegistrationsBuilder_ == null) { 7876 ensureServiceDirectoryRegistrationsIsMutable(); 7877 serviceDirectoryRegistrations_.set(index, builderForValue.build()); 7878 onChanged(); 7879 } else { 7880 serviceDirectoryRegistrationsBuilder_.setMessage(index, builderForValue.build()); 7881 } 7882 return this; 7883 } 7884 /** 7885 * 7886 * 7887 * <pre> 7888 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7889 * </pre> 7890 * 7891 * <code> 7892 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7893 * </code> 7894 */ addServiceDirectoryRegistrations( com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration value)7895 public Builder addServiceDirectoryRegistrations( 7896 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration value) { 7897 if (serviceDirectoryRegistrationsBuilder_ == null) { 7898 if (value == null) { 7899 throw new NullPointerException(); 7900 } 7901 ensureServiceDirectoryRegistrationsIsMutable(); 7902 serviceDirectoryRegistrations_.add(value); 7903 onChanged(); 7904 } else { 7905 serviceDirectoryRegistrationsBuilder_.addMessage(value); 7906 } 7907 return this; 7908 } 7909 /** 7910 * 7911 * 7912 * <pre> 7913 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7914 * </pre> 7915 * 7916 * <code> 7917 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7918 * </code> 7919 */ addServiceDirectoryRegistrations( int index, com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration value)7920 public Builder addServiceDirectoryRegistrations( 7921 int index, com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration value) { 7922 if (serviceDirectoryRegistrationsBuilder_ == null) { 7923 if (value == null) { 7924 throw new NullPointerException(); 7925 } 7926 ensureServiceDirectoryRegistrationsIsMutable(); 7927 serviceDirectoryRegistrations_.add(index, value); 7928 onChanged(); 7929 } else { 7930 serviceDirectoryRegistrationsBuilder_.addMessage(index, value); 7931 } 7932 return this; 7933 } 7934 /** 7935 * 7936 * 7937 * <pre> 7938 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7939 * </pre> 7940 * 7941 * <code> 7942 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7943 * </code> 7944 */ addServiceDirectoryRegistrations( com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder builderForValue)7945 public Builder addServiceDirectoryRegistrations( 7946 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder 7947 builderForValue) { 7948 if (serviceDirectoryRegistrationsBuilder_ == null) { 7949 ensureServiceDirectoryRegistrationsIsMutable(); 7950 serviceDirectoryRegistrations_.add(builderForValue.build()); 7951 onChanged(); 7952 } else { 7953 serviceDirectoryRegistrationsBuilder_.addMessage(builderForValue.build()); 7954 } 7955 return this; 7956 } 7957 /** 7958 * 7959 * 7960 * <pre> 7961 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7962 * </pre> 7963 * 7964 * <code> 7965 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7966 * </code> 7967 */ addServiceDirectoryRegistrations( int index, com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder builderForValue)7968 public Builder addServiceDirectoryRegistrations( 7969 int index, 7970 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder 7971 builderForValue) { 7972 if (serviceDirectoryRegistrationsBuilder_ == null) { 7973 ensureServiceDirectoryRegistrationsIsMutable(); 7974 serviceDirectoryRegistrations_.add(index, builderForValue.build()); 7975 onChanged(); 7976 } else { 7977 serviceDirectoryRegistrationsBuilder_.addMessage(index, builderForValue.build()); 7978 } 7979 return this; 7980 } 7981 /** 7982 * 7983 * 7984 * <pre> 7985 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 7986 * </pre> 7987 * 7988 * <code> 7989 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 7990 * </code> 7991 */ addAllServiceDirectoryRegistrations( java.lang.Iterable< ? extends com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration> values)7992 public Builder addAllServiceDirectoryRegistrations( 7993 java.lang.Iterable< 7994 ? extends com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration> 7995 values) { 7996 if (serviceDirectoryRegistrationsBuilder_ == null) { 7997 ensureServiceDirectoryRegistrationsIsMutable(); 7998 com.google.protobuf.AbstractMessageLite.Builder.addAll( 7999 values, serviceDirectoryRegistrations_); 8000 onChanged(); 8001 } else { 8002 serviceDirectoryRegistrationsBuilder_.addAllMessages(values); 8003 } 8004 return this; 8005 } 8006 /** 8007 * 8008 * 8009 * <pre> 8010 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 8011 * </pre> 8012 * 8013 * <code> 8014 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 8015 * </code> 8016 */ clearServiceDirectoryRegistrations()8017 public Builder clearServiceDirectoryRegistrations() { 8018 if (serviceDirectoryRegistrationsBuilder_ == null) { 8019 serviceDirectoryRegistrations_ = java.util.Collections.emptyList(); 8020 bitField0_ = (bitField0_ & ~0x08000000); 8021 onChanged(); 8022 } else { 8023 serviceDirectoryRegistrationsBuilder_.clear(); 8024 } 8025 return this; 8026 } 8027 /** 8028 * 8029 * 8030 * <pre> 8031 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 8032 * </pre> 8033 * 8034 * <code> 8035 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 8036 * </code> 8037 */ removeServiceDirectoryRegistrations(int index)8038 public Builder removeServiceDirectoryRegistrations(int index) { 8039 if (serviceDirectoryRegistrationsBuilder_ == null) { 8040 ensureServiceDirectoryRegistrationsIsMutable(); 8041 serviceDirectoryRegistrations_.remove(index); 8042 onChanged(); 8043 } else { 8044 serviceDirectoryRegistrationsBuilder_.remove(index); 8045 } 8046 return this; 8047 } 8048 /** 8049 * 8050 * 8051 * <pre> 8052 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 8053 * </pre> 8054 * 8055 * <code> 8056 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 8057 * </code> 8058 */ 8059 public com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder getServiceDirectoryRegistrationsBuilder(int index)8060 getServiceDirectoryRegistrationsBuilder(int index) { 8061 return getServiceDirectoryRegistrationsFieldBuilder().getBuilder(index); 8062 } 8063 /** 8064 * 8065 * 8066 * <pre> 8067 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 8068 * </pre> 8069 * 8070 * <code> 8071 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 8072 * </code> 8073 */ 8074 public com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistrationOrBuilder getServiceDirectoryRegistrationsOrBuilder(int index)8075 getServiceDirectoryRegistrationsOrBuilder(int index) { 8076 if (serviceDirectoryRegistrationsBuilder_ == null) { 8077 return serviceDirectoryRegistrations_.get(index); 8078 } else { 8079 return serviceDirectoryRegistrationsBuilder_.getMessageOrBuilder(index); 8080 } 8081 } 8082 /** 8083 * 8084 * 8085 * <pre> 8086 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 8087 * </pre> 8088 * 8089 * <code> 8090 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 8091 * </code> 8092 */ 8093 public java.util.List< 8094 ? extends 8095 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistrationOrBuilder> getServiceDirectoryRegistrationsOrBuilderList()8096 getServiceDirectoryRegistrationsOrBuilderList() { 8097 if (serviceDirectoryRegistrationsBuilder_ != null) { 8098 return serviceDirectoryRegistrationsBuilder_.getMessageOrBuilderList(); 8099 } else { 8100 return java.util.Collections.unmodifiableList(serviceDirectoryRegistrations_); 8101 } 8102 } 8103 /** 8104 * 8105 * 8106 * <pre> 8107 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 8108 * </pre> 8109 * 8110 * <code> 8111 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 8112 * </code> 8113 */ 8114 public com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder addServiceDirectoryRegistrationsBuilder()8115 addServiceDirectoryRegistrationsBuilder() { 8116 return getServiceDirectoryRegistrationsFieldBuilder() 8117 .addBuilder( 8118 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration 8119 .getDefaultInstance()); 8120 } 8121 /** 8122 * 8123 * 8124 * <pre> 8125 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 8126 * </pre> 8127 * 8128 * <code> 8129 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 8130 * </code> 8131 */ 8132 public com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder addServiceDirectoryRegistrationsBuilder(int index)8133 addServiceDirectoryRegistrationsBuilder(int index) { 8134 return getServiceDirectoryRegistrationsFieldBuilder() 8135 .addBuilder( 8136 index, 8137 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration 8138 .getDefaultInstance()); 8139 } 8140 /** 8141 * 8142 * 8143 * <pre> 8144 * Service Directory resources to register this forwarding rule with. Currently, only supports a single Service Directory resource. 8145 * </pre> 8146 * 8147 * <code> 8148 * repeated .google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration service_directory_registrations = 223549694; 8149 * </code> 8150 */ 8151 public java.util.List< 8152 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder> getServiceDirectoryRegistrationsBuilderList()8153 getServiceDirectoryRegistrationsBuilderList() { 8154 return getServiceDirectoryRegistrationsFieldBuilder().getBuilderList(); 8155 } 8156 8157 private com.google.protobuf.RepeatedFieldBuilderV3< 8158 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration, 8159 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder, 8160 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistrationOrBuilder> getServiceDirectoryRegistrationsFieldBuilder()8161 getServiceDirectoryRegistrationsFieldBuilder() { 8162 if (serviceDirectoryRegistrationsBuilder_ == null) { 8163 serviceDirectoryRegistrationsBuilder_ = 8164 new com.google.protobuf.RepeatedFieldBuilderV3< 8165 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration, 8166 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistration.Builder, 8167 com.google.cloud.compute.v1.ForwardingRuleServiceDirectoryRegistrationOrBuilder>( 8168 serviceDirectoryRegistrations_, 8169 ((bitField0_ & 0x08000000) != 0), 8170 getParentForChildren(), 8171 isClean()); 8172 serviceDirectoryRegistrations_ = null; 8173 } 8174 return serviceDirectoryRegistrationsBuilder_; 8175 } 8176 8177 private java.lang.Object serviceLabel_ = ""; 8178 /** 8179 * 8180 * 8181 * <pre> 8182 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 8183 * </pre> 8184 * 8185 * <code>optional string service_label = 417008874;</code> 8186 * 8187 * @return Whether the serviceLabel field is set. 8188 */ hasServiceLabel()8189 public boolean hasServiceLabel() { 8190 return ((bitField0_ & 0x10000000) != 0); 8191 } 8192 /** 8193 * 8194 * 8195 * <pre> 8196 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 8197 * </pre> 8198 * 8199 * <code>optional string service_label = 417008874;</code> 8200 * 8201 * @return The serviceLabel. 8202 */ getServiceLabel()8203 public java.lang.String getServiceLabel() { 8204 java.lang.Object ref = serviceLabel_; 8205 if (!(ref instanceof java.lang.String)) { 8206 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 8207 java.lang.String s = bs.toStringUtf8(); 8208 serviceLabel_ = s; 8209 return s; 8210 } else { 8211 return (java.lang.String) ref; 8212 } 8213 } 8214 /** 8215 * 8216 * 8217 * <pre> 8218 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 8219 * </pre> 8220 * 8221 * <code>optional string service_label = 417008874;</code> 8222 * 8223 * @return The bytes for serviceLabel. 8224 */ getServiceLabelBytes()8225 public com.google.protobuf.ByteString getServiceLabelBytes() { 8226 java.lang.Object ref = serviceLabel_; 8227 if (ref instanceof String) { 8228 com.google.protobuf.ByteString b = 8229 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 8230 serviceLabel_ = b; 8231 return b; 8232 } else { 8233 return (com.google.protobuf.ByteString) ref; 8234 } 8235 } 8236 /** 8237 * 8238 * 8239 * <pre> 8240 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 8241 * </pre> 8242 * 8243 * <code>optional string service_label = 417008874;</code> 8244 * 8245 * @param value The serviceLabel to set. 8246 * @return This builder for chaining. 8247 */ setServiceLabel(java.lang.String value)8248 public Builder setServiceLabel(java.lang.String value) { 8249 if (value == null) { 8250 throw new NullPointerException(); 8251 } 8252 serviceLabel_ = value; 8253 bitField0_ |= 0x10000000; 8254 onChanged(); 8255 return this; 8256 } 8257 /** 8258 * 8259 * 8260 * <pre> 8261 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 8262 * </pre> 8263 * 8264 * <code>optional string service_label = 417008874;</code> 8265 * 8266 * @return This builder for chaining. 8267 */ clearServiceLabel()8268 public Builder clearServiceLabel() { 8269 serviceLabel_ = getDefaultInstance().getServiceLabel(); 8270 bitField0_ = (bitField0_ & ~0x10000000); 8271 onChanged(); 8272 return this; 8273 } 8274 /** 8275 * 8276 * 8277 * <pre> 8278 * An optional prefix to the service name for this Forwarding Rule. If specified, the prefix is the first label of the fully qualified service name. The label must be 1-63 characters long, and comply with RFC1035. Specifically, the label must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. This field is only used for internal load balancing. 8279 * </pre> 8280 * 8281 * <code>optional string service_label = 417008874;</code> 8282 * 8283 * @param value The bytes for serviceLabel to set. 8284 * @return This builder for chaining. 8285 */ setServiceLabelBytes(com.google.protobuf.ByteString value)8286 public Builder setServiceLabelBytes(com.google.protobuf.ByteString value) { 8287 if (value == null) { 8288 throw new NullPointerException(); 8289 } 8290 checkByteStringIsUtf8(value); 8291 serviceLabel_ = value; 8292 bitField0_ |= 0x10000000; 8293 onChanged(); 8294 return this; 8295 } 8296 8297 private java.lang.Object serviceName_ = ""; 8298 /** 8299 * 8300 * 8301 * <pre> 8302 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 8303 * </pre> 8304 * 8305 * <code>optional string service_name = 359880149;</code> 8306 * 8307 * @return Whether the serviceName field is set. 8308 */ hasServiceName()8309 public boolean hasServiceName() { 8310 return ((bitField0_ & 0x20000000) != 0); 8311 } 8312 /** 8313 * 8314 * 8315 * <pre> 8316 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 8317 * </pre> 8318 * 8319 * <code>optional string service_name = 359880149;</code> 8320 * 8321 * @return The serviceName. 8322 */ getServiceName()8323 public java.lang.String getServiceName() { 8324 java.lang.Object ref = serviceName_; 8325 if (!(ref instanceof java.lang.String)) { 8326 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 8327 java.lang.String s = bs.toStringUtf8(); 8328 serviceName_ = s; 8329 return s; 8330 } else { 8331 return (java.lang.String) ref; 8332 } 8333 } 8334 /** 8335 * 8336 * 8337 * <pre> 8338 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 8339 * </pre> 8340 * 8341 * <code>optional string service_name = 359880149;</code> 8342 * 8343 * @return The bytes for serviceName. 8344 */ getServiceNameBytes()8345 public com.google.protobuf.ByteString getServiceNameBytes() { 8346 java.lang.Object ref = serviceName_; 8347 if (ref instanceof String) { 8348 com.google.protobuf.ByteString b = 8349 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 8350 serviceName_ = b; 8351 return b; 8352 } else { 8353 return (com.google.protobuf.ByteString) ref; 8354 } 8355 } 8356 /** 8357 * 8358 * 8359 * <pre> 8360 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 8361 * </pre> 8362 * 8363 * <code>optional string service_name = 359880149;</code> 8364 * 8365 * @param value The serviceName to set. 8366 * @return This builder for chaining. 8367 */ setServiceName(java.lang.String value)8368 public Builder setServiceName(java.lang.String value) { 8369 if (value == null) { 8370 throw new NullPointerException(); 8371 } 8372 serviceName_ = value; 8373 bitField0_ |= 0x20000000; 8374 onChanged(); 8375 return this; 8376 } 8377 /** 8378 * 8379 * 8380 * <pre> 8381 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 8382 * </pre> 8383 * 8384 * <code>optional string service_name = 359880149;</code> 8385 * 8386 * @return This builder for chaining. 8387 */ clearServiceName()8388 public Builder clearServiceName() { 8389 serviceName_ = getDefaultInstance().getServiceName(); 8390 bitField0_ = (bitField0_ & ~0x20000000); 8391 onChanged(); 8392 return this; 8393 } 8394 /** 8395 * 8396 * 8397 * <pre> 8398 * [Output Only] The internal fully qualified service name for this Forwarding Rule. This field is only used for internal load balancing. 8399 * </pre> 8400 * 8401 * <code>optional string service_name = 359880149;</code> 8402 * 8403 * @param value The bytes for serviceName to set. 8404 * @return This builder for chaining. 8405 */ setServiceNameBytes(com.google.protobuf.ByteString value)8406 public Builder setServiceNameBytes(com.google.protobuf.ByteString value) { 8407 if (value == null) { 8408 throw new NullPointerException(); 8409 } 8410 checkByteStringIsUtf8(value); 8411 serviceName_ = value; 8412 bitField0_ |= 0x20000000; 8413 onChanged(); 8414 return this; 8415 } 8416 8417 private com.google.protobuf.LazyStringList sourceIpRanges_ = 8418 com.google.protobuf.LazyStringArrayList.EMPTY; 8419 ensureSourceIpRangesIsMutable()8420 private void ensureSourceIpRangesIsMutable() { 8421 if (!((bitField0_ & 0x40000000) != 0)) { 8422 sourceIpRanges_ = new com.google.protobuf.LazyStringArrayList(sourceIpRanges_); 8423 bitField0_ |= 0x40000000; 8424 } 8425 } 8426 /** 8427 * 8428 * 8429 * <pre> 8430 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8431 * </pre> 8432 * 8433 * <code>repeated string source_ip_ranges = 111563210;</code> 8434 * 8435 * @return A list containing the sourceIpRanges. 8436 */ getSourceIpRangesList()8437 public com.google.protobuf.ProtocolStringList getSourceIpRangesList() { 8438 return sourceIpRanges_.getUnmodifiableView(); 8439 } 8440 /** 8441 * 8442 * 8443 * <pre> 8444 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8445 * </pre> 8446 * 8447 * <code>repeated string source_ip_ranges = 111563210;</code> 8448 * 8449 * @return The count of sourceIpRanges. 8450 */ getSourceIpRangesCount()8451 public int getSourceIpRangesCount() { 8452 return sourceIpRanges_.size(); 8453 } 8454 /** 8455 * 8456 * 8457 * <pre> 8458 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8459 * </pre> 8460 * 8461 * <code>repeated string source_ip_ranges = 111563210;</code> 8462 * 8463 * @param index The index of the element to return. 8464 * @return The sourceIpRanges at the given index. 8465 */ getSourceIpRanges(int index)8466 public java.lang.String getSourceIpRanges(int index) { 8467 return sourceIpRanges_.get(index); 8468 } 8469 /** 8470 * 8471 * 8472 * <pre> 8473 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8474 * </pre> 8475 * 8476 * <code>repeated string source_ip_ranges = 111563210;</code> 8477 * 8478 * @param index The index of the value to return. 8479 * @return The bytes of the sourceIpRanges at the given index. 8480 */ getSourceIpRangesBytes(int index)8481 public com.google.protobuf.ByteString getSourceIpRangesBytes(int index) { 8482 return sourceIpRanges_.getByteString(index); 8483 } 8484 /** 8485 * 8486 * 8487 * <pre> 8488 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8489 * </pre> 8490 * 8491 * <code>repeated string source_ip_ranges = 111563210;</code> 8492 * 8493 * @param index The index to set the value at. 8494 * @param value The sourceIpRanges to set. 8495 * @return This builder for chaining. 8496 */ setSourceIpRanges(int index, java.lang.String value)8497 public Builder setSourceIpRanges(int index, java.lang.String value) { 8498 if (value == null) { 8499 throw new NullPointerException(); 8500 } 8501 ensureSourceIpRangesIsMutable(); 8502 sourceIpRanges_.set(index, value); 8503 onChanged(); 8504 return this; 8505 } 8506 /** 8507 * 8508 * 8509 * <pre> 8510 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8511 * </pre> 8512 * 8513 * <code>repeated string source_ip_ranges = 111563210;</code> 8514 * 8515 * @param value The sourceIpRanges to add. 8516 * @return This builder for chaining. 8517 */ addSourceIpRanges(java.lang.String value)8518 public Builder addSourceIpRanges(java.lang.String value) { 8519 if (value == null) { 8520 throw new NullPointerException(); 8521 } 8522 ensureSourceIpRangesIsMutable(); 8523 sourceIpRanges_.add(value); 8524 onChanged(); 8525 return this; 8526 } 8527 /** 8528 * 8529 * 8530 * <pre> 8531 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8532 * </pre> 8533 * 8534 * <code>repeated string source_ip_ranges = 111563210;</code> 8535 * 8536 * @param values The sourceIpRanges to add. 8537 * @return This builder for chaining. 8538 */ addAllSourceIpRanges(java.lang.Iterable<java.lang.String> values)8539 public Builder addAllSourceIpRanges(java.lang.Iterable<java.lang.String> values) { 8540 ensureSourceIpRangesIsMutable(); 8541 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, sourceIpRanges_); 8542 onChanged(); 8543 return this; 8544 } 8545 /** 8546 * 8547 * 8548 * <pre> 8549 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8550 * </pre> 8551 * 8552 * <code>repeated string source_ip_ranges = 111563210;</code> 8553 * 8554 * @return This builder for chaining. 8555 */ clearSourceIpRanges()8556 public Builder clearSourceIpRanges() { 8557 sourceIpRanges_ = com.google.protobuf.LazyStringArrayList.EMPTY; 8558 bitField0_ = (bitField0_ & ~0x40000000); 8559 onChanged(); 8560 return this; 8561 } 8562 /** 8563 * 8564 * 8565 * <pre> 8566 * If not empty, this Forwarding Rule will only forward the traffic when the source IP address matches one of the IP addresses or CIDR ranges set here. Note that a Forwarding Rule can only have up to 64 source IP ranges, and this field can only be used with a regional Forwarding Rule whose scheme is EXTERNAL. Each source_ip_range entry should be either an IP address (for example, 1.2.3.4) or a CIDR range (for example, 1.2.3.0/24). 8567 * </pre> 8568 * 8569 * <code>repeated string source_ip_ranges = 111563210;</code> 8570 * 8571 * @param value The bytes of the sourceIpRanges to add. 8572 * @return This builder for chaining. 8573 */ addSourceIpRangesBytes(com.google.protobuf.ByteString value)8574 public Builder addSourceIpRangesBytes(com.google.protobuf.ByteString value) { 8575 if (value == null) { 8576 throw new NullPointerException(); 8577 } 8578 checkByteStringIsUtf8(value); 8579 ensureSourceIpRangesIsMutable(); 8580 sourceIpRanges_.add(value); 8581 onChanged(); 8582 return this; 8583 } 8584 8585 private java.lang.Object subnetwork_ = ""; 8586 /** 8587 * 8588 * 8589 * <pre> 8590 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 8591 * </pre> 8592 * 8593 * <code>optional string subnetwork = 307827694;</code> 8594 * 8595 * @return Whether the subnetwork field is set. 8596 */ hasSubnetwork()8597 public boolean hasSubnetwork() { 8598 return ((bitField0_ & 0x80000000) != 0); 8599 } 8600 /** 8601 * 8602 * 8603 * <pre> 8604 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 8605 * </pre> 8606 * 8607 * <code>optional string subnetwork = 307827694;</code> 8608 * 8609 * @return The subnetwork. 8610 */ getSubnetwork()8611 public java.lang.String getSubnetwork() { 8612 java.lang.Object ref = subnetwork_; 8613 if (!(ref instanceof java.lang.String)) { 8614 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 8615 java.lang.String s = bs.toStringUtf8(); 8616 subnetwork_ = s; 8617 return s; 8618 } else { 8619 return (java.lang.String) ref; 8620 } 8621 } 8622 /** 8623 * 8624 * 8625 * <pre> 8626 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 8627 * </pre> 8628 * 8629 * <code>optional string subnetwork = 307827694;</code> 8630 * 8631 * @return The bytes for subnetwork. 8632 */ getSubnetworkBytes()8633 public com.google.protobuf.ByteString getSubnetworkBytes() { 8634 java.lang.Object ref = subnetwork_; 8635 if (ref instanceof String) { 8636 com.google.protobuf.ByteString b = 8637 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 8638 subnetwork_ = b; 8639 return b; 8640 } else { 8641 return (com.google.protobuf.ByteString) ref; 8642 } 8643 } 8644 /** 8645 * 8646 * 8647 * <pre> 8648 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 8649 * </pre> 8650 * 8651 * <code>optional string subnetwork = 307827694;</code> 8652 * 8653 * @param value The subnetwork to set. 8654 * @return This builder for chaining. 8655 */ setSubnetwork(java.lang.String value)8656 public Builder setSubnetwork(java.lang.String value) { 8657 if (value == null) { 8658 throw new NullPointerException(); 8659 } 8660 subnetwork_ = value; 8661 bitField0_ |= 0x80000000; 8662 onChanged(); 8663 return this; 8664 } 8665 /** 8666 * 8667 * 8668 * <pre> 8669 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 8670 * </pre> 8671 * 8672 * <code>optional string subnetwork = 307827694;</code> 8673 * 8674 * @return This builder for chaining. 8675 */ clearSubnetwork()8676 public Builder clearSubnetwork() { 8677 subnetwork_ = getDefaultInstance().getSubnetwork(); 8678 bitField0_ = (bitField0_ & ~0x80000000); 8679 onChanged(); 8680 return this; 8681 } 8682 /** 8683 * 8684 * 8685 * <pre> 8686 * This field identifies the subnetwork that the load balanced IP should belong to for this Forwarding Rule, used in internal load balancing and network load balancing with IPv6. If the network specified is in auto subnet mode, this field is optional. However, a subnetwork must be specified if the network is in custom subnet mode or when creating external forwarding rule with IPv6. 8687 * </pre> 8688 * 8689 * <code>optional string subnetwork = 307827694;</code> 8690 * 8691 * @param value The bytes for subnetwork to set. 8692 * @return This builder for chaining. 8693 */ setSubnetworkBytes(com.google.protobuf.ByteString value)8694 public Builder setSubnetworkBytes(com.google.protobuf.ByteString value) { 8695 if (value == null) { 8696 throw new NullPointerException(); 8697 } 8698 checkByteStringIsUtf8(value); 8699 subnetwork_ = value; 8700 bitField0_ |= 0x80000000; 8701 onChanged(); 8702 return this; 8703 } 8704 8705 private java.lang.Object target_ = ""; 8706 /** 8707 * 8708 * 8709 * <pre> 8710 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 8711 * </pre> 8712 * 8713 * <code>optional string target = 192835985;</code> 8714 * 8715 * @return Whether the target field is set. 8716 */ hasTarget()8717 public boolean hasTarget() { 8718 return ((bitField1_ & 0x00000001) != 0); 8719 } 8720 /** 8721 * 8722 * 8723 * <pre> 8724 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 8725 * </pre> 8726 * 8727 * <code>optional string target = 192835985;</code> 8728 * 8729 * @return The target. 8730 */ getTarget()8731 public java.lang.String getTarget() { 8732 java.lang.Object ref = target_; 8733 if (!(ref instanceof java.lang.String)) { 8734 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 8735 java.lang.String s = bs.toStringUtf8(); 8736 target_ = s; 8737 return s; 8738 } else { 8739 return (java.lang.String) ref; 8740 } 8741 } 8742 /** 8743 * 8744 * 8745 * <pre> 8746 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 8747 * </pre> 8748 * 8749 * <code>optional string target = 192835985;</code> 8750 * 8751 * @return The bytes for target. 8752 */ getTargetBytes()8753 public com.google.protobuf.ByteString getTargetBytes() { 8754 java.lang.Object ref = target_; 8755 if (ref instanceof String) { 8756 com.google.protobuf.ByteString b = 8757 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 8758 target_ = b; 8759 return b; 8760 } else { 8761 return (com.google.protobuf.ByteString) ref; 8762 } 8763 } 8764 /** 8765 * 8766 * 8767 * <pre> 8768 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 8769 * </pre> 8770 * 8771 * <code>optional string target = 192835985;</code> 8772 * 8773 * @param value The target to set. 8774 * @return This builder for chaining. 8775 */ setTarget(java.lang.String value)8776 public Builder setTarget(java.lang.String value) { 8777 if (value == null) { 8778 throw new NullPointerException(); 8779 } 8780 target_ = value; 8781 bitField1_ |= 0x00000001; 8782 onChanged(); 8783 return this; 8784 } 8785 /** 8786 * 8787 * 8788 * <pre> 8789 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 8790 * </pre> 8791 * 8792 * <code>optional string target = 192835985;</code> 8793 * 8794 * @return This builder for chaining. 8795 */ clearTarget()8796 public Builder clearTarget() { 8797 target_ = getDefaultInstance().getTarget(); 8798 bitField1_ = (bitField1_ & ~0x00000001); 8799 onChanged(); 8800 return this; 8801 } 8802 /** 8803 * 8804 * 8805 * <pre> 8806 * The URL of the target resource to receive the matched traffic. For regional forwarding rules, this target must be in the same region as the forwarding rule. For global forwarding rules, this target must be a global load balancing resource. The forwarded traffic must be of a type appropriate to the target object. - For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications). - For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle: - vpc-sc - APIs that support VPC Service Controls. - all-apis - All supported Google APIs. - For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment. 8807 * </pre> 8808 * 8809 * <code>optional string target = 192835985;</code> 8810 * 8811 * @param value The bytes for target to set. 8812 * @return This builder for chaining. 8813 */ setTargetBytes(com.google.protobuf.ByteString value)8814 public Builder setTargetBytes(com.google.protobuf.ByteString value) { 8815 if (value == null) { 8816 throw new NullPointerException(); 8817 } 8818 checkByteStringIsUtf8(value); 8819 target_ = value; 8820 bitField1_ |= 0x00000001; 8821 onChanged(); 8822 return this; 8823 } 8824 8825 @java.lang.Override setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields)8826 public final Builder setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields) { 8827 return super.setUnknownFields(unknownFields); 8828 } 8829 8830 @java.lang.Override mergeUnknownFields( final com.google.protobuf.UnknownFieldSet unknownFields)8831 public final Builder mergeUnknownFields( 8832 final com.google.protobuf.UnknownFieldSet unknownFields) { 8833 return super.mergeUnknownFields(unknownFields); 8834 } 8835 8836 // @@protoc_insertion_point(builder_scope:google.cloud.compute.v1.ForwardingRule) 8837 } 8838 8839 // @@protoc_insertion_point(class_scope:google.cloud.compute.v1.ForwardingRule) 8840 private static final com.google.cloud.compute.v1.ForwardingRule DEFAULT_INSTANCE; 8841 8842 static { 8843 DEFAULT_INSTANCE = new com.google.cloud.compute.v1.ForwardingRule(); 8844 } 8845 getDefaultInstance()8846 public static com.google.cloud.compute.v1.ForwardingRule getDefaultInstance() { 8847 return DEFAULT_INSTANCE; 8848 } 8849 8850 private static final com.google.protobuf.Parser<ForwardingRule> PARSER = 8851 new com.google.protobuf.AbstractParser<ForwardingRule>() { 8852 @java.lang.Override 8853 public ForwardingRule parsePartialFrom( 8854 com.google.protobuf.CodedInputStream input, 8855 com.google.protobuf.ExtensionRegistryLite extensionRegistry) 8856 throws com.google.protobuf.InvalidProtocolBufferException { 8857 Builder builder = newBuilder(); 8858 try { 8859 builder.mergeFrom(input, extensionRegistry); 8860 } catch (com.google.protobuf.InvalidProtocolBufferException e) { 8861 throw e.setUnfinishedMessage(builder.buildPartial()); 8862 } catch (com.google.protobuf.UninitializedMessageException e) { 8863 throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); 8864 } catch (java.io.IOException e) { 8865 throw new com.google.protobuf.InvalidProtocolBufferException(e) 8866 .setUnfinishedMessage(builder.buildPartial()); 8867 } 8868 return builder.buildPartial(); 8869 } 8870 }; 8871 parser()8872 public static com.google.protobuf.Parser<ForwardingRule> parser() { 8873 return PARSER; 8874 } 8875 8876 @java.lang.Override getParserForType()8877 public com.google.protobuf.Parser<ForwardingRule> getParserForType() { 8878 return PARSER; 8879 } 8880 8881 @java.lang.Override getDefaultInstanceForType()8882 public com.google.cloud.compute.v1.ForwardingRule getDefaultInstanceForType() { 8883 return DEFAULT_INSTANCE; 8884 } 8885 } 8886