001 // Generated by the protocol buffer compiler. DO NOT EDIT!
002 // source: ProtobufRpcEngine.proto
003
004 package org.apache.hadoop.ipc.protobuf;
005
006 public final class ProtobufRpcEngineProtos {
007 private ProtobufRpcEngineProtos() {}
008 public static void registerAllExtensions(
009 com.google.protobuf.ExtensionRegistry registry) {
010 }
011 public interface RequestHeaderProtoOrBuilder
012 extends com.google.protobuf.MessageOrBuilder {
013
014 // required string methodName = 1;
015 /**
016 * <code>required string methodName = 1;</code>
017 *
018 * <pre>
019 ** Name of the RPC method
020 * </pre>
021 */
022 boolean hasMethodName();
023 /**
024 * <code>required string methodName = 1;</code>
025 *
026 * <pre>
027 ** Name of the RPC method
028 * </pre>
029 */
030 java.lang.String getMethodName();
031 /**
032 * <code>required string methodName = 1;</code>
033 *
034 * <pre>
035 ** Name of the RPC method
036 * </pre>
037 */
038 com.google.protobuf.ByteString
039 getMethodNameBytes();
040
041 // required string declaringClassProtocolName = 2;
042 /**
043 * <code>required string declaringClassProtocolName = 2;</code>
044 *
045 * <pre>
046 **
047 * RPCs for a particular interface (ie protocol) are done using a
048 * IPC connection that is setup using rpcProxy.
049 * The rpcProxy's has a declared protocol name that is
050 * sent form client to server at connection time.
051 *
052 * Each Rpc call also sends a protocol name
053 * (called declaringClassprotocolName). This name is usually the same
054 * as the connection protocol name except in some cases.
055 * For example metaProtocols such ProtocolInfoProto which get metainfo
056 * about the protocol reuse the connection but need to indicate that
057 * the actual protocol is different (i.e. the protocol is
058 * ProtocolInfoProto) since they reuse the connection; in this case
059 * the declaringClassProtocolName field is set to the ProtocolInfoProto
060 * </pre>
061 */
062 boolean hasDeclaringClassProtocolName();
063 /**
064 * <code>required string declaringClassProtocolName = 2;</code>
065 *
066 * <pre>
067 **
068 * RPCs for a particular interface (ie protocol) are done using a
069 * IPC connection that is setup using rpcProxy.
070 * The rpcProxy's has a declared protocol name that is
071 * sent form client to server at connection time.
072 *
073 * Each Rpc call also sends a protocol name
074 * (called declaringClassprotocolName). This name is usually the same
075 * as the connection protocol name except in some cases.
076 * For example metaProtocols such ProtocolInfoProto which get metainfo
077 * about the protocol reuse the connection but need to indicate that
078 * the actual protocol is different (i.e. the protocol is
079 * ProtocolInfoProto) since they reuse the connection; in this case
080 * the declaringClassProtocolName field is set to the ProtocolInfoProto
081 * </pre>
082 */
083 java.lang.String getDeclaringClassProtocolName();
084 /**
085 * <code>required string declaringClassProtocolName = 2;</code>
086 *
087 * <pre>
088 **
089 * RPCs for a particular interface (ie protocol) are done using a
090 * IPC connection that is setup using rpcProxy.
091 * The rpcProxy's has a declared protocol name that is
092 * sent form client to server at connection time.
093 *
094 * Each Rpc call also sends a protocol name
095 * (called declaringClassprotocolName). This name is usually the same
096 * as the connection protocol name except in some cases.
097 * For example metaProtocols such ProtocolInfoProto which get metainfo
098 * about the protocol reuse the connection but need to indicate that
099 * the actual protocol is different (i.e. the protocol is
100 * ProtocolInfoProto) since they reuse the connection; in this case
101 * the declaringClassProtocolName field is set to the ProtocolInfoProto
102 * </pre>
103 */
104 com.google.protobuf.ByteString
105 getDeclaringClassProtocolNameBytes();
106
107 // required uint64 clientProtocolVersion = 3;
108 /**
109 * <code>required uint64 clientProtocolVersion = 3;</code>
110 *
111 * <pre>
112 ** protocol version of class declaring the called method
113 * </pre>
114 */
115 boolean hasClientProtocolVersion();
116 /**
117 * <code>required uint64 clientProtocolVersion = 3;</code>
118 *
119 * <pre>
120 ** protocol version of class declaring the called method
121 * </pre>
122 */
123 long getClientProtocolVersion();
124 }
125 /**
126 * Protobuf type {@code hadoop.common.RequestHeaderProto}
127 *
128 * <pre>
129 **
130 * This message is the header for the Protobuf Rpc Engine
131 * when sending a RPC request from RPC client to the RPC server.
132 * The actual request (serialized as protobuf) follows this request.
133 *
134 * No special header is needed for the Rpc Response for Protobuf Rpc Engine.
135 * The normal RPC response header (see RpcHeader.proto) are sufficient.
136 * </pre>
137 */
138 public static final class RequestHeaderProto extends
139 com.google.protobuf.GeneratedMessage
140 implements RequestHeaderProtoOrBuilder {
141 // Use RequestHeaderProto.newBuilder() to construct.
142 private RequestHeaderProto(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
143 super(builder);
144 this.unknownFields = builder.getUnknownFields();
145 }
146 private RequestHeaderProto(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
147
148 private static final RequestHeaderProto defaultInstance;
149 public static RequestHeaderProto getDefaultInstance() {
150 return defaultInstance;
151 }
152
153 public RequestHeaderProto getDefaultInstanceForType() {
154 return defaultInstance;
155 }
156
157 private final com.google.protobuf.UnknownFieldSet unknownFields;
158 @java.lang.Override
159 public final com.google.protobuf.UnknownFieldSet
160 getUnknownFields() {
161 return this.unknownFields;
162 }
163 private RequestHeaderProto(
164 com.google.protobuf.CodedInputStream input,
165 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
166 throws com.google.protobuf.InvalidProtocolBufferException {
167 initFields();
168 int mutable_bitField0_ = 0;
169 com.google.protobuf.UnknownFieldSet.Builder unknownFields =
170 com.google.protobuf.UnknownFieldSet.newBuilder();
171 try {
172 boolean done = false;
173 while (!done) {
174 int tag = input.readTag();
175 switch (tag) {
176 case 0:
177 done = true;
178 break;
179 default: {
180 if (!parseUnknownField(input, unknownFields,
181 extensionRegistry, tag)) {
182 done = true;
183 }
184 break;
185 }
186 case 10: {
187 bitField0_ |= 0x00000001;
188 methodName_ = input.readBytes();
189 break;
190 }
191 case 18: {
192 bitField0_ |= 0x00000002;
193 declaringClassProtocolName_ = input.readBytes();
194 break;
195 }
196 case 24: {
197 bitField0_ |= 0x00000004;
198 clientProtocolVersion_ = input.readUInt64();
199 break;
200 }
201 }
202 }
203 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
204 throw e.setUnfinishedMessage(this);
205 } catch (java.io.IOException e) {
206 throw new com.google.protobuf.InvalidProtocolBufferException(
207 e.getMessage()).setUnfinishedMessage(this);
208 } finally {
209 this.unknownFields = unknownFields.build();
210 makeExtensionsImmutable();
211 }
212 }
213 public static final com.google.protobuf.Descriptors.Descriptor
214 getDescriptor() {
215 return org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.internal_static_hadoop_common_RequestHeaderProto_descriptor;
216 }
217
218 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
219 internalGetFieldAccessorTable() {
220 return org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.internal_static_hadoop_common_RequestHeaderProto_fieldAccessorTable
221 .ensureFieldAccessorsInitialized(
222 org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto.class, org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto.Builder.class);
223 }
224
225 public static com.google.protobuf.Parser<RequestHeaderProto> PARSER =
226 new com.google.protobuf.AbstractParser<RequestHeaderProto>() {
227 public RequestHeaderProto parsePartialFrom(
228 com.google.protobuf.CodedInputStream input,
229 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
230 throws com.google.protobuf.InvalidProtocolBufferException {
231 return new RequestHeaderProto(input, extensionRegistry);
232 }
233 };
234
235 @java.lang.Override
236 public com.google.protobuf.Parser<RequestHeaderProto> getParserForType() {
237 return PARSER;
238 }
239
240 private int bitField0_;
241 // required string methodName = 1;
242 public static final int METHODNAME_FIELD_NUMBER = 1;
243 private java.lang.Object methodName_;
244 /**
245 * <code>required string methodName = 1;</code>
246 *
247 * <pre>
248 ** Name of the RPC method
249 * </pre>
250 */
251 public boolean hasMethodName() {
252 return ((bitField0_ & 0x00000001) == 0x00000001);
253 }
254 /**
255 * <code>required string methodName = 1;</code>
256 *
257 * <pre>
258 ** Name of the RPC method
259 * </pre>
260 */
261 public java.lang.String getMethodName() {
262 java.lang.Object ref = methodName_;
263 if (ref instanceof java.lang.String) {
264 return (java.lang.String) ref;
265 } else {
266 com.google.protobuf.ByteString bs =
267 (com.google.protobuf.ByteString) ref;
268 java.lang.String s = bs.toStringUtf8();
269 if (bs.isValidUtf8()) {
270 methodName_ = s;
271 }
272 return s;
273 }
274 }
275 /**
276 * <code>required string methodName = 1;</code>
277 *
278 * <pre>
279 ** Name of the RPC method
280 * </pre>
281 */
282 public com.google.protobuf.ByteString
283 getMethodNameBytes() {
284 java.lang.Object ref = methodName_;
285 if (ref instanceof java.lang.String) {
286 com.google.protobuf.ByteString b =
287 com.google.protobuf.ByteString.copyFromUtf8(
288 (java.lang.String) ref);
289 methodName_ = b;
290 return b;
291 } else {
292 return (com.google.protobuf.ByteString) ref;
293 }
294 }
295
296 // required string declaringClassProtocolName = 2;
297 public static final int DECLARINGCLASSPROTOCOLNAME_FIELD_NUMBER = 2;
298 private java.lang.Object declaringClassProtocolName_;
299 /**
300 * <code>required string declaringClassProtocolName = 2;</code>
301 *
302 * <pre>
303 **
304 * RPCs for a particular interface (ie protocol) are done using a
305 * IPC connection that is setup using rpcProxy.
306 * The rpcProxy's has a declared protocol name that is
307 * sent form client to server at connection time.
308 *
309 * Each Rpc call also sends a protocol name
310 * (called declaringClassprotocolName). This name is usually the same
311 * as the connection protocol name except in some cases.
312 * For example metaProtocols such ProtocolInfoProto which get metainfo
313 * about the protocol reuse the connection but need to indicate that
314 * the actual protocol is different (i.e. the protocol is
315 * ProtocolInfoProto) since they reuse the connection; in this case
316 * the declaringClassProtocolName field is set to the ProtocolInfoProto
317 * </pre>
318 */
319 public boolean hasDeclaringClassProtocolName() {
320 return ((bitField0_ & 0x00000002) == 0x00000002);
321 }
322 /**
323 * <code>required string declaringClassProtocolName = 2;</code>
324 *
325 * <pre>
326 **
327 * RPCs for a particular interface (ie protocol) are done using a
328 * IPC connection that is setup using rpcProxy.
329 * The rpcProxy's has a declared protocol name that is
330 * sent form client to server at connection time.
331 *
332 * Each Rpc call also sends a protocol name
333 * (called declaringClassprotocolName). This name is usually the same
334 * as the connection protocol name except in some cases.
335 * For example metaProtocols such ProtocolInfoProto which get metainfo
336 * about the protocol reuse the connection but need to indicate that
337 * the actual protocol is different (i.e. the protocol is
338 * ProtocolInfoProto) since they reuse the connection; in this case
339 * the declaringClassProtocolName field is set to the ProtocolInfoProto
340 * </pre>
341 */
342 public java.lang.String getDeclaringClassProtocolName() {
343 java.lang.Object ref = declaringClassProtocolName_;
344 if (ref instanceof java.lang.String) {
345 return (java.lang.String) ref;
346 } else {
347 com.google.protobuf.ByteString bs =
348 (com.google.protobuf.ByteString) ref;
349 java.lang.String s = bs.toStringUtf8();
350 if (bs.isValidUtf8()) {
351 declaringClassProtocolName_ = s;
352 }
353 return s;
354 }
355 }
356 /**
357 * <code>required string declaringClassProtocolName = 2;</code>
358 *
359 * <pre>
360 **
361 * RPCs for a particular interface (ie protocol) are done using a
362 * IPC connection that is setup using rpcProxy.
363 * The rpcProxy's has a declared protocol name that is
364 * sent form client to server at connection time.
365 *
366 * Each Rpc call also sends a protocol name
367 * (called declaringClassprotocolName). This name is usually the same
368 * as the connection protocol name except in some cases.
369 * For example metaProtocols such ProtocolInfoProto which get metainfo
370 * about the protocol reuse the connection but need to indicate that
371 * the actual protocol is different (i.e. the protocol is
372 * ProtocolInfoProto) since they reuse the connection; in this case
373 * the declaringClassProtocolName field is set to the ProtocolInfoProto
374 * </pre>
375 */
376 public com.google.protobuf.ByteString
377 getDeclaringClassProtocolNameBytes() {
378 java.lang.Object ref = declaringClassProtocolName_;
379 if (ref instanceof java.lang.String) {
380 com.google.protobuf.ByteString b =
381 com.google.protobuf.ByteString.copyFromUtf8(
382 (java.lang.String) ref);
383 declaringClassProtocolName_ = b;
384 return b;
385 } else {
386 return (com.google.protobuf.ByteString) ref;
387 }
388 }
389
390 // required uint64 clientProtocolVersion = 3;
391 public static final int CLIENTPROTOCOLVERSION_FIELD_NUMBER = 3;
392 private long clientProtocolVersion_;
393 /**
394 * <code>required uint64 clientProtocolVersion = 3;</code>
395 *
396 * <pre>
397 ** protocol version of class declaring the called method
398 * </pre>
399 */
400 public boolean hasClientProtocolVersion() {
401 return ((bitField0_ & 0x00000004) == 0x00000004);
402 }
403 /**
404 * <code>required uint64 clientProtocolVersion = 3;</code>
405 *
406 * <pre>
407 ** protocol version of class declaring the called method
408 * </pre>
409 */
410 public long getClientProtocolVersion() {
411 return clientProtocolVersion_;
412 }
413
414 private void initFields() {
415 methodName_ = "";
416 declaringClassProtocolName_ = "";
417 clientProtocolVersion_ = 0L;
418 }
419 private byte memoizedIsInitialized = -1;
420 public final boolean isInitialized() {
421 byte isInitialized = memoizedIsInitialized;
422 if (isInitialized != -1) return isInitialized == 1;
423
424 if (!hasMethodName()) {
425 memoizedIsInitialized = 0;
426 return false;
427 }
428 if (!hasDeclaringClassProtocolName()) {
429 memoizedIsInitialized = 0;
430 return false;
431 }
432 if (!hasClientProtocolVersion()) {
433 memoizedIsInitialized = 0;
434 return false;
435 }
436 memoizedIsInitialized = 1;
437 return true;
438 }
439
440 public void writeTo(com.google.protobuf.CodedOutputStream output)
441 throws java.io.IOException {
442 getSerializedSize();
443 if (((bitField0_ & 0x00000001) == 0x00000001)) {
444 output.writeBytes(1, getMethodNameBytes());
445 }
446 if (((bitField0_ & 0x00000002) == 0x00000002)) {
447 output.writeBytes(2, getDeclaringClassProtocolNameBytes());
448 }
449 if (((bitField0_ & 0x00000004) == 0x00000004)) {
450 output.writeUInt64(3, clientProtocolVersion_);
451 }
452 getUnknownFields().writeTo(output);
453 }
454
455 private int memoizedSerializedSize = -1;
456 public int getSerializedSize() {
457 int size = memoizedSerializedSize;
458 if (size != -1) return size;
459
460 size = 0;
461 if (((bitField0_ & 0x00000001) == 0x00000001)) {
462 size += com.google.protobuf.CodedOutputStream
463 .computeBytesSize(1, getMethodNameBytes());
464 }
465 if (((bitField0_ & 0x00000002) == 0x00000002)) {
466 size += com.google.protobuf.CodedOutputStream
467 .computeBytesSize(2, getDeclaringClassProtocolNameBytes());
468 }
469 if (((bitField0_ & 0x00000004) == 0x00000004)) {
470 size += com.google.protobuf.CodedOutputStream
471 .computeUInt64Size(3, clientProtocolVersion_);
472 }
473 size += getUnknownFields().getSerializedSize();
474 memoizedSerializedSize = size;
475 return size;
476 }
477
478 private static final long serialVersionUID = 0L;
479 @java.lang.Override
480 protected java.lang.Object writeReplace()
481 throws java.io.ObjectStreamException {
482 return super.writeReplace();
483 }
484
485 @java.lang.Override
486 public boolean equals(final java.lang.Object obj) {
487 if (obj == this) {
488 return true;
489 }
490 if (!(obj instanceof org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto)) {
491 return super.equals(obj);
492 }
493 org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto other = (org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto) obj;
494
495 boolean result = true;
496 result = result && (hasMethodName() == other.hasMethodName());
497 if (hasMethodName()) {
498 result = result && getMethodName()
499 .equals(other.getMethodName());
500 }
501 result = result && (hasDeclaringClassProtocolName() == other.hasDeclaringClassProtocolName());
502 if (hasDeclaringClassProtocolName()) {
503 result = result && getDeclaringClassProtocolName()
504 .equals(other.getDeclaringClassProtocolName());
505 }
506 result = result && (hasClientProtocolVersion() == other.hasClientProtocolVersion());
507 if (hasClientProtocolVersion()) {
508 result = result && (getClientProtocolVersion()
509 == other.getClientProtocolVersion());
510 }
511 result = result &&
512 getUnknownFields().equals(other.getUnknownFields());
513 return result;
514 }
515
516 private int memoizedHashCode = 0;
517 @java.lang.Override
518 public int hashCode() {
519 if (memoizedHashCode != 0) {
520 return memoizedHashCode;
521 }
522 int hash = 41;
523 hash = (19 * hash) + getDescriptorForType().hashCode();
524 if (hasMethodName()) {
525 hash = (37 * hash) + METHODNAME_FIELD_NUMBER;
526 hash = (53 * hash) + getMethodName().hashCode();
527 }
528 if (hasDeclaringClassProtocolName()) {
529 hash = (37 * hash) + DECLARINGCLASSPROTOCOLNAME_FIELD_NUMBER;
530 hash = (53 * hash) + getDeclaringClassProtocolName().hashCode();
531 }
532 if (hasClientProtocolVersion()) {
533 hash = (37 * hash) + CLIENTPROTOCOLVERSION_FIELD_NUMBER;
534 hash = (53 * hash) + hashLong(getClientProtocolVersion());
535 }
536 hash = (29 * hash) + getUnknownFields().hashCode();
537 memoizedHashCode = hash;
538 return hash;
539 }
540
541 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseFrom(
542 com.google.protobuf.ByteString data)
543 throws com.google.protobuf.InvalidProtocolBufferException {
544 return PARSER.parseFrom(data);
545 }
546 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseFrom(
547 com.google.protobuf.ByteString data,
548 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
549 throws com.google.protobuf.InvalidProtocolBufferException {
550 return PARSER.parseFrom(data, extensionRegistry);
551 }
552 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseFrom(byte[] data)
553 throws com.google.protobuf.InvalidProtocolBufferException {
554 return PARSER.parseFrom(data);
555 }
556 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseFrom(
557 byte[] data,
558 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
559 throws com.google.protobuf.InvalidProtocolBufferException {
560 return PARSER.parseFrom(data, extensionRegistry);
561 }
562 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseFrom(java.io.InputStream input)
563 throws java.io.IOException {
564 return PARSER.parseFrom(input);
565 }
566 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseFrom(
567 java.io.InputStream input,
568 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
569 throws java.io.IOException {
570 return PARSER.parseFrom(input, extensionRegistry);
571 }
572 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseDelimitedFrom(java.io.InputStream input)
573 throws java.io.IOException {
574 return PARSER.parseDelimitedFrom(input);
575 }
576 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseDelimitedFrom(
577 java.io.InputStream input,
578 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
579 throws java.io.IOException {
580 return PARSER.parseDelimitedFrom(input, extensionRegistry);
581 }
582 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseFrom(
583 com.google.protobuf.CodedInputStream input)
584 throws java.io.IOException {
585 return PARSER.parseFrom(input);
586 }
587 public static org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parseFrom(
588 com.google.protobuf.CodedInputStream input,
589 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
590 throws java.io.IOException {
591 return PARSER.parseFrom(input, extensionRegistry);
592 }
593
594 public static Builder newBuilder() { return Builder.create(); }
595 public Builder newBuilderForType() { return newBuilder(); }
596 public static Builder newBuilder(org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto prototype) {
597 return newBuilder().mergeFrom(prototype);
598 }
599 public Builder toBuilder() { return newBuilder(this); }
600
601 @java.lang.Override
602 protected Builder newBuilderForType(
603 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
604 Builder builder = new Builder(parent);
605 return builder;
606 }
607 /**
608 * Protobuf type {@code hadoop.common.RequestHeaderProto}
609 *
610 * <pre>
611 **
612 * This message is the header for the Protobuf Rpc Engine
613 * when sending a RPC request from RPC client to the RPC server.
614 * The actual request (serialized as protobuf) follows this request.
615 *
616 * No special header is needed for the Rpc Response for Protobuf Rpc Engine.
617 * The normal RPC response header (see RpcHeader.proto) are sufficient.
618 * </pre>
619 */
620 public static final class Builder extends
621 com.google.protobuf.GeneratedMessage.Builder<Builder>
622 implements org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProtoOrBuilder {
623 public static final com.google.protobuf.Descriptors.Descriptor
624 getDescriptor() {
625 return org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.internal_static_hadoop_common_RequestHeaderProto_descriptor;
626 }
627
628 protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
629 internalGetFieldAccessorTable() {
630 return org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.internal_static_hadoop_common_RequestHeaderProto_fieldAccessorTable
631 .ensureFieldAccessorsInitialized(
632 org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto.class, org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto.Builder.class);
633 }
634
635 // Construct using org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto.newBuilder()
636 private Builder() {
637 maybeForceBuilderInitialization();
638 }
639
640 private Builder(
641 com.google.protobuf.GeneratedMessage.BuilderParent parent) {
642 super(parent);
643 maybeForceBuilderInitialization();
644 }
645 private void maybeForceBuilderInitialization() {
646 if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
647 }
648 }
649 private static Builder create() {
650 return new Builder();
651 }
652
653 public Builder clear() {
654 super.clear();
655 methodName_ = "";
656 bitField0_ = (bitField0_ & ~0x00000001);
657 declaringClassProtocolName_ = "";
658 bitField0_ = (bitField0_ & ~0x00000002);
659 clientProtocolVersion_ = 0L;
660 bitField0_ = (bitField0_ & ~0x00000004);
661 return this;
662 }
663
664 public Builder clone() {
665 return create().mergeFrom(buildPartial());
666 }
667
668 public com.google.protobuf.Descriptors.Descriptor
669 getDescriptorForType() {
670 return org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.internal_static_hadoop_common_RequestHeaderProto_descriptor;
671 }
672
673 public org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto getDefaultInstanceForType() {
674 return org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto.getDefaultInstance();
675 }
676
677 public org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto build() {
678 org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto result = buildPartial();
679 if (!result.isInitialized()) {
680 throw newUninitializedMessageException(result);
681 }
682 return result;
683 }
684
685 public org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto buildPartial() {
686 org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto result = new org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto(this);
687 int from_bitField0_ = bitField0_;
688 int to_bitField0_ = 0;
689 if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
690 to_bitField0_ |= 0x00000001;
691 }
692 result.methodName_ = methodName_;
693 if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
694 to_bitField0_ |= 0x00000002;
695 }
696 result.declaringClassProtocolName_ = declaringClassProtocolName_;
697 if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
698 to_bitField0_ |= 0x00000004;
699 }
700 result.clientProtocolVersion_ = clientProtocolVersion_;
701 result.bitField0_ = to_bitField0_;
702 onBuilt();
703 return result;
704 }
705
706 public Builder mergeFrom(com.google.protobuf.Message other) {
707 if (other instanceof org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto) {
708 return mergeFrom((org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto)other);
709 } else {
710 super.mergeFrom(other);
711 return this;
712 }
713 }
714
715 public Builder mergeFrom(org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto other) {
716 if (other == org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto.getDefaultInstance()) return this;
717 if (other.hasMethodName()) {
718 bitField0_ |= 0x00000001;
719 methodName_ = other.methodName_;
720 onChanged();
721 }
722 if (other.hasDeclaringClassProtocolName()) {
723 bitField0_ |= 0x00000002;
724 declaringClassProtocolName_ = other.declaringClassProtocolName_;
725 onChanged();
726 }
727 if (other.hasClientProtocolVersion()) {
728 setClientProtocolVersion(other.getClientProtocolVersion());
729 }
730 this.mergeUnknownFields(other.getUnknownFields());
731 return this;
732 }
733
734 public final boolean isInitialized() {
735 if (!hasMethodName()) {
736
737 return false;
738 }
739 if (!hasDeclaringClassProtocolName()) {
740
741 return false;
742 }
743 if (!hasClientProtocolVersion()) {
744
745 return false;
746 }
747 return true;
748 }
749
750 public Builder mergeFrom(
751 com.google.protobuf.CodedInputStream input,
752 com.google.protobuf.ExtensionRegistryLite extensionRegistry)
753 throws java.io.IOException {
754 org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto parsedMessage = null;
755 try {
756 parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
757 } catch (com.google.protobuf.InvalidProtocolBufferException e) {
758 parsedMessage = (org.apache.hadoop.ipc.protobuf.ProtobufRpcEngineProtos.RequestHeaderProto) e.getUnfinishedMessage();
759 throw e;
760 } finally {
761 if (parsedMessage != null) {
762 mergeFrom(parsedMessage);
763 }
764 }
765 return this;
766 }
767 private int bitField0_;
768
769 // required string methodName = 1;
770 private java.lang.Object methodName_ = "";
771 /**
772 * <code>required string methodName = 1;</code>
773 *
774 * <pre>
775 ** Name of the RPC method
776 * </pre>
777 */
778 public boolean hasMethodName() {
779 return ((bitField0_ & 0x00000001) == 0x00000001);
780 }
781 /**
782 * <code>required string methodName = 1;</code>
783 *
784 * <pre>
785 ** Name of the RPC method
786 * </pre>
787 */
788 public java.lang.String getMethodName() {
789 java.lang.Object ref = methodName_;
790 if (!(ref instanceof java.lang.String)) {
791 java.lang.String s = ((com.google.protobuf.ByteString) ref)
792 .toStringUtf8();
793 methodName_ = s;
794 return s;
795 } else {
796 return (java.lang.String) ref;
797 }
798 }
799 /**
800 * <code>required string methodName = 1;</code>
801 *
802 * <pre>
803 ** Name of the RPC method
804 * </pre>
805 */
806 public com.google.protobuf.ByteString
807 getMethodNameBytes() {
808 java.lang.Object ref = methodName_;
809 if (ref instanceof String) {
810 com.google.protobuf.ByteString b =
811 com.google.protobuf.ByteString.copyFromUtf8(
812 (java.lang.String) ref);
813 methodName_ = b;
814 return b;
815 } else {
816 return (com.google.protobuf.ByteString) ref;
817 }
818 }
819 /**
820 * <code>required string methodName = 1;</code>
821 *
822 * <pre>
823 ** Name of the RPC method
824 * </pre>
825 */
826 public Builder setMethodName(
827 java.lang.String value) {
828 if (value == null) {
829 throw new NullPointerException();
830 }
831 bitField0_ |= 0x00000001;
832 methodName_ = value;
833 onChanged();
834 return this;
835 }
836 /**
837 * <code>required string methodName = 1;</code>
838 *
839 * <pre>
840 ** Name of the RPC method
841 * </pre>
842 */
843 public Builder clearMethodName() {
844 bitField0_ = (bitField0_ & ~0x00000001);
845 methodName_ = getDefaultInstance().getMethodName();
846 onChanged();
847 return this;
848 }
849 /**
850 * <code>required string methodName = 1;</code>
851 *
852 * <pre>
853 ** Name of the RPC method
854 * </pre>
855 */
856 public Builder setMethodNameBytes(
857 com.google.protobuf.ByteString value) {
858 if (value == null) {
859 throw new NullPointerException();
860 }
861 bitField0_ |= 0x00000001;
862 methodName_ = value;
863 onChanged();
864 return this;
865 }
866
867 // required string declaringClassProtocolName = 2;
868 private java.lang.Object declaringClassProtocolName_ = "";
869 /**
870 * <code>required string declaringClassProtocolName = 2;</code>
871 *
872 * <pre>
873 **
874 * RPCs for a particular interface (ie protocol) are done using a
875 * IPC connection that is setup using rpcProxy.
876 * The rpcProxy's has a declared protocol name that is
877 * sent form client to server at connection time.
878 *
879 * Each Rpc call also sends a protocol name
880 * (called declaringClassprotocolName). This name is usually the same
881 * as the connection protocol name except in some cases.
882 * For example metaProtocols such ProtocolInfoProto which get metainfo
883 * about the protocol reuse the connection but need to indicate that
884 * the actual protocol is different (i.e. the protocol is
885 * ProtocolInfoProto) since they reuse the connection; in this case
886 * the declaringClassProtocolName field is set to the ProtocolInfoProto
887 * </pre>
888 */
889 public boolean hasDeclaringClassProtocolName() {
890 return ((bitField0_ & 0x00000002) == 0x00000002);
891 }
892 /**
893 * <code>required string declaringClassProtocolName = 2;</code>
894 *
895 * <pre>
896 **
897 * RPCs for a particular interface (ie protocol) are done using a
898 * IPC connection that is setup using rpcProxy.
899 * The rpcProxy's has a declared protocol name that is
900 * sent form client to server at connection time.
901 *
902 * Each Rpc call also sends a protocol name
903 * (called declaringClassprotocolName). This name is usually the same
904 * as the connection protocol name except in some cases.
905 * For example metaProtocols such ProtocolInfoProto which get metainfo
906 * about the protocol reuse the connection but need to indicate that
907 * the actual protocol is different (i.e. the protocol is
908 * ProtocolInfoProto) since they reuse the connection; in this case
909 * the declaringClassProtocolName field is set to the ProtocolInfoProto
910 * </pre>
911 */
912 public java.lang.String getDeclaringClassProtocolName() {
913 java.lang.Object ref = declaringClassProtocolName_;
914 if (!(ref instanceof java.lang.String)) {
915 java.lang.String s = ((com.google.protobuf.ByteString) ref)
916 .toStringUtf8();
917 declaringClassProtocolName_ = s;
918 return s;
919 } else {
920 return (java.lang.String) ref;
921 }
922 }
923 /**
924 * <code>required string declaringClassProtocolName = 2;</code>
925 *
926 * <pre>
927 **
928 * RPCs for a particular interface (ie protocol) are done using a
929 * IPC connection that is setup using rpcProxy.
930 * The rpcProxy's has a declared protocol name that is
931 * sent form client to server at connection time.
932 *
933 * Each Rpc call also sends a protocol name
934 * (called declaringClassprotocolName). This name is usually the same
935 * as the connection protocol name except in some cases.
936 * For example metaProtocols such ProtocolInfoProto which get metainfo
937 * about the protocol reuse the connection but need to indicate that
938 * the actual protocol is different (i.e. the protocol is
939 * ProtocolInfoProto) since they reuse the connection; in this case
940 * the declaringClassProtocolName field is set to the ProtocolInfoProto
941 * </pre>
942 */
943 public com.google.protobuf.ByteString
944 getDeclaringClassProtocolNameBytes() {
945 java.lang.Object ref = declaringClassProtocolName_;
946 if (ref instanceof String) {
947 com.google.protobuf.ByteString b =
948 com.google.protobuf.ByteString.copyFromUtf8(
949 (java.lang.String) ref);
950 declaringClassProtocolName_ = b;
951 return b;
952 } else {
953 return (com.google.protobuf.ByteString) ref;
954 }
955 }
956 /**
957 * <code>required string declaringClassProtocolName = 2;</code>
958 *
959 * <pre>
960 **
961 * RPCs for a particular interface (ie protocol) are done using a
962 * IPC connection that is setup using rpcProxy.
963 * The rpcProxy's has a declared protocol name that is
964 * sent form client to server at connection time.
965 *
966 * Each Rpc call also sends a protocol name
967 * (called declaringClassprotocolName). This name is usually the same
968 * as the connection protocol name except in some cases.
969 * For example metaProtocols such ProtocolInfoProto which get metainfo
970 * about the protocol reuse the connection but need to indicate that
971 * the actual protocol is different (i.e. the protocol is
972 * ProtocolInfoProto) since they reuse the connection; in this case
973 * the declaringClassProtocolName field is set to the ProtocolInfoProto
974 * </pre>
975 */
976 public Builder setDeclaringClassProtocolName(
977 java.lang.String value) {
978 if (value == null) {
979 throw new NullPointerException();
980 }
981 bitField0_ |= 0x00000002;
982 declaringClassProtocolName_ = value;
983 onChanged();
984 return this;
985 }
986 /**
987 * <code>required string declaringClassProtocolName = 2;</code>
988 *
989 * <pre>
990 **
991 * RPCs for a particular interface (ie protocol) are done using a
992 * IPC connection that is setup using rpcProxy.
993 * The rpcProxy's has a declared protocol name that is
994 * sent form client to server at connection time.
995 *
996 * Each Rpc call also sends a protocol name
997 * (called declaringClassprotocolName). This name is usually the same
998 * as the connection protocol name except in some cases.
999 * For example metaProtocols such ProtocolInfoProto which get metainfo
1000 * about the protocol reuse the connection but need to indicate that
1001 * the actual protocol is different (i.e. the protocol is
1002 * ProtocolInfoProto) since they reuse the connection; in this case
1003 * the declaringClassProtocolName field is set to the ProtocolInfoProto
1004 * </pre>
1005 */
1006 public Builder clearDeclaringClassProtocolName() {
1007 bitField0_ = (bitField0_ & ~0x00000002);
1008 declaringClassProtocolName_ = getDefaultInstance().getDeclaringClassProtocolName();
1009 onChanged();
1010 return this;
1011 }
1012 /**
1013 * <code>required string declaringClassProtocolName = 2;</code>
1014 *
1015 * <pre>
1016 **
1017 * RPCs for a particular interface (ie protocol) are done using a
1018 * IPC connection that is setup using rpcProxy.
1019 * The rpcProxy's has a declared protocol name that is
1020 * sent form client to server at connection time.
1021 *
1022 * Each Rpc call also sends a protocol name
1023 * (called declaringClassprotocolName). This name is usually the same
1024 * as the connection protocol name except in some cases.
1025 * For example metaProtocols such ProtocolInfoProto which get metainfo
1026 * about the protocol reuse the connection but need to indicate that
1027 * the actual protocol is different (i.e. the protocol is
1028 * ProtocolInfoProto) since they reuse the connection; in this case
1029 * the declaringClassProtocolName field is set to the ProtocolInfoProto
1030 * </pre>
1031 */
1032 public Builder setDeclaringClassProtocolNameBytes(
1033 com.google.protobuf.ByteString value) {
1034 if (value == null) {
1035 throw new NullPointerException();
1036 }
1037 bitField0_ |= 0x00000002;
1038 declaringClassProtocolName_ = value;
1039 onChanged();
1040 return this;
1041 }
1042
1043 // required uint64 clientProtocolVersion = 3;
1044 private long clientProtocolVersion_ ;
1045 /**
1046 * <code>required uint64 clientProtocolVersion = 3;</code>
1047 *
1048 * <pre>
1049 ** protocol version of class declaring the called method
1050 * </pre>
1051 */
1052 public boolean hasClientProtocolVersion() {
1053 return ((bitField0_ & 0x00000004) == 0x00000004);
1054 }
1055 /**
1056 * <code>required uint64 clientProtocolVersion = 3;</code>
1057 *
1058 * <pre>
1059 ** protocol version of class declaring the called method
1060 * </pre>
1061 */
1062 public long getClientProtocolVersion() {
1063 return clientProtocolVersion_;
1064 }
1065 /**
1066 * <code>required uint64 clientProtocolVersion = 3;</code>
1067 *
1068 * <pre>
1069 ** protocol version of class declaring the called method
1070 * </pre>
1071 */
1072 public Builder setClientProtocolVersion(long value) {
1073 bitField0_ |= 0x00000004;
1074 clientProtocolVersion_ = value;
1075 onChanged();
1076 return this;
1077 }
1078 /**
1079 * <code>required uint64 clientProtocolVersion = 3;</code>
1080 *
1081 * <pre>
1082 ** protocol version of class declaring the called method
1083 * </pre>
1084 */
1085 public Builder clearClientProtocolVersion() {
1086 bitField0_ = (bitField0_ & ~0x00000004);
1087 clientProtocolVersion_ = 0L;
1088 onChanged();
1089 return this;
1090 }
1091
1092 // @@protoc_insertion_point(builder_scope:hadoop.common.RequestHeaderProto)
1093 }
1094
1095 static {
1096 defaultInstance = new RequestHeaderProto(true);
1097 defaultInstance.initFields();
1098 }
1099
1100 // @@protoc_insertion_point(class_scope:hadoop.common.RequestHeaderProto)
1101 }
1102
1103 private static com.google.protobuf.Descriptors.Descriptor
1104 internal_static_hadoop_common_RequestHeaderProto_descriptor;
1105 private static
1106 com.google.protobuf.GeneratedMessage.FieldAccessorTable
1107 internal_static_hadoop_common_RequestHeaderProto_fieldAccessorTable;
1108
1109 public static com.google.protobuf.Descriptors.FileDescriptor
1110 getDescriptor() {
1111 return descriptor;
1112 }
1113 private static com.google.protobuf.Descriptors.FileDescriptor
1114 descriptor;
1115 static {
1116 java.lang.String[] descriptorData = {
1117 "\n\027ProtobufRpcEngine.proto\022\rhadoop.common" +
1118 "\"k\n\022RequestHeaderProto\022\022\n\nmethodName\030\001 \002" +
1119 "(\t\022\"\n\032declaringClassProtocolName\030\002 \002(\t\022\035" +
1120 "\n\025clientProtocolVersion\030\003 \002(\004B<\n\036org.apa" +
1121 "che.hadoop.ipc.protobufB\027ProtobufRpcEngi" +
1122 "neProtos\240\001\001"
1123 };
1124 com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
1125 new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
1126 public com.google.protobuf.ExtensionRegistry assignDescriptors(
1127 com.google.protobuf.Descriptors.FileDescriptor root) {
1128 descriptor = root;
1129 internal_static_hadoop_common_RequestHeaderProto_descriptor =
1130 getDescriptor().getMessageTypes().get(0);
1131 internal_static_hadoop_common_RequestHeaderProto_fieldAccessorTable = new
1132 com.google.protobuf.GeneratedMessage.FieldAccessorTable(
1133 internal_static_hadoop_common_RequestHeaderProto_descriptor,
1134 new java.lang.String[] { "MethodName", "DeclaringClassProtocolName", "ClientProtocolVersion", });
1135 return null;
1136 }
1137 };
1138 com.google.protobuf.Descriptors.FileDescriptor
1139 .internalBuildGeneratedFileFrom(descriptorData,
1140 new com.google.protobuf.Descriptors.FileDescriptor[] {
1141 }, assigner);
1142 }
1143
1144 // @@protoc_insertion_point(outer_class_scope)
1145 }