third_party/protobuf/csharp/src/Google.Protobuf.Test/TestProtos/UnittestProto3.cs - Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll).

Side by Side Diff: third_party/protobuf/csharp/src/Google.Protobuf.Test/TestProtos/UnittestProto3.cs

Issue 1322483002: Revert https://codereview.chromium.org/1291903002 (protobuf roll). (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Created 5 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

« no previous file with comments | « third_party/protobuf/csharp/src/Google.Protobuf.Test/TestProtos/UnittestIssues.cs ('k') | third_party/protobuf/csharp/src/Google.Protobuf.Test/TestProtos/UnittestWellKnownTypes.cs » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 // Generated by the protocol buffer compiler. DO NOT EDIT!

2 // source: google/protobuf/unittest_proto3.proto

3 #pragma warning disable 1591, 0612, 3021

4 #region Designer generated code

5

6 using pb = global::Google.Protobuf;

7 using pbc = global::Google.Protobuf.Collections;

8 using pbr = global::Google.Protobuf.Reflection;

9 using scg = global::System.Collections.Generic;

10 namespace Google.Protobuf.TestProtos {

11

12 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

13 public static partial class UnittestProto3 {

14

15 #region Descriptor

16 public static pbr::FileDescriptor Descriptor {

17 get { return descriptor; }

18 }

19 private static pbr::FileDescriptor descriptor;

20

21 static UnittestProto3() {

22 byte[] descriptorData = global::System.Convert.FromBase64String(

23 string.Concat(

24 "CiVnb29nbGUvcHJvdG9idWYvdW5pdHRlc3RfcHJvdG8zLnByb3RvEhFwcm90",

25 "b2J1Zl91bml0dGVzdBosZ29vZ2xlL3Byb3RvYnVmL3VuaXR0ZXN0X2ltcG9y",

26 "dF9wcm90bzMucHJvdG8i8A8KDFRlc3RBbGxUeXBlcxIUCgxzaW5nbGVfaW50",

27 "MzIYASABKAUSFAoMc2luZ2xlX2ludDY0GAIgASgDEhUKDXNpbmdsZV91aW50",

28 "MzIYAyABKA0SFQoNc2luZ2xlX3VpbnQ2NBgEIAEoBBIVCg1zaW5nbGVfc2lu",

29 "dDMyGAUgASgREhUKDXNpbmdsZV9zaW50NjQYBiABKBISFgoOc2luZ2xlX2Zp",

30 "eGVkMzIYByABKAcSFgoOc2luZ2xlX2ZpeGVkNjQYCCABKAYSFwoPc2luZ2xl",

31 "X3NmaXhlZDMyGAkgASgPEhcKD3NpbmdsZV9zZml4ZWQ2NBgKIAEoEBIUCgxz",

32 "aW5nbGVfZmxvYXQYCyABKAISFQoNc2luZ2xlX2RvdWJsZRgMIAEoARITCgtz",

33 "aW5nbGVfYm9vbBgNIAEoCBIVCg1zaW5nbGVfc3RyaW5nGA4gASgJEhQKDHNp",

34 "bmdsZV9ieXRlcxgPIAEoDBJMChVzaW5nbGVfbmVzdGVkX21lc3NhZ2UYEiAB",

35 "KAsyLS5wcm90b2J1Zl91bml0dGVzdC5UZXN0QWxsVHlwZXMuTmVzdGVkTWVz",

36 "c2FnZRJBChZzaW5nbGVfZm9yZWlnbl9tZXNzYWdlGBMgASgLMiEucHJvdG9i",

37 "dWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2USRgoVc2luZ2xlX2ltcG9ydF9t",

38 "ZXNzYWdlGBQgASgLMicucHJvdG9idWZfdW5pdHRlc3RfaW1wb3J0LkltcG9y",

39 "dE1lc3NhZ2USRgoSc2luZ2xlX25lc3RlZF9lbnVtGBUgASgOMioucHJvdG9i",

40 "dWZfdW5pdHRlc3QuVGVzdEFsbFR5cGVzLk5lc3RlZEVudW0SOwoTc2luZ2xl",

41 "X2ZvcmVpZ25fZW51bRgWIAEoDjIeLnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVp",

42 "Z25FbnVtEkAKEnNpbmdsZV9pbXBvcnRfZW51bRgXIAEoDjIkLnByb3RvYnVm",

43 "X3VuaXR0ZXN0X2ltcG9ydC5JbXBvcnRFbnVtElMKHHNpbmdsZV9wdWJsaWNf",

44 "aW1wb3J0X21lc3NhZ2UYGiABKAsyLS5wcm90b2J1Zl91bml0dGVzdF9pbXBv",

45 "cnQuUHVibGljSW1wb3J0TWVzc2FnZRIWCg5yZXBlYXRlZF9pbnQzMhgfIAMo",

46 "BRIWCg5yZXBlYXRlZF9pbnQ2NBggIAMoAxIXCg9yZXBlYXRlZF91aW50MzIY",

47 "ISADKA0SFwoPcmVwZWF0ZWRfdWludDY0GCIgAygEEhcKD3JlcGVhdGVkX3Np",

48 "bnQzMhgjIAMoERIXCg9yZXBlYXRlZF9zaW50NjQYJCADKBISGAoQcmVwZWF0",

49 "ZWRfZml4ZWQzMhglIAMoBxIYChByZXBlYXRlZF9maXhlZDY0GCYgAygGEhkK",

50 "EXJlcGVhdGVkX3NmaXhlZDMyGCcgAygPEhkKEXJlcGVhdGVkX3NmaXhlZDY0",

51 "GCggAygQEhYKDnJlcGVhdGVkX2Zsb2F0GCkgAygCEhcKD3JlcGVhdGVkX2Rv",

52 "dWJsZRgqIAMoARIVCg1yZXBlYXRlZF9ib29sGCsgAygIEhcKD3JlcGVhdGVk",

53 "X3N0cmluZxgsIAMoCRIWCg5yZXBlYXRlZF9ieXRlcxgtIAMoDBJOChdyZXBl",

54 "YXRlZF9uZXN0ZWRfbWVzc2FnZRgwIAMoCzItLnByb3RvYnVmX3VuaXR0ZXN0",

55 "LlRlc3RBbGxUeXBlcy5OZXN0ZWRNZXNzYWdlEkMKGHJlcGVhdGVkX2ZvcmVp",

56 "Z25fbWVzc2FnZRgxIAMoCzIhLnByb3RvYnVmX3VuaXR0ZXN0LkZvcmVpZ25N",

57 "ZXNzYWdlEkgKF3JlcGVhdGVkX2ltcG9ydF9tZXNzYWdlGDIgAygLMicucHJv",

58 "dG9idWZfdW5pdHRlc3RfaW1wb3J0LkltcG9ydE1lc3NhZ2USSAoUcmVwZWF0",

59 "ZWRfbmVzdGVkX2VudW0YMyADKA4yKi5wcm90b2J1Zl91bml0dGVzdC5UZXN0",

60 "QWxsVHlwZXMuTmVzdGVkRW51bRI9ChVyZXBlYXRlZF9mb3JlaWduX2VudW0Y",

61 "NCADKA4yHi5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduRW51bRJCChRyZXBl",

62 "YXRlZF9pbXBvcnRfZW51bRg1IAMoDjIkLnByb3RvYnVmX3VuaXR0ZXN0X2lt",

63 "cG9ydC5JbXBvcnRFbnVtElUKHnJlcGVhdGVkX3B1YmxpY19pbXBvcnRfbWVz",

64 "c2FnZRg2IAMoCzItLnByb3RvYnVmX3VuaXR0ZXN0X2ltcG9ydC5QdWJsaWNJ",

65 "bXBvcnRNZXNzYWdlEhYKDG9uZW9mX3VpbnQzMhhvIAEoDUgAEk0KFG9uZW9m",

66 "X25lc3RlZF9tZXNzYWdlGHAgASgLMi0ucHJvdG9idWZfdW5pdHRlc3QuVGVz",

67 "dEFsbFR5cGVzLk5lc3RlZE1lc3NhZ2VIABIWCgxvbmVvZl9zdHJpbmcYcSAB",

68 "KAlIABIVCgtvbmVvZl9ieXRlcxhyIAEoDEgAGhsKDU5lc3RlZE1lc3NhZ2US",

69 "CgoCYmIYASABKAUiVgoKTmVzdGVkRW51bRIbChdORVNURURfRU5VTV9VTlNQ",

70 "RUNJRklFRBAAEgcKA0ZPTxABEgcKA0JBUhACEgcKA0JBWhADEhAKA05FRxD/",

71 "//////////8BQg0KC29uZW9mX2ZpZWxkIrsBChJOZXN0ZWRUZXN0QWxsVHlw",

72 "ZXMSNAoFY2hpbGQYASABKAsyJS5wcm90b2J1Zl91bml0dGVzdC5OZXN0ZWRU",

73 "ZXN0QWxsVHlwZXMSMAoHcGF5bG9hZBgCIAEoCzIfLnByb3RvYnVmX3VuaXR0",

74 "ZXN0LlRlc3RBbGxUeXBlcxI9Cg5yZXBlYXRlZF9jaGlsZBgDIAMoCzIlLnBy",

75 "b3RvYnVmX3VuaXR0ZXN0Lk5lc3RlZFRlc3RBbGxUeXBlcyI0ChRUZXN0RGVw",

76 "cmVjYXRlZEZpZWxkcxIcChBkZXByZWNhdGVkX2ludDMyGAEgASgFQgIYASIb",

77 "Cg5Gb3JlaWduTWVzc2FnZRIJCgFjGAEgASgFIjAKElRlc3RSZXNlcnZlZEZp",

78 "ZWxkc0oECAIQA0oECA8QEEoECAkQDFIDYmFyUgNiYXoiWgoRVGVzdEZvcmVp",

79 "Z25OZXN0ZWQSRQoOZm9yZWlnbl9uZXN0ZWQYASABKAsyLS5wcm90b2J1Zl91",

80 "bml0dGVzdC5UZXN0QWxsVHlwZXMuTmVzdGVkTWVzc2FnZSI0ChhUZXN0UmVh",

81 "bGx5TGFyZ2VUYWdOdW1iZXISCQoBYRgBIAEoBRINCgJiYhj///9/IAEoBSJV",

82 "ChRUZXN0UmVjdXJzaXZlTWVzc2FnZRIyCgFhGAEgASgLMicucHJvdG9idWZf",

83 "dW5pdHRlc3QuVGVzdFJlY3Vyc2l2ZU1lc3NhZ2USCQoBaRgCIAEoBSJLChRU",

84 "ZXN0TXV0dWFsUmVjdXJzaW9uQRIzCgJiYhgBIAEoCzInLnByb3RvYnVmX3Vu",

85 "aXR0ZXN0LlRlc3RNdXR1YWxSZWN1cnNpb25CImIKFFRlc3RNdXR1YWxSZWN1",

86 "cnNpb25CEjIKAWEYASABKAsyJy5wcm90b2J1Zl91bml0dGVzdC5UZXN0TXV0",

87 "dWFsUmVjdXJzaW9uQRIWCg5vcHRpb25hbF9pbnQzMhgCIAEoBSLrAgoXVGVz",

88 "dENhbWVsQ2FzZUZpZWxkTmFtZXMSFgoOUHJpbWl0aXZlRmllbGQYASABKAUS",

89 "EwoLU3RyaW5nRmllbGQYAiABKAkSMQoJRW51bUZpZWxkGAMgASgOMh4ucHJv",

90 "dG9idWZfdW5pdHRlc3QuRm9yZWlnbkVudW0SNwoMTWVzc2FnZUZpZWxkGAQg",

91 "ASgLMiEucHJvdG9idWZfdW5pdHRlc3QuRm9yZWlnbk1lc3NhZ2USHgoWUmVw",

92 "ZWF0ZWRQcmltaXRpdmVGaWVsZBgHIAMoBRIbChNSZXBlYXRlZFN0cmluZ0Zp",

93 "ZWxkGAggAygJEjkKEVJlcGVhdGVkRW51bUZpZWxkGAkgAygOMh4ucHJvdG9i",

94 "dWZfdW5pdHRlc3QuRm9yZWlnbkVudW0SPwoUUmVwZWF0ZWRNZXNzYWdlRmll",

95 "bGQYCiADKAsyIS5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduTWVzc2FnZSLH",

96 "AQoSVGVzdEZpZWxkT3JkZXJpbmdzEhEKCW15X3N0cmluZxgLIAEoCRIOCgZt",

97 "eV9pbnQYASABKAMSEAoIbXlfZmxvYXQYZSABKAISUwoVc2luZ2xlX25lc3Rl",

98 "ZF9tZXNzYWdlGMgBIAEoCzIzLnByb3RvYnVmX3VuaXR0ZXN0LlRlc3RGaWVs",

99 "ZE9yZGVyaW5ncy5OZXN0ZWRNZXNzYWdlGicKDU5lc3RlZE1lc3NhZ2USCgoC",

100 "b28YAiABKAMSCgoCYmIYASABKAUiSwoRU3BhcnNlRW51bU1lc3NhZ2USNgoL",

101 "c3BhcnNlX2VudW0YASABKA4yIS5wcm90b2J1Zl91bml0dGVzdC5UZXN0U3Bh",

102 "cnNlRW51bSIZCglPbmVTdHJpbmcSDAoEZGF0YRgBIAEoCSIaCgpNb3JlU3Ry",

103 "aW5nEgwKBGRhdGEYASADKAkiGAoIT25lQnl0ZXMSDAoEZGF0YRgBIAEoDCIZ",

104 "CglNb3JlQnl0ZXMSDAoEZGF0YRgBIAEoDCIcCgxJbnQzMk1lc3NhZ2USDAoE",

105 "ZGF0YRgBIAEoBSIdCg1VaW50MzJNZXNzYWdlEgwKBGRhdGEYASABKA0iHAoM",

106 "SW50NjRNZXNzYWdlEgwKBGRhdGEYASABKAMiHQoNVWludDY0TWVzc2FnZRIM",

107 "CgRkYXRhGAEgASgEIhsKC0Jvb2xNZXNzYWdlEgwKBGRhdGEYASABKAgicwoJ",

108 "VGVzdE9uZW9mEhEKB2Zvb19pbnQYASABKAVIABIUCgpmb29fc3RyaW5nGAIg",

109 "ASgJSAASNgoLZm9vX21lc3NhZ2UYAyABKAsyHy5wcm90b2J1Zl91bml0dGVz",

110 "dC5UZXN0QWxsVHlwZXNIAEIFCgNmb28iqgMKD1Rlc3RQYWNrZWRUeXBlcxIY",

111 "CgxwYWNrZWRfaW50MzIYWiADKAVCAhABEhgKDHBhY2tlZF9pbnQ2NBhbIAMo",

112 "A0ICEAESGQoNcGFja2VkX3VpbnQzMhhcIAMoDUICEAESGQoNcGFja2VkX3Vp",

113 "bnQ2NBhdIAMoBEICEAESGQoNcGFja2VkX3NpbnQzMhheIAMoEUICEAESGQoN",

114 "cGFja2VkX3NpbnQ2NBhfIAMoEkICEAESGgoOcGFja2VkX2ZpeGVkMzIYYCAD",

115 "KAdCAhABEhoKDnBhY2tlZF9maXhlZDY0GGEgAygGQgIQARIbCg9wYWNrZWRf",

116 "c2ZpeGVkMzIYYiADKA9CAhABEhsKD3BhY2tlZF9zZml4ZWQ2NBhjIAMoEEIC",

117 "EAESGAoMcGFja2VkX2Zsb2F0GGQgAygCQgIQARIZCg1wYWNrZWRfZG91Ymxl",

118 "GGUgAygBQgIQARIXCgtwYWNrZWRfYm9vbBhmIAMoCEICEAESNwoLcGFja2Vk",

119 "X2VudW0YZyADKA4yHi5wcm90b2J1Zl91bml0dGVzdC5Gb3JlaWduRW51bUIC",

120 "EAEiyAMKEVRlc3RVbnBhY2tlZFR5cGVzEhoKDnVucGFja2VkX2ludDMyGFog",

121 "AygFQgIQABIaCg51bnBhY2tlZF9pbnQ2NBhbIAMoA0ICEAASGwoPdW5wYWNr",

122 "ZWRfdWludDMyGFwgAygNQgIQABIbCg91bnBhY2tlZF91aW50NjQYXSADKARC",

123 "AhAAEhsKD3VucGFja2VkX3NpbnQzMhheIAMoEUICEAASGwoPdW5wYWNrZWRf",

124 "c2ludDY0GF8gAygSQgIQABIcChB1bnBhY2tlZF9maXhlZDMyGGAgAygHQgIQ",

125 "ABIcChB1bnBhY2tlZF9maXhlZDY0GGEgAygGQgIQABIdChF1bnBhY2tlZF9z",

126 "Zml4ZWQzMhhiIAMoD0ICEAASHQoRdW5wYWNrZWRfc2ZpeGVkNjQYYyADKBBC",

127 "AhAAEhoKDnVucGFja2VkX2Zsb2F0GGQgAygCQgIQABIbCg91bnBhY2tlZF9k",

128 "b3VibGUYZSADKAFCAhAAEhkKDXVucGFja2VkX2Jvb2wYZiADKAhCAhAAEjkK",

129 "DXVucGFja2VkX2VudW0YZyADKA4yHi5wcm90b2J1Zl91bml0dGVzdC5Gb3Jl",

130 "aWduRW51bUICEAAiwAEKI1Rlc3RSZXBlYXRlZFNjYWxhckRpZmZlcmVudFRh",

131 "Z1NpemVzEhgKEHJlcGVhdGVkX2ZpeGVkMzIYDCADKAcSFgoOcmVwZWF0ZWRf",

132 "aW50MzIYDSADKAUSGQoQcmVwZWF0ZWRfZml4ZWQ2NBj+DyADKAYSFwoOcmVw",

133 "ZWF0ZWRfaW50NjQY/w8gAygDEhgKDnJlcGVhdGVkX2Zsb2F0GP7/DyADKAIS",

134 "GQoPcmVwZWF0ZWRfdWludDY0GP//DyADKAQiKAobVGVzdENvbW1lbnRJbmpl",

135 "Y3Rpb25NZXNzYWdlEgkKAWEYASABKAkiDAoKRm9vUmVxdWVzdCINCgtGb29S",

136 "ZXNwb25zZSISChBGb29DbGllbnRNZXNzYWdlIhIKEEZvb1NlcnZlck1lc3Nh",

137 "Z2UiDAoKQmFyUmVxdWVzdCINCgtCYXJSZXNwb25zZSpZCgtGb3JlaWduRW51",

138 "bRIXChNGT1JFSUdOX1VOU1BFQ0lGSUVEEAASDwoLRk9SRUlHTl9GT08QBBIP",

139 "CgtGT1JFSUdOX0JBUhAFEg8KC0ZPUkVJR05fQkFaEAYqdQoUVGVzdEVudW1X",

140 "aXRoRHVwVmFsdWUSKAokVEVTVF9FTlVNX1dJVEhfRFVQX1ZBTFVFX1VOU1BF",

141 "Q0lGSUVEEAASCAoERk9PMRABEggKBEJBUjEQAhIHCgNCQVoQAxIICgRGT08y",

142 "EAESCAoEQkFSMhACGgIQASqdAQoOVGVzdFNwYXJzZUVudW0SIAocVEVTVF9T",

143 "UEFSU0VfRU5VTV9VTlNQRUNJRklFRBAAEgwKCFNQQVJTRV9BEHsSDgoIU1BB",

144 "UlNFX0IQpucDEg8KCFNQQVJTRV9DELKxgAYSFQoIU1BBUlNFX0QQ8f//////",

145 "////ARIVCghTUEFSU0VfRRC03vz///////8BEgwKCFNQQVJTRV9HEAIymQEK",

146 "C1Rlc3RTZXJ2aWNlEkQKA0ZvbxIdLnByb3RvYnVmX3VuaXR0ZXN0LkZvb1Jl",

147 "cXVlc3QaHi5wcm90b2J1Zl91bml0dGVzdC5Gb29SZXNwb25zZRJECgNCYXIS",

148 "HS5wcm90b2J1Zl91bml0dGVzdC5CYXJSZXF1ZXN0Gh4ucHJvdG9idWZfdW5p",

149 "dHRlc3QuQmFyUmVzcG9uc2VCOkINVW5pdHRlc3RQcm90b0gBgAEBiAEBkAEB",

150 "+AEBqgIaR29vZ2xlLlByb3RvYnVmLlRlc3RQcm90b3NiBnByb3RvMw=="));

151 descriptor = pbr::FileDescriptor.InternalBuildGeneratedFileFrom(descriptor Data,

152 new pbr::FileDescriptor[] { global::Google.Protobuf.TestProtos.Unittes tImportProto3.Descriptor, },

153 new pbr::GeneratedCodeInfo(new[] {typeof(global::Google.Protobuf.TestP rotos.ForeignEnum), typeof(global::Google.Protobuf.TestProtos.TestEnumWithDupVal ue), typeof(global::Google.Protobuf.TestProtos.TestSparseEnum), }, new pbr::Gene ratedCodeInfo[] {

154 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestAllTypes), new[]{ "SingleInt32", "SingleInt64", "SingleUint32", "SingleUint 64", "SingleSint32", "SingleSint64", "SingleFixed32", "SingleFixed64", "SingleSf ixed32", "SingleSfixed64", "SingleFloat", "SingleDouble", "SingleBool", "SingleS tring", "SingleBytes", "SingleNestedMessage", "SingleForeignMessage", "SingleImp ortMessage", "SingleNestedEnum", "SingleForeignEnum", "SingleImportEnum", "Singl ePublicImportMessage", "RepeatedInt32", "RepeatedInt64", "RepeatedUint32", "Repe atedUint64", "RepeatedSint32", "RepeatedSint64", "RepeatedFixed32", "RepeatedFix ed64", "RepeatedSfixed32", "RepeatedSfixed64", "RepeatedFloat", "RepeatedDouble" , "RepeatedBool", "RepeatedString", "RepeatedBytes", "RepeatedNestedMessage", "R epeatedForeignMessage", "RepeatedImportMessage", "RepeatedNestedEnum", "Repeated ForeignEnum", "RepeatedImportEnum", "RepeatedPublicImportMessage", "OneofUint32" , "OneofNestedMessage", "OneofString", "OneofBytes" }, new[]{ "OneofField" }, ne w[]{ typeof(global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum) }, new pbr::GeneratedCodeInfo[] { new pbr::GeneratedCodeInfo(typeof(global::Google .Protobuf.TestProtos.TestAllTypes.Types.NestedMessage), new[]{ "Bb" }, null, nul l, null)}),

155 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .NestedTestAllTypes), new[]{ "Child", "Payload", "RepeatedChild" }, null, null, null),

156 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestDeprecatedFields), new[]{ "DeprecatedInt32" }, null, null, null),

157 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .ForeignMessage), new[]{ "C" }, null, null, null),

158 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestReservedFields), null, null, null, null),

159 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestForeignNested), new[]{ "ForeignNested" }, null, null, null),

160 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestReallyLargeTagNumber), new[]{ "A", "Bb" }, null, null, null),

161 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestRecursiveMessage), new[]{ "A", "I" }, null, null, null),

162 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestMutualRecursionA), new[]{ "Bb" }, null, null, null),

163 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestMutualRecursionB), new[]{ "A", "OptionalInt32" }, null, null, null),

164 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestCamelCaseFieldNames), new[]{ "PrimitiveField", "StringField", "EnumField", "MessageField", "RepeatedPrimitiveField", "RepeatedStringField", "RepeatedEnumFi eld", "RepeatedMessageField" }, null, null, null),

165 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestFieldOrderings), new[]{ "MyString", "MyInt", "MyFloat", "SingleNestedMessag e" }, null, null, new pbr::GeneratedCodeInfo[] { new pbr::GeneratedCodeInfo(type of(global::Google.Protobuf.TestProtos.TestFieldOrderings.Types.NestedMessage), n ew[]{ "Oo", "Bb" }, null, null, null)}),

166 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .SparseEnumMessage), new[]{ "SparseEnum" }, null, null, null),

167 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .OneString), new[]{ "Data" }, null, null, null),

168 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .MoreString), new[]{ "Data" }, null, null, null),

169 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .OneBytes), new[]{ "Data" }, null, null, null),

170 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .MoreBytes), new[]{ "Data" }, null, null, null),

171 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .Int32Message), new[]{ "Data" }, null, null, null),

172 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .Uint32Message), new[]{ "Data" }, null, null, null),

173 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .Int64Message), new[]{ "Data" }, null, null, null),

174 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .Uint64Message), new[]{ "Data" }, null, null, null),

175 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .BoolMessage), new[]{ "Data" }, null, null, null),

176 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestOneof), new[]{ "FooInt", "FooString", "FooMessage" }, new[]{ "Foo" }, null, null),

177 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestPackedTypes), new[]{ "PackedInt32", "PackedInt64", "PackedUint32", "PackedU int64", "PackedSint32", "PackedSint64", "PackedFixed32", "PackedFixed64", "Packe dSfixed32", "PackedSfixed64", "PackedFloat", "PackedDouble", "PackedBool", "Pack edEnum" }, null, null, null),

178 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestUnpackedTypes), new[]{ "UnpackedInt32", "UnpackedInt64", "UnpackedUint32", "UnpackedUint64", "UnpackedSint32", "UnpackedSint64", "UnpackedFixed32", "Unpack edFixed64", "UnpackedSfixed32", "UnpackedSfixed64", "UnpackedFloat", "UnpackedDo uble", "UnpackedBool", "UnpackedEnum" }, null, null, null),

179 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestRepeatedScalarDifferentTagSizes), new[]{ "RepeatedFixed32", "RepeatedInt32" , "RepeatedFixed64", "RepeatedInt64", "RepeatedFloat", "RepeatedUint64" }, null, null, null),

180 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .TestCommentInjectionMessage), new[]{ "A" }, null, null, null),

181 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .FooRequest), null, null, null, null),

182 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .FooResponse), null, null, null, null),

183 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .FooClientMessage), null, null, null, null),

184 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .FooServerMessage), null, null, null, null),

185 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .BarRequest), null, null, null, null),

186 new pbr::GeneratedCodeInfo(typeof(global::Google.Protobuf.TestProtos .BarResponse), null, null, null, null)

187 }));

188 }

189 #endregion

190

191 }

192 #region Enums

193 public enum ForeignEnum {

194 FOREIGN_UNSPECIFIED = 0,

195 FOREIGN_FOO = 4,

196 FOREIGN_BAR = 5,

197 FOREIGN_BAZ = 6,

198 }

199

200 public enum TestEnumWithDupValue {

201 TEST_ENUM_WITH_DUP_VALUE_UNSPECIFIED = 0,

202 FOO1 = 1,

203 BAR1 = 2,

204 BAZ = 3,

205 FOO2 = 1,

206 BAR2 = 2,

207 }

208

209 public enum TestSparseEnum {

210 TEST_SPARSE_ENUM_UNSPECIFIED = 0,

211 SPARSE_A = 123,

212 SPARSE_B = 62374,

213 SPARSE_C = 12589234,

214 SPARSE_D = -15,

215 SPARSE_E = -53452,

216 SPARSE_G = 2,

217 }

218

219 #endregion

220

221 #region Messages

222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

223 public sealed partial class TestAllTypes : pb::IMessage<TestAllTypes> {

224 private static readonly pb::MessageParser<TestAllTypes> _parser = new pb::Me ssageParser<TestAllTypes>(() => new TestAllTypes());

225 public static pb::MessageParser<TestAllTypes> Parser { get { return _parser; } }

226

227 public static pbr::MessageDescriptor Descriptor {

228 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[0]; }

229 }

230

231 pbr::MessageDescriptor pb::IMessage.Descriptor {

232 get { return Descriptor; }

233 }

234

235 public TestAllTypes() {

236 OnConstruction();

237 }

238

239 partial void OnConstruction();

240

