• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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&lt;string, string&gt; 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&lt;string, string&gt; 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&lt;string, string&gt; 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&lt;string, string&gt; 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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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&lt;string, string&gt; 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&lt;string, string&gt; 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&lt;string, string&gt; 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&lt;string, string&gt; 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&lt;string, string&gt; 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&lt;string, string&gt; 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&lt;string, string&gt; 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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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. &#64;pattern: &#92;&#92;d+(?:-&#92;&#92;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