• 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 Backend Service resource. A backend service defines how Google Cloud load balancers distribute traffic. The backend service configuration contains a set of values, such as the protocol used to connect to backends, various distribution and session settings, health checks, and timeouts. These settings provide fine-grained control over how your load balancer behaves. Most of the settings have default values that allow for easy configuration if you need to get started quickly. Backend services in Google Compute Engine can be either regionally or globally scoped. * [Global](https://cloud.google.com/compute/docs/reference/rest/v1/backendServices) * [Regional](https://cloud.google.com/compute/docs/reference/rest/v1/regionBackendServices) For more information, see Backend Services.
26  * </pre>
27  *
28  * Protobuf type {@code google.cloud.compute.v1.BackendService}
29  */
30 public final class BackendService extends com.google.protobuf.GeneratedMessageV3
31     implements
32     // @@protoc_insertion_point(message_implements:google.cloud.compute.v1.BackendService)
33     BackendServiceOrBuilder {
34   private static final long serialVersionUID = 0L;
35   // Use BackendService.newBuilder() to construct.
BackendService(com.google.protobuf.GeneratedMessageV3.Builder<?> builder)36   private BackendService(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
37     super(builder);
38   }
39 
BackendService()40   private BackendService() {
41     backends_ = java.util.Collections.emptyList();
42     compressionMode_ = "";
43     creationTimestamp_ = "";
44     customRequestHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY;
45     customResponseHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY;
46     description_ = "";
47     edgeSecurityPolicy_ = "";
48     fingerprint_ = "";
49     healthChecks_ = com.google.protobuf.LazyStringArrayList.EMPTY;
50     kind_ = "";
51     loadBalancingScheme_ = "";
52     localityLbPolicies_ = java.util.Collections.emptyList();
53     localityLbPolicy_ = "";
54     name_ = "";
55     network_ = "";
56     portName_ = "";
57     protocol_ = "";
58     region_ = "";
59     securityPolicy_ = "";
60     selfLink_ = "";
61     serviceBindings_ = com.google.protobuf.LazyStringArrayList.EMPTY;
62     sessionAffinity_ = "";
63   }
64 
65   @java.lang.Override
66   @SuppressWarnings({"unused"})
newInstance(UnusedPrivateParameter unused)67   protected java.lang.Object newInstance(UnusedPrivateParameter unused) {
68     return new BackendService();
69   }
70 
71   @java.lang.Override
getUnknownFields()72   public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
73     return this.unknownFields;
74   }
75 
getDescriptor()76   public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
77     return com.google.cloud.compute.v1.Compute
78         .internal_static_google_cloud_compute_v1_BackendService_descriptor;
79   }
80 
81   @java.lang.Override
82   protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable()83       internalGetFieldAccessorTable() {
84     return com.google.cloud.compute.v1.Compute
85         .internal_static_google_cloud_compute_v1_BackendService_fieldAccessorTable
86         .ensureFieldAccessorsInitialized(
87             com.google.cloud.compute.v1.BackendService.class,
88             com.google.cloud.compute.v1.BackendService.Builder.class);
89   }
90 
91   /**
92    *
93    *
94    * <pre>
95    * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
96    * </pre>
97    *
98    * Protobuf enum {@code google.cloud.compute.v1.BackendService.CompressionMode}
99    */
100   public enum CompressionMode implements com.google.protobuf.ProtocolMessageEnum {
101     /**
102      *
103      *
104      * <pre>
105      * A value indicating that the enum field is not set.
106      * </pre>
107      *
108      * <code>UNDEFINED_COMPRESSION_MODE = 0;</code>
109      */
110     UNDEFINED_COMPRESSION_MODE(0),
111     /**
112      *
113      *
114      * <pre>
115      * Automatically uses the best compression based on the Accept-Encoding header sent by the client.
116      * </pre>
117      *
118      * <code>AUTOMATIC = 165298699;</code>
119      */
120     AUTOMATIC(165298699),
121     /**
122      *
123      *
124      * <pre>
125      * Disables compression. Existing compressed responses cached by Cloud CDN will not be served to clients.
126      * </pre>
127      *
128      * <code>DISABLED = 516696700;</code>
129      */
130     DISABLED(516696700),
131     UNRECOGNIZED(-1),
132     ;
133 
134     /**
135      *
136      *
137      * <pre>
138      * A value indicating that the enum field is not set.
139      * </pre>
140      *
141      * <code>UNDEFINED_COMPRESSION_MODE = 0;</code>
142      */
143     public static final int UNDEFINED_COMPRESSION_MODE_VALUE = 0;
144     /**
145      *
146      *
147      * <pre>
148      * Automatically uses the best compression based on the Accept-Encoding header sent by the client.
149      * </pre>
150      *
151      * <code>AUTOMATIC = 165298699;</code>
152      */
153     public static final int AUTOMATIC_VALUE = 165298699;
154     /**
155      *
156      *
157      * <pre>
158      * Disables compression. Existing compressed responses cached by Cloud CDN will not be served to clients.
159      * </pre>
160      *
161      * <code>DISABLED = 516696700;</code>
162      */
163     public static final int DISABLED_VALUE = 516696700;
164 
getNumber()165     public final int getNumber() {
166       if (this == UNRECOGNIZED) {
167         throw new java.lang.IllegalArgumentException(
168             "Can't get the number of an unknown enum value.");
169       }
170       return value;
171     }
172 
173     /**
174      * @param value The numeric wire value of the corresponding enum entry.
175      * @return The enum associated with the given numeric wire value.
176      * @deprecated Use {@link #forNumber(int)} instead.
177      */
178     @java.lang.Deprecated
valueOf(int value)179     public static CompressionMode valueOf(int value) {
180       return forNumber(value);
181     }
182 
183     /**
184      * @param value The numeric wire value of the corresponding enum entry.
185      * @return The enum associated with the given numeric wire value.
186      */
forNumber(int value)187     public static CompressionMode forNumber(int value) {
188       switch (value) {
189         case 0:
190           return UNDEFINED_COMPRESSION_MODE;
191         case 165298699:
192           return AUTOMATIC;
193         case 516696700:
194           return DISABLED;
195         default:
196           return null;
197       }
198     }
199 
internalGetValueMap()200     public static com.google.protobuf.Internal.EnumLiteMap<CompressionMode> internalGetValueMap() {
201       return internalValueMap;
202     }
203 
204     private static final com.google.protobuf.Internal.EnumLiteMap<CompressionMode>
205         internalValueMap =
206             new com.google.protobuf.Internal.EnumLiteMap<CompressionMode>() {
207               public CompressionMode findValueByNumber(int number) {
208                 return CompressionMode.forNumber(number);
209               }
210             };
211 
getValueDescriptor()212     public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() {
213       if (this == UNRECOGNIZED) {
214         throw new java.lang.IllegalStateException(
215             "Can't get the descriptor of an unrecognized enum value.");
216       }
217       return getDescriptor().getValues().get(ordinal());
218     }
219 
getDescriptorForType()220     public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() {
221       return getDescriptor();
222     }
223 
getDescriptor()224     public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() {
225       return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(0);
226     }
227 
228     private static final CompressionMode[] VALUES = values();
229 
valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)230     public static CompressionMode valueOf(
231         com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
232       if (desc.getType() != getDescriptor()) {
233         throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type.");
234       }
235       if (desc.getIndex() == -1) {
236         return UNRECOGNIZED;
237       }
238       return VALUES[desc.getIndex()];
239     }
240 
241     private final int value;
242 
CompressionMode(int value)243     private CompressionMode(int value) {
244       this.value = value;
245     }
246 
247     // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.CompressionMode)
248   }
249 
250   /**
251    *
252    *
253    * <pre>
254    * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
255    * </pre>
256    *
257    * Protobuf enum {@code google.cloud.compute.v1.BackendService.LoadBalancingScheme}
258    */
259   public enum LoadBalancingScheme implements com.google.protobuf.ProtocolMessageEnum {
260     /**
261      *
262      *
263      * <pre>
264      * A value indicating that the enum field is not set.
265      * </pre>
266      *
267      * <code>UNDEFINED_LOAD_BALANCING_SCHEME = 0;</code>
268      */
269     UNDEFINED_LOAD_BALANCING_SCHEME(0),
270     /**
271      *
272      *
273      * <pre>
274      * Signifies that this will be used for external HTTP(S), SSL Proxy, TCP Proxy, or Network Load Balancing
275      * </pre>
276      *
277      * <code>EXTERNAL = 35607499;</code>
278      */
279     EXTERNAL(35607499),
280     /**
281      *
282      *
283      * <pre>
284      * Signifies that this will be used for External Managed HTTP(S) Load Balancing.
285      * </pre>
286      *
287      * <code>EXTERNAL_MANAGED = 512006923;</code>
288      */
289     EXTERNAL_MANAGED(512006923),
290     /**
291      *
292      *
293      * <pre>
294      * Signifies that this will be used for Internal TCP/UDP Load Balancing.
295      * </pre>
296      *
297      * <code>INTERNAL = 279295677;</code>
298      */
299     INTERNAL(279295677),
300     /**
301      *
302      *
303      * <pre>
304      * Signifies that this will be used for Internal HTTP(S) Load Balancing.
305      * </pre>
306      *
307      * <code>INTERNAL_MANAGED = 37350397;</code>
308      */
309     INTERNAL_MANAGED(37350397),
310     /**
311      *
312      *
313      * <pre>
314      * Signifies that this will be used by Traffic Director.
315      * </pre>
316      *
317      * <code>INTERNAL_SELF_MANAGED = 236211150;</code>
318      */
319     INTERNAL_SELF_MANAGED(236211150),
320     /** <code>INVALID_LOAD_BALANCING_SCHEME = 275352060;</code> */
321     INVALID_LOAD_BALANCING_SCHEME(275352060),
322     UNRECOGNIZED(-1),
323     ;
324 
325     /**
326      *
327      *
328      * <pre>
329      * A value indicating that the enum field is not set.
330      * </pre>
331      *
332      * <code>UNDEFINED_LOAD_BALANCING_SCHEME = 0;</code>
333      */
334     public static final int UNDEFINED_LOAD_BALANCING_SCHEME_VALUE = 0;
335     /**
336      *
337      *
338      * <pre>
339      * Signifies that this will be used for external HTTP(S), SSL Proxy, TCP Proxy, or Network Load Balancing
340      * </pre>
341      *
342      * <code>EXTERNAL = 35607499;</code>
343      */
344     public static final int EXTERNAL_VALUE = 35607499;
345     /**
346      *
347      *
348      * <pre>
349      * Signifies that this will be used for External Managed HTTP(S) Load Balancing.
350      * </pre>
351      *
352      * <code>EXTERNAL_MANAGED = 512006923;</code>
353      */
354     public static final int EXTERNAL_MANAGED_VALUE = 512006923;
355     /**
356      *
357      *
358      * <pre>
359      * Signifies that this will be used for Internal TCP/UDP Load Balancing.
360      * </pre>
361      *
362      * <code>INTERNAL = 279295677;</code>
363      */
364     public static final int INTERNAL_VALUE = 279295677;
365     /**
366      *
367      *
368      * <pre>
369      * Signifies that this will be used for Internal HTTP(S) Load Balancing.
370      * </pre>
371      *
372      * <code>INTERNAL_MANAGED = 37350397;</code>
373      */
374     public static final int INTERNAL_MANAGED_VALUE = 37350397;
375     /**
376      *
377      *
378      * <pre>
379      * Signifies that this will be used by Traffic Director.
380      * </pre>
381      *
382      * <code>INTERNAL_SELF_MANAGED = 236211150;</code>
383      */
384     public static final int INTERNAL_SELF_MANAGED_VALUE = 236211150;
385     /** <code>INVALID_LOAD_BALANCING_SCHEME = 275352060;</code> */
386     public static final int INVALID_LOAD_BALANCING_SCHEME_VALUE = 275352060;
387 
getNumber()388     public final int getNumber() {
389       if (this == UNRECOGNIZED) {
390         throw new java.lang.IllegalArgumentException(
391             "Can't get the number of an unknown enum value.");
392       }
393       return value;
394     }
395 
396     /**
397      * @param value The numeric wire value of the corresponding enum entry.
398      * @return The enum associated with the given numeric wire value.
399      * @deprecated Use {@link #forNumber(int)} instead.
400      */
401     @java.lang.Deprecated
valueOf(int value)402     public static LoadBalancingScheme valueOf(int value) {
403       return forNumber(value);
404     }
405 
406     /**
407      * @param value The numeric wire value of the corresponding enum entry.
408      * @return The enum associated with the given numeric wire value.
409      */
forNumber(int value)410     public static LoadBalancingScheme forNumber(int value) {
411       switch (value) {
412         case 0:
413           return UNDEFINED_LOAD_BALANCING_SCHEME;
414         case 35607499:
415           return EXTERNAL;
416         case 512006923:
417           return EXTERNAL_MANAGED;
418         case 279295677:
419           return INTERNAL;
420         case 37350397:
421           return INTERNAL_MANAGED;
422         case 236211150:
423           return INTERNAL_SELF_MANAGED;
424         case 275352060:
425           return INVALID_LOAD_BALANCING_SCHEME;
426         default:
427           return null;
428       }
429     }
430 
431     public static com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme>
internalGetValueMap()432         internalGetValueMap() {
433       return internalValueMap;
434     }
435 
436     private static final com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme>
437         internalValueMap =
438             new com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme>() {
439               public LoadBalancingScheme findValueByNumber(int number) {
440                 return LoadBalancingScheme.forNumber(number);
441               }
442             };
443 
getValueDescriptor()444     public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() {
445       if (this == UNRECOGNIZED) {
446         throw new java.lang.IllegalStateException(
447             "Can't get the descriptor of an unrecognized enum value.");
448       }
449       return getDescriptor().getValues().get(ordinal());
450     }
451 
getDescriptorForType()452     public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() {
453       return getDescriptor();
454     }
455 
getDescriptor()456     public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() {
457       return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(1);
458     }
459 
460     private static final LoadBalancingScheme[] VALUES = values();
461 
valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)462     public static LoadBalancingScheme valueOf(
463         com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
464       if (desc.getType() != getDescriptor()) {
465         throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type.");
466       }
467       if (desc.getIndex() == -1) {
468         return UNRECOGNIZED;
469       }
470       return VALUES[desc.getIndex()];
471     }
472 
473     private final int value;
474 
LoadBalancingScheme(int value)475     private LoadBalancingScheme(int value) {
476       this.value = value;
477     }
478 
479     // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.LoadBalancingScheme)
480   }
481 
482   /**
483    *
484    *
485    * <pre>
486    * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
487    * </pre>
488    *
489    * Protobuf enum {@code google.cloud.compute.v1.BackendService.LocalityLbPolicy}
490    */
491   public enum LocalityLbPolicy implements com.google.protobuf.ProtocolMessageEnum {
492     /**
493      *
494      *
495      * <pre>
496      * A value indicating that the enum field is not set.
497      * </pre>
498      *
499      * <code>UNDEFINED_LOCALITY_LB_POLICY = 0;</code>
500      */
501     UNDEFINED_LOCALITY_LB_POLICY(0),
502     /** <code>INVALID_LB_POLICY = 323318707;</code> */
503     INVALID_LB_POLICY(323318707),
504     /**
505      *
506      *
507      * <pre>
508      * An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests.
509      * </pre>
510      *
511      * <code>LEAST_REQUEST = 46604921;</code>
512      */
513     LEAST_REQUEST(46604921),
514     /**
515      *
516      *
517      * <pre>
518      * This algorithm implements consistent hashing to backends. Maglev can be used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824
519      * </pre>
520      *
521      * <code>MAGLEV = 119180266;</code>
522      */
523     MAGLEV(119180266),
524     /**
525      *
526      *
527      * <pre>
528      * Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer.
529      * </pre>
530      *
531      * <code>ORIGINAL_DESTINATION = 166297216;</code>
532      */
533     ORIGINAL_DESTINATION(166297216),
534     /**
535      *
536      *
537      * <pre>
538      * The load balancer selects a random healthy host.
539      * </pre>
540      *
541      * <code>RANDOM = 262527171;</code>
542      */
543     RANDOM(262527171),
544     /**
545      *
546      *
547      * <pre>
548      * The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests.
549      * </pre>
550      *
551      * <code>RING_HASH = 432795069;</code>
552      */
553     RING_HASH(432795069),
554     /**
555      *
556      *
557      * <pre>
558      * This is a simple policy in which each healthy backend is selected in round robin order. This is the default.
559      * </pre>
560      *
561      * <code>ROUND_ROBIN = 153895801;</code>
562      */
563     ROUND_ROBIN(153895801),
564     /**
565      *
566      *
567      * <pre>
568      * Per-instance weighted Load Balancing via health check reported weights. If set, the Backend Service must configure a non legacy HTTP-based Health Check, and health check replies are expected to contain non-standard HTTP response header field X-Load-Balancing-Endpoint-Weight to specify the per-instance weights. If set, Load Balancing is weighted based on the per-instance weights reported in the last processed health check replies, as long as every instance either reported a valid weight or had UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains equal-weight. This option is only supported in Network Load Balancing.
569      * </pre>
570      *
571      * <code>WEIGHTED_MAGLEV = 254930962;</code>
572      */
573     WEIGHTED_MAGLEV(254930962),
574     UNRECOGNIZED(-1),
575     ;
576 
577     /**
578      *
579      *
580      * <pre>
581      * A value indicating that the enum field is not set.
582      * </pre>
583      *
584      * <code>UNDEFINED_LOCALITY_LB_POLICY = 0;</code>
585      */
586     public static final int UNDEFINED_LOCALITY_LB_POLICY_VALUE = 0;
587     /** <code>INVALID_LB_POLICY = 323318707;</code> */
588     public static final int INVALID_LB_POLICY_VALUE = 323318707;
589     /**
590      *
591      *
592      * <pre>
593      * An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests.
594      * </pre>
595      *
596      * <code>LEAST_REQUEST = 46604921;</code>
597      */
598     public static final int LEAST_REQUEST_VALUE = 46604921;
599     /**
600      *
601      *
602      * <pre>
603      * This algorithm implements consistent hashing to backends. Maglev can be used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824
604      * </pre>
605      *
606      * <code>MAGLEV = 119180266;</code>
607      */
608     public static final int MAGLEV_VALUE = 119180266;
609     /**
610      *
611      *
612      * <pre>
613      * Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer.
614      * </pre>
615      *
616      * <code>ORIGINAL_DESTINATION = 166297216;</code>
617      */
618     public static final int ORIGINAL_DESTINATION_VALUE = 166297216;
619     /**
620      *
621      *
622      * <pre>
623      * The load balancer selects a random healthy host.
624      * </pre>
625      *
626      * <code>RANDOM = 262527171;</code>
627      */
628     public static final int RANDOM_VALUE = 262527171;
629     /**
630      *
631      *
632      * <pre>
633      * The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests.
634      * </pre>
635      *
636      * <code>RING_HASH = 432795069;</code>
637      */
638     public static final int RING_HASH_VALUE = 432795069;
639     /**
640      *
641      *
642      * <pre>
643      * This is a simple policy in which each healthy backend is selected in round robin order. This is the default.
644      * </pre>
645      *
646      * <code>ROUND_ROBIN = 153895801;</code>
647      */
648     public static final int ROUND_ROBIN_VALUE = 153895801;
649     /**
650      *
651      *
652      * <pre>
653      * Per-instance weighted Load Balancing via health check reported weights. If set, the Backend Service must configure a non legacy HTTP-based Health Check, and health check replies are expected to contain non-standard HTTP response header field X-Load-Balancing-Endpoint-Weight to specify the per-instance weights. If set, Load Balancing is weighted based on the per-instance weights reported in the last processed health check replies, as long as every instance either reported a valid weight or had UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains equal-weight. This option is only supported in Network Load Balancing.
654      * </pre>
655      *
656      * <code>WEIGHTED_MAGLEV = 254930962;</code>
657      */
658     public static final int WEIGHTED_MAGLEV_VALUE = 254930962;
659 
getNumber()660     public final int getNumber() {
661       if (this == UNRECOGNIZED) {
662         throw new java.lang.IllegalArgumentException(
663             "Can't get the number of an unknown enum value.");
664       }
665       return value;
666     }
667 
668     /**
669      * @param value The numeric wire value of the corresponding enum entry.
670      * @return The enum associated with the given numeric wire value.
671      * @deprecated Use {@link #forNumber(int)} instead.
672      */
673     @java.lang.Deprecated
valueOf(int value)674     public static LocalityLbPolicy valueOf(int value) {
675       return forNumber(value);
676     }
677 
678     /**
679      * @param value The numeric wire value of the corresponding enum entry.
680      * @return The enum associated with the given numeric wire value.
681      */
forNumber(int value)682     public static LocalityLbPolicy forNumber(int value) {
683       switch (value) {
684         case 0:
685           return UNDEFINED_LOCALITY_LB_POLICY;
686         case 323318707:
687           return INVALID_LB_POLICY;
688         case 46604921:
689           return LEAST_REQUEST;
690         case 119180266:
691           return MAGLEV;
692         case 166297216:
693           return ORIGINAL_DESTINATION;
694         case 262527171:
695           return RANDOM;
696         case 432795069:
697           return RING_HASH;
698         case 153895801:
699           return ROUND_ROBIN;
700         case 254930962:
701           return WEIGHTED_MAGLEV;
702         default:
703           return null;
704       }
705     }
706 
internalGetValueMap()707     public static com.google.protobuf.Internal.EnumLiteMap<LocalityLbPolicy> internalGetValueMap() {
708       return internalValueMap;
709     }
710 
711     private static final com.google.protobuf.Internal.EnumLiteMap<LocalityLbPolicy>
712         internalValueMap =
713             new com.google.protobuf.Internal.EnumLiteMap<LocalityLbPolicy>() {
714               public LocalityLbPolicy findValueByNumber(int number) {
715                 return LocalityLbPolicy.forNumber(number);
716               }
717             };
718 
getValueDescriptor()719     public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() {
720       if (this == UNRECOGNIZED) {
721         throw new java.lang.IllegalStateException(
722             "Can't get the descriptor of an unrecognized enum value.");
723       }
724       return getDescriptor().getValues().get(ordinal());
725     }
726 
getDescriptorForType()727     public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() {
728       return getDescriptor();
729     }
730 
getDescriptor()731     public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() {
732       return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(2);
733     }
734 
735     private static final LocalityLbPolicy[] VALUES = values();
736 
valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)737     public static LocalityLbPolicy valueOf(
738         com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
739       if (desc.getType() != getDescriptor()) {
740         throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type.");
741       }
742       if (desc.getIndex() == -1) {
743         return UNRECOGNIZED;
744       }
745       return VALUES[desc.getIndex()];
746     }
747 
748     private final int value;
749 
LocalityLbPolicy(int value)750     private LocalityLbPolicy(int value) {
751       this.value = value;
752     }
753 
754     // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.LocalityLbPolicy)
755   }
756 
757   /**
758    *
759    *
760    * <pre>
761    * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
762    * </pre>
763    *
764    * Protobuf enum {@code google.cloud.compute.v1.BackendService.Protocol}
765    */
766   public enum Protocol implements com.google.protobuf.ProtocolMessageEnum {
767     /**
768      *
769      *
770      * <pre>
771      * A value indicating that the enum field is not set.
772      * </pre>
773      *
774      * <code>UNDEFINED_PROTOCOL = 0;</code>
775      */
776     UNDEFINED_PROTOCOL(0),
777     /**
778      *
779      *
780      * <pre>
781      * gRPC (available for Traffic Director).
782      * </pre>
783      *
784      * <code>GRPC = 2196510;</code>
785      */
786     GRPC(2196510),
787     /** <code>HTTP = 2228360;</code> */
788     HTTP(2228360),
789     /**
790      *
791      *
792      * <pre>
793      * HTTP/2 with SSL.
794      * </pre>
795      *
796      * <code>HTTP2 = 69079210;</code>
797      */
798     HTTP2(69079210),
799     /** <code>HTTPS = 69079243;</code> */
800     HTTPS(69079243),
801     /**
802      *
803      *
804      * <pre>
805      * TCP proxying with SSL.
806      * </pre>
807      *
808      * <code>SSL = 82412;</code>
809      */
810     SSL(82412),
811     /**
812      *
813      *
814      * <pre>
815      * TCP proxying or TCP pass-through.
816      * </pre>
817      *
818      * <code>TCP = 82881;</code>
819      */
820     TCP(82881),
821     /**
822      *
823      *
824      * <pre>
825      * UDP.
826      * </pre>
827      *
828      * <code>UDP = 83873;</code>
829      */
830     UDP(83873),
831     /**
832      *
833      *
834      * <pre>
835      * If a Backend Service has UNSPECIFIED as its protocol, it can be used with any L3/L4 Forwarding Rules.
836      * </pre>
837      *
838      * <code>UNSPECIFIED = 526786327;</code>
839      */
840     UNSPECIFIED(526786327),
841     UNRECOGNIZED(-1),
842     ;
843 
844     /**
845      *
846      *
847      * <pre>
848      * A value indicating that the enum field is not set.
849      * </pre>
850      *
851      * <code>UNDEFINED_PROTOCOL = 0;</code>
852      */
853     public static final int UNDEFINED_PROTOCOL_VALUE = 0;
854     /**
855      *
856      *
857      * <pre>
858      * gRPC (available for Traffic Director).
859      * </pre>
860      *
861      * <code>GRPC = 2196510;</code>
862      */
863     public static final int GRPC_VALUE = 2196510;
864     /** <code>HTTP = 2228360;</code> */
865     public static final int HTTP_VALUE = 2228360;
866     /**
867      *
868      *
869      * <pre>
870      * HTTP/2 with SSL.
871      * </pre>
872      *
873      * <code>HTTP2 = 69079210;</code>
874      */
875     public static final int HTTP2_VALUE = 69079210;
876     /** <code>HTTPS = 69079243;</code> */
877     public static final int HTTPS_VALUE = 69079243;
878     /**
879      *
880      *
881      * <pre>
882      * TCP proxying with SSL.
883      * </pre>
884      *
885      * <code>SSL = 82412;</code>
886      */
887     public static final int SSL_VALUE = 82412;
888     /**
889      *
890      *
891      * <pre>
892      * TCP proxying or TCP pass-through.
893      * </pre>
894      *
895      * <code>TCP = 82881;</code>
896      */
897     public static final int TCP_VALUE = 82881;
898     /**
899      *
900      *
901      * <pre>
902      * UDP.
903      * </pre>
904      *
905      * <code>UDP = 83873;</code>
906      */
907     public static final int UDP_VALUE = 83873;
908     /**
909      *
910      *
911      * <pre>
912      * If a Backend Service has UNSPECIFIED as its protocol, it can be used with any L3/L4 Forwarding Rules.
913      * </pre>
914      *
915      * <code>UNSPECIFIED = 526786327;</code>
916      */
917     public static final int UNSPECIFIED_VALUE = 526786327;
918 
getNumber()919     public final int getNumber() {
920       if (this == UNRECOGNIZED) {
921         throw new java.lang.IllegalArgumentException(
922             "Can't get the number of an unknown enum value.");
923       }
924       return value;
925     }
926 
927     /**
928      * @param value The numeric wire value of the corresponding enum entry.
929      * @return The enum associated with the given numeric wire value.
930      * @deprecated Use {@link #forNumber(int)} instead.
931      */
932     @java.lang.Deprecated
valueOf(int value)933     public static Protocol valueOf(int value) {
934       return forNumber(value);
935     }
936 
937     /**
938      * @param value The numeric wire value of the corresponding enum entry.
939      * @return The enum associated with the given numeric wire value.
940      */
forNumber(int value)941     public static Protocol forNumber(int value) {
942       switch (value) {
943         case 0:
944           return UNDEFINED_PROTOCOL;
945         case 2196510:
946           return GRPC;
947         case 2228360:
948           return HTTP;
949         case 69079210:
950           return HTTP2;
951         case 69079243:
952           return HTTPS;
953         case 82412:
954           return SSL;
955         case 82881:
956           return TCP;
957         case 83873:
958           return UDP;
959         case 526786327:
960           return UNSPECIFIED;
961         default:
962           return null;
963       }
964     }
965 
internalGetValueMap()966     public static com.google.protobuf.Internal.EnumLiteMap<Protocol> internalGetValueMap() {
967       return internalValueMap;
968     }
969 
970     private static final com.google.protobuf.Internal.EnumLiteMap<Protocol> internalValueMap =
971         new com.google.protobuf.Internal.EnumLiteMap<Protocol>() {
972           public Protocol findValueByNumber(int number) {
973             return Protocol.forNumber(number);
974           }
975         };
976 
getValueDescriptor()977     public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() {
978       if (this == UNRECOGNIZED) {
979         throw new java.lang.IllegalStateException(
980             "Can't get the descriptor of an unrecognized enum value.");
981       }
982       return getDescriptor().getValues().get(ordinal());
983     }
984 
getDescriptorForType()985     public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() {
986       return getDescriptor();
987     }
988 
getDescriptor()989     public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() {
990       return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(3);
991     }
992 
993     private static final Protocol[] VALUES = values();
994 
valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc)995     public static Protocol valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
996       if (desc.getType() != getDescriptor()) {
997         throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type.");
998       }
999       if (desc.getIndex() == -1) {
1000         return UNRECOGNIZED;
1001       }
1002       return VALUES[desc.getIndex()];
1003     }
1004 
1005     private final int value;
1006 
Protocol(int value)1007     private Protocol(int value) {
1008       this.value = value;
1009     }
1010 
1011     // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.Protocol)
1012   }
1013 
1014   /**
1015    *
1016    *
1017    * <pre>
1018    * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
1019    * </pre>
1020    *
1021    * Protobuf enum {@code google.cloud.compute.v1.BackendService.SessionAffinity}
1022    */
1023   public enum SessionAffinity implements com.google.protobuf.ProtocolMessageEnum {
1024     /**
1025      *
1026      *
1027      * <pre>
1028      * A value indicating that the enum field is not set.
1029      * </pre>
1030      *
1031      * <code>UNDEFINED_SESSION_AFFINITY = 0;</code>
1032      */
1033     UNDEFINED_SESSION_AFFINITY(0),
1034     /**
1035      *
1036      *
1037      * <pre>
1038      * 2-tuple hash on packet's source and destination IP addresses. Connections from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy.
1039      * </pre>
1040      *
1041      * <code>CLIENT_IP = 345665051;</code>
1042      */
1043     CLIENT_IP(345665051),
1044     /**
1045      *
1046      *
1047      * <pre>
1048      * 1-tuple hash only on packet's source IP address. Connections from the same source IP address will be served by the same backend VM while that VM remains healthy. This option can only be used for Internal TCP/UDP Load Balancing.
1049      * </pre>
1050      *
1051      * <code>CLIENT_IP_NO_DESTINATION = 106122516;</code>
1052      */
1053     CLIENT_IP_NO_DESTINATION(106122516),
1054     /**
1055      *
1056      *
1057      * <pre>
1058      * 5-tuple hash on packet's source and destination IP addresses, IP protocol, and source and destination ports. Connections for the same IP protocol from the same source IP address and port to the same destination IP address and port will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing.
1059      * </pre>
1060      *
1061      * <code>CLIENT_IP_PORT_PROTO = 221722926;</code>
1062      */
1063     CLIENT_IP_PORT_PROTO(221722926),
1064     /**
1065      *
1066      *
1067      * <pre>
1068      * 3-tuple hash on packet's source and destination IP addresses, and IP protocol. Connections for the same IP protocol from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing.
1069      * </pre>
1070      *
1071      * <code>CLIENT_IP_PROTO = 25322148;</code>
1072      */
1073     CLIENT_IP_PROTO(25322148),
1074     /**
1075      *
1076      *
1077      * <pre>
1078      * Hash based on a cookie generated by the L7 loadbalancer. Only valid for HTTP(S) load balancing.
1079      * </pre>
1080      *
1081      * <code>GENERATED_COOKIE = 370321204;</code>
1082      */
1083     GENERATED_COOKIE(370321204),
1084     /**
1085      *
1086      *
1087      * <pre>
1088      * The hash is based on a user specified header field.
1089      * </pre>
1090      *
1091      * <code>HEADER_FIELD = 200737960;</code>
1092      */
1093     HEADER_FIELD(200737960),
1094     /**
1095      *
1096      *
1097      * <pre>
1098      * The hash is based on a user provided cookie.
1099      * </pre>
1100      *
1101      * <code>HTTP_COOKIE = 494981627;</code>
1102      */
1103     HTTP_COOKIE(494981627),
1104     /**
1105      *
1106      *
1107      * <pre>
1108      * No session affinity. Connections from the same client IP may go to any instance in the pool.
1109      * </pre>
1110      *
1111      * <code>NONE = 2402104;</code>
1112      */
1113     NONE(2402104),
1114     UNRECOGNIZED(-1),
1115     ;
1116 
1117     /**
1118      *
1119      *
1120      * <pre>
1121      * A value indicating that the enum field is not set.
1122      * </pre>
1123      *
1124      * <code>UNDEFINED_SESSION_AFFINITY = 0;</code>
1125      */
1126     public static final int UNDEFINED_SESSION_AFFINITY_VALUE = 0;
1127     /**
1128      *
1129      *
1130      * <pre>
1131      * 2-tuple hash on packet's source and destination IP addresses. Connections from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy.
1132      * </pre>
1133      *
1134      * <code>CLIENT_IP = 345665051;</code>
1135      */
1136     public static final int CLIENT_IP_VALUE = 345665051;
1137     /**
1138      *
1139      *
1140      * <pre>
1141      * 1-tuple hash only on packet's source IP address. Connections from the same source IP address will be served by the same backend VM while that VM remains healthy. This option can only be used for Internal TCP/UDP Load Balancing.
1142      * </pre>
1143      *
1144      * <code>CLIENT_IP_NO_DESTINATION = 106122516;</code>
1145      */
1146     public static final int CLIENT_IP_NO_DESTINATION_VALUE = 106122516;
1147     /**
1148      *
1149      *
1150      * <pre>
1151      * 5-tuple hash on packet's source and destination IP addresses, IP protocol, and source and destination ports. Connections for the same IP protocol from the same source IP address and port to the same destination IP address and port will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing.
1152      * </pre>
1153      *
1154      * <code>CLIENT_IP_PORT_PROTO = 221722926;</code>
1155      */
1156     public static final int CLIENT_IP_PORT_PROTO_VALUE = 221722926;
1157     /**
1158      *
1159      *
1160      * <pre>
1161      * 3-tuple hash on packet's source and destination IP addresses, and IP protocol. Connections for the same IP protocol from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing.
1162      * </pre>
1163      *
1164      * <code>CLIENT_IP_PROTO = 25322148;</code>
1165      */
1166     public static final int CLIENT_IP_PROTO_VALUE = 25322148;
1167     /**
1168      *
1169      *
1170      * <pre>
1171      * Hash based on a cookie generated by the L7 loadbalancer. Only valid for HTTP(S) load balancing.
1172      * </pre>
1173      *
1174      * <code>GENERATED_COOKIE = 370321204;</code>
1175      */
1176     public static final int GENERATED_COOKIE_VALUE = 370321204;
1177     /**
1178      *
1179      *
1180      * <pre>
1181      * The hash is based on a user specified header field.
1182      * </pre>
1183      *
1184      * <code>HEADER_FIELD = 200737960;</code>
1185      */
1186     public static final int HEADER_FIELD_VALUE = 200737960;
1187     /**
1188      *
1189      *
1190      * <pre>
1191      * The hash is based on a user provided cookie.
1192      * </pre>
1193      *
1194      * <code>HTTP_COOKIE = 494981627;</code>
1195      */
1196     public static final int HTTP_COOKIE_VALUE = 494981627;
1197     /**
1198      *
1199      *
1200      * <pre>
1201      * No session affinity. Connections from the same client IP may go to any instance in the pool.
1202      * </pre>
1203      *
1204      * <code>NONE = 2402104;</code>
1205      */
1206     public static final int NONE_VALUE = 2402104;
1207 
getNumber()1208     public final int getNumber() {
1209       if (this == UNRECOGNIZED) {
1210         throw new java.lang.IllegalArgumentException(
1211             "Can't get the number of an unknown enum value.");
1212       }
1213       return value;
1214     }
1215 
1216     /**
1217      * @param value The numeric wire value of the corresponding enum entry.
1218      * @return The enum associated with the given numeric wire value.
1219      * @deprecated Use {@link #forNumber(int)} instead.
1220      */
1221     @java.lang.Deprecated
valueOf(int value)1222     public static SessionAffinity valueOf(int value) {
1223       return forNumber(value);
1224     }
1225 
1226     /**
1227      * @param value The numeric wire value of the corresponding enum entry.
1228      * @return The enum associated with the given numeric wire value.
1229      */
forNumber(int value)1230     public static SessionAffinity forNumber(int value) {
1231       switch (value) {
1232         case 0:
1233           return UNDEFINED_SESSION_AFFINITY;
1234         case 345665051:
1235           return CLIENT_IP;
1236         case 106122516:
1237           return CLIENT_IP_NO_DESTINATION;
1238         case 221722926:
1239           return CLIENT_IP_PORT_PROTO;
1240         case 25322148:
1241           return CLIENT_IP_PROTO;
1242         case 370321204:
1243           return GENERATED_COOKIE;
1244         case 200737960:
1245           return HEADER_FIELD;
1246         case 494981627:
1247           return HTTP_COOKIE;
1248         case 2402104:
1249           return NONE;
1250         default:
1251           return null;
1252       }
1253     }
1254 
internalGetValueMap()1255     public static com.google.protobuf.Internal.EnumLiteMap<SessionAffinity> internalGetValueMap() {
1256       return internalValueMap;
1257     }
1258 
1259     private static final com.google.protobuf.Internal.EnumLiteMap<SessionAffinity>
1260         internalValueMap =
1261             new com.google.protobuf.Internal.EnumLiteMap<SessionAffinity>() {
1262               public SessionAffinity findValueByNumber(int number) {
1263                 return SessionAffinity.forNumber(number);
1264               }
1265             };
1266 
getValueDescriptor()1267     public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() {
1268       if (this == UNRECOGNIZED) {
1269         throw new java.lang.IllegalStateException(
1270             "Can't get the descriptor of an unrecognized enum value.");
1271       }
1272       return getDescriptor().getValues().get(ordinal());
1273     }
1274 
getDescriptorForType()1275     public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() {
1276       return getDescriptor();
1277     }
1278 
getDescriptor()1279     public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() {
1280       return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(4);
1281     }
1282 
1283     private static final SessionAffinity[] VALUES = values();
1284 
valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)1285     public static SessionAffinity valueOf(
1286         com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
1287       if (desc.getType() != getDescriptor()) {
1288         throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type.");
1289       }
1290       if (desc.getIndex() == -1) {
1291         return UNRECOGNIZED;
1292       }
1293       return VALUES[desc.getIndex()];
1294     }
1295 
1296     private final int value;
1297 
SessionAffinity(int value)1298     private SessionAffinity(int value) {
1299       this.value = value;
1300     }
1301 
1302     // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.SessionAffinity)
1303   }
1304 
1305   private int bitField0_;
1306   private int bitField1_;
1307   public static final int AFFINITY_COOKIE_TTL_SEC_FIELD_NUMBER = 369996954;
1308   private int affinityCookieTtlSec_ = 0;
1309   /**
1310    *
1311    *
1312    * <pre>
1313    * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
1314    * </pre>
1315    *
1316    * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code>
1317    *
1318    * @return Whether the affinityCookieTtlSec field is set.
1319    */
1320   @java.lang.Override
hasAffinityCookieTtlSec()1321   public boolean hasAffinityCookieTtlSec() {
1322     return ((bitField0_ & 0x00000001) != 0);
1323   }
1324   /**
1325    *
1326    *
1327    * <pre>
1328    * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
1329    * </pre>
1330    *
1331    * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code>
1332    *
1333    * @return The affinityCookieTtlSec.
1334    */
1335   @java.lang.Override
getAffinityCookieTtlSec()1336   public int getAffinityCookieTtlSec() {
1337     return affinityCookieTtlSec_;
1338   }
1339 
1340   public static final int BACKENDS_FIELD_NUMBER = 510839903;
1341 
1342   @SuppressWarnings("serial")
1343   private java.util.List<com.google.cloud.compute.v1.Backend> backends_;
1344   /**
1345    *
1346    *
1347    * <pre>
1348    * The list of backends that serve this BackendService.
1349    * </pre>
1350    *
1351    * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
1352    */
1353   @java.lang.Override
getBackendsList()1354   public java.util.List<com.google.cloud.compute.v1.Backend> getBackendsList() {
1355     return backends_;
1356   }
1357   /**
1358    *
1359    *
1360    * <pre>
1361    * The list of backends that serve this BackendService.
1362    * </pre>
1363    *
1364    * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
1365    */
1366   @java.lang.Override
1367   public java.util.List<? extends com.google.cloud.compute.v1.BackendOrBuilder>
getBackendsOrBuilderList()1368       getBackendsOrBuilderList() {
1369     return backends_;
1370   }
1371   /**
1372    *
1373    *
1374    * <pre>
1375    * The list of backends that serve this BackendService.
1376    * </pre>
1377    *
1378    * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
1379    */
1380   @java.lang.Override
getBackendsCount()1381   public int getBackendsCount() {
1382     return backends_.size();
1383   }
1384   /**
1385    *
1386    *
1387    * <pre>
1388    * The list of backends that serve this BackendService.
1389    * </pre>
1390    *
1391    * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
1392    */
1393   @java.lang.Override
getBackends(int index)1394   public com.google.cloud.compute.v1.Backend getBackends(int index) {
1395     return backends_.get(index);
1396   }
1397   /**
1398    *
1399    *
1400    * <pre>
1401    * The list of backends that serve this BackendService.
1402    * </pre>
1403    *
1404    * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
1405    */
1406   @java.lang.Override
getBackendsOrBuilder(int index)1407   public com.google.cloud.compute.v1.BackendOrBuilder getBackendsOrBuilder(int index) {
1408     return backends_.get(index);
1409   }
1410 
1411   public static final int CDN_POLICY_FIELD_NUMBER = 213976452;
1412   private com.google.cloud.compute.v1.BackendServiceCdnPolicy cdnPolicy_;
1413   /**
1414    *
1415    *
1416    * <pre>
1417    * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
1418    * </pre>
1419    *
1420    * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;</code>
1421    *
1422    * @return Whether the cdnPolicy field is set.
1423    */
1424   @java.lang.Override
hasCdnPolicy()1425   public boolean hasCdnPolicy() {
1426     return ((bitField0_ & 0x00000002) != 0);
1427   }
1428   /**
1429    *
1430    *
1431    * <pre>
1432    * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
1433    * </pre>
1434    *
1435    * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;</code>
1436    *
1437    * @return The cdnPolicy.
1438    */
1439   @java.lang.Override
getCdnPolicy()1440   public com.google.cloud.compute.v1.BackendServiceCdnPolicy getCdnPolicy() {
1441     return cdnPolicy_ == null
1442         ? com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance()
1443         : cdnPolicy_;
1444   }
1445   /**
1446    *
1447    *
1448    * <pre>
1449    * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
1450    * </pre>
1451    *
1452    * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;</code>
1453    */
1454   @java.lang.Override
getCdnPolicyOrBuilder()1455   public com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder getCdnPolicyOrBuilder() {
1456     return cdnPolicy_ == null
1457         ? com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance()
1458         : cdnPolicy_;
1459   }
1460 
1461   public static final int CIRCUIT_BREAKERS_FIELD_NUMBER = 421340061;
1462   private com.google.cloud.compute.v1.CircuitBreakers circuitBreakers_;
1463   /**
1464    * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
1465    *
1466    * @return Whether the circuitBreakers field is set.
1467    */
1468   @java.lang.Override
hasCircuitBreakers()1469   public boolean hasCircuitBreakers() {
1470     return ((bitField0_ & 0x00000004) != 0);
1471   }
1472   /**
1473    * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
1474    *
1475    * @return The circuitBreakers.
1476    */
1477   @java.lang.Override
getCircuitBreakers()1478   public com.google.cloud.compute.v1.CircuitBreakers getCircuitBreakers() {
1479     return circuitBreakers_ == null
1480         ? com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance()
1481         : circuitBreakers_;
1482   }
1483   /**
1484    * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
1485    */
1486   @java.lang.Override
getCircuitBreakersOrBuilder()1487   public com.google.cloud.compute.v1.CircuitBreakersOrBuilder getCircuitBreakersOrBuilder() {
1488     return circuitBreakers_ == null
1489         ? com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance()
1490         : circuitBreakers_;
1491   }
1492 
1493   public static final int COMPRESSION_MODE_FIELD_NUMBER = 95520988;
1494 
1495   @SuppressWarnings("serial")
1496   private volatile java.lang.Object compressionMode_ = "";
1497   /**
1498    *
1499    *
1500    * <pre>
1501    * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
1502    * Check the CompressionMode enum for the list of possible values.
1503    * </pre>
1504    *
1505    * <code>optional string compression_mode = 95520988;</code>
1506    *
1507    * @return Whether the compressionMode field is set.
1508    */
1509   @java.lang.Override
hasCompressionMode()1510   public boolean hasCompressionMode() {
1511     return ((bitField0_ & 0x00000008) != 0);
1512   }
1513   /**
1514    *
1515    *
1516    * <pre>
1517    * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
1518    * Check the CompressionMode enum for the list of possible values.
1519    * </pre>
1520    *
1521    * <code>optional string compression_mode = 95520988;</code>
1522    *
1523    * @return The compressionMode.
1524    */
1525   @java.lang.Override
getCompressionMode()1526   public java.lang.String getCompressionMode() {
1527     java.lang.Object ref = compressionMode_;
1528     if (ref instanceof java.lang.String) {
1529       return (java.lang.String) ref;
1530     } else {
1531       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
1532       java.lang.String s = bs.toStringUtf8();
1533       compressionMode_ = s;
1534       return s;
1535     }
1536   }
1537   /**
1538    *
1539    *
1540    * <pre>
1541    * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
1542    * Check the CompressionMode enum for the list of possible values.
1543    * </pre>
1544    *
1545    * <code>optional string compression_mode = 95520988;</code>
1546    *
1547    * @return The bytes for compressionMode.
1548    */
1549   @java.lang.Override
getCompressionModeBytes()1550   public com.google.protobuf.ByteString getCompressionModeBytes() {
1551     java.lang.Object ref = compressionMode_;
1552     if (ref instanceof java.lang.String) {
1553       com.google.protobuf.ByteString b =
1554           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
1555       compressionMode_ = b;
1556       return b;
1557     } else {
1558       return (com.google.protobuf.ByteString) ref;
1559     }
1560   }
1561 
1562   public static final int CONNECTION_DRAINING_FIELD_NUMBER = 461096747;
1563   private com.google.cloud.compute.v1.ConnectionDraining connectionDraining_;
1564   /**
1565    * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
1566    * </code>
1567    *
1568    * @return Whether the connectionDraining field is set.
1569    */
1570   @java.lang.Override
hasConnectionDraining()1571   public boolean hasConnectionDraining() {
1572     return ((bitField0_ & 0x00000010) != 0);
1573   }
1574   /**
1575    * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
1576    * </code>
1577    *
1578    * @return The connectionDraining.
1579    */
1580   @java.lang.Override
getConnectionDraining()1581   public com.google.cloud.compute.v1.ConnectionDraining getConnectionDraining() {
1582     return connectionDraining_ == null
1583         ? com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance()
1584         : connectionDraining_;
1585   }
1586   /**
1587    * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
1588    * </code>
1589    */
1590   @java.lang.Override
getConnectionDrainingOrBuilder()1591   public com.google.cloud.compute.v1.ConnectionDrainingOrBuilder getConnectionDrainingOrBuilder() {
1592     return connectionDraining_ == null
1593         ? com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance()
1594         : connectionDraining_;
1595   }
1596 
1597   public static final int CONNECTION_TRACKING_POLICY_FIELD_NUMBER = 143994969;
1598   private com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy
1599       connectionTrackingPolicy_;
1600   /**
1601    *
1602    *
1603    * <pre>
1604    * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
1605    * </pre>
1606    *
1607    * <code>
1608    * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
1609    * </code>
1610    *
1611    * @return Whether the connectionTrackingPolicy field is set.
1612    */
1613   @java.lang.Override
hasConnectionTrackingPolicy()1614   public boolean hasConnectionTrackingPolicy() {
1615     return ((bitField0_ & 0x00000020) != 0);
1616   }
1617   /**
1618    *
1619    *
1620    * <pre>
1621    * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
1622    * </pre>
1623    *
1624    * <code>
1625    * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
1626    * </code>
1627    *
1628    * @return The connectionTrackingPolicy.
1629    */
1630   @java.lang.Override
1631   public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy
getConnectionTrackingPolicy()1632       getConnectionTrackingPolicy() {
1633     return connectionTrackingPolicy_ == null
1634         ? com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.getDefaultInstance()
1635         : connectionTrackingPolicy_;
1636   }
1637   /**
1638    *
1639    *
1640    * <pre>
1641    * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
1642    * </pre>
1643    *
1644    * <code>
1645    * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
1646    * </code>
1647    */
1648   @java.lang.Override
1649   public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder
getConnectionTrackingPolicyOrBuilder()1650       getConnectionTrackingPolicyOrBuilder() {
1651     return connectionTrackingPolicy_ == null
1652         ? com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.getDefaultInstance()
1653         : connectionTrackingPolicy_;
1654   }
1655 
1656   public static final int CONSISTENT_HASH_FIELD_NUMBER = 905883;
1657   private com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistentHash_;
1658   /**
1659    *
1660    *
1661    * <pre>
1662    * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
1663    * </pre>
1664    *
1665    * <code>
1666    * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
1667    * </code>
1668    *
1669    * @return Whether the consistentHash field is set.
1670    */
1671   @java.lang.Override
hasConsistentHash()1672   public boolean hasConsistentHash() {
1673     return ((bitField0_ & 0x00000040) != 0);
1674   }
1675   /**
1676    *
1677    *
1678    * <pre>
1679    * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
1680    * </pre>
1681    *
1682    * <code>
1683    * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
1684    * </code>
1685    *
1686    * @return The consistentHash.
1687    */
1688   @java.lang.Override
getConsistentHash()1689   public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings getConsistentHash() {
1690     return consistentHash_ == null
1691         ? com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.getDefaultInstance()
1692         : consistentHash_;
1693   }
1694   /**
1695    *
1696    *
1697    * <pre>
1698    * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
1699    * </pre>
1700    *
1701    * <code>
1702    * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
1703    * </code>
1704    */
1705   @java.lang.Override
1706   public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder
getConsistentHashOrBuilder()1707       getConsistentHashOrBuilder() {
1708     return consistentHash_ == null
1709         ? com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.getDefaultInstance()
1710         : consistentHash_;
1711   }
1712 
1713   public static final int CREATION_TIMESTAMP_FIELD_NUMBER = 30525366;
1714 
1715   @SuppressWarnings("serial")
1716   private volatile java.lang.Object creationTimestamp_ = "";
1717   /**
1718    *
1719    *
1720    * <pre>
1721    * [Output Only] Creation timestamp in RFC3339 text format.
1722    * </pre>
1723    *
1724    * <code>optional string creation_timestamp = 30525366;</code>
1725    *
1726    * @return Whether the creationTimestamp field is set.
1727    */
1728   @java.lang.Override
hasCreationTimestamp()1729   public boolean hasCreationTimestamp() {
1730     return ((bitField0_ & 0x00000080) != 0);
1731   }
1732   /**
1733    *
1734    *
1735    * <pre>
1736    * [Output Only] Creation timestamp in RFC3339 text format.
1737    * </pre>
1738    *
1739    * <code>optional string creation_timestamp = 30525366;</code>
1740    *
1741    * @return The creationTimestamp.
1742    */
1743   @java.lang.Override
getCreationTimestamp()1744   public java.lang.String getCreationTimestamp() {
1745     java.lang.Object ref = creationTimestamp_;
1746     if (ref instanceof java.lang.String) {
1747       return (java.lang.String) ref;
1748     } else {
1749       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
1750       java.lang.String s = bs.toStringUtf8();
1751       creationTimestamp_ = s;
1752       return s;
1753     }
1754   }
1755   /**
1756    *
1757    *
1758    * <pre>
1759    * [Output Only] Creation timestamp in RFC3339 text format.
1760    * </pre>
1761    *
1762    * <code>optional string creation_timestamp = 30525366;</code>
1763    *
1764    * @return The bytes for creationTimestamp.
1765    */
1766   @java.lang.Override
getCreationTimestampBytes()1767   public com.google.protobuf.ByteString getCreationTimestampBytes() {
1768     java.lang.Object ref = creationTimestamp_;
1769     if (ref instanceof java.lang.String) {
1770       com.google.protobuf.ByteString b =
1771           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
1772       creationTimestamp_ = b;
1773       return b;
1774     } else {
1775       return (com.google.protobuf.ByteString) ref;
1776     }
1777   }
1778 
1779   public static final int CUSTOM_REQUEST_HEADERS_FIELD_NUMBER = 27977992;
1780 
1781   @SuppressWarnings("serial")
1782   private com.google.protobuf.LazyStringList customRequestHeaders_;
1783   /**
1784    *
1785    *
1786    * <pre>
1787    * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
1788    * </pre>
1789    *
1790    * <code>repeated string custom_request_headers = 27977992;</code>
1791    *
1792    * @return A list containing the customRequestHeaders.
1793    */
getCustomRequestHeadersList()1794   public com.google.protobuf.ProtocolStringList getCustomRequestHeadersList() {
1795     return customRequestHeaders_;
1796   }
1797   /**
1798    *
1799    *
1800    * <pre>
1801    * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
1802    * </pre>
1803    *
1804    * <code>repeated string custom_request_headers = 27977992;</code>
1805    *
1806    * @return The count of customRequestHeaders.
1807    */
getCustomRequestHeadersCount()1808   public int getCustomRequestHeadersCount() {
1809     return customRequestHeaders_.size();
1810   }
1811   /**
1812    *
1813    *
1814    * <pre>
1815    * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
1816    * </pre>
1817    *
1818    * <code>repeated string custom_request_headers = 27977992;</code>
1819    *
1820    * @param index The index of the element to return.
1821    * @return The customRequestHeaders at the given index.
1822    */
getCustomRequestHeaders(int index)1823   public java.lang.String getCustomRequestHeaders(int index) {
1824     return customRequestHeaders_.get(index);
1825   }
1826   /**
1827    *
1828    *
1829    * <pre>
1830    * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
1831    * </pre>
1832    *
1833    * <code>repeated string custom_request_headers = 27977992;</code>
1834    *
1835    * @param index The index of the value to return.
1836    * @return The bytes of the customRequestHeaders at the given index.
1837    */
getCustomRequestHeadersBytes(int index)1838   public com.google.protobuf.ByteString getCustomRequestHeadersBytes(int index) {
1839     return customRequestHeaders_.getByteString(index);
1840   }
1841 
1842   public static final int CUSTOM_RESPONSE_HEADERS_FIELD_NUMBER = 387539094;
1843 
1844   @SuppressWarnings("serial")
1845   private com.google.protobuf.LazyStringList customResponseHeaders_;
1846   /**
1847    *
1848    *
1849    * <pre>
1850    * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
1851    * </pre>
1852    *
1853    * <code>repeated string custom_response_headers = 387539094;</code>
1854    *
1855    * @return A list containing the customResponseHeaders.
1856    */
getCustomResponseHeadersList()1857   public com.google.protobuf.ProtocolStringList getCustomResponseHeadersList() {
1858     return customResponseHeaders_;
1859   }
1860   /**
1861    *
1862    *
1863    * <pre>
1864    * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
1865    * </pre>
1866    *
1867    * <code>repeated string custom_response_headers = 387539094;</code>
1868    *
1869    * @return The count of customResponseHeaders.
1870    */
getCustomResponseHeadersCount()1871   public int getCustomResponseHeadersCount() {
1872     return customResponseHeaders_.size();
1873   }
1874   /**
1875    *
1876    *
1877    * <pre>
1878    * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
1879    * </pre>
1880    *
1881    * <code>repeated string custom_response_headers = 387539094;</code>
1882    *
1883    * @param index The index of the element to return.
1884    * @return The customResponseHeaders at the given index.
1885    */
getCustomResponseHeaders(int index)1886   public java.lang.String getCustomResponseHeaders(int index) {
1887     return customResponseHeaders_.get(index);
1888   }
1889   /**
1890    *
1891    *
1892    * <pre>
1893    * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
1894    * </pre>
1895    *
1896    * <code>repeated string custom_response_headers = 387539094;</code>
1897    *
1898    * @param index The index of the value to return.
1899    * @return The bytes of the customResponseHeaders at the given index.
1900    */
getCustomResponseHeadersBytes(int index)1901   public com.google.protobuf.ByteString getCustomResponseHeadersBytes(int index) {
1902     return customResponseHeaders_.getByteString(index);
1903   }
1904 
1905   public static final int DESCRIPTION_FIELD_NUMBER = 422937596;
1906 
1907   @SuppressWarnings("serial")
1908   private volatile java.lang.Object description_ = "";
1909   /**
1910    *
1911    *
1912    * <pre>
1913    * An optional description of this resource. Provide this property when you create the resource.
1914    * </pre>
1915    *
1916    * <code>optional string description = 422937596;</code>
1917    *
1918    * @return Whether the description field is set.
1919    */
1920   @java.lang.Override
hasDescription()1921   public boolean hasDescription() {
1922     return ((bitField0_ & 0x00000100) != 0);
1923   }
1924   /**
1925    *
1926    *
1927    * <pre>
1928    * An optional description of this resource. Provide this property when you create the resource.
1929    * </pre>
1930    *
1931    * <code>optional string description = 422937596;</code>
1932    *
1933    * @return The description.
1934    */
1935   @java.lang.Override
getDescription()1936   public java.lang.String getDescription() {
1937     java.lang.Object ref = description_;
1938     if (ref instanceof java.lang.String) {
1939       return (java.lang.String) ref;
1940     } else {
1941       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
1942       java.lang.String s = bs.toStringUtf8();
1943       description_ = s;
1944       return s;
1945     }
1946   }
1947   /**
1948    *
1949    *
1950    * <pre>
1951    * An optional description of this resource. Provide this property when you create the resource.
1952    * </pre>
1953    *
1954    * <code>optional string description = 422937596;</code>
1955    *
1956    * @return The bytes for description.
1957    */
1958   @java.lang.Override
getDescriptionBytes()1959   public com.google.protobuf.ByteString getDescriptionBytes() {
1960     java.lang.Object ref = description_;
1961     if (ref instanceof java.lang.String) {
1962       com.google.protobuf.ByteString b =
1963           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
1964       description_ = b;
1965       return b;
1966     } else {
1967       return (com.google.protobuf.ByteString) ref;
1968     }
1969   }
1970 
1971   public static final int EDGE_SECURITY_POLICY_FIELD_NUMBER = 41036943;
1972 
1973   @SuppressWarnings("serial")
1974   private volatile java.lang.Object edgeSecurityPolicy_ = "";
1975   /**
1976    *
1977    *
1978    * <pre>
1979    * [Output Only] The resource URL for the edge security policy associated with this backend service.
1980    * </pre>
1981    *
1982    * <code>optional string edge_security_policy = 41036943;</code>
1983    *
1984    * @return Whether the edgeSecurityPolicy field is set.
1985    */
1986   @java.lang.Override
hasEdgeSecurityPolicy()1987   public boolean hasEdgeSecurityPolicy() {
1988     return ((bitField0_ & 0x00000200) != 0);
1989   }
1990   /**
1991    *
1992    *
1993    * <pre>
1994    * [Output Only] The resource URL for the edge security policy associated with this backend service.
1995    * </pre>
1996    *
1997    * <code>optional string edge_security_policy = 41036943;</code>
1998    *
1999    * @return The edgeSecurityPolicy.
2000    */
2001   @java.lang.Override
getEdgeSecurityPolicy()2002   public java.lang.String getEdgeSecurityPolicy() {
2003     java.lang.Object ref = edgeSecurityPolicy_;
2004     if (ref instanceof java.lang.String) {
2005       return (java.lang.String) ref;
2006     } else {
2007       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
2008       java.lang.String s = bs.toStringUtf8();
2009       edgeSecurityPolicy_ = s;
2010       return s;
2011     }
2012   }
2013   /**
2014    *
2015    *
2016    * <pre>
2017    * [Output Only] The resource URL for the edge security policy associated with this backend service.
2018    * </pre>
2019    *
2020    * <code>optional string edge_security_policy = 41036943;</code>
2021    *
2022    * @return The bytes for edgeSecurityPolicy.
2023    */
2024   @java.lang.Override
getEdgeSecurityPolicyBytes()2025   public com.google.protobuf.ByteString getEdgeSecurityPolicyBytes() {
2026     java.lang.Object ref = edgeSecurityPolicy_;
2027     if (ref instanceof java.lang.String) {
2028       com.google.protobuf.ByteString b =
2029           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
2030       edgeSecurityPolicy_ = b;
2031       return b;
2032     } else {
2033       return (com.google.protobuf.ByteString) ref;
2034     }
2035   }
2036 
2037   public static final int ENABLE_C_D_N_FIELD_NUMBER = 250733499;
2038   private boolean enableCDN_ = false;
2039   /**
2040    *
2041    *
2042    * <pre>
2043    * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer.
2044    * </pre>
2045    *
2046    * <code>optional bool enable_c_d_n = 250733499;</code>
2047    *
2048    * @return Whether the enableCDN field is set.
2049    */
2050   @java.lang.Override
hasEnableCDN()2051   public boolean hasEnableCDN() {
2052     return ((bitField0_ & 0x00000400) != 0);
2053   }
2054   /**
2055    *
2056    *
2057    * <pre>
2058    * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer.
2059    * </pre>
2060    *
2061    * <code>optional bool enable_c_d_n = 250733499;</code>
2062    *
2063    * @return The enableCDN.
2064    */
2065   @java.lang.Override
getEnableCDN()2066   public boolean getEnableCDN() {
2067     return enableCDN_;
2068   }
2069 
2070   public static final int FAILOVER_POLICY_FIELD_NUMBER = 105658655;
2071   private com.google.cloud.compute.v1.BackendServiceFailoverPolicy failoverPolicy_;
2072   /**
2073    *
2074    *
2075    * <pre>
2076    * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
2077    * </pre>
2078    *
2079    * <code>
2080    * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
2081    * </code>
2082    *
2083    * @return Whether the failoverPolicy field is set.
2084    */
2085   @java.lang.Override
hasFailoverPolicy()2086   public boolean hasFailoverPolicy() {
2087     return ((bitField0_ & 0x00000800) != 0);
2088   }
2089   /**
2090    *
2091    *
2092    * <pre>
2093    * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
2094    * </pre>
2095    *
2096    * <code>
2097    * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
2098    * </code>
2099    *
2100    * @return The failoverPolicy.
2101    */
2102   @java.lang.Override
getFailoverPolicy()2103   public com.google.cloud.compute.v1.BackendServiceFailoverPolicy getFailoverPolicy() {
2104     return failoverPolicy_ == null
2105         ? com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance()
2106         : failoverPolicy_;
2107   }
2108   /**
2109    *
2110    *
2111    * <pre>
2112    * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
2113    * </pre>
2114    *
2115    * <code>
2116    * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
2117    * </code>
2118    */
2119   @java.lang.Override
2120   public com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder
getFailoverPolicyOrBuilder()2121       getFailoverPolicyOrBuilder() {
2122     return failoverPolicy_ == null
2123         ? com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance()
2124         : failoverPolicy_;
2125   }
2126 
2127   public static final int FINGERPRINT_FIELD_NUMBER = 234678500;
2128 
2129   @SuppressWarnings("serial")
2130   private volatile java.lang.Object fingerprint_ = "";
2131   /**
2132    *
2133    *
2134    * <pre>
2135    * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
2136    * </pre>
2137    *
2138    * <code>optional string fingerprint = 234678500;</code>
2139    *
2140    * @return Whether the fingerprint field is set.
2141    */
2142   @java.lang.Override
hasFingerprint()2143   public boolean hasFingerprint() {
2144     return ((bitField0_ & 0x00001000) != 0);
2145   }
2146   /**
2147    *
2148    *
2149    * <pre>
2150    * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
2151    * </pre>
2152    *
2153    * <code>optional string fingerprint = 234678500;</code>
2154    *
2155    * @return The fingerprint.
2156    */
2157   @java.lang.Override
getFingerprint()2158   public java.lang.String getFingerprint() {
2159     java.lang.Object ref = fingerprint_;
2160     if (ref instanceof java.lang.String) {
2161       return (java.lang.String) ref;
2162     } else {
2163       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
2164       java.lang.String s = bs.toStringUtf8();
2165       fingerprint_ = s;
2166       return s;
2167     }
2168   }
2169   /**
2170    *
2171    *
2172    * <pre>
2173    * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
2174    * </pre>
2175    *
2176    * <code>optional string fingerprint = 234678500;</code>
2177    *
2178    * @return The bytes for fingerprint.
2179    */
2180   @java.lang.Override
getFingerprintBytes()2181   public com.google.protobuf.ByteString getFingerprintBytes() {
2182     java.lang.Object ref = fingerprint_;
2183     if (ref instanceof java.lang.String) {
2184       com.google.protobuf.ByteString b =
2185           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
2186       fingerprint_ = b;
2187       return b;
2188     } else {
2189       return (com.google.protobuf.ByteString) ref;
2190     }
2191   }
2192 
2193   public static final int HEALTH_CHECKS_FIELD_NUMBER = 448370606;
2194 
2195   @SuppressWarnings("serial")
2196   private com.google.protobuf.LazyStringList healthChecks_;
2197   /**
2198    *
2199    *
2200    * <pre>
2201    * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
2202    * </pre>
2203    *
2204    * <code>repeated string health_checks = 448370606;</code>
2205    *
2206    * @return A list containing the healthChecks.
2207    */
getHealthChecksList()2208   public com.google.protobuf.ProtocolStringList getHealthChecksList() {
2209     return healthChecks_;
2210   }
2211   /**
2212    *
2213    *
2214    * <pre>
2215    * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
2216    * </pre>
2217    *
2218    * <code>repeated string health_checks = 448370606;</code>
2219    *
2220    * @return The count of healthChecks.
2221    */
getHealthChecksCount()2222   public int getHealthChecksCount() {
2223     return healthChecks_.size();
2224   }
2225   /**
2226    *
2227    *
2228    * <pre>
2229    * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
2230    * </pre>
2231    *
2232    * <code>repeated string health_checks = 448370606;</code>
2233    *
2234    * @param index The index of the element to return.
2235    * @return The healthChecks at the given index.
2236    */
getHealthChecks(int index)2237   public java.lang.String getHealthChecks(int index) {
2238     return healthChecks_.get(index);
2239   }
2240   /**
2241    *
2242    *
2243    * <pre>
2244    * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
2245    * </pre>
2246    *
2247    * <code>repeated string health_checks = 448370606;</code>
2248    *
2249    * @param index The index of the value to return.
2250    * @return The bytes of the healthChecks at the given index.
2251    */
getHealthChecksBytes(int index)2252   public com.google.protobuf.ByteString getHealthChecksBytes(int index) {
2253     return healthChecks_.getByteString(index);
2254   }
2255 
2256   public static final int IAP_FIELD_NUMBER = 104024;
2257   private com.google.cloud.compute.v1.BackendServiceIAP iap_;
2258   /**
2259    *
2260    *
2261    * <pre>
2262    * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
2263    * </pre>
2264    *
2265    * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
2266    *
2267    * @return Whether the iap field is set.
2268    */
2269   @java.lang.Override
hasIap()2270   public boolean hasIap() {
2271     return ((bitField0_ & 0x00002000) != 0);
2272   }
2273   /**
2274    *
2275    *
2276    * <pre>
2277    * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
2278    * </pre>
2279    *
2280    * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
2281    *
2282    * @return The iap.
2283    */
2284   @java.lang.Override
getIap()2285   public com.google.cloud.compute.v1.BackendServiceIAP getIap() {
2286     return iap_ == null ? com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance() : iap_;
2287   }
2288   /**
2289    *
2290    *
2291    * <pre>
2292    * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
2293    * </pre>
2294    *
2295    * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
2296    */
2297   @java.lang.Override
getIapOrBuilder()2298   public com.google.cloud.compute.v1.BackendServiceIAPOrBuilder getIapOrBuilder() {
2299     return iap_ == null ? com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance() : iap_;
2300   }
2301 
2302   public static final int ID_FIELD_NUMBER = 3355;
2303   private long id_ = 0L;
2304   /**
2305    *
2306    *
2307    * <pre>
2308    * [Output Only] The unique identifier for the resource. This identifier is defined by the server.
2309    * </pre>
2310    *
2311    * <code>optional uint64 id = 3355;</code>
2312    *
2313    * @return Whether the id field is set.
2314    */
2315   @java.lang.Override
hasId()2316   public boolean hasId() {
2317     return ((bitField0_ & 0x00004000) != 0);
2318   }
2319   /**
2320    *
2321    *
2322    * <pre>
2323    * [Output Only] The unique identifier for the resource. This identifier is defined by the server.
2324    * </pre>
2325    *
2326    * <code>optional uint64 id = 3355;</code>
2327    *
2328    * @return The id.
2329    */
2330   @java.lang.Override
getId()2331   public long getId() {
2332     return id_;
2333   }
2334 
2335   public static final int KIND_FIELD_NUMBER = 3292052;
2336 
2337   @SuppressWarnings("serial")
2338   private volatile java.lang.Object kind_ = "";
2339   /**
2340    *
2341    *
2342    * <pre>
2343    * [Output Only] Type of resource. Always compute#backendService for backend services.
2344    * </pre>
2345    *
2346    * <code>optional string kind = 3292052;</code>
2347    *
2348    * @return Whether the kind field is set.
2349    */
2350   @java.lang.Override
hasKind()2351   public boolean hasKind() {
2352     return ((bitField0_ & 0x00008000) != 0);
2353   }
2354   /**
2355    *
2356    *
2357    * <pre>
2358    * [Output Only] Type of resource. Always compute#backendService for backend services.
2359    * </pre>
2360    *
2361    * <code>optional string kind = 3292052;</code>
2362    *
2363    * @return The kind.
2364    */
2365   @java.lang.Override
getKind()2366   public java.lang.String getKind() {
2367     java.lang.Object ref = kind_;
2368     if (ref instanceof java.lang.String) {
2369       return (java.lang.String) ref;
2370     } else {
2371       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
2372       java.lang.String s = bs.toStringUtf8();
2373       kind_ = s;
2374       return s;
2375     }
2376   }
2377   /**
2378    *
2379    *
2380    * <pre>
2381    * [Output Only] Type of resource. Always compute#backendService for backend services.
2382    * </pre>
2383    *
2384    * <code>optional string kind = 3292052;</code>
2385    *
2386    * @return The bytes for kind.
2387    */
2388   @java.lang.Override
getKindBytes()2389   public com.google.protobuf.ByteString getKindBytes() {
2390     java.lang.Object ref = kind_;
2391     if (ref instanceof java.lang.String) {
2392       com.google.protobuf.ByteString b =
2393           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
2394       kind_ = b;
2395       return b;
2396     } else {
2397       return (com.google.protobuf.ByteString) ref;
2398     }
2399   }
2400 
2401   public static final int LOAD_BALANCING_SCHEME_FIELD_NUMBER = 363890244;
2402 
2403   @SuppressWarnings("serial")
2404   private volatile java.lang.Object loadBalancingScheme_ = "";
2405   /**
2406    *
2407    *
2408    * <pre>
2409    * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
2410    * Check the LoadBalancingScheme enum for the list of possible values.
2411    * </pre>
2412    *
2413    * <code>optional string load_balancing_scheme = 363890244;</code>
2414    *
2415    * @return Whether the loadBalancingScheme field is set.
2416    */
2417   @java.lang.Override
hasLoadBalancingScheme()2418   public boolean hasLoadBalancingScheme() {
2419     return ((bitField0_ & 0x00010000) != 0);
2420   }
2421   /**
2422    *
2423    *
2424    * <pre>
2425    * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
2426    * Check the LoadBalancingScheme enum for the list of possible values.
2427    * </pre>
2428    *
2429    * <code>optional string load_balancing_scheme = 363890244;</code>
2430    *
2431    * @return The loadBalancingScheme.
2432    */
2433   @java.lang.Override
getLoadBalancingScheme()2434   public java.lang.String getLoadBalancingScheme() {
2435     java.lang.Object ref = loadBalancingScheme_;
2436     if (ref instanceof java.lang.String) {
2437       return (java.lang.String) ref;
2438     } else {
2439       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
2440       java.lang.String s = bs.toStringUtf8();
2441       loadBalancingScheme_ = s;
2442       return s;
2443     }
2444   }
2445   /**
2446    *
2447    *
2448    * <pre>
2449    * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
2450    * Check the LoadBalancingScheme enum for the list of possible values.
2451    * </pre>
2452    *
2453    * <code>optional string load_balancing_scheme = 363890244;</code>
2454    *
2455    * @return The bytes for loadBalancingScheme.
2456    */
2457   @java.lang.Override
getLoadBalancingSchemeBytes()2458   public com.google.protobuf.ByteString getLoadBalancingSchemeBytes() {
2459     java.lang.Object ref = loadBalancingScheme_;
2460     if (ref instanceof java.lang.String) {
2461       com.google.protobuf.ByteString b =
2462           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
2463       loadBalancingScheme_ = b;
2464       return b;
2465     } else {
2466       return (com.google.protobuf.ByteString) ref;
2467     }
2468   }
2469 
2470   public static final int LOCALITY_LB_POLICIES_FIELD_NUMBER = 140982557;
2471 
2472   @SuppressWarnings("serial")
2473   private java.util.List<
2474           com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig>
2475       localityLbPolicies_;
2476   /**
2477    *
2478    *
2479    * <pre>
2480    * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
2481    * </pre>
2482    *
2483    * <code>
2484    * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
2485    * </code>
2486    */
2487   @java.lang.Override
2488   public java.util.List<com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig>
getLocalityLbPoliciesList()2489       getLocalityLbPoliciesList() {
2490     return localityLbPolicies_;
2491   }
2492   /**
2493    *
2494    *
2495    * <pre>
2496    * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
2497    * </pre>
2498    *
2499    * <code>
2500    * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
2501    * </code>
2502    */
2503   @java.lang.Override
2504   public java.util.List<
2505           ? extends
2506               com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder>
getLocalityLbPoliciesOrBuilderList()2507       getLocalityLbPoliciesOrBuilderList() {
2508     return localityLbPolicies_;
2509   }
2510   /**
2511    *
2512    *
2513    * <pre>
2514    * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
2515    * </pre>
2516    *
2517    * <code>
2518    * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
2519    * </code>
2520    */
2521   @java.lang.Override
getLocalityLbPoliciesCount()2522   public int getLocalityLbPoliciesCount() {
2523     return localityLbPolicies_.size();
2524   }
2525   /**
2526    *
2527    *
2528    * <pre>
2529    * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
2530    * </pre>
2531    *
2532    * <code>
2533    * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
2534    * </code>
2535    */
2536   @java.lang.Override
2537   public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig
getLocalityLbPolicies(int index)2538       getLocalityLbPolicies(int index) {
2539     return localityLbPolicies_.get(index);
2540   }
2541   /**
2542    *
2543    *
2544    * <pre>
2545    * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
2546    * </pre>
2547    *
2548    * <code>
2549    * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
2550    * </code>
2551    */
2552   @java.lang.Override
2553   public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder
getLocalityLbPoliciesOrBuilder(int index)2554       getLocalityLbPoliciesOrBuilder(int index) {
2555     return localityLbPolicies_.get(index);
2556   }
2557 
2558   public static final int LOCALITY_LB_POLICY_FIELD_NUMBER = 131431487;
2559 
2560   @SuppressWarnings("serial")
2561   private volatile java.lang.Object localityLbPolicy_ = "";
2562   /**
2563    *
2564    *
2565    * <pre>
2566    * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
2567    * Check the LocalityLbPolicy enum for the list of possible values.
2568    * </pre>
2569    *
2570    * <code>optional string locality_lb_policy = 131431487;</code>
2571    *
2572    * @return Whether the localityLbPolicy field is set.
2573    */
2574   @java.lang.Override
hasLocalityLbPolicy()2575   public boolean hasLocalityLbPolicy() {
2576     return ((bitField0_ & 0x00020000) != 0);
2577   }
2578   /**
2579    *
2580    *
2581    * <pre>
2582    * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
2583    * Check the LocalityLbPolicy enum for the list of possible values.
2584    * </pre>
2585    *
2586    * <code>optional string locality_lb_policy = 131431487;</code>
2587    *
2588    * @return The localityLbPolicy.
2589    */
2590   @java.lang.Override
getLocalityLbPolicy()2591   public java.lang.String getLocalityLbPolicy() {
2592     java.lang.Object ref = localityLbPolicy_;
2593     if (ref instanceof java.lang.String) {
2594       return (java.lang.String) ref;
2595     } else {
2596       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
2597       java.lang.String s = bs.toStringUtf8();
2598       localityLbPolicy_ = s;
2599       return s;
2600     }
2601   }
2602   /**
2603    *
2604    *
2605    * <pre>
2606    * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
2607    * Check the LocalityLbPolicy enum for the list of possible values.
2608    * </pre>
2609    *
2610    * <code>optional string locality_lb_policy = 131431487;</code>
2611    *
2612    * @return The bytes for localityLbPolicy.
2613    */
2614   @java.lang.Override
getLocalityLbPolicyBytes()2615   public com.google.protobuf.ByteString getLocalityLbPolicyBytes() {
2616     java.lang.Object ref = localityLbPolicy_;
2617     if (ref instanceof java.lang.String) {
2618       com.google.protobuf.ByteString b =
2619           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
2620       localityLbPolicy_ = b;
2621       return b;
2622     } else {
2623       return (com.google.protobuf.ByteString) ref;
2624     }
2625   }
2626 
2627   public static final int LOG_CONFIG_FIELD_NUMBER = 351299741;
2628   private com.google.cloud.compute.v1.BackendServiceLogConfig logConfig_;
2629   /**
2630    *
2631    *
2632    * <pre>
2633    * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
2634    * </pre>
2635    *
2636    * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;</code>
2637    *
2638    * @return Whether the logConfig field is set.
2639    */
2640   @java.lang.Override
hasLogConfig()2641   public boolean hasLogConfig() {
2642     return ((bitField0_ & 0x00040000) != 0);
2643   }
2644   /**
2645    *
2646    *
2647    * <pre>
2648    * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
2649    * </pre>
2650    *
2651    * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;</code>
2652    *
2653    * @return The logConfig.
2654    */
2655   @java.lang.Override
getLogConfig()2656   public com.google.cloud.compute.v1.BackendServiceLogConfig getLogConfig() {
2657     return logConfig_ == null
2658         ? com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance()
2659         : logConfig_;
2660   }
2661   /**
2662    *
2663    *
2664    * <pre>
2665    * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
2666    * </pre>
2667    *
2668    * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;</code>
2669    */
2670   @java.lang.Override
getLogConfigOrBuilder()2671   public com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder getLogConfigOrBuilder() {
2672     return logConfig_ == null
2673         ? com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance()
2674         : logConfig_;
2675   }
2676 
2677   public static final int MAX_STREAM_DURATION_FIELD_NUMBER = 61428376;
2678   private com.google.cloud.compute.v1.Duration maxStreamDuration_;
2679   /**
2680    *
2681    *
2682    * <pre>
2683    * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
2684    * </pre>
2685    *
2686    * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
2687    *
2688    * @return Whether the maxStreamDuration field is set.
2689    */
2690   @java.lang.Override
hasMaxStreamDuration()2691   public boolean hasMaxStreamDuration() {
2692     return ((bitField0_ & 0x00080000) != 0);
2693   }
2694   /**
2695    *
2696    *
2697    * <pre>
2698    * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
2699    * </pre>
2700    *
2701    * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
2702    *
2703    * @return The maxStreamDuration.
2704    */
2705   @java.lang.Override
getMaxStreamDuration()2706   public com.google.cloud.compute.v1.Duration getMaxStreamDuration() {
2707     return maxStreamDuration_ == null
2708         ? com.google.cloud.compute.v1.Duration.getDefaultInstance()
2709         : maxStreamDuration_;
2710   }
2711   /**
2712    *
2713    *
2714    * <pre>
2715    * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
2716    * </pre>
2717    *
2718    * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
2719    */
2720   @java.lang.Override
getMaxStreamDurationOrBuilder()2721   public com.google.cloud.compute.v1.DurationOrBuilder getMaxStreamDurationOrBuilder() {
2722     return maxStreamDuration_ == null
2723         ? com.google.cloud.compute.v1.Duration.getDefaultInstance()
2724         : maxStreamDuration_;
2725   }
2726 
2727   public static final int NAME_FIELD_NUMBER = 3373707;
2728 
2729   @SuppressWarnings("serial")
2730   private volatile java.lang.Object name_ = "";
2731   /**
2732    *
2733    *
2734    * <pre>
2735    * 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.
2736    * </pre>
2737    *
2738    * <code>optional string name = 3373707;</code>
2739    *
2740    * @return Whether the name field is set.
2741    */
2742   @java.lang.Override
hasName()2743   public boolean hasName() {
2744     return ((bitField0_ & 0x00100000) != 0);
2745   }
2746   /**
2747    *
2748    *
2749    * <pre>
2750    * 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.
2751    * </pre>
2752    *
2753    * <code>optional string name = 3373707;</code>
2754    *
2755    * @return The name.
2756    */
2757   @java.lang.Override
getName()2758   public java.lang.String getName() {
2759     java.lang.Object ref = name_;
2760     if (ref instanceof java.lang.String) {
2761       return (java.lang.String) ref;
2762     } else {
2763       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
2764       java.lang.String s = bs.toStringUtf8();
2765       name_ = s;
2766       return s;
2767     }
2768   }
2769   /**
2770    *
2771    *
2772    * <pre>
2773    * 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.
2774    * </pre>
2775    *
2776    * <code>optional string name = 3373707;</code>
2777    *
2778    * @return The bytes for name.
2779    */
2780   @java.lang.Override
getNameBytes()2781   public com.google.protobuf.ByteString getNameBytes() {
2782     java.lang.Object ref = name_;
2783     if (ref instanceof java.lang.String) {
2784       com.google.protobuf.ByteString b =
2785           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
2786       name_ = b;
2787       return b;
2788     } else {
2789       return (com.google.protobuf.ByteString) ref;
2790     }
2791   }
2792 
2793   public static final int NETWORK_FIELD_NUMBER = 232872494;
2794 
2795   @SuppressWarnings("serial")
2796   private volatile java.lang.Object network_ = "";
2797   /**
2798    *
2799    *
2800    * <pre>
2801    * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
2802    * </pre>
2803    *
2804    * <code>optional string network = 232872494;</code>
2805    *
2806    * @return Whether the network field is set.
2807    */
2808   @java.lang.Override
hasNetwork()2809   public boolean hasNetwork() {
2810     return ((bitField0_ & 0x00200000) != 0);
2811   }
2812   /**
2813    *
2814    *
2815    * <pre>
2816    * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
2817    * </pre>
2818    *
2819    * <code>optional string network = 232872494;</code>
2820    *
2821    * @return The network.
2822    */
2823   @java.lang.Override
getNetwork()2824   public java.lang.String getNetwork() {
2825     java.lang.Object ref = network_;
2826     if (ref instanceof java.lang.String) {
2827       return (java.lang.String) ref;
2828     } else {
2829       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
2830       java.lang.String s = bs.toStringUtf8();
2831       network_ = s;
2832       return s;
2833     }
2834   }
2835   /**
2836    *
2837    *
2838    * <pre>
2839    * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
2840    * </pre>
2841    *
2842    * <code>optional string network = 232872494;</code>
2843    *
2844    * @return The bytes for network.
2845    */
2846   @java.lang.Override
getNetworkBytes()2847   public com.google.protobuf.ByteString getNetworkBytes() {
2848     java.lang.Object ref = network_;
2849     if (ref instanceof java.lang.String) {
2850       com.google.protobuf.ByteString b =
2851           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
2852       network_ = b;
2853       return b;
2854     } else {
2855       return (com.google.protobuf.ByteString) ref;
2856     }
2857   }
2858 
2859   public static final int OUTLIER_DETECTION_FIELD_NUMBER = 354625086;
2860   private com.google.cloud.compute.v1.OutlierDetection outlierDetection_;
2861   /**
2862    *
2863    *
2864    * <pre>
2865    * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
2866    * </pre>
2867    *
2868    * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;</code>
2869    *
2870    * @return Whether the outlierDetection field is set.
2871    */
2872   @java.lang.Override
hasOutlierDetection()2873   public boolean hasOutlierDetection() {
2874     return ((bitField0_ & 0x00400000) != 0);
2875   }
2876   /**
2877    *
2878    *
2879    * <pre>
2880    * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
2881    * </pre>
2882    *
2883    * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;</code>
2884    *
2885    * @return The outlierDetection.
2886    */
2887   @java.lang.Override
getOutlierDetection()2888   public com.google.cloud.compute.v1.OutlierDetection getOutlierDetection() {
2889     return outlierDetection_ == null
2890         ? com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance()
2891         : outlierDetection_;
2892   }
2893   /**
2894    *
2895    *
2896    * <pre>
2897    * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
2898    * </pre>
2899    *
2900    * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;</code>
2901    */
2902   @java.lang.Override
getOutlierDetectionOrBuilder()2903   public com.google.cloud.compute.v1.OutlierDetectionOrBuilder getOutlierDetectionOrBuilder() {
2904     return outlierDetection_ == null
2905         ? com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance()
2906         : outlierDetection_;
2907   }
2908 
2909   public static final int PORT_FIELD_NUMBER = 3446913;
2910   private int port_ = 0;
2911   /**
2912    *
2913    *
2914    * <pre>
2915    * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port.
2916    * </pre>
2917    *
2918    * <code>optional int32 port = 3446913;</code>
2919    *
2920    * @return Whether the port field is set.
2921    */
2922   @java.lang.Override
hasPort()2923   public boolean hasPort() {
2924     return ((bitField0_ & 0x00800000) != 0);
2925   }
2926   /**
2927    *
2928    *
2929    * <pre>
2930    * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port.
2931    * </pre>
2932    *
2933    * <code>optional int32 port = 3446913;</code>
2934    *
2935    * @return The port.
2936    */
2937   @java.lang.Override
getPort()2938   public int getPort() {
2939     return port_;
2940   }
2941 
2942   public static final int PORT_NAME_FIELD_NUMBER = 41534345;
2943 
2944   @SuppressWarnings("serial")
2945   private volatile java.lang.Object portName_ = "";
2946   /**
2947    *
2948    *
2949    * <pre>
2950    * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
2951    * </pre>
2952    *
2953    * <code>optional string port_name = 41534345;</code>
2954    *
2955    * @return Whether the portName field is set.
2956    */
2957   @java.lang.Override
hasPortName()2958   public boolean hasPortName() {
2959     return ((bitField0_ & 0x01000000) != 0);
2960   }
2961   /**
2962    *
2963    *
2964    * <pre>
2965    * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
2966    * </pre>
2967    *
2968    * <code>optional string port_name = 41534345;</code>
2969    *
2970    * @return The portName.
2971    */
2972   @java.lang.Override
getPortName()2973   public java.lang.String getPortName() {
2974     java.lang.Object ref = portName_;
2975     if (ref instanceof java.lang.String) {
2976       return (java.lang.String) ref;
2977     } else {
2978       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
2979       java.lang.String s = bs.toStringUtf8();
2980       portName_ = s;
2981       return s;
2982     }
2983   }
2984   /**
2985    *
2986    *
2987    * <pre>
2988    * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
2989    * </pre>
2990    *
2991    * <code>optional string port_name = 41534345;</code>
2992    *
2993    * @return The bytes for portName.
2994    */
2995   @java.lang.Override
getPortNameBytes()2996   public com.google.protobuf.ByteString getPortNameBytes() {
2997     java.lang.Object ref = portName_;
2998     if (ref instanceof java.lang.String) {
2999       com.google.protobuf.ByteString b =
3000           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
3001       portName_ = b;
3002       return b;
3003     } else {
3004       return (com.google.protobuf.ByteString) ref;
3005     }
3006   }
3007 
3008   public static final int PROTOCOL_FIELD_NUMBER = 84577944;
3009 
3010   @SuppressWarnings("serial")
3011   private volatile java.lang.Object protocol_ = "";
3012   /**
3013    *
3014    *
3015    * <pre>
3016    * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
3017    * Check the Protocol enum for the list of possible values.
3018    * </pre>
3019    *
3020    * <code>optional string protocol = 84577944;</code>
3021    *
3022    * @return Whether the protocol field is set.
3023    */
3024   @java.lang.Override
hasProtocol()3025   public boolean hasProtocol() {
3026     return ((bitField0_ & 0x02000000) != 0);
3027   }
3028   /**
3029    *
3030    *
3031    * <pre>
3032    * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
3033    * Check the Protocol enum for the list of possible values.
3034    * </pre>
3035    *
3036    * <code>optional string protocol = 84577944;</code>
3037    *
3038    * @return The protocol.
3039    */
3040   @java.lang.Override
getProtocol()3041   public java.lang.String getProtocol() {
3042     java.lang.Object ref = protocol_;
3043     if (ref instanceof java.lang.String) {
3044       return (java.lang.String) ref;
3045     } else {
3046       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
3047       java.lang.String s = bs.toStringUtf8();
3048       protocol_ = s;
3049       return s;
3050     }
3051   }
3052   /**
3053    *
3054    *
3055    * <pre>
3056    * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
3057    * Check the Protocol enum for the list of possible values.
3058    * </pre>
3059    *
3060    * <code>optional string protocol = 84577944;</code>
3061    *
3062    * @return The bytes for protocol.
3063    */
3064   @java.lang.Override
getProtocolBytes()3065   public com.google.protobuf.ByteString getProtocolBytes() {
3066     java.lang.Object ref = protocol_;
3067     if (ref instanceof java.lang.String) {
3068       com.google.protobuf.ByteString b =
3069           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
3070       protocol_ = b;
3071       return b;
3072     } else {
3073       return (com.google.protobuf.ByteString) ref;
3074     }
3075   }
3076 
3077   public static final int REGION_FIELD_NUMBER = 138946292;
3078 
3079   @SuppressWarnings("serial")
3080   private volatile java.lang.Object region_ = "";
3081   /**
3082    *
3083    *
3084    * <pre>
3085    * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
3086    * </pre>
3087    *
3088    * <code>optional string region = 138946292;</code>
3089    *
3090    * @return Whether the region field is set.
3091    */
3092   @java.lang.Override
hasRegion()3093   public boolean hasRegion() {
3094     return ((bitField0_ & 0x04000000) != 0);
3095   }
3096   /**
3097    *
3098    *
3099    * <pre>
3100    * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
3101    * </pre>
3102    *
3103    * <code>optional string region = 138946292;</code>
3104    *
3105    * @return The region.
3106    */
3107   @java.lang.Override
getRegion()3108   public java.lang.String getRegion() {
3109     java.lang.Object ref = region_;
3110     if (ref instanceof java.lang.String) {
3111       return (java.lang.String) ref;
3112     } else {
3113       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
3114       java.lang.String s = bs.toStringUtf8();
3115       region_ = s;
3116       return s;
3117     }
3118   }
3119   /**
3120    *
3121    *
3122    * <pre>
3123    * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
3124    * </pre>
3125    *
3126    * <code>optional string region = 138946292;</code>
3127    *
3128    * @return The bytes for region.
3129    */
3130   @java.lang.Override
getRegionBytes()3131   public com.google.protobuf.ByteString getRegionBytes() {
3132     java.lang.Object ref = region_;
3133     if (ref instanceof java.lang.String) {
3134       com.google.protobuf.ByteString b =
3135           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
3136       region_ = b;
3137       return b;
3138     } else {
3139       return (com.google.protobuf.ByteString) ref;
3140     }
3141   }
3142 
3143   public static final int SECURITY_POLICY_FIELD_NUMBER = 171082513;
3144 
3145   @SuppressWarnings("serial")
3146   private volatile java.lang.Object securityPolicy_ = "";
3147   /**
3148    *
3149    *
3150    * <pre>
3151    * [Output Only] The resource URL for the security policy associated with this backend service.
3152    * </pre>
3153    *
3154    * <code>optional string security_policy = 171082513;</code>
3155    *
3156    * @return Whether the securityPolicy field is set.
3157    */
3158   @java.lang.Override
hasSecurityPolicy()3159   public boolean hasSecurityPolicy() {
3160     return ((bitField0_ & 0x08000000) != 0);
3161   }
3162   /**
3163    *
3164    *
3165    * <pre>
3166    * [Output Only] The resource URL for the security policy associated with this backend service.
3167    * </pre>
3168    *
3169    * <code>optional string security_policy = 171082513;</code>
3170    *
3171    * @return The securityPolicy.
3172    */
3173   @java.lang.Override
getSecurityPolicy()3174   public java.lang.String getSecurityPolicy() {
3175     java.lang.Object ref = securityPolicy_;
3176     if (ref instanceof java.lang.String) {
3177       return (java.lang.String) ref;
3178     } else {
3179       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
3180       java.lang.String s = bs.toStringUtf8();
3181       securityPolicy_ = s;
3182       return s;
3183     }
3184   }
3185   /**
3186    *
3187    *
3188    * <pre>
3189    * [Output Only] The resource URL for the security policy associated with this backend service.
3190    * </pre>
3191    *
3192    * <code>optional string security_policy = 171082513;</code>
3193    *
3194    * @return The bytes for securityPolicy.
3195    */
3196   @java.lang.Override
getSecurityPolicyBytes()3197   public com.google.protobuf.ByteString getSecurityPolicyBytes() {
3198     java.lang.Object ref = securityPolicy_;
3199     if (ref instanceof java.lang.String) {
3200       com.google.protobuf.ByteString b =
3201           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
3202       securityPolicy_ = b;
3203       return b;
3204     } else {
3205       return (com.google.protobuf.ByteString) ref;
3206     }
3207   }
3208 
3209   public static final int SECURITY_SETTINGS_FIELD_NUMBER = 478649922;
3210   private com.google.cloud.compute.v1.SecuritySettings securitySettings_;
3211   /**
3212    *
3213    *
3214    * <pre>
3215    * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
3216    * </pre>
3217    *
3218    * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;</code>
3219    *
3220    * @return Whether the securitySettings field is set.
3221    */
3222   @java.lang.Override
hasSecuritySettings()3223   public boolean hasSecuritySettings() {
3224     return ((bitField0_ & 0x10000000) != 0);
3225   }
3226   /**
3227    *
3228    *
3229    * <pre>
3230    * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
3231    * </pre>
3232    *
3233    * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;</code>
3234    *
3235    * @return The securitySettings.
3236    */
3237   @java.lang.Override
getSecuritySettings()3238   public com.google.cloud.compute.v1.SecuritySettings getSecuritySettings() {
3239     return securitySettings_ == null
3240         ? com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance()
3241         : securitySettings_;
3242   }
3243   /**
3244    *
3245    *
3246    * <pre>
3247    * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
3248    * </pre>
3249    *
3250    * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;</code>
3251    */
3252   @java.lang.Override
getSecuritySettingsOrBuilder()3253   public com.google.cloud.compute.v1.SecuritySettingsOrBuilder getSecuritySettingsOrBuilder() {
3254     return securitySettings_ == null
3255         ? com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance()
3256         : securitySettings_;
3257   }
3258 
3259   public static final int SELF_LINK_FIELD_NUMBER = 456214797;
3260 
3261   @SuppressWarnings("serial")
3262   private volatile java.lang.Object selfLink_ = "";
3263   /**
3264    *
3265    *
3266    * <pre>
3267    * [Output Only] Server-defined URL for the resource.
3268    * </pre>
3269    *
3270    * <code>optional string self_link = 456214797;</code>
3271    *
3272    * @return Whether the selfLink field is set.
3273    */
3274   @java.lang.Override
hasSelfLink()3275   public boolean hasSelfLink() {
3276     return ((bitField0_ & 0x20000000) != 0);
3277   }
3278   /**
3279    *
3280    *
3281    * <pre>
3282    * [Output Only] Server-defined URL for the resource.
3283    * </pre>
3284    *
3285    * <code>optional string self_link = 456214797;</code>
3286    *
3287    * @return The selfLink.
3288    */
3289   @java.lang.Override
getSelfLink()3290   public java.lang.String getSelfLink() {
3291     java.lang.Object ref = selfLink_;
3292     if (ref instanceof java.lang.String) {
3293       return (java.lang.String) ref;
3294     } else {
3295       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
3296       java.lang.String s = bs.toStringUtf8();
3297       selfLink_ = s;
3298       return s;
3299     }
3300   }
3301   /**
3302    *
3303    *
3304    * <pre>
3305    * [Output Only] Server-defined URL for the resource.
3306    * </pre>
3307    *
3308    * <code>optional string self_link = 456214797;</code>
3309    *
3310    * @return The bytes for selfLink.
3311    */
3312   @java.lang.Override
getSelfLinkBytes()3313   public com.google.protobuf.ByteString getSelfLinkBytes() {
3314     java.lang.Object ref = selfLink_;
3315     if (ref instanceof java.lang.String) {
3316       com.google.protobuf.ByteString b =
3317           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
3318       selfLink_ = b;
3319       return b;
3320     } else {
3321       return (com.google.protobuf.ByteString) ref;
3322     }
3323   }
3324 
3325   public static final int SERVICE_BINDINGS_FIELD_NUMBER = 133581016;
3326 
3327   @SuppressWarnings("serial")
3328   private com.google.protobuf.LazyStringList serviceBindings_;
3329   /**
3330    *
3331    *
3332    * <pre>
3333    * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
3334    * </pre>
3335    *
3336    * <code>repeated string service_bindings = 133581016;</code>
3337    *
3338    * @return A list containing the serviceBindings.
3339    */
getServiceBindingsList()3340   public com.google.protobuf.ProtocolStringList getServiceBindingsList() {
3341     return serviceBindings_;
3342   }
3343   /**
3344    *
3345    *
3346    * <pre>
3347    * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
3348    * </pre>
3349    *
3350    * <code>repeated string service_bindings = 133581016;</code>
3351    *
3352    * @return The count of serviceBindings.
3353    */
getServiceBindingsCount()3354   public int getServiceBindingsCount() {
3355     return serviceBindings_.size();
3356   }
3357   /**
3358    *
3359    *
3360    * <pre>
3361    * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
3362    * </pre>
3363    *
3364    * <code>repeated string service_bindings = 133581016;</code>
3365    *
3366    * @param index The index of the element to return.
3367    * @return The serviceBindings at the given index.
3368    */
getServiceBindings(int index)3369   public java.lang.String getServiceBindings(int index) {
3370     return serviceBindings_.get(index);
3371   }
3372   /**
3373    *
3374    *
3375    * <pre>
3376    * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
3377    * </pre>
3378    *
3379    * <code>repeated string service_bindings = 133581016;</code>
3380    *
3381    * @param index The index of the value to return.
3382    * @return The bytes of the serviceBindings at the given index.
3383    */
getServiceBindingsBytes(int index)3384   public com.google.protobuf.ByteString getServiceBindingsBytes(int index) {
3385     return serviceBindings_.getByteString(index);
3386   }
3387 
3388   public static final int SESSION_AFFINITY_FIELD_NUMBER = 463888561;
3389 
3390   @SuppressWarnings("serial")
3391   private volatile java.lang.Object sessionAffinity_ = "";
3392   /**
3393    *
3394    *
3395    * <pre>
3396    * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
3397    * Check the SessionAffinity enum for the list of possible values.
3398    * </pre>
3399    *
3400    * <code>optional string session_affinity = 463888561;</code>
3401    *
3402    * @return Whether the sessionAffinity field is set.
3403    */
3404   @java.lang.Override
hasSessionAffinity()3405   public boolean hasSessionAffinity() {
3406     return ((bitField0_ & 0x40000000) != 0);
3407   }
3408   /**
3409    *
3410    *
3411    * <pre>
3412    * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
3413    * Check the SessionAffinity enum for the list of possible values.
3414    * </pre>
3415    *
3416    * <code>optional string session_affinity = 463888561;</code>
3417    *
3418    * @return The sessionAffinity.
3419    */
3420   @java.lang.Override
getSessionAffinity()3421   public java.lang.String getSessionAffinity() {
3422     java.lang.Object ref = sessionAffinity_;
3423     if (ref instanceof java.lang.String) {
3424       return (java.lang.String) ref;
3425     } else {
3426       com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
3427       java.lang.String s = bs.toStringUtf8();
3428       sessionAffinity_ = s;
3429       return s;
3430     }
3431   }
3432   /**
3433    *
3434    *
3435    * <pre>
3436    * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
3437    * Check the SessionAffinity enum for the list of possible values.
3438    * </pre>
3439    *
3440    * <code>optional string session_affinity = 463888561;</code>
3441    *
3442    * @return The bytes for sessionAffinity.
3443    */
3444   @java.lang.Override
getSessionAffinityBytes()3445   public com.google.protobuf.ByteString getSessionAffinityBytes() {
3446     java.lang.Object ref = sessionAffinity_;
3447     if (ref instanceof java.lang.String) {
3448       com.google.protobuf.ByteString b =
3449           com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
3450       sessionAffinity_ = b;
3451       return b;
3452     } else {
3453       return (com.google.protobuf.ByteString) ref;
3454     }
3455   }
3456 
3457   public static final int SUBSETTING_FIELD_NUMBER = 450283536;
3458   private com.google.cloud.compute.v1.Subsetting subsetting_;
3459   /**
3460    * <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code>
3461    *
3462    * @return Whether the subsetting field is set.
3463    */
3464   @java.lang.Override
hasSubsetting()3465   public boolean hasSubsetting() {
3466     return ((bitField0_ & 0x80000000) != 0);
3467   }
3468   /**
3469    * <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code>
3470    *
3471    * @return The subsetting.
3472    */
3473   @java.lang.Override
getSubsetting()3474   public com.google.cloud.compute.v1.Subsetting getSubsetting() {
3475     return subsetting_ == null
3476         ? com.google.cloud.compute.v1.Subsetting.getDefaultInstance()
3477         : subsetting_;
3478   }
3479   /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */
3480   @java.lang.Override
getSubsettingOrBuilder()3481   public com.google.cloud.compute.v1.SubsettingOrBuilder getSubsettingOrBuilder() {
3482     return subsetting_ == null
3483         ? com.google.cloud.compute.v1.Subsetting.getDefaultInstance()
3484         : subsetting_;
3485   }
3486 
3487   public static final int TIMEOUT_SEC_FIELD_NUMBER = 79994995;
3488   private int timeoutSec_ = 0;
3489   /**
3490    *
3491    *
3492    * <pre>
3493    * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration.
3494    * </pre>
3495    *
3496    * <code>optional int32 timeout_sec = 79994995;</code>
3497    *
3498    * @return Whether the timeoutSec field is set.
3499    */
3500   @java.lang.Override
hasTimeoutSec()3501   public boolean hasTimeoutSec() {
3502     return ((bitField1_ & 0x00000001) != 0);
3503   }
3504   /**
3505    *
3506    *
3507    * <pre>
3508    * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration.
3509    * </pre>
3510    *
3511    * <code>optional int32 timeout_sec = 79994995;</code>
3512    *
3513    * @return The timeoutSec.
3514    */
3515   @java.lang.Override
getTimeoutSec()3516   public int getTimeoutSec() {
3517     return timeoutSec_;
3518   }
3519 
3520   private byte memoizedIsInitialized = -1;
3521 
3522   @java.lang.Override
isInitialized()3523   public final boolean isInitialized() {
3524     byte isInitialized = memoizedIsInitialized;
3525     if (isInitialized == 1) return true;
3526     if (isInitialized == 0) return false;
3527 
3528     memoizedIsInitialized = 1;
3529     return true;
3530   }
3531 
3532   @java.lang.Override
writeTo(com.google.protobuf.CodedOutputStream output)3533   public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException {
3534     if (((bitField0_ & 0x00004000) != 0)) {
3535       output.writeUInt64(3355, id_);
3536     }
3537     if (((bitField0_ & 0x00002000) != 0)) {
3538       output.writeMessage(104024, getIap());
3539     }
3540     if (((bitField0_ & 0x00000040) != 0)) {
3541       output.writeMessage(905883, getConsistentHash());
3542     }
3543     if (((bitField0_ & 0x00008000) != 0)) {
3544       com.google.protobuf.GeneratedMessageV3.writeString(output, 3292052, kind_);
3545     }
3546     if (((bitField0_ & 0x00100000) != 0)) {
3547       com.google.protobuf.GeneratedMessageV3.writeString(output, 3373707, name_);
3548     }
3549     if (((bitField0_ & 0x00800000) != 0)) {
3550       output.writeInt32(3446913, port_);
3551     }
3552     for (int i = 0; i < customRequestHeaders_.size(); i++) {
3553       com.google.protobuf.GeneratedMessageV3.writeString(
3554           output, 27977992, customRequestHeaders_.getRaw(i));
3555     }
3556     if (((bitField0_ & 0x00000080) != 0)) {
3557       com.google.protobuf.GeneratedMessageV3.writeString(output, 30525366, creationTimestamp_);
3558     }
3559     if (((bitField0_ & 0x00000200) != 0)) {
3560       com.google.protobuf.GeneratedMessageV3.writeString(output, 41036943, edgeSecurityPolicy_);
3561     }
3562     if (((bitField0_ & 0x01000000) != 0)) {
3563       com.google.protobuf.GeneratedMessageV3.writeString(output, 41534345, portName_);
3564     }
3565     if (((bitField0_ & 0x00080000) != 0)) {
3566       output.writeMessage(61428376, getMaxStreamDuration());
3567     }
3568     if (((bitField1_ & 0x00000001) != 0)) {
3569       output.writeInt32(79994995, timeoutSec_);
3570     }
3571     if (((bitField0_ & 0x02000000) != 0)) {
3572       com.google.protobuf.GeneratedMessageV3.writeString(output, 84577944, protocol_);
3573     }
3574     if (((bitField0_ & 0x00000008) != 0)) {
3575       com.google.protobuf.GeneratedMessageV3.writeString(output, 95520988, compressionMode_);
3576     }
3577     if (((bitField0_ & 0x00000800) != 0)) {
3578       output.writeMessage(105658655, getFailoverPolicy());
3579     }
3580     if (((bitField0_ & 0x00020000) != 0)) {
3581       com.google.protobuf.GeneratedMessageV3.writeString(output, 131431487, localityLbPolicy_);
3582     }
3583     for (int i = 0; i < serviceBindings_.size(); i++) {
3584       com.google.protobuf.GeneratedMessageV3.writeString(
3585           output, 133581016, serviceBindings_.getRaw(i));
3586     }
3587     if (((bitField0_ & 0x04000000) != 0)) {
3588       com.google.protobuf.GeneratedMessageV3.writeString(output, 138946292, region_);
3589     }
3590     for (int i = 0; i < localityLbPolicies_.size(); i++) {
3591       output.writeMessage(140982557, localityLbPolicies_.get(i));
3592     }
3593     if (((bitField0_ & 0x00000020) != 0)) {
3594       output.writeMessage(143994969, getConnectionTrackingPolicy());
3595     }
3596     if (((bitField0_ & 0x08000000) != 0)) {
3597       com.google.protobuf.GeneratedMessageV3.writeString(output, 171082513, securityPolicy_);
3598     }
3599     if (((bitField0_ & 0x00000002) != 0)) {
3600       output.writeMessage(213976452, getCdnPolicy());
3601     }
3602     if (((bitField0_ & 0x00200000) != 0)) {
3603       com.google.protobuf.GeneratedMessageV3.writeString(output, 232872494, network_);
3604     }
3605     if (((bitField0_ & 0x00001000) != 0)) {
3606       com.google.protobuf.GeneratedMessageV3.writeString(output, 234678500, fingerprint_);
3607     }
3608     if (((bitField0_ & 0x00000400) != 0)) {
3609       output.writeBool(250733499, enableCDN_);
3610     }
3611     if (((bitField0_ & 0x00040000) != 0)) {
3612       output.writeMessage(351299741, getLogConfig());
3613     }
3614     if (((bitField0_ & 0x00400000) != 0)) {
3615       output.writeMessage(354625086, getOutlierDetection());
3616     }
3617     if (((bitField0_ & 0x00010000) != 0)) {
3618       com.google.protobuf.GeneratedMessageV3.writeString(output, 363890244, loadBalancingScheme_);
3619     }
3620     if (((bitField0_ & 0x00000001) != 0)) {
3621       output.writeInt32(369996954, affinityCookieTtlSec_);
3622     }
3623     for (int i = 0; i < customResponseHeaders_.size(); i++) {
3624       com.google.protobuf.GeneratedMessageV3.writeString(
3625           output, 387539094, customResponseHeaders_.getRaw(i));
3626     }
3627     if (((bitField0_ & 0x00000004) != 0)) {
3628       output.writeMessage(421340061, getCircuitBreakers());
3629     }
3630     if (((bitField0_ & 0x00000100) != 0)) {
3631       com.google.protobuf.GeneratedMessageV3.writeString(output, 422937596, description_);
3632     }
3633     for (int i = 0; i < healthChecks_.size(); i++) {
3634       com.google.protobuf.GeneratedMessageV3.writeString(
3635           output, 448370606, healthChecks_.getRaw(i));
3636     }
3637     if (((bitField0_ & 0x80000000) != 0)) {
3638       output.writeMessage(450283536, getSubsetting());
3639     }
3640     if (((bitField0_ & 0x20000000) != 0)) {
3641       com.google.protobuf.GeneratedMessageV3.writeString(output, 456214797, selfLink_);
3642     }
3643     if (((bitField0_ & 0x00000010) != 0)) {
3644       output.writeMessage(461096747, getConnectionDraining());
3645     }
3646     if (((bitField0_ & 0x40000000) != 0)) {
3647       com.google.protobuf.GeneratedMessageV3.writeString(output, 463888561, sessionAffinity_);
3648     }
3649     if (((bitField0_ & 0x10000000) != 0)) {
3650       output.writeMessage(478649922, getSecuritySettings());
3651     }
3652     for (int i = 0; i < backends_.size(); i++) {
3653       output.writeMessage(510839903, backends_.get(i));
3654     }
3655     getUnknownFields().writeTo(output);
3656   }
3657 
3658   @java.lang.Override
getSerializedSize()3659   public int getSerializedSize() {
3660     int size = memoizedSize;
3661     if (size != -1) return size;
3662 
3663     size = 0;
3664     if (((bitField0_ & 0x00004000) != 0)) {
3665       size += com.google.protobuf.CodedOutputStream.computeUInt64Size(3355, id_);
3666     }
3667     if (((bitField0_ & 0x00002000) != 0)) {
3668       size += com.google.protobuf.CodedOutputStream.computeMessageSize(104024, getIap());
3669     }
3670     if (((bitField0_ & 0x00000040) != 0)) {
3671       size += com.google.protobuf.CodedOutputStream.computeMessageSize(905883, getConsistentHash());
3672     }
3673     if (((bitField0_ & 0x00008000) != 0)) {
3674       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3292052, kind_);
3675     }
3676     if (((bitField0_ & 0x00100000) != 0)) {
3677       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3373707, name_);
3678     }
3679     if (((bitField0_ & 0x00800000) != 0)) {
3680       size += com.google.protobuf.CodedOutputStream.computeInt32Size(3446913, port_);
3681     }
3682     {
3683       int dataSize = 0;
3684       for (int i = 0; i < customRequestHeaders_.size(); i++) {
3685         dataSize += computeStringSizeNoTag(customRequestHeaders_.getRaw(i));
3686       }
3687       size += dataSize;
3688       size += 4 * getCustomRequestHeadersList().size();
3689     }
3690     if (((bitField0_ & 0x00000080) != 0)) {
3691       size +=
3692           com.google.protobuf.GeneratedMessageV3.computeStringSize(30525366, creationTimestamp_);
3693     }
3694     if (((bitField0_ & 0x00000200) != 0)) {
3695       size +=
3696           com.google.protobuf.GeneratedMessageV3.computeStringSize(41036943, edgeSecurityPolicy_);
3697     }
3698     if (((bitField0_ & 0x01000000) != 0)) {
3699       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(41534345, portName_);
3700     }
3701     if (((bitField0_ & 0x00080000) != 0)) {
3702       size +=
3703           com.google.protobuf.CodedOutputStream.computeMessageSize(
3704               61428376, getMaxStreamDuration());
3705     }
3706     if (((bitField1_ & 0x00000001) != 0)) {
3707       size += com.google.protobuf.CodedOutputStream.computeInt32Size(79994995, timeoutSec_);
3708     }
3709     if (((bitField0_ & 0x02000000) != 0)) {
3710       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(84577944, protocol_);
3711     }
3712     if (((bitField0_ & 0x00000008) != 0)) {
3713       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(95520988, compressionMode_);
3714     }
3715     if (((bitField0_ & 0x00000800) != 0)) {
3716       size +=
3717           com.google.protobuf.CodedOutputStream.computeMessageSize(105658655, getFailoverPolicy());
3718     }
3719     if (((bitField0_ & 0x00020000) != 0)) {
3720       size +=
3721           com.google.protobuf.GeneratedMessageV3.computeStringSize(131431487, localityLbPolicy_);
3722     }
3723     {
3724       int dataSize = 0;
3725       for (int i = 0; i < serviceBindings_.size(); i++) {
3726         dataSize += computeStringSizeNoTag(serviceBindings_.getRaw(i));
3727       }
3728       size += dataSize;
3729       size += 5 * getServiceBindingsList().size();
3730     }
3731     if (((bitField0_ & 0x04000000) != 0)) {
3732       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(138946292, region_);
3733     }
3734     for (int i = 0; i < localityLbPolicies_.size(); i++) {
3735       size +=
3736           com.google.protobuf.CodedOutputStream.computeMessageSize(
3737               140982557, localityLbPolicies_.get(i));
3738     }
3739     if (((bitField0_ & 0x00000020) != 0)) {
3740       size +=
3741           com.google.protobuf.CodedOutputStream.computeMessageSize(
3742               143994969, getConnectionTrackingPolicy());
3743     }
3744     if (((bitField0_ & 0x08000000) != 0)) {
3745       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(171082513, securityPolicy_);
3746     }
3747     if (((bitField0_ & 0x00000002) != 0)) {
3748       size += com.google.protobuf.CodedOutputStream.computeMessageSize(213976452, getCdnPolicy());
3749     }
3750     if (((bitField0_ & 0x00200000) != 0)) {
3751       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(232872494, network_);
3752     }
3753     if (((bitField0_ & 0x00001000) != 0)) {
3754       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(234678500, fingerprint_);
3755     }
3756     if (((bitField0_ & 0x00000400) != 0)) {
3757       size += com.google.protobuf.CodedOutputStream.computeBoolSize(250733499, enableCDN_);
3758     }
3759     if (((bitField0_ & 0x00040000) != 0)) {
3760       size += com.google.protobuf.CodedOutputStream.computeMessageSize(351299741, getLogConfig());
3761     }
3762     if (((bitField0_ & 0x00400000) != 0)) {
3763       size +=
3764           com.google.protobuf.CodedOutputStream.computeMessageSize(
3765               354625086, getOutlierDetection());
3766     }
3767     if (((bitField0_ & 0x00010000) != 0)) {
3768       size +=
3769           com.google.protobuf.GeneratedMessageV3.computeStringSize(363890244, loadBalancingScheme_);
3770     }
3771     if (((bitField0_ & 0x00000001) != 0)) {
3772       size +=
3773           com.google.protobuf.CodedOutputStream.computeInt32Size(369996954, affinityCookieTtlSec_);
3774     }
3775     {
3776       int dataSize = 0;
3777       for (int i = 0; i < customResponseHeaders_.size(); i++) {
3778         dataSize += computeStringSizeNoTag(customResponseHeaders_.getRaw(i));
3779       }
3780       size += dataSize;
3781       size += 5 * getCustomResponseHeadersList().size();
3782     }
3783     if (((bitField0_ & 0x00000004) != 0)) {
3784       size +=
3785           com.google.protobuf.CodedOutputStream.computeMessageSize(421340061, getCircuitBreakers());
3786     }
3787     if (((bitField0_ & 0x00000100) != 0)) {
3788       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(422937596, description_);
3789     }
3790     {
3791       int dataSize = 0;
3792       for (int i = 0; i < healthChecks_.size(); i++) {
3793         dataSize += computeStringSizeNoTag(healthChecks_.getRaw(i));
3794       }
3795       size += dataSize;
3796       size += 5 * getHealthChecksList().size();
3797     }
3798     if (((bitField0_ & 0x80000000) != 0)) {
3799       size += com.google.protobuf.CodedOutputStream.computeMessageSize(450283536, getSubsetting());
3800     }
3801     if (((bitField0_ & 0x20000000) != 0)) {
3802       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(456214797, selfLink_);
3803     }
3804     if (((bitField0_ & 0x00000010) != 0)) {
3805       size +=
3806           com.google.protobuf.CodedOutputStream.computeMessageSize(
3807               461096747, getConnectionDraining());
3808     }
3809     if (((bitField0_ & 0x40000000) != 0)) {
3810       size += com.google.protobuf.GeneratedMessageV3.computeStringSize(463888561, sessionAffinity_);
3811     }
3812     if (((bitField0_ & 0x10000000) != 0)) {
3813       size +=
3814           com.google.protobuf.CodedOutputStream.computeMessageSize(
3815               478649922, getSecuritySettings());
3816     }
3817     for (int i = 0; i < backends_.size(); i++) {
3818       size += com.google.protobuf.CodedOutputStream.computeMessageSize(510839903, backends_.get(i));
3819     }
3820     size += getUnknownFields().getSerializedSize();
3821     memoizedSize = size;
3822     return size;
3823   }
3824 
3825   @java.lang.Override
equals(final java.lang.Object obj)3826   public boolean equals(final java.lang.Object obj) {
3827     if (obj == this) {
3828       return true;
3829     }
3830     if (!(obj instanceof com.google.cloud.compute.v1.BackendService)) {
3831       return super.equals(obj);
3832     }
3833     com.google.cloud.compute.v1.BackendService other =
3834         (com.google.cloud.compute.v1.BackendService) obj;
3835 
3836     if (hasAffinityCookieTtlSec() != other.hasAffinityCookieTtlSec()) return false;
3837     if (hasAffinityCookieTtlSec()) {
3838       if (getAffinityCookieTtlSec() != other.getAffinityCookieTtlSec()) return false;
3839     }
3840     if (!getBackendsList().equals(other.getBackendsList())) return false;
3841     if (hasCdnPolicy() != other.hasCdnPolicy()) return false;
3842     if (hasCdnPolicy()) {
3843       if (!getCdnPolicy().equals(other.getCdnPolicy())) return false;
3844     }
3845     if (hasCircuitBreakers() != other.hasCircuitBreakers()) return false;
3846     if (hasCircuitBreakers()) {
3847       if (!getCircuitBreakers().equals(other.getCircuitBreakers())) return false;
3848     }
3849     if (hasCompressionMode() != other.hasCompressionMode()) return false;
3850     if (hasCompressionMode()) {
3851       if (!getCompressionMode().equals(other.getCompressionMode())) return false;
3852     }
3853     if (hasConnectionDraining() != other.hasConnectionDraining()) return false;
3854     if (hasConnectionDraining()) {
3855       if (!getConnectionDraining().equals(other.getConnectionDraining())) return false;
3856     }
3857     if (hasConnectionTrackingPolicy() != other.hasConnectionTrackingPolicy()) return false;
3858     if (hasConnectionTrackingPolicy()) {
3859       if (!getConnectionTrackingPolicy().equals(other.getConnectionTrackingPolicy())) return false;
3860     }
3861     if (hasConsistentHash() != other.hasConsistentHash()) return false;
3862     if (hasConsistentHash()) {
3863       if (!getConsistentHash().equals(other.getConsistentHash())) return false;
3864     }
3865     if (hasCreationTimestamp() != other.hasCreationTimestamp()) return false;
3866     if (hasCreationTimestamp()) {
3867       if (!getCreationTimestamp().equals(other.getCreationTimestamp())) return false;
3868     }
3869     if (!getCustomRequestHeadersList().equals(other.getCustomRequestHeadersList())) return false;
3870     if (!getCustomResponseHeadersList().equals(other.getCustomResponseHeadersList())) return false;
3871     if (hasDescription() != other.hasDescription()) return false;
3872     if (hasDescription()) {
3873       if (!getDescription().equals(other.getDescription())) return false;
3874     }
3875     if (hasEdgeSecurityPolicy() != other.hasEdgeSecurityPolicy()) return false;
3876     if (hasEdgeSecurityPolicy()) {
3877       if (!getEdgeSecurityPolicy().equals(other.getEdgeSecurityPolicy())) return false;
3878     }
3879     if (hasEnableCDN() != other.hasEnableCDN()) return false;
3880     if (hasEnableCDN()) {
3881       if (getEnableCDN() != other.getEnableCDN()) return false;
3882     }
3883     if (hasFailoverPolicy() != other.hasFailoverPolicy()) return false;
3884     if (hasFailoverPolicy()) {
3885       if (!getFailoverPolicy().equals(other.getFailoverPolicy())) return false;
3886     }
3887     if (hasFingerprint() != other.hasFingerprint()) return false;
3888     if (hasFingerprint()) {
3889       if (!getFingerprint().equals(other.getFingerprint())) return false;
3890     }
3891     if (!getHealthChecksList().equals(other.getHealthChecksList())) return false;
3892     if (hasIap() != other.hasIap()) return false;
3893     if (hasIap()) {
3894       if (!getIap().equals(other.getIap())) return false;
3895     }
3896     if (hasId() != other.hasId()) return false;
3897     if (hasId()) {
3898       if (getId() != other.getId()) return false;
3899     }
3900     if (hasKind() != other.hasKind()) return false;
3901     if (hasKind()) {
3902       if (!getKind().equals(other.getKind())) return false;
3903     }
3904     if (hasLoadBalancingScheme() != other.hasLoadBalancingScheme()) return false;
3905     if (hasLoadBalancingScheme()) {
3906       if (!getLoadBalancingScheme().equals(other.getLoadBalancingScheme())) return false;
3907     }
3908     if (!getLocalityLbPoliciesList().equals(other.getLocalityLbPoliciesList())) return false;
3909     if (hasLocalityLbPolicy() != other.hasLocalityLbPolicy()) return false;
3910     if (hasLocalityLbPolicy()) {
3911       if (!getLocalityLbPolicy().equals(other.getLocalityLbPolicy())) return false;
3912     }
3913     if (hasLogConfig() != other.hasLogConfig()) return false;
3914     if (hasLogConfig()) {
3915       if (!getLogConfig().equals(other.getLogConfig())) return false;
3916     }
3917     if (hasMaxStreamDuration() != other.hasMaxStreamDuration()) return false;
3918     if (hasMaxStreamDuration()) {
3919       if (!getMaxStreamDuration().equals(other.getMaxStreamDuration())) return false;
3920     }
3921     if (hasName() != other.hasName()) return false;
3922     if (hasName()) {
3923       if (!getName().equals(other.getName())) return false;
3924     }
3925     if (hasNetwork() != other.hasNetwork()) return false;
3926     if (hasNetwork()) {
3927       if (!getNetwork().equals(other.getNetwork())) return false;
3928     }
3929     if (hasOutlierDetection() != other.hasOutlierDetection()) return false;
3930     if (hasOutlierDetection()) {
3931       if (!getOutlierDetection().equals(other.getOutlierDetection())) return false;
3932     }
3933     if (hasPort() != other.hasPort()) return false;
3934     if (hasPort()) {
3935       if (getPort() != other.getPort()) return false;
3936     }
3937     if (hasPortName() != other.hasPortName()) return false;
3938     if (hasPortName()) {
3939       if (!getPortName().equals(other.getPortName())) return false;
3940     }
3941     if (hasProtocol() != other.hasProtocol()) return false;
3942     if (hasProtocol()) {
3943       if (!getProtocol().equals(other.getProtocol())) return false;
3944     }
3945     if (hasRegion() != other.hasRegion()) return false;
3946     if (hasRegion()) {
3947       if (!getRegion().equals(other.getRegion())) return false;
3948     }
3949     if (hasSecurityPolicy() != other.hasSecurityPolicy()) return false;
3950     if (hasSecurityPolicy()) {
3951       if (!getSecurityPolicy().equals(other.getSecurityPolicy())) return false;
3952     }
3953     if (hasSecuritySettings() != other.hasSecuritySettings()) return false;
3954     if (hasSecuritySettings()) {
3955       if (!getSecuritySettings().equals(other.getSecuritySettings())) return false;
3956     }
3957     if (hasSelfLink() != other.hasSelfLink()) return false;
3958     if (hasSelfLink()) {
3959       if (!getSelfLink().equals(other.getSelfLink())) return false;
3960     }
3961     if (!getServiceBindingsList().equals(other.getServiceBindingsList())) return false;
3962     if (hasSessionAffinity() != other.hasSessionAffinity()) return false;
3963     if (hasSessionAffinity()) {
3964       if (!getSessionAffinity().equals(other.getSessionAffinity())) return false;
3965     }
3966     if (hasSubsetting() != other.hasSubsetting()) return false;
3967     if (hasSubsetting()) {
3968       if (!getSubsetting().equals(other.getSubsetting())) return false;
3969     }
3970     if (hasTimeoutSec() != other.hasTimeoutSec()) return false;
3971     if (hasTimeoutSec()) {
3972       if (getTimeoutSec() != other.getTimeoutSec()) return false;
3973     }
3974     if (!getUnknownFields().equals(other.getUnknownFields())) return false;
3975     return true;
3976   }
3977 
3978   @java.lang.Override
hashCode()3979   public int hashCode() {
3980     if (memoizedHashCode != 0) {
3981       return memoizedHashCode;
3982     }
3983     int hash = 41;
3984     hash = (19 * hash) + getDescriptor().hashCode();
3985     if (hasAffinityCookieTtlSec()) {
3986       hash = (37 * hash) + AFFINITY_COOKIE_TTL_SEC_FIELD_NUMBER;
3987       hash = (53 * hash) + getAffinityCookieTtlSec();
3988     }
3989     if (getBackendsCount() > 0) {
3990       hash = (37 * hash) + BACKENDS_FIELD_NUMBER;
3991       hash = (53 * hash) + getBackendsList().hashCode();
3992     }
3993     if (hasCdnPolicy()) {
3994       hash = (37 * hash) + CDN_POLICY_FIELD_NUMBER;
3995       hash = (53 * hash) + getCdnPolicy().hashCode();
3996     }
3997     if (hasCircuitBreakers()) {
3998       hash = (37 * hash) + CIRCUIT_BREAKERS_FIELD_NUMBER;
3999       hash = (53 * hash) + getCircuitBreakers().hashCode();
4000     }
4001     if (hasCompressionMode()) {
4002       hash = (37 * hash) + COMPRESSION_MODE_FIELD_NUMBER;
4003       hash = (53 * hash) + getCompressionMode().hashCode();
4004     }
4005     if (hasConnectionDraining()) {
4006       hash = (37 * hash) + CONNECTION_DRAINING_FIELD_NUMBER;
4007       hash = (53 * hash) + getConnectionDraining().hashCode();
4008     }
4009     if (hasConnectionTrackingPolicy()) {
4010       hash = (37 * hash) + CONNECTION_TRACKING_POLICY_FIELD_NUMBER;
4011       hash = (53 * hash) + getConnectionTrackingPolicy().hashCode();
4012     }
4013     if (hasConsistentHash()) {
4014       hash = (37 * hash) + CONSISTENT_HASH_FIELD_NUMBER;
4015       hash = (53 * hash) + getConsistentHash().hashCode();
4016     }
4017     if (hasCreationTimestamp()) {
4018       hash = (37 * hash) + CREATION_TIMESTAMP_FIELD_NUMBER;
4019       hash = (53 * hash) + getCreationTimestamp().hashCode();
4020     }
4021     if (getCustomRequestHeadersCount() > 0) {
4022       hash = (37 * hash) + CUSTOM_REQUEST_HEADERS_FIELD_NUMBER;
4023       hash = (53 * hash) + getCustomRequestHeadersList().hashCode();
4024     }
4025     if (getCustomResponseHeadersCount() > 0) {
4026       hash = (37 * hash) + CUSTOM_RESPONSE_HEADERS_FIELD_NUMBER;
4027       hash = (53 * hash) + getCustomResponseHeadersList().hashCode();
4028     }
4029     if (hasDescription()) {
4030       hash = (37 * hash) + DESCRIPTION_FIELD_NUMBER;
4031       hash = (53 * hash) + getDescription().hashCode();
4032     }
4033     if (hasEdgeSecurityPolicy()) {
4034       hash = (37 * hash) + EDGE_SECURITY_POLICY_FIELD_NUMBER;
4035       hash = (53 * hash) + getEdgeSecurityPolicy().hashCode();
4036     }
4037     if (hasEnableCDN()) {
4038       hash = (37 * hash) + ENABLE_C_D_N_FIELD_NUMBER;
4039       hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(getEnableCDN());
4040     }
4041     if (hasFailoverPolicy()) {
4042       hash = (37 * hash) + FAILOVER_POLICY_FIELD_NUMBER;
4043       hash = (53 * hash) + getFailoverPolicy().hashCode();
4044     }
4045     if (hasFingerprint()) {
4046       hash = (37 * hash) + FINGERPRINT_FIELD_NUMBER;
4047       hash = (53 * hash) + getFingerprint().hashCode();
4048     }
4049     if (getHealthChecksCount() > 0) {
4050       hash = (37 * hash) + HEALTH_CHECKS_FIELD_NUMBER;
4051       hash = (53 * hash) + getHealthChecksList().hashCode();
4052     }
4053     if (hasIap()) {
4054       hash = (37 * hash) + IAP_FIELD_NUMBER;
4055       hash = (53 * hash) + getIap().hashCode();
4056     }
4057     if (hasId()) {
4058       hash = (37 * hash) + ID_FIELD_NUMBER;
4059       hash = (53 * hash) + com.google.protobuf.Internal.hashLong(getId());
4060     }
4061     if (hasKind()) {
4062       hash = (37 * hash) + KIND_FIELD_NUMBER;
4063       hash = (53 * hash) + getKind().hashCode();
4064     }
4065     if (hasLoadBalancingScheme()) {
4066       hash = (37 * hash) + LOAD_BALANCING_SCHEME_FIELD_NUMBER;
4067       hash = (53 * hash) + getLoadBalancingScheme().hashCode();
4068     }
4069     if (getLocalityLbPoliciesCount() > 0) {
4070       hash = (37 * hash) + LOCALITY_LB_POLICIES_FIELD_NUMBER;
4071       hash = (53 * hash) + getLocalityLbPoliciesList().hashCode();
4072     }
4073     if (hasLocalityLbPolicy()) {
4074       hash = (37 * hash) + LOCALITY_LB_POLICY_FIELD_NUMBER;
4075       hash = (53 * hash) + getLocalityLbPolicy().hashCode();
4076     }
4077     if (hasLogConfig()) {
4078       hash = (37 * hash) + LOG_CONFIG_FIELD_NUMBER;
4079       hash = (53 * hash) + getLogConfig().hashCode();
4080     }
4081     if (hasMaxStreamDuration()) {
4082       hash = (37 * hash) + MAX_STREAM_DURATION_FIELD_NUMBER;
4083       hash = (53 * hash) + getMaxStreamDuration().hashCode();
4084     }
4085     if (hasName()) {
4086       hash = (37 * hash) + NAME_FIELD_NUMBER;
4087       hash = (53 * hash) + getName().hashCode();
4088     }
4089     if (hasNetwork()) {
4090       hash = (37 * hash) + NETWORK_FIELD_NUMBER;
4091       hash = (53 * hash) + getNetwork().hashCode();
4092     }
4093     if (hasOutlierDetection()) {
4094       hash = (37 * hash) + OUTLIER_DETECTION_FIELD_NUMBER;
4095       hash = (53 * hash) + getOutlierDetection().hashCode();
4096     }
4097     if (hasPort()) {
4098       hash = (37 * hash) + PORT_FIELD_NUMBER;
4099       hash = (53 * hash) + getPort();
4100     }
4101     if (hasPortName()) {
4102       hash = (37 * hash) + PORT_NAME_FIELD_NUMBER;
4103       hash = (53 * hash) + getPortName().hashCode();
4104     }
4105     if (hasProtocol()) {
4106       hash = (37 * hash) + PROTOCOL_FIELD_NUMBER;
4107       hash = (53 * hash) + getProtocol().hashCode();
4108     }
4109     if (hasRegion()) {
4110       hash = (37 * hash) + REGION_FIELD_NUMBER;
4111       hash = (53 * hash) + getRegion().hashCode();
4112     }
4113     if (hasSecurityPolicy()) {
4114       hash = (37 * hash) + SECURITY_POLICY_FIELD_NUMBER;
4115       hash = (53 * hash) + getSecurityPolicy().hashCode();
4116     }
4117     if (hasSecuritySettings()) {
4118       hash = (37 * hash) + SECURITY_SETTINGS_FIELD_NUMBER;
4119       hash = (53 * hash) + getSecuritySettings().hashCode();
4120     }
4121     if (hasSelfLink()) {
4122       hash = (37 * hash) + SELF_LINK_FIELD_NUMBER;
4123       hash = (53 * hash) + getSelfLink().hashCode();
4124     }
4125     if (getServiceBindingsCount() > 0) {
4126       hash = (37 * hash) + SERVICE_BINDINGS_FIELD_NUMBER;
4127       hash = (53 * hash) + getServiceBindingsList().hashCode();
4128     }
4129     if (hasSessionAffinity()) {
4130       hash = (37 * hash) + SESSION_AFFINITY_FIELD_NUMBER;
4131       hash = (53 * hash) + getSessionAffinity().hashCode();
4132     }
4133     if (hasSubsetting()) {
4134       hash = (37 * hash) + SUBSETTING_FIELD_NUMBER;
4135       hash = (53 * hash) + getSubsetting().hashCode();
4136     }
4137     if (hasTimeoutSec()) {
4138       hash = (37 * hash) + TIMEOUT_SEC_FIELD_NUMBER;
4139       hash = (53 * hash) + getTimeoutSec();
4140     }
4141     hash = (29 * hash) + getUnknownFields().hashCode();
4142     memoizedHashCode = hash;
4143     return hash;
4144   }
4145 
parseFrom(java.nio.ByteBuffer data)4146   public static com.google.cloud.compute.v1.BackendService parseFrom(java.nio.ByteBuffer data)
4147       throws com.google.protobuf.InvalidProtocolBufferException {
4148     return PARSER.parseFrom(data);
4149   }
4150 
parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4151   public static com.google.cloud.compute.v1.BackendService parseFrom(
4152       java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4153       throws com.google.protobuf.InvalidProtocolBufferException {
4154     return PARSER.parseFrom(data, extensionRegistry);
4155   }
4156 
parseFrom( com.google.protobuf.ByteString data)4157   public static com.google.cloud.compute.v1.BackendService parseFrom(
4158       com.google.protobuf.ByteString data)
4159       throws com.google.protobuf.InvalidProtocolBufferException {
4160     return PARSER.parseFrom(data);
4161   }
4162 
parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4163   public static com.google.cloud.compute.v1.BackendService parseFrom(
4164       com.google.protobuf.ByteString data,
4165       com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4166       throws com.google.protobuf.InvalidProtocolBufferException {
4167     return PARSER.parseFrom(data, extensionRegistry);
4168   }
4169 
parseFrom(byte[] data)4170   public static com.google.cloud.compute.v1.BackendService parseFrom(byte[] data)
4171       throws com.google.protobuf.InvalidProtocolBufferException {
4172     return PARSER.parseFrom(data);
4173   }
4174 
parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4175   public static com.google.cloud.compute.v1.BackendService parseFrom(
4176       byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4177       throws com.google.protobuf.InvalidProtocolBufferException {
4178     return PARSER.parseFrom(data, extensionRegistry);
4179   }
4180 
parseFrom(java.io.InputStream input)4181   public static com.google.cloud.compute.v1.BackendService parseFrom(java.io.InputStream input)
4182       throws java.io.IOException {
4183     return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input);
4184   }
4185 
parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4186   public static com.google.cloud.compute.v1.BackendService parseFrom(
4187       java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4188       throws java.io.IOException {
4189     return com.google.protobuf.GeneratedMessageV3.parseWithIOException(
4190         PARSER, input, extensionRegistry);
4191   }
4192 
parseDelimitedFrom( java.io.InputStream input)4193   public static com.google.cloud.compute.v1.BackendService parseDelimitedFrom(
4194       java.io.InputStream input) throws java.io.IOException {
4195     return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(PARSER, input);
4196   }
4197 
parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4198   public static com.google.cloud.compute.v1.BackendService parseDelimitedFrom(
4199       java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4200       throws java.io.IOException {
4201     return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(
4202         PARSER, input, extensionRegistry);
4203   }
4204 
parseFrom( com.google.protobuf.CodedInputStream input)4205   public static com.google.cloud.compute.v1.BackendService parseFrom(
4206       com.google.protobuf.CodedInputStream input) throws java.io.IOException {
4207     return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input);
4208   }
4209 
parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4210   public static com.google.cloud.compute.v1.BackendService parseFrom(
4211       com.google.protobuf.CodedInputStream input,
4212       com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4213       throws java.io.IOException {
4214     return com.google.protobuf.GeneratedMessageV3.parseWithIOException(
4215         PARSER, input, extensionRegistry);
4216   }
4217 
4218   @java.lang.Override
newBuilderForType()4219   public Builder newBuilderForType() {
4220     return newBuilder();
4221   }
4222 
newBuilder()4223   public static Builder newBuilder() {
4224     return DEFAULT_INSTANCE.toBuilder();
4225   }
4226 
newBuilder(com.google.cloud.compute.v1.BackendService prototype)4227   public static Builder newBuilder(com.google.cloud.compute.v1.BackendService prototype) {
4228     return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
4229   }
4230 
4231   @java.lang.Override
toBuilder()4232   public Builder toBuilder() {
4233     return this == DEFAULT_INSTANCE ? new Builder() : new Builder().mergeFrom(this);
4234   }
4235 
4236   @java.lang.Override
newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent)4237   protected Builder newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
4238     Builder builder = new Builder(parent);
4239     return builder;
4240   }
4241   /**
4242    *
4243    *
4244    * <pre>
4245    * Represents a Backend Service resource. A backend service defines how Google Cloud load balancers distribute traffic. The backend service configuration contains a set of values, such as the protocol used to connect to backends, various distribution and session settings, health checks, and timeouts. These settings provide fine-grained control over how your load balancer behaves. Most of the settings have default values that allow for easy configuration if you need to get started quickly. Backend services in Google Compute Engine can be either regionally or globally scoped. * [Global](https://cloud.google.com/compute/docs/reference/rest/v1/backendServices) * [Regional](https://cloud.google.com/compute/docs/reference/rest/v1/regionBackendServices) For more information, see Backend Services.
4246    * </pre>
4247    *
4248    * Protobuf type {@code google.cloud.compute.v1.BackendService}
4249    */
4250   public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder<Builder>
4251       implements
4252       // @@protoc_insertion_point(builder_implements:google.cloud.compute.v1.BackendService)
4253       com.google.cloud.compute.v1.BackendServiceOrBuilder {
getDescriptor()4254     public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
4255       return com.google.cloud.compute.v1.Compute
4256           .internal_static_google_cloud_compute_v1_BackendService_descriptor;
4257     }
4258 
4259     @java.lang.Override
4260     protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable()4261         internalGetFieldAccessorTable() {
4262       return com.google.cloud.compute.v1.Compute
4263           .internal_static_google_cloud_compute_v1_BackendService_fieldAccessorTable
4264           .ensureFieldAccessorsInitialized(
4265               com.google.cloud.compute.v1.BackendService.class,
4266               com.google.cloud.compute.v1.BackendService.Builder.class);
4267     }
4268 
4269     // Construct using com.google.cloud.compute.v1.BackendService.newBuilder()
Builder()4270     private Builder() {
4271       maybeForceBuilderInitialization();
4272     }
4273 
Builder(com.google.protobuf.GeneratedMessageV3.BuilderParent parent)4274     private Builder(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
4275       super(parent);
4276       maybeForceBuilderInitialization();
4277     }
4278 
maybeForceBuilderInitialization()4279     private void maybeForceBuilderInitialization() {
4280       if (com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders) {
4281         getBackendsFieldBuilder();
4282         getCdnPolicyFieldBuilder();
4283         getCircuitBreakersFieldBuilder();
4284         getConnectionDrainingFieldBuilder();
4285         getConnectionTrackingPolicyFieldBuilder();
4286         getConsistentHashFieldBuilder();
4287         getFailoverPolicyFieldBuilder();
4288         getIapFieldBuilder();
4289         getLocalityLbPoliciesFieldBuilder();
4290         getLogConfigFieldBuilder();
4291         getMaxStreamDurationFieldBuilder();
4292         getOutlierDetectionFieldBuilder();
4293         getSecuritySettingsFieldBuilder();
4294         getSubsettingFieldBuilder();
4295       }
4296     }
4297 
4298     @java.lang.Override
clear()4299     public Builder clear() {
4300       super.clear();
4301       bitField0_ = 0;
4302       bitField1_ = 0;
4303       affinityCookieTtlSec_ = 0;
4304       if (backendsBuilder_ == null) {
4305         backends_ = java.util.Collections.emptyList();
4306       } else {
4307         backends_ = null;
4308         backendsBuilder_.clear();
4309       }
4310       bitField0_ = (bitField0_ & ~0x00000002);
4311       cdnPolicy_ = null;
4312       if (cdnPolicyBuilder_ != null) {
4313         cdnPolicyBuilder_.dispose();
4314         cdnPolicyBuilder_ = null;
4315       }
4316       circuitBreakers_ = null;
4317       if (circuitBreakersBuilder_ != null) {
4318         circuitBreakersBuilder_.dispose();
4319         circuitBreakersBuilder_ = null;
4320       }
4321       compressionMode_ = "";
4322       connectionDraining_ = null;
4323       if (connectionDrainingBuilder_ != null) {
4324         connectionDrainingBuilder_.dispose();
4325         connectionDrainingBuilder_ = null;
4326       }
4327       connectionTrackingPolicy_ = null;
4328       if (connectionTrackingPolicyBuilder_ != null) {
4329         connectionTrackingPolicyBuilder_.dispose();
4330         connectionTrackingPolicyBuilder_ = null;
4331       }
4332       consistentHash_ = null;
4333       if (consistentHashBuilder_ != null) {
4334         consistentHashBuilder_.dispose();
4335         consistentHashBuilder_ = null;
4336       }
4337       creationTimestamp_ = "";
4338       customRequestHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY;
4339       bitField0_ = (bitField0_ & ~0x00000200);
4340       customResponseHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY;
4341       bitField0_ = (bitField0_ & ~0x00000400);
4342       description_ = "";
4343       edgeSecurityPolicy_ = "";
4344       enableCDN_ = false;
4345       failoverPolicy_ = null;
4346       if (failoverPolicyBuilder_ != null) {
4347         failoverPolicyBuilder_.dispose();
4348         failoverPolicyBuilder_ = null;
4349       }
4350       fingerprint_ = "";
4351       healthChecks_ = com.google.protobuf.LazyStringArrayList.EMPTY;
4352       bitField0_ = (bitField0_ & ~0x00010000);
4353       iap_ = null;
4354       if (iapBuilder_ != null) {
4355         iapBuilder_.dispose();
4356         iapBuilder_ = null;
4357       }
4358       id_ = 0L;
4359       kind_ = "";
4360       loadBalancingScheme_ = "";
4361       if (localityLbPoliciesBuilder_ == null) {
4362         localityLbPolicies_ = java.util.Collections.emptyList();
4363       } else {
4364         localityLbPolicies_ = null;
4365         localityLbPoliciesBuilder_.clear();
4366       }
4367       bitField0_ = (bitField0_ & ~0x00200000);
4368       localityLbPolicy_ = "";
4369       logConfig_ = null;
4370       if (logConfigBuilder_ != null) {
4371         logConfigBuilder_.dispose();
4372         logConfigBuilder_ = null;
4373       }
4374       maxStreamDuration_ = null;
4375       if (maxStreamDurationBuilder_ != null) {
4376         maxStreamDurationBuilder_.dispose();
4377         maxStreamDurationBuilder_ = null;
4378       }
4379       name_ = "";
4380       network_ = "";
4381       outlierDetection_ = null;
4382       if (outlierDetectionBuilder_ != null) {
4383         outlierDetectionBuilder_.dispose();
4384         outlierDetectionBuilder_ = null;
4385       }
4386       port_ = 0;
4387       portName_ = "";
4388       protocol_ = "";
4389       region_ = "";
4390       securityPolicy_ = "";
4391       securitySettings_ = null;
4392       if (securitySettingsBuilder_ != null) {
4393         securitySettingsBuilder_.dispose();
4394         securitySettingsBuilder_ = null;
4395       }
4396       selfLink_ = "";
4397       serviceBindings_ = com.google.protobuf.LazyStringArrayList.EMPTY;
4398       bitField1_ = (bitField1_ & ~0x00000008);
4399       sessionAffinity_ = "";
4400       subsetting_ = null;
4401       if (subsettingBuilder_ != null) {
4402         subsettingBuilder_.dispose();
4403         subsettingBuilder_ = null;
4404       }
4405       timeoutSec_ = 0;
4406       return this;
4407     }
4408 
4409     @java.lang.Override
getDescriptorForType()4410     public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
4411       return com.google.cloud.compute.v1.Compute
4412           .internal_static_google_cloud_compute_v1_BackendService_descriptor;
4413     }
4414 
4415     @java.lang.Override
getDefaultInstanceForType()4416     public com.google.cloud.compute.v1.BackendService getDefaultInstanceForType() {
4417       return com.google.cloud.compute.v1.BackendService.getDefaultInstance();
4418     }
4419 
4420     @java.lang.Override
build()4421     public com.google.cloud.compute.v1.BackendService build() {
4422       com.google.cloud.compute.v1.BackendService result = buildPartial();
4423       if (!result.isInitialized()) {
4424         throw newUninitializedMessageException(result);
4425       }
4426       return result;
4427     }
4428 
4429     @java.lang.Override
buildPartial()4430     public com.google.cloud.compute.v1.BackendService buildPartial() {
4431       com.google.cloud.compute.v1.BackendService result =
4432           new com.google.cloud.compute.v1.BackendService(this);
4433       buildPartialRepeatedFields(result);
4434       if (bitField0_ != 0) {
4435         buildPartial0(result);
4436       }
4437       if (bitField1_ != 0) {
4438         buildPartial1(result);
4439       }
4440       onBuilt();
4441       return result;
4442     }
4443 
buildPartialRepeatedFields(com.google.cloud.compute.v1.BackendService result)4444     private void buildPartialRepeatedFields(com.google.cloud.compute.v1.BackendService result) {
4445       if (backendsBuilder_ == null) {
4446         if (((bitField0_ & 0x00000002) != 0)) {
4447           backends_ = java.util.Collections.unmodifiableList(backends_);
4448           bitField0_ = (bitField0_ & ~0x00000002);
4449         }
4450         result.backends_ = backends_;
4451       } else {
4452         result.backends_ = backendsBuilder_.build();
4453       }
4454       if (((bitField0_ & 0x00000200) != 0)) {
4455         customRequestHeaders_ = customRequestHeaders_.getUnmodifiableView();
4456         bitField0_ = (bitField0_ & ~0x00000200);
4457       }
4458       result.customRequestHeaders_ = customRequestHeaders_;
4459       if (((bitField0_ & 0x00000400) != 0)) {
4460         customResponseHeaders_ = customResponseHeaders_.getUnmodifiableView();
4461         bitField0_ = (bitField0_ & ~0x00000400);
4462       }
4463       result.customResponseHeaders_ = customResponseHeaders_;
4464       if (((bitField0_ & 0x00010000) != 0)) {
4465         healthChecks_ = healthChecks_.getUnmodifiableView();
4466         bitField0_ = (bitField0_ & ~0x00010000);
4467       }
4468       result.healthChecks_ = healthChecks_;
4469       if (localityLbPoliciesBuilder_ == null) {
4470         if (((bitField0_ & 0x00200000) != 0)) {
4471           localityLbPolicies_ = java.util.Collections.unmodifiableList(localityLbPolicies_);
4472           bitField0_ = (bitField0_ & ~0x00200000);
4473         }
4474         result.localityLbPolicies_ = localityLbPolicies_;
4475       } else {
4476         result.localityLbPolicies_ = localityLbPoliciesBuilder_.build();
4477       }
4478       if (((bitField1_ & 0x00000008) != 0)) {
4479         serviceBindings_ = serviceBindings_.getUnmodifiableView();
4480         bitField1_ = (bitField1_ & ~0x00000008);
4481       }
4482       result.serviceBindings_ = serviceBindings_;
4483     }
4484 
buildPartial0(com.google.cloud.compute.v1.BackendService result)4485     private void buildPartial0(com.google.cloud.compute.v1.BackendService result) {
4486       int from_bitField0_ = bitField0_;
4487       int to_bitField0_ = 0;
4488       if (((from_bitField0_ & 0x00000001) != 0)) {
4489         result.affinityCookieTtlSec_ = affinityCookieTtlSec_;
4490         to_bitField0_ |= 0x00000001;
4491       }
4492       if (((from_bitField0_ & 0x00000004) != 0)) {
4493         result.cdnPolicy_ = cdnPolicyBuilder_ == null ? cdnPolicy_ : cdnPolicyBuilder_.build();
4494         to_bitField0_ |= 0x00000002;
4495       }
4496       if (((from_bitField0_ & 0x00000008) != 0)) {
4497         result.circuitBreakers_ =
4498             circuitBreakersBuilder_ == null ? circuitBreakers_ : circuitBreakersBuilder_.build();
4499         to_bitField0_ |= 0x00000004;
4500       }
4501       if (((from_bitField0_ & 0x00000010) != 0)) {
4502         result.compressionMode_ = compressionMode_;
4503         to_bitField0_ |= 0x00000008;
4504       }
4505       if (((from_bitField0_ & 0x00000020) != 0)) {
4506         result.connectionDraining_ =
4507             connectionDrainingBuilder_ == null
4508                 ? connectionDraining_
4509                 : connectionDrainingBuilder_.build();
4510         to_bitField0_ |= 0x00000010;
4511       }
4512       if (((from_bitField0_ & 0x00000040) != 0)) {
4513         result.connectionTrackingPolicy_ =
4514             connectionTrackingPolicyBuilder_ == null
4515                 ? connectionTrackingPolicy_
4516                 : connectionTrackingPolicyBuilder_.build();
4517         to_bitField0_ |= 0x00000020;
4518       }
4519       if (((from_bitField0_ & 0x00000080) != 0)) {
4520         result.consistentHash_ =
4521             consistentHashBuilder_ == null ? consistentHash_ : consistentHashBuilder_.build();
4522         to_bitField0_ |= 0x00000040;
4523       }
4524       if (((from_bitField0_ & 0x00000100) != 0)) {
4525         result.creationTimestamp_ = creationTimestamp_;
4526         to_bitField0_ |= 0x00000080;
4527       }
4528       if (((from_bitField0_ & 0x00000800) != 0)) {
4529         result.description_ = description_;
4530         to_bitField0_ |= 0x00000100;
4531       }
4532       if (((from_bitField0_ & 0x00001000) != 0)) {
4533         result.edgeSecurityPolicy_ = edgeSecurityPolicy_;
4534         to_bitField0_ |= 0x00000200;
4535       }
4536       if (((from_bitField0_ & 0x00002000) != 0)) {
4537         result.enableCDN_ = enableCDN_;
4538         to_bitField0_ |= 0x00000400;
4539       }
4540       if (((from_bitField0_ & 0x00004000) != 0)) {
4541         result.failoverPolicy_ =
4542             failoverPolicyBuilder_ == null ? failoverPolicy_ : failoverPolicyBuilder_.build();
4543         to_bitField0_ |= 0x00000800;
4544       }
4545       if (((from_bitField0_ & 0x00008000) != 0)) {
4546         result.fingerprint_ = fingerprint_;
4547         to_bitField0_ |= 0x00001000;
4548       }
4549       if (((from_bitField0_ & 0x00020000) != 0)) {
4550         result.iap_ = iapBuilder_ == null ? iap_ : iapBuilder_.build();
4551         to_bitField0_ |= 0x00002000;
4552       }
4553       if (((from_bitField0_ & 0x00040000) != 0)) {
4554         result.id_ = id_;
4555         to_bitField0_ |= 0x00004000;
4556       }
4557       if (((from_bitField0_ & 0x00080000) != 0)) {
4558         result.kind_ = kind_;
4559         to_bitField0_ |= 0x00008000;
4560       }
4561       if (((from_bitField0_ & 0x00100000) != 0)) {
4562         result.loadBalancingScheme_ = loadBalancingScheme_;
4563         to_bitField0_ |= 0x00010000;
4564       }
4565       if (((from_bitField0_ & 0x00400000) != 0)) {
4566         result.localityLbPolicy_ = localityLbPolicy_;
4567         to_bitField0_ |= 0x00020000;
4568       }
4569       if (((from_bitField0_ & 0x00800000) != 0)) {
4570         result.logConfig_ = logConfigBuilder_ == null ? logConfig_ : logConfigBuilder_.build();
4571         to_bitField0_ |= 0x00040000;
4572       }
4573       if (((from_bitField0_ & 0x01000000) != 0)) {
4574         result.maxStreamDuration_ =
4575             maxStreamDurationBuilder_ == null
4576                 ? maxStreamDuration_
4577                 : maxStreamDurationBuilder_.build();
4578         to_bitField0_ |= 0x00080000;
4579       }
4580       if (((from_bitField0_ & 0x02000000) != 0)) {
4581         result.name_ = name_;
4582         to_bitField0_ |= 0x00100000;
4583       }
4584       if (((from_bitField0_ & 0x04000000) != 0)) {
4585         result.network_ = network_;
4586         to_bitField0_ |= 0x00200000;
4587       }
4588       if (((from_bitField0_ & 0x08000000) != 0)) {
4589         result.outlierDetection_ =
4590             outlierDetectionBuilder_ == null ? outlierDetection_ : outlierDetectionBuilder_.build();
4591         to_bitField0_ |= 0x00400000;
4592       }
4593       if (((from_bitField0_ & 0x10000000) != 0)) {
4594         result.port_ = port_;
4595         to_bitField0_ |= 0x00800000;
4596       }
4597       if (((from_bitField0_ & 0x20000000) != 0)) {
4598         result.portName_ = portName_;
4599         to_bitField0_ |= 0x01000000;
4600       }
4601       if (((from_bitField0_ & 0x40000000) != 0)) {
4602         result.protocol_ = protocol_;
4603         to_bitField0_ |= 0x02000000;
4604       }
4605       if (((from_bitField0_ & 0x80000000) != 0)) {
4606         result.region_ = region_;
4607         to_bitField0_ |= 0x04000000;
4608       }
4609       result.bitField0_ |= to_bitField0_;
4610     }
4611 
buildPartial1(com.google.cloud.compute.v1.BackendService result)4612     private void buildPartial1(com.google.cloud.compute.v1.BackendService result) {
4613       int from_bitField1_ = bitField1_;
4614       int to_bitField0_ = 0;
4615       if (((from_bitField1_ & 0x00000001) != 0)) {
4616         result.securityPolicy_ = securityPolicy_;
4617         to_bitField0_ |= 0x08000000;
4618       }
4619       if (((from_bitField1_ & 0x00000002) != 0)) {
4620         result.securitySettings_ =
4621             securitySettingsBuilder_ == null ? securitySettings_ : securitySettingsBuilder_.build();
4622         to_bitField0_ |= 0x10000000;
4623       }
4624       if (((from_bitField1_ & 0x00000004) != 0)) {
4625         result.selfLink_ = selfLink_;
4626         to_bitField0_ |= 0x20000000;
4627       }
4628       if (((from_bitField1_ & 0x00000010) != 0)) {
4629         result.sessionAffinity_ = sessionAffinity_;
4630         to_bitField0_ |= 0x40000000;
4631       }
4632       if (((from_bitField1_ & 0x00000020) != 0)) {
4633         result.subsetting_ = subsettingBuilder_ == null ? subsetting_ : subsettingBuilder_.build();
4634         to_bitField0_ |= 0x80000000;
4635       }
4636       int to_bitField1_ = 0;
4637       if (((from_bitField1_ & 0x00000040) != 0)) {
4638         result.timeoutSec_ = timeoutSec_;
4639         to_bitField1_ |= 0x00000001;
4640       }
4641       result.bitField0_ |= to_bitField0_;
4642       result.bitField1_ |= to_bitField1_;
4643     }
4644 
4645     @java.lang.Override
clone()4646     public Builder clone() {
4647       return super.clone();
4648     }
4649 
4650     @java.lang.Override
setField( com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)4651     public Builder setField(
4652         com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) {
4653       return super.setField(field, value);
4654     }
4655 
4656     @java.lang.Override
clearField(com.google.protobuf.Descriptors.FieldDescriptor field)4657     public Builder clearField(com.google.protobuf.Descriptors.FieldDescriptor field) {
4658       return super.clearField(field);
4659     }
4660 
4661     @java.lang.Override
clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof)4662     public Builder clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof) {
4663       return super.clearOneof(oneof);
4664     }
4665 
4666     @java.lang.Override
setRepeatedField( com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value)4667     public Builder setRepeatedField(
4668         com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value) {
4669       return super.setRepeatedField(field, index, value);
4670     }
4671 
4672     @java.lang.Override
addRepeatedField( com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)4673     public Builder addRepeatedField(
4674         com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) {
4675       return super.addRepeatedField(field, value);
4676     }
4677 
4678     @java.lang.Override
mergeFrom(com.google.protobuf.Message other)4679     public Builder mergeFrom(com.google.protobuf.Message other) {
4680       if (other instanceof com.google.cloud.compute.v1.BackendService) {
4681         return mergeFrom((com.google.cloud.compute.v1.BackendService) other);
4682       } else {
4683         super.mergeFrom(other);
4684         return this;
4685       }
4686     }
4687 
mergeFrom(com.google.cloud.compute.v1.BackendService other)4688     public Builder mergeFrom(com.google.cloud.compute.v1.BackendService other) {
4689       if (other == com.google.cloud.compute.v1.BackendService.getDefaultInstance()) return this;
4690       if (other.hasAffinityCookieTtlSec()) {
4691         setAffinityCookieTtlSec(other.getAffinityCookieTtlSec());
4692       }
4693       if (backendsBuilder_ == null) {
4694         if (!other.backends_.isEmpty()) {
4695           if (backends_.isEmpty()) {
4696             backends_ = other.backends_;
4697             bitField0_ = (bitField0_ & ~0x00000002);
4698           } else {
4699             ensureBackendsIsMutable();
4700             backends_.addAll(other.backends_);
4701           }
4702           onChanged();
4703         }
4704       } else {
4705         if (!other.backends_.isEmpty()) {
4706           if (backendsBuilder_.isEmpty()) {
4707             backendsBuilder_.dispose();
4708             backendsBuilder_ = null;
4709             backends_ = other.backends_;
4710             bitField0_ = (bitField0_ & ~0x00000002);
4711             backendsBuilder_ =
4712                 com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders
4713                     ? getBackendsFieldBuilder()
4714                     : null;
4715           } else {
4716             backendsBuilder_.addAllMessages(other.backends_);
4717           }
4718         }
4719       }
4720       if (other.hasCdnPolicy()) {
4721         mergeCdnPolicy(other.getCdnPolicy());
4722       }
4723       if (other.hasCircuitBreakers()) {
4724         mergeCircuitBreakers(other.getCircuitBreakers());
4725       }
4726       if (other.hasCompressionMode()) {
4727         compressionMode_ = other.compressionMode_;
4728         bitField0_ |= 0x00000010;
4729         onChanged();
4730       }
4731       if (other.hasConnectionDraining()) {
4732         mergeConnectionDraining(other.getConnectionDraining());
4733       }
4734       if (other.hasConnectionTrackingPolicy()) {
4735         mergeConnectionTrackingPolicy(other.getConnectionTrackingPolicy());
4736       }
4737       if (other.hasConsistentHash()) {
4738         mergeConsistentHash(other.getConsistentHash());
4739       }
4740       if (other.hasCreationTimestamp()) {
4741         creationTimestamp_ = other.creationTimestamp_;
4742         bitField0_ |= 0x00000100;
4743         onChanged();
4744       }
4745       if (!other.customRequestHeaders_.isEmpty()) {
4746         if (customRequestHeaders_.isEmpty()) {
4747           customRequestHeaders_ = other.customRequestHeaders_;
4748           bitField0_ = (bitField0_ & ~0x00000200);
4749         } else {
4750           ensureCustomRequestHeadersIsMutable();
4751           customRequestHeaders_.addAll(other.customRequestHeaders_);
4752         }
4753         onChanged();
4754       }
4755       if (!other.customResponseHeaders_.isEmpty()) {
4756         if (customResponseHeaders_.isEmpty()) {
4757           customResponseHeaders_ = other.customResponseHeaders_;
4758           bitField0_ = (bitField0_ & ~0x00000400);
4759         } else {
4760           ensureCustomResponseHeadersIsMutable();
4761           customResponseHeaders_.addAll(other.customResponseHeaders_);
4762         }
4763         onChanged();
4764       }
4765       if (other.hasDescription()) {
4766         description_ = other.description_;
4767         bitField0_ |= 0x00000800;
4768         onChanged();
4769       }
4770       if (other.hasEdgeSecurityPolicy()) {
4771         edgeSecurityPolicy_ = other.edgeSecurityPolicy_;
4772         bitField0_ |= 0x00001000;
4773         onChanged();
4774       }
4775       if (other.hasEnableCDN()) {
4776         setEnableCDN(other.getEnableCDN());
4777       }
4778       if (other.hasFailoverPolicy()) {
4779         mergeFailoverPolicy(other.getFailoverPolicy());
4780       }
4781       if (other.hasFingerprint()) {
4782         fingerprint_ = other.fingerprint_;
4783         bitField0_ |= 0x00008000;
4784         onChanged();
4785       }
4786       if (!other.healthChecks_.isEmpty()) {
4787         if (healthChecks_.isEmpty()) {
4788           healthChecks_ = other.healthChecks_;
4789           bitField0_ = (bitField0_ & ~0x00010000);
4790         } else {
4791           ensureHealthChecksIsMutable();
4792           healthChecks_.addAll(other.healthChecks_);
4793         }
4794         onChanged();
4795       }
4796       if (other.hasIap()) {
4797         mergeIap(other.getIap());
4798       }
4799       if (other.hasId()) {
4800         setId(other.getId());
4801       }
4802       if (other.hasKind()) {
4803         kind_ = other.kind_;
4804         bitField0_ |= 0x00080000;
4805         onChanged();
4806       }
4807       if (other.hasLoadBalancingScheme()) {
4808         loadBalancingScheme_ = other.loadBalancingScheme_;
4809         bitField0_ |= 0x00100000;
4810         onChanged();
4811       }
4812       if (localityLbPoliciesBuilder_ == null) {
4813         if (!other.localityLbPolicies_.isEmpty()) {
4814           if (localityLbPolicies_.isEmpty()) {
4815             localityLbPolicies_ = other.localityLbPolicies_;
4816             bitField0_ = (bitField0_ & ~0x00200000);
4817           } else {
4818             ensureLocalityLbPoliciesIsMutable();
4819             localityLbPolicies_.addAll(other.localityLbPolicies_);
4820           }
4821           onChanged();
4822         }
4823       } else {
4824         if (!other.localityLbPolicies_.isEmpty()) {
4825           if (localityLbPoliciesBuilder_.isEmpty()) {
4826             localityLbPoliciesBuilder_.dispose();
4827             localityLbPoliciesBuilder_ = null;
4828             localityLbPolicies_ = other.localityLbPolicies_;
4829             bitField0_ = (bitField0_ & ~0x00200000);
4830             localityLbPoliciesBuilder_ =
4831                 com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders
4832                     ? getLocalityLbPoliciesFieldBuilder()
4833                     : null;
4834           } else {
4835             localityLbPoliciesBuilder_.addAllMessages(other.localityLbPolicies_);
4836           }
4837         }
4838       }
4839       if (other.hasLocalityLbPolicy()) {
4840         localityLbPolicy_ = other.localityLbPolicy_;
4841         bitField0_ |= 0x00400000;
4842         onChanged();
4843       }
4844       if (other.hasLogConfig()) {
4845         mergeLogConfig(other.getLogConfig());
4846       }
4847       if (other.hasMaxStreamDuration()) {
4848         mergeMaxStreamDuration(other.getMaxStreamDuration());
4849       }
4850       if (other.hasName()) {
4851         name_ = other.name_;
4852         bitField0_ |= 0x02000000;
4853         onChanged();
4854       }
4855       if (other.hasNetwork()) {
4856         network_ = other.network_;
4857         bitField0_ |= 0x04000000;
4858         onChanged();
4859       }
4860       if (other.hasOutlierDetection()) {
4861         mergeOutlierDetection(other.getOutlierDetection());
4862       }
4863       if (other.hasPort()) {
4864         setPort(other.getPort());
4865       }
4866       if (other.hasPortName()) {
4867         portName_ = other.portName_;
4868         bitField0_ |= 0x20000000;
4869         onChanged();
4870       }
4871       if (other.hasProtocol()) {
4872         protocol_ = other.protocol_;
4873         bitField0_ |= 0x40000000;
4874         onChanged();
4875       }
4876       if (other.hasRegion()) {
4877         region_ = other.region_;
4878         bitField0_ |= 0x80000000;
4879         onChanged();
4880       }
4881       if (other.hasSecurityPolicy()) {
4882         securityPolicy_ = other.securityPolicy_;
4883         bitField1_ |= 0x00000001;
4884         onChanged();
4885       }
4886       if (other.hasSecuritySettings()) {
4887         mergeSecuritySettings(other.getSecuritySettings());
4888       }
4889       if (other.hasSelfLink()) {
4890         selfLink_ = other.selfLink_;
4891         bitField1_ |= 0x00000004;
4892         onChanged();
4893       }
4894       if (!other.serviceBindings_.isEmpty()) {
4895         if (serviceBindings_.isEmpty()) {
4896           serviceBindings_ = other.serviceBindings_;
4897           bitField1_ = (bitField1_ & ~0x00000008);
4898         } else {
4899           ensureServiceBindingsIsMutable();
4900           serviceBindings_.addAll(other.serviceBindings_);
4901         }
4902         onChanged();
4903       }
4904       if (other.hasSessionAffinity()) {
4905         sessionAffinity_ = other.sessionAffinity_;
4906         bitField1_ |= 0x00000010;
4907         onChanged();
4908       }
4909       if (other.hasSubsetting()) {
4910         mergeSubsetting(other.getSubsetting());
4911       }
4912       if (other.hasTimeoutSec()) {
4913         setTimeoutSec(other.getTimeoutSec());
4914       }
4915       this.mergeUnknownFields(other.getUnknownFields());
4916       onChanged();
4917       return this;
4918     }
4919 
4920     @java.lang.Override
isInitialized()4921     public final boolean isInitialized() {
4922       return true;
4923     }
4924 
4925     @java.lang.Override
mergeFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4926     public Builder mergeFrom(
4927         com.google.protobuf.CodedInputStream input,
4928         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
4929         throws java.io.IOException {
4930       if (extensionRegistry == null) {
4931         throw new java.lang.NullPointerException();
4932       }
4933       try {
4934         boolean done = false;
4935         while (!done) {
4936           int tag = input.readTag();
4937           switch (tag) {
4938             case 0:
4939               done = true;
4940               break;
4941             case 26840:
4942               {
4943                 id_ = input.readUInt64();
4944                 bitField0_ |= 0x00040000;
4945                 break;
4946               } // case 26840
4947             case 832194:
4948               {
4949                 input.readMessage(getIapFieldBuilder().getBuilder(), extensionRegistry);
4950                 bitField0_ |= 0x00020000;
4951                 break;
4952               } // case 832194
4953             case 7247066:
4954               {
4955                 input.readMessage(getConsistentHashFieldBuilder().getBuilder(), extensionRegistry);
4956                 bitField0_ |= 0x00000080;
4957                 break;
4958               } // case 7247066
4959             case 26336418:
4960               {
4961                 kind_ = input.readStringRequireUtf8();
4962                 bitField0_ |= 0x00080000;
4963                 break;
4964               } // case 26336418
4965             case 26989658:
4966               {
4967                 name_ = input.readStringRequireUtf8();
4968                 bitField0_ |= 0x02000000;
4969                 break;
4970               } // case 26989658
4971             case 27575304:
4972               {
4973                 port_ = input.readInt32();
4974                 bitField0_ |= 0x10000000;
4975                 break;
4976               } // case 27575304
4977             case 223823938:
4978               {
4979                 java.lang.String s = input.readStringRequireUtf8();
4980                 ensureCustomRequestHeadersIsMutable();
4981                 customRequestHeaders_.add(s);
4982                 break;
4983               } // case 223823938
4984             case 244202930:
4985               {
4986                 creationTimestamp_ = input.readStringRequireUtf8();
4987                 bitField0_ |= 0x00000100;
4988                 break;
4989               } // case 244202930
4990             case 328295546:
4991               {
4992                 edgeSecurityPolicy_ = input.readStringRequireUtf8();
4993                 bitField0_ |= 0x00001000;
4994                 break;
4995               } // case 328295546
4996             case 332274762:
4997               {
4998                 portName_ = input.readStringRequireUtf8();
4999                 bitField0_ |= 0x20000000;
5000                 break;
5001               } // case 332274762
5002             case 491427010:
5003               {
5004                 input.readMessage(
5005                     getMaxStreamDurationFieldBuilder().getBuilder(), extensionRegistry);
5006                 bitField0_ |= 0x01000000;
5007                 break;
5008               } // case 491427010
5009             case 639959960:
5010               {
5011                 timeoutSec_ = input.readInt32();
5012                 bitField1_ |= 0x00000040;
5013                 break;
5014               } // case 639959960
5015             case 676623554:
5016               {
5017                 protocol_ = input.readStringRequireUtf8();
5018                 bitField0_ |= 0x40000000;
5019                 break;
5020               } // case 676623554
5021             case 764167906:
5022               {
5023                 compressionMode_ = input.readStringRequireUtf8();
5024                 bitField0_ |= 0x00000010;
5025                 break;
5026               } // case 764167906
5027             case 845269242:
5028               {
5029                 input.readMessage(getFailoverPolicyFieldBuilder().getBuilder(), extensionRegistry);
5030                 bitField0_ |= 0x00004000;
5031                 break;
5032               } // case 845269242
5033             case 1051451898:
5034               {
5035                 localityLbPolicy_ = input.readStringRequireUtf8();
5036                 bitField0_ |= 0x00400000;
5037                 break;
5038               } // case 1051451898
5039             case 1068648130:
5040               {
5041                 java.lang.String s = input.readStringRequireUtf8();
5042                 ensureServiceBindingsIsMutable();
5043                 serviceBindings_.add(s);
5044                 break;
5045               } // case 1068648130
5046             case 1111570338:
5047               {
5048                 region_ = input.readStringRequireUtf8();
5049                 bitField0_ |= 0x80000000;
5050                 break;
5051               } // case 1111570338
5052             case 1127860458:
5053               {
5054                 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig m =
5055                     input.readMessage(
5056                         com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig
5057                             .parser(),
5058                         extensionRegistry);
5059                 if (localityLbPoliciesBuilder_ == null) {
5060                   ensureLocalityLbPoliciesIsMutable();
5061                   localityLbPolicies_.add(m);
5062                 } else {
5063                   localityLbPoliciesBuilder_.addMessage(m);
5064                 }
5065                 break;
5066               } // case 1127860458
5067             case 1151959754:
5068               {
5069                 input.readMessage(
5070                     getConnectionTrackingPolicyFieldBuilder().getBuilder(), extensionRegistry);
5071                 bitField0_ |= 0x00000040;
5072                 break;
5073               } // case 1151959754
5074             case 1368660106:
5075               {
5076                 securityPolicy_ = input.readStringRequireUtf8();
5077                 bitField1_ |= 0x00000001;
5078                 break;
5079               } // case 1368660106
5080             case 1711811618:
5081               {
5082                 input.readMessage(getCdnPolicyFieldBuilder().getBuilder(), extensionRegistry);
5083                 bitField0_ |= 0x00000004;
5084                 break;
5085               } // case 1711811618
5086             case 1862979954:
5087               {
5088                 network_ = input.readStringRequireUtf8();
5089                 bitField0_ |= 0x04000000;
5090                 break;
5091               } // case 1862979954
5092             case 1877428002:
5093               {
5094                 fingerprint_ = input.readStringRequireUtf8();
5095                 bitField0_ |= 0x00008000;
5096                 break;
5097               } // case 1877428002
5098             case 2005867992:
5099               {
5100                 enableCDN_ = input.readBool();
5101                 bitField0_ |= 0x00002000;
5102                 break;
5103               } // case 2005867992
5104             case -1484569366:
5105               {
5106                 input.readMessage(getLogConfigFieldBuilder().getBuilder(), extensionRegistry);
5107                 bitField0_ |= 0x00800000;
5108                 break;
5109               } // case -1484569366
5110             case -1457966606:
5111               {
5112                 input.readMessage(
5113                     getOutlierDetectionFieldBuilder().getBuilder(), extensionRegistry);
5114                 bitField0_ |= 0x08000000;
5115                 break;
5116               } // case -1457966606
5117             case -1383845342:
5118               {
5119                 loadBalancingScheme_ = input.readStringRequireUtf8();
5120                 bitField0_ |= 0x00100000;
5121                 break;
5122               } // case -1383845342
5123             case -1334991664:
5124               {
5125                 affinityCookieTtlSec_ = input.readInt32();
5126                 bitField0_ |= 0x00000001;
5127                 break;
5128               } // case -1334991664
5129             case -1194654542:
5130               {
5131                 java.lang.String s = input.readStringRequireUtf8();
5132                 ensureCustomResponseHeadersIsMutable();
5133                 customResponseHeaders_.add(s);
5134                 break;
5135               } // case -1194654542
5136             case -924246806:
5137               {
5138                 input.readMessage(getCircuitBreakersFieldBuilder().getBuilder(), extensionRegistry);
5139                 bitField0_ |= 0x00000008;
5140                 break;
5141               } // case -924246806
5142             case -911466526:
5143               {
5144                 description_ = input.readStringRequireUtf8();
5145                 bitField0_ |= 0x00000800;
5146                 break;
5147               } // case -911466526
5148             case -708002446:
5149               {
5150                 java.lang.String s = input.readStringRequireUtf8();
5151                 ensureHealthChecksIsMutable();
5152                 healthChecks_.add(s);
5153                 break;
5154               } // case -708002446
5155             case -692699006:
5156               {
5157                 input.readMessage(getSubsettingFieldBuilder().getBuilder(), extensionRegistry);
5158                 bitField1_ |= 0x00000020;
5159                 break;
5160               } // case -692699006
5161             case -645248918:
5162               {
5163                 selfLink_ = input.readStringRequireUtf8();
5164                 bitField1_ |= 0x00000004;
5165                 break;
5166               } // case -645248918
5167             case -606193318:
5168               {
5169                 input.readMessage(
5170                     getConnectionDrainingFieldBuilder().getBuilder(), extensionRegistry);
5171                 bitField0_ |= 0x00000020;
5172                 break;
5173               } // case -606193318
5174             case -583858806:
5175               {
5176                 sessionAffinity_ = input.readStringRequireUtf8();
5177                 bitField1_ |= 0x00000010;
5178                 break;
5179               } // case -583858806
5180             case -465767918:
5181               {
5182                 input.readMessage(
5183                     getSecuritySettingsFieldBuilder().getBuilder(), extensionRegistry);
5184                 bitField1_ |= 0x00000002;
5185                 break;
5186               } // case -465767918
5187             case -208248070:
5188               {
5189                 com.google.cloud.compute.v1.Backend m =
5190                     input.readMessage(
5191                         com.google.cloud.compute.v1.Backend.parser(), extensionRegistry);
5192                 if (backendsBuilder_ == null) {
5193                   ensureBackendsIsMutable();
5194                   backends_.add(m);
5195                 } else {
5196                   backendsBuilder_.addMessage(m);
5197                 }
5198                 break;
5199               } // case -208248070
5200             default:
5201               {
5202                 if (!super.parseUnknownField(input, extensionRegistry, tag)) {
5203                   done = true; // was an endgroup tag
5204                 }
5205                 break;
5206               } // default:
5207           } // switch (tag)
5208         } // while (!done)
5209       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
5210         throw e.unwrapIOException();
5211       } finally {
5212         onChanged();
5213       } // finally
5214       return this;
5215     }
5216 
5217     private int bitField0_;
5218     private int bitField1_;
5219 
5220     private int affinityCookieTtlSec_;
5221     /**
5222      *
5223      *
5224      * <pre>
5225      * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
5226      * </pre>
5227      *
5228      * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code>
5229      *
5230      * @return Whether the affinityCookieTtlSec field is set.
5231      */
5232     @java.lang.Override
hasAffinityCookieTtlSec()5233     public boolean hasAffinityCookieTtlSec() {
5234       return ((bitField0_ & 0x00000001) != 0);
5235     }
5236     /**
5237      *
5238      *
5239      * <pre>
5240      * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
5241      * </pre>
5242      *
5243      * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code>
5244      *
5245      * @return The affinityCookieTtlSec.
5246      */
5247     @java.lang.Override
getAffinityCookieTtlSec()5248     public int getAffinityCookieTtlSec() {
5249       return affinityCookieTtlSec_;
5250     }
5251     /**
5252      *
5253      *
5254      * <pre>
5255      * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
5256      * </pre>
5257      *
5258      * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code>
5259      *
5260      * @param value The affinityCookieTtlSec to set.
5261      * @return This builder for chaining.
5262      */
setAffinityCookieTtlSec(int value)5263     public Builder setAffinityCookieTtlSec(int value) {
5264 
5265       affinityCookieTtlSec_ = value;
5266       bitField0_ |= 0x00000001;
5267       onChanged();
5268       return this;
5269     }
5270     /**
5271      *
5272      *
5273      * <pre>
5274      * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
5275      * </pre>
5276      *
5277      * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code>
5278      *
5279      * @return This builder for chaining.
5280      */
clearAffinityCookieTtlSec()5281     public Builder clearAffinityCookieTtlSec() {
5282       bitField0_ = (bitField0_ & ~0x00000001);
5283       affinityCookieTtlSec_ = 0;
5284       onChanged();
5285       return this;
5286     }
5287 
5288     private java.util.List<com.google.cloud.compute.v1.Backend> backends_ =
5289         java.util.Collections.emptyList();
5290 
ensureBackendsIsMutable()5291     private void ensureBackendsIsMutable() {
5292       if (!((bitField0_ & 0x00000002) != 0)) {
5293         backends_ = new java.util.ArrayList<com.google.cloud.compute.v1.Backend>(backends_);
5294         bitField0_ |= 0x00000002;
5295       }
5296     }
5297 
5298     private com.google.protobuf.RepeatedFieldBuilderV3<
5299             com.google.cloud.compute.v1.Backend,
5300             com.google.cloud.compute.v1.Backend.Builder,
5301             com.google.cloud.compute.v1.BackendOrBuilder>
5302         backendsBuilder_;
5303 
5304     /**
5305      *
5306      *
5307      * <pre>
5308      * The list of backends that serve this BackendService.
5309      * </pre>
5310      *
5311      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5312      */
getBackendsList()5313     public java.util.List<com.google.cloud.compute.v1.Backend> getBackendsList() {
5314       if (backendsBuilder_ == null) {
5315         return java.util.Collections.unmodifiableList(backends_);
5316       } else {
5317         return backendsBuilder_.getMessageList();
5318       }
5319     }
5320     /**
5321      *
5322      *
5323      * <pre>
5324      * The list of backends that serve this BackendService.
5325      * </pre>
5326      *
5327      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5328      */
getBackendsCount()5329     public int getBackendsCount() {
5330       if (backendsBuilder_ == null) {
5331         return backends_.size();
5332       } else {
5333         return backendsBuilder_.getCount();
5334       }
5335     }
5336     /**
5337      *
5338      *
5339      * <pre>
5340      * The list of backends that serve this BackendService.
5341      * </pre>
5342      *
5343      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5344      */
getBackends(int index)5345     public com.google.cloud.compute.v1.Backend getBackends(int index) {
5346       if (backendsBuilder_ == null) {
5347         return backends_.get(index);
5348       } else {
5349         return backendsBuilder_.getMessage(index);
5350       }
5351     }
5352     /**
5353      *
5354      *
5355      * <pre>
5356      * The list of backends that serve this BackendService.
5357      * </pre>
5358      *
5359      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5360      */
setBackends(int index, com.google.cloud.compute.v1.Backend value)5361     public Builder setBackends(int index, com.google.cloud.compute.v1.Backend value) {
5362       if (backendsBuilder_ == null) {
5363         if (value == null) {
5364           throw new NullPointerException();
5365         }
5366         ensureBackendsIsMutable();
5367         backends_.set(index, value);
5368         onChanged();
5369       } else {
5370         backendsBuilder_.setMessage(index, value);
5371       }
5372       return this;
5373     }
5374     /**
5375      *
5376      *
5377      * <pre>
5378      * The list of backends that serve this BackendService.
5379      * </pre>
5380      *
5381      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5382      */
setBackends( int index, com.google.cloud.compute.v1.Backend.Builder builderForValue)5383     public Builder setBackends(
5384         int index, com.google.cloud.compute.v1.Backend.Builder builderForValue) {
5385       if (backendsBuilder_ == null) {
5386         ensureBackendsIsMutable();
5387         backends_.set(index, builderForValue.build());
5388         onChanged();
5389       } else {
5390         backendsBuilder_.setMessage(index, builderForValue.build());
5391       }
5392       return this;
5393     }
5394     /**
5395      *
5396      *
5397      * <pre>
5398      * The list of backends that serve this BackendService.
5399      * </pre>
5400      *
5401      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5402      */
addBackends(com.google.cloud.compute.v1.Backend value)5403     public Builder addBackends(com.google.cloud.compute.v1.Backend value) {
5404       if (backendsBuilder_ == null) {
5405         if (value == null) {
5406           throw new NullPointerException();
5407         }
5408         ensureBackendsIsMutable();
5409         backends_.add(value);
5410         onChanged();
5411       } else {
5412         backendsBuilder_.addMessage(value);
5413       }
5414       return this;
5415     }
5416     /**
5417      *
5418      *
5419      * <pre>
5420      * The list of backends that serve this BackendService.
5421      * </pre>
5422      *
5423      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5424      */
addBackends(int index, com.google.cloud.compute.v1.Backend value)5425     public Builder addBackends(int index, com.google.cloud.compute.v1.Backend value) {
5426       if (backendsBuilder_ == null) {
5427         if (value == null) {
5428           throw new NullPointerException();
5429         }
5430         ensureBackendsIsMutable();
5431         backends_.add(index, value);
5432         onChanged();
5433       } else {
5434         backendsBuilder_.addMessage(index, value);
5435       }
5436       return this;
5437     }
5438     /**
5439      *
5440      *
5441      * <pre>
5442      * The list of backends that serve this BackendService.
5443      * </pre>
5444      *
5445      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5446      */
addBackends(com.google.cloud.compute.v1.Backend.Builder builderForValue)5447     public Builder addBackends(com.google.cloud.compute.v1.Backend.Builder builderForValue) {
5448       if (backendsBuilder_ == null) {
5449         ensureBackendsIsMutable();
5450         backends_.add(builderForValue.build());
5451         onChanged();
5452       } else {
5453         backendsBuilder_.addMessage(builderForValue.build());
5454       }
5455       return this;
5456     }
5457     /**
5458      *
5459      *
5460      * <pre>
5461      * The list of backends that serve this BackendService.
5462      * </pre>
5463      *
5464      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5465      */
addBackends( int index, com.google.cloud.compute.v1.Backend.Builder builderForValue)5466     public Builder addBackends(
5467         int index, com.google.cloud.compute.v1.Backend.Builder builderForValue) {
5468       if (backendsBuilder_ == null) {
5469         ensureBackendsIsMutable();
5470         backends_.add(index, builderForValue.build());
5471         onChanged();
5472       } else {
5473         backendsBuilder_.addMessage(index, builderForValue.build());
5474       }
5475       return this;
5476     }
5477     /**
5478      *
5479      *
5480      * <pre>
5481      * The list of backends that serve this BackendService.
5482      * </pre>
5483      *
5484      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5485      */
addAllBackends( java.lang.Iterable<? extends com.google.cloud.compute.v1.Backend> values)5486     public Builder addAllBackends(
5487         java.lang.Iterable<? extends com.google.cloud.compute.v1.Backend> values) {
5488       if (backendsBuilder_ == null) {
5489         ensureBackendsIsMutable();
5490         com.google.protobuf.AbstractMessageLite.Builder.addAll(values, backends_);
5491         onChanged();
5492       } else {
5493         backendsBuilder_.addAllMessages(values);
5494       }
5495       return this;
5496     }
5497     /**
5498      *
5499      *
5500      * <pre>
5501      * The list of backends that serve this BackendService.
5502      * </pre>
5503      *
5504      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5505      */
clearBackends()5506     public Builder clearBackends() {
5507       if (backendsBuilder_ == null) {
5508         backends_ = java.util.Collections.emptyList();
5509         bitField0_ = (bitField0_ & ~0x00000002);
5510         onChanged();
5511       } else {
5512         backendsBuilder_.clear();
5513       }
5514       return this;
5515     }
5516     /**
5517      *
5518      *
5519      * <pre>
5520      * The list of backends that serve this BackendService.
5521      * </pre>
5522      *
5523      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5524      */
removeBackends(int index)5525     public Builder removeBackends(int index) {
5526       if (backendsBuilder_ == null) {
5527         ensureBackendsIsMutable();
5528         backends_.remove(index);
5529         onChanged();
5530       } else {
5531         backendsBuilder_.remove(index);
5532       }
5533       return this;
5534     }
5535     /**
5536      *
5537      *
5538      * <pre>
5539      * The list of backends that serve this BackendService.
5540      * </pre>
5541      *
5542      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5543      */
getBackendsBuilder(int index)5544     public com.google.cloud.compute.v1.Backend.Builder getBackendsBuilder(int index) {
5545       return getBackendsFieldBuilder().getBuilder(index);
5546     }
5547     /**
5548      *
5549      *
5550      * <pre>
5551      * The list of backends that serve this BackendService.
5552      * </pre>
5553      *
5554      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5555      */
getBackendsOrBuilder(int index)5556     public com.google.cloud.compute.v1.BackendOrBuilder getBackendsOrBuilder(int index) {
5557       if (backendsBuilder_ == null) {
5558         return backends_.get(index);
5559       } else {
5560         return backendsBuilder_.getMessageOrBuilder(index);
5561       }
5562     }
5563     /**
5564      *
5565      *
5566      * <pre>
5567      * The list of backends that serve this BackendService.
5568      * </pre>
5569      *
5570      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5571      */
5572     public java.util.List<? extends com.google.cloud.compute.v1.BackendOrBuilder>
getBackendsOrBuilderList()5573         getBackendsOrBuilderList() {
5574       if (backendsBuilder_ != null) {
5575         return backendsBuilder_.getMessageOrBuilderList();
5576       } else {
5577         return java.util.Collections.unmodifiableList(backends_);
5578       }
5579     }
5580     /**
5581      *
5582      *
5583      * <pre>
5584      * The list of backends that serve this BackendService.
5585      * </pre>
5586      *
5587      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5588      */
addBackendsBuilder()5589     public com.google.cloud.compute.v1.Backend.Builder addBackendsBuilder() {
5590       return getBackendsFieldBuilder()
5591           .addBuilder(com.google.cloud.compute.v1.Backend.getDefaultInstance());
5592     }
5593     /**
5594      *
5595      *
5596      * <pre>
5597      * The list of backends that serve this BackendService.
5598      * </pre>
5599      *
5600      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5601      */
addBackendsBuilder(int index)5602     public com.google.cloud.compute.v1.Backend.Builder addBackendsBuilder(int index) {
5603       return getBackendsFieldBuilder()
5604           .addBuilder(index, com.google.cloud.compute.v1.Backend.getDefaultInstance());
5605     }
5606     /**
5607      *
5608      *
5609      * <pre>
5610      * The list of backends that serve this BackendService.
5611      * </pre>
5612      *
5613      * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code>
5614      */
getBackendsBuilderList()5615     public java.util.List<com.google.cloud.compute.v1.Backend.Builder> getBackendsBuilderList() {
5616       return getBackendsFieldBuilder().getBuilderList();
5617     }
5618 
5619     private com.google.protobuf.RepeatedFieldBuilderV3<
5620             com.google.cloud.compute.v1.Backend,
5621             com.google.cloud.compute.v1.Backend.Builder,
5622             com.google.cloud.compute.v1.BackendOrBuilder>
getBackendsFieldBuilder()5623         getBackendsFieldBuilder() {
5624       if (backendsBuilder_ == null) {
5625         backendsBuilder_ =
5626             new com.google.protobuf.RepeatedFieldBuilderV3<
5627                 com.google.cloud.compute.v1.Backend,
5628                 com.google.cloud.compute.v1.Backend.Builder,
5629                 com.google.cloud.compute.v1.BackendOrBuilder>(
5630                 backends_, ((bitField0_ & 0x00000002) != 0), getParentForChildren(), isClean());
5631         backends_ = null;
5632       }
5633       return backendsBuilder_;
5634     }
5635 
5636     private com.google.cloud.compute.v1.BackendServiceCdnPolicy cdnPolicy_;
5637     private com.google.protobuf.SingleFieldBuilderV3<
5638             com.google.cloud.compute.v1.BackendServiceCdnPolicy,
5639             com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder,
5640             com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder>
5641         cdnPolicyBuilder_;
5642     /**
5643      *
5644      *
5645      * <pre>
5646      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5647      * </pre>
5648      *
5649      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5650      * </code>
5651      *
5652      * @return Whether the cdnPolicy field is set.
5653      */
hasCdnPolicy()5654     public boolean hasCdnPolicy() {
5655       return ((bitField0_ & 0x00000004) != 0);
5656     }
5657     /**
5658      *
5659      *
5660      * <pre>
5661      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5662      * </pre>
5663      *
5664      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5665      * </code>
5666      *
5667      * @return The cdnPolicy.
5668      */
getCdnPolicy()5669     public com.google.cloud.compute.v1.BackendServiceCdnPolicy getCdnPolicy() {
5670       if (cdnPolicyBuilder_ == null) {
5671         return cdnPolicy_ == null
5672             ? com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance()
5673             : cdnPolicy_;
5674       } else {
5675         return cdnPolicyBuilder_.getMessage();
5676       }
5677     }
5678     /**
5679      *
5680      *
5681      * <pre>
5682      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5683      * </pre>
5684      *
5685      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5686      * </code>
5687      */
setCdnPolicy(com.google.cloud.compute.v1.BackendServiceCdnPolicy value)5688     public Builder setCdnPolicy(com.google.cloud.compute.v1.BackendServiceCdnPolicy value) {
5689       if (cdnPolicyBuilder_ == null) {
5690         if (value == null) {
5691           throw new NullPointerException();
5692         }
5693         cdnPolicy_ = value;
5694       } else {
5695         cdnPolicyBuilder_.setMessage(value);
5696       }
5697       bitField0_ |= 0x00000004;
5698       onChanged();
5699       return this;
5700     }
5701     /**
5702      *
5703      *
5704      * <pre>
5705      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5706      * </pre>
5707      *
5708      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5709      * </code>
5710      */
setCdnPolicy( com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder builderForValue)5711     public Builder setCdnPolicy(
5712         com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder builderForValue) {
5713       if (cdnPolicyBuilder_ == null) {
5714         cdnPolicy_ = builderForValue.build();
5715       } else {
5716         cdnPolicyBuilder_.setMessage(builderForValue.build());
5717       }
5718       bitField0_ |= 0x00000004;
5719       onChanged();
5720       return this;
5721     }
5722     /**
5723      *
5724      *
5725      * <pre>
5726      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5727      * </pre>
5728      *
5729      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5730      * </code>
5731      */
mergeCdnPolicy(com.google.cloud.compute.v1.BackendServiceCdnPolicy value)5732     public Builder mergeCdnPolicy(com.google.cloud.compute.v1.BackendServiceCdnPolicy value) {
5733       if (cdnPolicyBuilder_ == null) {
5734         if (((bitField0_ & 0x00000004) != 0)
5735             && cdnPolicy_ != null
5736             && cdnPolicy_
5737                 != com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance()) {
5738           getCdnPolicyBuilder().mergeFrom(value);
5739         } else {
5740           cdnPolicy_ = value;
5741         }
5742       } else {
5743         cdnPolicyBuilder_.mergeFrom(value);
5744       }
5745       bitField0_ |= 0x00000004;
5746       onChanged();
5747       return this;
5748     }
5749     /**
5750      *
5751      *
5752      * <pre>
5753      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5754      * </pre>
5755      *
5756      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5757      * </code>
5758      */
clearCdnPolicy()5759     public Builder clearCdnPolicy() {
5760       bitField0_ = (bitField0_ & ~0x00000004);
5761       cdnPolicy_ = null;
5762       if (cdnPolicyBuilder_ != null) {
5763         cdnPolicyBuilder_.dispose();
5764         cdnPolicyBuilder_ = null;
5765       }
5766       onChanged();
5767       return this;
5768     }
5769     /**
5770      *
5771      *
5772      * <pre>
5773      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5774      * </pre>
5775      *
5776      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5777      * </code>
5778      */
getCdnPolicyBuilder()5779     public com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder getCdnPolicyBuilder() {
5780       bitField0_ |= 0x00000004;
5781       onChanged();
5782       return getCdnPolicyFieldBuilder().getBuilder();
5783     }
5784     /**
5785      *
5786      *
5787      * <pre>
5788      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5789      * </pre>
5790      *
5791      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5792      * </code>
5793      */
getCdnPolicyOrBuilder()5794     public com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder getCdnPolicyOrBuilder() {
5795       if (cdnPolicyBuilder_ != null) {
5796         return cdnPolicyBuilder_.getMessageOrBuilder();
5797       } else {
5798         return cdnPolicy_ == null
5799             ? com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance()
5800             : cdnPolicy_;
5801       }
5802     }
5803     /**
5804      *
5805      *
5806      * <pre>
5807      * Cloud CDN configuration for this BackendService. Only available for specified load balancer types.
5808      * </pre>
5809      *
5810      * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;
5811      * </code>
5812      */
5813     private com.google.protobuf.SingleFieldBuilderV3<
5814             com.google.cloud.compute.v1.BackendServiceCdnPolicy,
5815             com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder,
5816             com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder>
getCdnPolicyFieldBuilder()5817         getCdnPolicyFieldBuilder() {
5818       if (cdnPolicyBuilder_ == null) {
5819         cdnPolicyBuilder_ =
5820             new com.google.protobuf.SingleFieldBuilderV3<
5821                 com.google.cloud.compute.v1.BackendServiceCdnPolicy,
5822                 com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder,
5823                 com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder>(
5824                 getCdnPolicy(), getParentForChildren(), isClean());
5825         cdnPolicy_ = null;
5826       }
5827       return cdnPolicyBuilder_;
5828     }
5829 
5830     private com.google.cloud.compute.v1.CircuitBreakers circuitBreakers_;
5831     private com.google.protobuf.SingleFieldBuilderV3<
5832             com.google.cloud.compute.v1.CircuitBreakers,
5833             com.google.cloud.compute.v1.CircuitBreakers.Builder,
5834             com.google.cloud.compute.v1.CircuitBreakersOrBuilder>
5835         circuitBreakersBuilder_;
5836     /**
5837      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5838      *
5839      * @return Whether the circuitBreakers field is set.
5840      */
hasCircuitBreakers()5841     public boolean hasCircuitBreakers() {
5842       return ((bitField0_ & 0x00000008) != 0);
5843     }
5844     /**
5845      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5846      *
5847      * @return The circuitBreakers.
5848      */
getCircuitBreakers()5849     public com.google.cloud.compute.v1.CircuitBreakers getCircuitBreakers() {
5850       if (circuitBreakersBuilder_ == null) {
5851         return circuitBreakers_ == null
5852             ? com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance()
5853             : circuitBreakers_;
5854       } else {
5855         return circuitBreakersBuilder_.getMessage();
5856       }
5857     }
5858     /**
5859      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5860      */
setCircuitBreakers(com.google.cloud.compute.v1.CircuitBreakers value)5861     public Builder setCircuitBreakers(com.google.cloud.compute.v1.CircuitBreakers value) {
5862       if (circuitBreakersBuilder_ == null) {
5863         if (value == null) {
5864           throw new NullPointerException();
5865         }
5866         circuitBreakers_ = value;
5867       } else {
5868         circuitBreakersBuilder_.setMessage(value);
5869       }
5870       bitField0_ |= 0x00000008;
5871       onChanged();
5872       return this;
5873     }
5874     /**
5875      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5876      */
setCircuitBreakers( com.google.cloud.compute.v1.CircuitBreakers.Builder builderForValue)5877     public Builder setCircuitBreakers(
5878         com.google.cloud.compute.v1.CircuitBreakers.Builder builderForValue) {
5879       if (circuitBreakersBuilder_ == null) {
5880         circuitBreakers_ = builderForValue.build();
5881       } else {
5882         circuitBreakersBuilder_.setMessage(builderForValue.build());
5883       }
5884       bitField0_ |= 0x00000008;
5885       onChanged();
5886       return this;
5887     }
5888     /**
5889      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5890      */
mergeCircuitBreakers(com.google.cloud.compute.v1.CircuitBreakers value)5891     public Builder mergeCircuitBreakers(com.google.cloud.compute.v1.CircuitBreakers value) {
5892       if (circuitBreakersBuilder_ == null) {
5893         if (((bitField0_ & 0x00000008) != 0)
5894             && circuitBreakers_ != null
5895             && circuitBreakers_
5896                 != com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance()) {
5897           getCircuitBreakersBuilder().mergeFrom(value);
5898         } else {
5899           circuitBreakers_ = value;
5900         }
5901       } else {
5902         circuitBreakersBuilder_.mergeFrom(value);
5903       }
5904       bitField0_ |= 0x00000008;
5905       onChanged();
5906       return this;
5907     }
5908     /**
5909      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5910      */
clearCircuitBreakers()5911     public Builder clearCircuitBreakers() {
5912       bitField0_ = (bitField0_ & ~0x00000008);
5913       circuitBreakers_ = null;
5914       if (circuitBreakersBuilder_ != null) {
5915         circuitBreakersBuilder_.dispose();
5916         circuitBreakersBuilder_ = null;
5917       }
5918       onChanged();
5919       return this;
5920     }
5921     /**
5922      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5923      */
getCircuitBreakersBuilder()5924     public com.google.cloud.compute.v1.CircuitBreakers.Builder getCircuitBreakersBuilder() {
5925       bitField0_ |= 0x00000008;
5926       onChanged();
5927       return getCircuitBreakersFieldBuilder().getBuilder();
5928     }
5929     /**
5930      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5931      */
getCircuitBreakersOrBuilder()5932     public com.google.cloud.compute.v1.CircuitBreakersOrBuilder getCircuitBreakersOrBuilder() {
5933       if (circuitBreakersBuilder_ != null) {
5934         return circuitBreakersBuilder_.getMessageOrBuilder();
5935       } else {
5936         return circuitBreakers_ == null
5937             ? com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance()
5938             : circuitBreakers_;
5939       }
5940     }
5941     /**
5942      * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code>
5943      */
5944     private com.google.protobuf.SingleFieldBuilderV3<
5945             com.google.cloud.compute.v1.CircuitBreakers,
5946             com.google.cloud.compute.v1.CircuitBreakers.Builder,
5947             com.google.cloud.compute.v1.CircuitBreakersOrBuilder>
getCircuitBreakersFieldBuilder()5948         getCircuitBreakersFieldBuilder() {
5949       if (circuitBreakersBuilder_ == null) {
5950         circuitBreakersBuilder_ =
5951             new com.google.protobuf.SingleFieldBuilderV3<
5952                 com.google.cloud.compute.v1.CircuitBreakers,
5953                 com.google.cloud.compute.v1.CircuitBreakers.Builder,
5954                 com.google.cloud.compute.v1.CircuitBreakersOrBuilder>(
5955                 getCircuitBreakers(), getParentForChildren(), isClean());
5956         circuitBreakers_ = null;
5957       }
5958       return circuitBreakersBuilder_;
5959     }
5960 
5961     private java.lang.Object compressionMode_ = "";
5962     /**
5963      *
5964      *
5965      * <pre>
5966      * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
5967      * Check the CompressionMode enum for the list of possible values.
5968      * </pre>
5969      *
5970      * <code>optional string compression_mode = 95520988;</code>
5971      *
5972      * @return Whether the compressionMode field is set.
5973      */
hasCompressionMode()5974     public boolean hasCompressionMode() {
5975       return ((bitField0_ & 0x00000010) != 0);
5976     }
5977     /**
5978      *
5979      *
5980      * <pre>
5981      * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
5982      * Check the CompressionMode enum for the list of possible values.
5983      * </pre>
5984      *
5985      * <code>optional string compression_mode = 95520988;</code>
5986      *
5987      * @return The compressionMode.
5988      */
getCompressionMode()5989     public java.lang.String getCompressionMode() {
5990       java.lang.Object ref = compressionMode_;
5991       if (!(ref instanceof java.lang.String)) {
5992         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
5993         java.lang.String s = bs.toStringUtf8();
5994         compressionMode_ = s;
5995         return s;
5996       } else {
5997         return (java.lang.String) ref;
5998       }
5999     }
6000     /**
6001      *
6002      *
6003      * <pre>
6004      * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
6005      * Check the CompressionMode enum for the list of possible values.
6006      * </pre>
6007      *
6008      * <code>optional string compression_mode = 95520988;</code>
6009      *
6010      * @return The bytes for compressionMode.
6011      */
getCompressionModeBytes()6012     public com.google.protobuf.ByteString getCompressionModeBytes() {
6013       java.lang.Object ref = compressionMode_;
6014       if (ref instanceof String) {
6015         com.google.protobuf.ByteString b =
6016             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
6017         compressionMode_ = b;
6018         return b;
6019       } else {
6020         return (com.google.protobuf.ByteString) ref;
6021       }
6022     }
6023     /**
6024      *
6025      *
6026      * <pre>
6027      * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
6028      * Check the CompressionMode enum for the list of possible values.
6029      * </pre>
6030      *
6031      * <code>optional string compression_mode = 95520988;</code>
6032      *
6033      * @param value The compressionMode to set.
6034      * @return This builder for chaining.
6035      */
setCompressionMode(java.lang.String value)6036     public Builder setCompressionMode(java.lang.String value) {
6037       if (value == null) {
6038         throw new NullPointerException();
6039       }
6040       compressionMode_ = value;
6041       bitField0_ |= 0x00000010;
6042       onChanged();
6043       return this;
6044     }
6045     /**
6046      *
6047      *
6048      * <pre>
6049      * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
6050      * Check the CompressionMode enum for the list of possible values.
6051      * </pre>
6052      *
6053      * <code>optional string compression_mode = 95520988;</code>
6054      *
6055      * @return This builder for chaining.
6056      */
clearCompressionMode()6057     public Builder clearCompressionMode() {
6058       compressionMode_ = getDefaultInstance().getCompressionMode();
6059       bitField0_ = (bitField0_ & ~0x00000010);
6060       onChanged();
6061       return this;
6062     }
6063     /**
6064      *
6065      *
6066      * <pre>
6067      * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header.
6068      * Check the CompressionMode enum for the list of possible values.
6069      * </pre>
6070      *
6071      * <code>optional string compression_mode = 95520988;</code>
6072      *
6073      * @param value The bytes for compressionMode to set.
6074      * @return This builder for chaining.
6075      */
setCompressionModeBytes(com.google.protobuf.ByteString value)6076     public Builder setCompressionModeBytes(com.google.protobuf.ByteString value) {
6077       if (value == null) {
6078         throw new NullPointerException();
6079       }
6080       checkByteStringIsUtf8(value);
6081       compressionMode_ = value;
6082       bitField0_ |= 0x00000010;
6083       onChanged();
6084       return this;
6085     }
6086 
6087     private com.google.cloud.compute.v1.ConnectionDraining connectionDraining_;
6088     private com.google.protobuf.SingleFieldBuilderV3<
6089             com.google.cloud.compute.v1.ConnectionDraining,
6090             com.google.cloud.compute.v1.ConnectionDraining.Builder,
6091             com.google.cloud.compute.v1.ConnectionDrainingOrBuilder>
6092         connectionDrainingBuilder_;
6093     /**
6094      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6095      * </code>
6096      *
6097      * @return Whether the connectionDraining field is set.
6098      */
hasConnectionDraining()6099     public boolean hasConnectionDraining() {
6100       return ((bitField0_ & 0x00000020) != 0);
6101     }
6102     /**
6103      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6104      * </code>
6105      *
6106      * @return The connectionDraining.
6107      */
getConnectionDraining()6108     public com.google.cloud.compute.v1.ConnectionDraining getConnectionDraining() {
6109       if (connectionDrainingBuilder_ == null) {
6110         return connectionDraining_ == null
6111             ? com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance()
6112             : connectionDraining_;
6113       } else {
6114         return connectionDrainingBuilder_.getMessage();
6115       }
6116     }
6117     /**
6118      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6119      * </code>
6120      */
setConnectionDraining(com.google.cloud.compute.v1.ConnectionDraining value)6121     public Builder setConnectionDraining(com.google.cloud.compute.v1.ConnectionDraining value) {
6122       if (connectionDrainingBuilder_ == null) {
6123         if (value == null) {
6124           throw new NullPointerException();
6125         }
6126         connectionDraining_ = value;
6127       } else {
6128         connectionDrainingBuilder_.setMessage(value);
6129       }
6130       bitField0_ |= 0x00000020;
6131       onChanged();
6132       return this;
6133     }
6134     /**
6135      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6136      * </code>
6137      */
setConnectionDraining( com.google.cloud.compute.v1.ConnectionDraining.Builder builderForValue)6138     public Builder setConnectionDraining(
6139         com.google.cloud.compute.v1.ConnectionDraining.Builder builderForValue) {
6140       if (connectionDrainingBuilder_ == null) {
6141         connectionDraining_ = builderForValue.build();
6142       } else {
6143         connectionDrainingBuilder_.setMessage(builderForValue.build());
6144       }
6145       bitField0_ |= 0x00000020;
6146       onChanged();
6147       return this;
6148     }
6149     /**
6150      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6151      * </code>
6152      */
mergeConnectionDraining(com.google.cloud.compute.v1.ConnectionDraining value)6153     public Builder mergeConnectionDraining(com.google.cloud.compute.v1.ConnectionDraining value) {
6154       if (connectionDrainingBuilder_ == null) {
6155         if (((bitField0_ & 0x00000020) != 0)
6156             && connectionDraining_ != null
6157             && connectionDraining_
6158                 != com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance()) {
6159           getConnectionDrainingBuilder().mergeFrom(value);
6160         } else {
6161           connectionDraining_ = value;
6162         }
6163       } else {
6164         connectionDrainingBuilder_.mergeFrom(value);
6165       }
6166       bitField0_ |= 0x00000020;
6167       onChanged();
6168       return this;
6169     }
6170     /**
6171      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6172      * </code>
6173      */
clearConnectionDraining()6174     public Builder clearConnectionDraining() {
6175       bitField0_ = (bitField0_ & ~0x00000020);
6176       connectionDraining_ = null;
6177       if (connectionDrainingBuilder_ != null) {
6178         connectionDrainingBuilder_.dispose();
6179         connectionDrainingBuilder_ = null;
6180       }
6181       onChanged();
6182       return this;
6183     }
6184     /**
6185      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6186      * </code>
6187      */
getConnectionDrainingBuilder()6188     public com.google.cloud.compute.v1.ConnectionDraining.Builder getConnectionDrainingBuilder() {
6189       bitField0_ |= 0x00000020;
6190       onChanged();
6191       return getConnectionDrainingFieldBuilder().getBuilder();
6192     }
6193     /**
6194      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6195      * </code>
6196      */
6197     public com.google.cloud.compute.v1.ConnectionDrainingOrBuilder
getConnectionDrainingOrBuilder()6198         getConnectionDrainingOrBuilder() {
6199       if (connectionDrainingBuilder_ != null) {
6200         return connectionDrainingBuilder_.getMessageOrBuilder();
6201       } else {
6202         return connectionDraining_ == null
6203             ? com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance()
6204             : connectionDraining_;
6205       }
6206     }
6207     /**
6208      * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747;
6209      * </code>
6210      */
6211     private com.google.protobuf.SingleFieldBuilderV3<
6212             com.google.cloud.compute.v1.ConnectionDraining,
6213             com.google.cloud.compute.v1.ConnectionDraining.Builder,
6214             com.google.cloud.compute.v1.ConnectionDrainingOrBuilder>
getConnectionDrainingFieldBuilder()6215         getConnectionDrainingFieldBuilder() {
6216       if (connectionDrainingBuilder_ == null) {
6217         connectionDrainingBuilder_ =
6218             new com.google.protobuf.SingleFieldBuilderV3<
6219                 com.google.cloud.compute.v1.ConnectionDraining,
6220                 com.google.cloud.compute.v1.ConnectionDraining.Builder,
6221                 com.google.cloud.compute.v1.ConnectionDrainingOrBuilder>(
6222                 getConnectionDraining(), getParentForChildren(), isClean());
6223         connectionDraining_ = null;
6224       }
6225       return connectionDrainingBuilder_;
6226     }
6227 
6228     private com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy
6229         connectionTrackingPolicy_;
6230     private com.google.protobuf.SingleFieldBuilderV3<
6231             com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy,
6232             com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder,
6233             com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder>
6234         connectionTrackingPolicyBuilder_;
6235     /**
6236      *
6237      *
6238      * <pre>
6239      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6240      * </pre>
6241      *
6242      * <code>
6243      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6244      * </code>
6245      *
6246      * @return Whether the connectionTrackingPolicy field is set.
6247      */
hasConnectionTrackingPolicy()6248     public boolean hasConnectionTrackingPolicy() {
6249       return ((bitField0_ & 0x00000040) != 0);
6250     }
6251     /**
6252      *
6253      *
6254      * <pre>
6255      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6256      * </pre>
6257      *
6258      * <code>
6259      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6260      * </code>
6261      *
6262      * @return The connectionTrackingPolicy.
6263      */
6264     public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy
getConnectionTrackingPolicy()6265         getConnectionTrackingPolicy() {
6266       if (connectionTrackingPolicyBuilder_ == null) {
6267         return connectionTrackingPolicy_ == null
6268             ? com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy
6269                 .getDefaultInstance()
6270             : connectionTrackingPolicy_;
6271       } else {
6272         return connectionTrackingPolicyBuilder_.getMessage();
6273       }
6274     }
6275     /**
6276      *
6277      *
6278      * <pre>
6279      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6280      * </pre>
6281      *
6282      * <code>
6283      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6284      * </code>
6285      */
setConnectionTrackingPolicy( com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy value)6286     public Builder setConnectionTrackingPolicy(
6287         com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy value) {
6288       if (connectionTrackingPolicyBuilder_ == null) {
6289         if (value == null) {
6290           throw new NullPointerException();
6291         }
6292         connectionTrackingPolicy_ = value;
6293       } else {
6294         connectionTrackingPolicyBuilder_.setMessage(value);
6295       }
6296       bitField0_ |= 0x00000040;
6297       onChanged();
6298       return this;
6299     }
6300     /**
6301      *
6302      *
6303      * <pre>
6304      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6305      * </pre>
6306      *
6307      * <code>
6308      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6309      * </code>
6310      */
setConnectionTrackingPolicy( com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder builderForValue)6311     public Builder setConnectionTrackingPolicy(
6312         com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder
6313             builderForValue) {
6314       if (connectionTrackingPolicyBuilder_ == null) {
6315         connectionTrackingPolicy_ = builderForValue.build();
6316       } else {
6317         connectionTrackingPolicyBuilder_.setMessage(builderForValue.build());
6318       }
6319       bitField0_ |= 0x00000040;
6320       onChanged();
6321       return this;
6322     }
6323     /**
6324      *
6325      *
6326      * <pre>
6327      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6328      * </pre>
6329      *
6330      * <code>
6331      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6332      * </code>
6333      */
mergeConnectionTrackingPolicy( com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy value)6334     public Builder mergeConnectionTrackingPolicy(
6335         com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy value) {
6336       if (connectionTrackingPolicyBuilder_ == null) {
6337         if (((bitField0_ & 0x00000040) != 0)
6338             && connectionTrackingPolicy_ != null
6339             && connectionTrackingPolicy_
6340                 != com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy
6341                     .getDefaultInstance()) {
6342           getConnectionTrackingPolicyBuilder().mergeFrom(value);
6343         } else {
6344           connectionTrackingPolicy_ = value;
6345         }
6346       } else {
6347         connectionTrackingPolicyBuilder_.mergeFrom(value);
6348       }
6349       bitField0_ |= 0x00000040;
6350       onChanged();
6351       return this;
6352     }
6353     /**
6354      *
6355      *
6356      * <pre>
6357      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6358      * </pre>
6359      *
6360      * <code>
6361      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6362      * </code>
6363      */
clearConnectionTrackingPolicy()6364     public Builder clearConnectionTrackingPolicy() {
6365       bitField0_ = (bitField0_ & ~0x00000040);
6366       connectionTrackingPolicy_ = null;
6367       if (connectionTrackingPolicyBuilder_ != null) {
6368         connectionTrackingPolicyBuilder_.dispose();
6369         connectionTrackingPolicyBuilder_ = null;
6370       }
6371       onChanged();
6372       return this;
6373     }
6374     /**
6375      *
6376      *
6377      * <pre>
6378      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6379      * </pre>
6380      *
6381      * <code>
6382      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6383      * </code>
6384      */
6385     public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder
getConnectionTrackingPolicyBuilder()6386         getConnectionTrackingPolicyBuilder() {
6387       bitField0_ |= 0x00000040;
6388       onChanged();
6389       return getConnectionTrackingPolicyFieldBuilder().getBuilder();
6390     }
6391     /**
6392      *
6393      *
6394      * <pre>
6395      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6396      * </pre>
6397      *
6398      * <code>
6399      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6400      * </code>
6401      */
6402     public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder
getConnectionTrackingPolicyOrBuilder()6403         getConnectionTrackingPolicyOrBuilder() {
6404       if (connectionTrackingPolicyBuilder_ != null) {
6405         return connectionTrackingPolicyBuilder_.getMessageOrBuilder();
6406       } else {
6407         return connectionTrackingPolicy_ == null
6408             ? com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy
6409                 .getDefaultInstance()
6410             : connectionTrackingPolicy_;
6411       }
6412     }
6413     /**
6414      *
6415      *
6416      * <pre>
6417      * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing.
6418      * </pre>
6419      *
6420      * <code>
6421      * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969;
6422      * </code>
6423      */
6424     private com.google.protobuf.SingleFieldBuilderV3<
6425             com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy,
6426             com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder,
6427             com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder>
getConnectionTrackingPolicyFieldBuilder()6428         getConnectionTrackingPolicyFieldBuilder() {
6429       if (connectionTrackingPolicyBuilder_ == null) {
6430         connectionTrackingPolicyBuilder_ =
6431             new com.google.protobuf.SingleFieldBuilderV3<
6432                 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy,
6433                 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder,
6434                 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder>(
6435                 getConnectionTrackingPolicy(), getParentForChildren(), isClean());
6436         connectionTrackingPolicy_ = null;
6437       }
6438       return connectionTrackingPolicyBuilder_;
6439     }
6440 
6441     private com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistentHash_;
6442     private com.google.protobuf.SingleFieldBuilderV3<
6443             com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings,
6444             com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder,
6445             com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder>
6446         consistentHashBuilder_;
6447     /**
6448      *
6449      *
6450      * <pre>
6451      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6452      * </pre>
6453      *
6454      * <code>
6455      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6456      * </code>
6457      *
6458      * @return Whether the consistentHash field is set.
6459      */
hasConsistentHash()6460     public boolean hasConsistentHash() {
6461       return ((bitField0_ & 0x00000080) != 0);
6462     }
6463     /**
6464      *
6465      *
6466      * <pre>
6467      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6468      * </pre>
6469      *
6470      * <code>
6471      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6472      * </code>
6473      *
6474      * @return The consistentHash.
6475      */
getConsistentHash()6476     public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings getConsistentHash() {
6477       if (consistentHashBuilder_ == null) {
6478         return consistentHash_ == null
6479             ? com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.getDefaultInstance()
6480             : consistentHash_;
6481       } else {
6482         return consistentHashBuilder_.getMessage();
6483       }
6484     }
6485     /**
6486      *
6487      *
6488      * <pre>
6489      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6490      * </pre>
6491      *
6492      * <code>
6493      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6494      * </code>
6495      */
setConsistentHash( com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings value)6496     public Builder setConsistentHash(
6497         com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings value) {
6498       if (consistentHashBuilder_ == null) {
6499         if (value == null) {
6500           throw new NullPointerException();
6501         }
6502         consistentHash_ = value;
6503       } else {
6504         consistentHashBuilder_.setMessage(value);
6505       }
6506       bitField0_ |= 0x00000080;
6507       onChanged();
6508       return this;
6509     }
6510     /**
6511      *
6512      *
6513      * <pre>
6514      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6515      * </pre>
6516      *
6517      * <code>
6518      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6519      * </code>
6520      */
setConsistentHash( com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder builderForValue)6521     public Builder setConsistentHash(
6522         com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder builderForValue) {
6523       if (consistentHashBuilder_ == null) {
6524         consistentHash_ = builderForValue.build();
6525       } else {
6526         consistentHashBuilder_.setMessage(builderForValue.build());
6527       }
6528       bitField0_ |= 0x00000080;
6529       onChanged();
6530       return this;
6531     }
6532     /**
6533      *
6534      *
6535      * <pre>
6536      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6537      * </pre>
6538      *
6539      * <code>
6540      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6541      * </code>
6542      */
mergeConsistentHash( com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings value)6543     public Builder mergeConsistentHash(
6544         com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings value) {
6545       if (consistentHashBuilder_ == null) {
6546         if (((bitField0_ & 0x00000080) != 0)
6547             && consistentHash_ != null
6548             && consistentHash_
6549                 != com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings
6550                     .getDefaultInstance()) {
6551           getConsistentHashBuilder().mergeFrom(value);
6552         } else {
6553           consistentHash_ = value;
6554         }
6555       } else {
6556         consistentHashBuilder_.mergeFrom(value);
6557       }
6558       bitField0_ |= 0x00000080;
6559       onChanged();
6560       return this;
6561     }
6562     /**
6563      *
6564      *
6565      * <pre>
6566      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6567      * </pre>
6568      *
6569      * <code>
6570      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6571      * </code>
6572      */
clearConsistentHash()6573     public Builder clearConsistentHash() {
6574       bitField0_ = (bitField0_ & ~0x00000080);
6575       consistentHash_ = null;
6576       if (consistentHashBuilder_ != null) {
6577         consistentHashBuilder_.dispose();
6578         consistentHashBuilder_ = null;
6579       }
6580       onChanged();
6581       return this;
6582     }
6583     /**
6584      *
6585      *
6586      * <pre>
6587      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6588      * </pre>
6589      *
6590      * <code>
6591      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6592      * </code>
6593      */
6594     public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder
getConsistentHashBuilder()6595         getConsistentHashBuilder() {
6596       bitField0_ |= 0x00000080;
6597       onChanged();
6598       return getConsistentHashFieldBuilder().getBuilder();
6599     }
6600     /**
6601      *
6602      *
6603      * <pre>
6604      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6605      * </pre>
6606      *
6607      * <code>
6608      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6609      * </code>
6610      */
6611     public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder
getConsistentHashOrBuilder()6612         getConsistentHashOrBuilder() {
6613       if (consistentHashBuilder_ != null) {
6614         return consistentHashBuilder_.getMessageOrBuilder();
6615       } else {
6616         return consistentHash_ == null
6617             ? com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.getDefaultInstance()
6618             : consistentHash_;
6619       }
6620     }
6621     /**
6622      *
6623      *
6624      * <pre>
6625      * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
6626      * </pre>
6627      *
6628      * <code>
6629      * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883;
6630      * </code>
6631      */
6632     private com.google.protobuf.SingleFieldBuilderV3<
6633             com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings,
6634             com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder,
6635             com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder>
getConsistentHashFieldBuilder()6636         getConsistentHashFieldBuilder() {
6637       if (consistentHashBuilder_ == null) {
6638         consistentHashBuilder_ =
6639             new com.google.protobuf.SingleFieldBuilderV3<
6640                 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings,
6641                 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder,
6642                 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder>(
6643                 getConsistentHash(), getParentForChildren(), isClean());
6644         consistentHash_ = null;
6645       }
6646       return consistentHashBuilder_;
6647     }
6648 
6649     private java.lang.Object creationTimestamp_ = "";
6650     /**
6651      *
6652      *
6653      * <pre>
6654      * [Output Only] Creation timestamp in RFC3339 text format.
6655      * </pre>
6656      *
6657      * <code>optional string creation_timestamp = 30525366;</code>
6658      *
6659      * @return Whether the creationTimestamp field is set.
6660      */
hasCreationTimestamp()6661     public boolean hasCreationTimestamp() {
6662       return ((bitField0_ & 0x00000100) != 0);
6663     }
6664     /**
6665      *
6666      *
6667      * <pre>
6668      * [Output Only] Creation timestamp in RFC3339 text format.
6669      * </pre>
6670      *
6671      * <code>optional string creation_timestamp = 30525366;</code>
6672      *
6673      * @return The creationTimestamp.
6674      */
getCreationTimestamp()6675     public java.lang.String getCreationTimestamp() {
6676       java.lang.Object ref = creationTimestamp_;
6677       if (!(ref instanceof java.lang.String)) {
6678         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
6679         java.lang.String s = bs.toStringUtf8();
6680         creationTimestamp_ = s;
6681         return s;
6682       } else {
6683         return (java.lang.String) ref;
6684       }
6685     }
6686     /**
6687      *
6688      *
6689      * <pre>
6690      * [Output Only] Creation timestamp in RFC3339 text format.
6691      * </pre>
6692      *
6693      * <code>optional string creation_timestamp = 30525366;</code>
6694      *
6695      * @return The bytes for creationTimestamp.
6696      */
getCreationTimestampBytes()6697     public com.google.protobuf.ByteString getCreationTimestampBytes() {
6698       java.lang.Object ref = creationTimestamp_;
6699       if (ref instanceof String) {
6700         com.google.protobuf.ByteString b =
6701             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
6702         creationTimestamp_ = b;
6703         return b;
6704       } else {
6705         return (com.google.protobuf.ByteString) ref;
6706       }
6707     }
6708     /**
6709      *
6710      *
6711      * <pre>
6712      * [Output Only] Creation timestamp in RFC3339 text format.
6713      * </pre>
6714      *
6715      * <code>optional string creation_timestamp = 30525366;</code>
6716      *
6717      * @param value The creationTimestamp to set.
6718      * @return This builder for chaining.
6719      */
setCreationTimestamp(java.lang.String value)6720     public Builder setCreationTimestamp(java.lang.String value) {
6721       if (value == null) {
6722         throw new NullPointerException();
6723       }
6724       creationTimestamp_ = value;
6725       bitField0_ |= 0x00000100;
6726       onChanged();
6727       return this;
6728     }
6729     /**
6730      *
6731      *
6732      * <pre>
6733      * [Output Only] Creation timestamp in RFC3339 text format.
6734      * </pre>
6735      *
6736      * <code>optional string creation_timestamp = 30525366;</code>
6737      *
6738      * @return This builder for chaining.
6739      */
clearCreationTimestamp()6740     public Builder clearCreationTimestamp() {
6741       creationTimestamp_ = getDefaultInstance().getCreationTimestamp();
6742       bitField0_ = (bitField0_ & ~0x00000100);
6743       onChanged();
6744       return this;
6745     }
6746     /**
6747      *
6748      *
6749      * <pre>
6750      * [Output Only] Creation timestamp in RFC3339 text format.
6751      * </pre>
6752      *
6753      * <code>optional string creation_timestamp = 30525366;</code>
6754      *
6755      * @param value The bytes for creationTimestamp to set.
6756      * @return This builder for chaining.
6757      */
setCreationTimestampBytes(com.google.protobuf.ByteString value)6758     public Builder setCreationTimestampBytes(com.google.protobuf.ByteString value) {
6759       if (value == null) {
6760         throw new NullPointerException();
6761       }
6762       checkByteStringIsUtf8(value);
6763       creationTimestamp_ = value;
6764       bitField0_ |= 0x00000100;
6765       onChanged();
6766       return this;
6767     }
6768 
6769     private com.google.protobuf.LazyStringList customRequestHeaders_ =
6770         com.google.protobuf.LazyStringArrayList.EMPTY;
6771 
ensureCustomRequestHeadersIsMutable()6772     private void ensureCustomRequestHeadersIsMutable() {
6773       if (!((bitField0_ & 0x00000200) != 0)) {
6774         customRequestHeaders_ = new com.google.protobuf.LazyStringArrayList(customRequestHeaders_);
6775         bitField0_ |= 0x00000200;
6776       }
6777     }
6778     /**
6779      *
6780      *
6781      * <pre>
6782      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6783      * </pre>
6784      *
6785      * <code>repeated string custom_request_headers = 27977992;</code>
6786      *
6787      * @return A list containing the customRequestHeaders.
6788      */
getCustomRequestHeadersList()6789     public com.google.protobuf.ProtocolStringList getCustomRequestHeadersList() {
6790       return customRequestHeaders_.getUnmodifiableView();
6791     }
6792     /**
6793      *
6794      *
6795      * <pre>
6796      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6797      * </pre>
6798      *
6799      * <code>repeated string custom_request_headers = 27977992;</code>
6800      *
6801      * @return The count of customRequestHeaders.
6802      */
getCustomRequestHeadersCount()6803     public int getCustomRequestHeadersCount() {
6804       return customRequestHeaders_.size();
6805     }
6806     /**
6807      *
6808      *
6809      * <pre>
6810      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6811      * </pre>
6812      *
6813      * <code>repeated string custom_request_headers = 27977992;</code>
6814      *
6815      * @param index The index of the element to return.
6816      * @return The customRequestHeaders at the given index.
6817      */
getCustomRequestHeaders(int index)6818     public java.lang.String getCustomRequestHeaders(int index) {
6819       return customRequestHeaders_.get(index);
6820     }
6821     /**
6822      *
6823      *
6824      * <pre>
6825      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6826      * </pre>
6827      *
6828      * <code>repeated string custom_request_headers = 27977992;</code>
6829      *
6830      * @param index The index of the value to return.
6831      * @return The bytes of the customRequestHeaders at the given index.
6832      */
getCustomRequestHeadersBytes(int index)6833     public com.google.protobuf.ByteString getCustomRequestHeadersBytes(int index) {
6834       return customRequestHeaders_.getByteString(index);
6835     }
6836     /**
6837      *
6838      *
6839      * <pre>
6840      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6841      * </pre>
6842      *
6843      * <code>repeated string custom_request_headers = 27977992;</code>
6844      *
6845      * @param index The index to set the value at.
6846      * @param value The customRequestHeaders to set.
6847      * @return This builder for chaining.
6848      */
setCustomRequestHeaders(int index, java.lang.String value)6849     public Builder setCustomRequestHeaders(int index, java.lang.String value) {
6850       if (value == null) {
6851         throw new NullPointerException();
6852       }
6853       ensureCustomRequestHeadersIsMutable();
6854       customRequestHeaders_.set(index, value);
6855       onChanged();
6856       return this;
6857     }
6858     /**
6859      *
6860      *
6861      * <pre>
6862      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6863      * </pre>
6864      *
6865      * <code>repeated string custom_request_headers = 27977992;</code>
6866      *
6867      * @param value The customRequestHeaders to add.
6868      * @return This builder for chaining.
6869      */
addCustomRequestHeaders(java.lang.String value)6870     public Builder addCustomRequestHeaders(java.lang.String value) {
6871       if (value == null) {
6872         throw new NullPointerException();
6873       }
6874       ensureCustomRequestHeadersIsMutable();
6875       customRequestHeaders_.add(value);
6876       onChanged();
6877       return this;
6878     }
6879     /**
6880      *
6881      *
6882      * <pre>
6883      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6884      * </pre>
6885      *
6886      * <code>repeated string custom_request_headers = 27977992;</code>
6887      *
6888      * @param values The customRequestHeaders to add.
6889      * @return This builder for chaining.
6890      */
addAllCustomRequestHeaders(java.lang.Iterable<java.lang.String> values)6891     public Builder addAllCustomRequestHeaders(java.lang.Iterable<java.lang.String> values) {
6892       ensureCustomRequestHeadersIsMutable();
6893       com.google.protobuf.AbstractMessageLite.Builder.addAll(values, customRequestHeaders_);
6894       onChanged();
6895       return this;
6896     }
6897     /**
6898      *
6899      *
6900      * <pre>
6901      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6902      * </pre>
6903      *
6904      * <code>repeated string custom_request_headers = 27977992;</code>
6905      *
6906      * @return This builder for chaining.
6907      */
clearCustomRequestHeaders()6908     public Builder clearCustomRequestHeaders() {
6909       customRequestHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY;
6910       bitField0_ = (bitField0_ & ~0x00000200);
6911       onChanged();
6912       return this;
6913     }
6914     /**
6915      *
6916      *
6917      * <pre>
6918      * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6919      * </pre>
6920      *
6921      * <code>repeated string custom_request_headers = 27977992;</code>
6922      *
6923      * @param value The bytes of the customRequestHeaders to add.
6924      * @return This builder for chaining.
6925      */
addCustomRequestHeadersBytes(com.google.protobuf.ByteString value)6926     public Builder addCustomRequestHeadersBytes(com.google.protobuf.ByteString value) {
6927       if (value == null) {
6928         throw new NullPointerException();
6929       }
6930       checkByteStringIsUtf8(value);
6931       ensureCustomRequestHeadersIsMutable();
6932       customRequestHeaders_.add(value);
6933       onChanged();
6934       return this;
6935     }
6936 
6937     private com.google.protobuf.LazyStringList customResponseHeaders_ =
6938         com.google.protobuf.LazyStringArrayList.EMPTY;
6939 
ensureCustomResponseHeadersIsMutable()6940     private void ensureCustomResponseHeadersIsMutable() {
6941       if (!((bitField0_ & 0x00000400) != 0)) {
6942         customResponseHeaders_ =
6943             new com.google.protobuf.LazyStringArrayList(customResponseHeaders_);
6944         bitField0_ |= 0x00000400;
6945       }
6946     }
6947     /**
6948      *
6949      *
6950      * <pre>
6951      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6952      * </pre>
6953      *
6954      * <code>repeated string custom_response_headers = 387539094;</code>
6955      *
6956      * @return A list containing the customResponseHeaders.
6957      */
getCustomResponseHeadersList()6958     public com.google.protobuf.ProtocolStringList getCustomResponseHeadersList() {
6959       return customResponseHeaders_.getUnmodifiableView();
6960     }
6961     /**
6962      *
6963      *
6964      * <pre>
6965      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6966      * </pre>
6967      *
6968      * <code>repeated string custom_response_headers = 387539094;</code>
6969      *
6970      * @return The count of customResponseHeaders.
6971      */
getCustomResponseHeadersCount()6972     public int getCustomResponseHeadersCount() {
6973       return customResponseHeaders_.size();
6974     }
6975     /**
6976      *
6977      *
6978      * <pre>
6979      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6980      * </pre>
6981      *
6982      * <code>repeated string custom_response_headers = 387539094;</code>
6983      *
6984      * @param index The index of the element to return.
6985      * @return The customResponseHeaders at the given index.
6986      */
getCustomResponseHeaders(int index)6987     public java.lang.String getCustomResponseHeaders(int index) {
6988       return customResponseHeaders_.get(index);
6989     }
6990     /**
6991      *
6992      *
6993      * <pre>
6994      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
6995      * </pre>
6996      *
6997      * <code>repeated string custom_response_headers = 387539094;</code>
6998      *
6999      * @param index The index of the value to return.
7000      * @return The bytes of the customResponseHeaders at the given index.
7001      */
getCustomResponseHeadersBytes(int index)7002     public com.google.protobuf.ByteString getCustomResponseHeadersBytes(int index) {
7003       return customResponseHeaders_.getByteString(index);
7004     }
7005     /**
7006      *
7007      *
7008      * <pre>
7009      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
7010      * </pre>
7011      *
7012      * <code>repeated string custom_response_headers = 387539094;</code>
7013      *
7014      * @param index The index to set the value at.
7015      * @param value The customResponseHeaders to set.
7016      * @return This builder for chaining.
7017      */
setCustomResponseHeaders(int index, java.lang.String value)7018     public Builder setCustomResponseHeaders(int index, java.lang.String value) {
7019       if (value == null) {
7020         throw new NullPointerException();
7021       }
7022       ensureCustomResponseHeadersIsMutable();
7023       customResponseHeaders_.set(index, value);
7024       onChanged();
7025       return this;
7026     }
7027     /**
7028      *
7029      *
7030      * <pre>
7031      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
7032      * </pre>
7033      *
7034      * <code>repeated string custom_response_headers = 387539094;</code>
7035      *
7036      * @param value The customResponseHeaders to add.
7037      * @return This builder for chaining.
7038      */
addCustomResponseHeaders(java.lang.String value)7039     public Builder addCustomResponseHeaders(java.lang.String value) {
7040       if (value == null) {
7041         throw new NullPointerException();
7042       }
7043       ensureCustomResponseHeadersIsMutable();
7044       customResponseHeaders_.add(value);
7045       onChanged();
7046       return this;
7047     }
7048     /**
7049      *
7050      *
7051      * <pre>
7052      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
7053      * </pre>
7054      *
7055      * <code>repeated string custom_response_headers = 387539094;</code>
7056      *
7057      * @param values The customResponseHeaders to add.
7058      * @return This builder for chaining.
7059      */
addAllCustomResponseHeaders(java.lang.Iterable<java.lang.String> values)7060     public Builder addAllCustomResponseHeaders(java.lang.Iterable<java.lang.String> values) {
7061       ensureCustomResponseHeadersIsMutable();
7062       com.google.protobuf.AbstractMessageLite.Builder.addAll(values, customResponseHeaders_);
7063       onChanged();
7064       return this;
7065     }
7066     /**
7067      *
7068      *
7069      * <pre>
7070      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
7071      * </pre>
7072      *
7073      * <code>repeated string custom_response_headers = 387539094;</code>
7074      *
7075      * @return This builder for chaining.
7076      */
clearCustomResponseHeaders()7077     public Builder clearCustomResponseHeaders() {
7078       customResponseHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY;
7079       bitField0_ = (bitField0_ & ~0x00000400);
7080       onChanged();
7081       return this;
7082     }
7083     /**
7084      *
7085      *
7086      * <pre>
7087      * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers).
7088      * </pre>
7089      *
7090      * <code>repeated string custom_response_headers = 387539094;</code>
7091      *
7092      * @param value The bytes of the customResponseHeaders to add.
7093      * @return This builder for chaining.
7094      */
addCustomResponseHeadersBytes(com.google.protobuf.ByteString value)7095     public Builder addCustomResponseHeadersBytes(com.google.protobuf.ByteString value) {
7096       if (value == null) {
7097         throw new NullPointerException();
7098       }
7099       checkByteStringIsUtf8(value);
7100       ensureCustomResponseHeadersIsMutable();
7101       customResponseHeaders_.add(value);
7102       onChanged();
7103       return this;
7104     }
7105 
7106     private java.lang.Object description_ = "";
7107     /**
7108      *
7109      *
7110      * <pre>
7111      * An optional description of this resource. Provide this property when you create the resource.
7112      * </pre>
7113      *
7114      * <code>optional string description = 422937596;</code>
7115      *
7116      * @return Whether the description field is set.
7117      */
hasDescription()7118     public boolean hasDescription() {
7119       return ((bitField0_ & 0x00000800) != 0);
7120     }
7121     /**
7122      *
7123      *
7124      * <pre>
7125      * An optional description of this resource. Provide this property when you create the resource.
7126      * </pre>
7127      *
7128      * <code>optional string description = 422937596;</code>
7129      *
7130      * @return The description.
7131      */
getDescription()7132     public java.lang.String getDescription() {
7133       java.lang.Object ref = description_;
7134       if (!(ref instanceof java.lang.String)) {
7135         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
7136         java.lang.String s = bs.toStringUtf8();
7137         description_ = s;
7138         return s;
7139       } else {
7140         return (java.lang.String) ref;
7141       }
7142     }
7143     /**
7144      *
7145      *
7146      * <pre>
7147      * An optional description of this resource. Provide this property when you create the resource.
7148      * </pre>
7149      *
7150      * <code>optional string description = 422937596;</code>
7151      *
7152      * @return The bytes for description.
7153      */
getDescriptionBytes()7154     public com.google.protobuf.ByteString getDescriptionBytes() {
7155       java.lang.Object ref = description_;
7156       if (ref instanceof String) {
7157         com.google.protobuf.ByteString b =
7158             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
7159         description_ = b;
7160         return b;
7161       } else {
7162         return (com.google.protobuf.ByteString) ref;
7163       }
7164     }
7165     /**
7166      *
7167      *
7168      * <pre>
7169      * An optional description of this resource. Provide this property when you create the resource.
7170      * </pre>
7171      *
7172      * <code>optional string description = 422937596;</code>
7173      *
7174      * @param value The description to set.
7175      * @return This builder for chaining.
7176      */
setDescription(java.lang.String value)7177     public Builder setDescription(java.lang.String value) {
7178       if (value == null) {
7179         throw new NullPointerException();
7180       }
7181       description_ = value;
7182       bitField0_ |= 0x00000800;
7183       onChanged();
7184       return this;
7185     }
7186     /**
7187      *
7188      *
7189      * <pre>
7190      * An optional description of this resource. Provide this property when you create the resource.
7191      * </pre>
7192      *
7193      * <code>optional string description = 422937596;</code>
7194      *
7195      * @return This builder for chaining.
7196      */
clearDescription()7197     public Builder clearDescription() {
7198       description_ = getDefaultInstance().getDescription();
7199       bitField0_ = (bitField0_ & ~0x00000800);
7200       onChanged();
7201       return this;
7202     }
7203     /**
7204      *
7205      *
7206      * <pre>
7207      * An optional description of this resource. Provide this property when you create the resource.
7208      * </pre>
7209      *
7210      * <code>optional string description = 422937596;</code>
7211      *
7212      * @param value The bytes for description to set.
7213      * @return This builder for chaining.
7214      */
setDescriptionBytes(com.google.protobuf.ByteString value)7215     public Builder setDescriptionBytes(com.google.protobuf.ByteString value) {
7216       if (value == null) {
7217         throw new NullPointerException();
7218       }
7219       checkByteStringIsUtf8(value);
7220       description_ = value;
7221       bitField0_ |= 0x00000800;
7222       onChanged();
7223       return this;
7224     }
7225 
7226     private java.lang.Object edgeSecurityPolicy_ = "";
7227     /**
7228      *
7229      *
7230      * <pre>
7231      * [Output Only] The resource URL for the edge security policy associated with this backend service.
7232      * </pre>
7233      *
7234      * <code>optional string edge_security_policy = 41036943;</code>
7235      *
7236      * @return Whether the edgeSecurityPolicy field is set.
7237      */
hasEdgeSecurityPolicy()7238     public boolean hasEdgeSecurityPolicy() {
7239       return ((bitField0_ & 0x00001000) != 0);
7240     }
7241     /**
7242      *
7243      *
7244      * <pre>
7245      * [Output Only] The resource URL for the edge security policy associated with this backend service.
7246      * </pre>
7247      *
7248      * <code>optional string edge_security_policy = 41036943;</code>
7249      *
7250      * @return The edgeSecurityPolicy.
7251      */
getEdgeSecurityPolicy()7252     public java.lang.String getEdgeSecurityPolicy() {
7253       java.lang.Object ref = edgeSecurityPolicy_;
7254       if (!(ref instanceof java.lang.String)) {
7255         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
7256         java.lang.String s = bs.toStringUtf8();
7257         edgeSecurityPolicy_ = s;
7258         return s;
7259       } else {
7260         return (java.lang.String) ref;
7261       }
7262     }
7263     /**
7264      *
7265      *
7266      * <pre>
7267      * [Output Only] The resource URL for the edge security policy associated with this backend service.
7268      * </pre>
7269      *
7270      * <code>optional string edge_security_policy = 41036943;</code>
7271      *
7272      * @return The bytes for edgeSecurityPolicy.
7273      */
getEdgeSecurityPolicyBytes()7274     public com.google.protobuf.ByteString getEdgeSecurityPolicyBytes() {
7275       java.lang.Object ref = edgeSecurityPolicy_;
7276       if (ref instanceof String) {
7277         com.google.protobuf.ByteString b =
7278             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
7279         edgeSecurityPolicy_ = b;
7280         return b;
7281       } else {
7282         return (com.google.protobuf.ByteString) ref;
7283       }
7284     }
7285     /**
7286      *
7287      *
7288      * <pre>
7289      * [Output Only] The resource URL for the edge security policy associated with this backend service.
7290      * </pre>
7291      *
7292      * <code>optional string edge_security_policy = 41036943;</code>
7293      *
7294      * @param value The edgeSecurityPolicy to set.
7295      * @return This builder for chaining.
7296      */
setEdgeSecurityPolicy(java.lang.String value)7297     public Builder setEdgeSecurityPolicy(java.lang.String value) {
7298       if (value == null) {
7299         throw new NullPointerException();
7300       }
7301       edgeSecurityPolicy_ = value;
7302       bitField0_ |= 0x00001000;
7303       onChanged();
7304       return this;
7305     }
7306     /**
7307      *
7308      *
7309      * <pre>
7310      * [Output Only] The resource URL for the edge security policy associated with this backend service.
7311      * </pre>
7312      *
7313      * <code>optional string edge_security_policy = 41036943;</code>
7314      *
7315      * @return This builder for chaining.
7316      */
clearEdgeSecurityPolicy()7317     public Builder clearEdgeSecurityPolicy() {
7318       edgeSecurityPolicy_ = getDefaultInstance().getEdgeSecurityPolicy();
7319       bitField0_ = (bitField0_ & ~0x00001000);
7320       onChanged();
7321       return this;
7322     }
7323     /**
7324      *
7325      *
7326      * <pre>
7327      * [Output Only] The resource URL for the edge security policy associated with this backend service.
7328      * </pre>
7329      *
7330      * <code>optional string edge_security_policy = 41036943;</code>
7331      *
7332      * @param value The bytes for edgeSecurityPolicy to set.
7333      * @return This builder for chaining.
7334      */
setEdgeSecurityPolicyBytes(com.google.protobuf.ByteString value)7335     public Builder setEdgeSecurityPolicyBytes(com.google.protobuf.ByteString value) {
7336       if (value == null) {
7337         throw new NullPointerException();
7338       }
7339       checkByteStringIsUtf8(value);
7340       edgeSecurityPolicy_ = value;
7341       bitField0_ |= 0x00001000;
7342       onChanged();
7343       return this;
7344     }
7345 
7346     private boolean enableCDN_;
7347     /**
7348      *
7349      *
7350      * <pre>
7351      * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer.
7352      * </pre>
7353      *
7354      * <code>optional bool enable_c_d_n = 250733499;</code>
7355      *
7356      * @return Whether the enableCDN field is set.
7357      */
7358     @java.lang.Override
hasEnableCDN()7359     public boolean hasEnableCDN() {
7360       return ((bitField0_ & 0x00002000) != 0);
7361     }
7362     /**
7363      *
7364      *
7365      * <pre>
7366      * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer.
7367      * </pre>
7368      *
7369      * <code>optional bool enable_c_d_n = 250733499;</code>
7370      *
7371      * @return The enableCDN.
7372      */
7373     @java.lang.Override
getEnableCDN()7374     public boolean getEnableCDN() {
7375       return enableCDN_;
7376     }
7377     /**
7378      *
7379      *
7380      * <pre>
7381      * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer.
7382      * </pre>
7383      *
7384      * <code>optional bool enable_c_d_n = 250733499;</code>
7385      *
7386      * @param value The enableCDN to set.
7387      * @return This builder for chaining.
7388      */
setEnableCDN(boolean value)7389     public Builder setEnableCDN(boolean value) {
7390 
7391       enableCDN_ = value;
7392       bitField0_ |= 0x00002000;
7393       onChanged();
7394       return this;
7395     }
7396     /**
7397      *
7398      *
7399      * <pre>
7400      * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer.
7401      * </pre>
7402      *
7403      * <code>optional bool enable_c_d_n = 250733499;</code>
7404      *
7405      * @return This builder for chaining.
7406      */
clearEnableCDN()7407     public Builder clearEnableCDN() {
7408       bitField0_ = (bitField0_ & ~0x00002000);
7409       enableCDN_ = false;
7410       onChanged();
7411       return this;
7412     }
7413 
7414     private com.google.cloud.compute.v1.BackendServiceFailoverPolicy failoverPolicy_;
7415     private com.google.protobuf.SingleFieldBuilderV3<
7416             com.google.cloud.compute.v1.BackendServiceFailoverPolicy,
7417             com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder,
7418             com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder>
7419         failoverPolicyBuilder_;
7420     /**
7421      *
7422      *
7423      * <pre>
7424      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7425      * </pre>
7426      *
7427      * <code>
7428      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7429      * </code>
7430      *
7431      * @return Whether the failoverPolicy field is set.
7432      */
hasFailoverPolicy()7433     public boolean hasFailoverPolicy() {
7434       return ((bitField0_ & 0x00004000) != 0);
7435     }
7436     /**
7437      *
7438      *
7439      * <pre>
7440      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7441      * </pre>
7442      *
7443      * <code>
7444      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7445      * </code>
7446      *
7447      * @return The failoverPolicy.
7448      */
getFailoverPolicy()7449     public com.google.cloud.compute.v1.BackendServiceFailoverPolicy getFailoverPolicy() {
7450       if (failoverPolicyBuilder_ == null) {
7451         return failoverPolicy_ == null
7452             ? com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance()
7453             : failoverPolicy_;
7454       } else {
7455         return failoverPolicyBuilder_.getMessage();
7456       }
7457     }
7458     /**
7459      *
7460      *
7461      * <pre>
7462      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7463      * </pre>
7464      *
7465      * <code>
7466      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7467      * </code>
7468      */
setFailoverPolicy( com.google.cloud.compute.v1.BackendServiceFailoverPolicy value)7469     public Builder setFailoverPolicy(
7470         com.google.cloud.compute.v1.BackendServiceFailoverPolicy value) {
7471       if (failoverPolicyBuilder_ == null) {
7472         if (value == null) {
7473           throw new NullPointerException();
7474         }
7475         failoverPolicy_ = value;
7476       } else {
7477         failoverPolicyBuilder_.setMessage(value);
7478       }
7479       bitField0_ |= 0x00004000;
7480       onChanged();
7481       return this;
7482     }
7483     /**
7484      *
7485      *
7486      * <pre>
7487      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7488      * </pre>
7489      *
7490      * <code>
7491      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7492      * </code>
7493      */
setFailoverPolicy( com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder builderForValue)7494     public Builder setFailoverPolicy(
7495         com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder builderForValue) {
7496       if (failoverPolicyBuilder_ == null) {
7497         failoverPolicy_ = builderForValue.build();
7498       } else {
7499         failoverPolicyBuilder_.setMessage(builderForValue.build());
7500       }
7501       bitField0_ |= 0x00004000;
7502       onChanged();
7503       return this;
7504     }
7505     /**
7506      *
7507      *
7508      * <pre>
7509      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7510      * </pre>
7511      *
7512      * <code>
7513      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7514      * </code>
7515      */
mergeFailoverPolicy( com.google.cloud.compute.v1.BackendServiceFailoverPolicy value)7516     public Builder mergeFailoverPolicy(
7517         com.google.cloud.compute.v1.BackendServiceFailoverPolicy value) {
7518       if (failoverPolicyBuilder_ == null) {
7519         if (((bitField0_ & 0x00004000) != 0)
7520             && failoverPolicy_ != null
7521             && failoverPolicy_
7522                 != com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance()) {
7523           getFailoverPolicyBuilder().mergeFrom(value);
7524         } else {
7525           failoverPolicy_ = value;
7526         }
7527       } else {
7528         failoverPolicyBuilder_.mergeFrom(value);
7529       }
7530       bitField0_ |= 0x00004000;
7531       onChanged();
7532       return this;
7533     }
7534     /**
7535      *
7536      *
7537      * <pre>
7538      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7539      * </pre>
7540      *
7541      * <code>
7542      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7543      * </code>
7544      */
clearFailoverPolicy()7545     public Builder clearFailoverPolicy() {
7546       bitField0_ = (bitField0_ & ~0x00004000);
7547       failoverPolicy_ = null;
7548       if (failoverPolicyBuilder_ != null) {
7549         failoverPolicyBuilder_.dispose();
7550         failoverPolicyBuilder_ = null;
7551       }
7552       onChanged();
7553       return this;
7554     }
7555     /**
7556      *
7557      *
7558      * <pre>
7559      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7560      * </pre>
7561      *
7562      * <code>
7563      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7564      * </code>
7565      */
7566     public com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder
getFailoverPolicyBuilder()7567         getFailoverPolicyBuilder() {
7568       bitField0_ |= 0x00004000;
7569       onChanged();
7570       return getFailoverPolicyFieldBuilder().getBuilder();
7571     }
7572     /**
7573      *
7574      *
7575      * <pre>
7576      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7577      * </pre>
7578      *
7579      * <code>
7580      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7581      * </code>
7582      */
7583     public com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder
getFailoverPolicyOrBuilder()7584         getFailoverPolicyOrBuilder() {
7585       if (failoverPolicyBuilder_ != null) {
7586         return failoverPolicyBuilder_.getMessageOrBuilder();
7587       } else {
7588         return failoverPolicy_ == null
7589             ? com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance()
7590             : failoverPolicy_;
7591       }
7592     }
7593     /**
7594      *
7595      *
7596      * <pre>
7597      * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview).
7598      * </pre>
7599      *
7600      * <code>
7601      * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655;
7602      * </code>
7603      */
7604     private com.google.protobuf.SingleFieldBuilderV3<
7605             com.google.cloud.compute.v1.BackendServiceFailoverPolicy,
7606             com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder,
7607             com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder>
getFailoverPolicyFieldBuilder()7608         getFailoverPolicyFieldBuilder() {
7609       if (failoverPolicyBuilder_ == null) {
7610         failoverPolicyBuilder_ =
7611             new com.google.protobuf.SingleFieldBuilderV3<
7612                 com.google.cloud.compute.v1.BackendServiceFailoverPolicy,
7613                 com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder,
7614                 com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder>(
7615                 getFailoverPolicy(), getParentForChildren(), isClean());
7616         failoverPolicy_ = null;
7617       }
7618       return failoverPolicyBuilder_;
7619     }
7620 
7621     private java.lang.Object fingerprint_ = "";
7622     /**
7623      *
7624      *
7625      * <pre>
7626      * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
7627      * </pre>
7628      *
7629      * <code>optional string fingerprint = 234678500;</code>
7630      *
7631      * @return Whether the fingerprint field is set.
7632      */
hasFingerprint()7633     public boolean hasFingerprint() {
7634       return ((bitField0_ & 0x00008000) != 0);
7635     }
7636     /**
7637      *
7638      *
7639      * <pre>
7640      * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
7641      * </pre>
7642      *
7643      * <code>optional string fingerprint = 234678500;</code>
7644      *
7645      * @return The fingerprint.
7646      */
getFingerprint()7647     public java.lang.String getFingerprint() {
7648       java.lang.Object ref = fingerprint_;
7649       if (!(ref instanceof java.lang.String)) {
7650         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
7651         java.lang.String s = bs.toStringUtf8();
7652         fingerprint_ = s;
7653         return s;
7654       } else {
7655         return (java.lang.String) ref;
7656       }
7657     }
7658     /**
7659      *
7660      *
7661      * <pre>
7662      * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
7663      * </pre>
7664      *
7665      * <code>optional string fingerprint = 234678500;</code>
7666      *
7667      * @return The bytes for fingerprint.
7668      */
getFingerprintBytes()7669     public com.google.protobuf.ByteString getFingerprintBytes() {
7670       java.lang.Object ref = fingerprint_;
7671       if (ref instanceof String) {
7672         com.google.protobuf.ByteString b =
7673             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
7674         fingerprint_ = b;
7675         return b;
7676       } else {
7677         return (com.google.protobuf.ByteString) ref;
7678       }
7679     }
7680     /**
7681      *
7682      *
7683      * <pre>
7684      * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
7685      * </pre>
7686      *
7687      * <code>optional string fingerprint = 234678500;</code>
7688      *
7689      * @param value The fingerprint to set.
7690      * @return This builder for chaining.
7691      */
setFingerprint(java.lang.String value)7692     public Builder setFingerprint(java.lang.String value) {
7693       if (value == null) {
7694         throw new NullPointerException();
7695       }
7696       fingerprint_ = value;
7697       bitField0_ |= 0x00008000;
7698       onChanged();
7699       return this;
7700     }
7701     /**
7702      *
7703      *
7704      * <pre>
7705      * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
7706      * </pre>
7707      *
7708      * <code>optional string fingerprint = 234678500;</code>
7709      *
7710      * @return This builder for chaining.
7711      */
clearFingerprint()7712     public Builder clearFingerprint() {
7713       fingerprint_ = getDefaultInstance().getFingerprint();
7714       bitField0_ = (bitField0_ & ~0x00008000);
7715       onChanged();
7716       return this;
7717     }
7718     /**
7719      *
7720      *
7721      * <pre>
7722      * 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 BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService.
7723      * </pre>
7724      *
7725      * <code>optional string fingerprint = 234678500;</code>
7726      *
7727      * @param value The bytes for fingerprint to set.
7728      * @return This builder for chaining.
7729      */
setFingerprintBytes(com.google.protobuf.ByteString value)7730     public Builder setFingerprintBytes(com.google.protobuf.ByteString value) {
7731       if (value == null) {
7732         throw new NullPointerException();
7733       }
7734       checkByteStringIsUtf8(value);
7735       fingerprint_ = value;
7736       bitField0_ |= 0x00008000;
7737       onChanged();
7738       return this;
7739     }
7740 
7741     private com.google.protobuf.LazyStringList healthChecks_ =
7742         com.google.protobuf.LazyStringArrayList.EMPTY;
7743 
ensureHealthChecksIsMutable()7744     private void ensureHealthChecksIsMutable() {
7745       if (!((bitField0_ & 0x00010000) != 0)) {
7746         healthChecks_ = new com.google.protobuf.LazyStringArrayList(healthChecks_);
7747         bitField0_ |= 0x00010000;
7748       }
7749     }
7750     /**
7751      *
7752      *
7753      * <pre>
7754      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7755      * </pre>
7756      *
7757      * <code>repeated string health_checks = 448370606;</code>
7758      *
7759      * @return A list containing the healthChecks.
7760      */
getHealthChecksList()7761     public com.google.protobuf.ProtocolStringList getHealthChecksList() {
7762       return healthChecks_.getUnmodifiableView();
7763     }
7764     /**
7765      *
7766      *
7767      * <pre>
7768      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7769      * </pre>
7770      *
7771      * <code>repeated string health_checks = 448370606;</code>
7772      *
7773      * @return The count of healthChecks.
7774      */
getHealthChecksCount()7775     public int getHealthChecksCount() {
7776       return healthChecks_.size();
7777     }
7778     /**
7779      *
7780      *
7781      * <pre>
7782      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7783      * </pre>
7784      *
7785      * <code>repeated string health_checks = 448370606;</code>
7786      *
7787      * @param index The index of the element to return.
7788      * @return The healthChecks at the given index.
7789      */
getHealthChecks(int index)7790     public java.lang.String getHealthChecks(int index) {
7791       return healthChecks_.get(index);
7792     }
7793     /**
7794      *
7795      *
7796      * <pre>
7797      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7798      * </pre>
7799      *
7800      * <code>repeated string health_checks = 448370606;</code>
7801      *
7802      * @param index The index of the value to return.
7803      * @return The bytes of the healthChecks at the given index.
7804      */
getHealthChecksBytes(int index)7805     public com.google.protobuf.ByteString getHealthChecksBytes(int index) {
7806       return healthChecks_.getByteString(index);
7807     }
7808     /**
7809      *
7810      *
7811      * <pre>
7812      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7813      * </pre>
7814      *
7815      * <code>repeated string health_checks = 448370606;</code>
7816      *
7817      * @param index The index to set the value at.
7818      * @param value The healthChecks to set.
7819      * @return This builder for chaining.
7820      */
setHealthChecks(int index, java.lang.String value)7821     public Builder setHealthChecks(int index, java.lang.String value) {
7822       if (value == null) {
7823         throw new NullPointerException();
7824       }
7825       ensureHealthChecksIsMutable();
7826       healthChecks_.set(index, value);
7827       onChanged();
7828       return this;
7829     }
7830     /**
7831      *
7832      *
7833      * <pre>
7834      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7835      * </pre>
7836      *
7837      * <code>repeated string health_checks = 448370606;</code>
7838      *
7839      * @param value The healthChecks to add.
7840      * @return This builder for chaining.
7841      */
addHealthChecks(java.lang.String value)7842     public Builder addHealthChecks(java.lang.String value) {
7843       if (value == null) {
7844         throw new NullPointerException();
7845       }
7846       ensureHealthChecksIsMutable();
7847       healthChecks_.add(value);
7848       onChanged();
7849       return this;
7850     }
7851     /**
7852      *
7853      *
7854      * <pre>
7855      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7856      * </pre>
7857      *
7858      * <code>repeated string health_checks = 448370606;</code>
7859      *
7860      * @param values The healthChecks to add.
7861      * @return This builder for chaining.
7862      */
addAllHealthChecks(java.lang.Iterable<java.lang.String> values)7863     public Builder addAllHealthChecks(java.lang.Iterable<java.lang.String> values) {
7864       ensureHealthChecksIsMutable();
7865       com.google.protobuf.AbstractMessageLite.Builder.addAll(values, healthChecks_);
7866       onChanged();
7867       return this;
7868     }
7869     /**
7870      *
7871      *
7872      * <pre>
7873      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7874      * </pre>
7875      *
7876      * <code>repeated string health_checks = 448370606;</code>
7877      *
7878      * @return This builder for chaining.
7879      */
clearHealthChecks()7880     public Builder clearHealthChecks() {
7881       healthChecks_ = com.google.protobuf.LazyStringArrayList.EMPTY;
7882       bitField0_ = (bitField0_ & ~0x00010000);
7883       onChanged();
7884       return this;
7885     }
7886     /**
7887      *
7888      *
7889      * <pre>
7890      * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check.
7891      * </pre>
7892      *
7893      * <code>repeated string health_checks = 448370606;</code>
7894      *
7895      * @param value The bytes of the healthChecks to add.
7896      * @return This builder for chaining.
7897      */
addHealthChecksBytes(com.google.protobuf.ByteString value)7898     public Builder addHealthChecksBytes(com.google.protobuf.ByteString value) {
7899       if (value == null) {
7900         throw new NullPointerException();
7901       }
7902       checkByteStringIsUtf8(value);
7903       ensureHealthChecksIsMutable();
7904       healthChecks_.add(value);
7905       onChanged();
7906       return this;
7907     }
7908 
7909     private com.google.cloud.compute.v1.BackendServiceIAP iap_;
7910     private com.google.protobuf.SingleFieldBuilderV3<
7911             com.google.cloud.compute.v1.BackendServiceIAP,
7912             com.google.cloud.compute.v1.BackendServiceIAP.Builder,
7913             com.google.cloud.compute.v1.BackendServiceIAPOrBuilder>
7914         iapBuilder_;
7915     /**
7916      *
7917      *
7918      * <pre>
7919      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
7920      * </pre>
7921      *
7922      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
7923      *
7924      * @return Whether the iap field is set.
7925      */
hasIap()7926     public boolean hasIap() {
7927       return ((bitField0_ & 0x00020000) != 0);
7928     }
7929     /**
7930      *
7931      *
7932      * <pre>
7933      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
7934      * </pre>
7935      *
7936      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
7937      *
7938      * @return The iap.
7939      */
getIap()7940     public com.google.cloud.compute.v1.BackendServiceIAP getIap() {
7941       if (iapBuilder_ == null) {
7942         return iap_ == null
7943             ? com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance()
7944             : iap_;
7945       } else {
7946         return iapBuilder_.getMessage();
7947       }
7948     }
7949     /**
7950      *
7951      *
7952      * <pre>
7953      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
7954      * </pre>
7955      *
7956      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
7957      */
setIap(com.google.cloud.compute.v1.BackendServiceIAP value)7958     public Builder setIap(com.google.cloud.compute.v1.BackendServiceIAP value) {
7959       if (iapBuilder_ == null) {
7960         if (value == null) {
7961           throw new NullPointerException();
7962         }
7963         iap_ = value;
7964       } else {
7965         iapBuilder_.setMessage(value);
7966       }
7967       bitField0_ |= 0x00020000;
7968       onChanged();
7969       return this;
7970     }
7971     /**
7972      *
7973      *
7974      * <pre>
7975      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
7976      * </pre>
7977      *
7978      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
7979      */
setIap(com.google.cloud.compute.v1.BackendServiceIAP.Builder builderForValue)7980     public Builder setIap(com.google.cloud.compute.v1.BackendServiceIAP.Builder builderForValue) {
7981       if (iapBuilder_ == null) {
7982         iap_ = builderForValue.build();
7983       } else {
7984         iapBuilder_.setMessage(builderForValue.build());
7985       }
7986       bitField0_ |= 0x00020000;
7987       onChanged();
7988       return this;
7989     }
7990     /**
7991      *
7992      *
7993      * <pre>
7994      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
7995      * </pre>
7996      *
7997      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
7998      */
mergeIap(com.google.cloud.compute.v1.BackendServiceIAP value)7999     public Builder mergeIap(com.google.cloud.compute.v1.BackendServiceIAP value) {
8000       if (iapBuilder_ == null) {
8001         if (((bitField0_ & 0x00020000) != 0)
8002             && iap_ != null
8003             && iap_ != com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance()) {
8004           getIapBuilder().mergeFrom(value);
8005         } else {
8006           iap_ = value;
8007         }
8008       } else {
8009         iapBuilder_.mergeFrom(value);
8010       }
8011       bitField0_ |= 0x00020000;
8012       onChanged();
8013       return this;
8014     }
8015     /**
8016      *
8017      *
8018      * <pre>
8019      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
8020      * </pre>
8021      *
8022      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
8023      */
clearIap()8024     public Builder clearIap() {
8025       bitField0_ = (bitField0_ & ~0x00020000);
8026       iap_ = null;
8027       if (iapBuilder_ != null) {
8028         iapBuilder_.dispose();
8029         iapBuilder_ = null;
8030       }
8031       onChanged();
8032       return this;
8033     }
8034     /**
8035      *
8036      *
8037      * <pre>
8038      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
8039      * </pre>
8040      *
8041      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
8042      */
getIapBuilder()8043     public com.google.cloud.compute.v1.BackendServiceIAP.Builder getIapBuilder() {
8044       bitField0_ |= 0x00020000;
8045       onChanged();
8046       return getIapFieldBuilder().getBuilder();
8047     }
8048     /**
8049      *
8050      *
8051      * <pre>
8052      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
8053      * </pre>
8054      *
8055      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
8056      */
getIapOrBuilder()8057     public com.google.cloud.compute.v1.BackendServiceIAPOrBuilder getIapOrBuilder() {
8058       if (iapBuilder_ != null) {
8059         return iapBuilder_.getMessageOrBuilder();
8060       } else {
8061         return iap_ == null
8062             ? com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance()
8063             : iap_;
8064       }
8065     }
8066     /**
8067      *
8068      *
8069      * <pre>
8070      * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing.
8071      * </pre>
8072      *
8073      * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code>
8074      */
8075     private com.google.protobuf.SingleFieldBuilderV3<
8076             com.google.cloud.compute.v1.BackendServiceIAP,
8077             com.google.cloud.compute.v1.BackendServiceIAP.Builder,
8078             com.google.cloud.compute.v1.BackendServiceIAPOrBuilder>
getIapFieldBuilder()8079         getIapFieldBuilder() {
8080       if (iapBuilder_ == null) {
8081         iapBuilder_ =
8082             new com.google.protobuf.SingleFieldBuilderV3<
8083                 com.google.cloud.compute.v1.BackendServiceIAP,
8084                 com.google.cloud.compute.v1.BackendServiceIAP.Builder,
8085                 com.google.cloud.compute.v1.BackendServiceIAPOrBuilder>(
8086                 getIap(), getParentForChildren(), isClean());
8087         iap_ = null;
8088       }
8089       return iapBuilder_;
8090     }
8091 
8092     private long id_;
8093     /**
8094      *
8095      *
8096      * <pre>
8097      * [Output Only] The unique identifier for the resource. This identifier is defined by the server.
8098      * </pre>
8099      *
8100      * <code>optional uint64 id = 3355;</code>
8101      *
8102      * @return Whether the id field is set.
8103      */
8104     @java.lang.Override
hasId()8105     public boolean hasId() {
8106       return ((bitField0_ & 0x00040000) != 0);
8107     }
8108     /**
8109      *
8110      *
8111      * <pre>
8112      * [Output Only] The unique identifier for the resource. This identifier is defined by the server.
8113      * </pre>
8114      *
8115      * <code>optional uint64 id = 3355;</code>
8116      *
8117      * @return The id.
8118      */
8119     @java.lang.Override
getId()8120     public long getId() {
8121       return id_;
8122     }
8123     /**
8124      *
8125      *
8126      * <pre>
8127      * [Output Only] The unique identifier for the resource. This identifier is defined by the server.
8128      * </pre>
8129      *
8130      * <code>optional uint64 id = 3355;</code>
8131      *
8132      * @param value The id to set.
8133      * @return This builder for chaining.
8134      */
setId(long value)8135     public Builder setId(long value) {
8136 
8137       id_ = value;
8138       bitField0_ |= 0x00040000;
8139       onChanged();
8140       return this;
8141     }
8142     /**
8143      *
8144      *
8145      * <pre>
8146      * [Output Only] The unique identifier for the resource. This identifier is defined by the server.
8147      * </pre>
8148      *
8149      * <code>optional uint64 id = 3355;</code>
8150      *
8151      * @return This builder for chaining.
8152      */
clearId()8153     public Builder clearId() {
8154       bitField0_ = (bitField0_ & ~0x00040000);
8155       id_ = 0L;
8156       onChanged();
8157       return this;
8158     }
8159 
8160     private java.lang.Object kind_ = "";
8161     /**
8162      *
8163      *
8164      * <pre>
8165      * [Output Only] Type of resource. Always compute#backendService for backend services.
8166      * </pre>
8167      *
8168      * <code>optional string kind = 3292052;</code>
8169      *
8170      * @return Whether the kind field is set.
8171      */
hasKind()8172     public boolean hasKind() {
8173       return ((bitField0_ & 0x00080000) != 0);
8174     }
8175     /**
8176      *
8177      *
8178      * <pre>
8179      * [Output Only] Type of resource. Always compute#backendService for backend services.
8180      * </pre>
8181      *
8182      * <code>optional string kind = 3292052;</code>
8183      *
8184      * @return The kind.
8185      */
getKind()8186     public java.lang.String getKind() {
8187       java.lang.Object ref = kind_;
8188       if (!(ref instanceof java.lang.String)) {
8189         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
8190         java.lang.String s = bs.toStringUtf8();
8191         kind_ = s;
8192         return s;
8193       } else {
8194         return (java.lang.String) ref;
8195       }
8196     }
8197     /**
8198      *
8199      *
8200      * <pre>
8201      * [Output Only] Type of resource. Always compute#backendService for backend services.
8202      * </pre>
8203      *
8204      * <code>optional string kind = 3292052;</code>
8205      *
8206      * @return The bytes for kind.
8207      */
getKindBytes()8208     public com.google.protobuf.ByteString getKindBytes() {
8209       java.lang.Object ref = kind_;
8210       if (ref instanceof String) {
8211         com.google.protobuf.ByteString b =
8212             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
8213         kind_ = b;
8214         return b;
8215       } else {
8216         return (com.google.protobuf.ByteString) ref;
8217       }
8218     }
8219     /**
8220      *
8221      *
8222      * <pre>
8223      * [Output Only] Type of resource. Always compute#backendService for backend services.
8224      * </pre>
8225      *
8226      * <code>optional string kind = 3292052;</code>
8227      *
8228      * @param value The kind to set.
8229      * @return This builder for chaining.
8230      */
setKind(java.lang.String value)8231     public Builder setKind(java.lang.String value) {
8232       if (value == null) {
8233         throw new NullPointerException();
8234       }
8235       kind_ = value;
8236       bitField0_ |= 0x00080000;
8237       onChanged();
8238       return this;
8239     }
8240     /**
8241      *
8242      *
8243      * <pre>
8244      * [Output Only] Type of resource. Always compute#backendService for backend services.
8245      * </pre>
8246      *
8247      * <code>optional string kind = 3292052;</code>
8248      *
8249      * @return This builder for chaining.
8250      */
clearKind()8251     public Builder clearKind() {
8252       kind_ = getDefaultInstance().getKind();
8253       bitField0_ = (bitField0_ & ~0x00080000);
8254       onChanged();
8255       return this;
8256     }
8257     /**
8258      *
8259      *
8260      * <pre>
8261      * [Output Only] Type of resource. Always compute#backendService for backend services.
8262      * </pre>
8263      *
8264      * <code>optional string kind = 3292052;</code>
8265      *
8266      * @param value The bytes for kind to set.
8267      * @return This builder for chaining.
8268      */
setKindBytes(com.google.protobuf.ByteString value)8269     public Builder setKindBytes(com.google.protobuf.ByteString value) {
8270       if (value == null) {
8271         throw new NullPointerException();
8272       }
8273       checkByteStringIsUtf8(value);
8274       kind_ = value;
8275       bitField0_ |= 0x00080000;
8276       onChanged();
8277       return this;
8278     }
8279 
8280     private java.lang.Object loadBalancingScheme_ = "";
8281     /**
8282      *
8283      *
8284      * <pre>
8285      * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
8286      * Check the LoadBalancingScheme enum for the list of possible values.
8287      * </pre>
8288      *
8289      * <code>optional string load_balancing_scheme = 363890244;</code>
8290      *
8291      * @return Whether the loadBalancingScheme field is set.
8292      */
hasLoadBalancingScheme()8293     public boolean hasLoadBalancingScheme() {
8294       return ((bitField0_ & 0x00100000) != 0);
8295     }
8296     /**
8297      *
8298      *
8299      * <pre>
8300      * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
8301      * Check the LoadBalancingScheme enum for the list of possible values.
8302      * </pre>
8303      *
8304      * <code>optional string load_balancing_scheme = 363890244;</code>
8305      *
8306      * @return The loadBalancingScheme.
8307      */
getLoadBalancingScheme()8308     public java.lang.String getLoadBalancingScheme() {
8309       java.lang.Object ref = loadBalancingScheme_;
8310       if (!(ref instanceof java.lang.String)) {
8311         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
8312         java.lang.String s = bs.toStringUtf8();
8313         loadBalancingScheme_ = s;
8314         return s;
8315       } else {
8316         return (java.lang.String) ref;
8317       }
8318     }
8319     /**
8320      *
8321      *
8322      * <pre>
8323      * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
8324      * Check the LoadBalancingScheme enum for the list of possible values.
8325      * </pre>
8326      *
8327      * <code>optional string load_balancing_scheme = 363890244;</code>
8328      *
8329      * @return The bytes for loadBalancingScheme.
8330      */
getLoadBalancingSchemeBytes()8331     public com.google.protobuf.ByteString getLoadBalancingSchemeBytes() {
8332       java.lang.Object ref = loadBalancingScheme_;
8333       if (ref instanceof String) {
8334         com.google.protobuf.ByteString b =
8335             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
8336         loadBalancingScheme_ = b;
8337         return b;
8338       } else {
8339         return (com.google.protobuf.ByteString) ref;
8340       }
8341     }
8342     /**
8343      *
8344      *
8345      * <pre>
8346      * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
8347      * Check the LoadBalancingScheme enum for the list of possible values.
8348      * </pre>
8349      *
8350      * <code>optional string load_balancing_scheme = 363890244;</code>
8351      *
8352      * @param value The loadBalancingScheme to set.
8353      * @return This builder for chaining.
8354      */
setLoadBalancingScheme(java.lang.String value)8355     public Builder setLoadBalancingScheme(java.lang.String value) {
8356       if (value == null) {
8357         throw new NullPointerException();
8358       }
8359       loadBalancingScheme_ = value;
8360       bitField0_ |= 0x00100000;
8361       onChanged();
8362       return this;
8363     }
8364     /**
8365      *
8366      *
8367      * <pre>
8368      * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
8369      * Check the LoadBalancingScheme enum for the list of possible values.
8370      * </pre>
8371      *
8372      * <code>optional string load_balancing_scheme = 363890244;</code>
8373      *
8374      * @return This builder for chaining.
8375      */
clearLoadBalancingScheme()8376     public Builder clearLoadBalancingScheme() {
8377       loadBalancingScheme_ = getDefaultInstance().getLoadBalancingScheme();
8378       bitField0_ = (bitField0_ & ~0x00100000);
8379       onChanged();
8380       return this;
8381     }
8382     /**
8383      *
8384      *
8385      * <pre>
8386      * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer.
8387      * Check the LoadBalancingScheme enum for the list of possible values.
8388      * </pre>
8389      *
8390      * <code>optional string load_balancing_scheme = 363890244;</code>
8391      *
8392      * @param value The bytes for loadBalancingScheme to set.
8393      * @return This builder for chaining.
8394      */
setLoadBalancingSchemeBytes(com.google.protobuf.ByteString value)8395     public Builder setLoadBalancingSchemeBytes(com.google.protobuf.ByteString value) {
8396       if (value == null) {
8397         throw new NullPointerException();
8398       }
8399       checkByteStringIsUtf8(value);
8400       loadBalancingScheme_ = value;
8401       bitField0_ |= 0x00100000;
8402       onChanged();
8403       return this;
8404     }
8405 
8406     private java.util.List<
8407             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig>
8408         localityLbPolicies_ = java.util.Collections.emptyList();
8409 
ensureLocalityLbPoliciesIsMutable()8410     private void ensureLocalityLbPoliciesIsMutable() {
8411       if (!((bitField0_ & 0x00200000) != 0)) {
8412         localityLbPolicies_ =
8413             new java.util.ArrayList<
8414                 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig>(
8415                 localityLbPolicies_);
8416         bitField0_ |= 0x00200000;
8417       }
8418     }
8419 
8420     private com.google.protobuf.RepeatedFieldBuilderV3<
8421             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig,
8422             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder,
8423             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder>
8424         localityLbPoliciesBuilder_;
8425 
8426     /**
8427      *
8428      *
8429      * <pre>
8430      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8431      * </pre>
8432      *
8433      * <code>
8434      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8435      * </code>
8436      */
8437     public java.util.List<
8438             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig>
getLocalityLbPoliciesList()8439         getLocalityLbPoliciesList() {
8440       if (localityLbPoliciesBuilder_ == null) {
8441         return java.util.Collections.unmodifiableList(localityLbPolicies_);
8442       } else {
8443         return localityLbPoliciesBuilder_.getMessageList();
8444       }
8445     }
8446     /**
8447      *
8448      *
8449      * <pre>
8450      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8451      * </pre>
8452      *
8453      * <code>
8454      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8455      * </code>
8456      */
getLocalityLbPoliciesCount()8457     public int getLocalityLbPoliciesCount() {
8458       if (localityLbPoliciesBuilder_ == null) {
8459         return localityLbPolicies_.size();
8460       } else {
8461         return localityLbPoliciesBuilder_.getCount();
8462       }
8463     }
8464     /**
8465      *
8466      *
8467      * <pre>
8468      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8469      * </pre>
8470      *
8471      * <code>
8472      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8473      * </code>
8474      */
8475     public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig
getLocalityLbPolicies(int index)8476         getLocalityLbPolicies(int index) {
8477       if (localityLbPoliciesBuilder_ == null) {
8478         return localityLbPolicies_.get(index);
8479       } else {
8480         return localityLbPoliciesBuilder_.getMessage(index);
8481       }
8482     }
8483     /**
8484      *
8485      *
8486      * <pre>
8487      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8488      * </pre>
8489      *
8490      * <code>
8491      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8492      * </code>
8493      */
setLocalityLbPolicies( int index, com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value)8494     public Builder setLocalityLbPolicies(
8495         int index,
8496         com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value) {
8497       if (localityLbPoliciesBuilder_ == null) {
8498         if (value == null) {
8499           throw new NullPointerException();
8500         }
8501         ensureLocalityLbPoliciesIsMutable();
8502         localityLbPolicies_.set(index, value);
8503         onChanged();
8504       } else {
8505         localityLbPoliciesBuilder_.setMessage(index, value);
8506       }
8507       return this;
8508     }
8509     /**
8510      *
8511      *
8512      * <pre>
8513      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8514      * </pre>
8515      *
8516      * <code>
8517      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8518      * </code>
8519      */
setLocalityLbPolicies( int index, com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder builderForValue)8520     public Builder setLocalityLbPolicies(
8521         int index,
8522         com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder
8523             builderForValue) {
8524       if (localityLbPoliciesBuilder_ == null) {
8525         ensureLocalityLbPoliciesIsMutable();
8526         localityLbPolicies_.set(index, builderForValue.build());
8527         onChanged();
8528       } else {
8529         localityLbPoliciesBuilder_.setMessage(index, builderForValue.build());
8530       }
8531       return this;
8532     }
8533     /**
8534      *
8535      *
8536      * <pre>
8537      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8538      * </pre>
8539      *
8540      * <code>
8541      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8542      * </code>
8543      */
addLocalityLbPolicies( com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value)8544     public Builder addLocalityLbPolicies(
8545         com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value) {
8546       if (localityLbPoliciesBuilder_ == null) {
8547         if (value == null) {
8548           throw new NullPointerException();
8549         }
8550         ensureLocalityLbPoliciesIsMutable();
8551         localityLbPolicies_.add(value);
8552         onChanged();
8553       } else {
8554         localityLbPoliciesBuilder_.addMessage(value);
8555       }
8556       return this;
8557     }
8558     /**
8559      *
8560      *
8561      * <pre>
8562      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8563      * </pre>
8564      *
8565      * <code>
8566      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8567      * </code>
8568      */
addLocalityLbPolicies( int index, com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value)8569     public Builder addLocalityLbPolicies(
8570         int index,
8571         com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value) {
8572       if (localityLbPoliciesBuilder_ == null) {
8573         if (value == null) {
8574           throw new NullPointerException();
8575         }
8576         ensureLocalityLbPoliciesIsMutable();
8577         localityLbPolicies_.add(index, value);
8578         onChanged();
8579       } else {
8580         localityLbPoliciesBuilder_.addMessage(index, value);
8581       }
8582       return this;
8583     }
8584     /**
8585      *
8586      *
8587      * <pre>
8588      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8589      * </pre>
8590      *
8591      * <code>
8592      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8593      * </code>
8594      */
addLocalityLbPolicies( com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder builderForValue)8595     public Builder addLocalityLbPolicies(
8596         com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder
8597             builderForValue) {
8598       if (localityLbPoliciesBuilder_ == null) {
8599         ensureLocalityLbPoliciesIsMutable();
8600         localityLbPolicies_.add(builderForValue.build());
8601         onChanged();
8602       } else {
8603         localityLbPoliciesBuilder_.addMessage(builderForValue.build());
8604       }
8605       return this;
8606     }
8607     /**
8608      *
8609      *
8610      * <pre>
8611      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8612      * </pre>
8613      *
8614      * <code>
8615      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8616      * </code>
8617      */
addLocalityLbPolicies( int index, com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder builderForValue)8618     public Builder addLocalityLbPolicies(
8619         int index,
8620         com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder
8621             builderForValue) {
8622       if (localityLbPoliciesBuilder_ == null) {
8623         ensureLocalityLbPoliciesIsMutable();
8624         localityLbPolicies_.add(index, builderForValue.build());
8625         onChanged();
8626       } else {
8627         localityLbPoliciesBuilder_.addMessage(index, builderForValue.build());
8628       }
8629       return this;
8630     }
8631     /**
8632      *
8633      *
8634      * <pre>
8635      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8636      * </pre>
8637      *
8638      * <code>
8639      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8640      * </code>
8641      */
addAllLocalityLbPolicies( java.lang.Iterable< ? extends com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig> values)8642     public Builder addAllLocalityLbPolicies(
8643         java.lang.Iterable<
8644                 ? extends
8645                     com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig>
8646             values) {
8647       if (localityLbPoliciesBuilder_ == null) {
8648         ensureLocalityLbPoliciesIsMutable();
8649         com.google.protobuf.AbstractMessageLite.Builder.addAll(values, localityLbPolicies_);
8650         onChanged();
8651       } else {
8652         localityLbPoliciesBuilder_.addAllMessages(values);
8653       }
8654       return this;
8655     }
8656     /**
8657      *
8658      *
8659      * <pre>
8660      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8661      * </pre>
8662      *
8663      * <code>
8664      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8665      * </code>
8666      */
clearLocalityLbPolicies()8667     public Builder clearLocalityLbPolicies() {
8668       if (localityLbPoliciesBuilder_ == null) {
8669         localityLbPolicies_ = java.util.Collections.emptyList();
8670         bitField0_ = (bitField0_ & ~0x00200000);
8671         onChanged();
8672       } else {
8673         localityLbPoliciesBuilder_.clear();
8674       }
8675       return this;
8676     }
8677     /**
8678      *
8679      *
8680      * <pre>
8681      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8682      * </pre>
8683      *
8684      * <code>
8685      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8686      * </code>
8687      */
removeLocalityLbPolicies(int index)8688     public Builder removeLocalityLbPolicies(int index) {
8689       if (localityLbPoliciesBuilder_ == null) {
8690         ensureLocalityLbPoliciesIsMutable();
8691         localityLbPolicies_.remove(index);
8692         onChanged();
8693       } else {
8694         localityLbPoliciesBuilder_.remove(index);
8695       }
8696       return this;
8697     }
8698     /**
8699      *
8700      *
8701      * <pre>
8702      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8703      * </pre>
8704      *
8705      * <code>
8706      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8707      * </code>
8708      */
8709     public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder
getLocalityLbPoliciesBuilder(int index)8710         getLocalityLbPoliciesBuilder(int index) {
8711       return getLocalityLbPoliciesFieldBuilder().getBuilder(index);
8712     }
8713     /**
8714      *
8715      *
8716      * <pre>
8717      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8718      * </pre>
8719      *
8720      * <code>
8721      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8722      * </code>
8723      */
8724     public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder
getLocalityLbPoliciesOrBuilder(int index)8725         getLocalityLbPoliciesOrBuilder(int index) {
8726       if (localityLbPoliciesBuilder_ == null) {
8727         return localityLbPolicies_.get(index);
8728       } else {
8729         return localityLbPoliciesBuilder_.getMessageOrBuilder(index);
8730       }
8731     }
8732     /**
8733      *
8734      *
8735      * <pre>
8736      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8737      * </pre>
8738      *
8739      * <code>
8740      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8741      * </code>
8742      */
8743     public java.util.List<
8744             ? extends
8745                 com.google.cloud.compute.v1
8746                     .BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder>
getLocalityLbPoliciesOrBuilderList()8747         getLocalityLbPoliciesOrBuilderList() {
8748       if (localityLbPoliciesBuilder_ != null) {
8749         return localityLbPoliciesBuilder_.getMessageOrBuilderList();
8750       } else {
8751         return java.util.Collections.unmodifiableList(localityLbPolicies_);
8752       }
8753     }
8754     /**
8755      *
8756      *
8757      * <pre>
8758      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8759      * </pre>
8760      *
8761      * <code>
8762      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8763      * </code>
8764      */
8765     public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder
addLocalityLbPoliciesBuilder()8766         addLocalityLbPoliciesBuilder() {
8767       return getLocalityLbPoliciesFieldBuilder()
8768           .addBuilder(
8769               com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig
8770                   .getDefaultInstance());
8771     }
8772     /**
8773      *
8774      *
8775      * <pre>
8776      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8777      * </pre>
8778      *
8779      * <code>
8780      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8781      * </code>
8782      */
8783     public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder
addLocalityLbPoliciesBuilder(int index)8784         addLocalityLbPoliciesBuilder(int index) {
8785       return getLocalityLbPoliciesFieldBuilder()
8786           .addBuilder(
8787               index,
8788               com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig
8789                   .getDefaultInstance());
8790     }
8791     /**
8792      *
8793      *
8794      * <pre>
8795      * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration.
8796      * </pre>
8797      *
8798      * <code>
8799      * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557;
8800      * </code>
8801      */
8802     public java.util.List<
8803             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder>
getLocalityLbPoliciesBuilderList()8804         getLocalityLbPoliciesBuilderList() {
8805       return getLocalityLbPoliciesFieldBuilder().getBuilderList();
8806     }
8807 
8808     private com.google.protobuf.RepeatedFieldBuilderV3<
8809             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig,
8810             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder,
8811             com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder>
getLocalityLbPoliciesFieldBuilder()8812         getLocalityLbPoliciesFieldBuilder() {
8813       if (localityLbPoliciesBuilder_ == null) {
8814         localityLbPoliciesBuilder_ =
8815             new com.google.protobuf.RepeatedFieldBuilderV3<
8816                 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig,
8817                 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder,
8818                 com.google.cloud.compute.v1
8819                     .BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder>(
8820                 localityLbPolicies_,
8821                 ((bitField0_ & 0x00200000) != 0),
8822                 getParentForChildren(),
8823                 isClean());
8824         localityLbPolicies_ = null;
8825       }
8826       return localityLbPoliciesBuilder_;
8827     }
8828 
8829     private java.lang.Object localityLbPolicy_ = "";
8830     /**
8831      *
8832      *
8833      * <pre>
8834      * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
8835      * Check the LocalityLbPolicy enum for the list of possible values.
8836      * </pre>
8837      *
8838      * <code>optional string locality_lb_policy = 131431487;</code>
8839      *
8840      * @return Whether the localityLbPolicy field is set.
8841      */
hasLocalityLbPolicy()8842     public boolean hasLocalityLbPolicy() {
8843       return ((bitField0_ & 0x00400000) != 0);
8844     }
8845     /**
8846      *
8847      *
8848      * <pre>
8849      * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
8850      * Check the LocalityLbPolicy enum for the list of possible values.
8851      * </pre>
8852      *
8853      * <code>optional string locality_lb_policy = 131431487;</code>
8854      *
8855      * @return The localityLbPolicy.
8856      */
getLocalityLbPolicy()8857     public java.lang.String getLocalityLbPolicy() {
8858       java.lang.Object ref = localityLbPolicy_;
8859       if (!(ref instanceof java.lang.String)) {
8860         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
8861         java.lang.String s = bs.toStringUtf8();
8862         localityLbPolicy_ = s;
8863         return s;
8864       } else {
8865         return (java.lang.String) ref;
8866       }
8867     }
8868     /**
8869      *
8870      *
8871      * <pre>
8872      * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
8873      * Check the LocalityLbPolicy enum for the list of possible values.
8874      * </pre>
8875      *
8876      * <code>optional string locality_lb_policy = 131431487;</code>
8877      *
8878      * @return The bytes for localityLbPolicy.
8879      */
getLocalityLbPolicyBytes()8880     public com.google.protobuf.ByteString getLocalityLbPolicyBytes() {
8881       java.lang.Object ref = localityLbPolicy_;
8882       if (ref instanceof String) {
8883         com.google.protobuf.ByteString b =
8884             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
8885         localityLbPolicy_ = b;
8886         return b;
8887       } else {
8888         return (com.google.protobuf.ByteString) ref;
8889       }
8890     }
8891     /**
8892      *
8893      *
8894      * <pre>
8895      * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
8896      * Check the LocalityLbPolicy enum for the list of possible values.
8897      * </pre>
8898      *
8899      * <code>optional string locality_lb_policy = 131431487;</code>
8900      *
8901      * @param value The localityLbPolicy to set.
8902      * @return This builder for chaining.
8903      */
setLocalityLbPolicy(java.lang.String value)8904     public Builder setLocalityLbPolicy(java.lang.String value) {
8905       if (value == null) {
8906         throw new NullPointerException();
8907       }
8908       localityLbPolicy_ = value;
8909       bitField0_ |= 0x00400000;
8910       onChanged();
8911       return this;
8912     }
8913     /**
8914      *
8915      *
8916      * <pre>
8917      * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
8918      * Check the LocalityLbPolicy enum for the list of possible values.
8919      * </pre>
8920      *
8921      * <code>optional string locality_lb_policy = 131431487;</code>
8922      *
8923      * @return This builder for chaining.
8924      */
clearLocalityLbPolicy()8925     public Builder clearLocalityLbPolicy() {
8926       localityLbPolicy_ = getDefaultInstance().getLocalityLbPolicy();
8927       bitField0_ = (bitField0_ & ~0x00400000);
8928       onChanged();
8929       return this;
8930     }
8931     /**
8932      *
8933      *
8934      * <pre>
8935      * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true.
8936      * Check the LocalityLbPolicy enum for the list of possible values.
8937      * </pre>
8938      *
8939      * <code>optional string locality_lb_policy = 131431487;</code>
8940      *
8941      * @param value The bytes for localityLbPolicy to set.
8942      * @return This builder for chaining.
8943      */
setLocalityLbPolicyBytes(com.google.protobuf.ByteString value)8944     public Builder setLocalityLbPolicyBytes(com.google.protobuf.ByteString value) {
8945       if (value == null) {
8946         throw new NullPointerException();
8947       }
8948       checkByteStringIsUtf8(value);
8949       localityLbPolicy_ = value;
8950       bitField0_ |= 0x00400000;
8951       onChanged();
8952       return this;
8953     }
8954 
8955     private com.google.cloud.compute.v1.BackendServiceLogConfig logConfig_;
8956     private com.google.protobuf.SingleFieldBuilderV3<
8957             com.google.cloud.compute.v1.BackendServiceLogConfig,
8958             com.google.cloud.compute.v1.BackendServiceLogConfig.Builder,
8959             com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder>
8960         logConfigBuilder_;
8961     /**
8962      *
8963      *
8964      * <pre>
8965      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
8966      * </pre>
8967      *
8968      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
8969      * </code>
8970      *
8971      * @return Whether the logConfig field is set.
8972      */
hasLogConfig()8973     public boolean hasLogConfig() {
8974       return ((bitField0_ & 0x00800000) != 0);
8975     }
8976     /**
8977      *
8978      *
8979      * <pre>
8980      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
8981      * </pre>
8982      *
8983      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
8984      * </code>
8985      *
8986      * @return The logConfig.
8987      */
getLogConfig()8988     public com.google.cloud.compute.v1.BackendServiceLogConfig getLogConfig() {
8989       if (logConfigBuilder_ == null) {
8990         return logConfig_ == null
8991             ? com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance()
8992             : logConfig_;
8993       } else {
8994         return logConfigBuilder_.getMessage();
8995       }
8996     }
8997     /**
8998      *
8999      *
9000      * <pre>
9001      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
9002      * </pre>
9003      *
9004      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
9005      * </code>
9006      */
setLogConfig(com.google.cloud.compute.v1.BackendServiceLogConfig value)9007     public Builder setLogConfig(com.google.cloud.compute.v1.BackendServiceLogConfig value) {
9008       if (logConfigBuilder_ == null) {
9009         if (value == null) {
9010           throw new NullPointerException();
9011         }
9012         logConfig_ = value;
9013       } else {
9014         logConfigBuilder_.setMessage(value);
9015       }
9016       bitField0_ |= 0x00800000;
9017       onChanged();
9018       return this;
9019     }
9020     /**
9021      *
9022      *
9023      * <pre>
9024      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
9025      * </pre>
9026      *
9027      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
9028      * </code>
9029      */
setLogConfig( com.google.cloud.compute.v1.BackendServiceLogConfig.Builder builderForValue)9030     public Builder setLogConfig(
9031         com.google.cloud.compute.v1.BackendServiceLogConfig.Builder builderForValue) {
9032       if (logConfigBuilder_ == null) {
9033         logConfig_ = builderForValue.build();
9034       } else {
9035         logConfigBuilder_.setMessage(builderForValue.build());
9036       }
9037       bitField0_ |= 0x00800000;
9038       onChanged();
9039       return this;
9040     }
9041     /**
9042      *
9043      *
9044      * <pre>
9045      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
9046      * </pre>
9047      *
9048      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
9049      * </code>
9050      */
mergeLogConfig(com.google.cloud.compute.v1.BackendServiceLogConfig value)9051     public Builder mergeLogConfig(com.google.cloud.compute.v1.BackendServiceLogConfig value) {
9052       if (logConfigBuilder_ == null) {
9053         if (((bitField0_ & 0x00800000) != 0)
9054             && logConfig_ != null
9055             && logConfig_
9056                 != com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance()) {
9057           getLogConfigBuilder().mergeFrom(value);
9058         } else {
9059           logConfig_ = value;
9060         }
9061       } else {
9062         logConfigBuilder_.mergeFrom(value);
9063       }
9064       bitField0_ |= 0x00800000;
9065       onChanged();
9066       return this;
9067     }
9068     /**
9069      *
9070      *
9071      * <pre>
9072      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
9073      * </pre>
9074      *
9075      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
9076      * </code>
9077      */
clearLogConfig()9078     public Builder clearLogConfig() {
9079       bitField0_ = (bitField0_ & ~0x00800000);
9080       logConfig_ = null;
9081       if (logConfigBuilder_ != null) {
9082         logConfigBuilder_.dispose();
9083         logConfigBuilder_ = null;
9084       }
9085       onChanged();
9086       return this;
9087     }
9088     /**
9089      *
9090      *
9091      * <pre>
9092      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
9093      * </pre>
9094      *
9095      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
9096      * </code>
9097      */
getLogConfigBuilder()9098     public com.google.cloud.compute.v1.BackendServiceLogConfig.Builder getLogConfigBuilder() {
9099       bitField0_ |= 0x00800000;
9100       onChanged();
9101       return getLogConfigFieldBuilder().getBuilder();
9102     }
9103     /**
9104      *
9105      *
9106      * <pre>
9107      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
9108      * </pre>
9109      *
9110      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
9111      * </code>
9112      */
getLogConfigOrBuilder()9113     public com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder getLogConfigOrBuilder() {
9114       if (logConfigBuilder_ != null) {
9115         return logConfigBuilder_.getMessageOrBuilder();
9116       } else {
9117         return logConfig_ == null
9118             ? com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance()
9119             : logConfig_;
9120       }
9121     }
9122     /**
9123      *
9124      *
9125      * <pre>
9126      * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver.
9127      * </pre>
9128      *
9129      * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;
9130      * </code>
9131      */
9132     private com.google.protobuf.SingleFieldBuilderV3<
9133             com.google.cloud.compute.v1.BackendServiceLogConfig,
9134             com.google.cloud.compute.v1.BackendServiceLogConfig.Builder,
9135             com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder>
getLogConfigFieldBuilder()9136         getLogConfigFieldBuilder() {
9137       if (logConfigBuilder_ == null) {
9138         logConfigBuilder_ =
9139             new com.google.protobuf.SingleFieldBuilderV3<
9140                 com.google.cloud.compute.v1.BackendServiceLogConfig,
9141                 com.google.cloud.compute.v1.BackendServiceLogConfig.Builder,
9142                 com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder>(
9143                 getLogConfig(), getParentForChildren(), isClean());
9144         logConfig_ = null;
9145       }
9146       return logConfigBuilder_;
9147     }
9148 
9149     private com.google.cloud.compute.v1.Duration maxStreamDuration_;
9150     private com.google.protobuf.SingleFieldBuilderV3<
9151             com.google.cloud.compute.v1.Duration,
9152             com.google.cloud.compute.v1.Duration.Builder,
9153             com.google.cloud.compute.v1.DurationOrBuilder>
9154         maxStreamDurationBuilder_;
9155     /**
9156      *
9157      *
9158      * <pre>
9159      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9160      * </pre>
9161      *
9162      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9163      *
9164      * @return Whether the maxStreamDuration field is set.
9165      */
hasMaxStreamDuration()9166     public boolean hasMaxStreamDuration() {
9167       return ((bitField0_ & 0x01000000) != 0);
9168     }
9169     /**
9170      *
9171      *
9172      * <pre>
9173      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9174      * </pre>
9175      *
9176      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9177      *
9178      * @return The maxStreamDuration.
9179      */
getMaxStreamDuration()9180     public com.google.cloud.compute.v1.Duration getMaxStreamDuration() {
9181       if (maxStreamDurationBuilder_ == null) {
9182         return maxStreamDuration_ == null
9183             ? com.google.cloud.compute.v1.Duration.getDefaultInstance()
9184             : maxStreamDuration_;
9185       } else {
9186         return maxStreamDurationBuilder_.getMessage();
9187       }
9188     }
9189     /**
9190      *
9191      *
9192      * <pre>
9193      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9194      * </pre>
9195      *
9196      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9197      */
setMaxStreamDuration(com.google.cloud.compute.v1.Duration value)9198     public Builder setMaxStreamDuration(com.google.cloud.compute.v1.Duration value) {
9199       if (maxStreamDurationBuilder_ == null) {
9200         if (value == null) {
9201           throw new NullPointerException();
9202         }
9203         maxStreamDuration_ = value;
9204       } else {
9205         maxStreamDurationBuilder_.setMessage(value);
9206       }
9207       bitField0_ |= 0x01000000;
9208       onChanged();
9209       return this;
9210     }
9211     /**
9212      *
9213      *
9214      * <pre>
9215      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9216      * </pre>
9217      *
9218      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9219      */
setMaxStreamDuration( com.google.cloud.compute.v1.Duration.Builder builderForValue)9220     public Builder setMaxStreamDuration(
9221         com.google.cloud.compute.v1.Duration.Builder builderForValue) {
9222       if (maxStreamDurationBuilder_ == null) {
9223         maxStreamDuration_ = builderForValue.build();
9224       } else {
9225         maxStreamDurationBuilder_.setMessage(builderForValue.build());
9226       }
9227       bitField0_ |= 0x01000000;
9228       onChanged();
9229       return this;
9230     }
9231     /**
9232      *
9233      *
9234      * <pre>
9235      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9236      * </pre>
9237      *
9238      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9239      */
mergeMaxStreamDuration(com.google.cloud.compute.v1.Duration value)9240     public Builder mergeMaxStreamDuration(com.google.cloud.compute.v1.Duration value) {
9241       if (maxStreamDurationBuilder_ == null) {
9242         if (((bitField0_ & 0x01000000) != 0)
9243             && maxStreamDuration_ != null
9244             && maxStreamDuration_ != com.google.cloud.compute.v1.Duration.getDefaultInstance()) {
9245           getMaxStreamDurationBuilder().mergeFrom(value);
9246         } else {
9247           maxStreamDuration_ = value;
9248         }
9249       } else {
9250         maxStreamDurationBuilder_.mergeFrom(value);
9251       }
9252       bitField0_ |= 0x01000000;
9253       onChanged();
9254       return this;
9255     }
9256     /**
9257      *
9258      *
9259      * <pre>
9260      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9261      * </pre>
9262      *
9263      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9264      */
clearMaxStreamDuration()9265     public Builder clearMaxStreamDuration() {
9266       bitField0_ = (bitField0_ & ~0x01000000);
9267       maxStreamDuration_ = null;
9268       if (maxStreamDurationBuilder_ != null) {
9269         maxStreamDurationBuilder_.dispose();
9270         maxStreamDurationBuilder_ = null;
9271       }
9272       onChanged();
9273       return this;
9274     }
9275     /**
9276      *
9277      *
9278      * <pre>
9279      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9280      * </pre>
9281      *
9282      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9283      */
getMaxStreamDurationBuilder()9284     public com.google.cloud.compute.v1.Duration.Builder getMaxStreamDurationBuilder() {
9285       bitField0_ |= 0x01000000;
9286       onChanged();
9287       return getMaxStreamDurationFieldBuilder().getBuilder();
9288     }
9289     /**
9290      *
9291      *
9292      * <pre>
9293      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9294      * </pre>
9295      *
9296      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9297      */
getMaxStreamDurationOrBuilder()9298     public com.google.cloud.compute.v1.DurationOrBuilder getMaxStreamDurationOrBuilder() {
9299       if (maxStreamDurationBuilder_ != null) {
9300         return maxStreamDurationBuilder_.getMessageOrBuilder();
9301       } else {
9302         return maxStreamDuration_ == null
9303             ? com.google.cloud.compute.v1.Duration.getDefaultInstance()
9304             : maxStreamDuration_;
9305       }
9306     }
9307     /**
9308      *
9309      *
9310      * <pre>
9311      * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
9312      * </pre>
9313      *
9314      * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code>
9315      */
9316     private com.google.protobuf.SingleFieldBuilderV3<
9317             com.google.cloud.compute.v1.Duration,
9318             com.google.cloud.compute.v1.Duration.Builder,
9319             com.google.cloud.compute.v1.DurationOrBuilder>
getMaxStreamDurationFieldBuilder()9320         getMaxStreamDurationFieldBuilder() {
9321       if (maxStreamDurationBuilder_ == null) {
9322         maxStreamDurationBuilder_ =
9323             new com.google.protobuf.SingleFieldBuilderV3<
9324                 com.google.cloud.compute.v1.Duration,
9325                 com.google.cloud.compute.v1.Duration.Builder,
9326                 com.google.cloud.compute.v1.DurationOrBuilder>(
9327                 getMaxStreamDuration(), getParentForChildren(), isClean());
9328         maxStreamDuration_ = null;
9329       }
9330       return maxStreamDurationBuilder_;
9331     }
9332 
9333     private java.lang.Object name_ = "";
9334     /**
9335      *
9336      *
9337      * <pre>
9338      * 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.
9339      * </pre>
9340      *
9341      * <code>optional string name = 3373707;</code>
9342      *
9343      * @return Whether the name field is set.
9344      */
hasName()9345     public boolean hasName() {
9346       return ((bitField0_ & 0x02000000) != 0);
9347     }
9348     /**
9349      *
9350      *
9351      * <pre>
9352      * 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.
9353      * </pre>
9354      *
9355      * <code>optional string name = 3373707;</code>
9356      *
9357      * @return The name.
9358      */
getName()9359     public java.lang.String getName() {
9360       java.lang.Object ref = name_;
9361       if (!(ref instanceof java.lang.String)) {
9362         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
9363         java.lang.String s = bs.toStringUtf8();
9364         name_ = s;
9365         return s;
9366       } else {
9367         return (java.lang.String) ref;
9368       }
9369     }
9370     /**
9371      *
9372      *
9373      * <pre>
9374      * 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.
9375      * </pre>
9376      *
9377      * <code>optional string name = 3373707;</code>
9378      *
9379      * @return The bytes for name.
9380      */
getNameBytes()9381     public com.google.protobuf.ByteString getNameBytes() {
9382       java.lang.Object ref = name_;
9383       if (ref instanceof String) {
9384         com.google.protobuf.ByteString b =
9385             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
9386         name_ = b;
9387         return b;
9388       } else {
9389         return (com.google.protobuf.ByteString) ref;
9390       }
9391     }
9392     /**
9393      *
9394      *
9395      * <pre>
9396      * 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.
9397      * </pre>
9398      *
9399      * <code>optional string name = 3373707;</code>
9400      *
9401      * @param value The name to set.
9402      * @return This builder for chaining.
9403      */
setName(java.lang.String value)9404     public Builder setName(java.lang.String value) {
9405       if (value == null) {
9406         throw new NullPointerException();
9407       }
9408       name_ = value;
9409       bitField0_ |= 0x02000000;
9410       onChanged();
9411       return this;
9412     }
9413     /**
9414      *
9415      *
9416      * <pre>
9417      * 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.
9418      * </pre>
9419      *
9420      * <code>optional string name = 3373707;</code>
9421      *
9422      * @return This builder for chaining.
9423      */
clearName()9424     public Builder clearName() {
9425       name_ = getDefaultInstance().getName();
9426       bitField0_ = (bitField0_ & ~0x02000000);
9427       onChanged();
9428       return this;
9429     }
9430     /**
9431      *
9432      *
9433      * <pre>
9434      * 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.
9435      * </pre>
9436      *
9437      * <code>optional string name = 3373707;</code>
9438      *
9439      * @param value The bytes for name to set.
9440      * @return This builder for chaining.
9441      */
setNameBytes(com.google.protobuf.ByteString value)9442     public Builder setNameBytes(com.google.protobuf.ByteString value) {
9443       if (value == null) {
9444         throw new NullPointerException();
9445       }
9446       checkByteStringIsUtf8(value);
9447       name_ = value;
9448       bitField0_ |= 0x02000000;
9449       onChanged();
9450       return this;
9451     }
9452 
9453     private java.lang.Object network_ = "";
9454     /**
9455      *
9456      *
9457      * <pre>
9458      * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
9459      * </pre>
9460      *
9461      * <code>optional string network = 232872494;</code>
9462      *
9463      * @return Whether the network field is set.
9464      */
hasNetwork()9465     public boolean hasNetwork() {
9466       return ((bitField0_ & 0x04000000) != 0);
9467     }
9468     /**
9469      *
9470      *
9471      * <pre>
9472      * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
9473      * </pre>
9474      *
9475      * <code>optional string network = 232872494;</code>
9476      *
9477      * @return The network.
9478      */
getNetwork()9479     public java.lang.String getNetwork() {
9480       java.lang.Object ref = network_;
9481       if (!(ref instanceof java.lang.String)) {
9482         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
9483         java.lang.String s = bs.toStringUtf8();
9484         network_ = s;
9485         return s;
9486       } else {
9487         return (java.lang.String) ref;
9488       }
9489     }
9490     /**
9491      *
9492      *
9493      * <pre>
9494      * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
9495      * </pre>
9496      *
9497      * <code>optional string network = 232872494;</code>
9498      *
9499      * @return The bytes for network.
9500      */
getNetworkBytes()9501     public com.google.protobuf.ByteString getNetworkBytes() {
9502       java.lang.Object ref = network_;
9503       if (ref instanceof String) {
9504         com.google.protobuf.ByteString b =
9505             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
9506         network_ = b;
9507         return b;
9508       } else {
9509         return (com.google.protobuf.ByteString) ref;
9510       }
9511     }
9512     /**
9513      *
9514      *
9515      * <pre>
9516      * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
9517      * </pre>
9518      *
9519      * <code>optional string network = 232872494;</code>
9520      *
9521      * @param value The network to set.
9522      * @return This builder for chaining.
9523      */
setNetwork(java.lang.String value)9524     public Builder setNetwork(java.lang.String value) {
9525       if (value == null) {
9526         throw new NullPointerException();
9527       }
9528       network_ = value;
9529       bitField0_ |= 0x04000000;
9530       onChanged();
9531       return this;
9532     }
9533     /**
9534      *
9535      *
9536      * <pre>
9537      * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
9538      * </pre>
9539      *
9540      * <code>optional string network = 232872494;</code>
9541      *
9542      * @return This builder for chaining.
9543      */
clearNetwork()9544     public Builder clearNetwork() {
9545       network_ = getDefaultInstance().getNetwork();
9546       bitField0_ = (bitField0_ & ~0x04000000);
9547       onChanged();
9548       return this;
9549     }
9550     /**
9551      *
9552      *
9553      * <pre>
9554      * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.
9555      * </pre>
9556      *
9557      * <code>optional string network = 232872494;</code>
9558      *
9559      * @param value The bytes for network to set.
9560      * @return This builder for chaining.
9561      */
setNetworkBytes(com.google.protobuf.ByteString value)9562     public Builder setNetworkBytes(com.google.protobuf.ByteString value) {
9563       if (value == null) {
9564         throw new NullPointerException();
9565       }
9566       checkByteStringIsUtf8(value);
9567       network_ = value;
9568       bitField0_ |= 0x04000000;
9569       onChanged();
9570       return this;
9571     }
9572 
9573     private com.google.cloud.compute.v1.OutlierDetection outlierDetection_;
9574     private com.google.protobuf.SingleFieldBuilderV3<
9575             com.google.cloud.compute.v1.OutlierDetection,
9576             com.google.cloud.compute.v1.OutlierDetection.Builder,
9577             com.google.cloud.compute.v1.OutlierDetectionOrBuilder>
9578         outlierDetectionBuilder_;
9579     /**
9580      *
9581      *
9582      * <pre>
9583      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9584      * </pre>
9585      *
9586      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9587      * </code>
9588      *
9589      * @return Whether the outlierDetection field is set.
9590      */
hasOutlierDetection()9591     public boolean hasOutlierDetection() {
9592       return ((bitField0_ & 0x08000000) != 0);
9593     }
9594     /**
9595      *
9596      *
9597      * <pre>
9598      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9599      * </pre>
9600      *
9601      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9602      * </code>
9603      *
9604      * @return The outlierDetection.
9605      */
getOutlierDetection()9606     public com.google.cloud.compute.v1.OutlierDetection getOutlierDetection() {
9607       if (outlierDetectionBuilder_ == null) {
9608         return outlierDetection_ == null
9609             ? com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance()
9610             : outlierDetection_;
9611       } else {
9612         return outlierDetectionBuilder_.getMessage();
9613       }
9614     }
9615     /**
9616      *
9617      *
9618      * <pre>
9619      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9620      * </pre>
9621      *
9622      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9623      * </code>
9624      */
setOutlierDetection(com.google.cloud.compute.v1.OutlierDetection value)9625     public Builder setOutlierDetection(com.google.cloud.compute.v1.OutlierDetection value) {
9626       if (outlierDetectionBuilder_ == null) {
9627         if (value == null) {
9628           throw new NullPointerException();
9629         }
9630         outlierDetection_ = value;
9631       } else {
9632         outlierDetectionBuilder_.setMessage(value);
9633       }
9634       bitField0_ |= 0x08000000;
9635       onChanged();
9636       return this;
9637     }
9638     /**
9639      *
9640      *
9641      * <pre>
9642      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9643      * </pre>
9644      *
9645      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9646      * </code>
9647      */
setOutlierDetection( com.google.cloud.compute.v1.OutlierDetection.Builder builderForValue)9648     public Builder setOutlierDetection(
9649         com.google.cloud.compute.v1.OutlierDetection.Builder builderForValue) {
9650       if (outlierDetectionBuilder_ == null) {
9651         outlierDetection_ = builderForValue.build();
9652       } else {
9653         outlierDetectionBuilder_.setMessage(builderForValue.build());
9654       }
9655       bitField0_ |= 0x08000000;
9656       onChanged();
9657       return this;
9658     }
9659     /**
9660      *
9661      *
9662      * <pre>
9663      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9664      * </pre>
9665      *
9666      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9667      * </code>
9668      */
mergeOutlierDetection(com.google.cloud.compute.v1.OutlierDetection value)9669     public Builder mergeOutlierDetection(com.google.cloud.compute.v1.OutlierDetection value) {
9670       if (outlierDetectionBuilder_ == null) {
9671         if (((bitField0_ & 0x08000000) != 0)
9672             && outlierDetection_ != null
9673             && outlierDetection_
9674                 != com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance()) {
9675           getOutlierDetectionBuilder().mergeFrom(value);
9676         } else {
9677           outlierDetection_ = value;
9678         }
9679       } else {
9680         outlierDetectionBuilder_.mergeFrom(value);
9681       }
9682       bitField0_ |= 0x08000000;
9683       onChanged();
9684       return this;
9685     }
9686     /**
9687      *
9688      *
9689      * <pre>
9690      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9691      * </pre>
9692      *
9693      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9694      * </code>
9695      */
clearOutlierDetection()9696     public Builder clearOutlierDetection() {
9697       bitField0_ = (bitField0_ & ~0x08000000);
9698       outlierDetection_ = null;
9699       if (outlierDetectionBuilder_ != null) {
9700         outlierDetectionBuilder_.dispose();
9701         outlierDetectionBuilder_ = null;
9702       }
9703       onChanged();
9704       return this;
9705     }
9706     /**
9707      *
9708      *
9709      * <pre>
9710      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9711      * </pre>
9712      *
9713      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9714      * </code>
9715      */
getOutlierDetectionBuilder()9716     public com.google.cloud.compute.v1.OutlierDetection.Builder getOutlierDetectionBuilder() {
9717       bitField0_ |= 0x08000000;
9718       onChanged();
9719       return getOutlierDetectionFieldBuilder().getBuilder();
9720     }
9721     /**
9722      *
9723      *
9724      * <pre>
9725      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9726      * </pre>
9727      *
9728      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9729      * </code>
9730      */
getOutlierDetectionOrBuilder()9731     public com.google.cloud.compute.v1.OutlierDetectionOrBuilder getOutlierDetectionOrBuilder() {
9732       if (outlierDetectionBuilder_ != null) {
9733         return outlierDetectionBuilder_.getMessageOrBuilder();
9734       } else {
9735         return outlierDetection_ == null
9736             ? com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance()
9737             : outlierDetection_;
9738       }
9739     }
9740     /**
9741      *
9742      *
9743      * <pre>
9744      * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
9745      * </pre>
9746      *
9747      * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;
9748      * </code>
9749      */
9750     private com.google.protobuf.SingleFieldBuilderV3<
9751             com.google.cloud.compute.v1.OutlierDetection,
9752             com.google.cloud.compute.v1.OutlierDetection.Builder,
9753             com.google.cloud.compute.v1.OutlierDetectionOrBuilder>
getOutlierDetectionFieldBuilder()9754         getOutlierDetectionFieldBuilder() {
9755       if (outlierDetectionBuilder_ == null) {
9756         outlierDetectionBuilder_ =
9757             new com.google.protobuf.SingleFieldBuilderV3<
9758                 com.google.cloud.compute.v1.OutlierDetection,
9759                 com.google.cloud.compute.v1.OutlierDetection.Builder,
9760                 com.google.cloud.compute.v1.OutlierDetectionOrBuilder>(
9761                 getOutlierDetection(), getParentForChildren(), isClean());
9762         outlierDetection_ = null;
9763       }
9764       return outlierDetectionBuilder_;
9765     }
9766 
9767     private int port_;
9768     /**
9769      *
9770      *
9771      * <pre>
9772      * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port.
9773      * </pre>
9774      *
9775      * <code>optional int32 port = 3446913;</code>
9776      *
9777      * @return Whether the port field is set.
9778      */
9779     @java.lang.Override
hasPort()9780     public boolean hasPort() {
9781       return ((bitField0_ & 0x10000000) != 0);
9782     }
9783     /**
9784      *
9785      *
9786      * <pre>
9787      * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port.
9788      * </pre>
9789      *
9790      * <code>optional int32 port = 3446913;</code>
9791      *
9792      * @return The port.
9793      */
9794     @java.lang.Override
getPort()9795     public int getPort() {
9796       return port_;
9797     }
9798     /**
9799      *
9800      *
9801      * <pre>
9802      * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port.
9803      * </pre>
9804      *
9805      * <code>optional int32 port = 3446913;</code>
9806      *
9807      * @param value The port to set.
9808      * @return This builder for chaining.
9809      */
setPort(int value)9810     public Builder setPort(int value) {
9811 
9812       port_ = value;
9813       bitField0_ |= 0x10000000;
9814       onChanged();
9815       return this;
9816     }
9817     /**
9818      *
9819      *
9820      * <pre>
9821      * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port.
9822      * </pre>
9823      *
9824      * <code>optional int32 port = 3446913;</code>
9825      *
9826      * @return This builder for chaining.
9827      */
clearPort()9828     public Builder clearPort() {
9829       bitField0_ = (bitField0_ & ~0x10000000);
9830       port_ = 0;
9831       onChanged();
9832       return this;
9833     }
9834 
9835     private java.lang.Object portName_ = "";
9836     /**
9837      *
9838      *
9839      * <pre>
9840      * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
9841      * </pre>
9842      *
9843      * <code>optional string port_name = 41534345;</code>
9844      *
9845      * @return Whether the portName field is set.
9846      */
hasPortName()9847     public boolean hasPortName() {
9848       return ((bitField0_ & 0x20000000) != 0);
9849     }
9850     /**
9851      *
9852      *
9853      * <pre>
9854      * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
9855      * </pre>
9856      *
9857      * <code>optional string port_name = 41534345;</code>
9858      *
9859      * @return The portName.
9860      */
getPortName()9861     public java.lang.String getPortName() {
9862       java.lang.Object ref = portName_;
9863       if (!(ref instanceof java.lang.String)) {
9864         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
9865         java.lang.String s = bs.toStringUtf8();
9866         portName_ = s;
9867         return s;
9868       } else {
9869         return (java.lang.String) ref;
9870       }
9871     }
9872     /**
9873      *
9874      *
9875      * <pre>
9876      * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
9877      * </pre>
9878      *
9879      * <code>optional string port_name = 41534345;</code>
9880      *
9881      * @return The bytes for portName.
9882      */
getPortNameBytes()9883     public com.google.protobuf.ByteString getPortNameBytes() {
9884       java.lang.Object ref = portName_;
9885       if (ref instanceof String) {
9886         com.google.protobuf.ByteString b =
9887             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
9888         portName_ = b;
9889         return b;
9890       } else {
9891         return (com.google.protobuf.ByteString) ref;
9892       }
9893     }
9894     /**
9895      *
9896      *
9897      * <pre>
9898      * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
9899      * </pre>
9900      *
9901      * <code>optional string port_name = 41534345;</code>
9902      *
9903      * @param value The portName to set.
9904      * @return This builder for chaining.
9905      */
setPortName(java.lang.String value)9906     public Builder setPortName(java.lang.String value) {
9907       if (value == null) {
9908         throw new NullPointerException();
9909       }
9910       portName_ = value;
9911       bitField0_ |= 0x20000000;
9912       onChanged();
9913       return this;
9914     }
9915     /**
9916      *
9917      *
9918      * <pre>
9919      * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
9920      * </pre>
9921      *
9922      * <code>optional string port_name = 41534345;</code>
9923      *
9924      * @return This builder for chaining.
9925      */
clearPortName()9926     public Builder clearPortName() {
9927       portName_ = getDefaultInstance().getPortName();
9928       bitField0_ = (bitField0_ & ~0x20000000);
9929       onChanged();
9930       return this;
9931     }
9932     /**
9933      *
9934      *
9935      * <pre>
9936      * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name.
9937      * </pre>
9938      *
9939      * <code>optional string port_name = 41534345;</code>
9940      *
9941      * @param value The bytes for portName to set.
9942      * @return This builder for chaining.
9943      */
setPortNameBytes(com.google.protobuf.ByteString value)9944     public Builder setPortNameBytes(com.google.protobuf.ByteString value) {
9945       if (value == null) {
9946         throw new NullPointerException();
9947       }
9948       checkByteStringIsUtf8(value);
9949       portName_ = value;
9950       bitField0_ |= 0x20000000;
9951       onChanged();
9952       return this;
9953     }
9954 
9955     private java.lang.Object protocol_ = "";
9956     /**
9957      *
9958      *
9959      * <pre>
9960      * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
9961      * Check the Protocol enum for the list of possible values.
9962      * </pre>
9963      *
9964      * <code>optional string protocol = 84577944;</code>
9965      *
9966      * @return Whether the protocol field is set.
9967      */
hasProtocol()9968     public boolean hasProtocol() {
9969       return ((bitField0_ & 0x40000000) != 0);
9970     }
9971     /**
9972      *
9973      *
9974      * <pre>
9975      * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
9976      * Check the Protocol enum for the list of possible values.
9977      * </pre>
9978      *
9979      * <code>optional string protocol = 84577944;</code>
9980      *
9981      * @return The protocol.
9982      */
getProtocol()9983     public java.lang.String getProtocol() {
9984       java.lang.Object ref = protocol_;
9985       if (!(ref instanceof java.lang.String)) {
9986         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
9987         java.lang.String s = bs.toStringUtf8();
9988         protocol_ = s;
9989         return s;
9990       } else {
9991         return (java.lang.String) ref;
9992       }
9993     }
9994     /**
9995      *
9996      *
9997      * <pre>
9998      * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
9999      * Check the Protocol enum for the list of possible values.
10000      * </pre>
10001      *
10002      * <code>optional string protocol = 84577944;</code>
10003      *
10004      * @return The bytes for protocol.
10005      */
getProtocolBytes()10006     public com.google.protobuf.ByteString getProtocolBytes() {
10007       java.lang.Object ref = protocol_;
10008       if (ref instanceof String) {
10009         com.google.protobuf.ByteString b =
10010             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
10011         protocol_ = b;
10012         return b;
10013       } else {
10014         return (com.google.protobuf.ByteString) ref;
10015       }
10016     }
10017     /**
10018      *
10019      *
10020      * <pre>
10021      * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
10022      * Check the Protocol enum for the list of possible values.
10023      * </pre>
10024      *
10025      * <code>optional string protocol = 84577944;</code>
10026      *
10027      * @param value The protocol to set.
10028      * @return This builder for chaining.
10029      */
setProtocol(java.lang.String value)10030     public Builder setProtocol(java.lang.String value) {
10031       if (value == null) {
10032         throw new NullPointerException();
10033       }
10034       protocol_ = value;
10035       bitField0_ |= 0x40000000;
10036       onChanged();
10037       return this;
10038     }
10039     /**
10040      *
10041      *
10042      * <pre>
10043      * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
10044      * Check the Protocol enum for the list of possible values.
10045      * </pre>
10046      *
10047      * <code>optional string protocol = 84577944;</code>
10048      *
10049      * @return This builder for chaining.
10050      */
clearProtocol()10051     public Builder clearProtocol() {
10052       protocol_ = getDefaultInstance().getProtocol();
10053       bitField0_ = (bitField0_ & ~0x40000000);
10054       onChanged();
10055       return this;
10056     }
10057     /**
10058      *
10059      *
10060      * <pre>
10061      * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy.
10062      * Check the Protocol enum for the list of possible values.
10063      * </pre>
10064      *
10065      * <code>optional string protocol = 84577944;</code>
10066      *
10067      * @param value The bytes for protocol to set.
10068      * @return This builder for chaining.
10069      */
setProtocolBytes(com.google.protobuf.ByteString value)10070     public Builder setProtocolBytes(com.google.protobuf.ByteString value) {
10071       if (value == null) {
10072         throw new NullPointerException();
10073       }
10074       checkByteStringIsUtf8(value);
10075       protocol_ = value;
10076       bitField0_ |= 0x40000000;
10077       onChanged();
10078       return this;
10079     }
10080 
10081     private java.lang.Object region_ = "";
10082     /**
10083      *
10084      *
10085      * <pre>
10086      * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
10087      * </pre>
10088      *
10089      * <code>optional string region = 138946292;</code>
10090      *
10091      * @return Whether the region field is set.
10092      */
hasRegion()10093     public boolean hasRegion() {
10094       return ((bitField0_ & 0x80000000) != 0);
10095     }
10096     /**
10097      *
10098      *
10099      * <pre>
10100      * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
10101      * </pre>
10102      *
10103      * <code>optional string region = 138946292;</code>
10104      *
10105      * @return The region.
10106      */
getRegion()10107     public java.lang.String getRegion() {
10108       java.lang.Object ref = region_;
10109       if (!(ref instanceof java.lang.String)) {
10110         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
10111         java.lang.String s = bs.toStringUtf8();
10112         region_ = s;
10113         return s;
10114       } else {
10115         return (java.lang.String) ref;
10116       }
10117     }
10118     /**
10119      *
10120      *
10121      * <pre>
10122      * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
10123      * </pre>
10124      *
10125      * <code>optional string region = 138946292;</code>
10126      *
10127      * @return The bytes for region.
10128      */
getRegionBytes()10129     public com.google.protobuf.ByteString getRegionBytes() {
10130       java.lang.Object ref = region_;
10131       if (ref instanceof String) {
10132         com.google.protobuf.ByteString b =
10133             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
10134         region_ = b;
10135         return b;
10136       } else {
10137         return (com.google.protobuf.ByteString) ref;
10138       }
10139     }
10140     /**
10141      *
10142      *
10143      * <pre>
10144      * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
10145      * </pre>
10146      *
10147      * <code>optional string region = 138946292;</code>
10148      *
10149      * @param value The region to set.
10150      * @return This builder for chaining.
10151      */
setRegion(java.lang.String value)10152     public Builder setRegion(java.lang.String value) {
10153       if (value == null) {
10154         throw new NullPointerException();
10155       }
10156       region_ = value;
10157       bitField0_ |= 0x80000000;
10158       onChanged();
10159       return this;
10160     }
10161     /**
10162      *
10163      *
10164      * <pre>
10165      * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
10166      * </pre>
10167      *
10168      * <code>optional string region = 138946292;</code>
10169      *
10170      * @return This builder for chaining.
10171      */
clearRegion()10172     public Builder clearRegion() {
10173       region_ = getDefaultInstance().getRegion();
10174       bitField0_ = (bitField0_ & ~0x80000000);
10175       onChanged();
10176       return this;
10177     }
10178     /**
10179      *
10180      *
10181      * <pre>
10182      * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body.
10183      * </pre>
10184      *
10185      * <code>optional string region = 138946292;</code>
10186      *
10187      * @param value The bytes for region to set.
10188      * @return This builder for chaining.
10189      */
setRegionBytes(com.google.protobuf.ByteString value)10190     public Builder setRegionBytes(com.google.protobuf.ByteString value) {
10191       if (value == null) {
10192         throw new NullPointerException();
10193       }
10194       checkByteStringIsUtf8(value);
10195       region_ = value;
10196       bitField0_ |= 0x80000000;
10197       onChanged();
10198       return this;
10199     }
10200 
10201     private java.lang.Object securityPolicy_ = "";
10202     /**
10203      *
10204      *
10205      * <pre>
10206      * [Output Only] The resource URL for the security policy associated with this backend service.
10207      * </pre>
10208      *
10209      * <code>optional string security_policy = 171082513;</code>
10210      *
10211      * @return Whether the securityPolicy field is set.
10212      */
hasSecurityPolicy()10213     public boolean hasSecurityPolicy() {
10214       return ((bitField1_ & 0x00000001) != 0);
10215     }
10216     /**
10217      *
10218      *
10219      * <pre>
10220      * [Output Only] The resource URL for the security policy associated with this backend service.
10221      * </pre>
10222      *
10223      * <code>optional string security_policy = 171082513;</code>
10224      *
10225      * @return The securityPolicy.
10226      */
getSecurityPolicy()10227     public java.lang.String getSecurityPolicy() {
10228       java.lang.Object ref = securityPolicy_;
10229       if (!(ref instanceof java.lang.String)) {
10230         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
10231         java.lang.String s = bs.toStringUtf8();
10232         securityPolicy_ = s;
10233         return s;
10234       } else {
10235         return (java.lang.String) ref;
10236       }
10237     }
10238     /**
10239      *
10240      *
10241      * <pre>
10242      * [Output Only] The resource URL for the security policy associated with this backend service.
10243      * </pre>
10244      *
10245      * <code>optional string security_policy = 171082513;</code>
10246      *
10247      * @return The bytes for securityPolicy.
10248      */
getSecurityPolicyBytes()10249     public com.google.protobuf.ByteString getSecurityPolicyBytes() {
10250       java.lang.Object ref = securityPolicy_;
10251       if (ref instanceof String) {
10252         com.google.protobuf.ByteString b =
10253             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
10254         securityPolicy_ = b;
10255         return b;
10256       } else {
10257         return (com.google.protobuf.ByteString) ref;
10258       }
10259     }
10260     /**
10261      *
10262      *
10263      * <pre>
10264      * [Output Only] The resource URL for the security policy associated with this backend service.
10265      * </pre>
10266      *
10267      * <code>optional string security_policy = 171082513;</code>
10268      *
10269      * @param value The securityPolicy to set.
10270      * @return This builder for chaining.
10271      */
setSecurityPolicy(java.lang.String value)10272     public Builder setSecurityPolicy(java.lang.String value) {
10273       if (value == null) {
10274         throw new NullPointerException();
10275       }
10276       securityPolicy_ = value;
10277       bitField1_ |= 0x00000001;
10278       onChanged();
10279       return this;
10280     }
10281     /**
10282      *
10283      *
10284      * <pre>
10285      * [Output Only] The resource URL for the security policy associated with this backend service.
10286      * </pre>
10287      *
10288      * <code>optional string security_policy = 171082513;</code>
10289      *
10290      * @return This builder for chaining.
10291      */
clearSecurityPolicy()10292     public Builder clearSecurityPolicy() {
10293       securityPolicy_ = getDefaultInstance().getSecurityPolicy();
10294       bitField1_ = (bitField1_ & ~0x00000001);
10295       onChanged();
10296       return this;
10297     }
10298     /**
10299      *
10300      *
10301      * <pre>
10302      * [Output Only] The resource URL for the security policy associated with this backend service.
10303      * </pre>
10304      *
10305      * <code>optional string security_policy = 171082513;</code>
10306      *
10307      * @param value The bytes for securityPolicy to set.
10308      * @return This builder for chaining.
10309      */
setSecurityPolicyBytes(com.google.protobuf.ByteString value)10310     public Builder setSecurityPolicyBytes(com.google.protobuf.ByteString value) {
10311       if (value == null) {
10312         throw new NullPointerException();
10313       }
10314       checkByteStringIsUtf8(value);
10315       securityPolicy_ = value;
10316       bitField1_ |= 0x00000001;
10317       onChanged();
10318       return this;
10319     }
10320 
10321     private com.google.cloud.compute.v1.SecuritySettings securitySettings_;
10322     private com.google.protobuf.SingleFieldBuilderV3<
10323             com.google.cloud.compute.v1.SecuritySettings,
10324             com.google.cloud.compute.v1.SecuritySettings.Builder,
10325             com.google.cloud.compute.v1.SecuritySettingsOrBuilder>
10326         securitySettingsBuilder_;
10327     /**
10328      *
10329      *
10330      * <pre>
10331      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10332      * </pre>
10333      *
10334      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10335      * </code>
10336      *
10337      * @return Whether the securitySettings field is set.
10338      */
hasSecuritySettings()10339     public boolean hasSecuritySettings() {
10340       return ((bitField1_ & 0x00000002) != 0);
10341     }
10342     /**
10343      *
10344      *
10345      * <pre>
10346      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10347      * </pre>
10348      *
10349      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10350      * </code>
10351      *
10352      * @return The securitySettings.
10353      */
getSecuritySettings()10354     public com.google.cloud.compute.v1.SecuritySettings getSecuritySettings() {
10355       if (securitySettingsBuilder_ == null) {
10356         return securitySettings_ == null
10357             ? com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance()
10358             : securitySettings_;
10359       } else {
10360         return securitySettingsBuilder_.getMessage();
10361       }
10362     }
10363     /**
10364      *
10365      *
10366      * <pre>
10367      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10368      * </pre>
10369      *
10370      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10371      * </code>
10372      */
setSecuritySettings(com.google.cloud.compute.v1.SecuritySettings value)10373     public Builder setSecuritySettings(com.google.cloud.compute.v1.SecuritySettings value) {
10374       if (securitySettingsBuilder_ == null) {
10375         if (value == null) {
10376           throw new NullPointerException();
10377         }
10378         securitySettings_ = value;
10379       } else {
10380         securitySettingsBuilder_.setMessage(value);
10381       }
10382       bitField1_ |= 0x00000002;
10383       onChanged();
10384       return this;
10385     }
10386     /**
10387      *
10388      *
10389      * <pre>
10390      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10391      * </pre>
10392      *
10393      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10394      * </code>
10395      */
setSecuritySettings( com.google.cloud.compute.v1.SecuritySettings.Builder builderForValue)10396     public Builder setSecuritySettings(
10397         com.google.cloud.compute.v1.SecuritySettings.Builder builderForValue) {
10398       if (securitySettingsBuilder_ == null) {
10399         securitySettings_ = builderForValue.build();
10400       } else {
10401         securitySettingsBuilder_.setMessage(builderForValue.build());
10402       }
10403       bitField1_ |= 0x00000002;
10404       onChanged();
10405       return this;
10406     }
10407     /**
10408      *
10409      *
10410      * <pre>
10411      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10412      * </pre>
10413      *
10414      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10415      * </code>
10416      */
mergeSecuritySettings(com.google.cloud.compute.v1.SecuritySettings value)10417     public Builder mergeSecuritySettings(com.google.cloud.compute.v1.SecuritySettings value) {
10418       if (securitySettingsBuilder_ == null) {
10419         if (((bitField1_ & 0x00000002) != 0)
10420             && securitySettings_ != null
10421             && securitySettings_
10422                 != com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance()) {
10423           getSecuritySettingsBuilder().mergeFrom(value);
10424         } else {
10425           securitySettings_ = value;
10426         }
10427       } else {
10428         securitySettingsBuilder_.mergeFrom(value);
10429       }
10430       bitField1_ |= 0x00000002;
10431       onChanged();
10432       return this;
10433     }
10434     /**
10435      *
10436      *
10437      * <pre>
10438      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10439      * </pre>
10440      *
10441      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10442      * </code>
10443      */
clearSecuritySettings()10444     public Builder clearSecuritySettings() {
10445       bitField1_ = (bitField1_ & ~0x00000002);
10446       securitySettings_ = null;
10447       if (securitySettingsBuilder_ != null) {
10448         securitySettingsBuilder_.dispose();
10449         securitySettingsBuilder_ = null;
10450       }
10451       onChanged();
10452       return this;
10453     }
10454     /**
10455      *
10456      *
10457      * <pre>
10458      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10459      * </pre>
10460      *
10461      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10462      * </code>
10463      */
getSecuritySettingsBuilder()10464     public com.google.cloud.compute.v1.SecuritySettings.Builder getSecuritySettingsBuilder() {
10465       bitField1_ |= 0x00000002;
10466       onChanged();
10467       return getSecuritySettingsFieldBuilder().getBuilder();
10468     }
10469     /**
10470      *
10471      *
10472      * <pre>
10473      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10474      * </pre>
10475      *
10476      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10477      * </code>
10478      */
getSecuritySettingsOrBuilder()10479     public com.google.cloud.compute.v1.SecuritySettingsOrBuilder getSecuritySettingsOrBuilder() {
10480       if (securitySettingsBuilder_ != null) {
10481         return securitySettingsBuilder_.getMessageOrBuilder();
10482       } else {
10483         return securitySettings_ == null
10484             ? com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance()
10485             : securitySettings_;
10486       }
10487     }
10488     /**
10489      *
10490      *
10491      * <pre>
10492      * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED.
10493      * </pre>
10494      *
10495      * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;
10496      * </code>
10497      */
10498     private com.google.protobuf.SingleFieldBuilderV3<
10499             com.google.cloud.compute.v1.SecuritySettings,
10500             com.google.cloud.compute.v1.SecuritySettings.Builder,
10501             com.google.cloud.compute.v1.SecuritySettingsOrBuilder>
getSecuritySettingsFieldBuilder()10502         getSecuritySettingsFieldBuilder() {
10503       if (securitySettingsBuilder_ == null) {
10504         securitySettingsBuilder_ =
10505             new com.google.protobuf.SingleFieldBuilderV3<
10506                 com.google.cloud.compute.v1.SecuritySettings,
10507                 com.google.cloud.compute.v1.SecuritySettings.Builder,
10508                 com.google.cloud.compute.v1.SecuritySettingsOrBuilder>(
10509                 getSecuritySettings(), getParentForChildren(), isClean());
10510         securitySettings_ = null;
10511       }
10512       return securitySettingsBuilder_;
10513     }
10514 
10515     private java.lang.Object selfLink_ = "";
10516     /**
10517      *
10518      *
10519      * <pre>
10520      * [Output Only] Server-defined URL for the resource.
10521      * </pre>
10522      *
10523      * <code>optional string self_link = 456214797;</code>
10524      *
10525      * @return Whether the selfLink field is set.
10526      */
hasSelfLink()10527     public boolean hasSelfLink() {
10528       return ((bitField1_ & 0x00000004) != 0);
10529     }
10530     /**
10531      *
10532      *
10533      * <pre>
10534      * [Output Only] Server-defined URL for the resource.
10535      * </pre>
10536      *
10537      * <code>optional string self_link = 456214797;</code>
10538      *
10539      * @return The selfLink.
10540      */
getSelfLink()10541     public java.lang.String getSelfLink() {
10542       java.lang.Object ref = selfLink_;
10543       if (!(ref instanceof java.lang.String)) {
10544         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
10545         java.lang.String s = bs.toStringUtf8();
10546         selfLink_ = s;
10547         return s;
10548       } else {
10549         return (java.lang.String) ref;
10550       }
10551     }
10552     /**
10553      *
10554      *
10555      * <pre>
10556      * [Output Only] Server-defined URL for the resource.
10557      * </pre>
10558      *
10559      * <code>optional string self_link = 456214797;</code>
10560      *
10561      * @return The bytes for selfLink.
10562      */
getSelfLinkBytes()10563     public com.google.protobuf.ByteString getSelfLinkBytes() {
10564       java.lang.Object ref = selfLink_;
10565       if (ref instanceof String) {
10566         com.google.protobuf.ByteString b =
10567             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
10568         selfLink_ = b;
10569         return b;
10570       } else {
10571         return (com.google.protobuf.ByteString) ref;
10572       }
10573     }
10574     /**
10575      *
10576      *
10577      * <pre>
10578      * [Output Only] Server-defined URL for the resource.
10579      * </pre>
10580      *
10581      * <code>optional string self_link = 456214797;</code>
10582      *
10583      * @param value The selfLink to set.
10584      * @return This builder for chaining.
10585      */
setSelfLink(java.lang.String value)10586     public Builder setSelfLink(java.lang.String value) {
10587       if (value == null) {
10588         throw new NullPointerException();
10589       }
10590       selfLink_ = value;
10591       bitField1_ |= 0x00000004;
10592       onChanged();
10593       return this;
10594     }
10595     /**
10596      *
10597      *
10598      * <pre>
10599      * [Output Only] Server-defined URL for the resource.
10600      * </pre>
10601      *
10602      * <code>optional string self_link = 456214797;</code>
10603      *
10604      * @return This builder for chaining.
10605      */
clearSelfLink()10606     public Builder clearSelfLink() {
10607       selfLink_ = getDefaultInstance().getSelfLink();
10608       bitField1_ = (bitField1_ & ~0x00000004);
10609       onChanged();
10610       return this;
10611     }
10612     /**
10613      *
10614      *
10615      * <pre>
10616      * [Output Only] Server-defined URL for the resource.
10617      * </pre>
10618      *
10619      * <code>optional string self_link = 456214797;</code>
10620      *
10621      * @param value The bytes for selfLink to set.
10622      * @return This builder for chaining.
10623      */
setSelfLinkBytes(com.google.protobuf.ByteString value)10624     public Builder setSelfLinkBytes(com.google.protobuf.ByteString value) {
10625       if (value == null) {
10626         throw new NullPointerException();
10627       }
10628       checkByteStringIsUtf8(value);
10629       selfLink_ = value;
10630       bitField1_ |= 0x00000004;
10631       onChanged();
10632       return this;
10633     }
10634 
10635     private com.google.protobuf.LazyStringList serviceBindings_ =
10636         com.google.protobuf.LazyStringArrayList.EMPTY;
10637 
ensureServiceBindingsIsMutable()10638     private void ensureServiceBindingsIsMutable() {
10639       if (!((bitField1_ & 0x00000008) != 0)) {
10640         serviceBindings_ = new com.google.protobuf.LazyStringArrayList(serviceBindings_);
10641         bitField1_ |= 0x00000008;
10642       }
10643     }
10644     /**
10645      *
10646      *
10647      * <pre>
10648      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10649      * </pre>
10650      *
10651      * <code>repeated string service_bindings = 133581016;</code>
10652      *
10653      * @return A list containing the serviceBindings.
10654      */
getServiceBindingsList()10655     public com.google.protobuf.ProtocolStringList getServiceBindingsList() {
10656       return serviceBindings_.getUnmodifiableView();
10657     }
10658     /**
10659      *
10660      *
10661      * <pre>
10662      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10663      * </pre>
10664      *
10665      * <code>repeated string service_bindings = 133581016;</code>
10666      *
10667      * @return The count of serviceBindings.
10668      */
getServiceBindingsCount()10669     public int getServiceBindingsCount() {
10670       return serviceBindings_.size();
10671     }
10672     /**
10673      *
10674      *
10675      * <pre>
10676      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10677      * </pre>
10678      *
10679      * <code>repeated string service_bindings = 133581016;</code>
10680      *
10681      * @param index The index of the element to return.
10682      * @return The serviceBindings at the given index.
10683      */
getServiceBindings(int index)10684     public java.lang.String getServiceBindings(int index) {
10685       return serviceBindings_.get(index);
10686     }
10687     /**
10688      *
10689      *
10690      * <pre>
10691      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10692      * </pre>
10693      *
10694      * <code>repeated string service_bindings = 133581016;</code>
10695      *
10696      * @param index The index of the value to return.
10697      * @return The bytes of the serviceBindings at the given index.
10698      */
getServiceBindingsBytes(int index)10699     public com.google.protobuf.ByteString getServiceBindingsBytes(int index) {
10700       return serviceBindings_.getByteString(index);
10701     }
10702     /**
10703      *
10704      *
10705      * <pre>
10706      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10707      * </pre>
10708      *
10709      * <code>repeated string service_bindings = 133581016;</code>
10710      *
10711      * @param index The index to set the value at.
10712      * @param value The serviceBindings to set.
10713      * @return This builder for chaining.
10714      */
setServiceBindings(int index, java.lang.String value)10715     public Builder setServiceBindings(int index, java.lang.String value) {
10716       if (value == null) {
10717         throw new NullPointerException();
10718       }
10719       ensureServiceBindingsIsMutable();
10720       serviceBindings_.set(index, value);
10721       onChanged();
10722       return this;
10723     }
10724     /**
10725      *
10726      *
10727      * <pre>
10728      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10729      * </pre>
10730      *
10731      * <code>repeated string service_bindings = 133581016;</code>
10732      *
10733      * @param value The serviceBindings to add.
10734      * @return This builder for chaining.
10735      */
addServiceBindings(java.lang.String value)10736     public Builder addServiceBindings(java.lang.String value) {
10737       if (value == null) {
10738         throw new NullPointerException();
10739       }
10740       ensureServiceBindingsIsMutable();
10741       serviceBindings_.add(value);
10742       onChanged();
10743       return this;
10744     }
10745     /**
10746      *
10747      *
10748      * <pre>
10749      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10750      * </pre>
10751      *
10752      * <code>repeated string service_bindings = 133581016;</code>
10753      *
10754      * @param values The serviceBindings to add.
10755      * @return This builder for chaining.
10756      */
addAllServiceBindings(java.lang.Iterable<java.lang.String> values)10757     public Builder addAllServiceBindings(java.lang.Iterable<java.lang.String> values) {
10758       ensureServiceBindingsIsMutable();
10759       com.google.protobuf.AbstractMessageLite.Builder.addAll(values, serviceBindings_);
10760       onChanged();
10761       return this;
10762     }
10763     /**
10764      *
10765      *
10766      * <pre>
10767      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10768      * </pre>
10769      *
10770      * <code>repeated string service_bindings = 133581016;</code>
10771      *
10772      * @return This builder for chaining.
10773      */
clearServiceBindings()10774     public Builder clearServiceBindings() {
10775       serviceBindings_ = com.google.protobuf.LazyStringArrayList.EMPTY;
10776       bitField1_ = (bitField1_ & ~0x00000008);
10777       onChanged();
10778       return this;
10779     }
10780     /**
10781      *
10782      *
10783      * <pre>
10784      * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty.
10785      * </pre>
10786      *
10787      * <code>repeated string service_bindings = 133581016;</code>
10788      *
10789      * @param value The bytes of the serviceBindings to add.
10790      * @return This builder for chaining.
10791      */
addServiceBindingsBytes(com.google.protobuf.ByteString value)10792     public Builder addServiceBindingsBytes(com.google.protobuf.ByteString value) {
10793       if (value == null) {
10794         throw new NullPointerException();
10795       }
10796       checkByteStringIsUtf8(value);
10797       ensureServiceBindingsIsMutable();
10798       serviceBindings_.add(value);
10799       onChanged();
10800       return this;
10801     }
10802 
10803     private java.lang.Object sessionAffinity_ = "";
10804     /**
10805      *
10806      *
10807      * <pre>
10808      * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
10809      * Check the SessionAffinity enum for the list of possible values.
10810      * </pre>
10811      *
10812      * <code>optional string session_affinity = 463888561;</code>
10813      *
10814      * @return Whether the sessionAffinity field is set.
10815      */
hasSessionAffinity()10816     public boolean hasSessionAffinity() {
10817       return ((bitField1_ & 0x00000010) != 0);
10818     }
10819     /**
10820      *
10821      *
10822      * <pre>
10823      * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
10824      * Check the SessionAffinity enum for the list of possible values.
10825      * </pre>
10826      *
10827      * <code>optional string session_affinity = 463888561;</code>
10828      *
10829      * @return The sessionAffinity.
10830      */
getSessionAffinity()10831     public java.lang.String getSessionAffinity() {
10832       java.lang.Object ref = sessionAffinity_;
10833       if (!(ref instanceof java.lang.String)) {
10834         com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref;
10835         java.lang.String s = bs.toStringUtf8();
10836         sessionAffinity_ = s;
10837         return s;
10838       } else {
10839         return (java.lang.String) ref;
10840       }
10841     }
10842     /**
10843      *
10844      *
10845      * <pre>
10846      * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
10847      * Check the SessionAffinity enum for the list of possible values.
10848      * </pre>
10849      *
10850      * <code>optional string session_affinity = 463888561;</code>
10851      *
10852      * @return The bytes for sessionAffinity.
10853      */
getSessionAffinityBytes()10854     public com.google.protobuf.ByteString getSessionAffinityBytes() {
10855       java.lang.Object ref = sessionAffinity_;
10856       if (ref instanceof String) {
10857         com.google.protobuf.ByteString b =
10858             com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
10859         sessionAffinity_ = b;
10860         return b;
10861       } else {
10862         return (com.google.protobuf.ByteString) ref;
10863       }
10864     }
10865     /**
10866      *
10867      *
10868      * <pre>
10869      * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
10870      * Check the SessionAffinity enum for the list of possible values.
10871      * </pre>
10872      *
10873      * <code>optional string session_affinity = 463888561;</code>
10874      *
10875      * @param value The sessionAffinity to set.
10876      * @return This builder for chaining.
10877      */
setSessionAffinity(java.lang.String value)10878     public Builder setSessionAffinity(java.lang.String value) {
10879       if (value == null) {
10880         throw new NullPointerException();
10881       }
10882       sessionAffinity_ = value;
10883       bitField1_ |= 0x00000010;
10884       onChanged();
10885       return this;
10886     }
10887     /**
10888      *
10889      *
10890      * <pre>
10891      * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
10892      * Check the SessionAffinity enum for the list of possible values.
10893      * </pre>
10894      *
10895      * <code>optional string session_affinity = 463888561;</code>
10896      *
10897      * @return This builder for chaining.
10898      */
clearSessionAffinity()10899     public Builder clearSessionAffinity() {
10900       sessionAffinity_ = getDefaultInstance().getSessionAffinity();
10901       bitField1_ = (bitField1_ & ~0x00000010);
10902       onChanged();
10903       return this;
10904     }
10905     /**
10906      *
10907      *
10908      * <pre>
10909      * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity).
10910      * Check the SessionAffinity enum for the list of possible values.
10911      * </pre>
10912      *
10913      * <code>optional string session_affinity = 463888561;</code>
10914      *
10915      * @param value The bytes for sessionAffinity to set.
10916      * @return This builder for chaining.
10917      */
setSessionAffinityBytes(com.google.protobuf.ByteString value)10918     public Builder setSessionAffinityBytes(com.google.protobuf.ByteString value) {
10919       if (value == null) {
10920         throw new NullPointerException();
10921       }
10922       checkByteStringIsUtf8(value);
10923       sessionAffinity_ = value;
10924       bitField1_ |= 0x00000010;
10925       onChanged();
10926       return this;
10927     }
10928 
10929     private com.google.cloud.compute.v1.Subsetting subsetting_;
10930     private com.google.protobuf.SingleFieldBuilderV3<
10931             com.google.cloud.compute.v1.Subsetting,
10932             com.google.cloud.compute.v1.Subsetting.Builder,
10933             com.google.cloud.compute.v1.SubsettingOrBuilder>
10934         subsettingBuilder_;
10935     /**
10936      * <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code>
10937      *
10938      * @return Whether the subsetting field is set.
10939      */
hasSubsetting()10940     public boolean hasSubsetting() {
10941       return ((bitField1_ & 0x00000020) != 0);
10942     }
10943     /**
10944      * <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code>
10945      *
10946      * @return The subsetting.
10947      */
getSubsetting()10948     public com.google.cloud.compute.v1.Subsetting getSubsetting() {
10949       if (subsettingBuilder_ == null) {
10950         return subsetting_ == null
10951             ? com.google.cloud.compute.v1.Subsetting.getDefaultInstance()
10952             : subsetting_;
10953       } else {
10954         return subsettingBuilder_.getMessage();
10955       }
10956     }
10957     /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */
setSubsetting(com.google.cloud.compute.v1.Subsetting value)10958     public Builder setSubsetting(com.google.cloud.compute.v1.Subsetting value) {
10959       if (subsettingBuilder_ == null) {
10960         if (value == null) {
10961           throw new NullPointerException();
10962         }
10963         subsetting_ = value;
10964       } else {
10965         subsettingBuilder_.setMessage(value);
10966       }
10967       bitField1_ |= 0x00000020;
10968       onChanged();
10969       return this;
10970     }
10971     /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */
setSubsetting(com.google.cloud.compute.v1.Subsetting.Builder builderForValue)10972     public Builder setSubsetting(com.google.cloud.compute.v1.Subsetting.Builder builderForValue) {
10973       if (subsettingBuilder_ == null) {
10974         subsetting_ = builderForValue.build();
10975       } else {
10976         subsettingBuilder_.setMessage(builderForValue.build());
10977       }
10978       bitField1_ |= 0x00000020;
10979       onChanged();
10980       return this;
10981     }
10982     /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */
mergeSubsetting(com.google.cloud.compute.v1.Subsetting value)10983     public Builder mergeSubsetting(com.google.cloud.compute.v1.Subsetting value) {
10984       if (subsettingBuilder_ == null) {
10985         if (((bitField1_ & 0x00000020) != 0)
10986             && subsetting_ != null
10987             && subsetting_ != com.google.cloud.compute.v1.Subsetting.getDefaultInstance()) {
10988           getSubsettingBuilder().mergeFrom(value);
10989         } else {
10990           subsetting_ = value;
10991         }
10992       } else {
10993         subsettingBuilder_.mergeFrom(value);
10994       }
10995       bitField1_ |= 0x00000020;
10996       onChanged();
10997       return this;
10998     }
10999     /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */
clearSubsetting()11000     public Builder clearSubsetting() {
11001       bitField1_ = (bitField1_ & ~0x00000020);
11002       subsetting_ = null;
11003       if (subsettingBuilder_ != null) {
11004         subsettingBuilder_.dispose();
11005         subsettingBuilder_ = null;
11006       }
11007       onChanged();
11008       return this;
11009     }
11010     /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */
getSubsettingBuilder()11011     public com.google.cloud.compute.v1.Subsetting.Builder getSubsettingBuilder() {
11012       bitField1_ |= 0x00000020;
11013       onChanged();
11014       return getSubsettingFieldBuilder().getBuilder();
11015     }
11016     /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */
getSubsettingOrBuilder()11017     public com.google.cloud.compute.v1.SubsettingOrBuilder getSubsettingOrBuilder() {
11018       if (subsettingBuilder_ != null) {
11019         return subsettingBuilder_.getMessageOrBuilder();
11020       } else {
11021         return subsetting_ == null
11022             ? com.google.cloud.compute.v1.Subsetting.getDefaultInstance()
11023             : subsetting_;
11024       }
11025     }
11026     /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */
11027     private com.google.protobuf.SingleFieldBuilderV3<
11028             com.google.cloud.compute.v1.Subsetting,
11029             com.google.cloud.compute.v1.Subsetting.Builder,
11030             com.google.cloud.compute.v1.SubsettingOrBuilder>
getSubsettingFieldBuilder()11031         getSubsettingFieldBuilder() {
11032       if (subsettingBuilder_ == null) {
11033         subsettingBuilder_ =
11034             new com.google.protobuf.SingleFieldBuilderV3<
11035                 com.google.cloud.compute.v1.Subsetting,
11036                 com.google.cloud.compute.v1.Subsetting.Builder,
11037                 com.google.cloud.compute.v1.SubsettingOrBuilder>(
11038                 getSubsetting(), getParentForChildren(), isClean());
11039         subsetting_ = null;
11040       }
11041       return subsettingBuilder_;
11042     }
11043 
11044     private int timeoutSec_;
11045     /**
11046      *
11047      *
11048      * <pre>
11049      * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration.
11050      * </pre>
11051      *
11052      * <code>optional int32 timeout_sec = 79994995;</code>
11053      *
11054      * @return Whether the timeoutSec field is set.
11055      */
11056     @java.lang.Override
hasTimeoutSec()11057     public boolean hasTimeoutSec() {
11058       return ((bitField1_ & 0x00000040) != 0);
11059     }
11060     /**
11061      *
11062      *
11063      * <pre>
11064      * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration.
11065      * </pre>
11066      *
11067      * <code>optional int32 timeout_sec = 79994995;</code>
11068      *
11069      * @return The timeoutSec.
11070      */
11071     @java.lang.Override
getTimeoutSec()11072     public int getTimeoutSec() {
11073       return timeoutSec_;
11074     }
11075     /**
11076      *
11077      *
11078      * <pre>
11079      * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration.
11080      * </pre>
11081      *
11082      * <code>optional int32 timeout_sec = 79994995;</code>
11083      *
11084      * @param value The timeoutSec to set.
11085      * @return This builder for chaining.
11086      */
setTimeoutSec(int value)11087     public Builder setTimeoutSec(int value) {
11088 
11089       timeoutSec_ = value;
11090       bitField1_ |= 0x00000040;
11091       onChanged();
11092       return this;
11093     }
11094     /**
11095      *
11096      *
11097      * <pre>
11098      * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration.
11099      * </pre>
11100      *
11101      * <code>optional int32 timeout_sec = 79994995;</code>
11102      *
11103      * @return This builder for chaining.
11104      */
clearTimeoutSec()11105     public Builder clearTimeoutSec() {
11106       bitField1_ = (bitField1_ & ~0x00000040);
11107       timeoutSec_ = 0;
11108       onChanged();
11109       return this;
11110     }
11111 
11112     @java.lang.Override
setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields)11113     public final Builder setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields) {
11114       return super.setUnknownFields(unknownFields);
11115     }
11116 
11117     @java.lang.Override
mergeUnknownFields( final com.google.protobuf.UnknownFieldSet unknownFields)11118     public final Builder mergeUnknownFields(
11119         final com.google.protobuf.UnknownFieldSet unknownFields) {
11120       return super.mergeUnknownFields(unknownFields);
11121     }
11122 
11123     // @@protoc_insertion_point(builder_scope:google.cloud.compute.v1.BackendService)
11124   }
11125 
11126   // @@protoc_insertion_point(class_scope:google.cloud.compute.v1.BackendService)
11127   private static final com.google.cloud.compute.v1.BackendService DEFAULT_INSTANCE;
11128 
11129   static {
11130     DEFAULT_INSTANCE = new com.google.cloud.compute.v1.BackendService();
11131   }
11132 
getDefaultInstance()11133   public static com.google.cloud.compute.v1.BackendService getDefaultInstance() {
11134     return DEFAULT_INSTANCE;
11135   }
11136 
11137   private static final com.google.protobuf.Parser<BackendService> PARSER =
11138       new com.google.protobuf.AbstractParser<BackendService>() {
11139         @java.lang.Override
11140         public BackendService parsePartialFrom(
11141             com.google.protobuf.CodedInputStream input,
11142             com.google.protobuf.ExtensionRegistryLite extensionRegistry)
11143             throws com.google.protobuf.InvalidProtocolBufferException {
11144           Builder builder = newBuilder();
11145           try {
11146             builder.mergeFrom(input, extensionRegistry);
11147           } catch (com.google.protobuf.InvalidProtocolBufferException e) {
11148             throw e.setUnfinishedMessage(builder.buildPartial());
11149           } catch (com.google.protobuf.UninitializedMessageException e) {
11150             throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial());
11151           } catch (java.io.IOException e) {
11152             throw new com.google.protobuf.InvalidProtocolBufferException(e)
11153                 .setUnfinishedMessage(builder.buildPartial());
11154           }
11155           return builder.buildPartial();
11156         }
11157       };
11158 
parser()11159   public static com.google.protobuf.Parser<BackendService> parser() {
11160     return PARSER;
11161   }
11162 
11163   @java.lang.Override
getParserForType()11164   public com.google.protobuf.Parser<BackendService> getParserForType() {
11165     return PARSER;
11166   }
11167 
11168   @java.lang.Override
getDefaultInstanceForType()11169   public com.google.cloud.compute.v1.BackendService getDefaultInstanceForType() {
11170     return DEFAULT_INSTANCE;
11171   }
11172 }
11173