241 public TestAllTypes(TestAllTypes other) : this() {

242 singleInt32_ = other.singleInt32_;

243 singleInt64_ = other.singleInt64_;

244 singleUint32_ = other.singleUint32_;

245 singleUint64_ = other.singleUint64_;

246 singleSint32_ = other.singleSint32_;

247 singleSint64_ = other.singleSint64_;

248 singleFixed32_ = other.singleFixed32_;

249 singleFixed64_ = other.singleFixed64_;

250 singleSfixed32_ = other.singleSfixed32_;

251 singleSfixed64_ = other.singleSfixed64_;

252 singleFloat_ = other.singleFloat_;

253 singleDouble_ = other.singleDouble_;

254 singleBool_ = other.singleBool_;

255 singleString_ = other.singleString_;

256 singleBytes_ = other.singleBytes_;

257 SingleNestedMessage = other.singleNestedMessage_ != null ? other.SingleNes tedMessage.Clone() : null;

258 SingleForeignMessage = other.singleForeignMessage_ != null ? other.SingleF oreignMessage.Clone() : null;

259 SingleImportMessage = other.singleImportMessage_ != null ? other.SingleImp ortMessage.Clone() : null;

260 singleNestedEnum_ = other.singleNestedEnum_;

261 singleForeignEnum_ = other.singleForeignEnum_;

262 singleImportEnum_ = other.singleImportEnum_;

263 SinglePublicImportMessage = other.singlePublicImportMessage_ != null ? oth er.SinglePublicImportMessage.Clone() : null;

264 repeatedInt32_ = other.repeatedInt32_.Clone();

265 repeatedInt64_ = other.repeatedInt64_.Clone();

266 repeatedUint32_ = other.repeatedUint32_.Clone();

267 repeatedUint64_ = other.repeatedUint64_.Clone();

268 repeatedSint32_ = other.repeatedSint32_.Clone();

269 repeatedSint64_ = other.repeatedSint64_.Clone();

270 repeatedFixed32_ = other.repeatedFixed32_.Clone();

271 repeatedFixed64_ = other.repeatedFixed64_.Clone();

272 repeatedSfixed32_ = other.repeatedSfixed32_.Clone();

273 repeatedSfixed64_ = other.repeatedSfixed64_.Clone();

274 repeatedFloat_ = other.repeatedFloat_.Clone();

275 repeatedDouble_ = other.repeatedDouble_.Clone();

276 repeatedBool_ = other.repeatedBool_.Clone();

277 repeatedString_ = other.repeatedString_.Clone();

278 repeatedBytes_ = other.repeatedBytes_.Clone();

279 repeatedNestedMessage_ = other.repeatedNestedMessage_.Clone();

280 repeatedForeignMessage_ = other.repeatedForeignMessage_.Clone();

281 repeatedImportMessage_ = other.repeatedImportMessage_.Clone();

282 repeatedNestedEnum_ = other.repeatedNestedEnum_.Clone();

283 repeatedForeignEnum_ = other.repeatedForeignEnum_.Clone();

284 repeatedImportEnum_ = other.repeatedImportEnum_.Clone();

285 repeatedPublicImportMessage_ = other.repeatedPublicImportMessage_.Clone();

286 switch (other.OneofFieldCase) {

287 case OneofFieldOneofCase.OneofUint32:

288 OneofUint32 = other.OneofUint32;

289 break;

290 case OneofFieldOneofCase.OneofNestedMessage:

291 OneofNestedMessage = other.OneofNestedMessage.Clone();

292 break;

293 case OneofFieldOneofCase.OneofString:

294 OneofString = other.OneofString;

295 break;

296 case OneofFieldOneofCase.OneofBytes:

297 OneofBytes = other.OneofBytes;

298 break;

299 }

300

301 }

302

303 public TestAllTypes Clone() {

304 return new TestAllTypes(this);

305 }

306

307 public const int SingleInt32FieldNumber = 1;

308 private int singleInt32_;

309 public int SingleInt32 {

310 get { return singleInt32_; }

311 set {

312 singleInt32_ = value;

313 }

314 }

315

316 public const int SingleInt64FieldNumber = 2;

317 private long singleInt64_;

318 public long SingleInt64 {

319 get { return singleInt64_; }

320 set {

321 singleInt64_ = value;

322 }

323 }

324

325 public const int SingleUint32FieldNumber = 3;

326 private uint singleUint32_;

327 public uint SingleUint32 {

328 get { return singleUint32_; }

329 set {

330 singleUint32_ = value;

331 }

332 }

333

334 public const int SingleUint64FieldNumber = 4;

335 private ulong singleUint64_;

336 public ulong SingleUint64 {

337 get { return singleUint64_; }

338 set {

339 singleUint64_ = value;

340 }

341 }

342

343 public const int SingleSint32FieldNumber = 5;

344 private int singleSint32_;

345 public int SingleSint32 {

346 get { return singleSint32_; }

347 set {

348 singleSint32_ = value;

349 }

350 }

351

352 public const int SingleSint64FieldNumber = 6;

353 private long singleSint64_;

354 public long SingleSint64 {

355 get { return singleSint64_; }

356 set {

357 singleSint64_ = value;

358 }

359 }

360

361 public const int SingleFixed32FieldNumber = 7;

362 private uint singleFixed32_;

363 public uint SingleFixed32 {

364 get { return singleFixed32_; }

365 set {

366 singleFixed32_ = value;

367 }

368 }

369

370 public const int SingleFixed64FieldNumber = 8;

371 private ulong singleFixed64_;

372 public ulong SingleFixed64 {

373 get { return singleFixed64_; }

374 set {

375 singleFixed64_ = value;

376 }

377 }

378

379 public const int SingleSfixed32FieldNumber = 9;

380 private int singleSfixed32_;

381 public int SingleSfixed32 {

382 get { return singleSfixed32_; }

383 set {

384 singleSfixed32_ = value;

385 }

386 }

387

388 public const int SingleSfixed64FieldNumber = 10;

389 private long singleSfixed64_;

390 public long SingleSfixed64 {

391 get { return singleSfixed64_; }

392 set {

393 singleSfixed64_ = value;

394 }

395 }

396

397 public const int SingleFloatFieldNumber = 11;

398 private float singleFloat_;

399 public float SingleFloat {

400 get { return singleFloat_; }

401 set {

402 singleFloat_ = value;

403 }

404 }

405

406 public const int SingleDoubleFieldNumber = 12;

407 private double singleDouble_;

408 public double SingleDouble {

409 get { return singleDouble_; }

410 set {

411 singleDouble_ = value;

412 }

413 }

414

415 public const int SingleBoolFieldNumber = 13;

416 private bool singleBool_;

417 public bool SingleBool {

418 get { return singleBool_; }

419 set {

420 singleBool_ = value;

421 }

422 }

423

424 public const int SingleStringFieldNumber = 14;

425 private string singleString_ = "";

426 public string SingleString {

427 get { return singleString_; }

428 set {

429 singleString_ = pb::Preconditions.CheckNotNull(value, "value");

430 }

431 }

432

433 public const int SingleBytesFieldNumber = 15;

434 private pb::ByteString singleBytes_ = pb::ByteString.Empty;

435 public pb::ByteString SingleBytes {

436 get { return singleBytes_; }

437 set {

438 singleBytes_ = pb::Preconditions.CheckNotNull(value, "value");

439 }

440 }

441

442 public const int SingleNestedMessageFieldNumber = 18;

443 private global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage singleNestedMessage_;

444 public global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage S ingleNestedMessage {

445 get { return singleNestedMessage_; }

446 set {

447 singleNestedMessage_ = value;

448 }

449 }

450

451 public const int SingleForeignMessageFieldNumber = 19;

452 private global::Google.Protobuf.TestProtos.ForeignMessage singleForeignMessa ge_;

453 public global::Google.Protobuf.TestProtos.ForeignMessage SingleForeignMessag e {

454 get { return singleForeignMessage_; }

455 set {

456 singleForeignMessage_ = value;

457 }

458 }

459

460 public const int SingleImportMessageFieldNumber = 20;

461 private global::Google.Protobuf.TestProtos.ImportMessage singleImportMessage _;

462 public global::Google.Protobuf.TestProtos.ImportMessage SingleImportMessage {

463 get { return singleImportMessage_; }

464 set {

465 singleImportMessage_ = value;

466 }

467 }

468

469 public const int SingleNestedEnumFieldNumber = 21;

470 private global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum sin gleNestedEnum_ = global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnu m.NESTED_ENUM_UNSPECIFIED;

471 public global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum Sing leNestedEnum {

472 get { return singleNestedEnum_; }

473 set {

474 singleNestedEnum_ = value;

475 }

476 }

477

478 public const int SingleForeignEnumFieldNumber = 22;

479 private global::Google.Protobuf.TestProtos.ForeignEnum singleForeignEnum_ = global::Google.Protobuf.TestProtos.ForeignEnum.FOREIGN_UNSPECIFIED;

480 public global::Google.Protobuf.TestProtos.ForeignEnum SingleForeignEnum {

481 get { return singleForeignEnum_; }

482 set {

483 singleForeignEnum_ = value;

484 }

485 }

486

487 public const int SingleImportEnumFieldNumber = 23;

488 private global::Google.Protobuf.TestProtos.ImportEnum singleImportEnum_ = gl obal::Google.Protobuf.TestProtos.ImportEnum.IMPORT_ENUM_UNSPECIFIED;

489 public global::Google.Protobuf.TestProtos.ImportEnum SingleImportEnum {

490 get { return singleImportEnum_; }

491 set {

492 singleImportEnum_ = value;

493 }

494 }

495

496 public const int SinglePublicImportMessageFieldNumber = 26;

497 private global::Google.Protobuf.TestProtos.PublicImportMessage singlePublicI mportMessage_;

498 public global::Google.Protobuf.TestProtos.PublicImportMessage SinglePublicIm portMessage {

499 get { return singlePublicImportMessage_; }

500 set {

501 singlePublicImportMessage_ = value;

502 }

503 }

504

505 public const int RepeatedInt32FieldNumber = 31;

506 private static readonly pb::FieldCodec<int> _repeated_repeatedInt32_codec

507 = pb::FieldCodec.ForInt32(250);

508 private readonly pbc::RepeatedField<int> repeatedInt32_ = new pbc::RepeatedF ield<int>();

509 public pbc::RepeatedField<int> RepeatedInt32 {

510 get { return repeatedInt32_; }

511 }

512

513 public const int RepeatedInt64FieldNumber = 32;

514 private static readonly pb::FieldCodec<long> _repeated_repeatedInt64_codec

515 = pb::FieldCodec.ForInt64(258);

516 private readonly pbc::RepeatedField<long> repeatedInt64_ = new pbc::Repeated Field<long>();

517 public pbc::RepeatedField<long> RepeatedInt64 {

518 get { return repeatedInt64_; }

519 }

520

521 public const int RepeatedUint32FieldNumber = 33;

522 private static readonly pb::FieldCodec<uint> _repeated_repeatedUint32_codec

523 = pb::FieldCodec.ForUInt32(266);

524 private readonly pbc::RepeatedField<uint> repeatedUint32_ = new pbc::Repeate dField<uint>();

525 public pbc::RepeatedField<uint> RepeatedUint32 {

526 get { return repeatedUint32_; }

527 }

528

529 public const int RepeatedUint64FieldNumber = 34;

530 private static readonly pb::FieldCodec<ulong> _repeated_repeatedUint64_codec

531 = pb::FieldCodec.ForUInt64(274);

532 private readonly pbc::RepeatedField<ulong> repeatedUint64_ = new pbc::Repeat edField<ulong>();

533 public pbc::RepeatedField<ulong> RepeatedUint64 {

534 get { return repeatedUint64_; }

535 }

536

537 public const int RepeatedSint32FieldNumber = 35;

538 private static readonly pb::FieldCodec<int> _repeated_repeatedSint32_codec

539 = pb::FieldCodec.ForSInt32(282);

540 private readonly pbc::RepeatedField<int> repeatedSint32_ = new pbc::Repeated Field<int>();

541 public pbc::RepeatedField<int> RepeatedSint32 {

542 get { return repeatedSint32_; }

543 }

544

545 public const int RepeatedSint64FieldNumber = 36;

546 private static readonly pb::FieldCodec<long> _repeated_repeatedSint64_codec

547 = pb::FieldCodec.ForSInt64(290);

548 private readonly pbc::RepeatedField<long> repeatedSint64_ = new pbc::Repeate dField<long>();

549 public pbc::RepeatedField<long> RepeatedSint64 {

550 get { return repeatedSint64_; }

551 }

552

553 public const int RepeatedFixed32FieldNumber = 37;

554 private static readonly pb::FieldCodec<uint> _repeated_repeatedFixed32_codec

555 = pb::FieldCodec.ForFixed32(298);

556 private readonly pbc::RepeatedField<uint> repeatedFixed32_ = new pbc::Repeat edField<uint>();

557 public pbc::RepeatedField<uint> RepeatedFixed32 {

558 get { return repeatedFixed32_; }

559 }

560

561 public const int RepeatedFixed64FieldNumber = 38;

562 private static readonly pb::FieldCodec<ulong> _repeated_repeatedFixed64_code c

563 = pb::FieldCodec.ForFixed64(306);

564 private readonly pbc::RepeatedField<ulong> repeatedFixed64_ = new pbc::Repea tedField<ulong>();

565 public pbc::RepeatedField<ulong> RepeatedFixed64 {

566 get { return repeatedFixed64_; }

567 }

568

569 public const int RepeatedSfixed32FieldNumber = 39;

570 private static readonly pb::FieldCodec<int> _repeated_repeatedSfixed32_codec

571 = pb::FieldCodec.ForSFixed32(314);

572 private readonly pbc::RepeatedField<int> repeatedSfixed32_ = new pbc::Repeat edField<int>();

573 public pbc::RepeatedField<int> RepeatedSfixed32 {

574 get { return repeatedSfixed32_; }

575 }

576

577 public const int RepeatedSfixed64FieldNumber = 40;

578 private static readonly pb::FieldCodec<long> _repeated_repeatedSfixed64_code c

579 = pb::FieldCodec.ForSFixed64(322);

580 private readonly pbc::RepeatedField<long> repeatedSfixed64_ = new pbc::Repea tedField<long>();

581 public pbc::RepeatedField<long> RepeatedSfixed64 {

582 get { return repeatedSfixed64_; }

583 }

584

585 public const int RepeatedFloatFieldNumber = 41;

586 private static readonly pb::FieldCodec<float> _repeated_repeatedFloat_codec

587 = pb::FieldCodec.ForFloat(330);

588 private readonly pbc::RepeatedField<float> repeatedFloat_ = new pbc::Repeate dField<float>();

589 public pbc::RepeatedField<float> RepeatedFloat {

590 get { return repeatedFloat_; }

591 }

592

593 public const int RepeatedDoubleFieldNumber = 42;

594 private static readonly pb::FieldCodec<double> _repeated_repeatedDouble_code c

595 = pb::FieldCodec.ForDouble(338);

596 private readonly pbc::RepeatedField<double> repeatedDouble_ = new pbc::Repea tedField<double>();

597 public pbc::RepeatedField<double> RepeatedDouble {

598 get { return repeatedDouble_; }

599 }

600

601 public const int RepeatedBoolFieldNumber = 43;

602 private static readonly pb::FieldCodec<bool> _repeated_repeatedBool_codec

603 = pb::FieldCodec.ForBool(346);

604 private readonly pbc::RepeatedField<bool> repeatedBool_ = new pbc::RepeatedF ield<bool>();

605 public pbc::RepeatedField<bool> RepeatedBool {

606 get { return repeatedBool_; }

607 }

608

609 public const int RepeatedStringFieldNumber = 44;

610 private static readonly pb::FieldCodec<string> _repeated_repeatedString_code c

611 = pb::FieldCodec.ForString(354);

612 private readonly pbc::RepeatedField<string> repeatedString_ = new pbc::Repea tedField<string>();

613 public pbc::RepeatedField<string> RepeatedString {

614 get { return repeatedString_; }

615 }

616

617 public const int RepeatedBytesFieldNumber = 45;

618 private static readonly pb::FieldCodec<pb::ByteString> _repeated_repeatedByt es_codec

619 = pb::FieldCodec.ForBytes(362);

620 private readonly pbc::RepeatedField<pb::ByteString> repeatedBytes_ = new pbc ::RepeatedField<pb::ByteString>();

621 public pbc::RepeatedField<pb::ByteString> RepeatedBytes {

622 get { return repeatedBytes_; }

623 }

624

625 public const int RepeatedNestedMessageFieldNumber = 48;

626 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Te stAllTypes.Types.NestedMessage> _repeated_repeatedNestedMessage_codec

627 = pb::FieldCodec.ForMessage(386, global::Google.Protobuf.TestProtos.Test AllTypes.Types.NestedMessage.Parser);

628 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestA llTypes.Types.NestedMessage> repeatedNestedMessage_ = new pbc::RepeatedField<glo bal::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage>();

629 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Ty pes.NestedMessage> RepeatedNestedMessage {

630 get { return repeatedNestedMessage_; }

631 }

632

633 public const int RepeatedForeignMessageFieldNumber = 49;

634 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Fo reignMessage> _repeated_repeatedForeignMessage_codec

635 = pb::FieldCodec.ForMessage(394, global::Google.Protobuf.TestProtos.Fore ignMessage.Parser);

636 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Forei gnMessage> repeatedForeignMessage_ = new pbc::RepeatedField<global::Google.Proto buf.TestProtos.ForeignMessage>();

637 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> RepeatedForeignMessage {

638 get { return repeatedForeignMessage_; }

639 }

640

641 public const int RepeatedImportMessageFieldNumber = 50;

642 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Im portMessage> _repeated_repeatedImportMessage_codec

643 = pb::FieldCodec.ForMessage(402, global::Google.Protobuf.TestProtos.Impo rtMessage.Parser);

644 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Impor tMessage> repeatedImportMessage_ = new pbc::RepeatedField<global::Google.Protobu f.TestProtos.ImportMessage>();

645 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportMessage> RepeatedImportMessage {

646 get { return repeatedImportMessage_; }

647 }

648

649 public const int RepeatedNestedEnumFieldNumber = 51;

650 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Te stAllTypes.Types.NestedEnum> _repeated_repeatedNestedEnum_codec

651 = pb::FieldCodec.ForEnum(410, x => (int) x, x => (global::Google.Protobu f.TestProtos.TestAllTypes.Types.NestedEnum) x);

652 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestA llTypes.Types.NestedEnum> repeatedNestedEnum_ = new pbc::RepeatedField<global::G oogle.Protobuf.TestProtos.TestAllTypes.Types.NestedEnum>();

653 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.TestAllTypes.Ty pes.NestedEnum> RepeatedNestedEnum {

654 get { return repeatedNestedEnum_; }

655 }

656

657 public const int RepeatedForeignEnumFieldNumber = 52;

658 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Fo reignEnum> _repeated_repeatedForeignEnum_codec

659 = pb::FieldCodec.ForEnum(418, x => (int) x, x => (global::Google.Protobu f.TestProtos.ForeignEnum) x);

660 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Forei gnEnum> repeatedForeignEnum_ = new pbc::RepeatedField<global::Google.Protobuf.Te stProtos.ForeignEnum>();

661 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> Re peatedForeignEnum {

662 get { return repeatedForeignEnum_; }

663 }

664

665 public const int RepeatedImportEnumFieldNumber = 53;

666 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Im portEnum> _repeated_repeatedImportEnum_codec

667 = pb::FieldCodec.ForEnum(426, x => (int) x, x => (global::Google.Protobu f.TestProtos.ImportEnum) x);

668 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Impor tEnum> repeatedImportEnum_ = new pbc::RepeatedField<global::Google.Protobuf.Test Protos.ImportEnum>();

669 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ImportEnum> Rep eatedImportEnum {

670 get { return repeatedImportEnum_; }

671 }

672

673 public const int RepeatedPublicImportMessageFieldNumber = 54;

674 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Pu blicImportMessage> _repeated_repeatedPublicImportMessage_codec

675 = pb::FieldCodec.ForMessage(434, global::Google.Protobuf.TestProtos.Publ icImportMessage.Parser);

676 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Publi cImportMessage> repeatedPublicImportMessage_ = new pbc::RepeatedField<global::Go ogle.Protobuf.TestProtos.PublicImportMessage>();

677 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.PublicImportMes sage> RepeatedPublicImportMessage {

678 get { return repeatedPublicImportMessage_; }

679 }

680

681 public const int OneofUint32FieldNumber = 111;

682 public uint OneofUint32 {

683 get { return oneofFieldCase_ == OneofFieldOneofCase.OneofUint32 ? (uint) o neofField_ : 0; }

684 set {

685 oneofField_ = value;

686 oneofFieldCase_ = OneofFieldOneofCase.OneofUint32;

687 }

688 }

689

690 public const int OneofNestedMessageFieldNumber = 112;

691 public global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage O neofNestedMessage {

692 get { return oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage ? ( global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage) oneofField_ : null; }

693 set {

694 oneofField_ = value;

695 oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldO neofCase.OneofNestedMessage;

696 }

697 }

698

699 public const int OneofStringFieldNumber = 113;

700 public string OneofString {

701 get { return oneofFieldCase_ == OneofFieldOneofCase.OneofString ? (string) oneofField_ : ""; }

702 set {

703 oneofField_ = pb::Preconditions.CheckNotNull(value, "value");

704 oneofFieldCase_ = OneofFieldOneofCase.OneofString;

705 }

706 }

707

708 public const int OneofBytesFieldNumber = 114;

709 public pb::ByteString OneofBytes {

710 get { return oneofFieldCase_ == OneofFieldOneofCase.OneofBytes ? (pb::Byte String) oneofField_ : pb::ByteString.Empty; }

711 set {

712 oneofField_ = pb::Preconditions.CheckNotNull(value, "value");

713 oneofFieldCase_ = OneofFieldOneofCase.OneofBytes;

714 }

715 }

716

717 private object oneofField_;

718 public enum OneofFieldOneofCase {

719 None = 0,

720 OneofUint32 = 111,

721 OneofNestedMessage = 112,

722 OneofString = 113,

723 OneofBytes = 114,

724 }

725 private OneofFieldOneofCase oneofFieldCase_ = OneofFieldOneofCase.None;

726 public OneofFieldOneofCase OneofFieldCase {

727 get { return oneofFieldCase_; }

728 }

729

730 public void ClearOneofField() {

731 oneofFieldCase_ = OneofFieldOneofCase.None;

732 oneofField_ = null;

733 }

734

735 public override bool Equals(object other) {

736 return Equals(other as TestAllTypes);

737 }

738

739 public bool Equals(TestAllTypes other) {

740 if (ReferenceEquals(other, null)) {

741 return false;

742 }

743 if (ReferenceEquals(other, this)) {

744 return true;

745 }

746 if (SingleInt32 != other.SingleInt32) return false;

747 if (SingleInt64 != other.SingleInt64) return false;

748 if (SingleUint32 != other.SingleUint32) return false;

749 if (SingleUint64 != other.SingleUint64) return false;

750 if (SingleSint32 != other.SingleSint32) return false;

751 if (SingleSint64 != other.SingleSint64) return false;

752 if (SingleFixed32 != other.SingleFixed32) return false;

753 if (SingleFixed64 != other.SingleFixed64) return false;

754 if (SingleSfixed32 != other.SingleSfixed32) return false;

755 if (SingleSfixed64 != other.SingleSfixed64) return false;

756 if (SingleFloat != other.SingleFloat) return false;

757 if (SingleDouble != other.SingleDouble) return false;

758 if (SingleBool != other.SingleBool) return false;

759 if (SingleString != other.SingleString) return false;

760 if (SingleBytes != other.SingleBytes) return false;

761 if (!object.Equals(SingleNestedMessage, other.SingleNestedMessage)) return false;

762 if (!object.Equals(SingleForeignMessage, other.SingleForeignMessage)) retu rn false;

763 if (!object.Equals(SingleImportMessage, other.SingleImportMessage)) return false;

764 if (SingleNestedEnum != other.SingleNestedEnum) return false;

765 if (SingleForeignEnum != other.SingleForeignEnum) return false;

766 if (SingleImportEnum != other.SingleImportEnum) return false;

767 if (!object.Equals(SinglePublicImportMessage, other.SinglePublicImportMess age)) return false;

768 if(!repeatedInt32_.Equals(other.repeatedInt32_)) return false;

769 if(!repeatedInt64_.Equals(other.repeatedInt64_)) return false;

770 if(!repeatedUint32_.Equals(other.repeatedUint32_)) return false;

771 if(!repeatedUint64_.Equals(other.repeatedUint64_)) return false;

772 if(!repeatedSint32_.Equals(other.repeatedSint32_)) return false;

773 if(!repeatedSint64_.Equals(other.repeatedSint64_)) return false;

774 if(!repeatedFixed32_.Equals(other.repeatedFixed32_)) return false;

775 if(!repeatedFixed64_.Equals(other.repeatedFixed64_)) return false;

776 if(!repeatedSfixed32_.Equals(other.repeatedSfixed32_)) return false;

777 if(!repeatedSfixed64_.Equals(other.repeatedSfixed64_)) return false;

778 if(!repeatedFloat_.Equals(other.repeatedFloat_)) return false;

779 if(!repeatedDouble_.Equals(other.repeatedDouble_)) return false;

780 if(!repeatedBool_.Equals(other.repeatedBool_)) return false;

781 if(!repeatedString_.Equals(other.repeatedString_)) return false;

782 if(!repeatedBytes_.Equals(other.repeatedBytes_)) return false;

783 if(!repeatedNestedMessage_.Equals(other.repeatedNestedMessage_)) return fa lse;

784 if(!repeatedForeignMessage_.Equals(other.repeatedForeignMessage_)) return false;

785 if(!repeatedImportMessage_.Equals(other.repeatedImportMessage_)) return fa lse;

786 if(!repeatedNestedEnum_.Equals(other.repeatedNestedEnum_)) return false;

787 if(!repeatedForeignEnum_.Equals(other.repeatedForeignEnum_)) return false;

788 if(!repeatedImportEnum_.Equals(other.repeatedImportEnum_)) return false;

789 if(!repeatedPublicImportMessage_.Equals(other.repeatedPublicImportMessage_ )) return false;

790 if (OneofUint32 != other.OneofUint32) return false;

791 if (!object.Equals(OneofNestedMessage, other.OneofNestedMessage)) return f alse;

792 if (OneofString != other.OneofString) return false;

793 if (OneofBytes != other.OneofBytes) return false;

794 return true;

795 }

796

797 public override int GetHashCode() {

798 int hash = 1;

799 if (SingleInt32 != 0) hash ^= SingleInt32.GetHashCode();

800 if (SingleInt64 != 0L) hash ^= SingleInt64.GetHashCode();

801 if (SingleUint32 != 0) hash ^= SingleUint32.GetHashCode();

802 if (SingleUint64 != 0UL) hash ^= SingleUint64.GetHashCode();

803 if (SingleSint32 != 0) hash ^= SingleSint32.GetHashCode();

804 if (SingleSint64 != 0L) hash ^= SingleSint64.GetHashCode();

805 if (SingleFixed32 != 0) hash ^= SingleFixed32.GetHashCode();

806 if (SingleFixed64 != 0UL) hash ^= SingleFixed64.GetHashCode();

807 if (SingleSfixed32 != 0) hash ^= SingleSfixed32.GetHashCode();

808 if (SingleSfixed64 != 0L) hash ^= SingleSfixed64.GetHashCode();

809 if (SingleFloat != 0F) hash ^= SingleFloat.GetHashCode();

810 if (SingleDouble != 0D) hash ^= SingleDouble.GetHashCode();

811 if (SingleBool != false) hash ^= SingleBool.GetHashCode();

812 if (SingleString.Length != 0) hash ^= SingleString.GetHashCode();

813 if (SingleBytes.Length != 0) hash ^= SingleBytes.GetHashCode();

814 if (singleNestedMessage_ != null) hash ^= SingleNestedMessage.GetHashCode( );

815 if (singleForeignMessage_ != null) hash ^= SingleForeignMessage.GetHashCod e();

816 if (singleImportMessage_ != null) hash ^= SingleImportMessage.GetHashCode( );

817 if (SingleNestedEnum != global::Google.Protobuf.TestProtos.TestAllTypes.Ty pes.NestedEnum.NESTED_ENUM_UNSPECIFIED) hash ^= SingleNestedEnum.GetHashCode();

818 if (SingleForeignEnum != global::Google.Protobuf.TestProtos.ForeignEnum.FO REIGN_UNSPECIFIED) hash ^= SingleForeignEnum.GetHashCode();

819 if (SingleImportEnum != global::Google.Protobuf.TestProtos.ImportEnum.IMPO RT_ENUM_UNSPECIFIED) hash ^= SingleImportEnum.GetHashCode();

820 if (singlePublicImportMessage_ != null) hash ^= SinglePublicImportMessage. GetHashCode();

821 hash ^= repeatedInt32_.GetHashCode();

822 hash ^= repeatedInt64_.GetHashCode();

823 hash ^= repeatedUint32_.GetHashCode();

824 hash ^= repeatedUint64_.GetHashCode();

825 hash ^= repeatedSint32_.GetHashCode();

826 hash ^= repeatedSint64_.GetHashCode();

827 hash ^= repeatedFixed32_.GetHashCode();

828 hash ^= repeatedFixed64_.GetHashCode();

829 hash ^= repeatedSfixed32_.GetHashCode();

830 hash ^= repeatedSfixed64_.GetHashCode();

831 hash ^= repeatedFloat_.GetHashCode();

832 hash ^= repeatedDouble_.GetHashCode();

833 hash ^= repeatedBool_.GetHashCode();

834 hash ^= repeatedString_.GetHashCode();

835 hash ^= repeatedBytes_.GetHashCode();

836 hash ^= repeatedNestedMessage_.GetHashCode();

837 hash ^= repeatedForeignMessage_.GetHashCode();

838 hash ^= repeatedImportMessage_.GetHashCode();

839 hash ^= repeatedNestedEnum_.GetHashCode();

840 hash ^= repeatedForeignEnum_.GetHashCode();

841 hash ^= repeatedImportEnum_.GetHashCode();

842 hash ^= repeatedPublicImportMessage_.GetHashCode();

843 if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) hash ^= OneofUint3 2.GetHashCode();

844 if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) hash ^= One ofNestedMessage.GetHashCode();

845 if (oneofFieldCase_ == OneofFieldOneofCase.OneofString) hash ^= OneofStrin g.GetHashCode();

846 if (oneofFieldCase_ == OneofFieldOneofCase.OneofBytes) hash ^= OneofBytes. GetHashCode();

847 return hash;

848 }

849

850 public override string ToString() {

851 return pb::JsonFormatter.Default.Format(this);

852 }

853

