Protocol Buffers - Google's data interchange format (grpc依赖)
https://developers.google.com/protocol-buffers/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
715 lines
26 KiB
715 lines
26 KiB
// Generated by the protocol buffer compiler. DO NOT EDIT! |
|
// source: unittest_issues.proto |
|
#pragma warning disable 1591, 0612, 3021 |
|
#region Designer generated code |
|
|
|
using pb = global::Google.Protobuf; |
|
using pbc = global::Google.Protobuf.Collections; |
|
using pbd = global::Google.Protobuf.Descriptors; |
|
using scg = global::System.Collections.Generic; |
|
namespace UnitTest.Issues.TestProtos { |
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] |
|
public static partial class UnittestIssues { |
|
|
|
#region Static variables |
|
internal static pbd::MessageDescriptor internal__static_unittest_issues_NegativeEnumMessage__Descriptor; |
|
internal static pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.NegativeEnumMessage> internal__static_unittest_issues_NegativeEnumMessage__FieldAccessorTable; |
|
internal static pbd::MessageDescriptor internal__static_unittest_issues_DeprecatedChild__Descriptor; |
|
internal static pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.DeprecatedChild> internal__static_unittest_issues_DeprecatedChild__FieldAccessorTable; |
|
internal static pbd::MessageDescriptor internal__static_unittest_issues_DeprecatedFieldsMessage__Descriptor; |
|
internal static pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.DeprecatedFieldsMessage> internal__static_unittest_issues_DeprecatedFieldsMessage__FieldAccessorTable; |
|
internal static pbd::MessageDescriptor internal__static_unittest_issues_ItemField__Descriptor; |
|
internal static pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.ItemField> internal__static_unittest_issues_ItemField__FieldAccessorTable; |
|
#endregion |
|
#region Descriptor |
|
public static pbd::FileDescriptor Descriptor { |
|
get { return descriptor; } |
|
} |
|
private static pbd::FileDescriptor descriptor; |
|
|
|
static UnittestIssues() { |
|
byte[] descriptorData = global::System.Convert.FromBase64String( |
|
string.Concat( |
|
"ChV1bml0dGVzdF9pc3N1ZXMucHJvdG8SD3VuaXR0ZXN0X2lzc3VlcyKwAQoT", |
|
"TmVnYXRpdmVFbnVtTWVzc2FnZRIsCgV2YWx1ZRgBIAEoDjIdLnVuaXR0ZXN0", |
|
"X2lzc3Vlcy5OZWdhdGl2ZUVudW0SMQoGdmFsdWVzGAIgAygOMh0udW5pdHRl", |
|
"c3RfaXNzdWVzLk5lZ2F0aXZlRW51bUICEAASOAoNcGFja2VkX3ZhbHVlcxgD", |
|
"IAMoDjIdLnVuaXR0ZXN0X2lzc3Vlcy5OZWdhdGl2ZUVudW1CAhABIhEKD0Rl", |
|
"cHJlY2F0ZWRDaGlsZCK5AgoXRGVwcmVjYXRlZEZpZWxkc01lc3NhZ2USGgoO", |
|
"UHJpbWl0aXZlVmFsdWUYASABKAVCAhgBEhoKDlByaW1pdGl2ZUFycmF5GAIg", |
|
"AygFQgIYARI6CgxNZXNzYWdlVmFsdWUYAyABKAsyIC51bml0dGVzdF9pc3N1", |
|
"ZXMuRGVwcmVjYXRlZENoaWxkQgIYARI6CgxNZXNzYWdlQXJyYXkYBCADKAsy", |
|
"IC51bml0dGVzdF9pc3N1ZXMuRGVwcmVjYXRlZENoaWxkQgIYARI2CglFbnVt", |
|
"VmFsdWUYBSABKA4yHy51bml0dGVzdF9pc3N1ZXMuRGVwcmVjYXRlZEVudW1C", |
|
"AhgBEjYKCUVudW1BcnJheRgGIAMoDjIfLnVuaXR0ZXN0X2lzc3Vlcy5EZXBy", |
|
"ZWNhdGVkRW51bUICGAEiGQoJSXRlbUZpZWxkEgwKBGl0ZW0YASABKAUqVQoM", |
|
"TmVnYXRpdmVFbnVtEhYKEk5FR0FUSVZFX0VOVU1fWkVSTxAAEhYKCUZpdmVC", |
|
"ZWxvdxD7//////////8BEhUKCE1pbnVzT25lEP///////////wEqLgoORGVw", |
|
"cmVjYXRlZEVudW0SEwoPREVQUkVDQVRFRF9aRVJPEAASBwoDb25lEAFCH0gB", |
|
"qgIaVW5pdFRlc3QuSXNzdWVzLlRlc3RQcm90b3NiBnByb3RvMw==")); |
|
pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) { |
|
descriptor = root; |
|
internal__static_unittest_issues_NegativeEnumMessage__Descriptor = Descriptor.MessageTypes[0]; |
|
internal__static_unittest_issues_NegativeEnumMessage__FieldAccessorTable = |
|
new pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.NegativeEnumMessage>(internal__static_unittest_issues_NegativeEnumMessage__Descriptor, |
|
new string[] { "Value", "Values", "PackedValues", }); |
|
internal__static_unittest_issues_DeprecatedChild__Descriptor = Descriptor.MessageTypes[1]; |
|
internal__static_unittest_issues_DeprecatedChild__FieldAccessorTable = |
|
new pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.DeprecatedChild>(internal__static_unittest_issues_DeprecatedChild__Descriptor, |
|
new string[] { }); |
|
internal__static_unittest_issues_DeprecatedFieldsMessage__Descriptor = Descriptor.MessageTypes[2]; |
|
internal__static_unittest_issues_DeprecatedFieldsMessage__FieldAccessorTable = |
|
new pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.DeprecatedFieldsMessage>(internal__static_unittest_issues_DeprecatedFieldsMessage__Descriptor, |
|
new string[] { "PrimitiveValue", "PrimitiveArray", "MessageValue", "MessageArray", "EnumValue", "EnumArray", }); |
|
internal__static_unittest_issues_ItemField__Descriptor = Descriptor.MessageTypes[3]; |
|
internal__static_unittest_issues_ItemField__FieldAccessorTable = |
|
new pb::FieldAccess.FieldAccessorTable<global::UnitTest.Issues.TestProtos.ItemField>(internal__static_unittest_issues_ItemField__Descriptor, |
|
new string[] { "Item", }); |
|
}; |
|
pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData, |
|
new pbd::FileDescriptor[] { |
|
}, assigner); |
|
} |
|
#endregion |
|
|
|
} |
|
#region Enums |
|
public enum NegativeEnum { |
|
NEGATIVE_ENUM_ZERO = 0, |
|
FiveBelow = -5, |
|
MinusOne = -1, |
|
} |
|
|
|
public enum DeprecatedEnum { |
|
DEPRECATED_ZERO = 0, |
|
one = 1, |
|
} |
|
|
|
#endregion |
|
|
|
#region Messages |
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] |
|
public sealed partial class NegativeEnumMessage : pb::IMessage<NegativeEnumMessage> { |
|
private static readonly pb::MessageParser<NegativeEnumMessage> _parser = new pb::MessageParser<NegativeEnumMessage>(() => new NegativeEnumMessage()); |
|
public static pb::MessageParser<NegativeEnumMessage> Parser { get { return _parser; } } |
|
|
|
private static readonly string[] _fieldNames = new string[] { "packed_values", "value", "values" }; |
|
private static readonly uint[] _fieldTags = new uint[] { 26, 8, 16 }; |
|
public static pbd::MessageDescriptor Descriptor { |
|
get { return global::UnitTest.Issues.TestProtos.UnittestIssues.internal__static_unittest_issues_NegativeEnumMessage__Descriptor; } |
|
} |
|
|
|
public pb::FieldAccess.FieldAccessorTable<NegativeEnumMessage> Fields { |
|
get { return global::UnitTest.Issues.TestProtos.UnittestIssues.internal__static_unittest_issues_NegativeEnumMessage__FieldAccessorTable; } |
|
} |
|
|
|
private bool _frozen = false; |
|
public bool IsFrozen { get { return _frozen; } } |
|
|
|
public NegativeEnumMessage() { } |
|
|
|
public NegativeEnumMessage(NegativeEnumMessage other) { |
|
value_ = other.value_; |
|
values_ = other.values_.Clone(); |
|
packedValues_ = other.packedValues_.Clone(); |
|
} |
|
|
|
public NegativeEnumMessage Clone() { |
|
return new NegativeEnumMessage(this); |
|
} |
|
|
|
public void Freeze() { |
|
if (IsFrozen) { |
|
return; |
|
} |
|
_frozen = true; |
|
values_.Freeze(); |
|
packedValues_.Freeze(); |
|
} |
|
|
|
public const int ValueFieldNumber = 1; |
|
private global::UnitTest.Issues.TestProtos.NegativeEnum value_ = global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO; |
|
public global::UnitTest.Issues.TestProtos.NegativeEnum Value { |
|
get { return value_; } |
|
set { |
|
pb::Freezable.CheckMutable(this); |
|
value_ = value; |
|
} |
|
} |
|
|
|
public const int ValuesFieldNumber = 2; |
|
private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> values_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>(); |
|
public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> Values { |
|
get { return values_; } |
|
} |
|
|
|
public const int PackedValuesFieldNumber = 3; |
|
private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> packedValues_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum>(); |
|
public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.NegativeEnum> PackedValues { |
|
get { return packedValues_; } |
|
} |
|
|
|
public override bool Equals(object other) { |
|
return Equals(other as NegativeEnumMessage); |
|
} |
|
|
|
public bool Equals(NegativeEnumMessage other) { |
|
if (ReferenceEquals(other, null)) { |
|
return false; |
|
} |
|
if (ReferenceEquals(other, this)) { |
|
return true; |
|
} |
|
if (Value != other.Value) return false; |
|
if(!values_.Equals(other.values_)) return false; |
|
if(!packedValues_.Equals(other.packedValues_)) return false; |
|
return true; |
|
} |
|
|
|
public override int GetHashCode() { |
|
int hash = 17; |
|
if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) hash ^= Value.GetHashCode(); |
|
hash ^= values_.GetHashCode(); |
|
hash ^= packedValues_.GetHashCode(); |
|
return hash; |
|
} |
|
|
|
public void WriteTo(pb::CodedOutputStream output) { |
|
if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) { |
|
output.WriteRawTag(8); |
|
output.WriteEnum((int) Value); |
|
} |
|
if (values_.Count > 0) { |
|
output.WriteEnumArray(2, values_); |
|
} |
|
if (packedValues_.Count > 0) { |
|
output.WriteRawTag(26); |
|
output.WritePackedEnumArray(packedValues_); |
|
} |
|
} |
|
|
|
public int CalculateSize() { |
|
int size = 0; |
|
if (Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) { |
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Value); |
|
} |
|
if (values_.Count > 0) { |
|
int dataSize = 0; |
|
foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in values_) { |
|
dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); |
|
} |
|
size += dataSize; |
|
size += 1 * values_.Count; |
|
} |
|
if (packedValues_.Count > 0) { |
|
int dataSize = 0; |
|
foreach (global::UnitTest.Issues.TestProtos.NegativeEnum element in packedValues_) { |
|
dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); |
|
} |
|
size += dataSize; |
|
size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); |
|
} |
|
return size; |
|
} |
|
|
|
public void MergeFrom(NegativeEnumMessage other) { |
|
if (other == null) { |
|
return; |
|
} |
|
if (other.Value != global::UnitTest.Issues.TestProtos.NegativeEnum.NEGATIVE_ENUM_ZERO) { |
|
Value = other.Value; |
|
} |
|
values_.Add(other.values_); |
|
packedValues_.Add(other.packedValues_); |
|
} |
|
|
|
public void MergeFrom(pb::CodedInputStream input) { |
|
uint tag; |
|
while (input.ReadTag(out tag)) { |
|
switch(tag) { |
|
case 0: |
|
throw pb::InvalidProtocolBufferException.InvalidTag(); |
|
default: |
|
if (pb::WireFormat.IsEndGroupTag(tag)) { |
|
return; |
|
} |
|
break; |
|
case 8: { |
|
value_ = (global::UnitTest.Issues.TestProtos.NegativeEnum) input.ReadEnum(); |
|
break; |
|
} |
|
case 18: |
|
case 16: { |
|
input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(values_); |
|
break; |
|
} |
|
case 26: |
|
case 24: { |
|
input.ReadEnumArray<global::UnitTest.Issues.TestProtos.NegativeEnum>(packedValues_); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
} |
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] |
|
public sealed partial class DeprecatedChild : pb::IMessage<DeprecatedChild> { |
|
private static readonly pb::MessageParser<DeprecatedChild> _parser = new pb::MessageParser<DeprecatedChild>(() => new DeprecatedChild()); |
|
public static pb::MessageParser<DeprecatedChild> Parser { get { return _parser; } } |
|
|
|
private static readonly string[] _fieldNames = new string[] { }; |
|
private static readonly uint[] _fieldTags = new uint[] { }; |
|
public static pbd::MessageDescriptor Descriptor { |
|
get { return global::UnitTest.Issues.TestProtos.UnittestIssues.internal__static_unittest_issues_DeprecatedChild__Descriptor; } |
|
} |
|
|
|
public pb::FieldAccess.FieldAccessorTable<DeprecatedChild> Fields { |
|
get { return global::UnitTest.Issues.TestProtos.UnittestIssues.internal__static_unittest_issues_DeprecatedChild__FieldAccessorTable; } |
|
} |
|
|
|
private bool _frozen = false; |
|
public bool IsFrozen { get { return _frozen; } } |
|
|
|
public DeprecatedChild() { } |
|
|
|
public DeprecatedChild(DeprecatedChild other) { |
|
} |
|
|
|
public DeprecatedChild Clone() { |
|
return new DeprecatedChild(this); |
|
} |
|
|
|
public void Freeze() { |
|
if (IsFrozen) { |
|
return; |
|
} |
|
_frozen = true; |
|
} |
|
|
|
public override bool Equals(object other) { |
|
return Equals(other as DeprecatedChild); |
|
} |
|
|
|
public bool Equals(DeprecatedChild other) { |
|
if (ReferenceEquals(other, null)) { |
|
return false; |
|
} |
|
if (ReferenceEquals(other, this)) { |
|
return true; |
|
} |
|
return true; |
|
} |
|
|
|
public override int GetHashCode() { |
|
int hash = 17; |
|
return hash; |
|
} |
|
|
|
public void WriteTo(pb::CodedOutputStream output) { |
|
} |
|
|
|
public int CalculateSize() { |
|
int size = 0; |
|
return size; |
|
} |
|
|
|
public void MergeFrom(DeprecatedChild other) { |
|
if (other == null) { |
|
return; |
|
} |
|
} |
|
|
|
public void MergeFrom(pb::CodedInputStream input) { |
|
uint tag; |
|
while (input.ReadTag(out tag)) { |
|
switch(tag) { |
|
case 0: |
|
throw pb::InvalidProtocolBufferException.InvalidTag(); |
|
default: |
|
if (pb::WireFormat.IsEndGroupTag(tag)) { |
|
return; |
|
} |
|
break; |
|
} |
|
} |
|
} |
|
|
|
} |
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] |
|
public sealed partial class DeprecatedFieldsMessage : pb::IMessage<DeprecatedFieldsMessage> { |
|
private static readonly pb::MessageParser<DeprecatedFieldsMessage> _parser = new pb::MessageParser<DeprecatedFieldsMessage>(() => new DeprecatedFieldsMessage()); |
|
public static pb::MessageParser<DeprecatedFieldsMessage> Parser { get { return _parser; } } |
|
|
|
private static readonly string[] _fieldNames = new string[] { "EnumArray", "EnumValue", "MessageArray", "MessageValue", "PrimitiveArray", "PrimitiveValue" }; |
|
private static readonly uint[] _fieldTags = new uint[] { 50, 40, 34, 26, 18, 8 }; |
|
public static pbd::MessageDescriptor Descriptor { |
|
get { return global::UnitTest.Issues.TestProtos.UnittestIssues.internal__static_unittest_issues_DeprecatedFieldsMessage__Descriptor; } |
|
} |
|
|
|
public pb::FieldAccess.FieldAccessorTable<DeprecatedFieldsMessage> Fields { |
|
get { return global::UnitTest.Issues.TestProtos.UnittestIssues.internal__static_unittest_issues_DeprecatedFieldsMessage__FieldAccessorTable; } |
|
} |
|
|
|
private bool _frozen = false; |
|
public bool IsFrozen { get { return _frozen; } } |
|
|
|
public DeprecatedFieldsMessage() { } |
|
|
|
public DeprecatedFieldsMessage(DeprecatedFieldsMessage other) { |
|
primitiveValue_ = other.primitiveValue_; |
|
primitiveArray_ = other.primitiveArray_.Clone(); |
|
MessageValue = other.messageValue_ != null ? other.MessageValue.Clone() : null; |
|
messageArray_ = other.messageArray_.Clone(); |
|
enumValue_ = other.enumValue_; |
|
enumArray_ = other.enumArray_.Clone(); |
|
} |
|
|
|
public DeprecatedFieldsMessage Clone() { |
|
return new DeprecatedFieldsMessage(this); |
|
} |
|
|
|
public void Freeze() { |
|
if (IsFrozen) { |
|
return; |
|
} |
|
_frozen = true; |
|
primitiveArray_.Freeze(); |
|
if (messageValue_ != null) MessageValue.Freeze(); |
|
messageArray_.Freeze(); |
|
enumArray_.Freeze(); |
|
} |
|
|
|
public const int PrimitiveValueFieldNumber = 1; |
|
private int primitiveValue_; |
|
[global::System.ObsoleteAttribute()] |
|
public int PrimitiveValue { |
|
get { return primitiveValue_; } |
|
set { |
|
pb::Freezable.CheckMutable(this); |
|
primitiveValue_ = value; |
|
} |
|
} |
|
|
|
public const int PrimitiveArrayFieldNumber = 2; |
|
private readonly pbc::RepeatedField<int> primitiveArray_ = new pbc::RepeatedField<int>(); |
|
[global::System.ObsoleteAttribute()] |
|
public pbc::RepeatedField<int> PrimitiveArray { |
|
get { return primitiveArray_; } |
|
} |
|
|
|
public const int MessageValueFieldNumber = 3; |
|
private global::UnitTest.Issues.TestProtos.DeprecatedChild messageValue_; |
|
[global::System.ObsoleteAttribute()] |
|
public global::UnitTest.Issues.TestProtos.DeprecatedChild MessageValue { |
|
get { return messageValue_; } |
|
set { |
|
pb::Freezable.CheckMutable(this); |
|
messageValue_ = value; |
|
} |
|
} |
|
|
|
public const int MessageArrayFieldNumber = 4; |
|
private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild> messageArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild>(); |
|
[global::System.ObsoleteAttribute()] |
|
public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedChild> MessageArray { |
|
get { return messageArray_; } |
|
} |
|
|
|
public const int EnumValueFieldNumber = 5; |
|
private global::UnitTest.Issues.TestProtos.DeprecatedEnum enumValue_ = global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO; |
|
[global::System.ObsoleteAttribute()] |
|
public global::UnitTest.Issues.TestProtos.DeprecatedEnum EnumValue { |
|
get { return enumValue_; } |
|
set { |
|
pb::Freezable.CheckMutable(this); |
|
enumValue_ = value; |
|
} |
|
} |
|
|
|
public const int EnumArrayFieldNumber = 6; |
|
private readonly pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> enumArray_ = new pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(); |
|
[global::System.ObsoleteAttribute()] |
|
public pbc::RepeatedField<global::UnitTest.Issues.TestProtos.DeprecatedEnum> EnumArray { |
|
get { return enumArray_; } |
|
} |
|
|
|
public override bool Equals(object other) { |
|
return Equals(other as DeprecatedFieldsMessage); |
|
} |
|
|
|
public bool Equals(DeprecatedFieldsMessage other) { |
|
if (ReferenceEquals(other, null)) { |
|
return false; |
|
} |
|
if (ReferenceEquals(other, this)) { |
|
return true; |
|
} |
|
if (PrimitiveValue != other.PrimitiveValue) return false; |
|
if(!primitiveArray_.Equals(other.primitiveArray_)) return false; |
|
if (!object.Equals(MessageValue, other.MessageValue)) return false; |
|
if(!messageArray_.Equals(other.messageArray_)) return false; |
|
if (EnumValue != other.EnumValue) return false; |
|
if(!enumArray_.Equals(other.enumArray_)) return false; |
|
return true; |
|
} |
|
|
|
public override int GetHashCode() { |
|
int hash = 17; |
|
if (PrimitiveValue != 0) hash ^= PrimitiveValue.GetHashCode(); |
|
hash ^= primitiveArray_.GetHashCode(); |
|
if (messageValue_ != null) hash ^= MessageValue.GetHashCode(); |
|
hash ^= messageArray_.GetHashCode(); |
|
if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) hash ^= EnumValue.GetHashCode(); |
|
hash ^= enumArray_.GetHashCode(); |
|
return hash; |
|
} |
|
|
|
public void WriteTo(pb::CodedOutputStream output) { |
|
if (PrimitiveValue != 0) { |
|
output.WriteRawTag(8); |
|
output.WriteInt32(PrimitiveValue); |
|
} |
|
if (primitiveArray_.Count > 0) { |
|
output.WriteRawTag(18); |
|
output.WritePackedInt32Array(primitiveArray_); |
|
} |
|
if (messageValue_ != null) { |
|
output.WriteRawTag(26); |
|
output.WriteMessage(MessageValue); |
|
} |
|
if (messageArray_.Count > 0) { |
|
output.WriteMessageArray(4, messageArray_); |
|
} |
|
if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) { |
|
output.WriteRawTag(40); |
|
output.WriteEnum((int) EnumValue); |
|
} |
|
if (enumArray_.Count > 0) { |
|
output.WriteRawTag(50); |
|
output.WritePackedEnumArray(enumArray_); |
|
} |
|
} |
|
|
|
public int CalculateSize() { |
|
int size = 0; |
|
if (PrimitiveValue != 0) { |
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(PrimitiveValue); |
|
} |
|
if (primitiveArray_.Count > 0) { |
|
int dataSize = 0; |
|
foreach (int element in primitiveArray_) { |
|
dataSize += pb::CodedOutputStream.ComputeInt32Size(element); |
|
} |
|
size += dataSize; |
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(dataSize); |
|
} |
|
if (messageValue_ != null) { |
|
size += 1 + pb::CodedOutputStream.ComputeMessageSize(MessageValue); |
|
} |
|
if (messageArray_.Count > 0) { |
|
foreach (global::UnitTest.Issues.TestProtos.DeprecatedChild element in messageArray_) { |
|
size += pb::CodedOutputStream.ComputeMessageSize(element); |
|
} |
|
size += 1 * messageArray_.Count; |
|
} |
|
if (EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) { |
|
size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) EnumValue); |
|
} |
|
if (enumArray_.Count > 0) { |
|
int dataSize = 0; |
|
foreach (global::UnitTest.Issues.TestProtos.DeprecatedEnum element in enumArray_) { |
|
dataSize += pb::CodedOutputStream.ComputeEnumSize((int) element); |
|
} |
|
size += dataSize; |
|
size += 1 + pb::CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); |
|
} |
|
return size; |
|
} |
|
|
|
public void MergeFrom(DeprecatedFieldsMessage other) { |
|
if (other == null) { |
|
return; |
|
} |
|
if (other.PrimitiveValue != 0) { |
|
PrimitiveValue = other.PrimitiveValue; |
|
} |
|
primitiveArray_.Add(other.primitiveArray_); |
|
if (other.messageValue_ != null) { |
|
if (messageValue_ == null) { |
|
messageValue_ = new global::UnitTest.Issues.TestProtos.DeprecatedChild(); |
|
} |
|
MessageValue.MergeFrom(other.MessageValue); |
|
} |
|
messageArray_.Add(other.messageArray_); |
|
if (other.EnumValue != global::UnitTest.Issues.TestProtos.DeprecatedEnum.DEPRECATED_ZERO) { |
|
EnumValue = other.EnumValue; |
|
} |
|
enumArray_.Add(other.enumArray_); |
|
} |
|
|
|
public void MergeFrom(pb::CodedInputStream input) { |
|
uint tag; |
|
while (input.ReadTag(out tag)) { |
|
switch(tag) { |
|
case 0: |
|
throw pb::InvalidProtocolBufferException.InvalidTag(); |
|
default: |
|
if (pb::WireFormat.IsEndGroupTag(tag)) { |
|
return; |
|
} |
|
break; |
|
case 8: { |
|
PrimitiveValue = input.ReadInt32(); |
|
break; |
|
} |
|
case 18: |
|
case 16: { |
|
input.ReadInt32Array(primitiveArray_); |
|
break; |
|
} |
|
case 26: { |
|
if (messageValue_ == null) { |
|
messageValue_ = new global::UnitTest.Issues.TestProtos.DeprecatedChild(); |
|
} |
|
input.ReadMessage(messageValue_); |
|
break; |
|
} |
|
case 34: { |
|
input.ReadMessageArray(messageArray_, global::UnitTest.Issues.TestProtos.DeprecatedChild.Parser); |
|
break; |
|
} |
|
case 40: { |
|
enumValue_ = (global::UnitTest.Issues.TestProtos.DeprecatedEnum) input.ReadEnum(); |
|
break; |
|
} |
|
case 50: |
|
case 48: { |
|
input.ReadEnumArray<global::UnitTest.Issues.TestProtos.DeprecatedEnum>(enumArray_); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
} |
|
|
|
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] |
|
public sealed partial class ItemField : pb::IMessage<ItemField> { |
|
private static readonly pb::MessageParser<ItemField> _parser = new pb::MessageParser<ItemField>(() => new ItemField()); |
|
public static pb::MessageParser<ItemField> Parser { get { return _parser; } } |
|
|
|
private static readonly string[] _fieldNames = new string[] { "item" }; |
|
private static readonly uint[] _fieldTags = new uint[] { 8 }; |
|
public static pbd::MessageDescriptor Descriptor { |
|
get { return global::UnitTest.Issues.TestProtos.UnittestIssues.internal__static_unittest_issues_ItemField__Descriptor; } |
|
} |
|
|
|
public pb::FieldAccess.FieldAccessorTable<ItemField> Fields { |
|
get { return global::UnitTest.Issues.TestProtos.UnittestIssues.internal__static_unittest_issues_ItemField__FieldAccessorTable; } |
|
} |
|
|
|
private bool _frozen = false; |
|
public bool IsFrozen { get { return _frozen; } } |
|
|
|
public ItemField() { } |
|
|
|
public ItemField(ItemField other) { |
|
item_ = other.item_; |
|
} |
|
|
|
public ItemField Clone() { |
|
return new ItemField(this); |
|
} |
|
|
|
public void Freeze() { |
|
if (IsFrozen) { |
|
return; |
|
} |
|
_frozen = true; |
|
} |
|
|
|
public const int ItemFieldNumber = 1; |
|
private int item_; |
|
public int Item { |
|
get { return item_; } |
|
set { |
|
pb::Freezable.CheckMutable(this); |
|
item_ = value; |
|
} |
|
} |
|
|
|
public override bool Equals(object other) { |
|
return Equals(other as ItemField); |
|
} |
|
|
|
public bool Equals(ItemField other) { |
|
if (ReferenceEquals(other, null)) { |
|
return false; |
|
} |
|
if (ReferenceEquals(other, this)) { |
|
return true; |
|
} |
|
if (Item != other.Item) return false; |
|
return true; |
|
} |
|
|
|
public override int GetHashCode() { |
|
int hash = 17; |
|
if (Item != 0) hash ^= Item.GetHashCode(); |
|
return hash; |
|
} |
|
|
|
public void WriteTo(pb::CodedOutputStream output) { |
|
if (Item != 0) { |
|
output.WriteRawTag(8); |
|
output.WriteInt32(Item); |
|
} |
|
} |
|
|
|
public int CalculateSize() { |
|
int size = 0; |
|
if (Item != 0) { |
|
size += 1 + pb::CodedOutputStream.ComputeInt32Size(Item); |
|
} |
|
return size; |
|
} |
|
|
|
public void MergeFrom(ItemField other) { |
|
if (other == null) { |
|
return; |
|
} |
|
if (other.Item != 0) { |
|
Item = other.Item; |
|
} |
|
} |
|
|
|
public void MergeFrom(pb::CodedInputStream input) { |
|
uint tag; |
|
while (input.ReadTag(out tag)) { |
|
switch(tag) { |
|
case 0: |
|
throw pb::InvalidProtocolBufferException.InvalidTag(); |
|
default: |
|
if (pb::WireFormat.IsEndGroupTag(tag)) { |
|
return; |
|
} |
|
break; |
|
case 8: { |
|
Item = input.ReadInt32(); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
} |
|
|
|
#endregion |
|
|
|
} |
|
|
|
#endregion Designer generated code
|
|
|