From e06e2d1aa83ccaaa103ce1d7afbbfb27ec42c129 Mon Sep 17 00:00:00 2001 From: aoyu <1790306716@qq.com> Date: Mon, 27 Feb 2023 12:04:36 +0800 Subject: [PATCH] test[protocol]add performance test of specific object --- .../zfoo/protocol/field/FieldSpeedTest.java | 532 +- .../protocol/field/packet/BytesObject.java | 130 + .../field/packet/FieldProtobufObject.java | 11261 +++++++++++++++- .../protocol/field/packet/InnerObject.java | 30 + .../field/packet/InnerObjectObject.java | 120 + .../field/packet/ListIntegerObject.java | 121 + .../zfoo/protocol/field/packet/MapObject.java | 121 + .../zfoo/protocol/field/packet/SetObject.java | 121 + .../protocol/field/packet/StringObject.java | 111 + protocol/src/test/resources/fieldspeed.proto | 69 + 10 files changed, 12594 insertions(+), 22 deletions(-) create mode 100644 protocol/src/test/java/com/zfoo/protocol/field/packet/BytesObject.java create mode 100644 protocol/src/test/java/com/zfoo/protocol/field/packet/InnerObject.java create mode 100644 protocol/src/test/java/com/zfoo/protocol/field/packet/InnerObjectObject.java create mode 100644 protocol/src/test/java/com/zfoo/protocol/field/packet/ListIntegerObject.java create mode 100644 protocol/src/test/java/com/zfoo/protocol/field/packet/MapObject.java create mode 100644 protocol/src/test/java/com/zfoo/protocol/field/packet/SetObject.java create mode 100644 protocol/src/test/java/com/zfoo/protocol/field/packet/StringObject.java diff --git a/protocol/src/test/java/com/zfoo/protocol/field/FieldSpeedTest.java b/protocol/src/test/java/com/zfoo/protocol/field/FieldSpeedTest.java index ab5990d6..476e5057 100644 --- a/protocol/src/test/java/com/zfoo/protocol/field/FieldSpeedTest.java +++ b/protocol/src/test/java/com/zfoo/protocol/field/FieldSpeedTest.java @@ -3,13 +3,12 @@ package com.zfoo.protocol.field; import com.esotericsoftware.kryo.Kryo; import com.esotericsoftware.kryo.io.Input; import com.esotericsoftware.kryo.io.Output; +import com.google.protobuf.ByteString; import com.google.protobuf.CodedInputStream; import com.google.protobuf.CodedOutputStream; import com.zfoo.protocol.ProtocolManager; -import com.zfoo.protocol.field.packet.FieldProtobufObject; -import com.zfoo.protocol.field.packet.FloatObject; -import com.zfoo.protocol.field.packet.IntObject; -import com.zfoo.protocol.field.packet.IntegerObject; +import com.zfoo.protocol.collection.ArrayUtils; +import com.zfoo.protocol.field.packet.*; import com.zfoo.protocol.generate.GenerateOperation; import com.zfoo.protocol.util.StringUtils; import io.netty.buffer.ByteBuf; @@ -20,10 +19,7 @@ import org.junit.Ignore; import org.junit.Test; import java.io.IOException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Set; +import java.util.*; /** * 测试各种不同特征的数据类型的序列化和反序列化时间 @@ -35,14 +31,28 @@ public class FieldSpeedTest { public static IntObject intObject=new IntObject(); public static IntegerObject integerObject=new IntegerObject(); public static FloatObject floatObject=new FloatObject(); + public static BytesObject bytesObject=new BytesObject(); + public static StringObject stringObject=new StringObject(); + public static ListIntegerObject listIntegerObject=new ListIntegerObject(); + public static SetObject setObject=new SetObject(); + public static MapObject mapObject=new MapObject(); + public static InnerObjectObject innerObjectObject=new InnerObjectObject(); public static FieldProtobufObject.IntObject protobufIntObject = null; public static FieldProtobufObject.FloatObject protobufFloatObject = null; + public static FieldProtobufObject.BytesObject protobufBytesObject = null; + public static FieldProtobufObject.StringObject protobufStringObject = null; + public static FieldProtobufObject.ListIntegerObject protobufListIntegerObject=null; + public static FieldProtobufObject.MapObject protobufMapObject=null; + public static FieldProtobufObject.InnerObjectObject protobufInnerObjectObject=null; public static long zfooSerializationTime; public static long zfooDeserializationTime; public static long kryoSerializationTime; public static long kryoDeserializationTime; public static long protobufSerializationTime; public static long protobufDeserializationTime; + public static long zfooSerializationSize; + public static long kryoSerializationSize; + public static long protobufSerializationSize; @Test public void testIntObject() throws IOException { ByteBuf buffer = new UnpooledHeapByteBuf(ByteBufAllocator.DEFAULT, 10000_0000, 100000000); @@ -53,6 +63,7 @@ public class FieldSpeedTest { ProtocolManager.write(buffer,intObject); } zfooSerializationTime=System.currentTimeMillis() - startTime; + zfooSerializationSize=buffer.writerIndex(); startTime = System.currentTimeMillis(); for(int i=0;i listValue=new ArrayList<>(ArrayUtils.toList(new int[]{Integer.MIN_VALUE,-10000000,-100000,-1000,-10,0,10,1000,100000,10000000,Integer.MAX_VALUE})); + public static final Set setValue=new HashSet<>(listValue); + public static final Map mapValue=new HashMap<>(Map.of(Integer.MIN_VALUE,"a",-10000000,"ab",-100000,"abc",-1000,"abcd",-10,"abcde", + 0,"abcdef",10,"abcdefg",1000,"abcdefgh",100000,"abcdefghi",Integer.MAX_VALUE,"abcdefghij")); + public static final InnerObject innerObjectValue=new InnerObject(); @BeforeClass public static void prepare() { intObject.setA(intAValue); @@ -294,11 +703,89 @@ public class FieldSpeedTest { protobufFloatObject=FieldProtobufObject.FloatObject.newBuilder().setA(floatAValue).setB(floatBValue).setC(floatCValue) .setD(floatDValue).setE(floatEValue).setF(floatFValue).setG(floatGValue).setH(floatHValue).setI(floatIValue).setJ(floatJValue).build(); + bytesObject.setA(bytesValue); + bytesObject.setB(bytesValue); + bytesObject.setC(bytesValue); + bytesObject.setD(bytesValue); + bytesObject.setE(bytesValue); + bytesObject.setF(bytesValue); + bytesObject.setG(bytesValue); + bytesObject.setH(bytesValue); + bytesObject.setI(bytesValue); + bytesObject.setJ(bytesValue); + protobufBytesObject=FieldProtobufObject.BytesObject.newBuilder().setA(ByteString.copyFrom(bytesValue)).setB(ByteString.copyFrom(bytesValue)).setC(ByteString.copyFrom(bytesValue)) + .setD(ByteString.copyFrom(bytesValue)).setE(ByteString.copyFrom(bytesValue)).setF(ByteString.copyFrom(bytesValue)).setG(ByteString.copyFrom(bytesValue)).setH(ByteString.copyFrom(bytesValue)).setI(ByteString.copyFrom(bytesValue)).setJ(ByteString.copyFrom(bytesValue)).build(); + + stringObject.setA(stringAValue); + stringObject.setB(stringBValue); + stringObject.setC(stringCValue); + stringObject.setD(stringDValue); + stringObject.setE(stringEValue); + stringObject.setF(stringFValue); + stringObject.setG(stringGValue); + stringObject.setH(stringHValue); + stringObject.setI(stringIValue); + stringObject.setJ(stringJValue); + protobufStringObject=FieldProtobufObject.StringObject.newBuilder().setA(stringAValue).setB(stringBValue).setC(stringCValue) + .setD(stringDValue).setE(stringEValue).setF(stringFValue).setG(stringGValue).setH(stringHValue).setI(stringIValue).setJ(stringJValue).build(); + + listIntegerObject.setA(listValue); + listIntegerObject.setB(listValue); + listIntegerObject.setC(listValue); + listIntegerObject.setD(listValue); + listIntegerObject.setE(listValue); + listIntegerObject.setF(listValue); + listIntegerObject.setG(listValue); + listIntegerObject.setH(listValue); + listIntegerObject.setI(listValue); + listIntegerObject.setJ(listValue); + protobufListIntegerObject=FieldProtobufObject.ListIntegerObject.newBuilder().addAllA(listValue).addAllB(listValue).addAllC(listValue) + .addAllD(listValue).addAllE(listValue).addAllF(listValue).addAllG(listValue).addAllH(listValue).addAllI(listValue).addAllJ(listValue).build(); + + setObject.setA(setValue); + setObject.setB(setValue); + setObject.setC(setValue); + setObject.setD(setValue); + setObject.setE(setValue); + setObject.setF(setValue); + setObject.setG(setValue); + setObject.setH(setValue); + setObject.setI(setValue); + setObject.setJ(setValue); + + mapObject.setA(mapValue); + mapObject.setB(mapValue); + mapObject.setC(mapValue); + mapObject.setD(mapValue); + mapObject.setE(mapValue); + mapObject.setF(mapValue); + mapObject.setG(mapValue); + mapObject.setH(mapValue); + mapObject.setI(mapValue); + mapObject.setJ(mapValue); + protobufMapObject=FieldProtobufObject.MapObject.newBuilder().putAllA(mapValue).putAllB(mapValue).putAllC(mapValue) + .putAllD(mapValue).putAllE(mapValue).putAllF(mapValue).putAllG(mapValue).putAllH(mapValue).putAllI(mapValue).putAllJ(mapValue).build(); + + innerObjectValue.setX(10000); + innerObjectObject.setA(innerObjectValue); + innerObjectObject.setB(innerObjectValue); + innerObjectObject.setC(innerObjectValue); + innerObjectObject.setD(innerObjectValue); + innerObjectObject.setE(innerObjectValue); + innerObjectObject.setF(innerObjectValue); + innerObjectObject.setG(innerObjectValue); + innerObjectObject.setH(innerObjectValue); + innerObjectObject.setI(innerObjectValue); + innerObjectObject.setJ(innerObjectValue); + + var protobufInnerObject=FieldProtobufObject.InnerObject.newBuilder().setX(intXValue).build(); + protobufInnerObjectObject=FieldProtobufObject.InnerObjectObject.newBuilder().setA(protobufInnerObject).setB(protobufInnerObject).setC(protobufInnerObject) + .setD(protobufInnerObject).setE(protobufInnerObject).setF(protobufInnerObject).setG(protobufInnerObject).setH(protobufInnerObject).setI(protobufInnerObject).setJ(protobufInnerObject).build(); // zfoo ----------------------------------------------------------------------- System.setProperty("io.netty.buffer.checkAccessible", "false"); System.setProperty("io.netty.buffer.checkBounds", "false"); var op = GenerateOperation.NO_OPERATION; - ProtocolManager.initProtocolAuto(Set.of(IntObject.class,IntegerObject.class,FloatObject.class), op); + ProtocolManager.initProtocolAuto(Set.of(IntObject.class,IntegerObject.class,FloatObject.class,BytesObject.class,StringObject.class,ListIntegerObject.class,SetObject.class,MapObject.class,InnerObjectObject.class), op); } public static final ThreadLocal kryos = new ThreadLocal<>() { @@ -308,6 +795,13 @@ public class FieldSpeedTest { kryo.register(IntObject.class); kryo.register(IntegerObject.class); kryo.register(FloatObject.class); + kryo.register(BytesObject.class); + kryo.register(StringObject.class); + kryo.register(ListIntegerObject.class); + kryo.register(SetObject.class); + kryo.register(MapObject.class); + kryo.register(InnerObject.class); + kryo.register(InnerObjectObject.class); kryo.register(byte[].class); kryo.register(Byte[].class); kryo.register(short[].class); diff --git a/protocol/src/test/java/com/zfoo/protocol/field/packet/BytesObject.java b/protocol/src/test/java/com/zfoo/protocol/field/packet/BytesObject.java new file mode 100644 index 00000000..1d2cf03f --- /dev/null +++ b/protocol/src/test/java/com/zfoo/protocol/field/packet/BytesObject.java @@ -0,0 +1,130 @@ +package com.zfoo.protocol.field.packet; + +import com.zfoo.protocol.IPacket; + +import java.util.Arrays; + +public class BytesObject implements IPacket { + private byte[] a; + + private byte[] b; + + private byte[] c; + + private byte[] d; + + private byte[] e; + + private byte[] f; + + private byte[] g; + + private byte[] h; + + private byte[] i; + + private byte[] j; + + public byte[] getA() { + return a; + } + + public void setA(byte[] a) { + this.a = a; + } + + public byte[] getB() { + return b; + } + + public void setB(byte[] b) { + this.b = b; + } + + public byte[] getC() { + return c; + } + + public void setC(byte[] c) { + this.c = c; + } + + public byte[] getD() { + return d; + } + + public void setD(byte[] d) { + this.d = d; + } + + public byte[] getE() { + return e; + } + + public void setE(byte[] e) { + this.e = e; + } + + public byte[] getF() { + return f; + } + + public void setF(byte[] f) { + this.f = f; + } + + public byte[] getG() { + return g; + } + + public void setG(byte[] g) { + this.g = g; + } + + public byte[] getH() { + return h; + } + + public void setH(byte[] h) { + this.h = h; + } + + public byte[] getI() { + return i; + } + + public void setI(byte[] i) { + this.i = i; + } + + public byte[] getJ() { + return j; + } + + public void setJ(byte[] j) { + this.j = j; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + BytesObject that = (BytesObject) o; + return Arrays.equals(a, that.a) && Arrays.equals(b, that.b) && Arrays.equals(c, that.c) && Arrays.equals(d, that.d) && Arrays.equals(e, that.e) && Arrays.equals(f, that.f) && Arrays.equals(g, that.g) && Arrays.equals(h, that.h) && Arrays.equals(i, that.i) && Arrays.equals(j, that.j); + } + + @Override + public int hashCode() { + int result = Arrays.hashCode(a); + result = 31 * result + Arrays.hashCode(b); + result = 31 * result + Arrays.hashCode(c); + result = 31 * result + Arrays.hashCode(d); + result = 31 * result + Arrays.hashCode(e); + result = 31 * result + Arrays.hashCode(f); + result = 31 * result + Arrays.hashCode(g); + result = 31 * result + Arrays.hashCode(h); + result = 31 * result + Arrays.hashCode(i); + result = 31 * result + Arrays.hashCode(j); + return result; + } +} diff --git a/protocol/src/test/java/com/zfoo/protocol/field/packet/FieldProtobufObject.java b/protocol/src/test/java/com/zfoo/protocol/field/packet/FieldProtobufObject.java index 8000f47d..47f76990 100644 --- a/protocol/src/test/java/com/zfoo/protocol/field/packet/FieldProtobufObject.java +++ b/protocol/src/test/java/com/zfoo/protocol/field/packet/FieldProtobufObject.java @@ -2130,6 +2130,11050 @@ public final class FieldProtobufObject { } + public interface BytesObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:BytesObject) + com.google.protobuf.MessageOrBuilder { + + /** + * bytes a = 1; + */ + com.google.protobuf.ByteString getA(); + + /** + * bytes b = 2; + */ + com.google.protobuf.ByteString getB(); + + /** + * bytes c = 3; + */ + com.google.protobuf.ByteString getC(); + + /** + * bytes d = 4; + */ + com.google.protobuf.ByteString getD(); + + /** + * bytes e = 5; + */ + com.google.protobuf.ByteString getE(); + + /** + * bytes f = 6; + */ + com.google.protobuf.ByteString getF(); + + /** + * bytes g = 7; + */ + com.google.protobuf.ByteString getG(); + + /** + * bytes h = 8; + */ + com.google.protobuf.ByteString getH(); + + /** + * bytes i = 9; + */ + com.google.protobuf.ByteString getI(); + + /** + * bytes j = 10; + */ + com.google.protobuf.ByteString getJ(); + } + /** + * Protobuf type {@code BytesObject} + */ + public static final class BytesObject extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:BytesObject) + BytesObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use BytesObject.newBuilder() to construct. + private BytesObject(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private BytesObject() { + a_ = com.google.protobuf.ByteString.EMPTY; + b_ = com.google.protobuf.ByteString.EMPTY; + c_ = com.google.protobuf.ByteString.EMPTY; + d_ = com.google.protobuf.ByteString.EMPTY; + e_ = com.google.protobuf.ByteString.EMPTY; + f_ = com.google.protobuf.ByteString.EMPTY; + g_ = com.google.protobuf.ByteString.EMPTY; + h_ = com.google.protobuf.ByteString.EMPTY; + i_ = com.google.protobuf.ByteString.EMPTY; + j_ = com.google.protobuf.ByteString.EMPTY; + } + + @Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private BytesObject( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + + a_ = input.readBytes(); + break; + } + case 18: { + + b_ = input.readBytes(); + break; + } + case 26: { + + c_ = input.readBytes(); + break; + } + case 34: { + + d_ = input.readBytes(); + break; + } + case 42: { + + e_ = input.readBytes(); + break; + } + case 50: { + + f_ = input.readBytes(); + break; + } + case 58: { + + g_ = input.readBytes(); + break; + } + case 66: { + + h_ = input.readBytes(); + break; + } + case 74: { + + i_ = input.readBytes(); + break; + } + case 82: { + + j_ = input.readBytes(); + break; + } + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_BytesObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_BytesObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + BytesObject.class, Builder.class); + } + + public static final int A_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString a_; + /** + * bytes a = 1; + */ + public com.google.protobuf.ByteString getA() { + return a_; + } + + public static final int B_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString b_; + /** + * bytes b = 2; + */ + public com.google.protobuf.ByteString getB() { + return b_; + } + + public static final int C_FIELD_NUMBER = 3; + private com.google.protobuf.ByteString c_; + /** + * bytes c = 3; + */ + public com.google.protobuf.ByteString getC() { + return c_; + } + + public static final int D_FIELD_NUMBER = 4; + private com.google.protobuf.ByteString d_; + /** + * bytes d = 4; + */ + public com.google.protobuf.ByteString getD() { + return d_; + } + + public static final int E_FIELD_NUMBER = 5; + private com.google.protobuf.ByteString e_; + /** + * bytes e = 5; + */ + public com.google.protobuf.ByteString getE() { + return e_; + } + + public static final int F_FIELD_NUMBER = 6; + private com.google.protobuf.ByteString f_; + /** + * bytes f = 6; + */ + public com.google.protobuf.ByteString getF() { + return f_; + } + + public static final int G_FIELD_NUMBER = 7; + private com.google.protobuf.ByteString g_; + /** + * bytes g = 7; + */ + public com.google.protobuf.ByteString getG() { + return g_; + } + + public static final int H_FIELD_NUMBER = 8; + private com.google.protobuf.ByteString h_; + /** + * bytes h = 8; + */ + public com.google.protobuf.ByteString getH() { + return h_; + } + + public static final int I_FIELD_NUMBER = 9; + private com.google.protobuf.ByteString i_; + /** + * bytes i = 9; + */ + public com.google.protobuf.ByteString getI() { + return i_; + } + + public static final int J_FIELD_NUMBER = 10; + private com.google.protobuf.ByteString j_; + /** + * bytes j = 10; + */ + public com.google.protobuf.ByteString getJ() { + return j_; + } + + private byte memoizedIsInitialized = -1; + @Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!a_.isEmpty()) { + output.writeBytes(1, a_); + } + if (!b_.isEmpty()) { + output.writeBytes(2, b_); + } + if (!c_.isEmpty()) { + output.writeBytes(3, c_); + } + if (!d_.isEmpty()) { + output.writeBytes(4, d_); + } + if (!e_.isEmpty()) { + output.writeBytes(5, e_); + } + if (!f_.isEmpty()) { + output.writeBytes(6, f_); + } + if (!g_.isEmpty()) { + output.writeBytes(7, g_); + } + if (!h_.isEmpty()) { + output.writeBytes(8, h_); + } + if (!i_.isEmpty()) { + output.writeBytes(9, i_); + } + if (!j_.isEmpty()) { + output.writeBytes(10, j_); + } + unknownFields.writeTo(output); + } + + @Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!a_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, a_); + } + if (!b_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, b_); + } + if (!c_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, c_); + } + if (!d_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(4, d_); + } + if (!e_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(5, e_); + } + if (!f_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(6, f_); + } + if (!g_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(7, g_); + } + if (!h_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(8, h_); + } + if (!i_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(9, i_); + } + if (!j_.isEmpty()) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(10, j_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof BytesObject)) { + return super.equals(obj); + } + BytesObject other = (BytesObject) obj; + + boolean result = true; + result = result && getA() + .equals(other.getA()); + result = result && getB() + .equals(other.getB()); + result = result && getC() + .equals(other.getC()); + result = result && getD() + .equals(other.getD()); + result = result && getE() + .equals(other.getE()); + result = result && getF() + .equals(other.getF()); + result = result && getG() + .equals(other.getG()); + result = result && getH() + .equals(other.getH()); + result = result && getI() + .equals(other.getI()); + result = result && getJ() + .equals(other.getJ()); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + A_FIELD_NUMBER; + hash = (53 * hash) + getA().hashCode(); + hash = (37 * hash) + B_FIELD_NUMBER; + hash = (53 * hash) + getB().hashCode(); + hash = (37 * hash) + C_FIELD_NUMBER; + hash = (53 * hash) + getC().hashCode(); + hash = (37 * hash) + D_FIELD_NUMBER; + hash = (53 * hash) + getD().hashCode(); + hash = (37 * hash) + E_FIELD_NUMBER; + hash = (53 * hash) + getE().hashCode(); + hash = (37 * hash) + F_FIELD_NUMBER; + hash = (53 * hash) + getF().hashCode(); + hash = (37 * hash) + G_FIELD_NUMBER; + hash = (53 * hash) + getG().hashCode(); + hash = (37 * hash) + H_FIELD_NUMBER; + hash = (53 * hash) + getH().hashCode(); + hash = (37 * hash) + I_FIELD_NUMBER; + hash = (53 * hash) + getI().hashCode(); + hash = (37 * hash) + J_FIELD_NUMBER; + hash = (53 * hash) + getJ().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static BytesObject parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static BytesObject parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static BytesObject parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static BytesObject parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static BytesObject parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static BytesObject parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static BytesObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static BytesObject parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static BytesObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static BytesObject parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static BytesObject parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static BytesObject parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(BytesObject prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @Override + protected Builder newBuilderForType( + BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code BytesObject} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:BytesObject) + BytesObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_BytesObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_BytesObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + BytesObject.class, Builder.class); + } + + // Construct using com.zfoo.protocol.field.packet.FieldProtobufObject.BytesObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @Override + public Builder clear() { + super.clear(); + a_ = com.google.protobuf.ByteString.EMPTY; + + b_ = com.google.protobuf.ByteString.EMPTY; + + c_ = com.google.protobuf.ByteString.EMPTY; + + d_ = com.google.protobuf.ByteString.EMPTY; + + e_ = com.google.protobuf.ByteString.EMPTY; + + f_ = com.google.protobuf.ByteString.EMPTY; + + g_ = com.google.protobuf.ByteString.EMPTY; + + h_ = com.google.protobuf.ByteString.EMPTY; + + i_ = com.google.protobuf.ByteString.EMPTY; + + j_ = com.google.protobuf.ByteString.EMPTY; + + return this; + } + + @Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return FieldProtobufObject.internal_static_BytesObject_descriptor; + } + + @Override + public BytesObject getDefaultInstanceForType() { + return BytesObject.getDefaultInstance(); + } + + @Override + public BytesObject build() { + BytesObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @Override + public BytesObject buildPartial() { + BytesObject result = new BytesObject(this); + result.a_ = a_; + result.b_ = b_; + result.c_ = c_; + result.d_ = d_; + result.e_ = e_; + result.f_ = f_; + result.g_ = g_; + result.h_ = h_; + result.i_ = i_; + result.j_ = j_; + onBuilt(); + return result; + } + + @Override + public Builder clone() { + return (Builder) super.clone(); + } + @Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + @Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + @Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + @Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + @Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + @Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof BytesObject) { + return mergeFrom((BytesObject)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(BytesObject other) { + if (other == BytesObject.getDefaultInstance()) return this; + if (other.getA() != com.google.protobuf.ByteString.EMPTY) { + setA(other.getA()); + } + if (other.getB() != com.google.protobuf.ByteString.EMPTY) { + setB(other.getB()); + } + if (other.getC() != com.google.protobuf.ByteString.EMPTY) { + setC(other.getC()); + } + if (other.getD() != com.google.protobuf.ByteString.EMPTY) { + setD(other.getD()); + } + if (other.getE() != com.google.protobuf.ByteString.EMPTY) { + setE(other.getE()); + } + if (other.getF() != com.google.protobuf.ByteString.EMPTY) { + setF(other.getF()); + } + if (other.getG() != com.google.protobuf.ByteString.EMPTY) { + setG(other.getG()); + } + if (other.getH() != com.google.protobuf.ByteString.EMPTY) { + setH(other.getH()); + } + if (other.getI() != com.google.protobuf.ByteString.EMPTY) { + setI(other.getI()); + } + if (other.getJ() != com.google.protobuf.ByteString.EMPTY) { + setJ(other.getJ()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @Override + public final boolean isInitialized() { + return true; + } + + @Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + BytesObject parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (BytesObject) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private com.google.protobuf.ByteString a_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes a = 1; + */ + public com.google.protobuf.ByteString getA() { + return a_; + } + /** + * bytes a = 1; + */ + public Builder setA(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + a_ = value; + onChanged(); + return this; + } + /** + * bytes a = 1; + */ + public Builder clearA() { + + a_ = getDefaultInstance().getA(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString b_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes b = 2; + */ + public com.google.protobuf.ByteString getB() { + return b_; + } + /** + * bytes b = 2; + */ + public Builder setB(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + b_ = value; + onChanged(); + return this; + } + /** + * bytes b = 2; + */ + public Builder clearB() { + + b_ = getDefaultInstance().getB(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString c_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes c = 3; + */ + public com.google.protobuf.ByteString getC() { + return c_; + } + /** + * bytes c = 3; + */ + public Builder setC(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + c_ = value; + onChanged(); + return this; + } + /** + * bytes c = 3; + */ + public Builder clearC() { + + c_ = getDefaultInstance().getC(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString d_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes d = 4; + */ + public com.google.protobuf.ByteString getD() { + return d_; + } + /** + * bytes d = 4; + */ + public Builder setD(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + d_ = value; + onChanged(); + return this; + } + /** + * bytes d = 4; + */ + public Builder clearD() { + + d_ = getDefaultInstance().getD(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString e_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes e = 5; + */ + public com.google.protobuf.ByteString getE() { + return e_; + } + /** + * bytes e = 5; + */ + public Builder setE(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + e_ = value; + onChanged(); + return this; + } + /** + * bytes e = 5; + */ + public Builder clearE() { + + e_ = getDefaultInstance().getE(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString f_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes f = 6; + */ + public com.google.protobuf.ByteString getF() { + return f_; + } + /** + * bytes f = 6; + */ + public Builder setF(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + f_ = value; + onChanged(); + return this; + } + /** + * bytes f = 6; + */ + public Builder clearF() { + + f_ = getDefaultInstance().getF(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString g_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes g = 7; + */ + public com.google.protobuf.ByteString getG() { + return g_; + } + /** + * bytes g = 7; + */ + public Builder setG(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + g_ = value; + onChanged(); + return this; + } + /** + * bytes g = 7; + */ + public Builder clearG() { + + g_ = getDefaultInstance().getG(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString h_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes h = 8; + */ + public com.google.protobuf.ByteString getH() { + return h_; + } + /** + * bytes h = 8; + */ + public Builder setH(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + h_ = value; + onChanged(); + return this; + } + /** + * bytes h = 8; + */ + public Builder clearH() { + + h_ = getDefaultInstance().getH(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString i_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes i = 9; + */ + public com.google.protobuf.ByteString getI() { + return i_; + } + /** + * bytes i = 9; + */ + public Builder setI(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + i_ = value; + onChanged(); + return this; + } + /** + * bytes i = 9; + */ + public Builder clearI() { + + i_ = getDefaultInstance().getI(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString j_ = com.google.protobuf.ByteString.EMPTY; + /** + * bytes j = 10; + */ + public com.google.protobuf.ByteString getJ() { + return j_; + } + /** + * bytes j = 10; + */ + public Builder setJ(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + + j_ = value; + onChanged(); + return this; + } + /** + * bytes j = 10; + */ + public Builder clearJ() { + + j_ = getDefaultInstance().getJ(); + onChanged(); + return this; + } + @Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + @Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:BytesObject) + } + + // @@protoc_insertion_point(class_scope:BytesObject) + private static final BytesObject DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new BytesObject(); + } + + public static BytesObject getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @Override + public BytesObject parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new BytesObject(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @Override + public BytesObject getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface StringObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:StringObject) + com.google.protobuf.MessageOrBuilder { + + /** + * string a = 1; + */ + String getA(); + /** + * string a = 1; + */ + com.google.protobuf.ByteString + getABytes(); + + /** + * string b = 2; + */ + String getB(); + /** + * string b = 2; + */ + com.google.protobuf.ByteString + getBBytes(); + + /** + * string c = 3; + */ + String getC(); + /** + * string c = 3; + */ + com.google.protobuf.ByteString + getCBytes(); + + /** + * string d = 4; + */ + String getD(); + /** + * string d = 4; + */ + com.google.protobuf.ByteString + getDBytes(); + + /** + * string e = 5; + */ + String getE(); + /** + * string e = 5; + */ + com.google.protobuf.ByteString + getEBytes(); + + /** + * string f = 6; + */ + String getF(); + /** + * string f = 6; + */ + com.google.protobuf.ByteString + getFBytes(); + + /** + * string g = 7; + */ + String getG(); + /** + * string g = 7; + */ + com.google.protobuf.ByteString + getGBytes(); + + /** + * string h = 8; + */ + String getH(); + /** + * string h = 8; + */ + com.google.protobuf.ByteString + getHBytes(); + + /** + * string i = 9; + */ + String getI(); + /** + * string i = 9; + */ + com.google.protobuf.ByteString + getIBytes(); + + /** + * string j = 10; + */ + String getJ(); + /** + * string j = 10; + */ + com.google.protobuf.ByteString + getJBytes(); + } + /** + * Protobuf type {@code StringObject} + */ + public static final class StringObject extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:StringObject) + StringObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use StringObject.newBuilder() to construct. + private StringObject(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private StringObject() { + a_ = ""; + b_ = ""; + c_ = ""; + d_ = ""; + e_ = ""; + f_ = ""; + g_ = ""; + h_ = ""; + i_ = ""; + j_ = ""; + } + + @Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private StringObject( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + String s = input.readStringRequireUtf8(); + + a_ = s; + break; + } + case 18: { + String s = input.readStringRequireUtf8(); + + b_ = s; + break; + } + case 26: { + String s = input.readStringRequireUtf8(); + + c_ = s; + break; + } + case 34: { + String s = input.readStringRequireUtf8(); + + d_ = s; + break; + } + case 42: { + String s = input.readStringRequireUtf8(); + + e_ = s; + break; + } + case 50: { + String s = input.readStringRequireUtf8(); + + f_ = s; + break; + } + case 58: { + String s = input.readStringRequireUtf8(); + + g_ = s; + break; + } + case 66: { + String s = input.readStringRequireUtf8(); + + h_ = s; + break; + } + case 74: { + String s = input.readStringRequireUtf8(); + + i_ = s; + break; + } + case 82: { + String s = input.readStringRequireUtf8(); + + j_ = s; + break; + } + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_StringObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_StringObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + StringObject.class, Builder.class); + } + + public static final int A_FIELD_NUMBER = 1; + private volatile Object a_; + /** + * string a = 1; + */ + public String getA() { + Object ref = a_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + a_ = s; + return s; + } + } + /** + * string a = 1; + */ + public com.google.protobuf.ByteString + getABytes() { + Object ref = a_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + a_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int B_FIELD_NUMBER = 2; + private volatile Object b_; + /** + * string b = 2; + */ + public String getB() { + Object ref = b_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + b_ = s; + return s; + } + } + /** + * string b = 2; + */ + public com.google.protobuf.ByteString + getBBytes() { + Object ref = b_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + b_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int C_FIELD_NUMBER = 3; + private volatile Object c_; + /** + * string c = 3; + */ + public String getC() { + Object ref = c_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + c_ = s; + return s; + } + } + /** + * string c = 3; + */ + public com.google.protobuf.ByteString + getCBytes() { + Object ref = c_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + c_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int D_FIELD_NUMBER = 4; + private volatile Object d_; + /** + * string d = 4; + */ + public String getD() { + Object ref = d_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + d_ = s; + return s; + } + } + /** + * string d = 4; + */ + public com.google.protobuf.ByteString + getDBytes() { + Object ref = d_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + d_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int E_FIELD_NUMBER = 5; + private volatile Object e_; + /** + * string e = 5; + */ + public String getE() { + Object ref = e_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + e_ = s; + return s; + } + } + /** + * string e = 5; + */ + public com.google.protobuf.ByteString + getEBytes() { + Object ref = e_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + e_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int F_FIELD_NUMBER = 6; + private volatile Object f_; + /** + * string f = 6; + */ + public String getF() { + Object ref = f_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + f_ = s; + return s; + } + } + /** + * string f = 6; + */ + public com.google.protobuf.ByteString + getFBytes() { + Object ref = f_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + f_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int G_FIELD_NUMBER = 7; + private volatile Object g_; + /** + * string g = 7; + */ + public String getG() { + Object ref = g_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + g_ = s; + return s; + } + } + /** + * string g = 7; + */ + public com.google.protobuf.ByteString + getGBytes() { + Object ref = g_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + g_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int H_FIELD_NUMBER = 8; + private volatile Object h_; + /** + * string h = 8; + */ + public String getH() { + Object ref = h_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + h_ = s; + return s; + } + } + /** + * string h = 8; + */ + public com.google.protobuf.ByteString + getHBytes() { + Object ref = h_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + h_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int I_FIELD_NUMBER = 9; + private volatile Object i_; + /** + * string i = 9; + */ + public String getI() { + Object ref = i_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + i_ = s; + return s; + } + } + /** + * string i = 9; + */ + public com.google.protobuf.ByteString + getIBytes() { + Object ref = i_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + i_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int J_FIELD_NUMBER = 10; + private volatile Object j_; + /** + * string j = 10; + */ + public String getJ() { + Object ref = j_; + if (ref instanceof String) { + return (String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + j_ = s; + return s; + } + } + /** + * string j = 10; + */ + public com.google.protobuf.ByteString + getJBytes() { + Object ref = j_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + j_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!getABytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, a_); + } + if (!getBBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, b_); + } + if (!getCBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, c_); + } + if (!getDBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, d_); + } + if (!getEBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 5, e_); + } + if (!getFBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 6, f_); + } + if (!getGBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 7, g_); + } + if (!getHBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 8, h_); + } + if (!getIBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 9, i_); + } + if (!getJBytes().isEmpty()) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 10, j_); + } + unknownFields.writeTo(output); + } + + @Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!getABytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, a_); + } + if (!getBBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, b_); + } + if (!getCBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, c_); + } + if (!getDBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, d_); + } + if (!getEBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(5, e_); + } + if (!getFBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, f_); + } + if (!getGBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(7, g_); + } + if (!getHBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(8, h_); + } + if (!getIBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(9, i_); + } + if (!getJBytes().isEmpty()) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(10, j_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof StringObject)) { + return super.equals(obj); + } + StringObject other = (StringObject) obj; + + boolean result = true; + result = result && getA() + .equals(other.getA()); + result = result && getB() + .equals(other.getB()); + result = result && getC() + .equals(other.getC()); + result = result && getD() + .equals(other.getD()); + result = result && getE() + .equals(other.getE()); + result = result && getF() + .equals(other.getF()); + result = result && getG() + .equals(other.getG()); + result = result && getH() + .equals(other.getH()); + result = result && getI() + .equals(other.getI()); + result = result && getJ() + .equals(other.getJ()); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + A_FIELD_NUMBER; + hash = (53 * hash) + getA().hashCode(); + hash = (37 * hash) + B_FIELD_NUMBER; + hash = (53 * hash) + getB().hashCode(); + hash = (37 * hash) + C_FIELD_NUMBER; + hash = (53 * hash) + getC().hashCode(); + hash = (37 * hash) + D_FIELD_NUMBER; + hash = (53 * hash) + getD().hashCode(); + hash = (37 * hash) + E_FIELD_NUMBER; + hash = (53 * hash) + getE().hashCode(); + hash = (37 * hash) + F_FIELD_NUMBER; + hash = (53 * hash) + getF().hashCode(); + hash = (37 * hash) + G_FIELD_NUMBER; + hash = (53 * hash) + getG().hashCode(); + hash = (37 * hash) + H_FIELD_NUMBER; + hash = (53 * hash) + getH().hashCode(); + hash = (37 * hash) + I_FIELD_NUMBER; + hash = (53 * hash) + getI().hashCode(); + hash = (37 * hash) + J_FIELD_NUMBER; + hash = (53 * hash) + getJ().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static StringObject parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static StringObject parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static StringObject parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static StringObject parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static StringObject parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static StringObject parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static StringObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static StringObject parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static StringObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static StringObject parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static StringObject parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static StringObject parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(StringObject prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @Override + protected Builder newBuilderForType( + BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code StringObject} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:StringObject) + StringObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_StringObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_StringObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + StringObject.class, Builder.class); + } + + // Construct using com.zfoo.protocol.field.packet.FieldProtobufObject.StringObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @Override + public Builder clear() { + super.clear(); + a_ = ""; + + b_ = ""; + + c_ = ""; + + d_ = ""; + + e_ = ""; + + f_ = ""; + + g_ = ""; + + h_ = ""; + + i_ = ""; + + j_ = ""; + + return this; + } + + @Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return FieldProtobufObject.internal_static_StringObject_descriptor; + } + + @Override + public StringObject getDefaultInstanceForType() { + return StringObject.getDefaultInstance(); + } + + @Override + public StringObject build() { + StringObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @Override + public StringObject buildPartial() { + StringObject result = new StringObject(this); + result.a_ = a_; + result.b_ = b_; + result.c_ = c_; + result.d_ = d_; + result.e_ = e_; + result.f_ = f_; + result.g_ = g_; + result.h_ = h_; + result.i_ = i_; + result.j_ = j_; + onBuilt(); + return result; + } + + @Override + public Builder clone() { + return (Builder) super.clone(); + } + @Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + @Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + @Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + @Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + @Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + @Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof StringObject) { + return mergeFrom((StringObject)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(StringObject other) { + if (other == StringObject.getDefaultInstance()) return this; + if (!other.getA().isEmpty()) { + a_ = other.a_; + onChanged(); + } + if (!other.getB().isEmpty()) { + b_ = other.b_; + onChanged(); + } + if (!other.getC().isEmpty()) { + c_ = other.c_; + onChanged(); + } + if (!other.getD().isEmpty()) { + d_ = other.d_; + onChanged(); + } + if (!other.getE().isEmpty()) { + e_ = other.e_; + onChanged(); + } + if (!other.getF().isEmpty()) { + f_ = other.f_; + onChanged(); + } + if (!other.getG().isEmpty()) { + g_ = other.g_; + onChanged(); + } + if (!other.getH().isEmpty()) { + h_ = other.h_; + onChanged(); + } + if (!other.getI().isEmpty()) { + i_ = other.i_; + onChanged(); + } + if (!other.getJ().isEmpty()) { + j_ = other.j_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @Override + public final boolean isInitialized() { + return true; + } + + @Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + StringObject parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (StringObject) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private Object a_ = ""; + /** + * string a = 1; + */ + public String getA() { + Object ref = a_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + a_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string a = 1; + */ + public com.google.protobuf.ByteString + getABytes() { + Object ref = a_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + a_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string a = 1; + */ + public Builder setA( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + a_ = value; + onChanged(); + return this; + } + /** + * string a = 1; + */ + public Builder clearA() { + + a_ = getDefaultInstance().getA(); + onChanged(); + return this; + } + /** + * string a = 1; + */ + public Builder setABytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + a_ = value; + onChanged(); + return this; + } + + private Object b_ = ""; + /** + * string b = 2; + */ + public String getB() { + Object ref = b_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + b_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string b = 2; + */ + public com.google.protobuf.ByteString + getBBytes() { + Object ref = b_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + b_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string b = 2; + */ + public Builder setB( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + b_ = value; + onChanged(); + return this; + } + /** + * string b = 2; + */ + public Builder clearB() { + + b_ = getDefaultInstance().getB(); + onChanged(); + return this; + } + /** + * string b = 2; + */ + public Builder setBBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + b_ = value; + onChanged(); + return this; + } + + private Object c_ = ""; + /** + * string c = 3; + */ + public String getC() { + Object ref = c_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + c_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string c = 3; + */ + public com.google.protobuf.ByteString + getCBytes() { + Object ref = c_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + c_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string c = 3; + */ + public Builder setC( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + c_ = value; + onChanged(); + return this; + } + /** + * string c = 3; + */ + public Builder clearC() { + + c_ = getDefaultInstance().getC(); + onChanged(); + return this; + } + /** + * string c = 3; + */ + public Builder setCBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + c_ = value; + onChanged(); + return this; + } + + private Object d_ = ""; + /** + * string d = 4; + */ + public String getD() { + Object ref = d_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + d_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string d = 4; + */ + public com.google.protobuf.ByteString + getDBytes() { + Object ref = d_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + d_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string d = 4; + */ + public Builder setD( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + d_ = value; + onChanged(); + return this; + } + /** + * string d = 4; + */ + public Builder clearD() { + + d_ = getDefaultInstance().getD(); + onChanged(); + return this; + } + /** + * string d = 4; + */ + public Builder setDBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + d_ = value; + onChanged(); + return this; + } + + private Object e_ = ""; + /** + * string e = 5; + */ + public String getE() { + Object ref = e_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + e_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string e = 5; + */ + public com.google.protobuf.ByteString + getEBytes() { + Object ref = e_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + e_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string e = 5; + */ + public Builder setE( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + e_ = value; + onChanged(); + return this; + } + /** + * string e = 5; + */ + public Builder clearE() { + + e_ = getDefaultInstance().getE(); + onChanged(); + return this; + } + /** + * string e = 5; + */ + public Builder setEBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + e_ = value; + onChanged(); + return this; + } + + private Object f_ = ""; + /** + * string f = 6; + */ + public String getF() { + Object ref = f_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + f_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string f = 6; + */ + public com.google.protobuf.ByteString + getFBytes() { + Object ref = f_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + f_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string f = 6; + */ + public Builder setF( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + f_ = value; + onChanged(); + return this; + } + /** + * string f = 6; + */ + public Builder clearF() { + + f_ = getDefaultInstance().getF(); + onChanged(); + return this; + } + /** + * string f = 6; + */ + public Builder setFBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + f_ = value; + onChanged(); + return this; + } + + private Object g_ = ""; + /** + * string g = 7; + */ + public String getG() { + Object ref = g_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + g_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string g = 7; + */ + public com.google.protobuf.ByteString + getGBytes() { + Object ref = g_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + g_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string g = 7; + */ + public Builder setG( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + g_ = value; + onChanged(); + return this; + } + /** + * string g = 7; + */ + public Builder clearG() { + + g_ = getDefaultInstance().getG(); + onChanged(); + return this; + } + /** + * string g = 7; + */ + public Builder setGBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + g_ = value; + onChanged(); + return this; + } + + private Object h_ = ""; + /** + * string h = 8; + */ + public String getH() { + Object ref = h_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + h_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string h = 8; + */ + public com.google.protobuf.ByteString + getHBytes() { + Object ref = h_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + h_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string h = 8; + */ + public Builder setH( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + h_ = value; + onChanged(); + return this; + } + /** + * string h = 8; + */ + public Builder clearH() { + + h_ = getDefaultInstance().getH(); + onChanged(); + return this; + } + /** + * string h = 8; + */ + public Builder setHBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + h_ = value; + onChanged(); + return this; + } + + private Object i_ = ""; + /** + * string i = 9; + */ + public String getI() { + Object ref = i_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + i_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string i = 9; + */ + public com.google.protobuf.ByteString + getIBytes() { + Object ref = i_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + i_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string i = 9; + */ + public Builder setI( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + i_ = value; + onChanged(); + return this; + } + /** + * string i = 9; + */ + public Builder clearI() { + + i_ = getDefaultInstance().getI(); + onChanged(); + return this; + } + /** + * string i = 9; + */ + public Builder setIBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + i_ = value; + onChanged(); + return this; + } + + private Object j_ = ""; + /** + * string j = 10; + */ + public String getJ() { + Object ref = j_; + if (!(ref instanceof String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + String s = bs.toStringUtf8(); + j_ = s; + return s; + } else { + return (String) ref; + } + } + /** + * string j = 10; + */ + public com.google.protobuf.ByteString + getJBytes() { + Object ref = j_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (String) ref); + j_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * string j = 10; + */ + public Builder setJ( + String value) { + if (value == null) { + throw new NullPointerException(); + } + + j_ = value; + onChanged(); + return this; + } + /** + * string j = 10; + */ + public Builder clearJ() { + + j_ = getDefaultInstance().getJ(); + onChanged(); + return this; + } + /** + * string j = 10; + */ + public Builder setJBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + checkByteStringIsUtf8(value); + + j_ = value; + onChanged(); + return this; + } + @Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + @Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:StringObject) + } + + // @@protoc_insertion_point(class_scope:StringObject) + private static final StringObject DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new StringObject(); + } + + public static StringObject getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @Override + public StringObject parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new StringObject(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @Override + public StringObject getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ListIntegerObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:ListIntegerObject) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated int32 a = 1; + */ + java.util.List getAList(); + /** + * repeated int32 a = 1; + */ + int getACount(); + /** + * repeated int32 a = 1; + */ + int getA(int index); + + /** + * repeated int32 b = 2; + */ + java.util.List getBList(); + /** + * repeated int32 b = 2; + */ + int getBCount(); + /** + * repeated int32 b = 2; + */ + int getB(int index); + + /** + * repeated int32 c = 3; + */ + java.util.List getCList(); + /** + * repeated int32 c = 3; + */ + int getCCount(); + /** + * repeated int32 c = 3; + */ + int getC(int index); + + /** + * repeated int32 d = 4; + */ + java.util.List getDList(); + /** + * repeated int32 d = 4; + */ + int getDCount(); + /** + * repeated int32 d = 4; + */ + int getD(int index); + + /** + * repeated int32 e = 5; + */ + java.util.List getEList(); + /** + * repeated int32 e = 5; + */ + int getECount(); + /** + * repeated int32 e = 5; + */ + int getE(int index); + + /** + * repeated int32 f = 6; + */ + java.util.List getFList(); + /** + * repeated int32 f = 6; + */ + int getFCount(); + /** + * repeated int32 f = 6; + */ + int getF(int index); + + /** + * repeated int32 g = 7; + */ + java.util.List getGList(); + /** + * repeated int32 g = 7; + */ + int getGCount(); + /** + * repeated int32 g = 7; + */ + int getG(int index); + + /** + * repeated int32 h = 8; + */ + java.util.List getHList(); + /** + * repeated int32 h = 8; + */ + int getHCount(); + /** + * repeated int32 h = 8; + */ + int getH(int index); + + /** + * repeated int32 i = 9; + */ + java.util.List getIList(); + /** + * repeated int32 i = 9; + */ + int getICount(); + /** + * repeated int32 i = 9; + */ + int getI(int index); + + /** + * repeated int32 j = 10; + */ + java.util.List getJList(); + /** + * repeated int32 j = 10; + */ + int getJCount(); + /** + * repeated int32 j = 10; + */ + int getJ(int index); + } + /** + * Protobuf type {@code ListIntegerObject} + */ + public static final class ListIntegerObject extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:ListIntegerObject) + ListIntegerObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use ListIntegerObject.newBuilder() to construct. + private ListIntegerObject(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ListIntegerObject() { + a_ = java.util.Collections.emptyList(); + b_ = java.util.Collections.emptyList(); + c_ = java.util.Collections.emptyList(); + d_ = java.util.Collections.emptyList(); + e_ = java.util.Collections.emptyList(); + f_ = java.util.Collections.emptyList(); + g_ = java.util.Collections.emptyList(); + h_ = java.util.Collections.emptyList(); + i_ = java.util.Collections.emptyList(); + j_ = java.util.Collections.emptyList(); + } + + @Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ListIntegerObject( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + a_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + a_.add(input.readInt32()); + break; + } + case 10: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) { + a_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + while (input.getBytesUntilLimit() > 0) { + a_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 16: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + b_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + b_.add(input.readInt32()); + break; + } + case 18: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) { + b_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + while (input.getBytesUntilLimit() > 0) { + b_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 24: { + if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + c_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + c_.add(input.readInt32()); + break; + } + case 26: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) { + c_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + while (input.getBytesUntilLimit() > 0) { + c_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 32: { + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + d_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + d_.add(input.readInt32()); + break; + } + case 34: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008) && input.getBytesUntilLimit() > 0) { + d_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + while (input.getBytesUntilLimit() > 0) { + d_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 40: { + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + e_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + e_.add(input.readInt32()); + break; + } + case 42: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) { + e_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + while (input.getBytesUntilLimit() > 0) { + e_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 48: { + if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + f_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000020; + } + f_.add(input.readInt32()); + break; + } + case 50: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000020) == 0x00000020) && input.getBytesUntilLimit() > 0) { + f_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000020; + } + while (input.getBytesUntilLimit() > 0) { + f_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 56: { + if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) { + g_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000040; + } + g_.add(input.readInt32()); + break; + } + case 58: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000040) == 0x00000040) && input.getBytesUntilLimit() > 0) { + g_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000040; + } + while (input.getBytesUntilLimit() > 0) { + g_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 64: { + if (!((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + h_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000080; + } + h_.add(input.readInt32()); + break; + } + case 66: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000080) == 0x00000080) && input.getBytesUntilLimit() > 0) { + h_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000080; + } + while (input.getBytesUntilLimit() > 0) { + h_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 72: { + if (!((mutable_bitField0_ & 0x00000100) == 0x00000100)) { + i_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000100; + } + i_.add(input.readInt32()); + break; + } + case 74: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000100) == 0x00000100) && input.getBytesUntilLimit() > 0) { + i_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000100; + } + while (input.getBytesUntilLimit() > 0) { + i_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + case 80: { + if (!((mutable_bitField0_ & 0x00000200) == 0x00000200)) { + j_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000200; + } + j_.add(input.readInt32()); + break; + } + case 82: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x00000200) == 0x00000200) && input.getBytesUntilLimit() > 0) { + j_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000200; + } + while (input.getBytesUntilLimit() > 0) { + j_.add(input.readInt32()); + } + input.popLimit(limit); + break; + } + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + a_ = java.util.Collections.unmodifiableList(a_); + } + if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + b_ = java.util.Collections.unmodifiableList(b_); + } + if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + c_ = java.util.Collections.unmodifiableList(c_); + } + if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + d_ = java.util.Collections.unmodifiableList(d_); + } + if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + e_ = java.util.Collections.unmodifiableList(e_); + } + if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + f_ = java.util.Collections.unmodifiableList(f_); + } + if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) { + g_ = java.util.Collections.unmodifiableList(g_); + } + if (((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + h_ = java.util.Collections.unmodifiableList(h_); + } + if (((mutable_bitField0_ & 0x00000100) == 0x00000100)) { + i_ = java.util.Collections.unmodifiableList(i_); + } + if (((mutable_bitField0_ & 0x00000200) == 0x00000200)) { + j_ = java.util.Collections.unmodifiableList(j_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_ListIntegerObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_ListIntegerObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + ListIntegerObject.class, Builder.class); + } + + public static final int A_FIELD_NUMBER = 1; + private java.util.List a_; + /** + * repeated int32 a = 1; + */ + public java.util.List + getAList() { + return a_; + } + /** + * repeated int32 a = 1; + */ + public int getACount() { + return a_.size(); + } + /** + * repeated int32 a = 1; + */ + public int getA(int index) { + return a_.get(index); + } + private int aMemoizedSerializedSize = -1; + + public static final int B_FIELD_NUMBER = 2; + private java.util.List b_; + /** + * repeated int32 b = 2; + */ + public java.util.List + getBList() { + return b_; + } + /** + * repeated int32 b = 2; + */ + public int getBCount() { + return b_.size(); + } + /** + * repeated int32 b = 2; + */ + public int getB(int index) { + return b_.get(index); + } + private int bMemoizedSerializedSize = -1; + + public static final int C_FIELD_NUMBER = 3; + private java.util.List c_; + /** + * repeated int32 c = 3; + */ + public java.util.List + getCList() { + return c_; + } + /** + * repeated int32 c = 3; + */ + public int getCCount() { + return c_.size(); + } + /** + * repeated int32 c = 3; + */ + public int getC(int index) { + return c_.get(index); + } + private int cMemoizedSerializedSize = -1; + + public static final int D_FIELD_NUMBER = 4; + private java.util.List d_; + /** + * repeated int32 d = 4; + */ + public java.util.List + getDList() { + return d_; + } + /** + * repeated int32 d = 4; + */ + public int getDCount() { + return d_.size(); + } + /** + * repeated int32 d = 4; + */ + public int getD(int index) { + return d_.get(index); + } + private int dMemoizedSerializedSize = -1; + + public static final int E_FIELD_NUMBER = 5; + private java.util.List e_; + /** + * repeated int32 e = 5; + */ + public java.util.List + getEList() { + return e_; + } + /** + * repeated int32 e = 5; + */ + public int getECount() { + return e_.size(); + } + /** + * repeated int32 e = 5; + */ + public int getE(int index) { + return e_.get(index); + } + private int eMemoizedSerializedSize = -1; + + public static final int F_FIELD_NUMBER = 6; + private java.util.List f_; + /** + * repeated int32 f = 6; + */ + public java.util.List + getFList() { + return f_; + } + /** + * repeated int32 f = 6; + */ + public int getFCount() { + return f_.size(); + } + /** + * repeated int32 f = 6; + */ + public int getF(int index) { + return f_.get(index); + } + private int fMemoizedSerializedSize = -1; + + public static final int G_FIELD_NUMBER = 7; + private java.util.List g_; + /** + * repeated int32 g = 7; + */ + public java.util.List + getGList() { + return g_; + } + /** + * repeated int32 g = 7; + */ + public int getGCount() { + return g_.size(); + } + /** + * repeated int32 g = 7; + */ + public int getG(int index) { + return g_.get(index); + } + private int gMemoizedSerializedSize = -1; + + public static final int H_FIELD_NUMBER = 8; + private java.util.List h_; + /** + * repeated int32 h = 8; + */ + public java.util.List + getHList() { + return h_; + } + /** + * repeated int32 h = 8; + */ + public int getHCount() { + return h_.size(); + } + /** + * repeated int32 h = 8; + */ + public int getH(int index) { + return h_.get(index); + } + private int hMemoizedSerializedSize = -1; + + public static final int I_FIELD_NUMBER = 9; + private java.util.List i_; + /** + * repeated int32 i = 9; + */ + public java.util.List + getIList() { + return i_; + } + /** + * repeated int32 i = 9; + */ + public int getICount() { + return i_.size(); + } + /** + * repeated int32 i = 9; + */ + public int getI(int index) { + return i_.get(index); + } + private int iMemoizedSerializedSize = -1; + + public static final int J_FIELD_NUMBER = 10; + private java.util.List j_; + /** + * repeated int32 j = 10; + */ + public java.util.List + getJList() { + return j_; + } + /** + * repeated int32 j = 10; + */ + public int getJCount() { + return j_.size(); + } + /** + * repeated int32 j = 10; + */ + public int getJ(int index) { + return j_.get(index); + } + private int jMemoizedSerializedSize = -1; + + private byte memoizedIsInitialized = -1; + @Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + getSerializedSize(); + if (getAList().size() > 0) { + output.writeUInt32NoTag(10); + output.writeUInt32NoTag(aMemoizedSerializedSize); + } + for (int i = 0; i < a_.size(); i++) { + output.writeInt32NoTag(a_.get(i)); + } + if (getBList().size() > 0) { + output.writeUInt32NoTag(18); + output.writeUInt32NoTag(bMemoizedSerializedSize); + } + for (int i = 0; i < b_.size(); i++) { + output.writeInt32NoTag(b_.get(i)); + } + if (getCList().size() > 0) { + output.writeUInt32NoTag(26); + output.writeUInt32NoTag(cMemoizedSerializedSize); + } + for (int i = 0; i < c_.size(); i++) { + output.writeInt32NoTag(c_.get(i)); + } + if (getDList().size() > 0) { + output.writeUInt32NoTag(34); + output.writeUInt32NoTag(dMemoizedSerializedSize); + } + for (int i = 0; i < d_.size(); i++) { + output.writeInt32NoTag(d_.get(i)); + } + if (getEList().size() > 0) { + output.writeUInt32NoTag(42); + output.writeUInt32NoTag(eMemoizedSerializedSize); + } + for (int i = 0; i < e_.size(); i++) { + output.writeInt32NoTag(e_.get(i)); + } + if (getFList().size() > 0) { + output.writeUInt32NoTag(50); + output.writeUInt32NoTag(fMemoizedSerializedSize); + } + for (int i = 0; i < f_.size(); i++) { + output.writeInt32NoTag(f_.get(i)); + } + if (getGList().size() > 0) { + output.writeUInt32NoTag(58); + output.writeUInt32NoTag(gMemoizedSerializedSize); + } + for (int i = 0; i < g_.size(); i++) { + output.writeInt32NoTag(g_.get(i)); + } + if (getHList().size() > 0) { + output.writeUInt32NoTag(66); + output.writeUInt32NoTag(hMemoizedSerializedSize); + } + for (int i = 0; i < h_.size(); i++) { + output.writeInt32NoTag(h_.get(i)); + } + if (getIList().size() > 0) { + output.writeUInt32NoTag(74); + output.writeUInt32NoTag(iMemoizedSerializedSize); + } + for (int i = 0; i < i_.size(); i++) { + output.writeInt32NoTag(i_.get(i)); + } + if (getJList().size() > 0) { + output.writeUInt32NoTag(82); + output.writeUInt32NoTag(jMemoizedSerializedSize); + } + for (int i = 0; i < j_.size(); i++) { + output.writeInt32NoTag(j_.get(i)); + } + unknownFields.writeTo(output); + } + + @Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < a_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(a_.get(i)); + } + size += dataSize; + if (!getAList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + aMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < b_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(b_.get(i)); + } + size += dataSize; + if (!getBList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + bMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < c_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(c_.get(i)); + } + size += dataSize; + if (!getCList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + cMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < d_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(d_.get(i)); + } + size += dataSize; + if (!getDList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + dMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < e_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(e_.get(i)); + } + size += dataSize; + if (!getEList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + eMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < f_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(f_.get(i)); + } + size += dataSize; + if (!getFList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + fMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < g_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(g_.get(i)); + } + size += dataSize; + if (!getGList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + gMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < h_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(h_.get(i)); + } + size += dataSize; + if (!getHList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + hMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < i_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(i_.get(i)); + } + size += dataSize; + if (!getIList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + iMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < j_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(j_.get(i)); + } + size += dataSize; + if (!getJList().isEmpty()) { + size += 1; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + jMemoizedSerializedSize = dataSize; + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof ListIntegerObject)) { + return super.equals(obj); + } + ListIntegerObject other = (ListIntegerObject) obj; + + boolean result = true; + result = result && getAList() + .equals(other.getAList()); + result = result && getBList() + .equals(other.getBList()); + result = result && getCList() + .equals(other.getCList()); + result = result && getDList() + .equals(other.getDList()); + result = result && getEList() + .equals(other.getEList()); + result = result && getFList() + .equals(other.getFList()); + result = result && getGList() + .equals(other.getGList()); + result = result && getHList() + .equals(other.getHList()); + result = result && getIList() + .equals(other.getIList()); + result = result && getJList() + .equals(other.getJList()); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getACount() > 0) { + hash = (37 * hash) + A_FIELD_NUMBER; + hash = (53 * hash) + getAList().hashCode(); + } + if (getBCount() > 0) { + hash = (37 * hash) + B_FIELD_NUMBER; + hash = (53 * hash) + getBList().hashCode(); + } + if (getCCount() > 0) { + hash = (37 * hash) + C_FIELD_NUMBER; + hash = (53 * hash) + getCList().hashCode(); + } + if (getDCount() > 0) { + hash = (37 * hash) + D_FIELD_NUMBER; + hash = (53 * hash) + getDList().hashCode(); + } + if (getECount() > 0) { + hash = (37 * hash) + E_FIELD_NUMBER; + hash = (53 * hash) + getEList().hashCode(); + } + if (getFCount() > 0) { + hash = (37 * hash) + F_FIELD_NUMBER; + hash = (53 * hash) + getFList().hashCode(); + } + if (getGCount() > 0) { + hash = (37 * hash) + G_FIELD_NUMBER; + hash = (53 * hash) + getGList().hashCode(); + } + if (getHCount() > 0) { + hash = (37 * hash) + H_FIELD_NUMBER; + hash = (53 * hash) + getHList().hashCode(); + } + if (getICount() > 0) { + hash = (37 * hash) + I_FIELD_NUMBER; + hash = (53 * hash) + getIList().hashCode(); + } + if (getJCount() > 0) { + hash = (37 * hash) + J_FIELD_NUMBER; + hash = (53 * hash) + getJList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static ListIntegerObject parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static ListIntegerObject parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static ListIntegerObject parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static ListIntegerObject parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static ListIntegerObject parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static ListIntegerObject parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static ListIntegerObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static ListIntegerObject parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static ListIntegerObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static ListIntegerObject parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static ListIntegerObject parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static ListIntegerObject parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(ListIntegerObject prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @Override + protected Builder newBuilderForType( + BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code ListIntegerObject} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:ListIntegerObject) + ListIntegerObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_ListIntegerObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_ListIntegerObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + ListIntegerObject.class, Builder.class); + } + + // Construct using com.zfoo.protocol.field.packet.FieldProtobufObject.ListIntegerObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @Override + public Builder clear() { + super.clear(); + a_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + b_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + c_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + d_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + e_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + f_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + g_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + h_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + i_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000100); + j_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000200); + return this; + } + + @Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return FieldProtobufObject.internal_static_ListIntegerObject_descriptor; + } + + @Override + public ListIntegerObject getDefaultInstanceForType() { + return ListIntegerObject.getDefaultInstance(); + } + + @Override + public ListIntegerObject build() { + ListIntegerObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @Override + public ListIntegerObject buildPartial() { + ListIntegerObject result = new ListIntegerObject(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) == 0x00000001)) { + a_ = java.util.Collections.unmodifiableList(a_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.a_ = a_; + if (((bitField0_ & 0x00000002) == 0x00000002)) { + b_ = java.util.Collections.unmodifiableList(b_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.b_ = b_; + if (((bitField0_ & 0x00000004) == 0x00000004)) { + c_ = java.util.Collections.unmodifiableList(c_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.c_ = c_; + if (((bitField0_ & 0x00000008) == 0x00000008)) { + d_ = java.util.Collections.unmodifiableList(d_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.d_ = d_; + if (((bitField0_ & 0x00000010) == 0x00000010)) { + e_ = java.util.Collections.unmodifiableList(e_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.e_ = e_; + if (((bitField0_ & 0x00000020) == 0x00000020)) { + f_ = java.util.Collections.unmodifiableList(f_); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.f_ = f_; + if (((bitField0_ & 0x00000040) == 0x00000040)) { + g_ = java.util.Collections.unmodifiableList(g_); + bitField0_ = (bitField0_ & ~0x00000040); + } + result.g_ = g_; + if (((bitField0_ & 0x00000080) == 0x00000080)) { + h_ = java.util.Collections.unmodifiableList(h_); + bitField0_ = (bitField0_ & ~0x00000080); + } + result.h_ = h_; + if (((bitField0_ & 0x00000100) == 0x00000100)) { + i_ = java.util.Collections.unmodifiableList(i_); + bitField0_ = (bitField0_ & ~0x00000100); + } + result.i_ = i_; + if (((bitField0_ & 0x00000200) == 0x00000200)) { + j_ = java.util.Collections.unmodifiableList(j_); + bitField0_ = (bitField0_ & ~0x00000200); + } + result.j_ = j_; + onBuilt(); + return result; + } + + @Override + public Builder clone() { + return (Builder) super.clone(); + } + @Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + @Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + @Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + @Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + @Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + @Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof ListIntegerObject) { + return mergeFrom((ListIntegerObject)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(ListIntegerObject other) { + if (other == ListIntegerObject.getDefaultInstance()) return this; + if (!other.a_.isEmpty()) { + if (a_.isEmpty()) { + a_ = other.a_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureAIsMutable(); + a_.addAll(other.a_); + } + onChanged(); + } + if (!other.b_.isEmpty()) { + if (b_.isEmpty()) { + b_ = other.b_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureBIsMutable(); + b_.addAll(other.b_); + } + onChanged(); + } + if (!other.c_.isEmpty()) { + if (c_.isEmpty()) { + c_ = other.c_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureCIsMutable(); + c_.addAll(other.c_); + } + onChanged(); + } + if (!other.d_.isEmpty()) { + if (d_.isEmpty()) { + d_ = other.d_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureDIsMutable(); + d_.addAll(other.d_); + } + onChanged(); + } + if (!other.e_.isEmpty()) { + if (e_.isEmpty()) { + e_ = other.e_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureEIsMutable(); + e_.addAll(other.e_); + } + onChanged(); + } + if (!other.f_.isEmpty()) { + if (f_.isEmpty()) { + f_ = other.f_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureFIsMutable(); + f_.addAll(other.f_); + } + onChanged(); + } + if (!other.g_.isEmpty()) { + if (g_.isEmpty()) { + g_ = other.g_; + bitField0_ = (bitField0_ & ~0x00000040); + } else { + ensureGIsMutable(); + g_.addAll(other.g_); + } + onChanged(); + } + if (!other.h_.isEmpty()) { + if (h_.isEmpty()) { + h_ = other.h_; + bitField0_ = (bitField0_ & ~0x00000080); + } else { + ensureHIsMutable(); + h_.addAll(other.h_); + } + onChanged(); + } + if (!other.i_.isEmpty()) { + if (i_.isEmpty()) { + i_ = other.i_; + bitField0_ = (bitField0_ & ~0x00000100); + } else { + ensureIIsMutable(); + i_.addAll(other.i_); + } + onChanged(); + } + if (!other.j_.isEmpty()) { + if (j_.isEmpty()) { + j_ = other.j_; + bitField0_ = (bitField0_ & ~0x00000200); + } else { + ensureJIsMutable(); + j_.addAll(other.j_); + } + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @Override + public final boolean isInitialized() { + return true; + } + + @Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + ListIntegerObject parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (ListIntegerObject) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List a_ = java.util.Collections.emptyList(); + private void ensureAIsMutable() { + if (!((bitField0_ & 0x00000001) == 0x00000001)) { + a_ = new java.util.ArrayList(a_); + bitField0_ |= 0x00000001; + } + } + /** + * repeated int32 a = 1; + */ + public java.util.List + getAList() { + return java.util.Collections.unmodifiableList(a_); + } + /** + * repeated int32 a = 1; + */ + public int getACount() { + return a_.size(); + } + /** + * repeated int32 a = 1; + */ + public int getA(int index) { + return a_.get(index); + } + /** + * repeated int32 a = 1; + */ + public Builder setA( + int index, int value) { + ensureAIsMutable(); + a_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 a = 1; + */ + public Builder addA(int value) { + ensureAIsMutable(); + a_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 a = 1; + */ + public Builder addAllA( + Iterable values) { + ensureAIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, a_); + onChanged(); + return this; + } + /** + * repeated int32 a = 1; + */ + public Builder clearA() { + a_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + + private java.util.List b_ = java.util.Collections.emptyList(); + private void ensureBIsMutable() { + if (!((bitField0_ & 0x00000002) == 0x00000002)) { + b_ = new java.util.ArrayList(b_); + bitField0_ |= 0x00000002; + } + } + /** + * repeated int32 b = 2; + */ + public java.util.List + getBList() { + return java.util.Collections.unmodifiableList(b_); + } + /** + * repeated int32 b = 2; + */ + public int getBCount() { + return b_.size(); + } + /** + * repeated int32 b = 2; + */ + public int getB(int index) { + return b_.get(index); + } + /** + * repeated int32 b = 2; + */ + public Builder setB( + int index, int value) { + ensureBIsMutable(); + b_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 b = 2; + */ + public Builder addB(int value) { + ensureBIsMutable(); + b_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 b = 2; + */ + public Builder addAllB( + Iterable values) { + ensureBIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, b_); + onChanged(); + return this; + } + /** + * repeated int32 b = 2; + */ + public Builder clearB() { + b_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + return this; + } + + private java.util.List c_ = java.util.Collections.emptyList(); + private void ensureCIsMutable() { + if (!((bitField0_ & 0x00000004) == 0x00000004)) { + c_ = new java.util.ArrayList(c_); + bitField0_ |= 0x00000004; + } + } + /** + * repeated int32 c = 3; + */ + public java.util.List + getCList() { + return java.util.Collections.unmodifiableList(c_); + } + /** + * repeated int32 c = 3; + */ + public int getCCount() { + return c_.size(); + } + /** + * repeated int32 c = 3; + */ + public int getC(int index) { + return c_.get(index); + } + /** + * repeated int32 c = 3; + */ + public Builder setC( + int index, int value) { + ensureCIsMutable(); + c_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 c = 3; + */ + public Builder addC(int value) { + ensureCIsMutable(); + c_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 c = 3; + */ + public Builder addAllC( + Iterable values) { + ensureCIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, c_); + onChanged(); + return this; + } + /** + * repeated int32 c = 3; + */ + public Builder clearC() { + c_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + return this; + } + + private java.util.List d_ = java.util.Collections.emptyList(); + private void ensureDIsMutable() { + if (!((bitField0_ & 0x00000008) == 0x00000008)) { + d_ = new java.util.ArrayList(d_); + bitField0_ |= 0x00000008; + } + } + /** + * repeated int32 d = 4; + */ + public java.util.List + getDList() { + return java.util.Collections.unmodifiableList(d_); + } + /** + * repeated int32 d = 4; + */ + public int getDCount() { + return d_.size(); + } + /** + * repeated int32 d = 4; + */ + public int getD(int index) { + return d_.get(index); + } + /** + * repeated int32 d = 4; + */ + public Builder setD( + int index, int value) { + ensureDIsMutable(); + d_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 d = 4; + */ + public Builder addD(int value) { + ensureDIsMutable(); + d_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 d = 4; + */ + public Builder addAllD( + Iterable values) { + ensureDIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, d_); + onChanged(); + return this; + } + /** + * repeated int32 d = 4; + */ + public Builder clearD() { + d_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + return this; + } + + private java.util.List e_ = java.util.Collections.emptyList(); + private void ensureEIsMutable() { + if (!((bitField0_ & 0x00000010) == 0x00000010)) { + e_ = new java.util.ArrayList(e_); + bitField0_ |= 0x00000010; + } + } + /** + * repeated int32 e = 5; + */ + public java.util.List + getEList() { + return java.util.Collections.unmodifiableList(e_); + } + /** + * repeated int32 e = 5; + */ + public int getECount() { + return e_.size(); + } + /** + * repeated int32 e = 5; + */ + public int getE(int index) { + return e_.get(index); + } + /** + * repeated int32 e = 5; + */ + public Builder setE( + int index, int value) { + ensureEIsMutable(); + e_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 e = 5; + */ + public Builder addE(int value) { + ensureEIsMutable(); + e_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 e = 5; + */ + public Builder addAllE( + Iterable values) { + ensureEIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, e_); + onChanged(); + return this; + } + /** + * repeated int32 e = 5; + */ + public Builder clearE() { + e_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + return this; + } + + private java.util.List f_ = java.util.Collections.emptyList(); + private void ensureFIsMutable() { + if (!((bitField0_ & 0x00000020) == 0x00000020)) { + f_ = new java.util.ArrayList(f_); + bitField0_ |= 0x00000020; + } + } + /** + * repeated int32 f = 6; + */ + public java.util.List + getFList() { + return java.util.Collections.unmodifiableList(f_); + } + /** + * repeated int32 f = 6; + */ + public int getFCount() { + return f_.size(); + } + /** + * repeated int32 f = 6; + */ + public int getF(int index) { + return f_.get(index); + } + /** + * repeated int32 f = 6; + */ + public Builder setF( + int index, int value) { + ensureFIsMutable(); + f_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 f = 6; + */ + public Builder addF(int value) { + ensureFIsMutable(); + f_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 f = 6; + */ + public Builder addAllF( + Iterable values) { + ensureFIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, f_); + onChanged(); + return this; + } + /** + * repeated int32 f = 6; + */ + public Builder clearF() { + f_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + return this; + } + + private java.util.List g_ = java.util.Collections.emptyList(); + private void ensureGIsMutable() { + if (!((bitField0_ & 0x00000040) == 0x00000040)) { + g_ = new java.util.ArrayList(g_); + bitField0_ |= 0x00000040; + } + } + /** + * repeated int32 g = 7; + */ + public java.util.List + getGList() { + return java.util.Collections.unmodifiableList(g_); + } + /** + * repeated int32 g = 7; + */ + public int getGCount() { + return g_.size(); + } + /** + * repeated int32 g = 7; + */ + public int getG(int index) { + return g_.get(index); + } + /** + * repeated int32 g = 7; + */ + public Builder setG( + int index, int value) { + ensureGIsMutable(); + g_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 g = 7; + */ + public Builder addG(int value) { + ensureGIsMutable(); + g_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 g = 7; + */ + public Builder addAllG( + Iterable values) { + ensureGIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, g_); + onChanged(); + return this; + } + /** + * repeated int32 g = 7; + */ + public Builder clearG() { + g_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + onChanged(); + return this; + } + + private java.util.List h_ = java.util.Collections.emptyList(); + private void ensureHIsMutable() { + if (!((bitField0_ & 0x00000080) == 0x00000080)) { + h_ = new java.util.ArrayList(h_); + bitField0_ |= 0x00000080; + } + } + /** + * repeated int32 h = 8; + */ + public java.util.List + getHList() { + return java.util.Collections.unmodifiableList(h_); + } + /** + * repeated int32 h = 8; + */ + public int getHCount() { + return h_.size(); + } + /** + * repeated int32 h = 8; + */ + public int getH(int index) { + return h_.get(index); + } + /** + * repeated int32 h = 8; + */ + public Builder setH( + int index, int value) { + ensureHIsMutable(); + h_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 h = 8; + */ + public Builder addH(int value) { + ensureHIsMutable(); + h_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 h = 8; + */ + public Builder addAllH( + Iterable values) { + ensureHIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, h_); + onChanged(); + return this; + } + /** + * repeated int32 h = 8; + */ + public Builder clearH() { + h_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + onChanged(); + return this; + } + + private java.util.List i_ = java.util.Collections.emptyList(); + private void ensureIIsMutable() { + if (!((bitField0_ & 0x00000100) == 0x00000100)) { + i_ = new java.util.ArrayList(i_); + bitField0_ |= 0x00000100; + } + } + /** + * repeated int32 i = 9; + */ + public java.util.List + getIList() { + return java.util.Collections.unmodifiableList(i_); + } + /** + * repeated int32 i = 9; + */ + public int getICount() { + return i_.size(); + } + /** + * repeated int32 i = 9; + */ + public int getI(int index) { + return i_.get(index); + } + /** + * repeated int32 i = 9; + */ + public Builder setI( + int index, int value) { + ensureIIsMutable(); + i_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 i = 9; + */ + public Builder addI(int value) { + ensureIIsMutable(); + i_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 i = 9; + */ + public Builder addAllI( + Iterable values) { + ensureIIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, i_); + onChanged(); + return this; + } + /** + * repeated int32 i = 9; + */ + public Builder clearI() { + i_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000100); + onChanged(); + return this; + } + + private java.util.List j_ = java.util.Collections.emptyList(); + private void ensureJIsMutable() { + if (!((bitField0_ & 0x00000200) == 0x00000200)) { + j_ = new java.util.ArrayList(j_); + bitField0_ |= 0x00000200; + } + } + /** + * repeated int32 j = 10; + */ + public java.util.List + getJList() { + return java.util.Collections.unmodifiableList(j_); + } + /** + * repeated int32 j = 10; + */ + public int getJCount() { + return j_.size(); + } + /** + * repeated int32 j = 10; + */ + public int getJ(int index) { + return j_.get(index); + } + /** + * repeated int32 j = 10; + */ + public Builder setJ( + int index, int value) { + ensureJIsMutable(); + j_.set(index, value); + onChanged(); + return this; + } + /** + * repeated int32 j = 10; + */ + public Builder addJ(int value) { + ensureJIsMutable(); + j_.add(value); + onChanged(); + return this; + } + /** + * repeated int32 j = 10; + */ + public Builder addAllJ( + Iterable values) { + ensureJIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, j_); + onChanged(); + return this; + } + /** + * repeated int32 j = 10; + */ + public Builder clearJ() { + j_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000200); + onChanged(); + return this; + } + @Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + @Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:ListIntegerObject) + } + + // @@protoc_insertion_point(class_scope:ListIntegerObject) + private static final ListIntegerObject DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new ListIntegerObject(); + } + + public static ListIntegerObject getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @Override + public ListIntegerObject parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ListIntegerObject(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @Override + public ListIntegerObject getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface MapObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:MapObject) + com.google.protobuf.MessageOrBuilder { + + /** + * map<int32, string> a = 1; + */ + int getACount(); + /** + * map<int32, string> a = 1; + */ + boolean containsA( + int key); + /** + * Use {@link #getAMap()} instead. + */ + @Deprecated + java.util.Map + getA(); + /** + * map<int32, string> a = 1; + */ + java.util.Map + getAMap(); + /** + * map<int32, string> a = 1; + */ + + String getAOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> a = 1; + */ + + String getAOrThrow( + int key); + + /** + * map<int32, string> b = 2; + */ + int getBCount(); + /** + * map<int32, string> b = 2; + */ + boolean containsB( + int key); + /** + * Use {@link #getBMap()} instead. + */ + @Deprecated + java.util.Map + getB(); + /** + * map<int32, string> b = 2; + */ + java.util.Map + getBMap(); + /** + * map<int32, string> b = 2; + */ + + String getBOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> b = 2; + */ + + String getBOrThrow( + int key); + + /** + * map<int32, string> c = 3; + */ + int getCCount(); + /** + * map<int32, string> c = 3; + */ + boolean containsC( + int key); + /** + * Use {@link #getCMap()} instead. + */ + @Deprecated + java.util.Map + getC(); + /** + * map<int32, string> c = 3; + */ + java.util.Map + getCMap(); + /** + * map<int32, string> c = 3; + */ + + String getCOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> c = 3; + */ + + String getCOrThrow( + int key); + + /** + * map<int32, string> d = 4; + */ + int getDCount(); + /** + * map<int32, string> d = 4; + */ + boolean containsD( + int key); + /** + * Use {@link #getDMap()} instead. + */ + @Deprecated + java.util.Map + getD(); + /** + * map<int32, string> d = 4; + */ + java.util.Map + getDMap(); + /** + * map<int32, string> d = 4; + */ + + String getDOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> d = 4; + */ + + String getDOrThrow( + int key); + + /** + * map<int32, string> e = 5; + */ + int getECount(); + /** + * map<int32, string> e = 5; + */ + boolean containsE( + int key); + /** + * Use {@link #getEMap()} instead. + */ + @Deprecated + java.util.Map + getE(); + /** + * map<int32, string> e = 5; + */ + java.util.Map + getEMap(); + /** + * map<int32, string> e = 5; + */ + + String getEOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> e = 5; + */ + + String getEOrThrow( + int key); + + /** + * map<int32, string> f = 6; + */ + int getFCount(); + /** + * map<int32, string> f = 6; + */ + boolean containsF( + int key); + /** + * Use {@link #getFMap()} instead. + */ + @Deprecated + java.util.Map + getF(); + /** + * map<int32, string> f = 6; + */ + java.util.Map + getFMap(); + /** + * map<int32, string> f = 6; + */ + + String getFOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> f = 6; + */ + + String getFOrThrow( + int key); + + /** + * map<int32, string> g = 7; + */ + int getGCount(); + /** + * map<int32, string> g = 7; + */ + boolean containsG( + int key); + /** + * Use {@link #getGMap()} instead. + */ + @Deprecated + java.util.Map + getG(); + /** + * map<int32, string> g = 7; + */ + java.util.Map + getGMap(); + /** + * map<int32, string> g = 7; + */ + + String getGOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> g = 7; + */ + + String getGOrThrow( + int key); + + /** + * map<int32, string> h = 8; + */ + int getHCount(); + /** + * map<int32, string> h = 8; + */ + boolean containsH( + int key); + /** + * Use {@link #getHMap()} instead. + */ + @Deprecated + java.util.Map + getH(); + /** + * map<int32, string> h = 8; + */ + java.util.Map + getHMap(); + /** + * map<int32, string> h = 8; + */ + + String getHOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> h = 8; + */ + + String getHOrThrow( + int key); + + /** + * map<int32, string> i = 9; + */ + int getICount(); + /** + * map<int32, string> i = 9; + */ + boolean containsI( + int key); + /** + * Use {@link #getIMap()} instead. + */ + @Deprecated + java.util.Map + getI(); + /** + * map<int32, string> i = 9; + */ + java.util.Map + getIMap(); + /** + * map<int32, string> i = 9; + */ + + String getIOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> i = 9; + */ + + String getIOrThrow( + int key); + + /** + * map<int32, string> j = 10; + */ + int getJCount(); + /** + * map<int32, string> j = 10; + */ + boolean containsJ( + int key); + /** + * Use {@link #getJMap()} instead. + */ + @Deprecated + java.util.Map + getJ(); + /** + * map<int32, string> j = 10; + */ + java.util.Map + getJMap(); + /** + * map<int32, string> j = 10; + */ + + String getJOrDefault( + int key, + String defaultValue); + /** + * map<int32, string> j = 10; + */ + + String getJOrThrow( + int key); + } + /** + * Protobuf type {@code MapObject} + */ + public static final class MapObject extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:MapObject) + MapObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use MapObject.newBuilder() to construct. + private MapObject(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private MapObject() { + } + + @Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private MapObject( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) { + a_ = com.google.protobuf.MapField.newMapField( + ADefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000001; + } + com.google.protobuf.MapEntry + a__ = input.readMessage( + ADefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + a_.getMutableMap().put( + a__.getKey(), a__.getValue()); + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) { + b_ = com.google.protobuf.MapField.newMapField( + BDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000002; + } + com.google.protobuf.MapEntry + b__ = input.readMessage( + BDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + b_.getMutableMap().put( + b__.getKey(), b__.getValue()); + break; + } + case 26: { + if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) { + c_ = com.google.protobuf.MapField.newMapField( + CDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000004; + } + com.google.protobuf.MapEntry + c__ = input.readMessage( + CDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + c_.getMutableMap().put( + c__.getKey(), c__.getValue()); + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) { + d_ = com.google.protobuf.MapField.newMapField( + DDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000008; + } + com.google.protobuf.MapEntry + d__ = input.readMessage( + DDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + d_.getMutableMap().put( + d__.getKey(), d__.getValue()); + break; + } + case 42: { + if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) { + e_ = com.google.protobuf.MapField.newMapField( + EDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000010; + } + com.google.protobuf.MapEntry + e__ = input.readMessage( + EDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + e_.getMutableMap().put( + e__.getKey(), e__.getValue()); + break; + } + case 50: { + if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) { + f_ = com.google.protobuf.MapField.newMapField( + FDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000020; + } + com.google.protobuf.MapEntry + f__ = input.readMessage( + FDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + f_.getMutableMap().put( + f__.getKey(), f__.getValue()); + break; + } + case 58: { + if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) { + g_ = com.google.protobuf.MapField.newMapField( + GDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000040; + } + com.google.protobuf.MapEntry + g__ = input.readMessage( + GDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + g_.getMutableMap().put( + g__.getKey(), g__.getValue()); + break; + } + case 66: { + if (!((mutable_bitField0_ & 0x00000080) == 0x00000080)) { + h_ = com.google.protobuf.MapField.newMapField( + HDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000080; + } + com.google.protobuf.MapEntry + h__ = input.readMessage( + HDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + h_.getMutableMap().put( + h__.getKey(), h__.getValue()); + break; + } + case 74: { + if (!((mutable_bitField0_ & 0x00000100) == 0x00000100)) { + i_ = com.google.protobuf.MapField.newMapField( + IDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000100; + } + com.google.protobuf.MapEntry + i__ = input.readMessage( + IDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + i_.getMutableMap().put( + i__.getKey(), i__.getValue()); + break; + } + case 82: { + if (!((mutable_bitField0_ & 0x00000200) == 0x00000200)) { + j_ = com.google.protobuf.MapField.newMapField( + JDefaultEntryHolder.defaultEntry); + mutable_bitField0_ |= 0x00000200; + } + com.google.protobuf.MapEntry + j__ = input.readMessage( + JDefaultEntryHolder.defaultEntry.getParserForType(), extensionRegistry); + j_.getMutableMap().put( + j__.getKey(), j__.getValue()); + break; + } + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_MapObject_descriptor; + } + + @SuppressWarnings({"rawtypes"}) + @Override + protected com.google.protobuf.MapField internalGetMapField( + int number) { + switch (number) { + case 1: + return internalGetA(); + case 2: + return internalGetB(); + case 3: + return internalGetC(); + case 4: + return internalGetD(); + case 5: + return internalGetE(); + case 6: + return internalGetF(); + case 7: + return internalGetG(); + case 8: + return internalGetH(); + case 9: + return internalGetI(); + case 10: + return internalGetJ(); + default: + throw new RuntimeException( + "Invalid map field number: " + number); + } + } + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_MapObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + MapObject.class, Builder.class); + } + + public static final int A_FIELD_NUMBER = 1; + private static final class ADefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_AEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> a_; + private com.google.protobuf.MapField + internalGetA() { + if (a_ == null) { + return com.google.protobuf.MapField.emptyMapField( + ADefaultEntryHolder.defaultEntry); + } + return a_; + } + + public int getACount() { + return internalGetA().getMap().size(); + } + /** + * map<int32, string> a = 1; + */ + + public boolean containsA( + int key) { + + return internalGetA().getMap().containsKey(key); + } + /** + * Use {@link #getAMap()} instead. + */ + @Deprecated + public java.util.Map getA() { + return getAMap(); + } + /** + * map<int32, string> a = 1; + */ + + public java.util.Map getAMap() { + return internalGetA().getMap(); + } + /** + * map<int32, string> a = 1; + */ + + public String getAOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetA().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> a = 1; + */ + + public String getAOrThrow( + int key) { + + java.util.Map map = + internalGetA().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int B_FIELD_NUMBER = 2; + private static final class BDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_BEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> b_; + private com.google.protobuf.MapField + internalGetB() { + if (b_ == null) { + return com.google.protobuf.MapField.emptyMapField( + BDefaultEntryHolder.defaultEntry); + } + return b_; + } + + public int getBCount() { + return internalGetB().getMap().size(); + } + /** + * map<int32, string> b = 2; + */ + + public boolean containsB( + int key) { + + return internalGetB().getMap().containsKey(key); + } + /** + * Use {@link #getBMap()} instead. + */ + @Deprecated + public java.util.Map getB() { + return getBMap(); + } + /** + * map<int32, string> b = 2; + */ + + public java.util.Map getBMap() { + return internalGetB().getMap(); + } + /** + * map<int32, string> b = 2; + */ + + public String getBOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetB().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> b = 2; + */ + + public String getBOrThrow( + int key) { + + java.util.Map map = + internalGetB().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int C_FIELD_NUMBER = 3; + private static final class CDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_CEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> c_; + private com.google.protobuf.MapField + internalGetC() { + if (c_ == null) { + return com.google.protobuf.MapField.emptyMapField( + CDefaultEntryHolder.defaultEntry); + } + return c_; + } + + public int getCCount() { + return internalGetC().getMap().size(); + } + /** + * map<int32, string> c = 3; + */ + + public boolean containsC( + int key) { + + return internalGetC().getMap().containsKey(key); + } + /** + * Use {@link #getCMap()} instead. + */ + @Deprecated + public java.util.Map getC() { + return getCMap(); + } + /** + * map<int32, string> c = 3; + */ + + public java.util.Map getCMap() { + return internalGetC().getMap(); + } + /** + * map<int32, string> c = 3; + */ + + public String getCOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetC().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> c = 3; + */ + + public String getCOrThrow( + int key) { + + java.util.Map map = + internalGetC().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int D_FIELD_NUMBER = 4; + private static final class DDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_DEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> d_; + private com.google.protobuf.MapField + internalGetD() { + if (d_ == null) { + return com.google.protobuf.MapField.emptyMapField( + DDefaultEntryHolder.defaultEntry); + } + return d_; + } + + public int getDCount() { + return internalGetD().getMap().size(); + } + /** + * map<int32, string> d = 4; + */ + + public boolean containsD( + int key) { + + return internalGetD().getMap().containsKey(key); + } + /** + * Use {@link #getDMap()} instead. + */ + @Deprecated + public java.util.Map getD() { + return getDMap(); + } + /** + * map<int32, string> d = 4; + */ + + public java.util.Map getDMap() { + return internalGetD().getMap(); + } + /** + * map<int32, string> d = 4; + */ + + public String getDOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetD().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> d = 4; + */ + + public String getDOrThrow( + int key) { + + java.util.Map map = + internalGetD().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int E_FIELD_NUMBER = 5; + private static final class EDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_EEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> e_; + private com.google.protobuf.MapField + internalGetE() { + if (e_ == null) { + return com.google.protobuf.MapField.emptyMapField( + EDefaultEntryHolder.defaultEntry); + } + return e_; + } + + public int getECount() { + return internalGetE().getMap().size(); + } + /** + * map<int32, string> e = 5; + */ + + public boolean containsE( + int key) { + + return internalGetE().getMap().containsKey(key); + } + /** + * Use {@link #getEMap()} instead. + */ + @Deprecated + public java.util.Map getE() { + return getEMap(); + } + /** + * map<int32, string> e = 5; + */ + + public java.util.Map getEMap() { + return internalGetE().getMap(); + } + /** + * map<int32, string> e = 5; + */ + + public String getEOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetE().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> e = 5; + */ + + public String getEOrThrow( + int key) { + + java.util.Map map = + internalGetE().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int F_FIELD_NUMBER = 6; + private static final class FDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_FEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> f_; + private com.google.protobuf.MapField + internalGetF() { + if (f_ == null) { + return com.google.protobuf.MapField.emptyMapField( + FDefaultEntryHolder.defaultEntry); + } + return f_; + } + + public int getFCount() { + return internalGetF().getMap().size(); + } + /** + * map<int32, string> f = 6; + */ + + public boolean containsF( + int key) { + + return internalGetF().getMap().containsKey(key); + } + /** + * Use {@link #getFMap()} instead. + */ + @Deprecated + public java.util.Map getF() { + return getFMap(); + } + /** + * map<int32, string> f = 6; + */ + + public java.util.Map getFMap() { + return internalGetF().getMap(); + } + /** + * map<int32, string> f = 6; + */ + + public String getFOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetF().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> f = 6; + */ + + public String getFOrThrow( + int key) { + + java.util.Map map = + internalGetF().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int G_FIELD_NUMBER = 7; + private static final class GDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_GEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> g_; + private com.google.protobuf.MapField + internalGetG() { + if (g_ == null) { + return com.google.protobuf.MapField.emptyMapField( + GDefaultEntryHolder.defaultEntry); + } + return g_; + } + + public int getGCount() { + return internalGetG().getMap().size(); + } + /** + * map<int32, string> g = 7; + */ + + public boolean containsG( + int key) { + + return internalGetG().getMap().containsKey(key); + } + /** + * Use {@link #getGMap()} instead. + */ + @Deprecated + public java.util.Map getG() { + return getGMap(); + } + /** + * map<int32, string> g = 7; + */ + + public java.util.Map getGMap() { + return internalGetG().getMap(); + } + /** + * map<int32, string> g = 7; + */ + + public String getGOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetG().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> g = 7; + */ + + public String getGOrThrow( + int key) { + + java.util.Map map = + internalGetG().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int H_FIELD_NUMBER = 8; + private static final class HDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_HEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> h_; + private com.google.protobuf.MapField + internalGetH() { + if (h_ == null) { + return com.google.protobuf.MapField.emptyMapField( + HDefaultEntryHolder.defaultEntry); + } + return h_; + } + + public int getHCount() { + return internalGetH().getMap().size(); + } + /** + * map<int32, string> h = 8; + */ + + public boolean containsH( + int key) { + + return internalGetH().getMap().containsKey(key); + } + /** + * Use {@link #getHMap()} instead. + */ + @Deprecated + public java.util.Map getH() { + return getHMap(); + } + /** + * map<int32, string> h = 8; + */ + + public java.util.Map getHMap() { + return internalGetH().getMap(); + } + /** + * map<int32, string> h = 8; + */ + + public String getHOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetH().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> h = 8; + */ + + public String getHOrThrow( + int key) { + + java.util.Map map = + internalGetH().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int I_FIELD_NUMBER = 9; + private static final class IDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_IEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> i_; + private com.google.protobuf.MapField + internalGetI() { + if (i_ == null) { + return com.google.protobuf.MapField.emptyMapField( + IDefaultEntryHolder.defaultEntry); + } + return i_; + } + + public int getICount() { + return internalGetI().getMap().size(); + } + /** + * map<int32, string> i = 9; + */ + + public boolean containsI( + int key) { + + return internalGetI().getMap().containsKey(key); + } + /** + * Use {@link #getIMap()} instead. + */ + @Deprecated + public java.util.Map getI() { + return getIMap(); + } + /** + * map<int32, string> i = 9; + */ + + public java.util.Map getIMap() { + return internalGetI().getMap(); + } + /** + * map<int32, string> i = 9; + */ + + public String getIOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetI().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> i = 9; + */ + + public String getIOrThrow( + int key) { + + java.util.Map map = + internalGetI().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public static final int J_FIELD_NUMBER = 10; + private static final class JDefaultEntryHolder { + static final com.google.protobuf.MapEntry< + Integer, String> defaultEntry = + com.google.protobuf.MapEntry + .newDefaultInstance( + FieldProtobufObject.internal_static_MapObject_JEntry_descriptor, + com.google.protobuf.WireFormat.FieldType.INT32, + 0, + com.google.protobuf.WireFormat.FieldType.STRING, + ""); + } + private com.google.protobuf.MapField< + Integer, String> j_; + private com.google.protobuf.MapField + internalGetJ() { + if (j_ == null) { + return com.google.protobuf.MapField.emptyMapField( + JDefaultEntryHolder.defaultEntry); + } + return j_; + } + + public int getJCount() { + return internalGetJ().getMap().size(); + } + /** + * map<int32, string> j = 10; + */ + + public boolean containsJ( + int key) { + + return internalGetJ().getMap().containsKey(key); + } + /** + * Use {@link #getJMap()} instead. + */ + @Deprecated + public java.util.Map getJ() { + return getJMap(); + } + /** + * map<int32, string> j = 10; + */ + + public java.util.Map getJMap() { + return internalGetJ().getMap(); + } + /** + * map<int32, string> j = 10; + */ + + public String getJOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetJ().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> j = 10; + */ + + public String getJOrThrow( + int key) { + + java.util.Map map = + internalGetJ().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + private byte memoizedIsInitialized = -1; + @Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetA(), + ADefaultEntryHolder.defaultEntry, + 1); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetB(), + BDefaultEntryHolder.defaultEntry, + 2); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetC(), + CDefaultEntryHolder.defaultEntry, + 3); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetD(), + DDefaultEntryHolder.defaultEntry, + 4); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetE(), + EDefaultEntryHolder.defaultEntry, + 5); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetF(), + FDefaultEntryHolder.defaultEntry, + 6); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetG(), + GDefaultEntryHolder.defaultEntry, + 7); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetH(), + HDefaultEntryHolder.defaultEntry, + 8); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetI(), + IDefaultEntryHolder.defaultEntry, + 9); + com.google.protobuf.GeneratedMessageV3 + .serializeIntegerMapTo( + output, + internalGetJ(), + JDefaultEntryHolder.defaultEntry, + 10); + unknownFields.writeTo(output); + } + + @Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (java.util.Map.Entry entry + : internalGetA().getMap().entrySet()) { + com.google.protobuf.MapEntry + a__ = ADefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, a__); + } + for (java.util.Map.Entry entry + : internalGetB().getMap().entrySet()) { + com.google.protobuf.MapEntry + b__ = BDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, b__); + } + for (java.util.Map.Entry entry + : internalGetC().getMap().entrySet()) { + com.google.protobuf.MapEntry + c__ = CDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, c__); + } + for (java.util.Map.Entry entry + : internalGetD().getMap().entrySet()) { + com.google.protobuf.MapEntry + d__ = DDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, d__); + } + for (java.util.Map.Entry entry + : internalGetE().getMap().entrySet()) { + com.google.protobuf.MapEntry + e__ = EDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, e__); + } + for (java.util.Map.Entry entry + : internalGetF().getMap().entrySet()) { + com.google.protobuf.MapEntry + f__ = FDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, f__); + } + for (java.util.Map.Entry entry + : internalGetG().getMap().entrySet()) { + com.google.protobuf.MapEntry + g__ = GDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, g__); + } + for (java.util.Map.Entry entry + : internalGetH().getMap().entrySet()) { + com.google.protobuf.MapEntry + h__ = HDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, h__); + } + for (java.util.Map.Entry entry + : internalGetI().getMap().entrySet()) { + com.google.protobuf.MapEntry + i__ = IDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, i__); + } + for (java.util.Map.Entry entry + : internalGetJ().getMap().entrySet()) { + com.google.protobuf.MapEntry + j__ = JDefaultEntryHolder.defaultEntry.newBuilderForType() + .setKey(entry.getKey()) + .setValue(entry.getValue()) + .build(); + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(10, j__); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof MapObject)) { + return super.equals(obj); + } + MapObject other = (MapObject) obj; + + boolean result = true; + result = result && internalGetA().equals( + other.internalGetA()); + result = result && internalGetB().equals( + other.internalGetB()); + result = result && internalGetC().equals( + other.internalGetC()); + result = result && internalGetD().equals( + other.internalGetD()); + result = result && internalGetE().equals( + other.internalGetE()); + result = result && internalGetF().equals( + other.internalGetF()); + result = result && internalGetG().equals( + other.internalGetG()); + result = result && internalGetH().equals( + other.internalGetH()); + result = result && internalGetI().equals( + other.internalGetI()); + result = result && internalGetJ().equals( + other.internalGetJ()); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (!internalGetA().getMap().isEmpty()) { + hash = (37 * hash) + A_FIELD_NUMBER; + hash = (53 * hash) + internalGetA().hashCode(); + } + if (!internalGetB().getMap().isEmpty()) { + hash = (37 * hash) + B_FIELD_NUMBER; + hash = (53 * hash) + internalGetB().hashCode(); + } + if (!internalGetC().getMap().isEmpty()) { + hash = (37 * hash) + C_FIELD_NUMBER; + hash = (53 * hash) + internalGetC().hashCode(); + } + if (!internalGetD().getMap().isEmpty()) { + hash = (37 * hash) + D_FIELD_NUMBER; + hash = (53 * hash) + internalGetD().hashCode(); + } + if (!internalGetE().getMap().isEmpty()) { + hash = (37 * hash) + E_FIELD_NUMBER; + hash = (53 * hash) + internalGetE().hashCode(); + } + if (!internalGetF().getMap().isEmpty()) { + hash = (37 * hash) + F_FIELD_NUMBER; + hash = (53 * hash) + internalGetF().hashCode(); + } + if (!internalGetG().getMap().isEmpty()) { + hash = (37 * hash) + G_FIELD_NUMBER; + hash = (53 * hash) + internalGetG().hashCode(); + } + if (!internalGetH().getMap().isEmpty()) { + hash = (37 * hash) + H_FIELD_NUMBER; + hash = (53 * hash) + internalGetH().hashCode(); + } + if (!internalGetI().getMap().isEmpty()) { + hash = (37 * hash) + I_FIELD_NUMBER; + hash = (53 * hash) + internalGetI().hashCode(); + } + if (!internalGetJ().getMap().isEmpty()) { + hash = (37 * hash) + J_FIELD_NUMBER; + hash = (53 * hash) + internalGetJ().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static MapObject parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static MapObject parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static MapObject parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static MapObject parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static MapObject parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static MapObject parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static MapObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static MapObject parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static MapObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static MapObject parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static MapObject parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static MapObject parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(MapObject prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @Override + protected Builder newBuilderForType( + BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code MapObject} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:MapObject) + MapObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_MapObject_descriptor; + } + + @SuppressWarnings({"rawtypes"}) + protected com.google.protobuf.MapField internalGetMapField( + int number) { + switch (number) { + case 1: + return internalGetA(); + case 2: + return internalGetB(); + case 3: + return internalGetC(); + case 4: + return internalGetD(); + case 5: + return internalGetE(); + case 6: + return internalGetF(); + case 7: + return internalGetG(); + case 8: + return internalGetH(); + case 9: + return internalGetI(); + case 10: + return internalGetJ(); + default: + throw new RuntimeException( + "Invalid map field number: " + number); + } + } + @SuppressWarnings({"rawtypes"}) + protected com.google.protobuf.MapField internalGetMutableMapField( + int number) { + switch (number) { + case 1: + return internalGetMutableA(); + case 2: + return internalGetMutableB(); + case 3: + return internalGetMutableC(); + case 4: + return internalGetMutableD(); + case 5: + return internalGetMutableE(); + case 6: + return internalGetMutableF(); + case 7: + return internalGetMutableG(); + case 8: + return internalGetMutableH(); + case 9: + return internalGetMutableI(); + case 10: + return internalGetMutableJ(); + default: + throw new RuntimeException( + "Invalid map field number: " + number); + } + } + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_MapObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + MapObject.class, Builder.class); + } + + // Construct using com.zfoo.protocol.field.packet.FieldProtobufObject.MapObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @Override + public Builder clear() { + super.clear(); + internalGetMutableA().clear(); + internalGetMutableB().clear(); + internalGetMutableC().clear(); + internalGetMutableD().clear(); + internalGetMutableE().clear(); + internalGetMutableF().clear(); + internalGetMutableG().clear(); + internalGetMutableH().clear(); + internalGetMutableI().clear(); + internalGetMutableJ().clear(); + return this; + } + + @Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return FieldProtobufObject.internal_static_MapObject_descriptor; + } + + @Override + public MapObject getDefaultInstanceForType() { + return MapObject.getDefaultInstance(); + } + + @Override + public MapObject build() { + MapObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @Override + public MapObject buildPartial() { + MapObject result = new MapObject(this); + int from_bitField0_ = bitField0_; + result.a_ = internalGetA(); + result.a_.makeImmutable(); + result.b_ = internalGetB(); + result.b_.makeImmutable(); + result.c_ = internalGetC(); + result.c_.makeImmutable(); + result.d_ = internalGetD(); + result.d_.makeImmutable(); + result.e_ = internalGetE(); + result.e_.makeImmutable(); + result.f_ = internalGetF(); + result.f_.makeImmutable(); + result.g_ = internalGetG(); + result.g_.makeImmutable(); + result.h_ = internalGetH(); + result.h_.makeImmutable(); + result.i_ = internalGetI(); + result.i_.makeImmutable(); + result.j_ = internalGetJ(); + result.j_.makeImmutable(); + onBuilt(); + return result; + } + + @Override + public Builder clone() { + return (Builder) super.clone(); + } + @Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + @Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + @Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + @Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + @Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + @Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof MapObject) { + return mergeFrom((MapObject)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(MapObject other) { + if (other == MapObject.getDefaultInstance()) return this; + internalGetMutableA().mergeFrom( + other.internalGetA()); + internalGetMutableB().mergeFrom( + other.internalGetB()); + internalGetMutableC().mergeFrom( + other.internalGetC()); + internalGetMutableD().mergeFrom( + other.internalGetD()); + internalGetMutableE().mergeFrom( + other.internalGetE()); + internalGetMutableF().mergeFrom( + other.internalGetF()); + internalGetMutableG().mergeFrom( + other.internalGetG()); + internalGetMutableH().mergeFrom( + other.internalGetH()); + internalGetMutableI().mergeFrom( + other.internalGetI()); + internalGetMutableJ().mergeFrom( + other.internalGetJ()); + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @Override + public final boolean isInitialized() { + return true; + } + + @Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + MapObject parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (MapObject) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.google.protobuf.MapField< + Integer, String> a_; + private com.google.protobuf.MapField + internalGetA() { + if (a_ == null) { + return com.google.protobuf.MapField.emptyMapField( + ADefaultEntryHolder.defaultEntry); + } + return a_; + } + private com.google.protobuf.MapField + internalGetMutableA() { + onChanged();; + if (a_ == null) { + a_ = com.google.protobuf.MapField.newMapField( + ADefaultEntryHolder.defaultEntry); + } + if (!a_.isMutable()) { + a_ = a_.copy(); + } + return a_; + } + + public int getACount() { + return internalGetA().getMap().size(); + } + /** + * map<int32, string> a = 1; + */ + + public boolean containsA( + int key) { + + return internalGetA().getMap().containsKey(key); + } + /** + * Use {@link #getAMap()} instead. + */ + @Deprecated + public java.util.Map getA() { + return getAMap(); + } + /** + * map<int32, string> a = 1; + */ + + public java.util.Map getAMap() { + return internalGetA().getMap(); + } + /** + * map<int32, string> a = 1; + */ + + public String getAOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetA().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> a = 1; + */ + + public String getAOrThrow( + int key) { + + java.util.Map map = + internalGetA().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearA() { + internalGetMutableA().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> a = 1; + */ + + public Builder removeA( + int key) { + + internalGetMutableA().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableA() { + return internalGetMutableA().getMutableMap(); + } + /** + * map<int32, string> a = 1; + */ + public Builder putA( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableA().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> a = 1; + */ + + public Builder putAllA( + java.util.Map values) { + internalGetMutableA().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> b_; + private com.google.protobuf.MapField + internalGetB() { + if (b_ == null) { + return com.google.protobuf.MapField.emptyMapField( + BDefaultEntryHolder.defaultEntry); + } + return b_; + } + private com.google.protobuf.MapField + internalGetMutableB() { + onChanged();; + if (b_ == null) { + b_ = com.google.protobuf.MapField.newMapField( + BDefaultEntryHolder.defaultEntry); + } + if (!b_.isMutable()) { + b_ = b_.copy(); + } + return b_; + } + + public int getBCount() { + return internalGetB().getMap().size(); + } + /** + * map<int32, string> b = 2; + */ + + public boolean containsB( + int key) { + + return internalGetB().getMap().containsKey(key); + } + /** + * Use {@link #getBMap()} instead. + */ + @Deprecated + public java.util.Map getB() { + return getBMap(); + } + /** + * map<int32, string> b = 2; + */ + + public java.util.Map getBMap() { + return internalGetB().getMap(); + } + /** + * map<int32, string> b = 2; + */ + + public String getBOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetB().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> b = 2; + */ + + public String getBOrThrow( + int key) { + + java.util.Map map = + internalGetB().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearB() { + internalGetMutableB().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> b = 2; + */ + + public Builder removeB( + int key) { + + internalGetMutableB().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableB() { + return internalGetMutableB().getMutableMap(); + } + /** + * map<int32, string> b = 2; + */ + public Builder putB( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableB().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> b = 2; + */ + + public Builder putAllB( + java.util.Map values) { + internalGetMutableB().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> c_; + private com.google.protobuf.MapField + internalGetC() { + if (c_ == null) { + return com.google.protobuf.MapField.emptyMapField( + CDefaultEntryHolder.defaultEntry); + } + return c_; + } + private com.google.protobuf.MapField + internalGetMutableC() { + onChanged();; + if (c_ == null) { + c_ = com.google.protobuf.MapField.newMapField( + CDefaultEntryHolder.defaultEntry); + } + if (!c_.isMutable()) { + c_ = c_.copy(); + } + return c_; + } + + public int getCCount() { + return internalGetC().getMap().size(); + } + /** + * map<int32, string> c = 3; + */ + + public boolean containsC( + int key) { + + return internalGetC().getMap().containsKey(key); + } + /** + * Use {@link #getCMap()} instead. + */ + @Deprecated + public java.util.Map getC() { + return getCMap(); + } + /** + * map<int32, string> c = 3; + */ + + public java.util.Map getCMap() { + return internalGetC().getMap(); + } + /** + * map<int32, string> c = 3; + */ + + public String getCOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetC().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> c = 3; + */ + + public String getCOrThrow( + int key) { + + java.util.Map map = + internalGetC().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearC() { + internalGetMutableC().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> c = 3; + */ + + public Builder removeC( + int key) { + + internalGetMutableC().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableC() { + return internalGetMutableC().getMutableMap(); + } + /** + * map<int32, string> c = 3; + */ + public Builder putC( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableC().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> c = 3; + */ + + public Builder putAllC( + java.util.Map values) { + internalGetMutableC().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> d_; + private com.google.protobuf.MapField + internalGetD() { + if (d_ == null) { + return com.google.protobuf.MapField.emptyMapField( + DDefaultEntryHolder.defaultEntry); + } + return d_; + } + private com.google.protobuf.MapField + internalGetMutableD() { + onChanged();; + if (d_ == null) { + d_ = com.google.protobuf.MapField.newMapField( + DDefaultEntryHolder.defaultEntry); + } + if (!d_.isMutable()) { + d_ = d_.copy(); + } + return d_; + } + + public int getDCount() { + return internalGetD().getMap().size(); + } + /** + * map<int32, string> d = 4; + */ + + public boolean containsD( + int key) { + + return internalGetD().getMap().containsKey(key); + } + /** + * Use {@link #getDMap()} instead. + */ + @Deprecated + public java.util.Map getD() { + return getDMap(); + } + /** + * map<int32, string> d = 4; + */ + + public java.util.Map getDMap() { + return internalGetD().getMap(); + } + /** + * map<int32, string> d = 4; + */ + + public String getDOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetD().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> d = 4; + */ + + public String getDOrThrow( + int key) { + + java.util.Map map = + internalGetD().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearD() { + internalGetMutableD().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> d = 4; + */ + + public Builder removeD( + int key) { + + internalGetMutableD().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableD() { + return internalGetMutableD().getMutableMap(); + } + /** + * map<int32, string> d = 4; + */ + public Builder putD( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableD().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> d = 4; + */ + + public Builder putAllD( + java.util.Map values) { + internalGetMutableD().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> e_; + private com.google.protobuf.MapField + internalGetE() { + if (e_ == null) { + return com.google.protobuf.MapField.emptyMapField( + EDefaultEntryHolder.defaultEntry); + } + return e_; + } + private com.google.protobuf.MapField + internalGetMutableE() { + onChanged();; + if (e_ == null) { + e_ = com.google.protobuf.MapField.newMapField( + EDefaultEntryHolder.defaultEntry); + } + if (!e_.isMutable()) { + e_ = e_.copy(); + } + return e_; + } + + public int getECount() { + return internalGetE().getMap().size(); + } + /** + * map<int32, string> e = 5; + */ + + public boolean containsE( + int key) { + + return internalGetE().getMap().containsKey(key); + } + /** + * Use {@link #getEMap()} instead. + */ + @Deprecated + public java.util.Map getE() { + return getEMap(); + } + /** + * map<int32, string> e = 5; + */ + + public java.util.Map getEMap() { + return internalGetE().getMap(); + } + /** + * map<int32, string> e = 5; + */ + + public String getEOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetE().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> e = 5; + */ + + public String getEOrThrow( + int key) { + + java.util.Map map = + internalGetE().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearE() { + internalGetMutableE().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> e = 5; + */ + + public Builder removeE( + int key) { + + internalGetMutableE().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableE() { + return internalGetMutableE().getMutableMap(); + } + /** + * map<int32, string> e = 5; + */ + public Builder putE( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableE().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> e = 5; + */ + + public Builder putAllE( + java.util.Map values) { + internalGetMutableE().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> f_; + private com.google.protobuf.MapField + internalGetF() { + if (f_ == null) { + return com.google.protobuf.MapField.emptyMapField( + FDefaultEntryHolder.defaultEntry); + } + return f_; + } + private com.google.protobuf.MapField + internalGetMutableF() { + onChanged();; + if (f_ == null) { + f_ = com.google.protobuf.MapField.newMapField( + FDefaultEntryHolder.defaultEntry); + } + if (!f_.isMutable()) { + f_ = f_.copy(); + } + return f_; + } + + public int getFCount() { + return internalGetF().getMap().size(); + } + /** + * map<int32, string> f = 6; + */ + + public boolean containsF( + int key) { + + return internalGetF().getMap().containsKey(key); + } + /** + * Use {@link #getFMap()} instead. + */ + @Deprecated + public java.util.Map getF() { + return getFMap(); + } + /** + * map<int32, string> f = 6; + */ + + public java.util.Map getFMap() { + return internalGetF().getMap(); + } + /** + * map<int32, string> f = 6; + */ + + public String getFOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetF().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> f = 6; + */ + + public String getFOrThrow( + int key) { + + java.util.Map map = + internalGetF().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearF() { + internalGetMutableF().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> f = 6; + */ + + public Builder removeF( + int key) { + + internalGetMutableF().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableF() { + return internalGetMutableF().getMutableMap(); + } + /** + * map<int32, string> f = 6; + */ + public Builder putF( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableF().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> f = 6; + */ + + public Builder putAllF( + java.util.Map values) { + internalGetMutableF().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> g_; + private com.google.protobuf.MapField + internalGetG() { + if (g_ == null) { + return com.google.protobuf.MapField.emptyMapField( + GDefaultEntryHolder.defaultEntry); + } + return g_; + } + private com.google.protobuf.MapField + internalGetMutableG() { + onChanged();; + if (g_ == null) { + g_ = com.google.protobuf.MapField.newMapField( + GDefaultEntryHolder.defaultEntry); + } + if (!g_.isMutable()) { + g_ = g_.copy(); + } + return g_; + } + + public int getGCount() { + return internalGetG().getMap().size(); + } + /** + * map<int32, string> g = 7; + */ + + public boolean containsG( + int key) { + + return internalGetG().getMap().containsKey(key); + } + /** + * Use {@link #getGMap()} instead. + */ + @Deprecated + public java.util.Map getG() { + return getGMap(); + } + /** + * map<int32, string> g = 7; + */ + + public java.util.Map getGMap() { + return internalGetG().getMap(); + } + /** + * map<int32, string> g = 7; + */ + + public String getGOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetG().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> g = 7; + */ + + public String getGOrThrow( + int key) { + + java.util.Map map = + internalGetG().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearG() { + internalGetMutableG().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> g = 7; + */ + + public Builder removeG( + int key) { + + internalGetMutableG().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableG() { + return internalGetMutableG().getMutableMap(); + } + /** + * map<int32, string> g = 7; + */ + public Builder putG( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableG().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> g = 7; + */ + + public Builder putAllG( + java.util.Map values) { + internalGetMutableG().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> h_; + private com.google.protobuf.MapField + internalGetH() { + if (h_ == null) { + return com.google.protobuf.MapField.emptyMapField( + HDefaultEntryHolder.defaultEntry); + } + return h_; + } + private com.google.protobuf.MapField + internalGetMutableH() { + onChanged();; + if (h_ == null) { + h_ = com.google.protobuf.MapField.newMapField( + HDefaultEntryHolder.defaultEntry); + } + if (!h_.isMutable()) { + h_ = h_.copy(); + } + return h_; + } + + public int getHCount() { + return internalGetH().getMap().size(); + } + /** + * map<int32, string> h = 8; + */ + + public boolean containsH( + int key) { + + return internalGetH().getMap().containsKey(key); + } + /** + * Use {@link #getHMap()} instead. + */ + @Deprecated + public java.util.Map getH() { + return getHMap(); + } + /** + * map<int32, string> h = 8; + */ + + public java.util.Map getHMap() { + return internalGetH().getMap(); + } + /** + * map<int32, string> h = 8; + */ + + public String getHOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetH().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> h = 8; + */ + + public String getHOrThrow( + int key) { + + java.util.Map map = + internalGetH().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearH() { + internalGetMutableH().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> h = 8; + */ + + public Builder removeH( + int key) { + + internalGetMutableH().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableH() { + return internalGetMutableH().getMutableMap(); + } + /** + * map<int32, string> h = 8; + */ + public Builder putH( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableH().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> h = 8; + */ + + public Builder putAllH( + java.util.Map values) { + internalGetMutableH().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> i_; + private com.google.protobuf.MapField + internalGetI() { + if (i_ == null) { + return com.google.protobuf.MapField.emptyMapField( + IDefaultEntryHolder.defaultEntry); + } + return i_; + } + private com.google.protobuf.MapField + internalGetMutableI() { + onChanged();; + if (i_ == null) { + i_ = com.google.protobuf.MapField.newMapField( + IDefaultEntryHolder.defaultEntry); + } + if (!i_.isMutable()) { + i_ = i_.copy(); + } + return i_; + } + + public int getICount() { + return internalGetI().getMap().size(); + } + /** + * map<int32, string> i = 9; + */ + + public boolean containsI( + int key) { + + return internalGetI().getMap().containsKey(key); + } + /** + * Use {@link #getIMap()} instead. + */ + @Deprecated + public java.util.Map getI() { + return getIMap(); + } + /** + * map<int32, string> i = 9; + */ + + public java.util.Map getIMap() { + return internalGetI().getMap(); + } + /** + * map<int32, string> i = 9; + */ + + public String getIOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetI().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> i = 9; + */ + + public String getIOrThrow( + int key) { + + java.util.Map map = + internalGetI().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearI() { + internalGetMutableI().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> i = 9; + */ + + public Builder removeI( + int key) { + + internalGetMutableI().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableI() { + return internalGetMutableI().getMutableMap(); + } + /** + * map<int32, string> i = 9; + */ + public Builder putI( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableI().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> i = 9; + */ + + public Builder putAllI( + java.util.Map values) { + internalGetMutableI().getMutableMap() + .putAll(values); + return this; + } + + private com.google.protobuf.MapField< + Integer, String> j_; + private com.google.protobuf.MapField + internalGetJ() { + if (j_ == null) { + return com.google.protobuf.MapField.emptyMapField( + JDefaultEntryHolder.defaultEntry); + } + return j_; + } + private com.google.protobuf.MapField + internalGetMutableJ() { + onChanged();; + if (j_ == null) { + j_ = com.google.protobuf.MapField.newMapField( + JDefaultEntryHolder.defaultEntry); + } + if (!j_.isMutable()) { + j_ = j_.copy(); + } + return j_; + } + + public int getJCount() { + return internalGetJ().getMap().size(); + } + /** + * map<int32, string> j = 10; + */ + + public boolean containsJ( + int key) { + + return internalGetJ().getMap().containsKey(key); + } + /** + * Use {@link #getJMap()} instead. + */ + @Deprecated + public java.util.Map getJ() { + return getJMap(); + } + /** + * map<int32, string> j = 10; + */ + + public java.util.Map getJMap() { + return internalGetJ().getMap(); + } + /** + * map<int32, string> j = 10; + */ + + public String getJOrDefault( + int key, + String defaultValue) { + + java.util.Map map = + internalGetJ().getMap(); + return map.containsKey(key) ? map.get(key) : defaultValue; + } + /** + * map<int32, string> j = 10; + */ + + public String getJOrThrow( + int key) { + + java.util.Map map = + internalGetJ().getMap(); + if (!map.containsKey(key)) { + throw new IllegalArgumentException(); + } + return map.get(key); + } + + public Builder clearJ() { + internalGetMutableJ().getMutableMap() + .clear(); + return this; + } + /** + * map<int32, string> j = 10; + */ + + public Builder removeJ( + int key) { + + internalGetMutableJ().getMutableMap() + .remove(key); + return this; + } + /** + * Use alternate mutation accessors instead. + */ + @Deprecated + public java.util.Map + getMutableJ() { + return internalGetMutableJ().getMutableMap(); + } + /** + * map<int32, string> j = 10; + */ + public Builder putJ( + int key, + String value) { + + if (value == null) { throw new NullPointerException(); } + internalGetMutableJ().getMutableMap() + .put(key, value); + return this; + } + /** + * map<int32, string> j = 10; + */ + + public Builder putAllJ( + java.util.Map values) { + internalGetMutableJ().getMutableMap() + .putAll(values); + return this; + } + @Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + @Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:MapObject) + } + + // @@protoc_insertion_point(class_scope:MapObject) + private static final MapObject DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new MapObject(); + } + + public static MapObject getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @Override + public MapObject parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new MapObject(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @Override + public MapObject getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface InnerObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:InnerObject) + com.google.protobuf.MessageOrBuilder { + + /** + * int32 x = 1; + */ + int getX(); + } + /** + * Protobuf type {@code InnerObject} + */ + public static final class InnerObject extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:InnerObject) + InnerObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use InnerObject.newBuilder() to construct. + private InnerObject(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private InnerObject() { + x_ = 0; + } + + @Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private InnerObject( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + + x_ = input.readInt32(); + break; + } + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_InnerObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_InnerObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + InnerObject.class, Builder.class); + } + + public static final int X_FIELD_NUMBER = 1; + private int x_; + /** + * int32 x = 1; + */ + public int getX() { + return x_; + } + + private byte memoizedIsInitialized = -1; + @Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (x_ != 0) { + output.writeInt32(1, x_); + } + unknownFields.writeTo(output); + } + + @Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (x_ != 0) { + size += com.google.protobuf.CodedOutputStream + .computeInt32Size(1, x_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof InnerObject)) { + return super.equals(obj); + } + InnerObject other = (InnerObject) obj; + + boolean result = true; + result = result && (getX() + == other.getX()); + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + X_FIELD_NUMBER; + hash = (53 * hash) + getX(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static InnerObject parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static InnerObject parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static InnerObject parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static InnerObject parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static InnerObject parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static InnerObject parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static InnerObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static InnerObject parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static InnerObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static InnerObject parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static InnerObject parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static InnerObject parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(InnerObject prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @Override + protected Builder newBuilderForType( + BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code InnerObject} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:InnerObject) + InnerObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_InnerObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_InnerObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + InnerObject.class, Builder.class); + } + + // Construct using com.zfoo.protocol.field.packet.FieldProtobufObject.InnerObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @Override + public Builder clear() { + super.clear(); + x_ = 0; + + return this; + } + + @Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return FieldProtobufObject.internal_static_InnerObject_descriptor; + } + + @Override + public InnerObject getDefaultInstanceForType() { + return InnerObject.getDefaultInstance(); + } + + @Override + public InnerObject build() { + InnerObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @Override + public InnerObject buildPartial() { + InnerObject result = new InnerObject(this); + result.x_ = x_; + onBuilt(); + return result; + } + + @Override + public Builder clone() { + return (Builder) super.clone(); + } + @Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + @Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + @Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + @Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + @Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + @Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof InnerObject) { + return mergeFrom((InnerObject)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(InnerObject other) { + if (other == InnerObject.getDefaultInstance()) return this; + if (other.getX() != 0) { + setX(other.getX()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @Override + public final boolean isInitialized() { + return true; + } + + @Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + InnerObject parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (InnerObject) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private int x_ ; + /** + * int32 x = 1; + */ + public int getX() { + return x_; + } + /** + * int32 x = 1; + */ + public Builder setX(int value) { + + x_ = value; + onChanged(); + return this; + } + /** + * int32 x = 1; + */ + public Builder clearX() { + + x_ = 0; + onChanged(); + return this; + } + @Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + @Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:InnerObject) + } + + // @@protoc_insertion_point(class_scope:InnerObject) + private static final InnerObject DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new InnerObject(); + } + + public static InnerObject getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @Override + public InnerObject parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new InnerObject(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @Override + public InnerObject getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface InnerObjectObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:InnerObjectObject) + com.google.protobuf.MessageOrBuilder { + + /** + * .InnerObject a = 1; + */ + boolean hasA(); + /** + * .InnerObject a = 1; + */ + InnerObject getA(); + /** + * .InnerObject a = 1; + */ + InnerObjectOrBuilder getAOrBuilder(); + + /** + * .InnerObject b = 2; + */ + boolean hasB(); + /** + * .InnerObject b = 2; + */ + InnerObject getB(); + /** + * .InnerObject b = 2; + */ + InnerObjectOrBuilder getBOrBuilder(); + + /** + * .InnerObject c = 3; + */ + boolean hasC(); + /** + * .InnerObject c = 3; + */ + InnerObject getC(); + /** + * .InnerObject c = 3; + */ + InnerObjectOrBuilder getCOrBuilder(); + + /** + * .InnerObject d = 4; + */ + boolean hasD(); + /** + * .InnerObject d = 4; + */ + InnerObject getD(); + /** + * .InnerObject d = 4; + */ + InnerObjectOrBuilder getDOrBuilder(); + + /** + * .InnerObject e = 5; + */ + boolean hasE(); + /** + * .InnerObject e = 5; + */ + InnerObject getE(); + /** + * .InnerObject e = 5; + */ + InnerObjectOrBuilder getEOrBuilder(); + + /** + * .InnerObject f = 6; + */ + boolean hasF(); + /** + * .InnerObject f = 6; + */ + InnerObject getF(); + /** + * .InnerObject f = 6; + */ + InnerObjectOrBuilder getFOrBuilder(); + + /** + * .InnerObject g = 7; + */ + boolean hasG(); + /** + * .InnerObject g = 7; + */ + InnerObject getG(); + /** + * .InnerObject g = 7; + */ + InnerObjectOrBuilder getGOrBuilder(); + + /** + * .InnerObject h = 8; + */ + boolean hasH(); + /** + * .InnerObject h = 8; + */ + InnerObject getH(); + /** + * .InnerObject h = 8; + */ + InnerObjectOrBuilder getHOrBuilder(); + + /** + * .InnerObject i = 9; + */ + boolean hasI(); + /** + * .InnerObject i = 9; + */ + InnerObject getI(); + /** + * .InnerObject i = 9; + */ + InnerObjectOrBuilder getIOrBuilder(); + + /** + * .InnerObject j = 10; + */ + boolean hasJ(); + /** + * .InnerObject j = 10; + */ + InnerObject getJ(); + /** + * .InnerObject j = 10; + */ + InnerObjectOrBuilder getJOrBuilder(); + } + /** + * Protobuf type {@code InnerObjectObject} + */ + public static final class InnerObjectObject extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:InnerObjectObject) + InnerObjectObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use InnerObjectObject.newBuilder() to construct. + private InnerObjectObject(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private InnerObjectObject() { + } + + @Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private InnerObjectObject( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + InnerObject.Builder subBuilder = null; + if (a_ != null) { + subBuilder = a_.toBuilder(); + } + a_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(a_); + a_ = subBuilder.buildPartial(); + } + + break; + } + case 18: { + InnerObject.Builder subBuilder = null; + if (b_ != null) { + subBuilder = b_.toBuilder(); + } + b_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(b_); + b_ = subBuilder.buildPartial(); + } + + break; + } + case 26: { + InnerObject.Builder subBuilder = null; + if (c_ != null) { + subBuilder = c_.toBuilder(); + } + c_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(c_); + c_ = subBuilder.buildPartial(); + } + + break; + } + case 34: { + InnerObject.Builder subBuilder = null; + if (d_ != null) { + subBuilder = d_.toBuilder(); + } + d_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(d_); + d_ = subBuilder.buildPartial(); + } + + break; + } + case 42: { + InnerObject.Builder subBuilder = null; + if (e_ != null) { + subBuilder = e_.toBuilder(); + } + e_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(e_); + e_ = subBuilder.buildPartial(); + } + + break; + } + case 50: { + InnerObject.Builder subBuilder = null; + if (f_ != null) { + subBuilder = f_.toBuilder(); + } + f_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(f_); + f_ = subBuilder.buildPartial(); + } + + break; + } + case 58: { + InnerObject.Builder subBuilder = null; + if (g_ != null) { + subBuilder = g_.toBuilder(); + } + g_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(g_); + g_ = subBuilder.buildPartial(); + } + + break; + } + case 66: { + InnerObject.Builder subBuilder = null; + if (h_ != null) { + subBuilder = h_.toBuilder(); + } + h_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(h_); + h_ = subBuilder.buildPartial(); + } + + break; + } + case 74: { + InnerObject.Builder subBuilder = null; + if (i_ != null) { + subBuilder = i_.toBuilder(); + } + i_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(i_); + i_ = subBuilder.buildPartial(); + } + + break; + } + case 82: { + InnerObject.Builder subBuilder = null; + if (j_ != null) { + subBuilder = j_.toBuilder(); + } + j_ = input.readMessage(InnerObject.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(j_); + j_ = subBuilder.buildPartial(); + } + + break; + } + default: { + if (!parseUnknownFieldProto3( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_InnerObjectObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_InnerObjectObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + InnerObjectObject.class, Builder.class); + } + + public static final int A_FIELD_NUMBER = 1; + private InnerObject a_; + /** + * .InnerObject a = 1; + */ + public boolean hasA() { + return a_ != null; + } + /** + * .InnerObject a = 1; + */ + public InnerObject getA() { + return a_ == null ? InnerObject.getDefaultInstance() : a_; + } + /** + * .InnerObject a = 1; + */ + public InnerObjectOrBuilder getAOrBuilder() { + return getA(); + } + + public static final int B_FIELD_NUMBER = 2; + private InnerObject b_; + /** + * .InnerObject b = 2; + */ + public boolean hasB() { + return b_ != null; + } + /** + * .InnerObject b = 2; + */ + public InnerObject getB() { + return b_ == null ? InnerObject.getDefaultInstance() : b_; + } + /** + * .InnerObject b = 2; + */ + public InnerObjectOrBuilder getBOrBuilder() { + return getB(); + } + + public static final int C_FIELD_NUMBER = 3; + private InnerObject c_; + /** + * .InnerObject c = 3; + */ + public boolean hasC() { + return c_ != null; + } + /** + * .InnerObject c = 3; + */ + public InnerObject getC() { + return c_ == null ? InnerObject.getDefaultInstance() : c_; + } + /** + * .InnerObject c = 3; + */ + public InnerObjectOrBuilder getCOrBuilder() { + return getC(); + } + + public static final int D_FIELD_NUMBER = 4; + private InnerObject d_; + /** + * .InnerObject d = 4; + */ + public boolean hasD() { + return d_ != null; + } + /** + * .InnerObject d = 4; + */ + public InnerObject getD() { + return d_ == null ? InnerObject.getDefaultInstance() : d_; + } + /** + * .InnerObject d = 4; + */ + public InnerObjectOrBuilder getDOrBuilder() { + return getD(); + } + + public static final int E_FIELD_NUMBER = 5; + private InnerObject e_; + /** + * .InnerObject e = 5; + */ + public boolean hasE() { + return e_ != null; + } + /** + * .InnerObject e = 5; + */ + public InnerObject getE() { + return e_ == null ? InnerObject.getDefaultInstance() : e_; + } + /** + * .InnerObject e = 5; + */ + public InnerObjectOrBuilder getEOrBuilder() { + return getE(); + } + + public static final int F_FIELD_NUMBER = 6; + private InnerObject f_; + /** + * .InnerObject f = 6; + */ + public boolean hasF() { + return f_ != null; + } + /** + * .InnerObject f = 6; + */ + public InnerObject getF() { + return f_ == null ? InnerObject.getDefaultInstance() : f_; + } + /** + * .InnerObject f = 6; + */ + public InnerObjectOrBuilder getFOrBuilder() { + return getF(); + } + + public static final int G_FIELD_NUMBER = 7; + private InnerObject g_; + /** + * .InnerObject g = 7; + */ + public boolean hasG() { + return g_ != null; + } + /** + * .InnerObject g = 7; + */ + public InnerObject getG() { + return g_ == null ? InnerObject.getDefaultInstance() : g_; + } + /** + * .InnerObject g = 7; + */ + public InnerObjectOrBuilder getGOrBuilder() { + return getG(); + } + + public static final int H_FIELD_NUMBER = 8; + private InnerObject h_; + /** + * .InnerObject h = 8; + */ + public boolean hasH() { + return h_ != null; + } + /** + * .InnerObject h = 8; + */ + public InnerObject getH() { + return h_ == null ? InnerObject.getDefaultInstance() : h_; + } + /** + * .InnerObject h = 8; + */ + public InnerObjectOrBuilder getHOrBuilder() { + return getH(); + } + + public static final int I_FIELD_NUMBER = 9; + private InnerObject i_; + /** + * .InnerObject i = 9; + */ + public boolean hasI() { + return i_ != null; + } + /** + * .InnerObject i = 9; + */ + public InnerObject getI() { + return i_ == null ? InnerObject.getDefaultInstance() : i_; + } + /** + * .InnerObject i = 9; + */ + public InnerObjectOrBuilder getIOrBuilder() { + return getI(); + } + + public static final int J_FIELD_NUMBER = 10; + private InnerObject j_; + /** + * .InnerObject j = 10; + */ + public boolean hasJ() { + return j_ != null; + } + /** + * .InnerObject j = 10; + */ + public InnerObject getJ() { + return j_ == null ? InnerObject.getDefaultInstance() : j_; + } + /** + * .InnerObject j = 10; + */ + public InnerObjectOrBuilder getJOrBuilder() { + return getJ(); + } + + private byte memoizedIsInitialized = -1; + @Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (a_ != null) { + output.writeMessage(1, getA()); + } + if (b_ != null) { + output.writeMessage(2, getB()); + } + if (c_ != null) { + output.writeMessage(3, getC()); + } + if (d_ != null) { + output.writeMessage(4, getD()); + } + if (e_ != null) { + output.writeMessage(5, getE()); + } + if (f_ != null) { + output.writeMessage(6, getF()); + } + if (g_ != null) { + output.writeMessage(7, getG()); + } + if (h_ != null) { + output.writeMessage(8, getH()); + } + if (i_ != null) { + output.writeMessage(9, getI()); + } + if (j_ != null) { + output.writeMessage(10, getJ()); + } + unknownFields.writeTo(output); + } + + @Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (a_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getA()); + } + if (b_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getB()); + } + if (c_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getC()); + } + if (d_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getD()); + } + if (e_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, getE()); + } + if (f_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, getF()); + } + if (g_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, getG()); + } + if (h_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, getH()); + } + if (i_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, getI()); + } + if (j_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(10, getJ()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @Override + public boolean equals(final Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof InnerObjectObject)) { + return super.equals(obj); + } + InnerObjectObject other = (InnerObjectObject) obj; + + boolean result = true; + result = result && (hasA() == other.hasA()); + if (hasA()) { + result = result && getA() + .equals(other.getA()); + } + result = result && (hasB() == other.hasB()); + if (hasB()) { + result = result && getB() + .equals(other.getB()); + } + result = result && (hasC() == other.hasC()); + if (hasC()) { + result = result && getC() + .equals(other.getC()); + } + result = result && (hasD() == other.hasD()); + if (hasD()) { + result = result && getD() + .equals(other.getD()); + } + result = result && (hasE() == other.hasE()); + if (hasE()) { + result = result && getE() + .equals(other.getE()); + } + result = result && (hasF() == other.hasF()); + if (hasF()) { + result = result && getF() + .equals(other.getF()); + } + result = result && (hasG() == other.hasG()); + if (hasG()) { + result = result && getG() + .equals(other.getG()); + } + result = result && (hasH() == other.hasH()); + if (hasH()) { + result = result && getH() + .equals(other.getH()); + } + result = result && (hasI() == other.hasI()); + if (hasI()) { + result = result && getI() + .equals(other.getI()); + } + result = result && (hasJ() == other.hasJ()); + if (hasJ()) { + result = result && getJ() + .equals(other.getJ()); + } + result = result && unknownFields.equals(other.unknownFields); + return result; + } + + @Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasA()) { + hash = (37 * hash) + A_FIELD_NUMBER; + hash = (53 * hash) + getA().hashCode(); + } + if (hasB()) { + hash = (37 * hash) + B_FIELD_NUMBER; + hash = (53 * hash) + getB().hashCode(); + } + if (hasC()) { + hash = (37 * hash) + C_FIELD_NUMBER; + hash = (53 * hash) + getC().hashCode(); + } + if (hasD()) { + hash = (37 * hash) + D_FIELD_NUMBER; + hash = (53 * hash) + getD().hashCode(); + } + if (hasE()) { + hash = (37 * hash) + E_FIELD_NUMBER; + hash = (53 * hash) + getE().hashCode(); + } + if (hasF()) { + hash = (37 * hash) + F_FIELD_NUMBER; + hash = (53 * hash) + getF().hashCode(); + } + if (hasG()) { + hash = (37 * hash) + G_FIELD_NUMBER; + hash = (53 * hash) + getG().hashCode(); + } + if (hasH()) { + hash = (37 * hash) + H_FIELD_NUMBER; + hash = (53 * hash) + getH().hashCode(); + } + if (hasI()) { + hash = (37 * hash) + I_FIELD_NUMBER; + hash = (53 * hash) + getI().hashCode(); + } + if (hasJ()) { + hash = (37 * hash) + J_FIELD_NUMBER; + hash = (53 * hash) + getJ().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static InnerObjectObject parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static InnerObjectObject parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static InnerObjectObject parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static InnerObjectObject parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static InnerObjectObject parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static InnerObjectObject parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static InnerObjectObject parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static InnerObjectObject parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static InnerObjectObject parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static InnerObjectObject parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static InnerObjectObject parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static InnerObjectObject parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(InnerObjectObject prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @Override + protected Builder newBuilderForType( + BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code InnerObjectObject} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:InnerObjectObject) + InnerObjectObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return FieldProtobufObject.internal_static_InnerObjectObject_descriptor; + } + + @Override + protected FieldAccessorTable + internalGetFieldAccessorTable() { + return FieldProtobufObject.internal_static_InnerObjectObject_fieldAccessorTable + .ensureFieldAccessorsInitialized( + InnerObjectObject.class, Builder.class); + } + + // Construct using com.zfoo.protocol.field.packet.FieldProtobufObject.InnerObjectObject.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @Override + public Builder clear() { + super.clear(); + if (aBuilder_ == null) { + a_ = null; + } else { + a_ = null; + aBuilder_ = null; + } + if (bBuilder_ == null) { + b_ = null; + } else { + b_ = null; + bBuilder_ = null; + } + if (cBuilder_ == null) { + c_ = null; + } else { + c_ = null; + cBuilder_ = null; + } + if (dBuilder_ == null) { + d_ = null; + } else { + d_ = null; + dBuilder_ = null; + } + if (eBuilder_ == null) { + e_ = null; + } else { + e_ = null; + eBuilder_ = null; + } + if (fBuilder_ == null) { + f_ = null; + } else { + f_ = null; + fBuilder_ = null; + } + if (gBuilder_ == null) { + g_ = null; + } else { + g_ = null; + gBuilder_ = null; + } + if (hBuilder_ == null) { + h_ = null; + } else { + h_ = null; + hBuilder_ = null; + } + if (iBuilder_ == null) { + i_ = null; + } else { + i_ = null; + iBuilder_ = null; + } + if (jBuilder_ == null) { + j_ = null; + } else { + j_ = null; + jBuilder_ = null; + } + return this; + } + + @Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return FieldProtobufObject.internal_static_InnerObjectObject_descriptor; + } + + @Override + public InnerObjectObject getDefaultInstanceForType() { + return InnerObjectObject.getDefaultInstance(); + } + + @Override + public InnerObjectObject build() { + InnerObjectObject result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @Override + public InnerObjectObject buildPartial() { + InnerObjectObject result = new InnerObjectObject(this); + if (aBuilder_ == null) { + result.a_ = a_; + } else { + result.a_ = aBuilder_.build(); + } + if (bBuilder_ == null) { + result.b_ = b_; + } else { + result.b_ = bBuilder_.build(); + } + if (cBuilder_ == null) { + result.c_ = c_; + } else { + result.c_ = cBuilder_.build(); + } + if (dBuilder_ == null) { + result.d_ = d_; + } else { + result.d_ = dBuilder_.build(); + } + if (eBuilder_ == null) { + result.e_ = e_; + } else { + result.e_ = eBuilder_.build(); + } + if (fBuilder_ == null) { + result.f_ = f_; + } else { + result.f_ = fBuilder_.build(); + } + if (gBuilder_ == null) { + result.g_ = g_; + } else { + result.g_ = gBuilder_.build(); + } + if (hBuilder_ == null) { + result.h_ = h_; + } else { + result.h_ = hBuilder_.build(); + } + if (iBuilder_ == null) { + result.i_ = i_; + } else { + result.i_ = iBuilder_.build(); + } + if (jBuilder_ == null) { + result.j_ = j_; + } else { + result.j_ = jBuilder_.build(); + } + onBuilt(); + return result; + } + + @Override + public Builder clone() { + return (Builder) super.clone(); + } + @Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.setField(field, value); + } + @Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return (Builder) super.clearField(field); + } + @Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return (Builder) super.clearOneof(oneof); + } + @Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, Object value) { + return (Builder) super.setRepeatedField(field, index, value); + } + @Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + Object value) { + return (Builder) super.addRepeatedField(field, value); + } + @Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof InnerObjectObject) { + return mergeFrom((InnerObjectObject)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(InnerObjectObject other) { + if (other == InnerObjectObject.getDefaultInstance()) return this; + if (other.hasA()) { + mergeA(other.getA()); + } + if (other.hasB()) { + mergeB(other.getB()); + } + if (other.hasC()) { + mergeC(other.getC()); + } + if (other.hasD()) { + mergeD(other.getD()); + } + if (other.hasE()) { + mergeE(other.getE()); + } + if (other.hasF()) { + mergeF(other.getF()); + } + if (other.hasG()) { + mergeG(other.getG()); + } + if (other.hasH()) { + mergeH(other.getH()); + } + if (other.hasI()) { + mergeI(other.getI()); + } + if (other.hasJ()) { + mergeJ(other.getJ()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @Override + public final boolean isInitialized() { + return true; + } + + @Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + InnerObjectObject parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (InnerObjectObject) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private InnerObject a_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> aBuilder_; + /** + * .InnerObject a = 1; + */ + public boolean hasA() { + return aBuilder_ != null || a_ != null; + } + /** + * .InnerObject a = 1; + */ + public InnerObject getA() { + if (aBuilder_ == null) { + return a_ == null ? InnerObject.getDefaultInstance() : a_; + } else { + return aBuilder_.getMessage(); + } + } + /** + * .InnerObject a = 1; + */ + public Builder setA(InnerObject value) { + if (aBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + a_ = value; + onChanged(); + } else { + aBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject a = 1; + */ + public Builder setA( + InnerObject.Builder builderForValue) { + if (aBuilder_ == null) { + a_ = builderForValue.build(); + onChanged(); + } else { + aBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject a = 1; + */ + public Builder mergeA(InnerObject value) { + if (aBuilder_ == null) { + if (a_ != null) { + a_ = + InnerObject.newBuilder(a_).mergeFrom(value).buildPartial(); + } else { + a_ = value; + } + onChanged(); + } else { + aBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject a = 1; + */ + public Builder clearA() { + if (aBuilder_ == null) { + a_ = null; + onChanged(); + } else { + a_ = null; + aBuilder_ = null; + } + + return this; + } + /** + * .InnerObject a = 1; + */ + public InnerObject.Builder getABuilder() { + + onChanged(); + return getAFieldBuilder().getBuilder(); + } + /** + * .InnerObject a = 1; + */ + public InnerObjectOrBuilder getAOrBuilder() { + if (aBuilder_ != null) { + return aBuilder_.getMessageOrBuilder(); + } else { + return a_ == null ? + InnerObject.getDefaultInstance() : a_; + } + } + /** + * .InnerObject a = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getAFieldBuilder() { + if (aBuilder_ == null) { + aBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getA(), + getParentForChildren(), + isClean()); + a_ = null; + } + return aBuilder_; + } + + private InnerObject b_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> bBuilder_; + /** + * .InnerObject b = 2; + */ + public boolean hasB() { + return bBuilder_ != null || b_ != null; + } + /** + * .InnerObject b = 2; + */ + public InnerObject getB() { + if (bBuilder_ == null) { + return b_ == null ? InnerObject.getDefaultInstance() : b_; + } else { + return bBuilder_.getMessage(); + } + } + /** + * .InnerObject b = 2; + */ + public Builder setB(InnerObject value) { + if (bBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + b_ = value; + onChanged(); + } else { + bBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject b = 2; + */ + public Builder setB( + InnerObject.Builder builderForValue) { + if (bBuilder_ == null) { + b_ = builderForValue.build(); + onChanged(); + } else { + bBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject b = 2; + */ + public Builder mergeB(InnerObject value) { + if (bBuilder_ == null) { + if (b_ != null) { + b_ = + InnerObject.newBuilder(b_).mergeFrom(value).buildPartial(); + } else { + b_ = value; + } + onChanged(); + } else { + bBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject b = 2; + */ + public Builder clearB() { + if (bBuilder_ == null) { + b_ = null; + onChanged(); + } else { + b_ = null; + bBuilder_ = null; + } + + return this; + } + /** + * .InnerObject b = 2; + */ + public InnerObject.Builder getBBuilder() { + + onChanged(); + return getBFieldBuilder().getBuilder(); + } + /** + * .InnerObject b = 2; + */ + public InnerObjectOrBuilder getBOrBuilder() { + if (bBuilder_ != null) { + return bBuilder_.getMessageOrBuilder(); + } else { + return b_ == null ? + InnerObject.getDefaultInstance() : b_; + } + } + /** + * .InnerObject b = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getBFieldBuilder() { + if (bBuilder_ == null) { + bBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getB(), + getParentForChildren(), + isClean()); + b_ = null; + } + return bBuilder_; + } + + private InnerObject c_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> cBuilder_; + /** + * .InnerObject c = 3; + */ + public boolean hasC() { + return cBuilder_ != null || c_ != null; + } + /** + * .InnerObject c = 3; + */ + public InnerObject getC() { + if (cBuilder_ == null) { + return c_ == null ? InnerObject.getDefaultInstance() : c_; + } else { + return cBuilder_.getMessage(); + } + } + /** + * .InnerObject c = 3; + */ + public Builder setC(InnerObject value) { + if (cBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + c_ = value; + onChanged(); + } else { + cBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject c = 3; + */ + public Builder setC( + InnerObject.Builder builderForValue) { + if (cBuilder_ == null) { + c_ = builderForValue.build(); + onChanged(); + } else { + cBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject c = 3; + */ + public Builder mergeC(InnerObject value) { + if (cBuilder_ == null) { + if (c_ != null) { + c_ = + InnerObject.newBuilder(c_).mergeFrom(value).buildPartial(); + } else { + c_ = value; + } + onChanged(); + } else { + cBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject c = 3; + */ + public Builder clearC() { + if (cBuilder_ == null) { + c_ = null; + onChanged(); + } else { + c_ = null; + cBuilder_ = null; + } + + return this; + } + /** + * .InnerObject c = 3; + */ + public InnerObject.Builder getCBuilder() { + + onChanged(); + return getCFieldBuilder().getBuilder(); + } + /** + * .InnerObject c = 3; + */ + public InnerObjectOrBuilder getCOrBuilder() { + if (cBuilder_ != null) { + return cBuilder_.getMessageOrBuilder(); + } else { + return c_ == null ? + InnerObject.getDefaultInstance() : c_; + } + } + /** + * .InnerObject c = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getCFieldBuilder() { + if (cBuilder_ == null) { + cBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getC(), + getParentForChildren(), + isClean()); + c_ = null; + } + return cBuilder_; + } + + private InnerObject d_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> dBuilder_; + /** + * .InnerObject d = 4; + */ + public boolean hasD() { + return dBuilder_ != null || d_ != null; + } + /** + * .InnerObject d = 4; + */ + public InnerObject getD() { + if (dBuilder_ == null) { + return d_ == null ? InnerObject.getDefaultInstance() : d_; + } else { + return dBuilder_.getMessage(); + } + } + /** + * .InnerObject d = 4; + */ + public Builder setD(InnerObject value) { + if (dBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + d_ = value; + onChanged(); + } else { + dBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject d = 4; + */ + public Builder setD( + InnerObject.Builder builderForValue) { + if (dBuilder_ == null) { + d_ = builderForValue.build(); + onChanged(); + } else { + dBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject d = 4; + */ + public Builder mergeD(InnerObject value) { + if (dBuilder_ == null) { + if (d_ != null) { + d_ = + InnerObject.newBuilder(d_).mergeFrom(value).buildPartial(); + } else { + d_ = value; + } + onChanged(); + } else { + dBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject d = 4; + */ + public Builder clearD() { + if (dBuilder_ == null) { + d_ = null; + onChanged(); + } else { + d_ = null; + dBuilder_ = null; + } + + return this; + } + /** + * .InnerObject d = 4; + */ + public InnerObject.Builder getDBuilder() { + + onChanged(); + return getDFieldBuilder().getBuilder(); + } + /** + * .InnerObject d = 4; + */ + public InnerObjectOrBuilder getDOrBuilder() { + if (dBuilder_ != null) { + return dBuilder_.getMessageOrBuilder(); + } else { + return d_ == null ? + InnerObject.getDefaultInstance() : d_; + } + } + /** + * .InnerObject d = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getDFieldBuilder() { + if (dBuilder_ == null) { + dBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getD(), + getParentForChildren(), + isClean()); + d_ = null; + } + return dBuilder_; + } + + private InnerObject e_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> eBuilder_; + /** + * .InnerObject e = 5; + */ + public boolean hasE() { + return eBuilder_ != null || e_ != null; + } + /** + * .InnerObject e = 5; + */ + public InnerObject getE() { + if (eBuilder_ == null) { + return e_ == null ? InnerObject.getDefaultInstance() : e_; + } else { + return eBuilder_.getMessage(); + } + } + /** + * .InnerObject e = 5; + */ + public Builder setE(InnerObject value) { + if (eBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + e_ = value; + onChanged(); + } else { + eBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject e = 5; + */ + public Builder setE( + InnerObject.Builder builderForValue) { + if (eBuilder_ == null) { + e_ = builderForValue.build(); + onChanged(); + } else { + eBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject e = 5; + */ + public Builder mergeE(InnerObject value) { + if (eBuilder_ == null) { + if (e_ != null) { + e_ = + InnerObject.newBuilder(e_).mergeFrom(value).buildPartial(); + } else { + e_ = value; + } + onChanged(); + } else { + eBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject e = 5; + */ + public Builder clearE() { + if (eBuilder_ == null) { + e_ = null; + onChanged(); + } else { + e_ = null; + eBuilder_ = null; + } + + return this; + } + /** + * .InnerObject e = 5; + */ + public InnerObject.Builder getEBuilder() { + + onChanged(); + return getEFieldBuilder().getBuilder(); + } + /** + * .InnerObject e = 5; + */ + public InnerObjectOrBuilder getEOrBuilder() { + if (eBuilder_ != null) { + return eBuilder_.getMessageOrBuilder(); + } else { + return e_ == null ? + InnerObject.getDefaultInstance() : e_; + } + } + /** + * .InnerObject e = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getEFieldBuilder() { + if (eBuilder_ == null) { + eBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getE(), + getParentForChildren(), + isClean()); + e_ = null; + } + return eBuilder_; + } + + private InnerObject f_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> fBuilder_; + /** + * .InnerObject f = 6; + */ + public boolean hasF() { + return fBuilder_ != null || f_ != null; + } + /** + * .InnerObject f = 6; + */ + public InnerObject getF() { + if (fBuilder_ == null) { + return f_ == null ? InnerObject.getDefaultInstance() : f_; + } else { + return fBuilder_.getMessage(); + } + } + /** + * .InnerObject f = 6; + */ + public Builder setF(InnerObject value) { + if (fBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + f_ = value; + onChanged(); + } else { + fBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject f = 6; + */ + public Builder setF( + InnerObject.Builder builderForValue) { + if (fBuilder_ == null) { + f_ = builderForValue.build(); + onChanged(); + } else { + fBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject f = 6; + */ + public Builder mergeF(InnerObject value) { + if (fBuilder_ == null) { + if (f_ != null) { + f_ = + InnerObject.newBuilder(f_).mergeFrom(value).buildPartial(); + } else { + f_ = value; + } + onChanged(); + } else { + fBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject f = 6; + */ + public Builder clearF() { + if (fBuilder_ == null) { + f_ = null; + onChanged(); + } else { + f_ = null; + fBuilder_ = null; + } + + return this; + } + /** + * .InnerObject f = 6; + */ + public InnerObject.Builder getFBuilder() { + + onChanged(); + return getFFieldBuilder().getBuilder(); + } + /** + * .InnerObject f = 6; + */ + public InnerObjectOrBuilder getFOrBuilder() { + if (fBuilder_ != null) { + return fBuilder_.getMessageOrBuilder(); + } else { + return f_ == null ? + InnerObject.getDefaultInstance() : f_; + } + } + /** + * .InnerObject f = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getFFieldBuilder() { + if (fBuilder_ == null) { + fBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getF(), + getParentForChildren(), + isClean()); + f_ = null; + } + return fBuilder_; + } + + private InnerObject g_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> gBuilder_; + /** + * .InnerObject g = 7; + */ + public boolean hasG() { + return gBuilder_ != null || g_ != null; + } + /** + * .InnerObject g = 7; + */ + public InnerObject getG() { + if (gBuilder_ == null) { + return g_ == null ? InnerObject.getDefaultInstance() : g_; + } else { + return gBuilder_.getMessage(); + } + } + /** + * .InnerObject g = 7; + */ + public Builder setG(InnerObject value) { + if (gBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + g_ = value; + onChanged(); + } else { + gBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject g = 7; + */ + public Builder setG( + InnerObject.Builder builderForValue) { + if (gBuilder_ == null) { + g_ = builderForValue.build(); + onChanged(); + } else { + gBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject g = 7; + */ + public Builder mergeG(InnerObject value) { + if (gBuilder_ == null) { + if (g_ != null) { + g_ = + InnerObject.newBuilder(g_).mergeFrom(value).buildPartial(); + } else { + g_ = value; + } + onChanged(); + } else { + gBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject g = 7; + */ + public Builder clearG() { + if (gBuilder_ == null) { + g_ = null; + onChanged(); + } else { + g_ = null; + gBuilder_ = null; + } + + return this; + } + /** + * .InnerObject g = 7; + */ + public InnerObject.Builder getGBuilder() { + + onChanged(); + return getGFieldBuilder().getBuilder(); + } + /** + * .InnerObject g = 7; + */ + public InnerObjectOrBuilder getGOrBuilder() { + if (gBuilder_ != null) { + return gBuilder_.getMessageOrBuilder(); + } else { + return g_ == null ? + InnerObject.getDefaultInstance() : g_; + } + } + /** + * .InnerObject g = 7; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getGFieldBuilder() { + if (gBuilder_ == null) { + gBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getG(), + getParentForChildren(), + isClean()); + g_ = null; + } + return gBuilder_; + } + + private InnerObject h_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> hBuilder_; + /** + * .InnerObject h = 8; + */ + public boolean hasH() { + return hBuilder_ != null || h_ != null; + } + /** + * .InnerObject h = 8; + */ + public InnerObject getH() { + if (hBuilder_ == null) { + return h_ == null ? InnerObject.getDefaultInstance() : h_; + } else { + return hBuilder_.getMessage(); + } + } + /** + * .InnerObject h = 8; + */ + public Builder setH(InnerObject value) { + if (hBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + h_ = value; + onChanged(); + } else { + hBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject h = 8; + */ + public Builder setH( + InnerObject.Builder builderForValue) { + if (hBuilder_ == null) { + h_ = builderForValue.build(); + onChanged(); + } else { + hBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject h = 8; + */ + public Builder mergeH(InnerObject value) { + if (hBuilder_ == null) { + if (h_ != null) { + h_ = + InnerObject.newBuilder(h_).mergeFrom(value).buildPartial(); + } else { + h_ = value; + } + onChanged(); + } else { + hBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject h = 8; + */ + public Builder clearH() { + if (hBuilder_ == null) { + h_ = null; + onChanged(); + } else { + h_ = null; + hBuilder_ = null; + } + + return this; + } + /** + * .InnerObject h = 8; + */ + public InnerObject.Builder getHBuilder() { + + onChanged(); + return getHFieldBuilder().getBuilder(); + } + /** + * .InnerObject h = 8; + */ + public InnerObjectOrBuilder getHOrBuilder() { + if (hBuilder_ != null) { + return hBuilder_.getMessageOrBuilder(); + } else { + return h_ == null ? + InnerObject.getDefaultInstance() : h_; + } + } + /** + * .InnerObject h = 8; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getHFieldBuilder() { + if (hBuilder_ == null) { + hBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getH(), + getParentForChildren(), + isClean()); + h_ = null; + } + return hBuilder_; + } + + private InnerObject i_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> iBuilder_; + /** + * .InnerObject i = 9; + */ + public boolean hasI() { + return iBuilder_ != null || i_ != null; + } + /** + * .InnerObject i = 9; + */ + public InnerObject getI() { + if (iBuilder_ == null) { + return i_ == null ? InnerObject.getDefaultInstance() : i_; + } else { + return iBuilder_.getMessage(); + } + } + /** + * .InnerObject i = 9; + */ + public Builder setI(InnerObject value) { + if (iBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + i_ = value; + onChanged(); + } else { + iBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject i = 9; + */ + public Builder setI( + InnerObject.Builder builderForValue) { + if (iBuilder_ == null) { + i_ = builderForValue.build(); + onChanged(); + } else { + iBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject i = 9; + */ + public Builder mergeI(InnerObject value) { + if (iBuilder_ == null) { + if (i_ != null) { + i_ = + InnerObject.newBuilder(i_).mergeFrom(value).buildPartial(); + } else { + i_ = value; + } + onChanged(); + } else { + iBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject i = 9; + */ + public Builder clearI() { + if (iBuilder_ == null) { + i_ = null; + onChanged(); + } else { + i_ = null; + iBuilder_ = null; + } + + return this; + } + /** + * .InnerObject i = 9; + */ + public InnerObject.Builder getIBuilder() { + + onChanged(); + return getIFieldBuilder().getBuilder(); + } + /** + * .InnerObject i = 9; + */ + public InnerObjectOrBuilder getIOrBuilder() { + if (iBuilder_ != null) { + return iBuilder_.getMessageOrBuilder(); + } else { + return i_ == null ? + InnerObject.getDefaultInstance() : i_; + } + } + /** + * .InnerObject i = 9; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getIFieldBuilder() { + if (iBuilder_ == null) { + iBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getI(), + getParentForChildren(), + isClean()); + i_ = null; + } + return iBuilder_; + } + + private InnerObject j_ = null; + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> jBuilder_; + /** + * .InnerObject j = 10; + */ + public boolean hasJ() { + return jBuilder_ != null || j_ != null; + } + /** + * .InnerObject j = 10; + */ + public InnerObject getJ() { + if (jBuilder_ == null) { + return j_ == null ? InnerObject.getDefaultInstance() : j_; + } else { + return jBuilder_.getMessage(); + } + } + /** + * .InnerObject j = 10; + */ + public Builder setJ(InnerObject value) { + if (jBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + j_ = value; + onChanged(); + } else { + jBuilder_.setMessage(value); + } + + return this; + } + /** + * .InnerObject j = 10; + */ + public Builder setJ( + InnerObject.Builder builderForValue) { + if (jBuilder_ == null) { + j_ = builderForValue.build(); + onChanged(); + } else { + jBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .InnerObject j = 10; + */ + public Builder mergeJ(InnerObject value) { + if (jBuilder_ == null) { + if (j_ != null) { + j_ = + InnerObject.newBuilder(j_).mergeFrom(value).buildPartial(); + } else { + j_ = value; + } + onChanged(); + } else { + jBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .InnerObject j = 10; + */ + public Builder clearJ() { + if (jBuilder_ == null) { + j_ = null; + onChanged(); + } else { + j_ = null; + jBuilder_ = null; + } + + return this; + } + /** + * .InnerObject j = 10; + */ + public InnerObject.Builder getJBuilder() { + + onChanged(); + return getJFieldBuilder().getBuilder(); + } + /** + * .InnerObject j = 10; + */ + public InnerObjectOrBuilder getJOrBuilder() { + if (jBuilder_ != null) { + return jBuilder_.getMessageOrBuilder(); + } else { + return j_ == null ? + InnerObject.getDefaultInstance() : j_; + } + } + /** + * .InnerObject j = 10; + */ + private com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder> + getJFieldBuilder() { + if (jBuilder_ == null) { + jBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + InnerObject, InnerObject.Builder, InnerObjectOrBuilder>( + getJ(), + getParentForChildren(), + isClean()); + j_ = null; + } + return jBuilder_; + } + @Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFieldsProto3(unknownFields); + } + + @Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:InnerObjectObject) + } + + // @@protoc_insertion_point(class_scope:InnerObjectObject) + private static final InnerObjectObject DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new InnerObjectObject(); + } + + public static InnerObjectObject getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @Override + public InnerObjectObject parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new InnerObjectObject(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @Override + public InnerObjectObject getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + private static final com.google.protobuf.Descriptors.Descriptor internal_static_IntObject_descriptor; private static final @@ -2140,6 +13184,86 @@ public final class FieldProtobufObject { private static final com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internal_static_FloatObject_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_BytesObject_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_BytesObject_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_StringObject_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_StringObject_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_ListIntegerObject_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_ListIntegerObject_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_AEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_AEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_BEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_BEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_CEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_CEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_DEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_DEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_EEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_EEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_FEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_FEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_GEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_GEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_HEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_HEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_IEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_IEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_MapObject_JEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_MapObject_JEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_InnerObject_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_InnerObject_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_InnerObjectObject_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_InnerObjectObject_fieldAccessorTable; public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() { @@ -2155,9 +13279,44 @@ public final class FieldProtobufObject { "\t\n\001i\030\t \001(\005\022\t\n\001j\030\n \001(\005\"{\n\013FloatObject\022\t\n\001" + "a\030\001 \001(\002\022\t\n\001b\030\002 \001(\002\022\t\n\001c\030\003 \001(\002\022\t\n\001d\030\004 \001(\002" + "\022\t\n\001e\030\005 \001(\002\022\t\n\001f\030\006 \001(\002\022\t\n\001g\030\007 \001(\002\022\t\n\001h\030\010" + - " \001(\002\022\t\n\001i\030\t \001(\002\022\t\n\001j\030\n \001(\002B5\n\036com.zfoo.p" + - "rotocol.field.packetB\023FieldProtobufObjec" + - "tb\006proto3" + " \001(\002\022\t\n\001i\030\t \001(\002\022\t\n\001j\030\n \001(\002\"{\n\013BytesObjec" + + "t\022\t\n\001a\030\001 \001(\014\022\t\n\001b\030\002 \001(\014\022\t\n\001c\030\003 \001(\014\022\t\n\001d\030" + + "\004 \001(\014\022\t\n\001e\030\005 \001(\014\022\t\n\001f\030\006 \001(\014\022\t\n\001g\030\007 \001(\014\022\t" + + "\n\001h\030\010 \001(\014\022\t\n\001i\030\t \001(\014\022\t\n\001j\030\n \001(\014\"|\n\014Strin" + + "gObject\022\t\n\001a\030\001 \001(\t\022\t\n\001b\030\002 \001(\t\022\t\n\001c\030\003 \001(\t" + + "\022\t\n\001d\030\004 \001(\t\022\t\n\001e\030\005 \001(\t\022\t\n\001f\030\006 \001(\t\022\t\n\001g\030\007" + + " \001(\t\022\t\n\001h\030\010 \001(\t\022\t\n\001i\030\t \001(\t\022\t\n\001j\030\n \001(\t\"\201\001" + + "\n\021ListIntegerObject\022\t\n\001a\030\001 \003(\005\022\t\n\001b\030\002 \003(" + + "\005\022\t\n\001c\030\003 \003(\005\022\t\n\001d\030\004 \003(\005\022\t\n\001e\030\005 \003(\005\022\t\n\001f\030" + + "\006 \003(\005\022\t\n\001g\030\007 \003(\005\022\t\n\001h\030\010 \003(\005\022\t\n\001i\030\t \003(\005\022\t" + + "\n\001j\030\n \003(\005\"\333\005\n\tMapObject\022\034\n\001a\030\001 \003(\0132\021.Map" + + "Object.AEntry\022\034\n\001b\030\002 \003(\0132\021.MapObject.BEn" + + "try\022\034\n\001c\030\003 \003(\0132\021.MapObject.CEntry\022\034\n\001d\030\004" + + " \003(\0132\021.MapObject.DEntry\022\034\n\001e\030\005 \003(\0132\021.Map" + + "Object.EEntry\022\034\n\001f\030\006 \003(\0132\021.MapObject.FEn" + + "try\022\034\n\001g\030\007 \003(\0132\021.MapObject.GEntry\022\034\n\001h\030\010" + + " \003(\0132\021.MapObject.HEntry\022\034\n\001i\030\t \003(\0132\021.Map" + + "Object.IEntry\022\034\n\001j\030\n \003(\0132\021.MapObject.JEn" + + "try\032(\n\006AEntry\022\013\n\003key\030\001 \001(\005\022\r\n\005value\030\002 \001(" + + "\t:\0028\001\032(\n\006BEntry\022\013\n\003key\030\001 \001(\005\022\r\n\005value\030\002 " + + "\001(\t:\0028\001\032(\n\006CEntry\022\013\n\003key\030\001 \001(\005\022\r\n\005value\030" + + "\002 \001(\t:\0028\001\032(\n\006DEntry\022\013\n\003key\030\001 \001(\005\022\r\n\005valu" + + "e\030\002 \001(\t:\0028\001\032(\n\006EEntry\022\013\n\003key\030\001 \001(\005\022\r\n\005va" + + "lue\030\002 \001(\t:\0028\001\032(\n\006FEntry\022\013\n\003key\030\001 \001(\005\022\r\n\005" + + "value\030\002 \001(\t:\0028\001\032(\n\006GEntry\022\013\n\003key\030\001 \001(\005\022\r" + + "\n\005value\030\002 \001(\t:\0028\001\032(\n\006HEntry\022\013\n\003key\030\001 \001(\005" + + "\022\r\n\005value\030\002 \001(\t:\0028\001\032(\n\006IEntry\022\013\n\003key\030\001 \001" + + "(\005\022\r\n\005value\030\002 \001(\t:\0028\001\032(\n\006JEntry\022\013\n\003key\030\001" + + " \001(\005\022\r\n\005value\030\002 \001(\t:\0028\001\"\030\n\013InnerObject\022\t" + + "\n\001x\030\001 \001(\005\"\215\002\n\021InnerObjectObject\022\027\n\001a\030\001 \001" + + "(\0132\014.InnerObject\022\027\n\001b\030\002 \001(\0132\014.InnerObjec" + + "t\022\027\n\001c\030\003 \001(\0132\014.InnerObject\022\027\n\001d\030\004 \001(\0132\014." + + "InnerObject\022\027\n\001e\030\005 \001(\0132\014.InnerObject\022\027\n\001" + + "f\030\006 \001(\0132\014.InnerObject\022\027\n\001g\030\007 \001(\0132\014.Inner" + + "Object\022\027\n\001h\030\010 \001(\0132\014.InnerObject\022\027\n\001i\030\t \001" + + "(\0132\014.InnerObject\022\027\n\001j\030\n \001(\0132\014.InnerObjec" + + "tB5\n\036com.zfoo.protocol.field.packetB\023Fie" + + "ldProtobufObjectb\006proto3" }; com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new com.google.protobuf.Descriptors.FileDescriptor. InternalDescriptorAssigner() { @@ -2183,6 +13342,102 @@ public final class FieldProtobufObject { com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( internal_static_FloatObject_descriptor, new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", }); + internal_static_BytesObject_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_BytesObject_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_BytesObject_descriptor, + new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", }); + internal_static_StringObject_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_StringObject_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_StringObject_descriptor, + new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", }); + internal_static_ListIntegerObject_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_ListIntegerObject_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_ListIntegerObject_descriptor, + new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", }); + internal_static_MapObject_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_MapObject_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_descriptor, + new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", }); + internal_static_MapObject_AEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(0); + internal_static_MapObject_AEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_AEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_BEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(1); + internal_static_MapObject_BEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_BEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_CEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(2); + internal_static_MapObject_CEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_CEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_DEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(3); + internal_static_MapObject_DEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_DEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_EEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(4); + internal_static_MapObject_EEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_EEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_FEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(5); + internal_static_MapObject_FEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_FEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_GEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(6); + internal_static_MapObject_GEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_GEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_HEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(7); + internal_static_MapObject_HEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_HEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_IEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(8); + internal_static_MapObject_IEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_IEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_MapObject_JEntry_descriptor = + internal_static_MapObject_descriptor.getNestedTypes().get(9); + internal_static_MapObject_JEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_MapObject_JEntry_descriptor, + new String[] { "Key", "Value", }); + internal_static_InnerObject_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_InnerObject_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_InnerObject_descriptor, + new String[] { "X", }); + internal_static_InnerObjectObject_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_InnerObjectObject_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_InnerObjectObject_descriptor, + new String[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", }); } // @@protoc_insertion_point(outer_class_scope) diff --git a/protocol/src/test/java/com/zfoo/protocol/field/packet/InnerObject.java b/protocol/src/test/java/com/zfoo/protocol/field/packet/InnerObject.java new file mode 100644 index 00000000..f202e6de --- /dev/null +++ b/protocol/src/test/java/com/zfoo/protocol/field/packet/InnerObject.java @@ -0,0 +1,30 @@ +package com.zfoo.protocol.field.packet; + +import com.zfoo.protocol.IPacket; + +import java.util.Objects; + +public class InnerObject implements IPacket { + private int x; + + public int getX() { + return x; + } + + public void setX(int x) { + this.x = x; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + InnerObject that = (InnerObject) o; + return x == that.x; + } + + @Override + public int hashCode() { + return Objects.hash(x); + } +} diff --git a/protocol/src/test/java/com/zfoo/protocol/field/packet/InnerObjectObject.java b/protocol/src/test/java/com/zfoo/protocol/field/packet/InnerObjectObject.java new file mode 100644 index 00000000..7888c7ce --- /dev/null +++ b/protocol/src/test/java/com/zfoo/protocol/field/packet/InnerObjectObject.java @@ -0,0 +1,120 @@ +package com.zfoo.protocol.field.packet; + +import com.zfoo.protocol.IPacket; + +import java.util.Objects; + +public class InnerObjectObject implements IPacket { + private InnerObject a; + + private InnerObject b; + + private InnerObject c; + + private InnerObject d; + + private InnerObject e; + + private InnerObject f; + + private InnerObject g; + + private InnerObject h; + + private InnerObject i; + + private InnerObject j; + + public InnerObject getA() { + return a; + } + + public void setA(InnerObject a) { + this.a = a; + } + + public InnerObject getB() { + return b; + } + + public void setB(InnerObject b) { + this.b = b; + } + + public InnerObject getC() { + return c; + } + + public void setC(InnerObject c) { + this.c = c; + } + + public InnerObject getD() { + return d; + } + + public void setD(InnerObject d) { + this.d = d; + } + + public InnerObject getE() { + return e; + } + + public void setE(InnerObject e) { + this.e = e; + } + + public InnerObject getF() { + return f; + } + + public void setF(InnerObject f) { + this.f = f; + } + + public InnerObject getG() { + return g; + } + + public void setG(InnerObject g) { + this.g = g; + } + + public InnerObject getH() { + return h; + } + + public void setH(InnerObject h) { + this.h = h; + } + + public InnerObject getI() { + return i; + } + + public void setI(InnerObject i) { + this.i = i; + } + + public InnerObject getJ() { + return j; + } + + public void setJ(InnerObject j) { + this.j = j; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + InnerObjectObject that = (InnerObjectObject) o; + return Objects.equals(a, that.a) && Objects.equals(b, that.b) && Objects.equals(c, that.c) && Objects.equals(d, that.d) && Objects.equals(e, that.e) && Objects.equals(f, that.f) && Objects.equals(g, that.g) && Objects.equals(h, that.h) && Objects.equals(i, that.i) && Objects.equals(j, that.j); + } + + @Override + public int hashCode() { + return Objects.hash(a, b, c, d, e, f, g, h, i, j); + } +} diff --git a/protocol/src/test/java/com/zfoo/protocol/field/packet/ListIntegerObject.java b/protocol/src/test/java/com/zfoo/protocol/field/packet/ListIntegerObject.java new file mode 100644 index 00000000..6716ca15 --- /dev/null +++ b/protocol/src/test/java/com/zfoo/protocol/field/packet/ListIntegerObject.java @@ -0,0 +1,121 @@ +package com.zfoo.protocol.field.packet; + +import com.zfoo.protocol.IPacket; + +import java.util.List; +import java.util.Objects; + +public class ListIntegerObject implements IPacket { + private List a; + + private List b; + + private List c; + + private List d; + + private List e; + + private List f; + + private List g; + + private List h; + + private List i; + + private List j; + + public List getA() { + return a; + } + + public void setA(List a) { + this.a = a; + } + + public List getB() { + return b; + } + + public void setB(List b) { + this.b = b; + } + + public List getC() { + return c; + } + + public void setC(List c) { + this.c = c; + } + + public List getD() { + return d; + } + + public void setD(List d) { + this.d = d; + } + + public List getE() { + return e; + } + + public void setE(List e) { + this.e = e; + } + + public List getF() { + return f; + } + + public void setF(List f) { + this.f = f; + } + + public List getG() { + return g; + } + + public void setG(List g) { + this.g = g; + } + + public List getH() { + return h; + } + + public void setH(List h) { + this.h = h; + } + + public List getI() { + return i; + } + + public void setI(List i) { + this.i = i; + } + + public List getJ() { + return j; + } + + public void setJ(List j) { + this.j = j; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + ListIntegerObject that = (ListIntegerObject) o; + return Objects.equals(a, that.a) && Objects.equals(b, that.b) && Objects.equals(c, that.c) && Objects.equals(d, that.d) && Objects.equals(e, that.e) && Objects.equals(f, that.f) && Objects.equals(g, that.g) && Objects.equals(h, that.h) && Objects.equals(i, that.i) && Objects.equals(j, that.j); + } + + @Override + public int hashCode() { + return Objects.hash(a, b, c, d, e, f, g, h, i, j); + } +} diff --git a/protocol/src/test/java/com/zfoo/protocol/field/packet/MapObject.java b/protocol/src/test/java/com/zfoo/protocol/field/packet/MapObject.java new file mode 100644 index 00000000..bffce752 --- /dev/null +++ b/protocol/src/test/java/com/zfoo/protocol/field/packet/MapObject.java @@ -0,0 +1,121 @@ +package com.zfoo.protocol.field.packet; + +import com.zfoo.protocol.IPacket; + +import java.util.Map; +import java.util.Objects; + +public class MapObject implements IPacket { + private Map a; + + private Map b; + + private Map c; + + private Map d; + + private Map e; + + private Map f; + + private Map g; + + private Map h; + + private Map i; + + private Map j; + + public Map getA() { + return a; + } + + public void setA(Map a) { + this.a = a; + } + + public Map getB() { + return b; + } + + public void setB(Map b) { + this.b = b; + } + + public Map getC() { + return c; + } + + public void setC(Map c) { + this.c = c; + } + + public Map getD() { + return d; + } + + public void setD(Map d) { + this.d = d; + } + + public Map getE() { + return e; + } + + public void setE(Map e) { + this.e = e; + } + + public Map getF() { + return f; + } + + public void setF(Map f) { + this.f = f; + } + + public Map getG() { + return g; + } + + public void setG(Map g) { + this.g = g; + } + + public Map getH() { + return h; + } + + public void setH(Map h) { + this.h = h; + } + + public Map getI() { + return i; + } + + public void setI(Map i) { + this.i = i; + } + + public Map getJ() { + return j; + } + + public void setJ(Map j) { + this.j = j; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + MapObject mapObject = (MapObject) o; + return Objects.equals(a, mapObject.a) && Objects.equals(b, mapObject.b) && Objects.equals(c, mapObject.c) && Objects.equals(d, mapObject.d) && Objects.equals(e, mapObject.e) && Objects.equals(f, mapObject.f) && Objects.equals(g, mapObject.g) && Objects.equals(h, mapObject.h) && Objects.equals(i, mapObject.i) && Objects.equals(j, mapObject.j); + } + + @Override + public int hashCode() { + return Objects.hash(a, b, c, d, e, f, g, h, i, j); + } +} diff --git a/protocol/src/test/java/com/zfoo/protocol/field/packet/SetObject.java b/protocol/src/test/java/com/zfoo/protocol/field/packet/SetObject.java new file mode 100644 index 00000000..7a5af7b9 --- /dev/null +++ b/protocol/src/test/java/com/zfoo/protocol/field/packet/SetObject.java @@ -0,0 +1,121 @@ +package com.zfoo.protocol.field.packet; + +import com.zfoo.protocol.IPacket; + +import java.util.Objects; +import java.util.Set; + +public class SetObject implements IPacket { + private Set a; + + private Set b; + + private Set c; + + private Set d; + + private Set e; + + private Set f; + + private Set g; + + private Set h; + + private Set i; + + private Set j; + + public Set getA() { + return a; + } + + public void setA(Set a) { + this.a = a; + } + + public Set getB() { + return b; + } + + public void setB(Set b) { + this.b = b; + } + + public Set getC() { + return c; + } + + public void setC(Set c) { + this.c = c; + } + + public Set getD() { + return d; + } + + public void setD(Set d) { + this.d = d; + } + + public Set getE() { + return e; + } + + public void setE(Set e) { + this.e = e; + } + + public Set getF() { + return f; + } + + public void setF(Set f) { + this.f = f; + } + + public Set getG() { + return g; + } + + public void setG(Set g) { + this.g = g; + } + + public Set getH() { + return h; + } + + public void setH(Set h) { + this.h = h; + } + + public Set getI() { + return i; + } + + public void setI(Set i) { + this.i = i; + } + + public Set getJ() { + return j; + } + + public void setJ(Set j) { + this.j = j; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + SetObject setObject = (SetObject) o; + return Objects.equals(a, setObject.a) && Objects.equals(b, setObject.b) && Objects.equals(c, setObject.c) && Objects.equals(d, setObject.d) && Objects.equals(e, setObject.e) && Objects.equals(f, setObject.f) && Objects.equals(g, setObject.g) && Objects.equals(h, setObject.h) && Objects.equals(i, setObject.i) && Objects.equals(j, setObject.j); + } + + @Override + public int hashCode() { + return Objects.hash(a, b, c, d, e, f, g, h, i, j); + } +} diff --git a/protocol/src/test/java/com/zfoo/protocol/field/packet/StringObject.java b/protocol/src/test/java/com/zfoo/protocol/field/packet/StringObject.java new file mode 100644 index 00000000..fcddc651 --- /dev/null +++ b/protocol/src/test/java/com/zfoo/protocol/field/packet/StringObject.java @@ -0,0 +1,111 @@ +package com.zfoo.protocol.field.packet; + +import com.zfoo.protocol.IPacket; + +import java.util.Objects; + +public class StringObject implements IPacket { + private String a; + private String b; + private String c; + private String d; + private String e; + private String f; + private String g; + private String h; + private String i; + private String j; + + public String getA() { + return a; + } + + public void setA(String a) { + this.a = a; + } + + public String getB() { + return b; + } + + public void setB(String b) { + this.b = b; + } + + public String getC() { + return c; + } + + public void setC(String c) { + this.c = c; + } + + public String getD() { + return d; + } + + public void setD(String d) { + this.d = d; + } + + public String getE() { + return e; + } + + public void setE(String e) { + this.e = e; + } + + public String getF() { + return f; + } + + public void setF(String f) { + this.f = f; + } + + public String getG() { + return g; + } + + public void setG(String g) { + this.g = g; + } + + public String getH() { + return h; + } + + public void setH(String h) { + this.h = h; + } + + public String getI() { + return i; + } + + public void setI(String i) { + this.i = i; + } + + public String getJ() { + return j; + } + + public void setJ(String j) { + this.j = j; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + StringObject that = (StringObject) o; + return Objects.equals(a, that.a) && Objects.equals(b, that.b) && Objects.equals(c, that.c) && Objects.equals(d, that.d) && Objects.equals(e, that.e) && Objects.equals(f, that.f) && Objects.equals(g, that.g) && Objects.equals(h, that.h) && Objects.equals(i, that.i) && Objects.equals(j, that.j); + } + + @Override + public int hashCode() { + return Objects.hash(a, b, c, d, e, f, g, h, i, j); + } +} diff --git a/protocol/src/test/resources/fieldspeed.proto b/protocol/src/test/resources/fieldspeed.proto index e388252a..b71cde4a 100644 --- a/protocol/src/test/resources/fieldspeed.proto +++ b/protocol/src/test/resources/fieldspeed.proto @@ -28,3 +28,72 @@ message FloatObject{ float i=9; float j=10; } + +message BytesObject{ + bytes a=1; + bytes b=2; + bytes c=3; + bytes d=4; + bytes e=5; + bytes f=6; + bytes g=7; + bytes h=8; + bytes i=9; + bytes j=10; +} + +message StringObject{ + string a=1; + string b=2; + string c=3; + string d=4; + string e=5; + string f=6; + string g=7; + string h=8; + string i=9; + string j=10; +} + +message ListIntegerObject{ + repeated int32 a=1; + repeated int32 b=2; + repeated int32 c=3; + repeated int32 d=4; + repeated int32 e=5; + repeated int32 f=6; + repeated int32 g=7; + repeated int32 h=8; + repeated int32 i=9; + repeated int32 j=10; +} + +message MapObject{ + map a=1; + map b=2; + map c=3; + map d=4; + map e=5; + map f=6; + map g=7; + map h=8; + map i=9; + map j=10; +} + +message InnerObject{ + int32 x=1; +} + +message InnerObjectObject{ + InnerObject a=1; + InnerObject b=2; + InnerObject c=3; + InnerObject d=4; + InnerObject e=5; + InnerObject f=6; + InnerObject g=7; + InnerObject h=8; + InnerObject i=9; + InnerObject j=10; +}