854 public void WriteTo(pb::CodedOutputStream output) {

855 if (SingleInt32 != 0) {

856 output.WriteRawTag(8);

857 output.WriteInt32(SingleInt32);

858 }

859 if (SingleInt64 != 0L) {

860 output.WriteRawTag(16);

861 output.WriteInt64(SingleInt64);

862 }

863 if (SingleUint32 != 0) {

864 output.WriteRawTag(24);

865 output.WriteUInt32(SingleUint32);

866 }

867 if (SingleUint64 != 0UL) {

868 output.WriteRawTag(32);

869 output.WriteUInt64(SingleUint64);

870 }

871 if (SingleSint32 != 0) {

872 output.WriteRawTag(40);

873 output.WriteSInt32(SingleSint32);

874 }

875 if (SingleSint64 != 0L) {

876 output.WriteRawTag(48);

877 output.WriteSInt64(SingleSint64);

878 }

879 if (SingleFixed32 != 0) {

880 output.WriteRawTag(61);

881 output.WriteFixed32(SingleFixed32);

882 }

883 if (SingleFixed64 != 0UL) {

884 output.WriteRawTag(65);

885 output.WriteFixed64(SingleFixed64);

886 }

887 if (SingleSfixed32 != 0) {

888 output.WriteRawTag(77);

889 output.WriteSFixed32(SingleSfixed32);

890 }

891 if (SingleSfixed64 != 0L) {

892 output.WriteRawTag(81);

893 output.WriteSFixed64(SingleSfixed64);

894 }

895 if (SingleFloat != 0F) {

896 output.WriteRawTag(93);

897 output.WriteFloat(SingleFloat);

898 }

899 if (SingleDouble != 0D) {

900 output.WriteRawTag(97);

901 output.WriteDouble(SingleDouble);

902 }

903 if (SingleBool != false) {

904 output.WriteRawTag(104);

905 output.WriteBool(SingleBool);

906 }

907 if (SingleString.Length != 0) {

908 output.WriteRawTag(114);

909 output.WriteString(SingleString);

910 }

911 if (SingleBytes.Length != 0) {

912 output.WriteRawTag(122);

913 output.WriteBytes(SingleBytes);

914 }

915 if (singleNestedMessage_ != null) {

916 output.WriteRawTag(146, 1);

917 output.WriteMessage(SingleNestedMessage);

918 }

919 if (singleForeignMessage_ != null) {

920 output.WriteRawTag(154, 1);

921 output.WriteMessage(SingleForeignMessage);

922 }

923 if (singleImportMessage_ != null) {

924 output.WriteRawTag(162, 1);

925 output.WriteMessage(SingleImportMessage);

926 }

927 if (SingleNestedEnum != global::Google.Protobuf.TestProtos.TestAllTypes.Ty pes.NestedEnum.NESTED_ENUM_UNSPECIFIED) {

928 output.WriteRawTag(168, 1);

929 output.WriteEnum((int) SingleNestedEnum);

930 }

931 if (SingleForeignEnum != global::Google.Protobuf.TestProtos.ForeignEnum.FO REIGN_UNSPECIFIED) {

932 output.WriteRawTag(176, 1);

933 output.WriteEnum((int) SingleForeignEnum);

934 }

935 if (SingleImportEnum != global::Google.Protobuf.TestProtos.ImportEnum.IMPO RT_ENUM_UNSPECIFIED) {

936 output.WriteRawTag(184, 1);

937 output.WriteEnum((int) SingleImportEnum);

938 }

939 if (singlePublicImportMessage_ != null) {

940 output.WriteRawTag(210, 1);

941 output.WriteMessage(SinglePublicImportMessage);

942 }

943 repeatedInt32_.WriteTo(output, _repeated_repeatedInt32_codec);

944 repeatedInt64_.WriteTo(output, _repeated_repeatedInt64_codec);

945 repeatedUint32_.WriteTo(output, _repeated_repeatedUint32_codec);

946 repeatedUint64_.WriteTo(output, _repeated_repeatedUint64_codec);

947 repeatedSint32_.WriteTo(output, _repeated_repeatedSint32_codec);

948 repeatedSint64_.WriteTo(output, _repeated_repeatedSint64_codec);

949 repeatedFixed32_.WriteTo(output, _repeated_repeatedFixed32_codec);

950 repeatedFixed64_.WriteTo(output, _repeated_repeatedFixed64_codec);

951 repeatedSfixed32_.WriteTo(output, _repeated_repeatedSfixed32_codec);

952 repeatedSfixed64_.WriteTo(output, _repeated_repeatedSfixed64_codec);

953 repeatedFloat_.WriteTo(output, _repeated_repeatedFloat_codec);

954 repeatedDouble_.WriteTo(output, _repeated_repeatedDouble_codec);

955 repeatedBool_.WriteTo(output, _repeated_repeatedBool_codec);

956 repeatedString_.WriteTo(output, _repeated_repeatedString_codec);

957 repeatedBytes_.WriteTo(output, _repeated_repeatedBytes_codec);

958 repeatedNestedMessage_.WriteTo(output, _repeated_repeatedNestedMessage_cod ec);

959 repeatedForeignMessage_.WriteTo(output, _repeated_repeatedForeignMessage_c odec);

960 repeatedImportMessage_.WriteTo(output, _repeated_repeatedImportMessage_cod ec);

961 repeatedNestedEnum_.WriteTo(output, _repeated_repeatedNestedEnum_codec);

962 repeatedForeignEnum_.WriteTo(output, _repeated_repeatedForeignEnum_codec);

963 repeatedImportEnum_.WriteTo(output, _repeated_repeatedImportEnum_codec);

964 repeatedPublicImportMessage_.WriteTo(output, _repeated_repeatedPublicImpor tMessage_codec);

965 if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) {

966 output.WriteRawTag(248, 6);

967 output.WriteUInt32(OneofUint32);

968 }

969 if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) {

970 output.WriteRawTag(130, 7);

971 output.WriteMessage(OneofNestedMessage);

972 }

973 if (oneofFieldCase_ == OneofFieldOneofCase.OneofString) {

974 output.WriteRawTag(138, 7);

975 output.WriteString(OneofString);

976 }

977 if (oneofFieldCase_ == OneofFieldOneofCase.OneofBytes) {

978 output.WriteRawTag(146, 7);

979 output.WriteBytes(OneofBytes);

980 }

981 }

982

983 public int CalculateSize() {

984 int size = 0;

985 if (SingleInt32 != 0) {

986 size += 1 + pb::CodedOutputStream.ComputeInt32Size(SingleInt32);

987 }

988 if (SingleInt64 != 0L) {

989 size += 1 + pb::CodedOutputStream.ComputeInt64Size(SingleInt64);

990 }

991 if (SingleUint32 != 0) {

992 size += 1 + pb::CodedOutputStream.ComputeUInt32Size(SingleUint32);

993 }

994 if (SingleUint64 != 0UL) {

995 size += 1 + pb::CodedOutputStream.ComputeUInt64Size(SingleUint64);

996 }

997 if (SingleSint32 != 0) {

998 size += 1 + pb::CodedOutputStream.ComputeSInt32Size(SingleSint32);

999 }

1000 if (SingleSint64 != 0L) {

1001 size += 1 + pb::CodedOutputStream.ComputeSInt64Size(SingleSint64);

1002 }

1003 if (SingleFixed32 != 0) {

1004 size += 1 + 4;

1005 }

1006 if (SingleFixed64 != 0UL) {

1007 size += 1 + 8;

1008 }

1009 if (SingleSfixed32 != 0) {

1010 size += 1 + 4;

1011 }

1012 if (SingleSfixed64 != 0L) {

1013 size += 1 + 8;

1014 }

1015 if (SingleFloat != 0F) {

1016 size += 1 + 4;

1017 }

1018 if (SingleDouble != 0D) {

1019 size += 1 + 8;

1020 }

1021 if (SingleBool != false) {

1022 size += 1 + 1;

1023 }

1024 if (SingleString.Length != 0) {

1025 size += 1 + pb::CodedOutputStream.ComputeStringSize(SingleString);

1026 }

1027 if (SingleBytes.Length != 0) {

1028 size += 1 + pb::CodedOutputStream.ComputeBytesSize(SingleBytes);

1029 }

1030 if (singleNestedMessage_ != null) {

1031 size += 2 + pb::CodedOutputStream.ComputeMessageSize(SingleNestedMessage );

1032 }

1033 if (singleForeignMessage_ != null) {

1034 size += 2 + pb::CodedOutputStream.ComputeMessageSize(SingleForeignMessag e);

1035 }

1036 if (singleImportMessage_ != null) {

1037 size += 2 + pb::CodedOutputStream.ComputeMessageSize(SingleImportMessage );

1038 }

1039 if (SingleNestedEnum != global::Google.Protobuf.TestProtos.TestAllTypes.Ty pes.NestedEnum.NESTED_ENUM_UNSPECIFIED) {

1040 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) SingleNestedEnum );

1041 }

1042 if (SingleForeignEnum != global::Google.Protobuf.TestProtos.ForeignEnum.FO REIGN_UNSPECIFIED) {

1043 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) SingleForeignEnu m);

1044 }

1045 if (SingleImportEnum != global::Google.Protobuf.TestProtos.ImportEnum.IMPO RT_ENUM_UNSPECIFIED) {

1046 size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) SingleImportEnum );

1047 }

1048 if (singlePublicImportMessage_ != null) {

1049 size += 2 + pb::CodedOutputStream.ComputeMessageSize(SinglePublicImportM essage);

1050 }

1051 size += repeatedInt32_.CalculateSize(_repeated_repeatedInt32_codec);

1052 size += repeatedInt64_.CalculateSize(_repeated_repeatedInt64_codec);

1053 size += repeatedUint32_.CalculateSize(_repeated_repeatedUint32_codec);

1054 size += repeatedUint64_.CalculateSize(_repeated_repeatedUint64_codec);

1055 size += repeatedSint32_.CalculateSize(_repeated_repeatedSint32_codec);

1056 size += repeatedSint64_.CalculateSize(_repeated_repeatedSint64_codec);

1057 size += repeatedFixed32_.CalculateSize(_repeated_repeatedFixed32_codec);

1058 size += repeatedFixed64_.CalculateSize(_repeated_repeatedFixed64_codec);

1059 size += repeatedSfixed32_.CalculateSize(_repeated_repeatedSfixed32_codec);

1060 size += repeatedSfixed64_.CalculateSize(_repeated_repeatedSfixed64_codec);

1061 size += repeatedFloat_.CalculateSize(_repeated_repeatedFloat_codec);

1062 size += repeatedDouble_.CalculateSize(_repeated_repeatedDouble_codec);

1063 size += repeatedBool_.CalculateSize(_repeated_repeatedBool_codec);

1064 size += repeatedString_.CalculateSize(_repeated_repeatedString_codec);

1065 size += repeatedBytes_.CalculateSize(_repeated_repeatedBytes_codec);

1066 size += repeatedNestedMessage_.CalculateSize(_repeated_repeatedNestedMessa ge_codec);

1067 size += repeatedForeignMessage_.CalculateSize(_repeated_repeatedForeignMes sage_codec);

1068 size += repeatedImportMessage_.CalculateSize(_repeated_repeatedImportMessa ge_codec);

1069 size += repeatedNestedEnum_.CalculateSize(_repeated_repeatedNestedEnum_cod ec);

1070 size += repeatedForeignEnum_.CalculateSize(_repeated_repeatedForeignEnum_c odec);

1071 size += repeatedImportEnum_.CalculateSize(_repeated_repeatedImportEnum_cod ec);

1072 size += repeatedPublicImportMessage_.CalculateSize(_repeated_repeatedPubli cImportMessage_codec);

1073 if (oneofFieldCase_ == OneofFieldOneofCase.OneofUint32) {

1074 size += 2 + pb::CodedOutputStream.ComputeUInt32Size(OneofUint32);

1075 }

1076 if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) {

1077 size += 2 + pb::CodedOutputStream.ComputeMessageSize(OneofNestedMessage) ;

1078 }

1079 if (oneofFieldCase_ == OneofFieldOneofCase.OneofString) {

1080 size += 2 + pb::CodedOutputStream.ComputeStringSize(OneofString);

1081 }

1082 if (oneofFieldCase_ == OneofFieldOneofCase.OneofBytes) {

1083 size += 2 + pb::CodedOutputStream.ComputeBytesSize(OneofBytes);

1084 }

1085 return size;

1086 }

1087

1088 public void MergeFrom(TestAllTypes other) {

1089 if (other == null) {

1090 return;

1091 }

1092 if (other.SingleInt32 != 0) {

1093 SingleInt32 = other.SingleInt32;

1094 }

1095 if (other.SingleInt64 != 0L) {

1096 SingleInt64 = other.SingleInt64;

1097 }

1098 if (other.SingleUint32 != 0) {

1099 SingleUint32 = other.SingleUint32;

1100 }

1101 if (other.SingleUint64 != 0UL) {

1102 SingleUint64 = other.SingleUint64;

1103 }

1104 if (other.SingleSint32 != 0) {

1105 SingleSint32 = other.SingleSint32;

1106 }

1107 if (other.SingleSint64 != 0L) {

1108 SingleSint64 = other.SingleSint64;

1109 }

1110 if (other.SingleFixed32 != 0) {

1111 SingleFixed32 = other.SingleFixed32;

1112 }

1113 if (other.SingleFixed64 != 0UL) {

1114 SingleFixed64 = other.SingleFixed64;

1115 }

1116 if (other.SingleSfixed32 != 0) {

1117 SingleSfixed32 = other.SingleSfixed32;

1118 }

1119 if (other.SingleSfixed64 != 0L) {

1120 SingleSfixed64 = other.SingleSfixed64;

1121 }

1122 if (other.SingleFloat != 0F) {

1123 SingleFloat = other.SingleFloat;

1124 }

1125 if (other.SingleDouble != 0D) {

1126 SingleDouble = other.SingleDouble;

1127 }

1128 if (other.SingleBool != false) {

1129 SingleBool = other.SingleBool;

1130 }

1131 if (other.SingleString.Length != 0) {

1132 SingleString = other.SingleString;

1133 }

1134 if (other.SingleBytes.Length != 0) {

1135 SingleBytes = other.SingleBytes;

1136 }

1137 if (other.singleNestedMessage_ != null) {

1138 if (singleNestedMessage_ == null) {

1139 singleNestedMessage_ = new global::Google.Protobuf.TestProtos.TestAllT ypes.Types.NestedMessage();

1140 }

1141 SingleNestedMessage.MergeFrom(other.SingleNestedMessage);

1142 }

1143 if (other.singleForeignMessage_ != null) {

1144 if (singleForeignMessage_ == null) {

1145 singleForeignMessage_ = new global::Google.Protobuf.TestProtos.Foreign Message();

1146 }

1147 SingleForeignMessage.MergeFrom(other.SingleForeignMessage);

1148 }

1149 if (other.singleImportMessage_ != null) {

1150 if (singleImportMessage_ == null) {

1151 singleImportMessage_ = new global::Google.Protobuf.TestProtos.ImportMe ssage();

1152 }

1153 SingleImportMessage.MergeFrom(other.SingleImportMessage);

1154 }

1155 if (other.SingleNestedEnum != global::Google.Protobuf.TestProtos.TestAllTy pes.Types.NestedEnum.NESTED_ENUM_UNSPECIFIED) {

1156 SingleNestedEnum = other.SingleNestedEnum;

1157 }

1158 if (other.SingleForeignEnum != global::Google.Protobuf.TestProtos.ForeignE num.FOREIGN_UNSPECIFIED) {

1159 SingleForeignEnum = other.SingleForeignEnum;

1160 }

1161 if (other.SingleImportEnum != global::Google.Protobuf.TestProtos.ImportEnu m.IMPORT_ENUM_UNSPECIFIED) {

1162 SingleImportEnum = other.SingleImportEnum;

1163 }

1164 if (other.singlePublicImportMessage_ != null) {

1165 if (singlePublicImportMessage_ == null) {

1166 singlePublicImportMessage_ = new global::Google.Protobuf.TestProtos.Pu blicImportMessage();

1167 }

1168 SinglePublicImportMessage.MergeFrom(other.SinglePublicImportMessage);

1169 }

1170 repeatedInt32_.Add(other.repeatedInt32_);

1171 repeatedInt64_.Add(other.repeatedInt64_);

1172 repeatedUint32_.Add(other.repeatedUint32_);

1173 repeatedUint64_.Add(other.repeatedUint64_);

1174 repeatedSint32_.Add(other.repeatedSint32_);

1175 repeatedSint64_.Add(other.repeatedSint64_);

1176 repeatedFixed32_.Add(other.repeatedFixed32_);

1177 repeatedFixed64_.Add(other.repeatedFixed64_);

1178 repeatedSfixed32_.Add(other.repeatedSfixed32_);

1179 repeatedSfixed64_.Add(other.repeatedSfixed64_);

1180 repeatedFloat_.Add(other.repeatedFloat_);

1181 repeatedDouble_.Add(other.repeatedDouble_);

1182 repeatedBool_.Add(other.repeatedBool_);

1183 repeatedString_.Add(other.repeatedString_);

1184 repeatedBytes_.Add(other.repeatedBytes_);

1185 repeatedNestedMessage_.Add(other.repeatedNestedMessage_);

1186 repeatedForeignMessage_.Add(other.repeatedForeignMessage_);

1187 repeatedImportMessage_.Add(other.repeatedImportMessage_);

1188 repeatedNestedEnum_.Add(other.repeatedNestedEnum_);

1189 repeatedForeignEnum_.Add(other.repeatedForeignEnum_);

1190 repeatedImportEnum_.Add(other.repeatedImportEnum_);

1191 repeatedPublicImportMessage_.Add(other.repeatedPublicImportMessage_);

1192 switch (other.OneofFieldCase) {

1193 case OneofFieldOneofCase.OneofUint32:

1194 OneofUint32 = other.OneofUint32;

1195 break;

1196 case OneofFieldOneofCase.OneofNestedMessage:

1197 OneofNestedMessage = other.OneofNestedMessage;

1198 break;

1199 case OneofFieldOneofCase.OneofString:

1200 OneofString = other.OneofString;

1201 break;

1202 case OneofFieldOneofCase.OneofBytes:

1203 OneofBytes = other.OneofBytes;

1204 break;

1205 }

1206

1207 }

1208

1209 public void MergeFrom(pb::CodedInputStream input) {

1210 uint tag;

1211 while ((tag = input.ReadTag()) != 0) {

1212 switch(tag) {

1213 default:

1214 input.SkipLastField();

1215 break;

1216 case 8: {

1217 SingleInt32 = input.ReadInt32();

1218 break;

1219 }

1220 case 16: {

1221 SingleInt64 = input.ReadInt64();

1222 break;

1223 }

1224 case 24: {

1225 SingleUint32 = input.ReadUInt32();

1226 break;

1227 }

1228 case 32: {

1229 SingleUint64 = input.ReadUInt64();

1230 break;

1231 }

1232 case 40: {

1233 SingleSint32 = input.ReadSInt32();

1234 break;

1235 }

1236 case 48: {

1237 SingleSint64 = input.ReadSInt64();

1238 break;

1239 }

1240 case 61: {

1241 SingleFixed32 = input.ReadFixed32();

1242 break;

1243 }

1244 case 65: {

1245 SingleFixed64 = input.ReadFixed64();

1246 break;

1247 }

1248 case 77: {

1249 SingleSfixed32 = input.ReadSFixed32();

1250 break;

1251 }

1252 case 81: {

1253 SingleSfixed64 = input.ReadSFixed64();

1254 break;

1255 }

1256 case 93: {

1257 SingleFloat = input.ReadFloat();

1258 break;

1259 }

1260 case 97: {

1261 SingleDouble = input.ReadDouble();

1262 break;

1263 }

1264 case 104: {

1265 SingleBool = input.ReadBool();

1266 break;

1267 }

1268 case 114: {

1269 SingleString = input.ReadString();

1270 break;

1271 }

1272 case 122: {

1273 SingleBytes = input.ReadBytes();

1274 break;

1275 }

1276 case 146: {

1277 if (singleNestedMessage_ == null) {

1278 singleNestedMessage_ = new global::Google.Protobuf.TestProtos.Test AllTypes.Types.NestedMessage();

1279 }

1280 input.ReadMessage(singleNestedMessage_);

1281 break;

1282 }

1283 case 154: {

1284 if (singleForeignMessage_ == null) {

1285 singleForeignMessage_ = new global::Google.Protobuf.TestProtos.For eignMessage();

1286 }

1287 input.ReadMessage(singleForeignMessage_);

1288 break;

1289 }

1290 case 162: {

1291 if (singleImportMessage_ == null) {

1292 singleImportMessage_ = new global::Google.Protobuf.TestProtos.Impo rtMessage();

1293 }

1294 input.ReadMessage(singleImportMessage_);

1295 break;

1296 }

1297 case 168: {

1298 singleNestedEnum_ = (global::Google.Protobuf.TestProtos.TestAllTypes .Types.NestedEnum) input.ReadEnum();

1299 break;

1300 }

1301 case 176: {

1302 singleForeignEnum_ = (global::Google.Protobuf.TestProtos.ForeignEnum ) input.ReadEnum();

1303 break;

1304 }

1305 case 184: {

1306 singleImportEnum_ = (global::Google.Protobuf.TestProtos.ImportEnum) input.ReadEnum();

1307 break;

1308 }

1309 case 210: {

1310 if (singlePublicImportMessage_ == null) {

1311 singlePublicImportMessage_ = new global::Google.Protobuf.TestProto s.PublicImportMessage();

1312 }

1313 input.ReadMessage(singlePublicImportMessage_);

1314 break;

1315 }

1316 case 250:

1317 case 248: {

1318 repeatedInt32_.AddEntriesFrom(input, _repeated_repeatedInt32_codec);

1319 break;

1320 }

1321 case 258:

1322 case 256: {

1323 repeatedInt64_.AddEntriesFrom(input, _repeated_repeatedInt64_codec);

1324 break;

1325 }

1326 case 266:

1327 case 264: {

1328 repeatedUint32_.AddEntriesFrom(input, _repeated_repeatedUint32_codec );

1329 break;

1330 }

1331 case 274:

1332 case 272: {

1333 repeatedUint64_.AddEntriesFrom(input, _repeated_repeatedUint64_codec );

1334 break;

1335 }

1336 case 282:

1337 case 280: {

1338 repeatedSint32_.AddEntriesFrom(input, _repeated_repeatedSint32_codec );

1339 break;

1340 }

1341 case 290:

1342 case 288: {

1343 repeatedSint64_.AddEntriesFrom(input, _repeated_repeatedSint64_codec );

1344 break;

1345 }

1346 case 298:

1347 case 301: {

1348 repeatedFixed32_.AddEntriesFrom(input, _repeated_repeatedFixed32_cod ec);

1349 break;

1350 }

1351 case 306:

1352 case 305: {

1353 repeatedFixed64_.AddEntriesFrom(input, _repeated_repeatedFixed64_cod ec);

1354 break;

1355 }

1356 case 314:

1357 case 317: {

1358 repeatedSfixed32_.AddEntriesFrom(input, _repeated_repeatedSfixed32_c odec);

1359 break;

1360 }

1361 case 322:

1362 case 321: {

1363 repeatedSfixed64_.AddEntriesFrom(input, _repeated_repeatedSfixed64_c odec);

1364 break;

1365 }

1366 case 330:

1367 case 333: {

1368 repeatedFloat_.AddEntriesFrom(input, _repeated_repeatedFloat_codec);

1369 break;

1370 }

1371 case 338:

1372 case 337: {

1373 repeatedDouble_.AddEntriesFrom(input, _repeated_repeatedDouble_codec );

1374 break;

1375 }

1376 case 346:

1377 case 344: {

1378 repeatedBool_.AddEntriesFrom(input, _repeated_repeatedBool_codec);

1379 break;

1380 }

1381 case 354: {

1382 repeatedString_.AddEntriesFrom(input, _repeated_repeatedString_codec );

1383 break;

1384 }

1385 case 362: {

1386 repeatedBytes_.AddEntriesFrom(input, _repeated_repeatedBytes_codec);

1387 break;

1388 }

1389 case 386: {

1390 repeatedNestedMessage_.AddEntriesFrom(input, _repeated_repeatedNeste dMessage_codec);

1391 break;

1392 }

1393 case 394: {

1394 repeatedForeignMessage_.AddEntriesFrom(input, _repeated_repeatedFore ignMessage_codec);

1395 break;

1396 }

1397 case 402: {

1398 repeatedImportMessage_.AddEntriesFrom(input, _repeated_repeatedImpor tMessage_codec);

1399 break;

1400 }

1401 case 410:

1402 case 408: {

1403 repeatedNestedEnum_.AddEntriesFrom(input, _repeated_repeatedNestedEn um_codec);

1404 break;

1405 }

1406 case 418:

1407 case 416: {

1408 repeatedForeignEnum_.AddEntriesFrom(input, _repeated_repeatedForeign Enum_codec);

1409 break;

1410 }

1411 case 426:

1412 case 424: {

1413 repeatedImportEnum_.AddEntriesFrom(input, _repeated_repeatedImportEn um_codec);

1414 break;

1415 }

1416 case 434: {

1417 repeatedPublicImportMessage_.AddEntriesFrom(input, _repeated_repeate dPublicImportMessage_codec);

1418 break;

1419 }

1420 case 888: {

1421 OneofUint32 = input.ReadUInt32();

1422 break;

1423 }

1424 case 898: {

1425 global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage subBuilder = new global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMes sage();

1426 if (oneofFieldCase_ == OneofFieldOneofCase.OneofNestedMessage) {

1427 subBuilder.MergeFrom(OneofNestedMessage);

1428 }

1429 input.ReadMessage(subBuilder);

1430 OneofNestedMessage = subBuilder;

1431 break;

1432 }

1433 case 906: {

1434 OneofString = input.ReadString();

1435 break;

1436 }

1437 case 914: {

1438 OneofBytes = input.ReadBytes();

1439 break;

1440 }

1441 }

1442 }

1443 }

1444

1445 #region Nested types

1446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1447 public static partial class Types {

1448 public enum NestedEnum {

1449 NESTED_ENUM_UNSPECIFIED = 0,

1450 FOO = 1,

1451 BAR = 2,

1452 BAZ = 3,

1453 NEG = -1,

1454 }

1455

1456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1457 public sealed partial class NestedMessage : pb::IMessage<NestedMessage> {

1458 private static readonly pb::MessageParser<NestedMessage> _parser = new p b::MessageParser<NestedMessage>(() => new NestedMessage());

1459 public static pb::MessageParser<NestedMessage> Parser { get { return _pa rser; } }

1460

1461 public static pbr::MessageDescriptor Descriptor {

1462 get { return global::Google.Protobuf.TestProtos.TestAllTypes.Descripto r.NestedTypes[0]; }

1463 }

1464

1465 pbr::MessageDescriptor pb::IMessage.Descriptor {

1466 get { return Descriptor; }

1467 }

1468

1469 public NestedMessage() {

1470 OnConstruction();

1471 }

1472

1473 partial void OnConstruction();

1474

1475 public NestedMessage(NestedMessage other) : this() {

1476 bb_ = other.bb_;

1477 }

1478

1479 public NestedMessage Clone() {

1480 return new NestedMessage(this);

1481 }

1482

1483 public const int BbFieldNumber = 1;

1484 private int bb_;

1485 public int Bb {

1486 get { return bb_; }

1487 set {

1488 bb_ = value;

1489 }

1490 }

1491

1492 public override bool Equals(object other) {

1493 return Equals(other as NestedMessage);

1494 }

1495

1496 public bool Equals(NestedMessage other) {

1497 if (ReferenceEquals(other, null)) {

1498 return false;

1499 }

1500 if (ReferenceEquals(other, this)) {

1501 return true;

1502 }

1503 if (Bb != other.Bb) return false;

1504 return true;

1505 }

1506

1507 public override int GetHashCode() {

1508 int hash = 1;

1509 if (Bb != 0) hash ^= Bb.GetHashCode();

1510 return hash;

1511 }

1512

1513 public override string ToString() {

1514 return pb::JsonFormatter.Default.Format(this);

1515 }

1516

1517 public void WriteTo(pb::CodedOutputStream output) {

1518 if (Bb != 0) {

1519 output.WriteRawTag(8);

1520 output.WriteInt32(Bb);

1521 }

1522 }

1523

1524 public int CalculateSize() {

1525 int size = 0;

1526 if (Bb != 0) {

1527 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Bb);

1528 }

1529 return size;

1530 }

1531

1532 public void MergeFrom(NestedMessage other) {

1533 if (other == null) {

1534 return;

1535 }

1536 if (other.Bb != 0) {

1537 Bb = other.Bb;

1538 }

1539 }

1540

1541 public void MergeFrom(pb::CodedInputStream input) {

1542 uint tag;

1543 while ((tag = input.ReadTag()) != 0) {

1544 switch(tag) {

1545 default:

1546 input.SkipLastField();

1547 break;

1548 case 8: {

1549 Bb = input.ReadInt32();

1550 break;

1551 }

1552 }

1553 }

1554 }

1555

1556 }

1557

1558 }

1559 #endregion

1560

1561 }

1562

1563 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1564 public sealed partial class NestedTestAllTypes : pb::IMessage<NestedTestAllTyp es> {

1565 private static readonly pb::MessageParser<NestedTestAllTypes> _parser = new pb::MessageParser<NestedTestAllTypes>(() => new NestedTestAllTypes());

1566 public static pb::MessageParser<NestedTestAllTypes> Parser { get { return _p arser; } }

1567

1568 public static pbr::MessageDescriptor Descriptor {

1569 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[1]; }

1570 }

