Return-Path: X-Original-To: apmail-hadoop-hdfs-commits-archive@minotaur.apache.org Delivered-To: apmail-hadoop-hdfs-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id BF9A3781F for ; Tue, 1 Nov 2011 05:17:31 +0000 (UTC) Received: (qmail 20900 invoked by uid 500); 1 Nov 2011 05:17:31 -0000 Delivered-To: apmail-hadoop-hdfs-commits-archive@hadoop.apache.org Received: (qmail 20731 invoked by uid 500); 1 Nov 2011 05:17:30 -0000 Mailing-List: contact hdfs-commits-help@hadoop.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: hdfs-dev@hadoop.apache.org Delivered-To: mailing list hdfs-commits@hadoop.apache.org Received: (qmail 20543 invoked by uid 99); 1 Nov 2011 05:17:28 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 01 Nov 2011 05:17:28 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 01 Nov 2011 05:17:17 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id EE80F23889FD; Tue, 1 Nov 2011 05:16:54 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1195828 [2/3] - in /hadoop/common/branches/branch-0.23/hadoop-hdfs-project/hadoop-hdfs: ./ src/main/java/org/apache/hadoop/hdfs/ src/main/java/org/apache/hadoop/hdfs/protocol/datatransfer/ src/main/java/org/apache/hadoop/hdfs/protocol/prot... Date: Tue, 01 Nov 2011 05:16:54 -0000 To: hdfs-commits@hadoop.apache.org From: todd@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20111101051654.EE80F23889FD@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Modified: hadoop/common/branches/branch-0.23/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/protocol/proto/DataTransferProtos.java URL: http://svn.apache.org/viewvc/hadoop/common/branches/branch-0.23/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/protocol/proto/DataTransferProtos.java?rev=1195828&r1=1195827&r2=1195828&view=diff ============================================================================== --- hadoop/common/branches/branch-0.23/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/protocol/proto/DataTransferProtos.java (original) +++ hadoop/common/branches/branch-0.23/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/protocol/proto/DataTransferProtos.java Tue Nov 1 05:16:53 2011 @@ -1951,127 +1951,77 @@ public final class DataTransferProtos { // @@protoc_insertion_point(class_scope:OpReadBlockProto) } - public interface OpWriteBlockProtoOrBuilder + public interface ChecksumProtoOrBuilder extends com.google.protobuf.MessageOrBuilder { - // required .ClientOperationHeaderProto header = 1; - boolean hasHeader(); - org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto getHeader(); - org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProtoOrBuilder getHeaderOrBuilder(); - - // repeated .DatanodeInfoProto targets = 2; - java.util.List - getTargetsList(); - org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getTargets(int index); - int getTargetsCount(); - java.util.List - getTargetsOrBuilderList(); - org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getTargetsOrBuilder( - int index); - - // optional .DatanodeInfoProto source = 3; - boolean hasSource(); - org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getSource(); - org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getSourceOrBuilder(); - - // required .OpWriteBlockProto.BlockConstructionStage stage = 4; - boolean hasStage(); - org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage getStage(); - - // required uint32 pipelineSize = 5; - boolean hasPipelineSize(); - int getPipelineSize(); - - // required uint64 minBytesRcvd = 6; - boolean hasMinBytesRcvd(); - long getMinBytesRcvd(); - - // required uint64 maxBytesRcvd = 7; - boolean hasMaxBytesRcvd(); - long getMaxBytesRcvd(); - - // required uint64 latestGenerationStamp = 8; - boolean hasLatestGenerationStamp(); - long getLatestGenerationStamp(); + // required .ChecksumProto.ChecksumType type = 1; + boolean hasType(); + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType getType(); + + // required uint32 bytesPerChecksum = 2; + boolean hasBytesPerChecksum(); + int getBytesPerChecksum(); } - public static final class OpWriteBlockProto extends + public static final class ChecksumProto extends com.google.protobuf.GeneratedMessage - implements OpWriteBlockProtoOrBuilder { - // Use OpWriteBlockProto.newBuilder() to construct. - private OpWriteBlockProto(Builder builder) { + implements ChecksumProtoOrBuilder { + // Use ChecksumProto.newBuilder() to construct. + private ChecksumProto(Builder builder) { super(builder); } - private OpWriteBlockProto(boolean noInit) {} + private ChecksumProto(boolean noInit) {} - private static final OpWriteBlockProto defaultInstance; - public static OpWriteBlockProto getDefaultInstance() { + private static final ChecksumProto defaultInstance; + public static ChecksumProto getDefaultInstance() { return defaultInstance; } - public OpWriteBlockProto getDefaultInstanceForType() { + public ChecksumProto getDefaultInstanceForType() { return defaultInstance; } public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { - return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_OpWriteBlockProto_descriptor; + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_ChecksumProto_descriptor; } protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() { - return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_OpWriteBlockProto_fieldAccessorTable; + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_ChecksumProto_fieldAccessorTable; } - public enum BlockConstructionStage + public enum ChecksumType implements com.google.protobuf.ProtocolMessageEnum { - PIPELINE_SETUP_APPEND(0, 0), - PIPELINE_SETUP_APPEND_RECOVERY(1, 1), - DATA_STREAMING(2, 2), - PIPELINE_SETUP_STREAMING_RECOVERY(3, 3), - PIPELINE_CLOSE(4, 4), - PIPELINE_CLOSE_RECOVERY(5, 5), - PIPELINE_SETUP_CREATE(6, 6), - TRANSFER_RBW(7, 7), - TRANSFER_FINALIZED(8, 8), + NULL(0, 0), + CRC32(1, 1), + CRC32C(2, 2), ; - public static final int PIPELINE_SETUP_APPEND_VALUE = 0; - public static final int PIPELINE_SETUP_APPEND_RECOVERY_VALUE = 1; - public static final int DATA_STREAMING_VALUE = 2; - public static final int PIPELINE_SETUP_STREAMING_RECOVERY_VALUE = 3; - public static final int PIPELINE_CLOSE_VALUE = 4; - public static final int PIPELINE_CLOSE_RECOVERY_VALUE = 5; - public static final int PIPELINE_SETUP_CREATE_VALUE = 6; - public static final int TRANSFER_RBW_VALUE = 7; - public static final int TRANSFER_FINALIZED_VALUE = 8; + public static final int NULL_VALUE = 0; + public static final int CRC32_VALUE = 1; + public static final int CRC32C_VALUE = 2; public final int getNumber() { return value; } - public static BlockConstructionStage valueOf(int value) { + public static ChecksumType valueOf(int value) { switch (value) { - case 0: return PIPELINE_SETUP_APPEND; - case 1: return PIPELINE_SETUP_APPEND_RECOVERY; - case 2: return DATA_STREAMING; - case 3: return PIPELINE_SETUP_STREAMING_RECOVERY; - case 4: return PIPELINE_CLOSE; - case 5: return PIPELINE_CLOSE_RECOVERY; - case 6: return PIPELINE_SETUP_CREATE; - case 7: return TRANSFER_RBW; - case 8: return TRANSFER_FINALIZED; + case 0: return NULL; + case 1: return CRC32; + case 2: return CRC32C; default: return null; } } - public static com.google.protobuf.Internal.EnumLiteMap + public static com.google.protobuf.Internal.EnumLiteMap internalGetValueMap() { return internalValueMap; } - private static com.google.protobuf.Internal.EnumLiteMap + private static com.google.protobuf.Internal.EnumLiteMap internalValueMap = - new com.google.protobuf.Internal.EnumLiteMap() { - public BlockConstructionStage findValueByNumber(int number) { - return BlockConstructionStage.valueOf(number); + new com.google.protobuf.Internal.EnumLiteMap() { + public ChecksumType findValueByNumber(int number) { + return ChecksumType.valueOf(number); } }; @@ -2085,14 +2035,14 @@ public final class DataTransferProtos { } public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { - return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.getDescriptor().getEnumTypes().get(0); + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.getDescriptor().getEnumTypes().get(0); } - private static final BlockConstructionStage[] VALUES = { - PIPELINE_SETUP_APPEND, PIPELINE_SETUP_APPEND_RECOVERY, DATA_STREAMING, PIPELINE_SETUP_STREAMING_RECOVERY, PIPELINE_CLOSE, PIPELINE_CLOSE_RECOVERY, PIPELINE_SETUP_CREATE, TRANSFER_RBW, TRANSFER_FINALIZED, + private static final ChecksumType[] VALUES = { + NULL, CRC32, CRC32C, }; - public static BlockConstructionStage valueOf( + public static ChecksumType valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc) { if (desc.getType() != getDescriptor()) { throw new java.lang.IllegalArgumentException( @@ -2104,148 +2054,2093 @@ public final class DataTransferProtos { private final int index; private final int value; - private BlockConstructionStage(int index, int value) { + private ChecksumType(int index, int value) { this.index = index; this.value = value; } - // @@protoc_insertion_point(enum_scope:OpWriteBlockProto.BlockConstructionStage) + // @@protoc_insertion_point(enum_scope:ChecksumProto.ChecksumType) } private int bitField0_; - // required .ClientOperationHeaderProto header = 1; - public static final int HEADER_FIELD_NUMBER = 1; - private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto header_; - public boolean hasHeader() { + // required .ChecksumProto.ChecksumType type = 1; + public static final int TYPE_FIELD_NUMBER = 1; + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType type_; + public boolean hasType() { return ((bitField0_ & 0x00000001) == 0x00000001); } - public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto getHeader() { - return header_; - } - public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProtoOrBuilder getHeaderOrBuilder() { - return header_; - } - - // repeated .DatanodeInfoProto targets = 2; - public static final int TARGETS_FIELD_NUMBER = 2; - private java.util.List targets_; - public java.util.List getTargetsList() { - return targets_; - } - public java.util.List - getTargetsOrBuilderList() { - return targets_; - } - public int getTargetsCount() { - return targets_.size(); - } - public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getTargets(int index) { - return targets_.get(index); - } - public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getTargetsOrBuilder( - int index) { - return targets_.get(index); + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType getType() { + return type_; } - // optional .DatanodeInfoProto source = 3; - public static final int SOURCE_FIELD_NUMBER = 3; - private org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto source_; - public boolean hasSource() { + // required uint32 bytesPerChecksum = 2; + public static final int BYTESPERCHECKSUM_FIELD_NUMBER = 2; + private int bytesPerChecksum_; + public boolean hasBytesPerChecksum() { return ((bitField0_ & 0x00000002) == 0x00000002); } - public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getSource() { - return source_; - } - public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getSourceOrBuilder() { - return source_; - } - - // required .OpWriteBlockProto.BlockConstructionStage stage = 4; - public static final int STAGE_FIELD_NUMBER = 4; - private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage stage_; - public boolean hasStage() { - return ((bitField0_ & 0x00000004) == 0x00000004); - } - public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage getStage() { - return stage_; - } - - // required uint32 pipelineSize = 5; - public static final int PIPELINESIZE_FIELD_NUMBER = 5; - private int pipelineSize_; - public boolean hasPipelineSize() { - return ((bitField0_ & 0x00000008) == 0x00000008); - } - public int getPipelineSize() { - return pipelineSize_; - } - - // required uint64 minBytesRcvd = 6; - public static final int MINBYTESRCVD_FIELD_NUMBER = 6; - private long minBytesRcvd_; - public boolean hasMinBytesRcvd() { - return ((bitField0_ & 0x00000010) == 0x00000010); - } - public long getMinBytesRcvd() { - return minBytesRcvd_; - } - - // required uint64 maxBytesRcvd = 7; - public static final int MAXBYTESRCVD_FIELD_NUMBER = 7; - private long maxBytesRcvd_; - public boolean hasMaxBytesRcvd() { - return ((bitField0_ & 0x00000020) == 0x00000020); - } - public long getMaxBytesRcvd() { - return maxBytesRcvd_; - } - - // required uint64 latestGenerationStamp = 8; - public static final int LATESTGENERATIONSTAMP_FIELD_NUMBER = 8; - private long latestGenerationStamp_; - public boolean hasLatestGenerationStamp() { - return ((bitField0_ & 0x00000040) == 0x00000040); - } - public long getLatestGenerationStamp() { - return latestGenerationStamp_; + public int getBytesPerChecksum() { + return bytesPerChecksum_; } private void initFields() { - header_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.getDefaultInstance(); - targets_ = java.util.Collections.emptyList(); - source_ = org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.getDefaultInstance(); - stage_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage.PIPELINE_SETUP_APPEND; - pipelineSize_ = 0; - minBytesRcvd_ = 0L; - maxBytesRcvd_ = 0L; - latestGenerationStamp_ = 0L; + type_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType.NULL; + bytesPerChecksum_ = 0; } private byte memoizedIsInitialized = -1; public final boolean isInitialized() { byte isInitialized = memoizedIsInitialized; if (isInitialized != -1) return isInitialized == 1; - if (!hasHeader()) { + if (!hasType()) { memoizedIsInitialized = 0; return false; } - if (!hasStage()) { + if (!hasBytesPerChecksum()) { memoizedIsInitialized = 0; return false; } - if (!hasPipelineSize()) { - memoizedIsInitialized = 0; - return false; + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeEnum(1, type_.getNumber()); } - if (!hasMinBytesRcvd()) { - memoizedIsInitialized = 0; - return false; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeUInt32(2, bytesPerChecksum_); } - if (!hasMaxBytesRcvd()) { - memoizedIsInitialized = 0; - return false; + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_.getNumber()); } - if (!hasLatestGenerationStamp()) { + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(2, bytesPerChecksum_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto)) { + return super.equals(obj); + } + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto other = (org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto) obj; + + boolean result = true; + result = result && (hasType() == other.hasType()); + if (hasType()) { + result = result && + (getType() == other.getType()); + } + result = result && (hasBytesPerChecksum() == other.hasBytesPerChecksum()); + if (hasBytesPerChecksum()) { + result = result && (getBytesPerChecksum() + == other.getBytesPerChecksum()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + hashEnum(getType()); + } + if (hasBytesPerChecksum()) { + hash = (37 * hash) + BYTESPERCHECKSUM_FIELD_NUMBER; + hash = (53 * hash) + getBytesPerChecksum(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProtoOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_ChecksumProto_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_ChecksumProto_fieldAccessorTable; + } + + // Construct using org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + type_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType.NULL; + bitField0_ = (bitField0_ & ~0x00000001); + bytesPerChecksum_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.getDescriptor(); + } + + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto getDefaultInstanceForType() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.getDefaultInstance(); + } + + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto build() { + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto buildPartial() { + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto result = new org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) == 0x00000002)) { + to_bitField0_ |= 0x00000002; + } + result.bytesPerChecksum_ = bytesPerChecksum_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto) { + return mergeFrom((org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto other) { + if (other == org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasBytesPerChecksum()) { + setBytesPerChecksum(other.getBytesPerChecksum()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasType()) { + + return false; + } + if (!hasBytesPerChecksum()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 8: { + int rawValue = input.readEnum(); + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType value = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = value; + } + break; + } + case 16: { + bitField0_ |= 0x00000002; + bytesPerChecksum_ = input.readUInt32(); + break; + } + } + } + } + + private int bitField0_; + + // required .ChecksumProto.ChecksumType type = 1; + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType type_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType.NULL; + public boolean hasType() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType getType() { + return type_; + } + public Builder setType(org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value; + onChanged(); + return this; + } + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.ChecksumType.NULL; + onChanged(); + return this; + } + + // required uint32 bytesPerChecksum = 2; + private int bytesPerChecksum_ ; + public boolean hasBytesPerChecksum() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public int getBytesPerChecksum() { + return bytesPerChecksum_; + } + public Builder setBytesPerChecksum(int value) { + bitField0_ |= 0x00000002; + bytesPerChecksum_ = value; + onChanged(); + return this; + } + public Builder clearBytesPerChecksum() { + bitField0_ = (bitField0_ & ~0x00000002); + bytesPerChecksum_ = 0; + onChanged(); + return this; + } + + // @@protoc_insertion_point(builder_scope:ChecksumProto) + } + + static { + defaultInstance = new ChecksumProto(true); + defaultInstance.initFields(); + } + + // @@protoc_insertion_point(class_scope:ChecksumProto) + } + + public interface OpWriteBlockProtoOrBuilder + extends com.google.protobuf.MessageOrBuilder { + + // required .ClientOperationHeaderProto header = 1; + boolean hasHeader(); + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto getHeader(); + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProtoOrBuilder getHeaderOrBuilder(); + + // repeated .DatanodeInfoProto targets = 2; + java.util.List + getTargetsList(); + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getTargets(int index); + int getTargetsCount(); + java.util.List + getTargetsOrBuilderList(); + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getTargetsOrBuilder( + int index); + + // optional .DatanodeInfoProto source = 3; + boolean hasSource(); + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getSource(); + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getSourceOrBuilder(); + + // required .OpWriteBlockProto.BlockConstructionStage stage = 4; + boolean hasStage(); + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage getStage(); + + // required uint32 pipelineSize = 5; + boolean hasPipelineSize(); + int getPipelineSize(); + + // required uint64 minBytesRcvd = 6; + boolean hasMinBytesRcvd(); + long getMinBytesRcvd(); + + // required uint64 maxBytesRcvd = 7; + boolean hasMaxBytesRcvd(); + long getMaxBytesRcvd(); + + // required uint64 latestGenerationStamp = 8; + boolean hasLatestGenerationStamp(); + long getLatestGenerationStamp(); + + // required .ChecksumProto requestedChecksum = 9; + boolean hasRequestedChecksum(); + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto getRequestedChecksum(); + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProtoOrBuilder getRequestedChecksumOrBuilder(); + } + public static final class OpWriteBlockProto extends + com.google.protobuf.GeneratedMessage + implements OpWriteBlockProtoOrBuilder { + // Use OpWriteBlockProto.newBuilder() to construct. + private OpWriteBlockProto(Builder builder) { + super(builder); + } + private OpWriteBlockProto(boolean noInit) {} + + private static final OpWriteBlockProto defaultInstance; + public static OpWriteBlockProto getDefaultInstance() { + return defaultInstance; + } + + public OpWriteBlockProto getDefaultInstanceForType() { + return defaultInstance; + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_OpWriteBlockProto_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_OpWriteBlockProto_fieldAccessorTable; + } + + public enum BlockConstructionStage + implements com.google.protobuf.ProtocolMessageEnum { + PIPELINE_SETUP_APPEND(0, 0), + PIPELINE_SETUP_APPEND_RECOVERY(1, 1), + DATA_STREAMING(2, 2), + PIPELINE_SETUP_STREAMING_RECOVERY(3, 3), + PIPELINE_CLOSE(4, 4), + PIPELINE_CLOSE_RECOVERY(5, 5), + PIPELINE_SETUP_CREATE(6, 6), + TRANSFER_RBW(7, 7), + TRANSFER_FINALIZED(8, 8), + ; + + public static final int PIPELINE_SETUP_APPEND_VALUE = 0; + public static final int PIPELINE_SETUP_APPEND_RECOVERY_VALUE = 1; + public static final int DATA_STREAMING_VALUE = 2; + public static final int PIPELINE_SETUP_STREAMING_RECOVERY_VALUE = 3; + public static final int PIPELINE_CLOSE_VALUE = 4; + public static final int PIPELINE_CLOSE_RECOVERY_VALUE = 5; + public static final int PIPELINE_SETUP_CREATE_VALUE = 6; + public static final int TRANSFER_RBW_VALUE = 7; + public static final int TRANSFER_FINALIZED_VALUE = 8; + + + public final int getNumber() { return value; } + + public static BlockConstructionStage valueOf(int value) { + switch (value) { + case 0: return PIPELINE_SETUP_APPEND; + case 1: return PIPELINE_SETUP_APPEND_RECOVERY; + case 2: return DATA_STREAMING; + case 3: return PIPELINE_SETUP_STREAMING_RECOVERY; + case 4: return PIPELINE_CLOSE; + case 5: return PIPELINE_CLOSE_RECOVERY; + case 6: return PIPELINE_SETUP_CREATE; + case 7: return TRANSFER_RBW; + case 8: return TRANSFER_FINALIZED; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static com.google.protobuf.Internal.EnumLiteMap + internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public BlockConstructionStage findValueByNumber(int number) { + return BlockConstructionStage.valueOf(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(index); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.getDescriptor().getEnumTypes().get(0); + } + + private static final BlockConstructionStage[] VALUES = { + PIPELINE_SETUP_APPEND, PIPELINE_SETUP_APPEND_RECOVERY, DATA_STREAMING, PIPELINE_SETUP_STREAMING_RECOVERY, PIPELINE_CLOSE, PIPELINE_CLOSE_RECOVERY, PIPELINE_SETUP_CREATE, TRANSFER_RBW, TRANSFER_FINALIZED, + }; + + public static BlockConstructionStage valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int index; + private final int value; + + private BlockConstructionStage(int index, int value) { + this.index = index; + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:OpWriteBlockProto.BlockConstructionStage) + } + + private int bitField0_; + // required .ClientOperationHeaderProto header = 1; + public static final int HEADER_FIELD_NUMBER = 1; + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto header_; + public boolean hasHeader() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto getHeader() { + return header_; + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProtoOrBuilder getHeaderOrBuilder() { + return header_; + } + + // repeated .DatanodeInfoProto targets = 2; + public static final int TARGETS_FIELD_NUMBER = 2; + private java.util.List targets_; + public java.util.List getTargetsList() { + return targets_; + } + public java.util.List + getTargetsOrBuilderList() { + return targets_; + } + public int getTargetsCount() { + return targets_.size(); + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getTargets(int index) { + return targets_.get(index); + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getTargetsOrBuilder( + int index) { + return targets_.get(index); + } + + // optional .DatanodeInfoProto source = 3; + public static final int SOURCE_FIELD_NUMBER = 3; + private org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto source_; + public boolean hasSource() { + return ((bitField0_ & 0x00000002) == 0x00000002); + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getSource() { + return source_; + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getSourceOrBuilder() { + return source_; + } + + // required .OpWriteBlockProto.BlockConstructionStage stage = 4; + public static final int STAGE_FIELD_NUMBER = 4; + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage stage_; + public boolean hasStage() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage getStage() { + return stage_; + } + + // required uint32 pipelineSize = 5; + public static final int PIPELINESIZE_FIELD_NUMBER = 5; + private int pipelineSize_; + public boolean hasPipelineSize() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public int getPipelineSize() { + return pipelineSize_; + } + + // required uint64 minBytesRcvd = 6; + public static final int MINBYTESRCVD_FIELD_NUMBER = 6; + private long minBytesRcvd_; + public boolean hasMinBytesRcvd() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + public long getMinBytesRcvd() { + return minBytesRcvd_; + } + + // required uint64 maxBytesRcvd = 7; + public static final int MAXBYTESRCVD_FIELD_NUMBER = 7; + private long maxBytesRcvd_; + public boolean hasMaxBytesRcvd() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + public long getMaxBytesRcvd() { + return maxBytesRcvd_; + } + + // required uint64 latestGenerationStamp = 8; + public static final int LATESTGENERATIONSTAMP_FIELD_NUMBER = 8; + private long latestGenerationStamp_; + public boolean hasLatestGenerationStamp() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } + public long getLatestGenerationStamp() { + return latestGenerationStamp_; + } + + // required .ChecksumProto requestedChecksum = 9; + public static final int REQUESTEDCHECKSUM_FIELD_NUMBER = 9; + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto requestedChecksum_; + public boolean hasRequestedChecksum() { + return ((bitField0_ & 0x00000080) == 0x00000080); + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto getRequestedChecksum() { + return requestedChecksum_; + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProtoOrBuilder getRequestedChecksumOrBuilder() { + return requestedChecksum_; + } + + private void initFields() { + header_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.getDefaultInstance(); + targets_ = java.util.Collections.emptyList(); + source_ = org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.getDefaultInstance(); + stage_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage.PIPELINE_SETUP_APPEND; + pipelineSize_ = 0; + minBytesRcvd_ = 0L; + maxBytesRcvd_ = 0L; + latestGenerationStamp_ = 0L; + requestedChecksum_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized != -1) return isInitialized == 1; + + if (!hasHeader()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasStage()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasPipelineSize()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMinBytesRcvd()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMaxBytesRcvd()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasLatestGenerationStamp()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasRequestedChecksum()) { + memoizedIsInitialized = 0; + return false; + } + if (!getHeader().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getTargetsCount(); i++) { + if (!getTargets(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasSource()) { + if (!getSource().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (!getRequestedChecksum().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (((bitField0_ & 0x00000001) == 0x00000001)) { + output.writeMessage(1, header_); + } + for (int i = 0; i < targets_.size(); i++) { + output.writeMessage(2, targets_.get(i)); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + output.writeMessage(3, source_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + output.writeEnum(4, stage_.getNumber()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + output.writeUInt32(5, pipelineSize_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + output.writeUInt64(6, minBytesRcvd_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + output.writeUInt64(7, maxBytesRcvd_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + output.writeUInt64(8, latestGenerationStamp_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + output.writeMessage(9, requestedChecksum_); + } + getUnknownFields().writeTo(output); + } + + private int memoizedSerializedSize = -1; + public int getSerializedSize() { + int size = memoizedSerializedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, header_); + } + for (int i = 0; i < targets_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, targets_.get(i)); + } + if (((bitField0_ & 0x00000002) == 0x00000002)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, source_); + } + if (((bitField0_ & 0x00000004) == 0x00000004)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(4, stage_.getNumber()); + } + if (((bitField0_ & 0x00000008) == 0x00000008)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(5, pipelineSize_); + } + if (((bitField0_ & 0x00000010) == 0x00000010)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(6, minBytesRcvd_); + } + if (((bitField0_ & 0x00000020) == 0x00000020)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(7, maxBytesRcvd_); + } + if (((bitField0_ & 0x00000040) == 0x00000040)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(8, latestGenerationStamp_); + } + if (((bitField0_ & 0x00000080) == 0x00000080)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, requestedChecksum_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSerializedSize = size; + return size; + } + + private static final long serialVersionUID = 0L; + @java.lang.Override + protected java.lang.Object writeReplace() + throws java.io.ObjectStreamException { + return super.writeReplace(); + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto)) { + return super.equals(obj); + } + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto other = (org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto) obj; + + boolean result = true; + result = result && (hasHeader() == other.hasHeader()); + if (hasHeader()) { + result = result && getHeader() + .equals(other.getHeader()); + } + result = result && getTargetsList() + .equals(other.getTargetsList()); + result = result && (hasSource() == other.hasSource()); + if (hasSource()) { + result = result && getSource() + .equals(other.getSource()); + } + result = result && (hasStage() == other.hasStage()); + if (hasStage()) { + result = result && + (getStage() == other.getStage()); + } + result = result && (hasPipelineSize() == other.hasPipelineSize()); + if (hasPipelineSize()) { + result = result && (getPipelineSize() + == other.getPipelineSize()); + } + result = result && (hasMinBytesRcvd() == other.hasMinBytesRcvd()); + if (hasMinBytesRcvd()) { + result = result && (getMinBytesRcvd() + == other.getMinBytesRcvd()); + } + result = result && (hasMaxBytesRcvd() == other.hasMaxBytesRcvd()); + if (hasMaxBytesRcvd()) { + result = result && (getMaxBytesRcvd() + == other.getMaxBytesRcvd()); + } + result = result && (hasLatestGenerationStamp() == other.hasLatestGenerationStamp()); + if (hasLatestGenerationStamp()) { + result = result && (getLatestGenerationStamp() + == other.getLatestGenerationStamp()); + } + result = result && (hasRequestedChecksum() == other.hasRequestedChecksum()); + if (hasRequestedChecksum()) { + result = result && getRequestedChecksum() + .equals(other.getRequestedChecksum()); + } + result = result && + getUnknownFields().equals(other.getUnknownFields()); + return result; + } + + @java.lang.Override + public int hashCode() { + int hash = 41; + hash = (19 * hash) + getDescriptorForType().hashCode(); + if (hasHeader()) { + hash = (37 * hash) + HEADER_FIELD_NUMBER; + hash = (53 * hash) + getHeader().hashCode(); + } + if (getTargetsCount() > 0) { + hash = (37 * hash) + TARGETS_FIELD_NUMBER; + hash = (53 * hash) + getTargetsList().hashCode(); + } + if (hasSource()) { + hash = (37 * hash) + SOURCE_FIELD_NUMBER; + hash = (53 * hash) + getSource().hashCode(); + } + if (hasStage()) { + hash = (37 * hash) + STAGE_FIELD_NUMBER; + hash = (53 * hash) + hashEnum(getStage()); + } + if (hasPipelineSize()) { + hash = (37 * hash) + PIPELINESIZE_FIELD_NUMBER; + hash = (53 * hash) + getPipelineSize(); + } + if (hasMinBytesRcvd()) { + hash = (37 * hash) + MINBYTESRCVD_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getMinBytesRcvd()); + } + if (hasMaxBytesRcvd()) { + hash = (37 * hash) + MAXBYTESRCVD_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getMaxBytesRcvd()); + } + if (hasLatestGenerationStamp()) { + hash = (37 * hash) + LATESTGENERATIONSTAMP_FIELD_NUMBER; + hash = (53 * hash) + hashLong(getLatestGenerationStamp()); + } + if (hasRequestedChecksum()) { + hash = (37 * hash) + REQUESTEDCHECKSUM_FIELD_NUMBER; + hash = (53 * hash) + getRequestedChecksum().hashCode(); + } + hash = (29 * hash) + getUnknownFields().hashCode(); + return hash; + } + + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data).buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return newBuilder().mergeFrom(data, extensionRegistry) + .buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseFrom(java.io.InputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + Builder builder = newBuilder(); + if (builder.mergeDelimitedFrom(input, extensionRegistry)) { + return builder.buildParsed(); + } else { + return null; + } + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return newBuilder().mergeFrom(input).buildParsed(); + } + public static org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return newBuilder().mergeFrom(input, extensionRegistry) + .buildParsed(); + } + + public static Builder newBuilder() { return Builder.create(); } + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder(org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto prototype) { + return newBuilder().mergeFrom(prototype); + } + public Builder toBuilder() { return newBuilder(this); } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessage.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + public static final class Builder extends + com.google.protobuf.GeneratedMessage.Builder + implements org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProtoOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_OpWriteBlockProto_descriptor; + } + + protected com.google.protobuf.GeneratedMessage.FieldAccessorTable + internalGetFieldAccessorTable() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.internal_static_OpWriteBlockProto_fieldAccessorTable; + } + + // Construct using org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder(BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { + getHeaderFieldBuilder(); + getTargetsFieldBuilder(); + getSourceFieldBuilder(); + getRequestedChecksumFieldBuilder(); + } + } + private static Builder create() { + return new Builder(); + } + + public Builder clear() { + super.clear(); + if (headerBuilder_ == null) { + header_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.getDefaultInstance(); + } else { + headerBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + if (targetsBuilder_ == null) { + targets_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + targetsBuilder_.clear(); + } + if (sourceBuilder_ == null) { + source_ = org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.getDefaultInstance(); + } else { + sourceBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + stage_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage.PIPELINE_SETUP_APPEND; + bitField0_ = (bitField0_ & ~0x00000008); + pipelineSize_ = 0; + bitField0_ = (bitField0_ & ~0x00000010); + minBytesRcvd_ = 0L; + bitField0_ = (bitField0_ & ~0x00000020); + maxBytesRcvd_ = 0L; + bitField0_ = (bitField0_ & ~0x00000040); + latestGenerationStamp_ = 0L; + bitField0_ = (bitField0_ & ~0x00000080); + if (requestedChecksumBuilder_ == null) { + requestedChecksum_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.getDefaultInstance(); + } else { + requestedChecksumBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000100); + return this; + } + + public Builder clone() { + return create().mergeFrom(buildPartial()); + } + + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.getDescriptor(); + } + + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto getDefaultInstanceForType() { + return org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.getDefaultInstance(); + } + + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto build() { + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto buildParsed() + throws com.google.protobuf.InvalidProtocolBufferException { + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException( + result).asInvalidProtocolBufferException(); + } + return result; + } + + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto buildPartial() { + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto result = new org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) == 0x00000001)) { + to_bitField0_ |= 0x00000001; + } + if (headerBuilder_ == null) { + result.header_ = header_; + } else { + result.header_ = headerBuilder_.build(); + } + if (targetsBuilder_ == null) { + if (((bitField0_ & 0x00000002) == 0x00000002)) { + targets_ = java.util.Collections.unmodifiableList(targets_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.targets_ = targets_; + } else { + result.targets_ = targetsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000004) == 0x00000004)) { + to_bitField0_ |= 0x00000002; + } + if (sourceBuilder_ == null) { + result.source_ = source_; + } else { + result.source_ = sourceBuilder_.build(); + } + if (((from_bitField0_ & 0x00000008) == 0x00000008)) { + to_bitField0_ |= 0x00000004; + } + result.stage_ = stage_; + if (((from_bitField0_ & 0x00000010) == 0x00000010)) { + to_bitField0_ |= 0x00000008; + } + result.pipelineSize_ = pipelineSize_; + if (((from_bitField0_ & 0x00000020) == 0x00000020)) { + to_bitField0_ |= 0x00000010; + } + result.minBytesRcvd_ = minBytesRcvd_; + if (((from_bitField0_ & 0x00000040) == 0x00000040)) { + to_bitField0_ |= 0x00000020; + } + result.maxBytesRcvd_ = maxBytesRcvd_; + if (((from_bitField0_ & 0x00000080) == 0x00000080)) { + to_bitField0_ |= 0x00000040; + } + result.latestGenerationStamp_ = latestGenerationStamp_; + if (((from_bitField0_ & 0x00000100) == 0x00000100)) { + to_bitField0_ |= 0x00000080; + } + if (requestedChecksumBuilder_ == null) { + result.requestedChecksum_ = requestedChecksum_; + } else { + result.requestedChecksum_ = requestedChecksumBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto) { + return mergeFrom((org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto other) { + if (other == org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.getDefaultInstance()) return this; + if (other.hasHeader()) { + mergeHeader(other.getHeader()); + } + if (targetsBuilder_ == null) { + if (!other.targets_.isEmpty()) { + if (targets_.isEmpty()) { + targets_ = other.targets_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureTargetsIsMutable(); + targets_.addAll(other.targets_); + } + onChanged(); + } + } else { + if (!other.targets_.isEmpty()) { + if (targetsBuilder_.isEmpty()) { + targetsBuilder_.dispose(); + targetsBuilder_ = null; + targets_ = other.targets_; + bitField0_ = (bitField0_ & ~0x00000002); + targetsBuilder_ = + com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? + getTargetsFieldBuilder() : null; + } else { + targetsBuilder_.addAllMessages(other.targets_); + } + } + } + if (other.hasSource()) { + mergeSource(other.getSource()); + } + if (other.hasStage()) { + setStage(other.getStage()); + } + if (other.hasPipelineSize()) { + setPipelineSize(other.getPipelineSize()); + } + if (other.hasMinBytesRcvd()) { + setMinBytesRcvd(other.getMinBytesRcvd()); + } + if (other.hasMaxBytesRcvd()) { + setMaxBytesRcvd(other.getMaxBytesRcvd()); + } + if (other.hasLatestGenerationStamp()) { + setLatestGenerationStamp(other.getLatestGenerationStamp()); + } + if (other.hasRequestedChecksum()) { + mergeRequestedChecksum(other.getRequestedChecksum()); + } + this.mergeUnknownFields(other.getUnknownFields()); + return this; + } + + public final boolean isInitialized() { + if (!hasHeader()) { + + return false; + } + if (!hasStage()) { + + return false; + } + if (!hasPipelineSize()) { + + return false; + } + if (!hasMinBytesRcvd()) { + + return false; + } + if (!hasMaxBytesRcvd()) { + + return false; + } + if (!hasLatestGenerationStamp()) { + + return false; + } + if (!hasRequestedChecksum()) { + + return false; + } + if (!getHeader().isInitialized()) { + + return false; + } + for (int i = 0; i < getTargetsCount(); i++) { + if (!getTargets(i).isInitialized()) { + + return false; + } + } + if (hasSource()) { + if (!getSource().isInitialized()) { + + return false; + } + } + if (!getRequestedChecksum().isInitialized()) { + + return false; + } + return true; + } + + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder( + this.getUnknownFields()); + while (true) { + int tag = input.readTag(); + switch (tag) { + case 0: + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + default: { + if (!parseUnknownField(input, unknownFields, + extensionRegistry, tag)) { + this.setUnknownFields(unknownFields.build()); + onChanged(); + return this; + } + break; + } + case 10: { + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.Builder subBuilder = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.newBuilder(); + if (hasHeader()) { + subBuilder.mergeFrom(getHeader()); + } + input.readMessage(subBuilder, extensionRegistry); + setHeader(subBuilder.buildPartial()); + break; + } + case 18: { + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder subBuilder = org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.newBuilder(); + input.readMessage(subBuilder, extensionRegistry); + addTargets(subBuilder.buildPartial()); + break; + } + case 26: { + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder subBuilder = org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.newBuilder(); + if (hasSource()) { + subBuilder.mergeFrom(getSource()); + } + input.readMessage(subBuilder, extensionRegistry); + setSource(subBuilder.buildPartial()); + break; + } + case 32: { + int rawValue = input.readEnum(); + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage value = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(4, rawValue); + } else { + bitField0_ |= 0x00000008; + stage_ = value; + } + break; + } + case 40: { + bitField0_ |= 0x00000010; + pipelineSize_ = input.readUInt32(); + break; + } + case 48: { + bitField0_ |= 0x00000020; + minBytesRcvd_ = input.readUInt64(); + break; + } + case 56: { + bitField0_ |= 0x00000040; + maxBytesRcvd_ = input.readUInt64(); + break; + } + case 64: { + bitField0_ |= 0x00000080; + latestGenerationStamp_ = input.readUInt64(); + break; + } + case 74: { + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.Builder subBuilder = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ChecksumProto.newBuilder(); + if (hasRequestedChecksum()) { + subBuilder.mergeFrom(getRequestedChecksum()); + } + input.readMessage(subBuilder, extensionRegistry); + setRequestedChecksum(subBuilder.buildPartial()); + break; + } + } + } + } + + private int bitField0_; + + // required .ClientOperationHeaderProto header = 1; + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto header_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto, org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.Builder, org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProtoOrBuilder> headerBuilder_; + public boolean hasHeader() { + return ((bitField0_ & 0x00000001) == 0x00000001); + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto getHeader() { + if (headerBuilder_ == null) { + return header_; + } else { + return headerBuilder_.getMessage(); + } + } + public Builder setHeader(org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto value) { + if (headerBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + header_ = value; + onChanged(); + } else { + headerBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + public Builder setHeader( + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.Builder builderForValue) { + if (headerBuilder_ == null) { + header_ = builderForValue.build(); + onChanged(); + } else { + headerBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + public Builder mergeHeader(org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto value) { + if (headerBuilder_ == null) { + if (((bitField0_ & 0x00000001) == 0x00000001) && + header_ != org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.getDefaultInstance()) { + header_ = + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.newBuilder(header_).mergeFrom(value).buildPartial(); + } else { + header_ = value; + } + onChanged(); + } else { + headerBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + public Builder clearHeader() { + if (headerBuilder_ == null) { + header_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.getDefaultInstance(); + onChanged(); + } else { + headerBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.Builder getHeaderBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getHeaderFieldBuilder().getBuilder(); + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProtoOrBuilder getHeaderOrBuilder() { + if (headerBuilder_ != null) { + return headerBuilder_.getMessageOrBuilder(); + } else { + return header_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto, org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.Builder, org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProtoOrBuilder> + getHeaderFieldBuilder() { + if (headerBuilder_ == null) { + headerBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto, org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProto.Builder, org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.ClientOperationHeaderProtoOrBuilder>( + header_, + getParentForChildren(), + isClean()); + header_ = null; + } + return headerBuilder_; + } + + // repeated .DatanodeInfoProto targets = 2; + private java.util.List targets_ = + java.util.Collections.emptyList(); + private void ensureTargetsIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + targets_ = new java.util.ArrayList(targets_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder> targetsBuilder_; + + public java.util.List getTargetsList() { + if (targetsBuilder_ == null) { + return java.util.Collections.unmodifiableList(targets_); + } else { + return targetsBuilder_.getMessageList(); + } + } + public int getTargetsCount() { + if (targetsBuilder_ == null) { + return targets_.size(); + } else { + return targetsBuilder_.getCount(); + } + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getTargets(int index) { + if (targetsBuilder_ == null) { + return targets_.get(index); + } else { + return targetsBuilder_.getMessage(index); + } + } + public Builder setTargets( + int index, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto value) { + if (targetsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureTargetsIsMutable(); + targets_.set(index, value); + onChanged(); + } else { + targetsBuilder_.setMessage(index, value); + } + return this; + } + public Builder setTargets( + int index, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder builderForValue) { + if (targetsBuilder_ == null) { + ensureTargetsIsMutable(); + targets_.set(index, builderForValue.build()); + onChanged(); + } else { + targetsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + public Builder addTargets(org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto value) { + if (targetsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureTargetsIsMutable(); + targets_.add(value); + onChanged(); + } else { + targetsBuilder_.addMessage(value); + } + return this; + } + public Builder addTargets( + int index, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto value) { + if (targetsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureTargetsIsMutable(); + targets_.add(index, value); + onChanged(); + } else { + targetsBuilder_.addMessage(index, value); + } + return this; + } + public Builder addTargets( + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder builderForValue) { + if (targetsBuilder_ == null) { + ensureTargetsIsMutable(); + targets_.add(builderForValue.build()); + onChanged(); + } else { + targetsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + public Builder addTargets( + int index, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder builderForValue) { + if (targetsBuilder_ == null) { + ensureTargetsIsMutable(); + targets_.add(index, builderForValue.build()); + onChanged(); + } else { + targetsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + public Builder addAllTargets( + java.lang.Iterable values) { + if (targetsBuilder_ == null) { + ensureTargetsIsMutable(); + super.addAll(values, targets_); + onChanged(); + } else { + targetsBuilder_.addAllMessages(values); + } + return this; + } + public Builder clearTargets() { + if (targetsBuilder_ == null) { + targets_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + targetsBuilder_.clear(); + } + return this; + } + public Builder removeTargets(int index) { + if (targetsBuilder_ == null) { + ensureTargetsIsMutable(); + targets_.remove(index); + onChanged(); + } else { + targetsBuilder_.remove(index); + } + return this; + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder getTargetsBuilder( + int index) { + return getTargetsFieldBuilder().getBuilder(index); + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getTargetsOrBuilder( + int index) { + if (targetsBuilder_ == null) { + return targets_.get(index); } else { + return targetsBuilder_.getMessageOrBuilder(index); + } + } + public java.util.List + getTargetsOrBuilderList() { + if (targetsBuilder_ != null) { + return targetsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(targets_); + } + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder addTargetsBuilder() { + return getTargetsFieldBuilder().addBuilder( + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.getDefaultInstance()); + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder addTargetsBuilder( + int index) { + return getTargetsFieldBuilder().addBuilder( + index, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.getDefaultInstance()); + } + public java.util.List + getTargetsBuilderList() { + return getTargetsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder> + getTargetsFieldBuilder() { + if (targetsBuilder_ == null) { + targetsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder>( + targets_, + ((bitField0_ & 0x00000002) == 0x00000002), + getParentForChildren(), + isClean()); + targets_ = null; + } + return targetsBuilder_; + } + + // optional .DatanodeInfoProto source = 3; + private org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto source_ = org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.getDefaultInstance(); + private com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder> sourceBuilder_; + public boolean hasSource() { + return ((bitField0_ & 0x00000004) == 0x00000004); + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto getSource() { + if (sourceBuilder_ == null) { + return source_; + } else { + return sourceBuilder_.getMessage(); + } + } + public Builder setSource(org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto value) { + if (sourceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + source_ = value; + onChanged(); + } else { + sourceBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder setSource( + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder builderForValue) { + if (sourceBuilder_ == null) { + source_ = builderForValue.build(); + onChanged(); + } else { + sourceBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder mergeSource(org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto value) { + if (sourceBuilder_ == null) { + if (((bitField0_ & 0x00000004) == 0x00000004) && + source_ != org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.getDefaultInstance()) { + source_ = + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.newBuilder(source_).mergeFrom(value).buildPartial(); + } else { + source_ = value; + } + onChanged(); + } else { + sourceBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + public Builder clearSource() { + if (sourceBuilder_ == null) { + source_ = org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.getDefaultInstance(); + onChanged(); + } else { + sourceBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder getSourceBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getSourceFieldBuilder().getBuilder(); + } + public org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder getSourceOrBuilder() { + if (sourceBuilder_ != null) { + return sourceBuilder_.getMessageOrBuilder(); + } else { + return source_; + } + } + private com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder> + getSourceFieldBuilder() { + if (sourceBuilder_ == null) { + sourceBuilder_ = new com.google.protobuf.SingleFieldBuilder< + org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProto.Builder, org.apache.hadoop.hdfs.protocol.proto.HdfsProtos.DatanodeInfoProtoOrBuilder>( + source_, + getParentForChildren(), + isClean()); + source_ = null; + } + return sourceBuilder_; + } + + // required .OpWriteBlockProto.BlockConstructionStage stage = 4; + private org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage stage_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage.PIPELINE_SETUP_APPEND; + public boolean hasStage() { + return ((bitField0_ & 0x00000008) == 0x00000008); + } + public org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage getStage() { + return stage_; + } + public Builder setStage(org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + stage_ = value; + onChanged(); + return this; + } + public Builder clearStage() { + bitField0_ = (bitField0_ & ~0x00000008); + stage_ = org.apache.hadoop.hdfs.protocol.proto.DataTransferProtos.OpWriteBlockProto.BlockConstructionStage.PIPELINE_SETUP_APPEND; + onChanged(); + return this; + } + + // required uint32 pipelineSize = 5; + private int pipelineSize_ ; + public boolean hasPipelineSize() { + return ((bitField0_ & 0x00000010) == 0x00000010); + } + public int getPipelineSize() { + return pipelineSize_; + } + public Builder setPipelineSize(int value) { + bitField0_ |= 0x00000010; + pipelineSize_ = value; + onChanged(); + return this; + } + public Builder clearPipelineSize() { + bitField0_ = (bitField0_ & ~0x00000010); + pipelineSize_ = 0; + onChanged(); + return this; + } + + // required uint64 minBytesRcvd = 6; + private long minBytesRcvd_ ; + public boolean hasMinBytesRcvd() { + return ((bitField0_ & 0x00000020) == 0x00000020); + } + public long getMinBytesRcvd() { + return minBytesRcvd_; + } + public Builder setMinBytesRcvd(long value) { + bitField0_ |= 0x00000020; + minBytesRcvd_ = value; + onChanged(); + return this; + } + public Builder clearMinBytesRcvd() { + bitField0_ = (bitField0_ & ~0x00000020); + minBytesRcvd_ = 0L; + onChanged(); + return this; + } + + // required uint64 maxBytesRcvd = 7; + private long maxBytesRcvd_ ; + public boolean hasMaxBytesRcvd() { + return ((bitField0_ & 0x00000040) == 0x00000040); + } [... 5428 lines stripped ...]