1571

1572 pbr::MessageDescriptor pb::IMessage.Descriptor {

1573 get { return Descriptor; }

1574 }

1575

1576 public NestedTestAllTypes() {

1577 OnConstruction();

1578 }

1579

1580 partial void OnConstruction();

1581

1582 public NestedTestAllTypes(NestedTestAllTypes other) : this() {

1583 Child = other.child_ != null ? other.Child.Clone() : null;

1584 Payload = other.payload_ != null ? other.Payload.Clone() : null;

1585 repeatedChild_ = other.repeatedChild_.Clone();

1586 }

1587

1588 public NestedTestAllTypes Clone() {

1589 return new NestedTestAllTypes(this);

1590 }

1591

1592 public const int ChildFieldNumber = 1;

1593 private global::Google.Protobuf.TestProtos.NestedTestAllTypes child_;

1594 public global::Google.Protobuf.TestProtos.NestedTestAllTypes Child {

1595 get { return child_; }

1596 set {

1597 child_ = value;

1598 }

1599 }

1600

1601 public const int PayloadFieldNumber = 2;

1602 private global::Google.Protobuf.TestProtos.TestAllTypes payload_;

1603 public global::Google.Protobuf.TestProtos.TestAllTypes Payload {

1604 get { return payload_; }

1605 set {

1606 payload_ = value;

1607 }

1608 }

1609

1610 public const int RepeatedChildFieldNumber = 3;

1611 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Ne stedTestAllTypes> _repeated_repeatedChild_codec

1612 = pb::FieldCodec.ForMessage(26, global::Google.Protobuf.TestProtos.Neste dTestAllTypes.Parser);

1613 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Neste dTestAllTypes> repeatedChild_ = new pbc::RepeatedField<global::Google.Protobuf.T estProtos.NestedTestAllTypes>();

1614 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.NestedTestAllTy pes> RepeatedChild {

1615 get { return repeatedChild_; }

1616 }

1617

1618 public override bool Equals(object other) {

1619 return Equals(other as NestedTestAllTypes);

1620 }

1621

1622 public bool Equals(NestedTestAllTypes other) {

1623 if (ReferenceEquals(other, null)) {

1624 return false;

1625 }

1626 if (ReferenceEquals(other, this)) {

1627 return true;

1628 }

1629 if (!object.Equals(Child, other.Child)) return false;

1630 if (!object.Equals(Payload, other.Payload)) return false;

1631 if(!repeatedChild_.Equals(other.repeatedChild_)) return false;

1632 return true;

1633 }

1634

1635 public override int GetHashCode() {

1636 int hash = 1;

1637 if (child_ != null) hash ^= Child.GetHashCode();

1638 if (payload_ != null) hash ^= Payload.GetHashCode();

1639 hash ^= repeatedChild_.GetHashCode();

1640 return hash;

1641 }

1642

1643 public override string ToString() {

1644 return pb::JsonFormatter.Default.Format(this);

1645 }

1646

1647 public void WriteTo(pb::CodedOutputStream output) {

1648 if (child_ != null) {

1649 output.WriteRawTag(10);

1650 output.WriteMessage(Child);

1651 }

1652 if (payload_ != null) {

1653 output.WriteRawTag(18);

1654 output.WriteMessage(Payload);

1655 }

1656 repeatedChild_.WriteTo(output, _repeated_repeatedChild_codec);

1657 }

1658

1659 public int CalculateSize() {

1660 int size = 0;

1661 if (child_ != null) {

1662 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Child);

1663 }

1664 if (payload_ != null) {

1665 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Payload);

1666 }

1667 size += repeatedChild_.CalculateSize(_repeated_repeatedChild_codec);

1668 return size;

1669 }

1670

1671 public void MergeFrom(NestedTestAllTypes other) {

1672 if (other == null) {

1673 return;

1674 }

1675 if (other.child_ != null) {

1676 if (child_ == null) {

1677 child_ = new global::Google.Protobuf.TestProtos.NestedTestAllTypes();

1678 }

1679 Child.MergeFrom(other.Child);

1680 }

1681 if (other.payload_ != null) {

1682 if (payload_ == null) {

1683 payload_ = new global::Google.Protobuf.TestProtos.TestAllTypes();

1684 }

1685 Payload.MergeFrom(other.Payload);

1686 }

1687 repeatedChild_.Add(other.repeatedChild_);

1688 }

1689

1690 public void MergeFrom(pb::CodedInputStream input) {

1691 uint tag;

1692 while ((tag = input.ReadTag()) != 0) {

1693 switch(tag) {

1694 default:

1695 input.SkipLastField();

1696 break;

1697 case 10: {

1698 if (child_ == null) {

1699 child_ = new global::Google.Protobuf.TestProtos.NestedTestAllTypes ();

1700 }

1701 input.ReadMessage(child_);

1702 break;

1703 }

1704 case 18: {

1705 if (payload_ == null) {

1706 payload_ = new global::Google.Protobuf.TestProtos.TestAllTypes();

1707 }

1708 input.ReadMessage(payload_);

1709 break;

1710 }

1711 case 26: {

1712 repeatedChild_.AddEntriesFrom(input, _repeated_repeatedChild_codec);

1713 break;

1714 }

1715 }

1716 }

1717 }

1718

1719 }

1720

1721 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1722 public sealed partial class TestDeprecatedFields : pb::IMessage<TestDeprecated Fields> {

1723 private static readonly pb::MessageParser<TestDeprecatedFields> _parser = ne w pb::MessageParser<TestDeprecatedFields>(() => new TestDeprecatedFields());

1724 public static pb::MessageParser<TestDeprecatedFields> Parser { get { return _parser; } }

1725

1726 public static pbr::MessageDescriptor Descriptor {

1727 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[2]; }

1728 }

1729

1730 pbr::MessageDescriptor pb::IMessage.Descriptor {

1731 get { return Descriptor; }

1732 }

1733

1734 public TestDeprecatedFields() {

1735 OnConstruction();

1736 }

1737

1738 partial void OnConstruction();

1739

1740 public TestDeprecatedFields(TestDeprecatedFields other) : this() {

1741 deprecatedInt32_ = other.deprecatedInt32_;

1742 }

1743

1744 public TestDeprecatedFields Clone() {

1745 return new TestDeprecatedFields(this);

1746 }

1747

1748 public const int DeprecatedInt32FieldNumber = 1;

1749 private int deprecatedInt32_;

1750 [global::System.ObsoleteAttribute()]

1751 public int DeprecatedInt32 {

1752 get { return deprecatedInt32_; }

1753 set {

1754 deprecatedInt32_ = value;

1755 }

1756 }

1757

1758 public override bool Equals(object other) {

1759 return Equals(other as TestDeprecatedFields);

1760 }

1761

1762 public bool Equals(TestDeprecatedFields other) {

1763 if (ReferenceEquals(other, null)) {

1764 return false;

1765 }

1766 if (ReferenceEquals(other, this)) {

1767 return true;

1768 }

1769 if (DeprecatedInt32 != other.DeprecatedInt32) return false;

1770 return true;

1771 }

1772

1773 public override int GetHashCode() {

1774 int hash = 1;

1775 if (DeprecatedInt32 != 0) hash ^= DeprecatedInt32.GetHashCode();

1776 return hash;

1777 }

1778

1779 public override string ToString() {

1780 return pb::JsonFormatter.Default.Format(this);

1781 }

1782

1783 public void WriteTo(pb::CodedOutputStream output) {

1784 if (DeprecatedInt32 != 0) {

1785 output.WriteRawTag(8);

1786 output.WriteInt32(DeprecatedInt32);

1787 }

1788 }

1789

1790 public int CalculateSize() {

1791 int size = 0;

1792 if (DeprecatedInt32 != 0) {

1793 size += 1 + pb::CodedOutputStream.ComputeInt32Size(DeprecatedInt32);

1794 }

1795 return size;

1796 }

1797

1798 public void MergeFrom(TestDeprecatedFields other) {

1799 if (other == null) {

1800 return;

1801 }

1802 if (other.DeprecatedInt32 != 0) {

1803 DeprecatedInt32 = other.DeprecatedInt32;

1804 }

1805 }

1806

1807 public void MergeFrom(pb::CodedInputStream input) {

1808 uint tag;

1809 while ((tag = input.ReadTag()) != 0) {

1810 switch(tag) {

1811 default:

1812 input.SkipLastField();

1813 break;

1814 case 8: {

1815 DeprecatedInt32 = input.ReadInt32();

1816 break;

1817 }

1818 }

1819 }

1820 }

1821

1822 }

1823

1824 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1825 public sealed partial class ForeignMessage : pb::IMessage<ForeignMessage> {

1826 private static readonly pb::MessageParser<ForeignMessage> _parser = new pb:: MessageParser<ForeignMessage>(() => new ForeignMessage());

1827 public static pb::MessageParser<ForeignMessage> Parser { get { return _parse r; } }

1828

1829 public static pbr::MessageDescriptor Descriptor {

1830 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[3]; }

1831 }

1832

1833 pbr::MessageDescriptor pb::IMessage.Descriptor {

1834 get { return Descriptor; }

1835 }

1836

1837 public ForeignMessage() {

1838 OnConstruction();

1839 }

1840

1841 partial void OnConstruction();

1842

1843 public ForeignMessage(ForeignMessage other) : this() {

1844 c_ = other.c_;

1845 }

1846

1847 public ForeignMessage Clone() {

1848 return new ForeignMessage(this);

1849 }

1850

1851 public const int CFieldNumber = 1;

1852 private int c_;

1853 public int C {

1854 get { return c_; }

1855 set {

1856 c_ = value;

1857 }

1858 }

1859

1860 public override bool Equals(object other) {

1861 return Equals(other as ForeignMessage);

1862 }

1863

1864 public bool Equals(ForeignMessage other) {

1865 if (ReferenceEquals(other, null)) {

1866 return false;

1867 }

1868 if (ReferenceEquals(other, this)) {

1869 return true;

1870 }

1871 if (C != other.C) return false;

1872 return true;

1873 }

1874

1875 public override int GetHashCode() {

1876 int hash = 1;

1877 if (C != 0) hash ^= C.GetHashCode();

1878 return hash;

1879 }

1880

1881 public override string ToString() {

1882 return pb::JsonFormatter.Default.Format(this);

1883 }

1884

1885 public void WriteTo(pb::CodedOutputStream output) {

1886 if (C != 0) {

1887 output.WriteRawTag(8);

1888 output.WriteInt32(C);

1889 }

1890 }

1891

1892 public int CalculateSize() {

1893 int size = 0;

1894 if (C != 0) {

1895 size += 1 + pb::CodedOutputStream.ComputeInt32Size(C);

1896 }

1897 return size;

1898 }

1899

1900 public void MergeFrom(ForeignMessage other) {

1901 if (other == null) {

1902 return;

1903 }

1904 if (other.C != 0) {

1905 C = other.C;

1906 }

1907 }

1908

1909 public void MergeFrom(pb::CodedInputStream input) {

1910 uint tag;

1911 while ((tag = input.ReadTag()) != 0) {

1912 switch(tag) {

1913 default:

1914 input.SkipLastField();

1915 break;

1916 case 8: {

1917 C = input.ReadInt32();

1918 break;

1919 }

1920 }

1921 }

1922 }

1923

1924 }

1925

1926 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

1927 public sealed partial class TestReservedFields : pb::IMessage<TestReservedFiel ds> {

1928 private static readonly pb::MessageParser<TestReservedFields> _parser = new pb::MessageParser<TestReservedFields>(() => new TestReservedFields());

1929 public static pb::MessageParser<TestReservedFields> Parser { get { return _p arser; } }

1930

1931 public static pbr::MessageDescriptor Descriptor {

1932 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[4]; }

1933 }

1934

1935 pbr::MessageDescriptor pb::IMessage.Descriptor {

1936 get { return Descriptor; }

1937 }

1938

1939 public TestReservedFields() {

1940 OnConstruction();

1941 }

1942

1943 partial void OnConstruction();

1944

1945 public TestReservedFields(TestReservedFields other) : this() {

1946 }

1947

1948 public TestReservedFields Clone() {

1949 return new TestReservedFields(this);

1950 }

1951

1952 public override bool Equals(object other) {

1953 return Equals(other as TestReservedFields);

1954 }

1955

1956 public bool Equals(TestReservedFields other) {

1957 if (ReferenceEquals(other, null)) {

1958 return false;

1959 }

1960 if (ReferenceEquals(other, this)) {

1961 return true;

1962 }

1963 return true;

1964 }

1965

1966 public override int GetHashCode() {

1967 int hash = 1;

1968 return hash;

1969 }

1970

1971 public override string ToString() {

1972 return pb::JsonFormatter.Default.Format(this);

1973 }

1974

1975 public void WriteTo(pb::CodedOutputStream output) {

1976 }

1977

1978 public int CalculateSize() {

1979 int size = 0;

1980 return size;

1981 }

1982

1983 public void MergeFrom(TestReservedFields other) {

1984 if (other == null) {

1985 return;

1986 }

1987 }

1988

1989 public void MergeFrom(pb::CodedInputStream input) {

1990 uint tag;

1991 while ((tag = input.ReadTag()) != 0) {

1992 switch(tag) {

1993 default:

1994 input.SkipLastField();

1995 break;

1996 }

1997 }

1998 }

1999

2000 }

2001

2002 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2003 public sealed partial class TestForeignNested : pb::IMessage<TestForeignNested > {

2004 private static readonly pb::MessageParser<TestForeignNested> _parser = new p b::MessageParser<TestForeignNested>(() => new TestForeignNested());

2005 public static pb::MessageParser<TestForeignNested> Parser { get { return _pa rser; } }

2006

2007 public static pbr::MessageDescriptor Descriptor {

2008 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[5]; }

2009 }

2010

2011 pbr::MessageDescriptor pb::IMessage.Descriptor {

2012 get { return Descriptor; }

2013 }

2014

2015 public TestForeignNested() {

2016 OnConstruction();

2017 }

2018

2019 partial void OnConstruction();

2020

2021 public TestForeignNested(TestForeignNested other) : this() {

2022 ForeignNested = other.foreignNested_ != null ? other.ForeignNested.Clone() : null;

2023 }

2024

2025 public TestForeignNested Clone() {

2026 return new TestForeignNested(this);

2027 }

2028

2029 public const int ForeignNestedFieldNumber = 1;

2030 private global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage foreignNested_;

2031 public global::Google.Protobuf.TestProtos.TestAllTypes.Types.NestedMessage F oreignNested {

2032 get { return foreignNested_; }

2033 set {

2034 foreignNested_ = value;

2035 }

2036 }

2037

2038 public override bool Equals(object other) {

2039 return Equals(other as TestForeignNested);

2040 }

2041

2042 public bool Equals(TestForeignNested other) {

2043 if (ReferenceEquals(other, null)) {

2044 return false;

2045 }

2046 if (ReferenceEquals(other, this)) {

2047 return true;

2048 }

2049 if (!object.Equals(ForeignNested, other.ForeignNested)) return false;

2050 return true;

2051 }

2052

2053 public override int GetHashCode() {

2054 int hash = 1;

2055 if (foreignNested_ != null) hash ^= ForeignNested.GetHashCode();

2056 return hash;

2057 }

2058

2059 public override string ToString() {

2060 return pb::JsonFormatter.Default.Format(this);

2061 }

2062

2063 public void WriteTo(pb::CodedOutputStream output) {

2064 if (foreignNested_ != null) {

2065 output.WriteRawTag(10);

2066 output.WriteMessage(ForeignNested);

2067 }

2068 }

2069

2070 public int CalculateSize() {

2071 int size = 0;

2072 if (foreignNested_ != null) {

2073 size += 1 + pb::CodedOutputStream.ComputeMessageSize(ForeignNested);

2074 }

2075 return size;

2076 }

2077

2078 public void MergeFrom(TestForeignNested other) {

2079 if (other == null) {

2080 return;

2081 }

2082 if (other.foreignNested_ != null) {

2083 if (foreignNested_ == null) {

2084 foreignNested_ = new global::Google.Protobuf.TestProtos.TestAllTypes.T ypes.NestedMessage();

2085 }

2086 ForeignNested.MergeFrom(other.ForeignNested);

2087 }

2088 }

2089

2090 public void MergeFrom(pb::CodedInputStream input) {

2091 uint tag;

2092 while ((tag = input.ReadTag()) != 0) {

2093 switch(tag) {

2094 default:

2095 input.SkipLastField();

2096 break;

2097 case 10: {

2098 if (foreignNested_ == null) {

2099 foreignNested_ = new global::Google.Protobuf.TestProtos.TestAllTyp es.Types.NestedMessage();

2100 }

2101 input.ReadMessage(foreignNested_);

2102 break;

2103 }

2104 }

2105 }

2106 }

2107

2108 }

2109

2110 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2111 public sealed partial class TestReallyLargeTagNumber : pb::IMessage<TestReally LargeTagNumber> {

2112 private static readonly pb::MessageParser<TestReallyLargeTagNumber> _parser = new pb::MessageParser<TestReallyLargeTagNumber>(() => new TestReallyLargeTagNu mber());

2113 public static pb::MessageParser<TestReallyLargeTagNumber> Parser { get { ret urn _parser; } }

2114

2115 public static pbr::MessageDescriptor Descriptor {

2116 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[6]; }

2117 }

2118

2119 pbr::MessageDescriptor pb::IMessage.Descriptor {

2120 get { return Descriptor; }

2121 }

2122

2123 public TestReallyLargeTagNumber() {

2124 OnConstruction();

2125 }

2126

2127 partial void OnConstruction();

2128

2129 public TestReallyLargeTagNumber(TestReallyLargeTagNumber other) : this() {

2130 a_ = other.a_;

2131 bb_ = other.bb_;

2132 }

2133

2134 public TestReallyLargeTagNumber Clone() {

2135 return new TestReallyLargeTagNumber(this);

2136 }

2137

2138 public const int AFieldNumber = 1;

2139 private int a_;

2140 public int A {

2141 get { return a_; }

2142 set {

2143 a_ = value;

2144 }

2145 }

2146

2147 public const int BbFieldNumber = 268435455;

2148 private int bb_;

2149 public int Bb {

2150 get { return bb_; }

2151 set {

2152 bb_ = value;

2153 }

2154 }

2155

2156 public override bool Equals(object other) {

2157 return Equals(other as TestReallyLargeTagNumber);

2158 }

2159

2160 public bool Equals(TestReallyLargeTagNumber other) {

2161 if (ReferenceEquals(other, null)) {

2162 return false;

2163 }

2164 if (ReferenceEquals(other, this)) {

2165 return true;

2166 }

2167 if (A != other.A) return false;

2168 if (Bb != other.Bb) return false;

2169 return true;

2170 }

2171

2172 public override int GetHashCode() {

2173 int hash = 1;

2174 if (A != 0) hash ^= A.GetHashCode();

2175 if (Bb != 0) hash ^= Bb.GetHashCode();

2176 return hash;

2177 }

2178

2179 public override string ToString() {

2180 return pb::JsonFormatter.Default.Format(this);

2181 }

2182

2183 public void WriteTo(pb::CodedOutputStream output) {

2184 if (A != 0) {

2185 output.WriteRawTag(8);

2186 output.WriteInt32(A);

2187 }

2188 if (Bb != 0) {

2189 output.WriteRawTag(248, 255, 255, 255, 7);

2190 output.WriteInt32(Bb);

2191 }

2192 }

2193

2194 public int CalculateSize() {

2195 int size = 0;

2196 if (A != 0) {

2197 size += 1 + pb::CodedOutputStream.ComputeInt32Size(A);

2198 }

2199 if (Bb != 0) {

2200 size += 5 + pb::CodedOutputStream.ComputeInt32Size(Bb);

2201 }

2202 return size;

2203 }

2204

2205 public void MergeFrom(TestReallyLargeTagNumber other) {

2206 if (other == null) {

2207 return;

2208 }

2209 if (other.A != 0) {

2210 A = other.A;

2211 }

2212 if (other.Bb != 0) {

2213 Bb = other.Bb;

2214 }

2215 }

2216

2217 public void MergeFrom(pb::CodedInputStream input) {

2218 uint tag;

2219 while ((tag = input.ReadTag()) != 0) {

2220 switch(tag) {

2221 default:

2222 input.SkipLastField();

2223 break;

2224 case 8: {

2225 A = input.ReadInt32();

2226 break;

2227 }

2228 case 2147483640: {

2229 Bb = input.ReadInt32();

2230 break;

2231 }

2232 }

2233 }

2234 }

2235

2236 }

2237

2238 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2239 public sealed partial class TestRecursiveMessage : pb::IMessage<TestRecursiveM essage> {

2240 private static readonly pb::MessageParser<TestRecursiveMessage> _parser = ne w pb::MessageParser<TestRecursiveMessage>(() => new TestRecursiveMessage());

2241 public static pb::MessageParser<TestRecursiveMessage> Parser { get { return _parser; } }

2242

2243 public static pbr::MessageDescriptor Descriptor {

2244 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[7]; }

2245 }

2246

2247 pbr::MessageDescriptor pb::IMessage.Descriptor {

2248 get { return Descriptor; }

2249 }

2250

2251 public TestRecursiveMessage() {

2252 OnConstruction();

2253 }

2254

2255 partial void OnConstruction();

2256

2257 public TestRecursiveMessage(TestRecursiveMessage other) : this() {

2258 A = other.a_ != null ? other.A.Clone() : null;

2259 i_ = other.i_;

2260 }

2261

2262 public TestRecursiveMessage Clone() {

2263 return new TestRecursiveMessage(this);

2264 }

2265

2266 public const int AFieldNumber = 1;

2267 private global::Google.Protobuf.TestProtos.TestRecursiveMessage a_;

2268 public global::Google.Protobuf.TestProtos.TestRecursiveMessage A {

2269 get { return a_; }

2270 set {

2271 a_ = value;

2272 }

2273 }

2274

2275 public const int IFieldNumber = 2;

2276 private int i_;

2277 public int I {

2278 get { return i_; }

2279 set {

2280 i_ = value;

2281 }

2282 }

2283

2284 public override bool Equals(object other) {

2285 return Equals(other as TestRecursiveMessage);

2286 }

2287

2288 public bool Equals(TestRecursiveMessage other) {

2289 if (ReferenceEquals(other, null)) {

2290 return false;

2291 }

2292 if (ReferenceEquals(other, this)) {

2293 return true;

2294 }

2295 if (!object.Equals(A, other.A)) return false;

2296 if (I != other.I) return false;

2297 return true;

2298 }

2299

2300 public override int GetHashCode() {

2301 int hash = 1;

2302 if (a_ != null) hash ^= A.GetHashCode();

2303 if (I != 0) hash ^= I.GetHashCode();

2304 return hash;

2305 }

2306

2307 public override string ToString() {

2308 return pb::JsonFormatter.Default.Format(this);

2309 }

2310

2311 public void WriteTo(pb::CodedOutputStream output) {

2312 if (a_ != null) {

2313 output.WriteRawTag(10);

2314 output.WriteMessage(A);

2315 }

2316 if (I != 0) {

2317 output.WriteRawTag(16);

2318 output.WriteInt32(I);

2319 }

2320 }

2321

2322 public int CalculateSize() {

2323 int size = 0;

2324 if (a_ != null) {

2325 size += 1 + pb::CodedOutputStream.ComputeMessageSize(A);

2326 }

2327 if (I != 0) {

2328 size += 1 + pb::CodedOutputStream.ComputeInt32Size(I);

2329 }

2330 return size;

2331 }

2332

2333 public void MergeFrom(TestRecursiveMessage other) {

2334 if (other == null) {

2335 return;

2336 }

2337 if (other.a_ != null) {

2338 if (a_ == null) {

2339 a_ = new global::Google.Protobuf.TestProtos.TestRecursiveMessage();

2340 }

2341 A.MergeFrom(other.A);

2342 }

2343 if (other.I != 0) {

2344 I = other.I;

2345 }

2346 }

2347

2348 public void MergeFrom(pb::CodedInputStream input) {

2349 uint tag;

2350 while ((tag = input.ReadTag()) != 0) {

2351 switch(tag) {

2352 default:

2353 input.SkipLastField();

2354 break;

2355 case 10: {

2356 if (a_ == null) {

2357 a_ = new global::Google.Protobuf.TestProtos.TestRecursiveMessage() ;

2358 }

2359 input.ReadMessage(a_);

2360 break;

2361 }

2362 case 16: {

2363 I = input.ReadInt32();

2364 break;

2365 }

2366 }

2367 }

2368 }

2369

2370 }

2371

2372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2373 public sealed partial class TestMutualRecursionA : pb::IMessage<TestMutualRecu rsionA> {

2374 private static readonly pb::MessageParser<TestMutualRecursionA> _parser = ne w pb::MessageParser<TestMutualRecursionA>(() => new TestMutualRecursionA());

2375 public static pb::MessageParser<TestMutualRecursionA> Parser { get { return _parser; } }

2376

2377 public static pbr::MessageDescriptor Descriptor {

2378 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[8]; }

2379 }

2380

2381 pbr::MessageDescriptor pb::IMessage.Descriptor {

2382 get { return Descriptor; }

2383 }

2384

2385 public TestMutualRecursionA() {

2386 OnConstruction();

2387 }

2388

2389 partial void OnConstruction();

2390

2391 public TestMutualRecursionA(TestMutualRecursionA other) : this() {

2392 Bb = other.bb_ != null ? other.Bb.Clone() : null;

2393 }

2394

2395 public TestMutualRecursionA Clone() {

2396 return new TestMutualRecursionA(this);

2397 }

2398

2399 public const int BbFieldNumber = 1;

2400 private global::Google.Protobuf.TestProtos.TestMutualRecursionB bb_;

2401 public global::Google.Protobuf.TestProtos.TestMutualRecursionB Bb {

2402 get { return bb_; }

2403 set {

2404 bb_ = value;

2405 }

2406 }

2407

2408 public override bool Equals(object other) {

2409 return Equals(other as TestMutualRecursionA);

2410 }

2411

2412 public bool Equals(TestMutualRecursionA other) {

2413 if (ReferenceEquals(other, null)) {

2414 return false;

2415 }

2416 if (ReferenceEquals(other, this)) {

2417 return true;

2418 }

2419 if (!object.Equals(Bb, other.Bb)) return false;

2420 return true;

2421 }

2422

2423 public override int GetHashCode() {

2424 int hash = 1;

2425 if (bb_ != null) hash ^= Bb.GetHashCode();

2426 return hash;

2427 }

2428

2429 public override string ToString() {

2430 return pb::JsonFormatter.Default.Format(this);

2431 }

2432

2433 public void WriteTo(pb::CodedOutputStream output) {

2434 if (bb_ != null) {

2435 output.WriteRawTag(10);

2436 output.WriteMessage(Bb);

2437 }

2438 }

2439

2440 public int CalculateSize() {

2441 int size = 0;

2442 if (bb_ != null) {

2443 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Bb);

2444 }

2445 return size;

2446 }

2447

2448 public void MergeFrom(TestMutualRecursionA other) {

2449 if (other == null) {

2450 return;

2451 }

2452 if (other.bb_ != null) {

2453 if (bb_ == null) {

2454 bb_ = new global::Google.Protobuf.TestProtos.TestMutualRecursionB();

2455 }

2456 Bb.MergeFrom(other.Bb);

2457 }

2458 }

2459

2460 public void MergeFrom(pb::CodedInputStream input) {

2461 uint tag;

2462 while ((tag = input.ReadTag()) != 0) {

2463 switch(tag) {

2464 default:

2465 input.SkipLastField();

2466 break;

2467 case 10: {

2468 if (bb_ == null) {

2469 bb_ = new global::Google.Protobuf.TestProtos.TestMutualRecursionB( );

2470 }

2471 input.ReadMessage(bb_);

2472 break;

2473 }

2474 }

2475 }

2476 }

2477

2478 }

2479

2480 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2481 public sealed partial class TestMutualRecursionB : pb::IMessage<TestMutualRecu rsionB> {

2482 private static readonly pb::MessageParser<TestMutualRecursionB> _parser = ne w pb::MessageParser<TestMutualRecursionB>(() => new TestMutualRecursionB());

2483 public static pb::MessageParser<TestMutualRecursionB> Parser { get { return _parser; } }

2484

2485 public static pbr::MessageDescriptor Descriptor {

2486 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[9]; }

2487 }

2488

2489 pbr::MessageDescriptor pb::IMessage.Descriptor {

2490 get { return Descriptor; }

2491 }

2492

2493 public TestMutualRecursionB() {

2494 OnConstruction();

2495 }

2496

2497 partial void OnConstruction();

2498

2499 public TestMutualRecursionB(TestMutualRecursionB other) : this() {

2500 A = other.a_ != null ? other.A.Clone() : null;

2501 optionalInt32_ = other.optionalInt32_;

2502 }

2503

2504 public TestMutualRecursionB Clone() {

2505 return new TestMutualRecursionB(this);

2506 }

2507

2508 public const int AFieldNumber = 1;

2509 private global::Google.Protobuf.TestProtos.TestMutualRecursionA a_;

2510 public global::Google.Protobuf.TestProtos.TestMutualRecursionA A {

2511 get { return a_; }

2512 set {

2513 a_ = value;

2514 }

2515 }

2516

2517 public const int OptionalInt32FieldNumber = 2;

2518 private int optionalInt32_;

2519 public int OptionalInt32 {

2520 get { return optionalInt32_; }

2521 set {

2522 optionalInt32_ = value;

2523 }

2524 }

2525

2526 public override bool Equals(object other) {

2527 return Equals(other as TestMutualRecursionB);

2528 }

2529

2530 public bool Equals(TestMutualRecursionB other) {

2531 if (ReferenceEquals(other, null)) {

2532 return false;

2533 }

2534 if (ReferenceEquals(other, this)) {

2535 return true;

2536 }

2537 if (!object.Equals(A, other.A)) return false;

2538 if (OptionalInt32 != other.OptionalInt32) return false;

2539 return true;

2540 }

2541

2542 public override int GetHashCode() {

2543 int hash = 1;

2544 if (a_ != null) hash ^= A.GetHashCode();

2545 if (OptionalInt32 != 0) hash ^= OptionalInt32.GetHashCode();

2546 return hash;

2547 }

2548

2549 public override string ToString() {

2550 return pb::JsonFormatter.Default.Format(this);

2551 }

2552

2553 public void WriteTo(pb::CodedOutputStream output) {

2554 if (a_ != null) {

2555 output.WriteRawTag(10);

2556 output.WriteMessage(A);

2557 }

2558 if (OptionalInt32 != 0) {

2559 output.WriteRawTag(16);

2560 output.WriteInt32(OptionalInt32);

2561 }

2562 }

2563

2564 public int CalculateSize() {

2565 int size = 0;

2566 if (a_ != null) {

2567 size += 1 + pb::CodedOutputStream.ComputeMessageSize(A);

2568 }

2569 if (OptionalInt32 != 0) {

2570 size += 1 + pb::CodedOutputStream.ComputeInt32Size(OptionalInt32);

2571 }

2572 return size;

2573 }

2574

2575 public void MergeFrom(TestMutualRecursionB other) {

2576 if (other == null) {

2577 return;

2578 }

2579 if (other.a_ != null) {

2580 if (a_ == null) {

2581 a_ = new global::Google.Protobuf.TestProtos.TestMutualRecursionA();

2582 }

2583 A.MergeFrom(other.A);

2584 }

2585 if (other.OptionalInt32 != 0) {

2586 OptionalInt32 = other.OptionalInt32;

2587 }

2588 }

2589

2590 public void MergeFrom(pb::CodedInputStream input) {

2591 uint tag;

2592 while ((tag = input.ReadTag()) != 0) {

2593 switch(tag) {

2594 default:

2595 input.SkipLastField();

2596 break;

2597 case 10: {

2598 if (a_ == null) {

2599 a_ = new global::Google.Protobuf.TestProtos.TestMutualRecursionA() ;

2600 }

2601 input.ReadMessage(a_);

2602 break;

2603 }

2604 case 16: {

2605 OptionalInt32 = input.ReadInt32();

2606 break;

2607 }

2608 }

2609 }

2610 }

2611

2612 }

2613

2614 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2615 public sealed partial class TestCamelCaseFieldNames : pb::IMessage<TestCamelCa seFieldNames> {

2616 private static readonly pb::MessageParser<TestCamelCaseFieldNames> _parser = new pb::MessageParser<TestCamelCaseFieldNames>(() => new TestCamelCaseFieldName s());

2617 public static pb::MessageParser<TestCamelCaseFieldNames> Parser { get { retu rn _parser; } }

2618

2619 public static pbr::MessageDescriptor Descriptor {

2620 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[10]; }

2621 }

2622

2623 pbr::MessageDescriptor pb::IMessage.Descriptor {

2624 get { return Descriptor; }

2625 }

2626

2627 public TestCamelCaseFieldNames() {

2628 OnConstruction();

2629 }

2630

2631 partial void OnConstruction();

2632

2633 public TestCamelCaseFieldNames(TestCamelCaseFieldNames other) : this() {

2634 primitiveField_ = other.primitiveField_;

2635 stringField_ = other.stringField_;

2636 enumField_ = other.enumField_;

2637 MessageField = other.messageField_ != null ? other.MessageField.Clone() : null;

2638 repeatedPrimitiveField_ = other.repeatedPrimitiveField_.Clone();

2639 repeatedStringField_ = other.repeatedStringField_.Clone();

2640 repeatedEnumField_ = other.repeatedEnumField_.Clone();

2641 repeatedMessageField_ = other.repeatedMessageField_.Clone();

2642 }

2643

2644 public TestCamelCaseFieldNames Clone() {

2645 return new TestCamelCaseFieldNames(this);

2646 }

2647

2648 public const int PrimitiveFieldFieldNumber = 1;

2649 private int primitiveField_;

2650 public int PrimitiveField {

2651 get { return primitiveField_; }

2652 set {

2653 primitiveField_ = value;

2654 }

2655 }

2656

2657 public const int StringFieldFieldNumber = 2;

2658 private string stringField_ = "";

2659 public string StringField {

2660 get { return stringField_; }

2661 set {

2662 stringField_ = pb::Preconditions.CheckNotNull(value, "value");

2663 }

2664 }

2665

2666 public const int EnumFieldFieldNumber = 3;

2667 private global::Google.Protobuf.TestProtos.ForeignEnum enumField_ = global:: Google.Protobuf.TestProtos.ForeignEnum.FOREIGN_UNSPECIFIED;

2668 public global::Google.Protobuf.TestProtos.ForeignEnum EnumField {

2669 get { return enumField_; }

2670 set {

2671 enumField_ = value;

2672 }

2673 }

2674

2675 public const int MessageFieldFieldNumber = 4;

2676 private global::Google.Protobuf.TestProtos.ForeignMessage messageField_;

2677 public global::Google.Protobuf.TestProtos.ForeignMessage MessageField {

2678 get { return messageField_; }

2679 set {

2680 messageField_ = value;

2681 }

2682 }

2683

2684 public const int RepeatedPrimitiveFieldFieldNumber = 7;

2685 private static readonly pb::FieldCodec<int> _repeated_repeatedPrimitiveField _codec

2686 = pb::FieldCodec.ForInt32(58);

2687 private readonly pbc::RepeatedField<int> repeatedPrimitiveField_ = new pbc:: RepeatedField<int>();

2688 public pbc::RepeatedField<int> RepeatedPrimitiveField {

2689 get { return repeatedPrimitiveField_; }

2690 }

2691

2692 public const int RepeatedStringFieldFieldNumber = 8;

2693 private static readonly pb::FieldCodec<string> _repeated_repeatedStringField _codec

2694 = pb::FieldCodec.ForString(66);

2695 private readonly pbc::RepeatedField<string> repeatedStringField_ = new pbc:: RepeatedField<string>();

2696 public pbc::RepeatedField<string> RepeatedStringField {

2697 get { return repeatedStringField_; }

2698 }

2699

2700 public const int RepeatedEnumFieldFieldNumber = 9;

2701 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Fo reignEnum> _repeated_repeatedEnumField_codec

2702 = pb::FieldCodec.ForEnum(74, x => (int) x, x => (global::Google.Protobuf .TestProtos.ForeignEnum) x);

2703 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Forei gnEnum> repeatedEnumField_ = new pbc::RepeatedField<global::Google.Protobuf.Test Protos.ForeignEnum>();

2704 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> Re peatedEnumField {

2705 get { return repeatedEnumField_; }

2706 }

2707

2708 public const int RepeatedMessageFieldFieldNumber = 10;

2709 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Fo reignMessage> _repeated_repeatedMessageField_codec

2710 = pb::FieldCodec.ForMessage(82, global::Google.Protobuf.TestProtos.Forei gnMessage.Parser);

2711 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Forei gnMessage> repeatedMessageField_ = new pbc::RepeatedField<global::Google.Protobu f.TestProtos.ForeignMessage>();

2712 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignMessage> RepeatedMessageField {

2713 get { return repeatedMessageField_; }

2714 }

2715

2716 public override bool Equals(object other) {

2717 return Equals(other as TestCamelCaseFieldNames);

2718 }

2719

2720 public bool Equals(TestCamelCaseFieldNames other) {

2721 if (ReferenceEquals(other, null)) {

2722 return false;

2723 }

2724 if (ReferenceEquals(other, this)) {

2725 return true;

2726 }

2727 if (PrimitiveField != other.PrimitiveField) return false;

2728 if (StringField != other.StringField) return false;

2729 if (EnumField != other.EnumField) return false;

2730 if (!object.Equals(MessageField, other.MessageField)) return false;

2731 if(!repeatedPrimitiveField_.Equals(other.repeatedPrimitiveField_)) return false;

2732 if(!repeatedStringField_.Equals(other.repeatedStringField_)) return false;

2733 if(!repeatedEnumField_.Equals(other.repeatedEnumField_)) return false;

2734 if(!repeatedMessageField_.Equals(other.repeatedMessageField_)) return fals e;

2735 return true;

2736 }

2737

2738 public override int GetHashCode() {

2739 int hash = 1;

2740 if (PrimitiveField != 0) hash ^= PrimitiveField.GetHashCode();

2741 if (StringField.Length != 0) hash ^= StringField.GetHashCode();

2742 if (EnumField != global::Google.Protobuf.TestProtos.ForeignEnum.FOREIGN_UN SPECIFIED) hash ^= EnumField.GetHashCode();

2743 if (messageField_ != null) hash ^= MessageField.GetHashCode();

2744 hash ^= repeatedPrimitiveField_.GetHashCode();

2745 hash ^= repeatedStringField_.GetHashCode();

2746 hash ^= repeatedEnumField_.GetHashCode();

2747 hash ^= repeatedMessageField_.GetHashCode();

2748 return hash;

2749 }

2750

2751 public override string ToString() {

2752 return pb::JsonFormatter.Default.Format(this);

2753 }

2754

2755 public void WriteTo(pb::CodedOutputStream output) {

2756 if (PrimitiveField != 0) {

2757 output.WriteRawTag(8);

2758 output.WriteInt32(PrimitiveField);

2759 }

2760 if (StringField.Length != 0) {

2761 output.WriteRawTag(18);

2762 output.WriteString(StringField);

2763 }

2764 if (EnumField != global::Google.Protobuf.TestProtos.ForeignEnum.FOREIGN_UN SPECIFIED) {

2765 output.WriteRawTag(24);

2766 output.WriteEnum((int) EnumField);

2767 }

2768 if (messageField_ != null) {

2769 output.WriteRawTag(34);

2770 output.WriteMessage(MessageField);

2771 }

2772 repeatedPrimitiveField_.WriteTo(output, _repeated_repeatedPrimitiveField_c odec);

2773 repeatedStringField_.WriteTo(output, _repeated_repeatedStringField_codec);

2774 repeatedEnumField_.WriteTo(output, _repeated_repeatedEnumField_codec);

2775 repeatedMessageField_.WriteTo(output, _repeated_repeatedMessageField_codec );

2776 }

2777

2778 public int CalculateSize() {

2779 int size = 0;

2780 if (PrimitiveField != 0) {

2781 size += 1 + pb::CodedOutputStream.ComputeInt32Size(PrimitiveField);

2782 }

2783 if (StringField.Length != 0) {

2784 size += 1 + pb::CodedOutputStream.ComputeStringSize(StringField);

2785 }

2786 if (EnumField != global::Google.Protobuf.TestProtos.ForeignEnum.FOREIGN_UN SPECIFIED) {

2787 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) EnumField);

2788 }

2789 if (messageField_ != null) {

2790 size += 1 + pb::CodedOutputStream.ComputeMessageSize(MessageField);

2791 }

2792 size += repeatedPrimitiveField_.CalculateSize(_repeated_repeatedPrimitiveF ield_codec);

2793 size += repeatedStringField_.CalculateSize(_repeated_repeatedStringField_c odec);

2794 size += repeatedEnumField_.CalculateSize(_repeated_repeatedEnumField_codec );

2795 size += repeatedMessageField_.CalculateSize(_repeated_repeatedMessageField _codec);

2796 return size;

2797 }

2798

2799 public void MergeFrom(TestCamelCaseFieldNames other) {

2800 if (other == null) {

2801 return;

2802 }

2803 if (other.PrimitiveField != 0) {

2804 PrimitiveField = other.PrimitiveField;

2805 }

2806 if (other.StringField.Length != 0) {

2807 StringField = other.StringField;

2808 }

2809 if (other.EnumField != global::Google.Protobuf.TestProtos.ForeignEnum.FORE IGN_UNSPECIFIED) {

2810 EnumField = other.EnumField;

2811 }

2812 if (other.messageField_ != null) {

2813 if (messageField_ == null) {

2814 messageField_ = new global::Google.Protobuf.TestProtos.ForeignMessage( );

2815 }

2816 MessageField.MergeFrom(other.MessageField);

2817 }

2818 repeatedPrimitiveField_.Add(other.repeatedPrimitiveField_);

2819 repeatedStringField_.Add(other.repeatedStringField_);

2820 repeatedEnumField_.Add(other.repeatedEnumField_);

2821 repeatedMessageField_.Add(other.repeatedMessageField_);

2822 }

2823

2824 public void MergeFrom(pb::CodedInputStream input) {

2825 uint tag;

2826 while ((tag = input.ReadTag()) != 0) {

2827 switch(tag) {

2828 default:

2829 input.SkipLastField();

2830 break;

2831 case 8: {

2832 PrimitiveField = input.ReadInt32();

2833 break;

2834 }

2835 case 18: {

2836 StringField = input.ReadString();

2837 break;

2838 }

2839 case 24: {

2840 enumField_ = (global::Google.Protobuf.TestProtos.ForeignEnum) input. ReadEnum();

2841 break;

2842 }

2843 case 34: {

2844 if (messageField_ == null) {

2845 messageField_ = new global::Google.Protobuf.TestProtos.ForeignMess age();

2846 }

2847 input.ReadMessage(messageField_);

2848 break;

2849 }

2850 case 58:

2851 case 56: {

2852 repeatedPrimitiveField_.AddEntriesFrom(input, _repeated_repeatedPrim itiveField_codec);

2853 break;

2854 }

2855 case 66: {

2856 repeatedStringField_.AddEntriesFrom(input, _repeated_repeatedStringF ield_codec);

2857 break;

2858 }

2859 case 74:

2860 case 72: {

2861 repeatedEnumField_.AddEntriesFrom(input, _repeated_repeatedEnumField _codec);

2862 break;

2863 }

2864 case 82: {

2865 repeatedMessageField_.AddEntriesFrom(input, _repeated_repeatedMessag eField_codec);

2866 break;

2867 }

2868 }

2869 }

2870 }

2871

2872 }

2873

2874 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

2875 public sealed partial class TestFieldOrderings : pb::IMessage<TestFieldOrderin gs> {

2876 private static readonly pb::MessageParser<TestFieldOrderings> _parser = new pb::MessageParser<TestFieldOrderings>(() => new TestFieldOrderings());

2877 public static pb::MessageParser<TestFieldOrderings> Parser { get { return _p arser; } }

2878

2879 public static pbr::MessageDescriptor Descriptor {

2880 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[11]; }

2881 }

2882

2883 pbr::MessageDescriptor pb::IMessage.Descriptor {

2884 get { return Descriptor; }

2885 }

2886

2887 public TestFieldOrderings() {

2888 OnConstruction();

2889 }

2890

2891 partial void OnConstruction();

2892

2893 public TestFieldOrderings(TestFieldOrderings other) : this() {

2894 myString_ = other.myString_;

2895 myInt_ = other.myInt_;

2896 myFloat_ = other.myFloat_;

2897 SingleNestedMessage = other.singleNestedMessage_ != null ? other.SingleNes tedMessage.Clone() : null;

2898 }

2899

2900 public TestFieldOrderings Clone() {

2901 return new TestFieldOrderings(this);

2902 }

2903

2904 public const int MyStringFieldNumber = 11;

2905 private string myString_ = "";

2906 public string MyString {

2907 get { return myString_; }

2908 set {

2909 myString_ = pb::Preconditions.CheckNotNull(value, "value");

2910 }

2911 }

2912

2913 public const int MyIntFieldNumber = 1;

2914 private long myInt_;

2915 public long MyInt {

2916 get { return myInt_; }

2917 set {

2918 myInt_ = value;

2919 }

2920 }

2921

2922 public const int MyFloatFieldNumber = 101;

2923 private float myFloat_;

2924 public float MyFloat {

2925 get { return myFloat_; }

2926 set {

2927 myFloat_ = value;

2928 }

2929 }

2930

2931 public const int SingleNestedMessageFieldNumber = 200;

2932 private global::Google.Protobuf.TestProtos.TestFieldOrderings.Types.NestedMe ssage singleNestedMessage_;

2933 public global::Google.Protobuf.TestProtos.TestFieldOrderings.Types.NestedMes sage SingleNestedMessage {

2934 get { return singleNestedMessage_; }

2935 set {

2936 singleNestedMessage_ = value;

2937 }

2938 }

2939

2940 public override bool Equals(object other) {

2941 return Equals(other as TestFieldOrderings);

2942 }

2943

2944 public bool Equals(TestFieldOrderings other) {

2945 if (ReferenceEquals(other, null)) {

2946 return false;

2947 }

2948 if (ReferenceEquals(other, this)) {

2949 return true;

2950 }

2951 if (MyString != other.MyString) return false;

2952 if (MyInt != other.MyInt) return false;

2953 if (MyFloat != other.MyFloat) return false;

2954 if (!object.Equals(SingleNestedMessage, other.SingleNestedMessage)) return false;

2955 return true;

2956 }

2957

2958 public override int GetHashCode() {

2959 int hash = 1;

2960 if (MyString.Length != 0) hash ^= MyString.GetHashCode();

2961 if (MyInt != 0L) hash ^= MyInt.GetHashCode();

2962 if (MyFloat != 0F) hash ^= MyFloat.GetHashCode();

2963 if (singleNestedMessage_ != null) hash ^= SingleNestedMessage.GetHashCode( );

2964 return hash;

2965 }

2966

2967 public override string ToString() {

2968 return pb::JsonFormatter.Default.Format(this);

2969 }

2970

2971 public void WriteTo(pb::CodedOutputStream output) {

2972 if (MyInt != 0L) {

2973 output.WriteRawTag(8);

2974 output.WriteInt64(MyInt);

2975 }

2976 if (MyString.Length != 0) {

2977 output.WriteRawTag(90);

2978 output.WriteString(MyString);

2979 }

2980 if (MyFloat != 0F) {

2981 output.WriteRawTag(173, 6);

2982 output.WriteFloat(MyFloat);

2983 }

2984 if (singleNestedMessage_ != null) {

2985 output.WriteRawTag(194, 12);

2986 output.WriteMessage(SingleNestedMessage);

2987 }

2988 }

2989

2990 public int CalculateSize() {

2991 int size = 0;

2992 if (MyString.Length != 0) {

2993 size += 1 + pb::CodedOutputStream.ComputeStringSize(MyString);

2994 }

2995 if (MyInt != 0L) {

2996 size += 1 + pb::CodedOutputStream.ComputeInt64Size(MyInt);

2997 }

2998 if (MyFloat != 0F) {

2999 size += 2 + 4;

3000 }

3001 if (singleNestedMessage_ != null) {

3002 size += 2 + pb::CodedOutputStream.ComputeMessageSize(SingleNestedMessage );

3003 }

3004 return size;

3005 }

3006

3007 public void MergeFrom(TestFieldOrderings other) {

3008 if (other == null) {

3009 return;

3010 }

3011 if (other.MyString.Length != 0) {

3012 MyString = other.MyString;

3013 }

3014 if (other.MyInt != 0L) {

3015 MyInt = other.MyInt;

3016 }

3017 if (other.MyFloat != 0F) {

3018 MyFloat = other.MyFloat;

3019 }

3020 if (other.singleNestedMessage_ != null) {

3021 if (singleNestedMessage_ == null) {

3022 singleNestedMessage_ = new global::Google.Protobuf.TestProtos.TestFiel dOrderings.Types.NestedMessage();

3023 }

3024 SingleNestedMessage.MergeFrom(other.SingleNestedMessage);

3025 }

3026 }

3027

3028 public void MergeFrom(pb::CodedInputStream input) {

3029 uint tag;

3030 while ((tag = input.ReadTag()) != 0) {

3031 switch(tag) {

3032 default:

3033 input.SkipLastField();

3034 break;

3035 case 8: {

3036 MyInt = input.ReadInt64();

3037 break;

3038 }

3039 case 90: {

3040 MyString = input.ReadString();

3041 break;

3042 }

3043 case 813: {

3044 MyFloat = input.ReadFloat();

3045 break;

3046 }

3047 case 1602: {

3048 if (singleNestedMessage_ == null) {

3049 singleNestedMessage_ = new global::Google.Protobuf.TestProtos.Test FieldOrderings.Types.NestedMessage();

3050 }

3051 input.ReadMessage(singleNestedMessage_);

3052 break;

3053 }

3054 }

3055 }

3056 }

3057

3058 #region Nested types

3059 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3060 public static partial class Types {

3061 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3062 public sealed partial class NestedMessage : pb::IMessage<NestedMessage> {

3063 private static readonly pb::MessageParser<NestedMessage> _parser = new p b::MessageParser<NestedMessage>(() => new NestedMessage());

3064 public static pb::MessageParser<NestedMessage> Parser { get { return _pa rser; } }

3065

3066 public static pbr::MessageDescriptor Descriptor {

3067 get { return global::Google.Protobuf.TestProtos.TestFieldOrderings.Des criptor.NestedTypes[0]; }

3068 }

3069

3070 pbr::MessageDescriptor pb::IMessage.Descriptor {

3071 get { return Descriptor; }

3072 }

3073

3074 public NestedMessage() {

3075 OnConstruction();

3076 }

3077

3078 partial void OnConstruction();

3079

3080 public NestedMessage(NestedMessage other) : this() {

3081 oo_ = other.oo_;

3082 bb_ = other.bb_;

3083 }

3084

3085 public NestedMessage Clone() {

3086 return new NestedMessage(this);

3087 }

3088

3089 public const int OoFieldNumber = 2;

3090 private long oo_;

3091 public long Oo {

3092 get { return oo_; }

3093 set {

3094 oo_ = value;

3095 }

3096 }

3097

3098 public const int BbFieldNumber = 1;

3099 private int bb_;

3100 public int Bb {

3101 get { return bb_; }

3102 set {

3103 bb_ = value;

3104 }

3105 }

3106

3107 public override bool Equals(object other) {

3108 return Equals(other as NestedMessage);

3109 }

3110

3111 public bool Equals(NestedMessage other) {

3112 if (ReferenceEquals(other, null)) {

3113 return false;

3114 }

3115 if (ReferenceEquals(other, this)) {

3116 return true;

3117 }

3118 if (Oo != other.Oo) return false;

3119 if (Bb != other.Bb) return false;

3120 return true;

3121 }

3122

3123 public override int GetHashCode() {

3124 int hash = 1;

3125 if (Oo != 0L) hash ^= Oo.GetHashCode();

3126 if (Bb != 0) hash ^= Bb.GetHashCode();

3127 return hash;

3128 }

3129

3130 public override string ToString() {

3131 return pb::JsonFormatter.Default.Format(this);

3132 }

3133

3134 public void WriteTo(pb::CodedOutputStream output) {

3135 if (Bb != 0) {

3136 output.WriteRawTag(8);

3137 output.WriteInt32(Bb);

3138 }

3139 if (Oo != 0L) {

3140 output.WriteRawTag(16);

3141 output.WriteInt64(Oo);

3142 }

3143 }

3144

3145 public int CalculateSize() {

3146 int size = 0;

3147 if (Oo != 0L) {

3148 size += 1 + pb::CodedOutputStream.ComputeInt64Size(Oo);

3149 }

3150 if (Bb != 0) {

3151 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Bb);

3152 }

3153 return size;

3154 }

3155

3156 public void MergeFrom(NestedMessage other) {

3157 if (other == null) {

3158 return;

3159 }

3160 if (other.Oo != 0L) {

3161 Oo = other.Oo;

3162 }

3163 if (other.Bb != 0) {

3164 Bb = other.Bb;

3165 }

3166 }

3167

3168 public void MergeFrom(pb::CodedInputStream input) {

3169 uint tag;

3170 while ((tag = input.ReadTag()) != 0) {

3171 switch(tag) {

3172 default:

3173 input.SkipLastField();

3174 break;

3175 case 8: {

3176 Bb = input.ReadInt32();

3177 break;

3178 }

3179 case 16: {

3180 Oo = input.ReadInt64();

3181 break;

3182 }

3183 }

3184 }

3185 }

3186

3187 }

3188

3189 }

3190 #endregion

3191

3192 }

3193

3194 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3195 public sealed partial class SparseEnumMessage : pb::IMessage<SparseEnumMessage > {

3196 private static readonly pb::MessageParser<SparseEnumMessage> _parser = new p b::MessageParser<SparseEnumMessage>(() => new SparseEnumMessage());

3197 public static pb::MessageParser<SparseEnumMessage> Parser { get { return _pa rser; } }

3198

3199 public static pbr::MessageDescriptor Descriptor {

3200 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[12]; }

3201 }

3202

3203 pbr::MessageDescriptor pb::IMessage.Descriptor {

3204 get { return Descriptor; }

3205 }

3206

3207 public SparseEnumMessage() {

3208 OnConstruction();

3209 }

3210

3211 partial void OnConstruction();

3212

3213 public SparseEnumMessage(SparseEnumMessage other) : this() {

3214 sparseEnum_ = other.sparseEnum_;

3215 }

3216

3217 public SparseEnumMessage Clone() {

3218 return new SparseEnumMessage(this);

3219 }

3220

3221 public const int SparseEnumFieldNumber = 1;

3222 private global::Google.Protobuf.TestProtos.TestSparseEnum sparseEnum_ = glob al::Google.Protobuf.TestProtos.TestSparseEnum.TEST_SPARSE_ENUM_UNSPECIFIED;

3223 public global::Google.Protobuf.TestProtos.TestSparseEnum SparseEnum {

3224 get { return sparseEnum_; }

3225 set {

3226 sparseEnum_ = value;

3227 }

3228 }

3229

3230 public override bool Equals(object other) {

3231 return Equals(other as SparseEnumMessage);

3232 }

3233

3234 public bool Equals(SparseEnumMessage other) {

3235 if (ReferenceEquals(other, null)) {

3236 return false;

3237 }

3238 if (ReferenceEquals(other, this)) {

3239 return true;

3240 }

3241 if (SparseEnum != other.SparseEnum) return false;

3242 return true;

3243 }

3244

3245 public override int GetHashCode() {

3246 int hash = 1;

3247 if (SparseEnum != global::Google.Protobuf.TestProtos.TestSparseEnum.TEST_S PARSE_ENUM_UNSPECIFIED) hash ^= SparseEnum.GetHashCode();

3248 return hash;

3249 }

3250

3251 public override string ToString() {

3252 return pb::JsonFormatter.Default.Format(this);

3253 }

3254

3255 public void WriteTo(pb::CodedOutputStream output) {

3256 if (SparseEnum != global::Google.Protobuf.TestProtos.TestSparseEnum.TEST_S PARSE_ENUM_UNSPECIFIED) {

3257 output.WriteRawTag(8);

3258 output.WriteEnum((int) SparseEnum);

3259 }

3260 }

3261

3262 public int CalculateSize() {

3263 int size = 0;

3264 if (SparseEnum != global::Google.Protobuf.TestProtos.TestSparseEnum.TEST_S PARSE_ENUM_UNSPECIFIED) {

3265 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) SparseEnum);

3266 }

3267 return size;

3268 }

3269

3270 public void MergeFrom(SparseEnumMessage other) {

3271 if (other == null) {

3272 return;

3273 }

3274 if (other.SparseEnum != global::Google.Protobuf.TestProtos.TestSparseEnum. TEST_SPARSE_ENUM_UNSPECIFIED) {

3275 SparseEnum = other.SparseEnum;

3276 }

3277 }

3278

3279 public void MergeFrom(pb::CodedInputStream input) {

3280 uint tag;

3281 while ((tag = input.ReadTag()) != 0) {

3282 switch(tag) {

3283 default:

3284 input.SkipLastField();

3285 break;

3286 case 8: {

3287 sparseEnum_ = (global::Google.Protobuf.TestProtos.TestSparseEnum) in put.ReadEnum();

3288 break;

3289 }

3290 }

3291 }

3292 }

3293

3294 }

3295

3296 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3297 public sealed partial class OneString : pb::IMessage<OneString> {

3298 private static readonly pb::MessageParser<OneString> _parser = new pb::Messa geParser<OneString>(() => new OneString());

3299 public static pb::MessageParser<OneString> Parser { get { return _parser; } }

3300

3301 public static pbr::MessageDescriptor Descriptor {

3302 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[13]; }

3303 }

3304

3305 pbr::MessageDescriptor pb::IMessage.Descriptor {

3306 get { return Descriptor; }

3307 }

3308

3309 public OneString() {

3310 OnConstruction();

3311 }

3312

3313 partial void OnConstruction();

3314

3315 public OneString(OneString other) : this() {

3316 data_ = other.data_;

3317 }

3318

3319 public OneString Clone() {

3320 return new OneString(this);

3321 }

3322

3323 public const int DataFieldNumber = 1;

3324 private string data_ = "";

3325 public string Data {

3326 get { return data_; }

3327 set {

3328 data_ = pb::Preconditions.CheckNotNull(value, "value");

3329 }

3330 }

3331

3332 public override bool Equals(object other) {

3333 return Equals(other as OneString);

3334 }

3335

3336 public bool Equals(OneString other) {

3337 if (ReferenceEquals(other, null)) {

3338 return false;

3339 }

3340 if (ReferenceEquals(other, this)) {

3341 return true;

3342 }

3343 if (Data != other.Data) return false;

3344 return true;

3345 }

3346

3347 public override int GetHashCode() {

3348 int hash = 1;

3349 if (Data.Length != 0) hash ^= Data.GetHashCode();

3350 return hash;

3351 }

3352

3353 public override string ToString() {

3354 return pb::JsonFormatter.Default.Format(this);

3355 }

3356

3357 public void WriteTo(pb::CodedOutputStream output) {

3358 if (Data.Length != 0) {

3359 output.WriteRawTag(10);

3360 output.WriteString(Data);

3361 }

3362 }

3363

3364 public int CalculateSize() {

3365 int size = 0;

3366 if (Data.Length != 0) {

3367 size += 1 + pb::CodedOutputStream.ComputeStringSize(Data);

3368 }

3369 return size;

3370 }

3371

3372 public void MergeFrom(OneString other) {

3373 if (other == null) {

3374 return;

3375 }

3376 if (other.Data.Length != 0) {

3377 Data = other.Data;

3378 }

3379 }

3380

3381 public void MergeFrom(pb::CodedInputStream input) {

3382 uint tag;

3383 while ((tag = input.ReadTag()) != 0) {

3384 switch(tag) {

3385 default:

3386 input.SkipLastField();

3387 break;

3388 case 10: {

3389 Data = input.ReadString();

3390 break;

3391 }

3392 }

3393 }

3394 }

3395

3396 }

3397

3398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3399 public sealed partial class MoreString : pb::IMessage<MoreString> {

3400 private static readonly pb::MessageParser<MoreString> _parser = new pb::Mess ageParser<MoreString>(() => new MoreString());

3401 public static pb::MessageParser<MoreString> Parser { get { return _parser; } }

3402

3403 public static pbr::MessageDescriptor Descriptor {

3404 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[14]; }

3405 }

3406

3407 pbr::MessageDescriptor pb::IMessage.Descriptor {

3408 get { return Descriptor; }

3409 }

3410

3411 public MoreString() {

3412 OnConstruction();

3413 }

3414

3415 partial void OnConstruction();

3416

3417 public MoreString(MoreString other) : this() {

3418 data_ = other.data_.Clone();

3419 }

3420

3421 public MoreString Clone() {

3422 return new MoreString(this);

3423 }

3424

3425 public const int DataFieldNumber = 1;

3426 private static readonly pb::FieldCodec<string> _repeated_data_codec

3427 = pb::FieldCodec.ForString(10);

3428 private readonly pbc::RepeatedField<string> data_ = new pbc::RepeatedField<s tring>();

3429 public pbc::RepeatedField<string> Data {

3430 get { return data_; }

3431 }

3432

3433 public override bool Equals(object other) {

3434 return Equals(other as MoreString);

3435 }

3436

3437 public bool Equals(MoreString other) {

3438 if (ReferenceEquals(other, null)) {

3439 return false;

3440 }

3441 if (ReferenceEquals(other, this)) {

3442 return true;

3443 }

3444 if(!data_.Equals(other.data_)) return false;

3445 return true;

3446 }

3447

3448 public override int GetHashCode() {

3449 int hash = 1;

3450 hash ^= data_.GetHashCode();

3451 return hash;

3452 }

3453

3454 public override string ToString() {

3455 return pb::JsonFormatter.Default.Format(this);

3456 }

3457

3458 public void WriteTo(pb::CodedOutputStream output) {

3459 data_.WriteTo(output, _repeated_data_codec);

3460 }

3461

3462 public int CalculateSize() {

3463 int size = 0;

3464 size += data_.CalculateSize(_repeated_data_codec);

3465 return size;

3466 }

3467

3468 public void MergeFrom(MoreString other) {

3469 if (other == null) {

3470 return;

3471 }

3472 data_.Add(other.data_);

3473 }

3474

3475 public void MergeFrom(pb::CodedInputStream input) {

3476 uint tag;

3477 while ((tag = input.ReadTag()) != 0) {

3478 switch(tag) {

3479 default:

3480 input.SkipLastField();

3481 break;

3482 case 10: {

3483 data_.AddEntriesFrom(input, _repeated_data_codec);

3484 break;

3485 }

3486 }

3487 }

3488 }

3489

3490 }

3491

3492 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3493 public sealed partial class OneBytes : pb::IMessage<OneBytes> {

3494 private static readonly pb::MessageParser<OneBytes> _parser = new pb::Messag eParser<OneBytes>(() => new OneBytes());

3495 public static pb::MessageParser<OneBytes> Parser { get { return _parser; } }

3496

3497 public static pbr::MessageDescriptor Descriptor {

3498 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[15]; }

3499 }

3500

3501 pbr::MessageDescriptor pb::IMessage.Descriptor {

3502 get { return Descriptor; }

3503 }

3504

3505 public OneBytes() {

3506 OnConstruction();

3507 }

3508

3509 partial void OnConstruction();

3510

3511 public OneBytes(OneBytes other) : this() {

3512 data_ = other.data_;

3513 }

3514

3515 public OneBytes Clone() {

3516 return new OneBytes(this);

3517 }

3518

3519 public const int DataFieldNumber = 1;

3520 private pb::ByteString data_ = pb::ByteString.Empty;

3521 public pb::ByteString Data {

3522 get { return data_; }

3523 set {

3524 data_ = pb::Preconditions.CheckNotNull(value, "value");

3525 }

3526 }

3527

3528 public override bool Equals(object other) {

3529 return Equals(other as OneBytes);

3530 }

3531

3532 public bool Equals(OneBytes other) {

3533 if (ReferenceEquals(other, null)) {

3534 return false;

3535 }

3536 if (ReferenceEquals(other, this)) {

3537 return true;

3538 }

3539 if (Data != other.Data) return false;

3540 return true;

3541 }

3542

3543 public override int GetHashCode() {

3544 int hash = 1;

3545 if (Data.Length != 0) hash ^= Data.GetHashCode();

3546 return hash;

3547 }

3548

3549 public override string ToString() {

3550 return pb::JsonFormatter.Default.Format(this);

3551 }

3552

3553 public void WriteTo(pb::CodedOutputStream output) {

3554 if (Data.Length != 0) {

3555 output.WriteRawTag(10);

3556 output.WriteBytes(Data);

3557 }

3558 }

3559

3560 public int CalculateSize() {

3561 int size = 0;

3562 if (Data.Length != 0) {

3563 size += 1 + pb::CodedOutputStream.ComputeBytesSize(Data);

3564 }

3565 return size;

3566 }

3567

3568 public void MergeFrom(OneBytes other) {

3569 if (other == null) {

3570 return;

3571 }

3572 if (other.Data.Length != 0) {

3573 Data = other.Data;

3574 }

3575 }

3576

3577 public void MergeFrom(pb::CodedInputStream input) {

3578 uint tag;

3579 while ((tag = input.ReadTag()) != 0) {

3580 switch(tag) {

3581 default:

3582 input.SkipLastField();

3583 break;

3584 case 10: {

3585 Data = input.ReadBytes();

3586 break;

3587 }

3588 }

3589 }

3590 }

3591

3592 }

3593

3594 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3595 public sealed partial class MoreBytes : pb::IMessage<MoreBytes> {

3596 private static readonly pb::MessageParser<MoreBytes> _parser = new pb::Messa geParser<MoreBytes>(() => new MoreBytes());

3597 public static pb::MessageParser<MoreBytes> Parser { get { return _parser; } }

3598

3599 public static pbr::MessageDescriptor Descriptor {

3600 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[16]; }

3601 }

3602

3603 pbr::MessageDescriptor pb::IMessage.Descriptor {

3604 get { return Descriptor; }

3605 }

3606

3607 public MoreBytes() {

3608 OnConstruction();

3609 }

3610

3611 partial void OnConstruction();

3612

3613 public MoreBytes(MoreBytes other) : this() {

3614 data_ = other.data_;

3615 }

3616

3617 public MoreBytes Clone() {

3618 return new MoreBytes(this);

3619 }

3620

3621 public const int DataFieldNumber = 1;

3622 private pb::ByteString data_ = pb::ByteString.Empty;

3623 public pb::ByteString Data {

3624 get { return data_; }

3625 set {

3626 data_ = pb::Preconditions.CheckNotNull(value, "value");

3627 }

3628 }

3629

3630 public override bool Equals(object other) {

3631 return Equals(other as MoreBytes);

3632 }

3633

3634 public bool Equals(MoreBytes other) {

3635 if (ReferenceEquals(other, null)) {

3636 return false;

3637 }

3638 if (ReferenceEquals(other, this)) {

3639 return true;

3640 }

3641 if (Data != other.Data) return false;

3642 return true;

3643 }

3644

3645 public override int GetHashCode() {

3646 int hash = 1;

3647 if (Data.Length != 0) hash ^= Data.GetHashCode();

3648 return hash;

3649 }

3650

3651 public override string ToString() {

3652 return pb::JsonFormatter.Default.Format(this);

3653 }

3654

3655 public void WriteTo(pb::CodedOutputStream output) {

3656 if (Data.Length != 0) {

3657 output.WriteRawTag(10);

3658 output.WriteBytes(Data);

3659 }

3660 }

3661

3662 public int CalculateSize() {

3663 int size = 0;

3664 if (Data.Length != 0) {

3665 size += 1 + pb::CodedOutputStream.ComputeBytesSize(Data);

3666 }

3667 return size;

3668 }

3669

3670 public void MergeFrom(MoreBytes other) {

3671 if (other == null) {

3672 return;

3673 }

3674 if (other.Data.Length != 0) {

3675 Data = other.Data;

3676 }

3677 }

3678

3679 public void MergeFrom(pb::CodedInputStream input) {

3680 uint tag;

3681 while ((tag = input.ReadTag()) != 0) {

3682 switch(tag) {

3683 default:

3684 input.SkipLastField();

3685 break;

3686 case 10: {

3687 Data = input.ReadBytes();

3688 break;

3689 }

3690 }

3691 }

3692 }

3693

3694 }

3695

3696 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3697 public sealed partial class Int32Message : pb::IMessage<Int32Message> {

3698 private static readonly pb::MessageParser<Int32Message> _parser = new pb::Me ssageParser<Int32Message>(() => new Int32Message());

3699 public static pb::MessageParser<Int32Message> Parser { get { return _parser; } }

3700

3701 public static pbr::MessageDescriptor Descriptor {

3702 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[17]; }

3703 }

3704

3705 pbr::MessageDescriptor pb::IMessage.Descriptor {

3706 get { return Descriptor; }

3707 }

3708

3709 public Int32Message() {

3710 OnConstruction();

3711 }

3712

3713 partial void OnConstruction();

3714

3715 public Int32Message(Int32Message other) : this() {

3716 data_ = other.data_;

3717 }

3718

3719 public Int32Message Clone() {

3720 return new Int32Message(this);

3721 }

3722

3723 public const int DataFieldNumber = 1;

3724 private int data_;

3725 public int Data {

3726 get { return data_; }

3727 set {

3728 data_ = value;

3729 }

3730 }

3731

3732 public override bool Equals(object other) {

3733 return Equals(other as Int32Message);

3734 }

3735

3736 public bool Equals(Int32Message other) {

3737 if (ReferenceEquals(other, null)) {

3738 return false;

3739 }

3740 if (ReferenceEquals(other, this)) {

3741 return true;

3742 }

3743 if (Data != other.Data) return false;

3744 return true;

3745 }

3746

3747 public override int GetHashCode() {

3748 int hash = 1;

3749 if (Data != 0) hash ^= Data.GetHashCode();

3750 return hash;

3751 }

3752

3753 public override string ToString() {

3754 return pb::JsonFormatter.Default.Format(this);

3755 }

3756

3757 public void WriteTo(pb::CodedOutputStream output) {

3758 if (Data != 0) {

3759 output.WriteRawTag(8);

3760 output.WriteInt32(Data);

3761 }

3762 }

3763

3764 public int CalculateSize() {

3765 int size = 0;

3766 if (Data != 0) {

3767 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Data);

3768 }

3769 return size;

3770 }

3771

3772 public void MergeFrom(Int32Message other) {

3773 if (other == null) {

3774 return;

3775 }

3776 if (other.Data != 0) {

3777 Data = other.Data;

3778 }

3779 }

3780

3781 public void MergeFrom(pb::CodedInputStream input) {

3782 uint tag;

3783 while ((tag = input.ReadTag()) != 0) {

3784 switch(tag) {

3785 default:

3786 input.SkipLastField();

3787 break;

3788 case 8: {

3789 Data = input.ReadInt32();

3790 break;

3791 }

3792 }

3793 }

3794 }

3795

3796 }

3797

3798 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3799 public sealed partial class Uint32Message : pb::IMessage<Uint32Message> {

3800 private static readonly pb::MessageParser<Uint32Message> _parser = new pb::M essageParser<Uint32Message>(() => new Uint32Message());

3801 public static pb::MessageParser<Uint32Message> Parser { get { return _parser ; } }

3802

3803 public static pbr::MessageDescriptor Descriptor {

3804 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[18]; }

3805 }

3806

3807 pbr::MessageDescriptor pb::IMessage.Descriptor {

3808 get { return Descriptor; }

3809 }

3810

3811 public Uint32Message() {

3812 OnConstruction();

3813 }

3814

3815 partial void OnConstruction();

3816

3817 public Uint32Message(Uint32Message other) : this() {

3818 data_ = other.data_;

3819 }

3820

3821 public Uint32Message Clone() {

3822 return new Uint32Message(this);

3823 }

3824

3825 public const int DataFieldNumber = 1;

3826 private uint data_;

3827 public uint Data {

3828 get { return data_; }

3829 set {

3830 data_ = value;

3831 }

3832 }

3833

3834 public override bool Equals(object other) {

3835 return Equals(other as Uint32Message);

3836 }

3837

3838 public bool Equals(Uint32Message other) {

3839 if (ReferenceEquals(other, null)) {

3840 return false;

3841 }

3842 if (ReferenceEquals(other, this)) {

3843 return true;

3844 }

3845 if (Data != other.Data) return false;

3846 return true;

3847 }

3848

3849 public override int GetHashCode() {

3850 int hash = 1;

3851 if (Data != 0) hash ^= Data.GetHashCode();

3852 return hash;

3853 }

3854

3855 public override string ToString() {

3856 return pb::JsonFormatter.Default.Format(this);

3857 }

3858

3859 public void WriteTo(pb::CodedOutputStream output) {

3860 if (Data != 0) {

3861 output.WriteRawTag(8);

3862 output.WriteUInt32(Data);

3863 }

3864 }

3865

3866 public int CalculateSize() {

3867 int size = 0;

3868 if (Data != 0) {

3869 size += 1 + pb::CodedOutputStream.ComputeUInt32Size(Data);

3870 }

3871 return size;

3872 }

3873

3874 public void MergeFrom(Uint32Message other) {

3875 if (other == null) {

3876 return;

3877 }

3878 if (other.Data != 0) {

3879 Data = other.Data;

3880 }

3881 }

3882

3883 public void MergeFrom(pb::CodedInputStream input) {

3884 uint tag;

3885 while ((tag = input.ReadTag()) != 0) {

3886 switch(tag) {

3887 default:

3888 input.SkipLastField();

3889 break;

3890 case 8: {

3891 Data = input.ReadUInt32();

3892 break;

3893 }

3894 }

3895 }

3896 }

3897

3898 }

3899

3900 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

3901 public sealed partial class Int64Message : pb::IMessage<Int64Message> {

3902 private static readonly pb::MessageParser<Int64Message> _parser = new pb::Me ssageParser<Int64Message>(() => new Int64Message());

3903 public static pb::MessageParser<Int64Message> Parser { get { return _parser; } }

3904

3905 public static pbr::MessageDescriptor Descriptor {

3906 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[19]; }

3907 }

3908

3909 pbr::MessageDescriptor pb::IMessage.Descriptor {

3910 get { return Descriptor; }

3911 }

3912

3913 public Int64Message() {

3914 OnConstruction();

3915 }

3916

3917 partial void OnConstruction();

3918

3919 public Int64Message(Int64Message other) : this() {

3920 data_ = other.data_;

3921 }

3922

3923 public Int64Message Clone() {

3924 return new Int64Message(this);

3925 }

3926

3927 public const int DataFieldNumber = 1;

3928 private long data_;

3929 public long Data {

3930 get { return data_; }

3931 set {

3932 data_ = value;

3933 }

3934 }

3935

3936 public override bool Equals(object other) {

3937 return Equals(other as Int64Message);

3938 }

3939

3940 public bool Equals(Int64Message other) {

3941 if (ReferenceEquals(other, null)) {

3942 return false;

3943 }

3944 if (ReferenceEquals(other, this)) {

3945 return true;

3946 }

3947 if (Data != other.Data) return false;

3948 return true;

3949 }

3950

3951 public override int GetHashCode() {

3952 int hash = 1;

3953 if (Data != 0L) hash ^= Data.GetHashCode();

3954 return hash;

3955 }

3956

3957 public override string ToString() {

3958 return pb::JsonFormatter.Default.Format(this);

3959 }

3960

3961 public void WriteTo(pb::CodedOutputStream output) {

3962 if (Data != 0L) {

3963 output.WriteRawTag(8);

3964 output.WriteInt64(Data);

3965 }

3966 }

3967

3968 public int CalculateSize() {

3969 int size = 0;

3970 if (Data != 0L) {

3971 size += 1 + pb::CodedOutputStream.ComputeInt64Size(Data);

3972 }

3973 return size;

3974 }

3975

3976 public void MergeFrom(Int64Message other) {

3977 if (other == null) {

3978 return;

3979 }

3980 if (other.Data != 0L) {

3981 Data = other.Data;

3982 }

3983 }

3984

3985 public void MergeFrom(pb::CodedInputStream input) {

3986 uint tag;

3987 while ((tag = input.ReadTag()) != 0) {

3988 switch(tag) {

3989 default:

3990 input.SkipLastField();

3991 break;

3992 case 8: {

3993 Data = input.ReadInt64();

3994 break;

3995 }

3996 }

3997 }

3998 }

3999

4000 }

4001

4002 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

4003 public sealed partial class Uint64Message : pb::IMessage<Uint64Message> {

4004 private static readonly pb::MessageParser<Uint64Message> _parser = new pb::M essageParser<Uint64Message>(() => new Uint64Message());

4005 public static pb::MessageParser<Uint64Message> Parser { get { return _parser ; } }

4006

4007 public static pbr::MessageDescriptor Descriptor {

4008 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[20]; }

4009 }

4010

4011 pbr::MessageDescriptor pb::IMessage.Descriptor {

4012 get { return Descriptor; }

4013 }

4014

4015 public Uint64Message() {

4016 OnConstruction();

4017 }

4018

4019 partial void OnConstruction();

4020

4021 public Uint64Message(Uint64Message other) : this() {

4022 data_ = other.data_;

4023 }

4024

4025 public Uint64Message Clone() {

4026 return new Uint64Message(this);

4027 }

4028

4029 public const int DataFieldNumber = 1;

4030 private ulong data_;

4031 public ulong Data {

4032 get { return data_; }

4033 set {

4034 data_ = value;

4035 }

4036 }

4037

4038 public override bool Equals(object other) {

4039 return Equals(other as Uint64Message);

4040 }

4041

4042 public bool Equals(Uint64Message other) {

4043 if (ReferenceEquals(other, null)) {

4044 return false;

4045 }

4046 if (ReferenceEquals(other, this)) {

4047 return true;

4048 }

4049 if (Data != other.Data) return false;

4050 return true;

4051 }

4052

4053 public override int GetHashCode() {

4054 int hash = 1;

4055 if (Data != 0UL) hash ^= Data.GetHashCode();

4056 return hash;

4057 }

4058

4059 public override string ToString() {

4060 return pb::JsonFormatter.Default.Format(this);

4061 }

4062

4063 public void WriteTo(pb::CodedOutputStream output) {

4064 if (Data != 0UL) {

4065 output.WriteRawTag(8);

4066 output.WriteUInt64(Data);

4067 }

4068 }

4069

4070 public int CalculateSize() {

4071 int size = 0;

4072 if (Data != 0UL) {

4073 size += 1 + pb::CodedOutputStream.ComputeUInt64Size(Data);

4074 }

4075 return size;

4076 }

4077

4078 public void MergeFrom(Uint64Message other) {

4079 if (other == null) {

4080 return;

4081 }

4082 if (other.Data != 0UL) {

4083 Data = other.Data;

4084 }

4085 }

4086

4087 public void MergeFrom(pb::CodedInputStream input) {

4088 uint tag;

4089 while ((tag = input.ReadTag()) != 0) {

4090 switch(tag) {

4091 default:

4092 input.SkipLastField();

4093 break;

4094 case 8: {

4095 Data = input.ReadUInt64();

4096 break;

4097 }

4098 }

4099 }

4100 }

4101

4102 }

4103

4104 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

4105 public sealed partial class BoolMessage : pb::IMessage<BoolMessage> {

4106 private static readonly pb::MessageParser<BoolMessage> _parser = new pb::Mes sageParser<BoolMessage>(() => new BoolMessage());

4107 public static pb::MessageParser<BoolMessage> Parser { get { return _parser; } }

4108

4109 public static pbr::MessageDescriptor Descriptor {

4110 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[21]; }

4111 }

4112

4113 pbr::MessageDescriptor pb::IMessage.Descriptor {

4114 get { return Descriptor; }

4115 }

4116

4117 public BoolMessage() {

4118 OnConstruction();

4119 }

4120

4121 partial void OnConstruction();

4122

4123 public BoolMessage(BoolMessage other) : this() {

4124 data_ = other.data_;

4125 }

4126

4127 public BoolMessage Clone() {

4128 return new BoolMessage(this);

4129 }

4130

4131 public const int DataFieldNumber = 1;

4132 private bool data_;

4133 public bool Data {

4134 get { return data_; }

4135 set {

4136 data_ = value;

4137 }

4138 }

4139

4140 public override bool Equals(object other) {

4141 return Equals(other as BoolMessage);

4142 }

4143

4144 public bool Equals(BoolMessage other) {

4145 if (ReferenceEquals(other, null)) {

4146 return false;

4147 }

4148 if (ReferenceEquals(other, this)) {

4149 return true;

4150 }

4151 if (Data != other.Data) return false;

4152 return true;

4153 }

4154

4155 public override int GetHashCode() {

4156 int hash = 1;

4157 if (Data != false) hash ^= Data.GetHashCode();

4158 return hash;

4159 }

4160

4161 public override string ToString() {

4162 return pb::JsonFormatter.Default.Format(this);

4163 }

4164

4165 public void WriteTo(pb::CodedOutputStream output) {

4166 if (Data != false) {

4167 output.WriteRawTag(8);

4168 output.WriteBool(Data);

4169 }

4170 }

4171

4172 public int CalculateSize() {

4173 int size = 0;

4174 if (Data != false) {

4175 size += 1 + 1;

4176 }

4177 return size;

4178 }

4179

4180 public void MergeFrom(BoolMessage other) {

4181 if (other == null) {

4182 return;

4183 }

4184 if (other.Data != false) {

4185 Data = other.Data;

4186 }

4187 }

4188

4189 public void MergeFrom(pb::CodedInputStream input) {

4190 uint tag;

4191 while ((tag = input.ReadTag()) != 0) {

4192 switch(tag) {

4193 default:

4194 input.SkipLastField();

4195 break;

4196 case 8: {

4197 Data = input.ReadBool();

4198 break;

4199 }

4200 }

4201 }

4202 }

4203

4204 }

4205

4206 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

4207 public sealed partial class TestOneof : pb::IMessage<TestOneof> {

4208 private static readonly pb::MessageParser<TestOneof> _parser = new pb::Messa geParser<TestOneof>(() => new TestOneof());

4209 public static pb::MessageParser<TestOneof> Parser { get { return _parser; } }

4210

4211 public static pbr::MessageDescriptor Descriptor {

4212 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[22]; }

4213 }

4214

4215 pbr::MessageDescriptor pb::IMessage.Descriptor {

4216 get { return Descriptor; }

4217 }

4218

4219 public TestOneof() {

4220 OnConstruction();

4221 }

4222

4223 partial void OnConstruction();

4224

4225 public TestOneof(TestOneof other) : this() {

4226 switch (other.FooCase) {

4227 case FooOneofCase.FooInt:

4228 FooInt = other.FooInt;

4229 break;

4230 case FooOneofCase.FooString:

4231 FooString = other.FooString;

4232 break;

4233 case FooOneofCase.FooMessage:

4234 FooMessage = other.FooMessage.Clone();

4235 break;

4236 }

4237

4238 }

4239

4240 public TestOneof Clone() {

4241 return new TestOneof(this);

4242 }

4243

4244 public const int FooIntFieldNumber = 1;

4245 public int FooInt {

4246 get { return fooCase_ == FooOneofCase.FooInt ? (int) foo_ : 0; }

4247 set {

4248 foo_ = value;

4249 fooCase_ = FooOneofCase.FooInt;

4250 }

4251 }

4252

4253 public const int FooStringFieldNumber = 2;

4254 public string FooString {

4255 get { return fooCase_ == FooOneofCase.FooString ? (string) foo_ : ""; }

4256 set {

4257 foo_ = pb::Preconditions.CheckNotNull(value, "value");

4258 fooCase_ = FooOneofCase.FooString;

4259 }

4260 }

4261

4262 public const int FooMessageFieldNumber = 3;

4263 public global::Google.Protobuf.TestProtos.TestAllTypes FooMessage {

4264 get { return fooCase_ == FooOneofCase.FooMessage ? (global::Google.Protobu f.TestProtos.TestAllTypes) foo_ : null; }

4265 set {

4266 foo_ = value;

4267 fooCase_ = value == null ? FooOneofCase.None : FooOneofCase.FooMessage;

4268 }

4269 }

4270

4271 private object foo_;

4272 public enum FooOneofCase {

4273 None = 0,

4274 FooInt = 1,

4275 FooString = 2,

4276 FooMessage = 3,

4277 }

4278 private FooOneofCase fooCase_ = FooOneofCase.None;

4279 public FooOneofCase FooCase {

4280 get { return fooCase_; }

4281 }

4282

4283 public void ClearFoo() {

4284 fooCase_ = FooOneofCase.None;

4285 foo_ = null;

4286 }

4287

4288 public override bool Equals(object other) {

4289 return Equals(other as TestOneof);

4290 }

4291

4292 public bool Equals(TestOneof other) {

4293 if (ReferenceEquals(other, null)) {

4294 return false;

4295 }

4296 if (ReferenceEquals(other, this)) {

4297 return true;

4298 }

4299 if (FooInt != other.FooInt) return false;

4300 if (FooString != other.FooString) return false;

4301 if (!object.Equals(FooMessage, other.FooMessage)) return false;

4302 return true;

4303 }

4304

4305 public override int GetHashCode() {

4306 int hash = 1;

4307 if (fooCase_ == FooOneofCase.FooInt) hash ^= FooInt.GetHashCode();

4308 if (fooCase_ == FooOneofCase.FooString) hash ^= FooString.GetHashCode();

4309 if (fooCase_ == FooOneofCase.FooMessage) hash ^= FooMessage.GetHashCode();

4310 return hash;

4311 }

4312

4313 public override string ToString() {

4314 return pb::JsonFormatter.Default.Format(this);

4315 }

4316

4317 public void WriteTo(pb::CodedOutputStream output) {

4318 if (fooCase_ == FooOneofCase.FooInt) {

4319 output.WriteRawTag(8);

4320 output.WriteInt32(FooInt);

4321 }

4322 if (fooCase_ == FooOneofCase.FooString) {

4323 output.WriteRawTag(18);

4324 output.WriteString(FooString);

4325 }

4326 if (fooCase_ == FooOneofCase.FooMessage) {

4327 output.WriteRawTag(26);

4328 output.WriteMessage(FooMessage);

4329 }

4330 }

4331

4332 public int CalculateSize() {

4333 int size = 0;

4334 if (fooCase_ == FooOneofCase.FooInt) {

4335 size += 1 + pb::CodedOutputStream.ComputeInt32Size(FooInt);

4336 }

4337 if (fooCase_ == FooOneofCase.FooString) {

4338 size += 1 + pb::CodedOutputStream.ComputeStringSize(FooString);

4339 }

4340 if (fooCase_ == FooOneofCase.FooMessage) {

4341 size += 1 + pb::CodedOutputStream.ComputeMessageSize(FooMessage);

4342 }

4343 return size;

4344 }

4345

4346 public void MergeFrom(TestOneof other) {

4347 if (other == null) {

4348 return;

4349 }

4350 switch (other.FooCase) {

4351 case FooOneofCase.FooInt:

4352 FooInt = other.FooInt;

4353 break;

4354 case FooOneofCase.FooString:

4355 FooString = other.FooString;

4356 break;

4357 case FooOneofCase.FooMessage:

4358 FooMessage = other.FooMessage;

4359 break;

4360 }

4361

4362 }

4363

4364 public void MergeFrom(pb::CodedInputStream input) {

4365 uint tag;

4366 while ((tag = input.ReadTag()) != 0) {

4367 switch(tag) {

4368 default:

4369 input.SkipLastField();

4370 break;

4371 case 8: {

4372 FooInt = input.ReadInt32();

4373 break;

4374 }

4375 case 18: {

4376 FooString = input.ReadString();

4377 break;

4378 }

4379 case 26: {

4380 global::Google.Protobuf.TestProtos.TestAllTypes subBuilder = new glo bal::Google.Protobuf.TestProtos.TestAllTypes();

4381 if (fooCase_ == FooOneofCase.FooMessage) {

4382 subBuilder.MergeFrom(FooMessage);

4383 }

4384 input.ReadMessage(subBuilder);

4385 FooMessage = subBuilder;

4386 break;

4387 }

4388 }

4389 }

4390 }

4391

4392 }

4393

4394 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

4395 public sealed partial class TestPackedTypes : pb::IMessage<TestPackedTypes> {

4396 private static readonly pb::MessageParser<TestPackedTypes> _parser = new pb: :MessageParser<TestPackedTypes>(() => new TestPackedTypes());

4397 public static pb::MessageParser<TestPackedTypes> Parser { get { return _pars er; } }

4398

4399 public static pbr::MessageDescriptor Descriptor {

4400 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[23]; }

4401 }

4402

4403 pbr::MessageDescriptor pb::IMessage.Descriptor {

4404 get { return Descriptor; }

4405 }

4406

4407 public TestPackedTypes() {

4408 OnConstruction();

4409 }

4410

4411 partial void OnConstruction();

4412

4413 public TestPackedTypes(TestPackedTypes other) : this() {

4414 packedInt32_ = other.packedInt32_.Clone();

4415 packedInt64_ = other.packedInt64_.Clone();

4416 packedUint32_ = other.packedUint32_.Clone();

4417 packedUint64_ = other.packedUint64_.Clone();

4418 packedSint32_ = other.packedSint32_.Clone();

4419 packedSint64_ = other.packedSint64_.Clone();

4420 packedFixed32_ = other.packedFixed32_.Clone();

4421 packedFixed64_ = other.packedFixed64_.Clone();

4422 packedSfixed32_ = other.packedSfixed32_.Clone();

4423 packedSfixed64_ = other.packedSfixed64_.Clone();

4424 packedFloat_ = other.packedFloat_.Clone();

4425 packedDouble_ = other.packedDouble_.Clone();

4426 packedBool_ = other.packedBool_.Clone();

4427 packedEnum_ = other.packedEnum_.Clone();

4428 }

4429

4430 public TestPackedTypes Clone() {

4431 return new TestPackedTypes(this);

4432 }

4433

4434 public const int PackedInt32FieldNumber = 90;

4435 private static readonly pb::FieldCodec<int> _repeated_packedInt32_codec

4436 = pb::FieldCodec.ForInt32(722);

4437 private readonly pbc::RepeatedField<int> packedInt32_ = new pbc::RepeatedFie ld<int>();

4438 public pbc::RepeatedField<int> PackedInt32 {

4439 get { return packedInt32_; }

4440 }

4441

4442 public const int PackedInt64FieldNumber = 91;

4443 private static readonly pb::FieldCodec<long> _repeated_packedInt64_codec

4444 = pb::FieldCodec.ForInt64(730);

4445 private readonly pbc::RepeatedField<long> packedInt64_ = new pbc::RepeatedFi eld<long>();

4446 public pbc::RepeatedField<long> PackedInt64 {

4447 get { return packedInt64_; }

4448 }

4449

4450 public const int PackedUint32FieldNumber = 92;

4451 private static readonly pb::FieldCodec<uint> _repeated_packedUint32_codec

4452 = pb::FieldCodec.ForUInt32(738);

4453 private readonly pbc::RepeatedField<uint> packedUint32_ = new pbc::RepeatedF ield<uint>();

4454 public pbc::RepeatedField<uint> PackedUint32 {

4455 get { return packedUint32_; }

4456 }

4457

4458 public const int PackedUint64FieldNumber = 93;

4459 private static readonly pb::FieldCodec<ulong> _repeated_packedUint64_codec

4460 = pb::FieldCodec.ForUInt64(746);

4461 private readonly pbc::RepeatedField<ulong> packedUint64_ = new pbc::Repeated Field<ulong>();

4462 public pbc::RepeatedField<ulong> PackedUint64 {

4463 get { return packedUint64_; }

4464 }

4465

4466 public const int PackedSint32FieldNumber = 94;

4467 private static readonly pb::FieldCodec<int> _repeated_packedSint32_codec

4468 = pb::FieldCodec.ForSInt32(754);

4469 private readonly pbc::RepeatedField<int> packedSint32_ = new pbc::RepeatedFi eld<int>();

4470 public pbc::RepeatedField<int> PackedSint32 {

4471 get { return packedSint32_; }

4472 }

4473

4474 public const int PackedSint64FieldNumber = 95;

4475 private static readonly pb::FieldCodec<long> _repeated_packedSint64_codec

4476 = pb::FieldCodec.ForSInt64(762);

4477 private readonly pbc::RepeatedField<long> packedSint64_ = new pbc::RepeatedF ield<long>();

4478 public pbc::RepeatedField<long> PackedSint64 {

4479 get { return packedSint64_; }

4480 }

4481

4482 public const int PackedFixed32FieldNumber = 96;

4483 private static readonly pb::FieldCodec<uint> _repeated_packedFixed32_codec

4484 = pb::FieldCodec.ForFixed32(770);

4485 private readonly pbc::RepeatedField<uint> packedFixed32_ = new pbc::Repeated Field<uint>();

4486 public pbc::RepeatedField<uint> PackedFixed32 {

4487 get { return packedFixed32_; }

4488 }

4489

4490 public const int PackedFixed64FieldNumber = 97;

4491 private static readonly pb::FieldCodec<ulong> _repeated_packedFixed64_codec

4492 = pb::FieldCodec.ForFixed64(778);

4493 private readonly pbc::RepeatedField<ulong> packedFixed64_ = new pbc::Repeate dField<ulong>();

4494 public pbc::RepeatedField<ulong> PackedFixed64 {

4495 get { return packedFixed64_; }

4496 }

4497

4498 public const int PackedSfixed32FieldNumber = 98;

4499 private static readonly pb::FieldCodec<int> _repeated_packedSfixed32_codec

4500 = pb::FieldCodec.ForSFixed32(786);

4501 private readonly pbc::RepeatedField<int> packedSfixed32_ = new pbc::Repeated Field<int>();

4502 public pbc::RepeatedField<int> PackedSfixed32 {

4503 get { return packedSfixed32_; }

4504 }

4505

4506 public const int PackedSfixed64FieldNumber = 99;

4507 private static readonly pb::FieldCodec<long> _repeated_packedSfixed64_codec

4508 = pb::FieldCodec.ForSFixed64(794);

4509 private readonly pbc::RepeatedField<long> packedSfixed64_ = new pbc::Repeate dField<long>();

4510 public pbc::RepeatedField<long> PackedSfixed64 {

4511 get { return packedSfixed64_; }

4512 }

4513

4514 public const int PackedFloatFieldNumber = 100;

4515 private static readonly pb::FieldCodec<float> _repeated_packedFloat_codec

4516 = pb::FieldCodec.ForFloat(802);

4517 private readonly pbc::RepeatedField<float> packedFloat_ = new pbc::RepeatedF ield<float>();

4518 public pbc::RepeatedField<float> PackedFloat {

4519 get { return packedFloat_; }

4520 }

4521

4522 public const int PackedDoubleFieldNumber = 101;

4523 private static readonly pb::FieldCodec<double> _repeated_packedDouble_codec

4524 = pb::FieldCodec.ForDouble(810);

4525 private readonly pbc::RepeatedField<double> packedDouble_ = new pbc::Repeate dField<double>();

4526 public pbc::RepeatedField<double> PackedDouble {

4527 get { return packedDouble_; }

4528 }

4529

4530 public const int PackedBoolFieldNumber = 102;

4531 private static readonly pb::FieldCodec<bool> _repeated_packedBool_codec

4532 = pb::FieldCodec.ForBool(818);

4533 private readonly pbc::RepeatedField<bool> packedBool_ = new pbc::RepeatedFie ld<bool>();

4534 public pbc::RepeatedField<bool> PackedBool {

4535 get { return packedBool_; }

4536 }

4537

4538 public const int PackedEnumFieldNumber = 103;

4539 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Fo reignEnum> _repeated_packedEnum_codec

4540 = pb::FieldCodec.ForEnum(826, x => (int) x, x => (global::Google.Protobu f.TestProtos.ForeignEnum) x);

4541 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Forei gnEnum> packedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProtos. ForeignEnum>();

4542 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> Pa ckedEnum {

4543 get { return packedEnum_; }

4544 }

4545

4546 public override bool Equals(object other) {

4547 return Equals(other as TestPackedTypes);

4548 }

4549

4550 public bool Equals(TestPackedTypes other) {

4551 if (ReferenceEquals(other, null)) {

4552 return false;

4553 }

4554 if (ReferenceEquals(other, this)) {

4555 return true;

4556 }

4557 if(!packedInt32_.Equals(other.packedInt32_)) return false;

4558 if(!packedInt64_.Equals(other.packedInt64_)) return false;

4559 if(!packedUint32_.Equals(other.packedUint32_)) return false;

4560 if(!packedUint64_.Equals(other.packedUint64_)) return false;

4561 if(!packedSint32_.Equals(other.packedSint32_)) return false;

4562 if(!packedSint64_.Equals(other.packedSint64_)) return false;

4563 if(!packedFixed32_.Equals(other.packedFixed32_)) return false;

4564 if(!packedFixed64_.Equals(other.packedFixed64_)) return false;

4565 if(!packedSfixed32_.Equals(other.packedSfixed32_)) return false;

4566 if(!packedSfixed64_.Equals(other.packedSfixed64_)) return false;

4567 if(!packedFloat_.Equals(other.packedFloat_)) return false;

4568 if(!packedDouble_.Equals(other.packedDouble_)) return false;

4569 if(!packedBool_.Equals(other.packedBool_)) return false;

4570 if(!packedEnum_.Equals(other.packedEnum_)) return false;

4571 return true;

4572 }

4573

4574 public override int GetHashCode() {

4575 int hash = 1;

4576 hash ^= packedInt32_.GetHashCode();

4577 hash ^= packedInt64_.GetHashCode();

4578 hash ^= packedUint32_.GetHashCode();

4579 hash ^= packedUint64_.GetHashCode();

4580 hash ^= packedSint32_.GetHashCode();

4581 hash ^= packedSint64_.GetHashCode();

4582 hash ^= packedFixed32_.GetHashCode();

4583 hash ^= packedFixed64_.GetHashCode();

4584 hash ^= packedSfixed32_.GetHashCode();

4585 hash ^= packedSfixed64_.GetHashCode();

4586 hash ^= packedFloat_.GetHashCode();

4587 hash ^= packedDouble_.GetHashCode();

4588 hash ^= packedBool_.GetHashCode();

4589 hash ^= packedEnum_.GetHashCode();

4590 return hash;

4591 }

4592

4593 public override string ToString() {

4594 return pb::JsonFormatter.Default.Format(this);

4595 }

4596

4597 public void WriteTo(pb::CodedOutputStream output) {

4598 packedInt32_.WriteTo(output, _repeated_packedInt32_codec);

4599 packedInt64_.WriteTo(output, _repeated_packedInt64_codec);

4600 packedUint32_.WriteTo(output, _repeated_packedUint32_codec);

4601 packedUint64_.WriteTo(output, _repeated_packedUint64_codec);

4602 packedSint32_.WriteTo(output, _repeated_packedSint32_codec);

4603 packedSint64_.WriteTo(output, _repeated_packedSint64_codec);

4604 packedFixed32_.WriteTo(output, _repeated_packedFixed32_codec);

4605 packedFixed64_.WriteTo(output, _repeated_packedFixed64_codec);

4606 packedSfixed32_.WriteTo(output, _repeated_packedSfixed32_codec);

4607 packedSfixed64_.WriteTo(output, _repeated_packedSfixed64_codec);

4608 packedFloat_.WriteTo(output, _repeated_packedFloat_codec);

4609 packedDouble_.WriteTo(output, _repeated_packedDouble_codec);

4610 packedBool_.WriteTo(output, _repeated_packedBool_codec);

4611 packedEnum_.WriteTo(output, _repeated_packedEnum_codec);

4612 }

4613

4614 public int CalculateSize() {

4615 int size = 0;

4616 size += packedInt32_.CalculateSize(_repeated_packedInt32_codec);

4617 size += packedInt64_.CalculateSize(_repeated_packedInt64_codec);

4618 size += packedUint32_.CalculateSize(_repeated_packedUint32_codec);

4619 size += packedUint64_.CalculateSize(_repeated_packedUint64_codec);

4620 size += packedSint32_.CalculateSize(_repeated_packedSint32_codec);

4621 size += packedSint64_.CalculateSize(_repeated_packedSint64_codec);

4622 size += packedFixed32_.CalculateSize(_repeated_packedFixed32_codec);

4623 size += packedFixed64_.CalculateSize(_repeated_packedFixed64_codec);

4624 size += packedSfixed32_.CalculateSize(_repeated_packedSfixed32_codec);

4625 size += packedSfixed64_.CalculateSize(_repeated_packedSfixed64_codec);

4626 size += packedFloat_.CalculateSize(_repeated_packedFloat_codec);

4627 size += packedDouble_.CalculateSize(_repeated_packedDouble_codec);

4628 size += packedBool_.CalculateSize(_repeated_packedBool_codec);

4629 size += packedEnum_.CalculateSize(_repeated_packedEnum_codec);

4630 return size;

4631 }

4632

4633 public void MergeFrom(TestPackedTypes other) {

4634 if (other == null) {

4635 return;

4636 }

4637 packedInt32_.Add(other.packedInt32_);

4638 packedInt64_.Add(other.packedInt64_);

4639 packedUint32_.Add(other.packedUint32_);

4640 packedUint64_.Add(other.packedUint64_);

4641 packedSint32_.Add(other.packedSint32_);

4642 packedSint64_.Add(other.packedSint64_);

4643 packedFixed32_.Add(other.packedFixed32_);

4644 packedFixed64_.Add(other.packedFixed64_);

4645 packedSfixed32_.Add(other.packedSfixed32_);

4646 packedSfixed64_.Add(other.packedSfixed64_);

4647 packedFloat_.Add(other.packedFloat_);

4648 packedDouble_.Add(other.packedDouble_);

4649 packedBool_.Add(other.packedBool_);

4650 packedEnum_.Add(other.packedEnum_);

4651 }

4652

4653 public void MergeFrom(pb::CodedInputStream input) {

4654 uint tag;

4655 while ((tag = input.ReadTag()) != 0) {

4656 switch(tag) {

4657 default:

4658 input.SkipLastField();

4659 break;

4660 case 722:

4661 case 720: {

4662 packedInt32_.AddEntriesFrom(input, _repeated_packedInt32_codec);

4663 break;

4664 }

4665 case 730:

4666 case 728: {

4667 packedInt64_.AddEntriesFrom(input, _repeated_packedInt64_codec);

4668 break;

4669 }

4670 case 738:

4671 case 736: {

4672 packedUint32_.AddEntriesFrom(input, _repeated_packedUint32_codec);

4673 break;

4674 }

4675 case 746:

4676 case 744: {

4677 packedUint64_.AddEntriesFrom(input, _repeated_packedUint64_codec);

4678 break;

4679 }

4680 case 754:

4681 case 752: {

4682 packedSint32_.AddEntriesFrom(input, _repeated_packedSint32_codec);

4683 break;

4684 }

4685 case 762:

4686 case 760: {

4687 packedSint64_.AddEntriesFrom(input, _repeated_packedSint64_codec);

4688 break;

4689 }

4690 case 770:

4691 case 773: {

4692 packedFixed32_.AddEntriesFrom(input, _repeated_packedFixed32_codec);

4693 break;

4694 }

4695 case 778:

4696 case 777: {

4697 packedFixed64_.AddEntriesFrom(input, _repeated_packedFixed64_codec);

4698 break;

4699 }

4700 case 786:

4701 case 789: {

4702 packedSfixed32_.AddEntriesFrom(input, _repeated_packedSfixed32_codec );

4703 break;

4704 }

4705 case 794:

4706 case 793: {

4707 packedSfixed64_.AddEntriesFrom(input, _repeated_packedSfixed64_codec );

4708 break;

4709 }

4710 case 802:

4711 case 805: {

4712 packedFloat_.AddEntriesFrom(input, _repeated_packedFloat_codec);

4713 break;

4714 }

4715 case 810:

4716 case 809: {

4717 packedDouble_.AddEntriesFrom(input, _repeated_packedDouble_codec);

4718 break;

4719 }

4720 case 818:

4721 case 816: {

4722 packedBool_.AddEntriesFrom(input, _repeated_packedBool_codec);

4723 break;

4724 }

4725 case 826:

4726 case 824: {

4727 packedEnum_.AddEntriesFrom(input, _repeated_packedEnum_codec);

4728 break;

4729 }

4730 }

4731 }

4732 }

4733

4734 }

4735

4736 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

4737 public sealed partial class TestUnpackedTypes : pb::IMessage<TestUnpackedTypes > {

4738 private static readonly pb::MessageParser<TestUnpackedTypes> _parser = new p b::MessageParser<TestUnpackedTypes>(() => new TestUnpackedTypes());

4739 public static pb::MessageParser<TestUnpackedTypes> Parser { get { return _pa rser; } }

4740

4741 public static pbr::MessageDescriptor Descriptor {

4742 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[24]; }

4743 }

4744

4745 pbr::MessageDescriptor pb::IMessage.Descriptor {

4746 get { return Descriptor; }

4747 }

4748

4749 public TestUnpackedTypes() {

4750 OnConstruction();

4751 }

4752

4753 partial void OnConstruction();

4754

4755 public TestUnpackedTypes(TestUnpackedTypes other) : this() {

4756 unpackedInt32_ = other.unpackedInt32_.Clone();

4757 unpackedInt64_ = other.unpackedInt64_.Clone();

4758 unpackedUint32_ = other.unpackedUint32_.Clone();

4759 unpackedUint64_ = other.unpackedUint64_.Clone();

4760 unpackedSint32_ = other.unpackedSint32_.Clone();

4761 unpackedSint64_ = other.unpackedSint64_.Clone();

4762 unpackedFixed32_ = other.unpackedFixed32_.Clone();

4763 unpackedFixed64_ = other.unpackedFixed64_.Clone();

4764 unpackedSfixed32_ = other.unpackedSfixed32_.Clone();

4765 unpackedSfixed64_ = other.unpackedSfixed64_.Clone();

4766 unpackedFloat_ = other.unpackedFloat_.Clone();

4767 unpackedDouble_ = other.unpackedDouble_.Clone();

4768 unpackedBool_ = other.unpackedBool_.Clone();

4769 unpackedEnum_ = other.unpackedEnum_.Clone();

4770 }

4771

4772 public TestUnpackedTypes Clone() {

4773 return new TestUnpackedTypes(this);

4774 }

4775

4776 public const int UnpackedInt32FieldNumber = 90;

4777 private static readonly pb::FieldCodec<int> _repeated_unpackedInt32_codec

4778 = pb::FieldCodec.ForInt32(720);

4779 private readonly pbc::RepeatedField<int> unpackedInt32_ = new pbc::RepeatedF ield<int>();

4780 public pbc::RepeatedField<int> UnpackedInt32 {

4781 get { return unpackedInt32_; }

4782 }

4783

4784 public const int UnpackedInt64FieldNumber = 91;

4785 private static readonly pb::FieldCodec<long> _repeated_unpackedInt64_codec

4786 = pb::FieldCodec.ForInt64(728);

4787 private readonly pbc::RepeatedField<long> unpackedInt64_ = new pbc::Repeated Field<long>();

4788 public pbc::RepeatedField<long> UnpackedInt64 {

4789 get { return unpackedInt64_; }

4790 }

4791

4792 public const int UnpackedUint32FieldNumber = 92;

4793 private static readonly pb::FieldCodec<uint> _repeated_unpackedUint32_codec

4794 = pb::FieldCodec.ForUInt32(736);

4795 private readonly pbc::RepeatedField<uint> unpackedUint32_ = new pbc::Repeate dField<uint>();

4796 public pbc::RepeatedField<uint> UnpackedUint32 {

4797 get { return unpackedUint32_; }

4798 }

4799

4800 public const int UnpackedUint64FieldNumber = 93;

4801 private static readonly pb::FieldCodec<ulong> _repeated_unpackedUint64_codec

4802 = pb::FieldCodec.ForUInt64(744);

4803 private readonly pbc::RepeatedField<ulong> unpackedUint64_ = new pbc::Repeat edField<ulong>();

4804 public pbc::RepeatedField<ulong> UnpackedUint64 {

4805 get { return unpackedUint64_; }

4806 }

4807

4808 public const int UnpackedSint32FieldNumber = 94;

4809 private static readonly pb::FieldCodec<int> _repeated_unpackedSint32_codec

4810 = pb::FieldCodec.ForSInt32(752);

4811 private readonly pbc::RepeatedField<int> unpackedSint32_ = new pbc::Repeated Field<int>();

4812 public pbc::RepeatedField<int> UnpackedSint32 {

4813 get { return unpackedSint32_; }

4814 }

4815

4816 public const int UnpackedSint64FieldNumber = 95;

4817 private static readonly pb::FieldCodec<long> _repeated_unpackedSint64_codec

4818 = pb::FieldCodec.ForSInt64(760);

4819 private readonly pbc::RepeatedField<long> unpackedSint64_ = new pbc::Repeate dField<long>();

4820 public pbc::RepeatedField<long> UnpackedSint64 {

4821 get { return unpackedSint64_; }

4822 }

4823

4824 public const int UnpackedFixed32FieldNumber = 96;

4825 private static readonly pb::FieldCodec<uint> _repeated_unpackedFixed32_codec

4826 = pb::FieldCodec.ForFixed32(773);

4827 private readonly pbc::RepeatedField<uint> unpackedFixed32_ = new pbc::Repeat edField<uint>();

4828 public pbc::RepeatedField<uint> UnpackedFixed32 {

4829 get { return unpackedFixed32_; }

4830 }

4831

4832 public const int UnpackedFixed64FieldNumber = 97;

4833 private static readonly pb::FieldCodec<ulong> _repeated_unpackedFixed64_code c

4834 = pb::FieldCodec.ForFixed64(777);

4835 private readonly pbc::RepeatedField<ulong> unpackedFixed64_ = new pbc::Repea tedField<ulong>();

4836 public pbc::RepeatedField<ulong> UnpackedFixed64 {

4837 get { return unpackedFixed64_; }

4838 }

4839

4840 public const int UnpackedSfixed32FieldNumber = 98;

4841 private static readonly pb::FieldCodec<int> _repeated_unpackedSfixed32_codec

4842 = pb::FieldCodec.ForSFixed32(789);

4843 private readonly pbc::RepeatedField<int> unpackedSfixed32_ = new pbc::Repeat edField<int>();

4844 public pbc::RepeatedField<int> UnpackedSfixed32 {

4845 get { return unpackedSfixed32_; }

4846 }

4847

4848 public const int UnpackedSfixed64FieldNumber = 99;

4849 private static readonly pb::FieldCodec<long> _repeated_unpackedSfixed64_code c

4850 = pb::FieldCodec.ForSFixed64(793);

4851 private readonly pbc::RepeatedField<long> unpackedSfixed64_ = new pbc::Repea tedField<long>();

4852 public pbc::RepeatedField<long> UnpackedSfixed64 {

4853 get { return unpackedSfixed64_; }

4854 }

4855

4856 public const int UnpackedFloatFieldNumber = 100;

4857 private static readonly pb::FieldCodec<float> _repeated_unpackedFloat_codec

4858 = pb::FieldCodec.ForFloat(805);

4859 private readonly pbc::RepeatedField<float> unpackedFloat_ = new pbc::Repeate dField<float>();

4860 public pbc::RepeatedField<float> UnpackedFloat {

4861 get { return unpackedFloat_; }

4862 }

4863

4864 public const int UnpackedDoubleFieldNumber = 101;

4865 private static readonly pb::FieldCodec<double> _repeated_unpackedDouble_code c

4866 = pb::FieldCodec.ForDouble(809);

4867 private readonly pbc::RepeatedField<double> unpackedDouble_ = new pbc::Repea tedField<double>();

4868 public pbc::RepeatedField<double> UnpackedDouble {

4869 get { return unpackedDouble_; }

4870 }

4871

4872 public const int UnpackedBoolFieldNumber = 102;

4873 private static readonly pb::FieldCodec<bool> _repeated_unpackedBool_codec

4874 = pb::FieldCodec.ForBool(816);

4875 private readonly pbc::RepeatedField<bool> unpackedBool_ = new pbc::RepeatedF ield<bool>();

4876 public pbc::RepeatedField<bool> UnpackedBool {

4877 get { return unpackedBool_; }

4878 }

4879

4880 public const int UnpackedEnumFieldNumber = 103;

4881 private static readonly pb::FieldCodec<global::Google.Protobuf.TestProtos.Fo reignEnum> _repeated_unpackedEnum_codec

4882 = pb::FieldCodec.ForEnum(824, x => (int) x, x => (global::Google.Protobu f.TestProtos.ForeignEnum) x);

4883 private readonly pbc::RepeatedField<global::Google.Protobuf.TestProtos.Forei gnEnum> unpackedEnum_ = new pbc::RepeatedField<global::Google.Protobuf.TestProto s.ForeignEnum>();

4884 public pbc::RepeatedField<global::Google.Protobuf.TestProtos.ForeignEnum> Un packedEnum {

4885 get { return unpackedEnum_; }

4886 }

4887

4888 public override bool Equals(object other) {

4889 return Equals(other as TestUnpackedTypes);

4890 }

4891

4892 public bool Equals(TestUnpackedTypes other) {

4893 if (ReferenceEquals(other, null)) {

4894 return false;

4895 }

4896 if (ReferenceEquals(other, this)) {

4897 return true;

4898 }

4899 if(!unpackedInt32_.Equals(other.unpackedInt32_)) return false;

4900 if(!unpackedInt64_.Equals(other.unpackedInt64_)) return false;

4901 if(!unpackedUint32_.Equals(other.unpackedUint32_)) return false;

4902 if(!unpackedUint64_.Equals(other.unpackedUint64_)) return false;

4903 if(!unpackedSint32_.Equals(other.unpackedSint32_)) return false;

4904 if(!unpackedSint64_.Equals(other.unpackedSint64_)) return false;

4905 if(!unpackedFixed32_.Equals(other.unpackedFixed32_)) return false;

4906 if(!unpackedFixed64_.Equals(other.unpackedFixed64_)) return false;

4907 if(!unpackedSfixed32_.Equals(other.unpackedSfixed32_)) return false;

4908 if(!unpackedSfixed64_.Equals(other.unpackedSfixed64_)) return false;

4909 if(!unpackedFloat_.Equals(other.unpackedFloat_)) return false;

4910 if(!unpackedDouble_.Equals(other.unpackedDouble_)) return false;

4911 if(!unpackedBool_.Equals(other.unpackedBool_)) return false;

4912 if(!unpackedEnum_.Equals(other.unpackedEnum_)) return false;

4913 return true;

4914 }

4915

4916 public override int GetHashCode() {

4917 int hash = 1;

4918 hash ^= unpackedInt32_.GetHashCode();

4919 hash ^= unpackedInt64_.GetHashCode();

4920 hash ^= unpackedUint32_.GetHashCode();

4921 hash ^= unpackedUint64_.GetHashCode();

4922 hash ^= unpackedSint32_.GetHashCode();

4923 hash ^= unpackedSint64_.GetHashCode();

4924 hash ^= unpackedFixed32_.GetHashCode();

4925 hash ^= unpackedFixed64_.GetHashCode();

4926 hash ^= unpackedSfixed32_.GetHashCode();

4927 hash ^= unpackedSfixed64_.GetHashCode();

4928 hash ^= unpackedFloat_.GetHashCode();

4929 hash ^= unpackedDouble_.GetHashCode();

4930 hash ^= unpackedBool_.GetHashCode();

4931 hash ^= unpackedEnum_.GetHashCode();

4932 return hash;

4933 }

4934

4935 public override string ToString() {

4936 return pb::JsonFormatter.Default.Format(this);

4937 }

4938

4939 public void WriteTo(pb::CodedOutputStream output) {

4940 unpackedInt32_.WriteTo(output, _repeated_unpackedInt32_codec);

4941 unpackedInt64_.WriteTo(output, _repeated_unpackedInt64_codec);

4942 unpackedUint32_.WriteTo(output, _repeated_unpackedUint32_codec);

4943 unpackedUint64_.WriteTo(output, _repeated_unpackedUint64_codec);

4944 unpackedSint32_.WriteTo(output, _repeated_unpackedSint32_codec);

4945 unpackedSint64_.WriteTo(output, _repeated_unpackedSint64_codec);

4946 unpackedFixed32_.WriteTo(output, _repeated_unpackedFixed32_codec);

4947 unpackedFixed64_.WriteTo(output, _repeated_unpackedFixed64_codec);

4948 unpackedSfixed32_.WriteTo(output, _repeated_unpackedSfixed32_codec);

4949 unpackedSfixed64_.WriteTo(output, _repeated_unpackedSfixed64_codec);

4950 unpackedFloat_.WriteTo(output, _repeated_unpackedFloat_codec);

4951 unpackedDouble_.WriteTo(output, _repeated_unpackedDouble_codec);

4952 unpackedBool_.WriteTo(output, _repeated_unpackedBool_codec);

4953 unpackedEnum_.WriteTo(output, _repeated_unpackedEnum_codec);

4954 }

4955

4956 public int CalculateSize() {

4957 int size = 0;

4958 size += unpackedInt32_.CalculateSize(_repeated_unpackedInt32_codec);

4959 size += unpackedInt64_.CalculateSize(_repeated_unpackedInt64_codec);

4960 size += unpackedUint32_.CalculateSize(_repeated_unpackedUint32_codec);

4961 size += unpackedUint64_.CalculateSize(_repeated_unpackedUint64_codec);

4962 size += unpackedSint32_.CalculateSize(_repeated_unpackedSint32_codec);

4963 size += unpackedSint64_.CalculateSize(_repeated_unpackedSint64_codec);

4964 size += unpackedFixed32_.CalculateSize(_repeated_unpackedFixed32_codec);

4965 size += unpackedFixed64_.CalculateSize(_repeated_unpackedFixed64_codec);

4966 size += unpackedSfixed32_.CalculateSize(_repeated_unpackedSfixed32_codec);

4967 size += unpackedSfixed64_.CalculateSize(_repeated_unpackedSfixed64_codec);

4968 size += unpackedFloat_.CalculateSize(_repeated_unpackedFloat_codec);

4969 size += unpackedDouble_.CalculateSize(_repeated_unpackedDouble_codec);

4970 size += unpackedBool_.CalculateSize(_repeated_unpackedBool_codec);

4971 size += unpackedEnum_.CalculateSize(_repeated_unpackedEnum_codec);

4972 return size;

4973 }

4974

4975 public void MergeFrom(TestUnpackedTypes other) {

4976 if (other == null) {

4977 return;

4978 }

4979 unpackedInt32_.Add(other.unpackedInt32_);

4980 unpackedInt64_.Add(other.unpackedInt64_);

4981 unpackedUint32_.Add(other.unpackedUint32_);

4982 unpackedUint64_.Add(other.unpackedUint64_);

4983 unpackedSint32_.Add(other.unpackedSint32_);

4984 unpackedSint64_.Add(other.unpackedSint64_);

4985 unpackedFixed32_.Add(other.unpackedFixed32_);

4986 unpackedFixed64_.Add(other.unpackedFixed64_);

4987 unpackedSfixed32_.Add(other.unpackedSfixed32_);

4988 unpackedSfixed64_.Add(other.unpackedSfixed64_);

4989 unpackedFloat_.Add(other.unpackedFloat_);

4990 unpackedDouble_.Add(other.unpackedDouble_);

4991 unpackedBool_.Add(other.unpackedBool_);

4992 unpackedEnum_.Add(other.unpackedEnum_);

4993 }

4994

4995 public void MergeFrom(pb::CodedInputStream input) {

4996 uint tag;

4997 while ((tag = input.ReadTag()) != 0) {

4998 switch(tag) {

4999 default:

5000 input.SkipLastField();

5001 break;

5002 case 722:

5003 case 720: {

5004 unpackedInt32_.AddEntriesFrom(input, _repeated_unpackedInt32_codec);

5005 break;

5006 }

5007 case 730:

5008 case 728: {

5009 unpackedInt64_.AddEntriesFrom(input, _repeated_unpackedInt64_codec);

5010 break;

5011 }

5012 case 738:

5013 case 736: {

5014 unpackedUint32_.AddEntriesFrom(input, _repeated_unpackedUint32_codec );

5015 break;

5016 }

5017 case 746:

5018 case 744: {

5019 unpackedUint64_.AddEntriesFrom(input, _repeated_unpackedUint64_codec );

5020 break;

5021 }

5022 case 754:

5023 case 752: {

5024 unpackedSint32_.AddEntriesFrom(input, _repeated_unpackedSint32_codec );

5025 break;

5026 }

5027 case 762:

5028 case 760: {

5029 unpackedSint64_.AddEntriesFrom(input, _repeated_unpackedSint64_codec );

5030 break;

5031 }

5032 case 770:

5033 case 773: {

5034 unpackedFixed32_.AddEntriesFrom(input, _repeated_unpackedFixed32_cod ec);

5035 break;

5036 }

5037 case 778:

5038 case 777: {

5039 unpackedFixed64_.AddEntriesFrom(input, _repeated_unpackedFixed64_cod ec);

5040 break;

5041 }

5042 case 786:

5043 case 789: {

5044 unpackedSfixed32_.AddEntriesFrom(input, _repeated_unpackedSfixed32_c odec);

5045 break;

5046 }

5047 case 794:

5048 case 793: {

5049 unpackedSfixed64_.AddEntriesFrom(input, _repeated_unpackedSfixed64_c odec);

5050 break;

5051 }

5052 case 802:

5053 case 805: {

5054 unpackedFloat_.AddEntriesFrom(input, _repeated_unpackedFloat_codec);

5055 break;

5056 }

5057 case 810:

5058 case 809: {

5059 unpackedDouble_.AddEntriesFrom(input, _repeated_unpackedDouble_codec );

5060 break;

5061 }

5062 case 818:

5063 case 816: {

5064 unpackedBool_.AddEntriesFrom(input, _repeated_unpackedBool_codec);

5065 break;

5066 }

5067 case 826:

5068 case 824: {

5069 unpackedEnum_.AddEntriesFrom(input, _repeated_unpackedEnum_codec);

5070 break;

5071 }

5072 }

5073 }

5074 }

5075

5076 }

5077

5078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

5079 public sealed partial class TestRepeatedScalarDifferentTagSizes : pb::IMessage <TestRepeatedScalarDifferentTagSizes> {

5080 private static readonly pb::MessageParser<TestRepeatedScalarDifferentTagSize s> _parser = new pb::MessageParser<TestRepeatedScalarDifferentTagSizes>(() => ne w TestRepeatedScalarDifferentTagSizes());

5081 public static pb::MessageParser<TestRepeatedScalarDifferentTagSizes> Parser { get { return _parser; } }

5082

5083 public static pbr::MessageDescriptor Descriptor {

5084 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[25]; }

5085 }

5086

5087 pbr::MessageDescriptor pb::IMessage.Descriptor {

5088 get { return Descriptor; }

5089 }

5090

5091 public TestRepeatedScalarDifferentTagSizes() {

5092 OnConstruction();

5093 }

5094

5095 partial void OnConstruction();

5096

5097 public TestRepeatedScalarDifferentTagSizes(TestRepeatedScalarDifferentTagSiz es other) : this() {

5098 repeatedFixed32_ = other.repeatedFixed32_.Clone();

5099 repeatedInt32_ = other.repeatedInt32_.Clone();

5100 repeatedFixed64_ = other.repeatedFixed64_.Clone();

5101 repeatedInt64_ = other.repeatedInt64_.Clone();

5102 repeatedFloat_ = other.repeatedFloat_.Clone();

5103 repeatedUint64_ = other.repeatedUint64_.Clone();

5104 }

5105

5106 public TestRepeatedScalarDifferentTagSizes Clone() {

5107 return new TestRepeatedScalarDifferentTagSizes(this);

5108 }

5109

5110 public const int RepeatedFixed32FieldNumber = 12;

5111 private static readonly pb::FieldCodec<uint> _repeated_repeatedFixed32_codec

5112 = pb::FieldCodec.ForFixed32(98);

5113 private readonly pbc::RepeatedField<uint> repeatedFixed32_ = new pbc::Repeat edField<uint>();

5114 public pbc::RepeatedField<uint> RepeatedFixed32 {

5115 get { return repeatedFixed32_; }

5116 }

5117

5118 public const int RepeatedInt32FieldNumber = 13;

5119 private static readonly pb::FieldCodec<int> _repeated_repeatedInt32_codec

5120 = pb::FieldCodec.ForInt32(106);

5121 private readonly pbc::RepeatedField<int> repeatedInt32_ = new pbc::RepeatedF ield<int>();

5122 public pbc::RepeatedField<int> RepeatedInt32 {

5123 get { return repeatedInt32_; }

5124 }

5125

5126 public const int RepeatedFixed64FieldNumber = 2046;

5127 private static readonly pb::FieldCodec<ulong> _repeated_repeatedFixed64_code c

5128 = pb::FieldCodec.ForFixed64(16370);

5129 private readonly pbc::RepeatedField<ulong> repeatedFixed64_ = new pbc::Repea tedField<ulong>();

5130 public pbc::RepeatedField<ulong> RepeatedFixed64 {

5131 get { return repeatedFixed64_; }

5132 }

5133

5134 public const int RepeatedInt64FieldNumber = 2047;

5135 private static readonly pb::FieldCodec<long> _repeated_repeatedInt64_codec

5136 = pb::FieldCodec.ForInt64(16378);

5137 private readonly pbc::RepeatedField<long> repeatedInt64_ = new pbc::Repeated Field<long>();

5138 public pbc::RepeatedField<long> RepeatedInt64 {

5139 get { return repeatedInt64_; }

5140 }

5141

5142 public const int RepeatedFloatFieldNumber = 262142;

5143 private static readonly pb::FieldCodec<float> _repeated_repeatedFloat_codec

5144 = pb::FieldCodec.ForFloat(2097138);

5145 private readonly pbc::RepeatedField<float> repeatedFloat_ = new pbc::Repeate dField<float>();

5146 public pbc::RepeatedField<float> RepeatedFloat {

5147 get { return repeatedFloat_; }

5148 }

5149

5150 public const int RepeatedUint64FieldNumber = 262143;

5151 private static readonly pb::FieldCodec<ulong> _repeated_repeatedUint64_codec

5152 = pb::FieldCodec.ForUInt64(2097146);

5153 private readonly pbc::RepeatedField<ulong> repeatedUint64_ = new pbc::Repeat edField<ulong>();

5154 public pbc::RepeatedField<ulong> RepeatedUint64 {

5155 get { return repeatedUint64_; }

5156 }

5157

5158 public override bool Equals(object other) {

5159 return Equals(other as TestRepeatedScalarDifferentTagSizes);

5160 }

5161

5162 public bool Equals(TestRepeatedScalarDifferentTagSizes other) {

5163 if (ReferenceEquals(other, null)) {

5164 return false;

5165 }

5166 if (ReferenceEquals(other, this)) {

5167 return true;

5168 }

5169 if(!repeatedFixed32_.Equals(other.repeatedFixed32_)) return false;

5170 if(!repeatedInt32_.Equals(other.repeatedInt32_)) return false;

5171 if(!repeatedFixed64_.Equals(other.repeatedFixed64_)) return false;

5172 if(!repeatedInt64_.Equals(other.repeatedInt64_)) return false;

5173 if(!repeatedFloat_.Equals(other.repeatedFloat_)) return false;

5174 if(!repeatedUint64_.Equals(other.repeatedUint64_)) return false;

5175 return true;

5176 }

5177

5178 public override int GetHashCode() {

5179 int hash = 1;

5180 hash ^= repeatedFixed32_.GetHashCode();

5181 hash ^= repeatedInt32_.GetHashCode();

5182 hash ^= repeatedFixed64_.GetHashCode();

5183 hash ^= repeatedInt64_.GetHashCode();

5184 hash ^= repeatedFloat_.GetHashCode();

5185 hash ^= repeatedUint64_.GetHashCode();

5186 return hash;

5187 }

5188

5189 public override string ToString() {

5190 return pb::JsonFormatter.Default.Format(this);

5191 }

5192

5193 public void WriteTo(pb::CodedOutputStream output) {

5194 repeatedFixed32_.WriteTo(output, _repeated_repeatedFixed32_codec);

5195 repeatedInt32_.WriteTo(output, _repeated_repeatedInt32_codec);

5196 repeatedFixed64_.WriteTo(output, _repeated_repeatedFixed64_codec);

5197 repeatedInt64_.WriteTo(output, _repeated_repeatedInt64_codec);

5198 repeatedFloat_.WriteTo(output, _repeated_repeatedFloat_codec);

5199 repeatedUint64_.WriteTo(output, _repeated_repeatedUint64_codec);

5200 }

5201

5202 public int CalculateSize() {

5203 int size = 0;

5204 size += repeatedFixed32_.CalculateSize(_repeated_repeatedFixed32_codec);

5205 size += repeatedInt32_.CalculateSize(_repeated_repeatedInt32_codec);

5206 size += repeatedFixed64_.CalculateSize(_repeated_repeatedFixed64_codec);

5207 size += repeatedInt64_.CalculateSize(_repeated_repeatedInt64_codec);

5208 size += repeatedFloat_.CalculateSize(_repeated_repeatedFloat_codec);

5209 size += repeatedUint64_.CalculateSize(_repeated_repeatedUint64_codec);

5210 return size;

5211 }

5212

5213 public void MergeFrom(TestRepeatedScalarDifferentTagSizes other) {

5214 if (other == null) {

5215 return;

5216 }

5217 repeatedFixed32_.Add(other.repeatedFixed32_);

5218 repeatedInt32_.Add(other.repeatedInt32_);

5219 repeatedFixed64_.Add(other.repeatedFixed64_);

5220 repeatedInt64_.Add(other.repeatedInt64_);

5221 repeatedFloat_.Add(other.repeatedFloat_);

5222 repeatedUint64_.Add(other.repeatedUint64_);

5223 }

5224

5225 public void MergeFrom(pb::CodedInputStream input) {

5226 uint tag;

5227 while ((tag = input.ReadTag()) != 0) {

5228 switch(tag) {

5229 default:

5230 input.SkipLastField();

5231 break;

5232 case 98:

5233 case 101: {

5234 repeatedFixed32_.AddEntriesFrom(input, _repeated_repeatedFixed32_cod ec);

5235 break;

5236 }

5237 case 106:

5238 case 104: {

5239 repeatedInt32_.AddEntriesFrom(input, _repeated_repeatedInt32_codec);

5240 break;

5241 }

5242 case 16370:

5243 case 16369: {

5244 repeatedFixed64_.AddEntriesFrom(input, _repeated_repeatedFixed64_cod ec);

5245 break;

5246 }

5247 case 16378:

5248 case 16376: {

5249 repeatedInt64_.AddEntriesFrom(input, _repeated_repeatedInt64_codec);

5250 break;

5251 }

5252 case 2097138:

5253 case 2097141: {

5254 repeatedFloat_.AddEntriesFrom(input, _repeated_repeatedFloat_codec);

5255 break;

5256 }

5257 case 2097146:

5258 case 2097144: {

5259 repeatedUint64_.AddEntriesFrom(input, _repeated_repeatedUint64_codec );

5260 break;

5261 }

5262 }

5263 }

5264 }

5265

5266 }

5267

5268 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

5269 public sealed partial class TestCommentInjectionMessage : pb::IMessage<TestCom mentInjectionMessage> {

5270 private static readonly pb::MessageParser<TestCommentInjectionMessage> _pars er = new pb::MessageParser<TestCommentInjectionMessage>(() => new TestCommentInj ectionMessage());

5271 public static pb::MessageParser<TestCommentInjectionMessage> Parser { get { return _parser; } }

5272

5273 public static pbr::MessageDescriptor Descriptor {

5274 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[26]; }

5275 }

5276

5277 pbr::MessageDescriptor pb::IMessage.Descriptor {

5278 get { return Descriptor; }

5279 }

5280

5281 public TestCommentInjectionMessage() {

5282 OnConstruction();

5283 }

5284

5285 partial void OnConstruction();

5286

5287 public TestCommentInjectionMessage(TestCommentInjectionMessage other) : this () {

5288 a_ = other.a_;

5289 }

5290

5291 public TestCommentInjectionMessage Clone() {

5292 return new TestCommentInjectionMessage(this);

5293 }

5294

5295 public const int AFieldNumber = 1;

5296 private string a_ = "";

5297 public string A {

5298 get { return a_; }

5299 set {

5300 a_ = pb::Preconditions.CheckNotNull(value, "value");

5301 }

5302 }

5303

5304 public override bool Equals(object other) {

5305 return Equals(other as TestCommentInjectionMessage);

5306 }

5307

5308 public bool Equals(TestCommentInjectionMessage other) {

5309 if (ReferenceEquals(other, null)) {

5310 return false;

5311 }

5312 if (ReferenceEquals(other, this)) {

5313 return true;

5314 }

5315 if (A != other.A) return false;

5316 return true;

5317 }

5318

5319 public override int GetHashCode() {

5320 int hash = 1;

5321 if (A.Length != 0) hash ^= A.GetHashCode();

5322 return hash;

5323 }

5324

5325 public override string ToString() {

5326 return pb::JsonFormatter.Default.Format(this);

5327 }

5328

5329 public void WriteTo(pb::CodedOutputStream output) {

5330 if (A.Length != 0) {

5331 output.WriteRawTag(10);

5332 output.WriteString(A);

5333 }

5334 }

5335

5336 public int CalculateSize() {

5337 int size = 0;

5338 if (A.Length != 0) {

5339 size += 1 + pb::CodedOutputStream.ComputeStringSize(A);

5340 }

5341 return size;

5342 }

5343

5344 public void MergeFrom(TestCommentInjectionMessage other) {

5345 if (other == null) {

5346 return;

5347 }

5348 if (other.A.Length != 0) {

5349 A = other.A;

5350 }

5351 }

5352

5353 public void MergeFrom(pb::CodedInputStream input) {

5354 uint tag;

5355 while ((tag = input.ReadTag()) != 0) {

5356 switch(tag) {

5357 default:

5358 input.SkipLastField();

5359 break;

5360 case 10: {

5361 A = input.ReadString();

5362 break;

5363 }

5364 }

5365 }

5366 }

5367

5368 }

5369

5370 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

5371 public sealed partial class FooRequest : pb::IMessage<FooRequest> {

5372 private static readonly pb::MessageParser<FooRequest> _parser = new pb::Mess ageParser<FooRequest>(() => new FooRequest());

5373 public static pb::MessageParser<FooRequest> Parser { get { return _parser; } }

5374

5375 public static pbr::MessageDescriptor Descriptor {

5376 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[27]; }

5377 }

5378

5379 pbr::MessageDescriptor pb::IMessage.Descriptor {

5380 get { return Descriptor; }

5381 }

5382

5383 public FooRequest() {

5384 OnConstruction();

5385 }

5386

5387 partial void OnConstruction();

5388

5389 public FooRequest(FooRequest other) : this() {

5390 }

5391

5392 public FooRequest Clone() {

5393 return new FooRequest(this);

5394 }

5395

5396 public override bool Equals(object other) {

5397 return Equals(other as FooRequest);

5398 }

5399

5400 public bool Equals(FooRequest other) {

5401 if (ReferenceEquals(other, null)) {

5402 return false;

5403 }

5404 if (ReferenceEquals(other, this)) {

5405 return true;

5406 }

5407 return true;

5408 }

5409

5410 public override int GetHashCode() {

5411 int hash = 1;

5412 return hash;

5413 }

5414

5415 public override string ToString() {

5416 return pb::JsonFormatter.Default.Format(this);

5417 }

5418

5419 public void WriteTo(pb::CodedOutputStream output) {

5420 }

5421

5422 public int CalculateSize() {

5423 int size = 0;

5424 return size;

5425 }

5426

5427 public void MergeFrom(FooRequest other) {

5428 if (other == null) {

5429 return;

5430 }

5431 }

5432

5433 public void MergeFrom(pb::CodedInputStream input) {

5434 uint tag;

5435 while ((tag = input.ReadTag()) != 0) {

5436 switch(tag) {

5437 default:

5438 input.SkipLastField();

5439 break;

5440 }

5441 }

5442 }

5443

5444 }

5445

5446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

5447 public sealed partial class FooResponse : pb::IMessage<FooResponse> {

5448 private static readonly pb::MessageParser<FooResponse> _parser = new pb::Mes sageParser<FooResponse>(() => new FooResponse());

5449 public static pb::MessageParser<FooResponse> Parser { get { return _parser; } }

5450

5451 public static pbr::MessageDescriptor Descriptor {

5452 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[28]; }

5453 }

5454

5455 pbr::MessageDescriptor pb::IMessage.Descriptor {

5456 get { return Descriptor; }

5457 }

5458

5459 public FooResponse() {

5460 OnConstruction();

5461 }

5462

5463 partial void OnConstruction();

5464

5465 public FooResponse(FooResponse other) : this() {

5466 }

5467

5468 public FooResponse Clone() {

5469 return new FooResponse(this);

5470 }

5471

5472 public override bool Equals(object other) {

5473 return Equals(other as FooResponse);

5474 }

5475

5476 public bool Equals(FooResponse other) {

5477 if (ReferenceEquals(other, null)) {

5478 return false;

5479 }

5480 if (ReferenceEquals(other, this)) {

5481 return true;

5482 }

5483 return true;

5484 }

5485

5486 public override int GetHashCode() {

5487 int hash = 1;

5488 return hash;

5489 }

5490

5491 public override string ToString() {

5492 return pb::JsonFormatter.Default.Format(this);

5493 }

5494

5495 public void WriteTo(pb::CodedOutputStream output) {

5496 }

5497

5498 public int CalculateSize() {

5499 int size = 0;

5500 return size;

5501 }

5502

5503 public void MergeFrom(FooResponse other) {

5504 if (other == null) {

5505 return;

5506 }

5507 }

5508

5509 public void MergeFrom(pb::CodedInputStream input) {

5510 uint tag;

5511 while ((tag = input.ReadTag()) != 0) {

5512 switch(tag) {

5513 default:

5514 input.SkipLastField();

5515 break;

5516 }

5517 }

5518 }

5519

5520 }

5521

5522 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

5523 public sealed partial class FooClientMessage : pb::IMessage<FooClientMessage> {

5524 private static readonly pb::MessageParser<FooClientMessage> _parser = new pb ::MessageParser<FooClientMessage>(() => new FooClientMessage());

5525 public static pb::MessageParser<FooClientMessage> Parser { get { return _par ser; } }

5526

5527 public static pbr::MessageDescriptor Descriptor {

5528 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[29]; }

5529 }

5530

5531 pbr::MessageDescriptor pb::IMessage.Descriptor {

5532 get { return Descriptor; }

5533 }

5534

5535 public FooClientMessage() {

5536 OnConstruction();

5537 }

5538

5539 partial void OnConstruction();

5540

5541 public FooClientMessage(FooClientMessage other) : this() {

5542 }

5543

5544 public FooClientMessage Clone() {

5545 return new FooClientMessage(this);

5546 }

5547

5548 public override bool Equals(object other) {

5549 return Equals(other as FooClientMessage);

5550 }

5551

5552 public bool Equals(FooClientMessage other) {

5553 if (ReferenceEquals(other, null)) {

5554 return false;

5555 }

5556 if (ReferenceEquals(other, this)) {

5557 return true;

5558 }

5559 return true;

5560 }

5561

5562 public override int GetHashCode() {

5563 int hash = 1;

5564 return hash;

5565 }

5566

5567 public override string ToString() {

5568 return pb::JsonFormatter.Default.Format(this);

5569 }

5570

5571 public void WriteTo(pb::CodedOutputStream output) {

5572 }

5573

5574 public int CalculateSize() {

5575 int size = 0;

5576 return size;

5577 }

5578

5579 public void MergeFrom(FooClientMessage other) {

5580 if (other == null) {

5581 return;

5582 }

5583 }

5584

5585 public void MergeFrom(pb::CodedInputStream input) {

5586 uint tag;

5587 while ((tag = input.ReadTag()) != 0) {

5588 switch(tag) {

5589 default:

5590 input.SkipLastField();

5591 break;

5592 }

5593 }

5594 }

5595

5596 }

5597

5598 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

5599 public sealed partial class FooServerMessage : pb::IMessage<FooServerMessage> {

5600 private static readonly pb::MessageParser<FooServerMessage> _parser = new pb ::MessageParser<FooServerMessage>(() => new FooServerMessage());

5601 public static pb::MessageParser<FooServerMessage> Parser { get { return _par ser; } }

5602

5603 public static pbr::MessageDescriptor Descriptor {

5604 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[30]; }

5605 }

5606

5607 pbr::MessageDescriptor pb::IMessage.Descriptor {

5608 get { return Descriptor; }

5609 }

5610

5611 public FooServerMessage() {

5612 OnConstruction();

5613 }

5614

5615 partial void OnConstruction();

5616

5617 public FooServerMessage(FooServerMessage other) : this() {

5618 }

5619

5620 public FooServerMessage Clone() {

5621 return new FooServerMessage(this);

5622 }

5623

5624 public override bool Equals(object other) {

5625 return Equals(other as FooServerMessage);

5626 }

5627

5628 public bool Equals(FooServerMessage other) {

5629 if (ReferenceEquals(other, null)) {

5630 return false;

5631 }

5632 if (ReferenceEquals(other, this)) {

5633 return true;

5634 }

5635 return true;

5636 }

5637

5638 public override int GetHashCode() {

5639 int hash = 1;

5640 return hash;

5641 }

5642

5643 public override string ToString() {

5644 return pb::JsonFormatter.Default.Format(this);

5645 }

5646

5647 public void WriteTo(pb::CodedOutputStream output) {

5648 }

5649

5650 public int CalculateSize() {

5651 int size = 0;

5652 return size;

5653 }

5654

5655 public void MergeFrom(FooServerMessage other) {

5656 if (other == null) {

5657 return;

5658 }

5659 }

5660

5661 public void MergeFrom(pb::CodedInputStream input) {

5662 uint tag;

5663 while ((tag = input.ReadTag()) != 0) {

5664 switch(tag) {

5665 default:

5666 input.SkipLastField();

5667 break;

5668 }

5669 }

5670 }

5671

5672 }

5673

5674 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

5675 public sealed partial class BarRequest : pb::IMessage<BarRequest> {

5676 private static readonly pb::MessageParser<BarRequest> _parser = new pb::Mess ageParser<BarRequest>(() => new BarRequest());

5677 public static pb::MessageParser<BarRequest> Parser { get { return _parser; } }

5678

5679 public static pbr::MessageDescriptor Descriptor {

5680 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[31]; }

5681 }

5682

5683 pbr::MessageDescriptor pb::IMessage.Descriptor {

5684 get { return Descriptor; }

5685 }

5686

5687 public BarRequest() {

5688 OnConstruction();

5689 }

5690

5691 partial void OnConstruction();

5692

5693 public BarRequest(BarRequest other) : this() {

5694 }

5695

5696 public BarRequest Clone() {

5697 return new BarRequest(this);

5698 }

5699

5700 public override bool Equals(object other) {

5701 return Equals(other as BarRequest);

5702 }

5703

5704 public bool Equals(BarRequest other) {

5705 if (ReferenceEquals(other, null)) {

5706 return false;

5707 }

5708 if (ReferenceEquals(other, this)) {

5709 return true;

5710 }

5711 return true;

5712 }

5713

5714 public override int GetHashCode() {

5715 int hash = 1;

5716 return hash;

5717 }

5718

5719 public override string ToString() {

5720 return pb::JsonFormatter.Default.Format(this);

5721 }

5722

5723 public void WriteTo(pb::CodedOutputStream output) {

5724 }

5725

5726 public int CalculateSize() {

5727 int size = 0;

5728 return size;

5729 }

5730

5731 public void MergeFrom(BarRequest other) {

5732 if (other == null) {

5733 return;

5734 }

5735 }

5736

5737 public void MergeFrom(pb::CodedInputStream input) {

5738 uint tag;

5739 while ((tag = input.ReadTag()) != 0) {

5740 switch(tag) {

5741 default:

5742 input.SkipLastField();

5743 break;

5744 }

5745 }

5746 }

5747

5748 }

5749

5750 [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]

5751 public sealed partial class BarResponse : pb::IMessage<BarResponse> {

5752 private static readonly pb::MessageParser<BarResponse> _parser = new pb::Mes sageParser<BarResponse>(() => new BarResponse());

5753 public static pb::MessageParser<BarResponse> Parser { get { return _parser; } }

5754

5755 public static pbr::MessageDescriptor Descriptor {

5756 get { return global::Google.Protobuf.TestProtos.UnittestProto3.Descriptor. MessageTypes[32]; }

5757 }

5758

5759 pbr::MessageDescriptor pb::IMessage.Descriptor {

5760 get { return Descriptor; }

5761 }

5762

5763 public BarResponse() {

5764 OnConstruction();

5765 }

5766

5767 partial void OnConstruction();

5768

5769 public BarResponse(BarResponse other) : this() {

5770 }

5771

5772 public BarResponse Clone() {

5773 return new BarResponse(this);

5774 }

5775

5776 public override bool Equals(object other) {

5777 return Equals(other as BarResponse);

5778 }

5779

5780 public bool Equals(BarResponse other) {

5781 if (ReferenceEquals(other, null)) {

5782 return false;

5783 }

5784 if (ReferenceEquals(other, this)) {

5785 return true;

5786 }

5787 return true;

5788 }

5789

5790 public override int GetHashCode() {

5791 int hash = 1;

5792 return hash;

5793 }

5794

5795 public override string ToString() {

5796 return pb::JsonFormatter.Default.Format(this);

5797 }

5798

5799 public void WriteTo(pb::CodedOutputStream output) {

5800 }

5801

5802 public int CalculateSize() {

5803 int size = 0;

5804 return size;

5805 }

5806

5807 public void MergeFrom(BarResponse other) {

5808 if (other == null) {

5809 return;

5810 }

5811 }

5812

5813 public void MergeFrom(pb::CodedInputStream input) {

5814 uint tag;

5815 while ((tag = input.ReadTag()) != 0) {

5816 switch(tag) {

5817 default:

5818 input.SkipLastField();

5819 break;

5820 }

5821 }

5822 }

5823

5824 }

5825

5826 #endregion

5827

5828 }

5829

5830 #endregion Designer generated code

OLD	NEW