From 29d5186867cef4cce9b434a63698288daa8bb7db Mon Sep 17 00:00:00 2001 From: Sydney Acksman Date: Tue, 2 Jul 2019 17:46:01 -0500 Subject: [PATCH] Regenerate testprotos.pb --- .../TestProtos/TestMessagesProto2.cs | 855 +++++++++++++++--- csharp/src/Google.Protobuf.Test/testprotos.pb | Bin 204502 -> 326118 bytes 2 files changed, 735 insertions(+), 120 deletions(-) diff --git a/csharp/src/Google.Protobuf.Test/TestProtos/TestMessagesProto2.cs b/csharp/src/Google.Protobuf.Test/TestProtos/TestMessagesProto2.cs index 04e1dc41ad..ac6ba48f8e 100644 --- a/csharp/src/Google.Protobuf.Test/TestProtos/TestMessagesProto2.cs +++ b/csharp/src/Google.Protobuf.Test/TestProtos/TestMessagesProto2.cs @@ -25,7 +25,7 @@ namespace ProtobufTestMessages.Proto2 { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "Cipnb29nbGUvcHJvdG9idWYvdGVzdF9tZXNzYWdlc19wcm90bzIucHJvdG8S", - "HXByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yIuYyChJUZXN0QWxsVHlw", + "HXByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yIv45ChJUZXN0QWxsVHlw", "ZXNQcm90bzISFgoOb3B0aW9uYWxfaW50MzIYASABKAUSFgoOb3B0aW9uYWxf", "aW50NjQYAiABKAMSFwoPb3B0aW9uYWxfdWludDMyGAMgASgNEhcKD29wdGlv", "bmFsX3VpbnQ2NBgEIAEoBBIXCg9vcHRpb25hbF9zaW50MzIYBSABKBESFwoP", @@ -63,130 +63,151 @@ namespace ProtobufTestMessages.Proto2 { "bnVtEk8KFXJlcGVhdGVkX2ZvcmVpZ25fZW51bRg0IAMoDjIwLnByb3RvYnVm", "X3Rlc3RfbWVzc2FnZXMucHJvdG8yLkZvcmVpZ25FbnVtUHJvdG8yEiEKFXJl", "cGVhdGVkX3N0cmluZ19waWVjZRg2IAMoCUICCAISGQoNcmVwZWF0ZWRfY29y", - "ZBg3IAMoCUICCAESXQoPbWFwX2ludDMyX2ludDMyGDggAygLMkQucHJvdG9i", - "dWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1h", - "cEludDMySW50MzJFbnRyeRJdCg9tYXBfaW50NjRfaW50NjQYOSADKAsyRC5w", - "cm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90", - "bzIuTWFwSW50NjRJbnQ2NEVudHJ5EmEKEW1hcF91aW50MzJfdWludDMyGDog", - "AygLMkYucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5", - "cGVzUHJvdG8yLk1hcFVpbnQzMlVpbnQzMkVudHJ5EmEKEW1hcF91aW50NjRf", - "dWludDY0GDsgAygLMkYucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIu", - "VGVzdEFsbFR5cGVzUHJvdG8yLk1hcFVpbnQ2NFVpbnQ2NEVudHJ5EmEKEW1h", - "cF9zaW50MzJfc2ludDMyGDwgAygLMkYucHJvdG9idWZfdGVzdF9tZXNzYWdl", - "cy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1hcFNpbnQzMlNpbnQzMkVu", - "dHJ5EmEKEW1hcF9zaW50NjRfc2ludDY0GD0gAygLMkYucHJvdG9idWZfdGVz", - "dF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1hcFNpbnQ2", - "NFNpbnQ2NEVudHJ5EmUKE21hcF9maXhlZDMyX2ZpeGVkMzIYPiADKAsySC5w", - "cm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90", - "bzIuTWFwRml4ZWQzMkZpeGVkMzJFbnRyeRJlChNtYXBfZml4ZWQ2NF9maXhl", - "ZDY0GD8gAygLMkgucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVz", - "dEFsbFR5cGVzUHJvdG8yLk1hcEZpeGVkNjRGaXhlZDY0RW50cnkSaQoVbWFw", - "X3NmaXhlZDMyX3NmaXhlZDMyGEAgAygLMkoucHJvdG9idWZfdGVzdF9tZXNz", - "YWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1hcFNmaXhlZDMyU2Zp", - "eGVkMzJFbnRyeRJpChVtYXBfc2ZpeGVkNjRfc2ZpeGVkNjQYQSADKAsySi5w", + "ZBg3IAMoCUICCAESGAoMcGFja2VkX2ludDMyGEsgAygFQgIQARIYCgxwYWNr", + "ZWRfaW50NjQYTCADKANCAhABEhkKDXBhY2tlZF91aW50MzIYTSADKA1CAhAB", + "EhkKDXBhY2tlZF91aW50NjQYTiADKARCAhABEhkKDXBhY2tlZF9zaW50MzIY", + "TyADKBFCAhABEhkKDXBhY2tlZF9zaW50NjQYUCADKBJCAhABEhoKDnBhY2tl", + "ZF9maXhlZDMyGFEgAygHQgIQARIaCg5wYWNrZWRfZml4ZWQ2NBhSIAMoBkIC", + "EAESGwoPcGFja2VkX3NmaXhlZDMyGFMgAygPQgIQARIbCg9wYWNrZWRfc2Zp", + "eGVkNjQYVCADKBBCAhABEhgKDHBhY2tlZF9mbG9hdBhVIAMoAkICEAESGQoN", + "cGFja2VkX2RvdWJsZRhWIAMoAUICEAESFwoLcGFja2VkX2Jvb2wYVyADKAhC", + "AhABElwKEnBhY2tlZF9uZXN0ZWRfZW51bRhYIAMoDjI8LnByb3RvYnVmX3Rl", + "c3RfbWVzc2FnZXMucHJvdG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5OZXN0ZWRF", + "bnVtQgIQARIaCg51bnBhY2tlZF9pbnQzMhhZIAMoBUICEAASGgoOdW5wYWNr", + "ZWRfaW50NjQYWiADKANCAhAAEhsKD3VucGFja2VkX3VpbnQzMhhbIAMoDUIC", + "EAASGwoPdW5wYWNrZWRfdWludDY0GFwgAygEQgIQABIbCg91bnBhY2tlZF9z", + "aW50MzIYXSADKBFCAhAAEhsKD3VucGFja2VkX3NpbnQ2NBheIAMoEkICEAAS", + "HAoQdW5wYWNrZWRfZml4ZWQzMhhfIAMoB0ICEAASHAoQdW5wYWNrZWRfZml4", + "ZWQ2NBhgIAMoBkICEAASHQoRdW5wYWNrZWRfc2ZpeGVkMzIYYSADKA9CAhAA", + "Eh0KEXVucGFja2VkX3NmaXhlZDY0GGIgAygQQgIQABIaCg51bnBhY2tlZF9m", + "bG9hdBhjIAMoAkICEAASGwoPdW5wYWNrZWRfZG91YmxlGGQgAygBQgIQABIZ", + "Cg11bnBhY2tlZF9ib29sGGUgAygIQgIQABJeChR1bnBhY2tlZF9uZXN0ZWRf", + "ZW51bRhmIAMoDjI8LnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRl", + "c3RBbGxUeXBlc1Byb3RvMi5OZXN0ZWRFbnVtQgIQABJdCg9tYXBfaW50MzJf", + "aW50MzIYOCADKAsyRC5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5U", + "ZXN0QWxsVHlwZXNQcm90bzIuTWFwSW50MzJJbnQzMkVudHJ5El0KD21hcF9p", + "bnQ2NF9pbnQ2NBg5IAMoCzJELnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJv", + "dG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5NYXBJbnQ2NEludDY0RW50cnkSYQoR", + "bWFwX3VpbnQzMl91aW50MzIYOiADKAsyRi5wcm90b2J1Zl90ZXN0X21lc3Nh", + "Z2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90bzIuTWFwVWludDMyVWludDMy", + "RW50cnkSYQoRbWFwX3VpbnQ2NF91aW50NjQYOyADKAsyRi5wcm90b2J1Zl90", + "ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90bzIuTWFwVWlu", + "dDY0VWludDY0RW50cnkSYQoRbWFwX3NpbnQzMl9zaW50MzIYPCADKAsyRi5w", "cm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90", - "bzIuTWFwU2ZpeGVkNjRTZml4ZWQ2NEVudHJ5El0KD21hcF9pbnQzMl9mbG9h", - "dBhCIAMoCzJELnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRlc3RB", - "bGxUeXBlc1Byb3RvMi5NYXBJbnQzMkZsb2F0RW50cnkSXwoQbWFwX2ludDMy", - "X2RvdWJsZRhDIAMoCzJFLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8y", - "LlRlc3RBbGxUeXBlc1Byb3RvMi5NYXBJbnQzMkRvdWJsZUVudHJ5ElkKDW1h", - "cF9ib29sX2Jvb2wYRCADKAsyQi5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnBy", - "b3RvMi5UZXN0QWxsVHlwZXNQcm90bzIuTWFwQm9vbEJvb2xFbnRyeRJhChFt", - "YXBfc3RyaW5nX3N0cmluZxhFIAMoCzJGLnByb3RvYnVmX3Rlc3RfbWVzc2Fn", - "ZXMucHJvdG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5NYXBTdHJpbmdTdHJpbmdF", - "bnRyeRJfChBtYXBfc3RyaW5nX2J5dGVzGEYgAygLMkUucHJvdG9idWZfdGVz", - "dF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1hcFN0cmlu", - "Z0J5dGVzRW50cnkScAoZbWFwX3N0cmluZ19uZXN0ZWRfbWVzc2FnZRhHIAMo", - "CzJNLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRlc3RBbGxUeXBl", - "c1Byb3RvMi5NYXBTdHJpbmdOZXN0ZWRNZXNzYWdlRW50cnkScgoabWFwX3N0", - "cmluZ19mb3JlaWduX21lc3NhZ2UYSCADKAsyTi5wcm90b2J1Zl90ZXN0X21l", - "c3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90bzIuTWFwU3RyaW5nRm9y", - "ZWlnbk1lc3NhZ2VFbnRyeRJqChZtYXBfc3RyaW5nX25lc3RlZF9lbnVtGEkg", - "AygLMkoucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5", - "cGVzUHJvdG8yLk1hcFN0cmluZ05lc3RlZEVudW1FbnRyeRJsChdtYXBfc3Ry", - "aW5nX2ZvcmVpZ25fZW51bRhKIAMoCzJLLnByb3RvYnVmX3Rlc3RfbWVzc2Fn", - "ZXMucHJvdG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5NYXBTdHJpbmdGb3JlaWdu", - "RW51bUVudHJ5EhYKDG9uZW9mX3VpbnQzMhhvIAEoDUgAEl8KFG9uZW9mX25l", - "c3RlZF9tZXNzYWdlGHAgASgLMj8ucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5w", - "cm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk5lc3RlZE1lc3NhZ2VIABIWCgxv", - "bmVvZl9zdHJpbmcYcSABKAlIABIVCgtvbmVvZl9ieXRlcxhyIAEoDEgAEhQK", - "Cm9uZW9mX2Jvb2wYcyABKAhIABIWCgxvbmVvZl91aW50NjQYdCABKARIABIV", - "CgtvbmVvZl9mbG9hdBh1IAEoAkgAEhYKDG9uZW9mX2RvdWJsZRh2IAEoAUgA", - "ElIKCm9uZW9mX2VudW0YdyABKA4yPC5wcm90b2J1Zl90ZXN0X21lc3NhZ2Vz", - "LnByb3RvMi5UZXN0QWxsVHlwZXNQcm90bzIuTmVzdGVkRW51bUgAEkUKBGRh", - "dGEYyQEgASgKMjYucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVz", - "dEFsbFR5cGVzUHJvdG8yLkRhdGESEwoKZmllbGRuYW1lMRiRAyABKAUSFAoL", - "ZmllbGRfbmFtZTIYkgMgASgFEhUKDF9maWVsZF9uYW1lMxiTAyABKAUSFgoN", - "ZmllbGRfX25hbWU0XxiUAyABKAUSFAoLZmllbGQwbmFtZTUYlQMgASgFEhYK", - "DWZpZWxkXzBfbmFtZTYYlgMgASgFEhMKCmZpZWxkTmFtZTcYlwMgASgFEhMK", - "CkZpZWxkTmFtZTgYmAMgASgFEhQKC2ZpZWxkX05hbWU5GJkDIAEoBRIVCgxG", - "aWVsZF9OYW1lMTAYmgMgASgFEhUKDEZJRUxEX05BTUUxMRibAyABKAUSFQoM", - "RklFTERfbmFtZTEyGJwDIAEoBRIXCg5fX2ZpZWxkX25hbWUxMxidAyABKAUS", - "FwoOX19GaWVsZF9uYW1lMTQYngMgASgFEhYKDWZpZWxkX19uYW1lMTUYnwMg", - "ASgFEhYKDWZpZWxkX19OYW1lMTYYoAMgASgFEhcKDmZpZWxkX25hbWUxN19f", - "GKEDIAEoBRIXCg5GaWVsZF9uYW1lMThfXxiiAyABKAUaYgoNTmVzdGVkTWVz", - "c2FnZRIJCgFhGAEgASgFEkYKC2NvcmVjdXJzaXZlGAIgASgLMjEucHJvdG9i", - "dWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yGjQK", - "Ek1hcEludDMySW50MzJFbnRyeRILCgNrZXkYASABKAUSDQoFdmFsdWUYAiAB", - "KAU6AjgBGjQKEk1hcEludDY0SW50NjRFbnRyeRILCgNrZXkYASABKAMSDQoF", - "dmFsdWUYAiABKAM6AjgBGjYKFE1hcFVpbnQzMlVpbnQzMkVudHJ5EgsKA2tl", - "eRgBIAEoDRINCgV2YWx1ZRgCIAEoDToCOAEaNgoUTWFwVWludDY0VWludDY0", - "RW50cnkSCwoDa2V5GAEgASgEEg0KBXZhbHVlGAIgASgEOgI4ARo2ChRNYXBT", - "aW50MzJTaW50MzJFbnRyeRILCgNrZXkYASABKBESDQoFdmFsdWUYAiABKBE6", - "AjgBGjYKFE1hcFNpbnQ2NFNpbnQ2NEVudHJ5EgsKA2tleRgBIAEoEhINCgV2", - "YWx1ZRgCIAEoEjoCOAEaOAoWTWFwRml4ZWQzMkZpeGVkMzJFbnRyeRILCgNr", - "ZXkYASABKAcSDQoFdmFsdWUYAiABKAc6AjgBGjgKFk1hcEZpeGVkNjRGaXhl", - "ZDY0RW50cnkSCwoDa2V5GAEgASgGEg0KBXZhbHVlGAIgASgGOgI4ARo6ChhN", - "YXBTZml4ZWQzMlNmaXhlZDMyRW50cnkSCwoDa2V5GAEgASgPEg0KBXZhbHVl", - "GAIgASgPOgI4ARo6ChhNYXBTZml4ZWQ2NFNmaXhlZDY0RW50cnkSCwoDa2V5", - "GAEgASgQEg0KBXZhbHVlGAIgASgQOgI4ARo0ChJNYXBJbnQzMkZsb2F0RW50", - "cnkSCwoDa2V5GAEgASgFEg0KBXZhbHVlGAIgASgCOgI4ARo1ChNNYXBJbnQz", - "MkRvdWJsZUVudHJ5EgsKA2tleRgBIAEoBRINCgV2YWx1ZRgCIAEoAToCOAEa", - "MgoQTWFwQm9vbEJvb2xFbnRyeRILCgNrZXkYASABKAgSDQoFdmFsdWUYAiAB", - "KAg6AjgBGjYKFE1hcFN0cmluZ1N0cmluZ0VudHJ5EgsKA2tleRgBIAEoCRIN", - "CgV2YWx1ZRgCIAEoCToCOAEaNQoTTWFwU3RyaW5nQnl0ZXNFbnRyeRILCgNr", - "ZXkYASABKAkSDQoFdmFsdWUYAiABKAw6AjgBGn4KG01hcFN0cmluZ05lc3Rl", - "ZE1lc3NhZ2VFbnRyeRILCgNrZXkYASABKAkSTgoFdmFsdWUYAiABKAsyPy5w", + "bzIuTWFwU2ludDMyU2ludDMyRW50cnkSYQoRbWFwX3NpbnQ2NF9zaW50NjQY", + "PSADKAsyRi5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxs", + "VHlwZXNQcm90bzIuTWFwU2ludDY0U2ludDY0RW50cnkSZQoTbWFwX2ZpeGVk", + "MzJfZml4ZWQzMhg+IAMoCzJILnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJv", + "dG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5NYXBGaXhlZDMyRml4ZWQzMkVudHJ5", + "EmUKE21hcF9maXhlZDY0X2ZpeGVkNjQYPyADKAsySC5wcm90b2J1Zl90ZXN0", + "X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90bzIuTWFwRml4ZWQ2", + "NEZpeGVkNjRFbnRyeRJpChVtYXBfc2ZpeGVkMzJfc2ZpeGVkMzIYQCADKAsy", + "Si5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQ", + "cm90bzIuTWFwU2ZpeGVkMzJTZml4ZWQzMkVudHJ5EmkKFW1hcF9zZml4ZWQ2", + "NF9zZml4ZWQ2NBhBIAMoCzJKLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJv", + "dG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5NYXBTZml4ZWQ2NFNmaXhlZDY0RW50", + "cnkSXQoPbWFwX2ludDMyX2Zsb2F0GEIgAygLMkQucHJvdG9idWZfdGVzdF9t", + "ZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1hcEludDMyRmxv", + "YXRFbnRyeRJfChBtYXBfaW50MzJfZG91YmxlGEMgAygLMkUucHJvdG9idWZf", + "dGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1hcElu", + "dDMyRG91YmxlRW50cnkSWQoNbWFwX2Jvb2xfYm9vbBhEIAMoCzJCLnByb3Rv", + "YnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5N", + "YXBCb29sQm9vbEVudHJ5EmEKEW1hcF9zdHJpbmdfc3RyaW5nGEUgAygLMkYu", + "cHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJv", + "dG8yLk1hcFN0cmluZ1N0cmluZ0VudHJ5El8KEG1hcF9zdHJpbmdfYnl0ZXMY", + "RiADKAsyRS5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxs", + "VHlwZXNQcm90bzIuTWFwU3RyaW5nQnl0ZXNFbnRyeRJwChltYXBfc3RyaW5n", + "X25lc3RlZF9tZXNzYWdlGEcgAygLMk0ucHJvdG9idWZfdGVzdF9tZXNzYWdl", + "cy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1hcFN0cmluZ05lc3RlZE1l", + "c3NhZ2VFbnRyeRJyChptYXBfc3RyaW5nX2ZvcmVpZ25fbWVzc2FnZRhIIAMo", + "CzJOLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRlc3RBbGxUeXBl", + "c1Byb3RvMi5NYXBTdHJpbmdGb3JlaWduTWVzc2FnZUVudHJ5EmoKFm1hcF9z", + "dHJpbmdfbmVzdGVkX2VudW0YSSADKAsySi5wcm90b2J1Zl90ZXN0X21lc3Nh", + "Z2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90bzIuTWFwU3RyaW5nTmVzdGVk", + "RW51bUVudHJ5EmwKF21hcF9zdHJpbmdfZm9yZWlnbl9lbnVtGEogAygLMksu", + "cHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJv", + "dG8yLk1hcFN0cmluZ0ZvcmVpZ25FbnVtRW50cnkSFgoMb25lb2ZfdWludDMy", + "GG8gASgNSAASXwoUb25lb2ZfbmVzdGVkX21lc3NhZ2UYcCABKAsyPy5wcm90", + "b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90bzIu", + "TmVzdGVkTWVzc2FnZUgAEhYKDG9uZW9mX3N0cmluZxhxIAEoCUgAEhUKC29u", + "ZW9mX2J5dGVzGHIgASgMSAASFAoKb25lb2ZfYm9vbBhzIAEoCEgAEhYKDG9u", + "ZW9mX3VpbnQ2NBh0IAEoBEgAEhUKC29uZW9mX2Zsb2F0GHUgASgCSAASFgoM", + "b25lb2ZfZG91YmxlGHYgASgBSAASUgoKb25lb2ZfZW51bRh3IAEoDjI8LnBy", + "b3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRlc3RBbGxUeXBlc1Byb3Rv", + "Mi5OZXN0ZWRFbnVtSAASRQoEZGF0YRjJASABKAoyNi5wcm90b2J1Zl90ZXN0", + "X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90bzIuRGF0YRITCgpm", + "aWVsZG5hbWUxGJEDIAEoBRIUCgtmaWVsZF9uYW1lMhiSAyABKAUSFQoMX2Zp", + "ZWxkX25hbWUzGJMDIAEoBRIWCg1maWVsZF9fbmFtZTRfGJQDIAEoBRIUCgtm", + "aWVsZDBuYW1lNRiVAyABKAUSFgoNZmllbGRfMF9uYW1lNhiWAyABKAUSEwoK", + "ZmllbGROYW1lNxiXAyABKAUSEwoKRmllbGROYW1lOBiYAyABKAUSFAoLZmll", + "bGRfTmFtZTkYmQMgASgFEhUKDEZpZWxkX05hbWUxMBiaAyABKAUSFQoMRklF", + "TERfTkFNRTExGJsDIAEoBRIVCgxGSUVMRF9uYW1lMTIYnAMgASgFEhcKDl9f", + "ZmllbGRfbmFtZTEzGJ0DIAEoBRIXCg5fX0ZpZWxkX25hbWUxNBieAyABKAUS", + "FgoNZmllbGRfX25hbWUxNRifAyABKAUSFgoNZmllbGRfX05hbWUxNhigAyAB", + "KAUSFwoOZmllbGRfbmFtZTE3X18YoQMgASgFEhcKDkZpZWxkX25hbWUxOF9f", + "GKIDIAEoBRpiCg1OZXN0ZWRNZXNzYWdlEgkKAWEYASABKAUSRgoLY29yZWN1", + "cnNpdmUYAiABKAsyMS5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5U", + "ZXN0QWxsVHlwZXNQcm90bzIaNAoSTWFwSW50MzJJbnQzMkVudHJ5EgsKA2tl", + "eRgBIAEoBRINCgV2YWx1ZRgCIAEoBToCOAEaNAoSTWFwSW50NjRJbnQ2NEVu", + "dHJ5EgsKA2tleRgBIAEoAxINCgV2YWx1ZRgCIAEoAzoCOAEaNgoUTWFwVWlu", + "dDMyVWludDMyRW50cnkSCwoDa2V5GAEgASgNEg0KBXZhbHVlGAIgASgNOgI4", + "ARo2ChRNYXBVaW50NjRVaW50NjRFbnRyeRILCgNrZXkYASABKAQSDQoFdmFs", + "dWUYAiABKAQ6AjgBGjYKFE1hcFNpbnQzMlNpbnQzMkVudHJ5EgsKA2tleRgB", + "IAEoERINCgV2YWx1ZRgCIAEoEToCOAEaNgoUTWFwU2ludDY0U2ludDY0RW50", + "cnkSCwoDa2V5GAEgASgSEg0KBXZhbHVlGAIgASgSOgI4ARo4ChZNYXBGaXhl", + "ZDMyRml4ZWQzMkVudHJ5EgsKA2tleRgBIAEoBxINCgV2YWx1ZRgCIAEoBzoC", + "OAEaOAoWTWFwRml4ZWQ2NEZpeGVkNjRFbnRyeRILCgNrZXkYASABKAYSDQoF", + "dmFsdWUYAiABKAY6AjgBGjoKGE1hcFNmaXhlZDMyU2ZpeGVkMzJFbnRyeRIL", + "CgNrZXkYASABKA8SDQoFdmFsdWUYAiABKA86AjgBGjoKGE1hcFNmaXhlZDY0", + "U2ZpeGVkNjRFbnRyeRILCgNrZXkYASABKBASDQoFdmFsdWUYAiABKBA6AjgB", + "GjQKEk1hcEludDMyRmxvYXRFbnRyeRILCgNrZXkYASABKAUSDQoFdmFsdWUY", + "AiABKAI6AjgBGjUKE01hcEludDMyRG91YmxlRW50cnkSCwoDa2V5GAEgASgF", + "Eg0KBXZhbHVlGAIgASgBOgI4ARoyChBNYXBCb29sQm9vbEVudHJ5EgsKA2tl", + "eRgBIAEoCBINCgV2YWx1ZRgCIAEoCDoCOAEaNgoUTWFwU3RyaW5nU3RyaW5n", + "RW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ARo1ChNNYXBT", + "dHJpbmdCeXRlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoDDoC", + "OAEafgobTWFwU3RyaW5nTmVzdGVkTWVzc2FnZUVudHJ5EgsKA2tleRgBIAEo", + "CRJOCgV2YWx1ZRgCIAEoCzI/LnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJv", + "dG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5OZXN0ZWRNZXNzYWdlOgI4ARpzChxN", + "YXBTdHJpbmdGb3JlaWduTWVzc2FnZUVudHJ5EgsKA2tleRgBIAEoCRJCCgV2", + "YWx1ZRgCIAEoCzIzLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLkZv", + "cmVpZ25NZXNzYWdlUHJvdG8yOgI4ARp4ChhNYXBTdHJpbmdOZXN0ZWRFbnVt", + "RW50cnkSCwoDa2V5GAEgASgJEksKBXZhbHVlGAIgASgOMjwucHJvdG9idWZf", + "dGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk5lc3Rl", + "ZEVudW06AjgBGm0KGU1hcFN0cmluZ0ZvcmVpZ25FbnVtRW50cnkSCwoDa2V5", + "GAEgASgJEj8KBXZhbHVlGAIgASgOMjAucHJvdG9idWZfdGVzdF9tZXNzYWdl", + "cy5wcm90bzIuRm9yZWlnbkVudW1Qcm90bzI6AjgBGjMKBERhdGESFAoLZ3Jv", + "dXBfaW50MzIYygEgASgFEhUKDGdyb3VwX3VpbnQzMhjLASABKA0aIQoRTWVz", + "c2FnZVNldENvcnJlY3QqCAgEEP////8HOgIIARrgAQobTWVzc2FnZVNldENv", + "cnJlY3RFeHRlbnNpb24xEgsKA3N0chgZIAEoCTKzAQoVbWVzc2FnZV9zZXRf", + "ZXh0ZW5zaW9uEkMucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVz", + "dEFsbFR5cGVzUHJvdG8yLk1lc3NhZ2VTZXRDb3JyZWN0GPm7XiABKAsyTS5w", "cm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5UZXN0QWxsVHlwZXNQcm90", - "bzIuTmVzdGVkTWVzc2FnZToCOAEacwocTWFwU3RyaW5nRm9yZWlnbk1lc3Nh", - "Z2VFbnRyeRILCgNrZXkYASABKAkSQgoFdmFsdWUYAiABKAsyMy5wcm90b2J1", - "Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5Gb3JlaWduTWVzc2FnZVByb3RvMjoC", - "OAEaeAoYTWFwU3RyaW5nTmVzdGVkRW51bUVudHJ5EgsKA2tleRgBIAEoCRJL", - "CgV2YWx1ZRgCIAEoDjI8LnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8y", - "LlRlc3RBbGxUeXBlc1Byb3RvMi5OZXN0ZWRFbnVtOgI4ARptChlNYXBTdHJp", - "bmdGb3JlaWduRW51bUVudHJ5EgsKA2tleRgBIAEoCRI/CgV2YWx1ZRgCIAEo", - "DjIwLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLkZvcmVpZ25FbnVt", - "UHJvdG8yOgI4ARozCgREYXRhEhQKC2dyb3VwX2ludDMyGMoBIAEoBRIVCgxn", - "cm91cF91aW50MzIYywEgASgNGiEKEU1lc3NhZ2VTZXRDb3JyZWN0KggIBBD/", - "////BzoCCAEa4AEKG01lc3NhZ2VTZXRDb3JyZWN0RXh0ZW5zaW9uMRILCgNz", - "dHIYGSABKAkyswEKFW1lc3NhZ2Vfc2V0X2V4dGVuc2lvbhJDLnByb3RvYnVm", - "X3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5NZXNz", - "YWdlU2V0Q29ycmVjdBj5u14gASgLMk0ucHJvdG9idWZfdGVzdF9tZXNzYWdl", - "cy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yLk1lc3NhZ2VTZXRDb3JyZWN0", - "RXh0ZW5zaW9uMRrfAQobTWVzc2FnZVNldENvcnJlY3RFeHRlbnNpb24yEgkK", - "AWkYCSABKAUytAEKFW1lc3NhZ2Vfc2V0X2V4dGVuc2lvbhJDLnByb3RvYnVm", - "X3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5NZXNz", - "YWdlU2V0Q29ycmVjdBiQs/wBIAEoCzJNLnByb3RvYnVmX3Rlc3RfbWVzc2Fn", - "ZXMucHJvdG8yLlRlc3RBbGxUeXBlc1Byb3RvMi5NZXNzYWdlU2V0Q29ycmVj", - "dEV4dGVuc2lvbjIiOQoKTmVzdGVkRW51bRIHCgNGT08QABIHCgNCQVIQARIH", - "CgNCQVoQAhIQCgNORUcQ////////////ASoFCHgQyQFCDQoLb25lb2ZfZmll", - "bGRKBgjoBxCQTiIhChRGb3JlaWduTWVzc2FnZVByb3RvMhIJCgFjGAEgASgF", - "IsECChVVbmtub3duVG9UZXN0QWxsVHlwZXMSFwoOb3B0aW9uYWxfaW50MzIY", - "6QcgASgFEhgKD29wdGlvbmFsX3N0cmluZxjqByABKAkSTAoObmVzdGVkX21l", - "c3NhZ2UY6wcgASgLMjMucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIu", - "Rm9yZWlnbk1lc3NhZ2VQcm90bzISWgoNb3B0aW9uYWxncm91cBjsByABKAoy", - "Qi5wcm90b2J1Zl90ZXN0X21lc3NhZ2VzLnByb3RvMi5Vbmtub3duVG9UZXN0", - "QWxsVHlwZXMuT3B0aW9uYWxHcm91cBIWCg1vcHRpb25hbF9ib29sGO4HIAEo", - "CBIXCg5yZXBlYXRlZF9pbnQzMhjzByADKAUaGgoNT3B0aW9uYWxHcm91cBIJ", - "CgFhGAEgASgFKkYKEUZvcmVpZ25FbnVtUHJvdG8yEg8KC0ZPUkVJR05fRk9P", - "EAASDwoLRk9SRUlHTl9CQVIQARIPCgtGT1JFSUdOX0JBWhACOkoKD2V4dGVu", - "c2lvbl9pbnQzMhIxLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMucHJvdG8yLlRl", - "c3RBbGxUeXBlc1Byb3RvMhh4IAEoBUIvCihjb20uZ29vZ2xlLnByb3RvYnVm", - "X3Rlc3RfbWVzc2FnZXMucHJvdG8ySAH4AQE=")); + "bzIuTWVzc2FnZVNldENvcnJlY3RFeHRlbnNpb24xGt8BChtNZXNzYWdlU2V0", + "Q29ycmVjdEV4dGVuc2lvbjISCQoBaRgJIAEoBTK0AQoVbWVzc2FnZV9zZXRf", + "ZXh0ZW5zaW9uEkMucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVz", + "dEFsbFR5cGVzUHJvdG8yLk1lc3NhZ2VTZXRDb3JyZWN0GJCz/AEgASgLMk0u", + "cHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJv", + "dG8yLk1lc3NhZ2VTZXRDb3JyZWN0RXh0ZW5zaW9uMiI5CgpOZXN0ZWRFbnVt", + "EgcKA0ZPTxAAEgcKA0JBUhABEgcKA0JBWhACEhAKA05FRxD///////////8B", + "KgUIeBDJAUINCgtvbmVvZl9maWVsZEoGCOgHEJBOIiEKFEZvcmVpZ25NZXNz", + "YWdlUHJvdG8yEgkKAWMYASABKAUiwQIKFVVua25vd25Ub1Rlc3RBbGxUeXBl", + "cxIXCg5vcHRpb25hbF9pbnQzMhjpByABKAUSGAoPb3B0aW9uYWxfc3RyaW5n", + "GOoHIAEoCRJMCg5uZXN0ZWRfbWVzc2FnZRjrByABKAsyMy5wcm90b2J1Zl90", + "ZXN0X21lc3NhZ2VzLnByb3RvMi5Gb3JlaWduTWVzc2FnZVByb3RvMhJaCg1v", + "cHRpb25hbGdyb3VwGOwHIAEoCjJCLnByb3RvYnVmX3Rlc3RfbWVzc2FnZXMu", + "cHJvdG8yLlVua25vd25Ub1Rlc3RBbGxUeXBlcy5PcHRpb25hbEdyb3VwEhYK", + "DW9wdGlvbmFsX2Jvb2wY7gcgASgIEhcKDnJlcGVhdGVkX2ludDMyGPMHIAMo", + "BRoaCg1PcHRpb25hbEdyb3VwEgkKAWEYASABKAUqRgoRRm9yZWlnbkVudW1Q", + "cm90bzISDwoLRk9SRUlHTl9GT08QABIPCgtGT1JFSUdOX0JBUhABEg8KC0ZP", + "UkVJR05fQkFaEAI6SgoPZXh0ZW5zaW9uX2ludDMyEjEucHJvdG9idWZfdGVz", + "dF9tZXNzYWdlcy5wcm90bzIuVGVzdEFsbFR5cGVzUHJvdG8yGHggASgFQi8K", + "KGNvbS5nb29nbGUucHJvdG9idWZfdGVzdF9tZXNzYWdlcy5wcm90bzJIAfgB", + "AQ==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::ProtobufTestMessages.Proto2.ForeignEnumProto2), }, new pb::Extension[] { TestMessagesProto2Extensions.ExtensionInt32 }, new pbr::GeneratedClrTypeInfo[] { - new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2), global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Parser, new[]{ "OptionalInt32", "OptionalInt64", "OptionalUint32", "OptionalUint64", "OptionalSint32", "OptionalSint64", "OptionalFixed32", "OptionalFixed64", "OptionalSfixed32", "OptionalSfixed64", "OptionalFloat", "OptionalDouble", "OptionalBool", "OptionalString", "OptionalBytes", "OptionalNestedMessage", "OptionalForeignMessage", "OptionalNestedEnum", "OptionalForeignEnum", "OptionalStringPiece", "OptionalCord", "RecursiveMessage", "RepeatedInt32", "RepeatedInt64", "RepeatedUint32", "RepeatedUint64", "RepeatedSint32", "RepeatedSint64", "RepeatedFixed32", "RepeatedFixed64", "RepeatedSfixed32", "RepeatedSfixed64", "RepeatedFloat", "RepeatedDouble", "RepeatedBool", "RepeatedString", "RepeatedBytes", "RepeatedNestedMessage", "RepeatedForeignMessage", "RepeatedNestedEnum", "RepeatedForeignEnum", "RepeatedStringPiece", "RepeatedCord", "MapInt32Int32", "MapInt64Int64", "MapUint32Uint32", "MapUint64Uint64", "MapSint32Sint32", "MapSint64Sint64", "MapFixed32Fixed32", "MapFixed64Fixed64", "MapSfixed32Sfixed32", "MapSfixed64Sfixed64", "MapInt32Float", "MapInt32Double", "MapBoolBool", "MapStringString", "MapStringBytes", "MapStringNestedMessage", "MapStringForeignMessage", "MapStringNestedEnum", "MapStringForeignEnum", "OneofUint32", "OneofNestedMessage", "OneofString", "OneofBytes", "OneofBool", "OneofUint64", "OneofFloat", "OneofDouble", "OneofEnum", "Data", "Fieldname1", "FieldName2", "FieldName3", "FieldName4", "Field0Name5", "Field0Name6", "FieldName7", "FieldName8", "FieldName9", "FieldName10", "FIELDNAME11", "FIELDName12", "FieldName13", "FieldName14", "FieldName15", "FieldName16", "FieldName17", "FieldName18" }, new[]{ "OneofField" }, new[]{ typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.NestedEnum) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.NestedMessage), global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.NestedMessage.Parser, new[]{ "A", "Corecursive" }, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2), global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Parser, new[]{ "OptionalInt32", "OptionalInt64", "OptionalUint32", "OptionalUint64", "OptionalSint32", "OptionalSint64", "OptionalFixed32", "OptionalFixed64", "OptionalSfixed32", "OptionalSfixed64", "OptionalFloat", "OptionalDouble", "OptionalBool", "OptionalString", "OptionalBytes", "OptionalNestedMessage", "OptionalForeignMessage", "OptionalNestedEnum", "OptionalForeignEnum", "OptionalStringPiece", "OptionalCord", "RecursiveMessage", "RepeatedInt32", "RepeatedInt64", "RepeatedUint32", "RepeatedUint64", "RepeatedSint32", "RepeatedSint64", "RepeatedFixed32", "RepeatedFixed64", "RepeatedSfixed32", "RepeatedSfixed64", "RepeatedFloat", "RepeatedDouble", "RepeatedBool", "RepeatedString", "RepeatedBytes", "RepeatedNestedMessage", "RepeatedForeignMessage", "RepeatedNestedEnum", "RepeatedForeignEnum", "RepeatedStringPiece", "RepeatedCord", "PackedInt32", "PackedInt64", "PackedUint32", "PackedUint64", "PackedSint32", "PackedSint64", "PackedFixed32", "PackedFixed64", "PackedSfixed32", "PackedSfixed64", "PackedFloat", "PackedDouble", "PackedBool", "PackedNestedEnum", "UnpackedInt32", "UnpackedInt64", "UnpackedUint32", "UnpackedUint64", "UnpackedSint32", "UnpackedSint64", "UnpackedFixed32", "UnpackedFixed64", "UnpackedSfixed32", "UnpackedSfixed64", "UnpackedFloat", "UnpackedDouble", "UnpackedBool", "UnpackedNestedEnum", "MapInt32Int32", "MapInt64Int64", "MapUint32Uint32", "MapUint64Uint64", "MapSint32Sint32", "MapSint64Sint64", "MapFixed32Fixed32", "MapFixed64Fixed64", "MapSfixed32Sfixed32", "MapSfixed64Sfixed64", "MapInt32Float", "MapInt32Double", "MapBoolBool", "MapStringString", "MapStringBytes", "MapStringNestedMessage", "MapStringForeignMessage", "MapStringNestedEnum", "MapStringForeignEnum", "OneofUint32", "OneofNestedMessage", "OneofString", "OneofBytes", "OneofBool", "OneofUint64", "OneofFloat", "OneofDouble", "OneofEnum", "Data", "Fieldname1", "FieldName2", "FieldName3", "FieldName4", "Field0Name5", "Field0Name6", "FieldName7", "FieldName8", "FieldName9", "FieldName10", "FIELDNAME11", "FIELDName12", "FieldName13", "FieldName14", "FieldName15", "FieldName16", "FieldName17", "FieldName18" }, new[]{ "OneofField" }, new[]{ typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.NestedEnum) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.NestedMessage), global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.NestedMessage.Parser, new[]{ "A", "Corecursive" }, null, null, null, null), null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.Data), global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.Data.Parser, new[]{ "GroupInt32", "GroupUint32" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.MessageSetCorrect), global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.MessageSetCorrect.Parser, null, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.MessageSetCorrectExtension1), global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.MessageSetCorrectExtension1.Parser, new[]{ "Str" }, null, null, new pb::Extension[] { global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.MessageSetCorrectExtension1.Extensions.MessageSetExtension }, null), @@ -297,6 +318,34 @@ namespace ProtobufTestMessages.Proto2 { repeatedForeignEnum_ = other.repeatedForeignEnum_.Clone(); repeatedStringPiece_ = other.repeatedStringPiece_.Clone(); repeatedCord_ = other.repeatedCord_.Clone(); + packedInt32_ = other.packedInt32_.Clone(); + packedInt64_ = other.packedInt64_.Clone(); + packedUint32_ = other.packedUint32_.Clone(); + packedUint64_ = other.packedUint64_.Clone(); + packedSint32_ = other.packedSint32_.Clone(); + packedSint64_ = other.packedSint64_.Clone(); + packedFixed32_ = other.packedFixed32_.Clone(); + packedFixed64_ = other.packedFixed64_.Clone(); + packedSfixed32_ = other.packedSfixed32_.Clone(); + packedSfixed64_ = other.packedSfixed64_.Clone(); + packedFloat_ = other.packedFloat_.Clone(); + packedDouble_ = other.packedDouble_.Clone(); + packedBool_ = other.packedBool_.Clone(); + packedNestedEnum_ = other.packedNestedEnum_.Clone(); + unpackedInt32_ = other.unpackedInt32_.Clone(); + unpackedInt64_ = other.unpackedInt64_.Clone(); + unpackedUint32_ = other.unpackedUint32_.Clone(); + unpackedUint64_ = other.unpackedUint64_.Clone(); + unpackedSint32_ = other.unpackedSint32_.Clone(); + unpackedSint64_ = other.unpackedSint64_.Clone(); + unpackedFixed32_ = other.unpackedFixed32_.Clone(); + unpackedFixed64_ = other.unpackedFixed64_.Clone(); + unpackedSfixed32_ = other.unpackedSfixed32_.Clone(); + unpackedSfixed64_ = other.unpackedSfixed64_.Clone(); + unpackedFloat_ = other.unpackedFloat_.Clone(); + unpackedDouble_ = other.unpackedDouble_.Clone(); + unpackedBool_ = other.unpackedBool_.Clone(); + unpackedNestedEnum_ = other.unpackedNestedEnum_.Clone(); mapInt32Int32_ = other.mapInt32Int32_.Clone(); mapInt64Int64_ = other.mapInt64Int64_.Clone(); mapUint32Uint32_ = other.mapUint32Uint32_.Clone(); @@ -1105,6 +1154,292 @@ namespace ProtobufTestMessages.Proto2 { get { return repeatedCord_; } } + /// Field number for the "packed_int32" field. + public const int PackedInt32FieldNumber = 75; + private static readonly pb::FieldCodec _repeated_packedInt32_codec + = pb::FieldCodec.ForInt32(602); + private readonly pbc::RepeatedField packedInt32_ = new pbc::RepeatedField(); + /// + /// Packed + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedInt32 { + get { return packedInt32_; } + } + + /// Field number for the "packed_int64" field. + public const int PackedInt64FieldNumber = 76; + private static readonly pb::FieldCodec _repeated_packedInt64_codec + = pb::FieldCodec.ForInt64(610); + private readonly pbc::RepeatedField packedInt64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedInt64 { + get { return packedInt64_; } + } + + /// Field number for the "packed_uint32" field. + public const int PackedUint32FieldNumber = 77; + private static readonly pb::FieldCodec _repeated_packedUint32_codec + = pb::FieldCodec.ForUInt32(618); + private readonly pbc::RepeatedField packedUint32_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedUint32 { + get { return packedUint32_; } + } + + /// Field number for the "packed_uint64" field. + public const int PackedUint64FieldNumber = 78; + private static readonly pb::FieldCodec _repeated_packedUint64_codec + = pb::FieldCodec.ForUInt64(626); + private readonly pbc::RepeatedField packedUint64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedUint64 { + get { return packedUint64_; } + } + + /// Field number for the "packed_sint32" field. + public const int PackedSint32FieldNumber = 79; + private static readonly pb::FieldCodec _repeated_packedSint32_codec + = pb::FieldCodec.ForSInt32(634); + private readonly pbc::RepeatedField packedSint32_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedSint32 { + get { return packedSint32_; } + } + + /// Field number for the "packed_sint64" field. + public const int PackedSint64FieldNumber = 80; + private static readonly pb::FieldCodec _repeated_packedSint64_codec + = pb::FieldCodec.ForSInt64(642); + private readonly pbc::RepeatedField packedSint64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedSint64 { + get { return packedSint64_; } + } + + /// Field number for the "packed_fixed32" field. + public const int PackedFixed32FieldNumber = 81; + private static readonly pb::FieldCodec _repeated_packedFixed32_codec + = pb::FieldCodec.ForFixed32(650); + private readonly pbc::RepeatedField packedFixed32_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedFixed32 { + get { return packedFixed32_; } + } + + /// Field number for the "packed_fixed64" field. + public const int PackedFixed64FieldNumber = 82; + private static readonly pb::FieldCodec _repeated_packedFixed64_codec + = pb::FieldCodec.ForFixed64(658); + private readonly pbc::RepeatedField packedFixed64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedFixed64 { + get { return packedFixed64_; } + } + + /// Field number for the "packed_sfixed32" field. + public const int PackedSfixed32FieldNumber = 83; + private static readonly pb::FieldCodec _repeated_packedSfixed32_codec + = pb::FieldCodec.ForSFixed32(666); + private readonly pbc::RepeatedField packedSfixed32_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedSfixed32 { + get { return packedSfixed32_; } + } + + /// Field number for the "packed_sfixed64" field. + public const int PackedSfixed64FieldNumber = 84; + private static readonly pb::FieldCodec _repeated_packedSfixed64_codec + = pb::FieldCodec.ForSFixed64(674); + private readonly pbc::RepeatedField packedSfixed64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedSfixed64 { + get { return packedSfixed64_; } + } + + /// Field number for the "packed_float" field. + public const int PackedFloatFieldNumber = 85; + private static readonly pb::FieldCodec _repeated_packedFloat_codec + = pb::FieldCodec.ForFloat(682); + private readonly pbc::RepeatedField packedFloat_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedFloat { + get { return packedFloat_; } + } + + /// Field number for the "packed_double" field. + public const int PackedDoubleFieldNumber = 86; + private static readonly pb::FieldCodec _repeated_packedDouble_codec + = pb::FieldCodec.ForDouble(690); + private readonly pbc::RepeatedField packedDouble_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedDouble { + get { return packedDouble_; } + } + + /// Field number for the "packed_bool" field. + public const int PackedBoolFieldNumber = 87; + private static readonly pb::FieldCodec _repeated_packedBool_codec + = pb::FieldCodec.ForBool(698); + private readonly pbc::RepeatedField packedBool_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedBool { + get { return packedBool_; } + } + + /// Field number for the "packed_nested_enum" field. + public const int PackedNestedEnumFieldNumber = 88; + private static readonly pb::FieldCodec _repeated_packedNestedEnum_codec + = pb::FieldCodec.ForEnum(706, x => (int) x, x => (global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.NestedEnum) x); + private readonly pbc::RepeatedField packedNestedEnum_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField PackedNestedEnum { + get { return packedNestedEnum_; } + } + + /// Field number for the "unpacked_int32" field. + public const int UnpackedInt32FieldNumber = 89; + private static readonly pb::FieldCodec _repeated_unpackedInt32_codec + = pb::FieldCodec.ForInt32(712); + private readonly pbc::RepeatedField unpackedInt32_ = new pbc::RepeatedField(); + /// + /// Unpacked + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedInt32 { + get { return unpackedInt32_; } + } + + /// Field number for the "unpacked_int64" field. + public const int UnpackedInt64FieldNumber = 90; + private static readonly pb::FieldCodec _repeated_unpackedInt64_codec + = pb::FieldCodec.ForInt64(720); + private readonly pbc::RepeatedField unpackedInt64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedInt64 { + get { return unpackedInt64_; } + } + + /// Field number for the "unpacked_uint32" field. + public const int UnpackedUint32FieldNumber = 91; + private static readonly pb::FieldCodec _repeated_unpackedUint32_codec + = pb::FieldCodec.ForUInt32(728); + private readonly pbc::RepeatedField unpackedUint32_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedUint32 { + get { return unpackedUint32_; } + } + + /// Field number for the "unpacked_uint64" field. + public const int UnpackedUint64FieldNumber = 92; + private static readonly pb::FieldCodec _repeated_unpackedUint64_codec + = pb::FieldCodec.ForUInt64(736); + private readonly pbc::RepeatedField unpackedUint64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedUint64 { + get { return unpackedUint64_; } + } + + /// Field number for the "unpacked_sint32" field. + public const int UnpackedSint32FieldNumber = 93; + private static readonly pb::FieldCodec _repeated_unpackedSint32_codec + = pb::FieldCodec.ForSInt32(744); + private readonly pbc::RepeatedField unpackedSint32_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedSint32 { + get { return unpackedSint32_; } + } + + /// Field number for the "unpacked_sint64" field. + public const int UnpackedSint64FieldNumber = 94; + private static readonly pb::FieldCodec _repeated_unpackedSint64_codec + = pb::FieldCodec.ForSInt64(752); + private readonly pbc::RepeatedField unpackedSint64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedSint64 { + get { return unpackedSint64_; } + } + + /// Field number for the "unpacked_fixed32" field. + public const int UnpackedFixed32FieldNumber = 95; + private static readonly pb::FieldCodec _repeated_unpackedFixed32_codec + = pb::FieldCodec.ForFixed32(765); + private readonly pbc::RepeatedField unpackedFixed32_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedFixed32 { + get { return unpackedFixed32_; } + } + + /// Field number for the "unpacked_fixed64" field. + public const int UnpackedFixed64FieldNumber = 96; + private static readonly pb::FieldCodec _repeated_unpackedFixed64_codec + = pb::FieldCodec.ForFixed64(769); + private readonly pbc::RepeatedField unpackedFixed64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedFixed64 { + get { return unpackedFixed64_; } + } + + /// Field number for the "unpacked_sfixed32" field. + public const int UnpackedSfixed32FieldNumber = 97; + private static readonly pb::FieldCodec _repeated_unpackedSfixed32_codec + = pb::FieldCodec.ForSFixed32(781); + private readonly pbc::RepeatedField unpackedSfixed32_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedSfixed32 { + get { return unpackedSfixed32_; } + } + + /// Field number for the "unpacked_sfixed64" field. + public const int UnpackedSfixed64FieldNumber = 98; + private static readonly pb::FieldCodec _repeated_unpackedSfixed64_codec + = pb::FieldCodec.ForSFixed64(785); + private readonly pbc::RepeatedField unpackedSfixed64_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedSfixed64 { + get { return unpackedSfixed64_; } + } + + /// Field number for the "unpacked_float" field. + public const int UnpackedFloatFieldNumber = 99; + private static readonly pb::FieldCodec _repeated_unpackedFloat_codec + = pb::FieldCodec.ForFloat(797); + private readonly pbc::RepeatedField unpackedFloat_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedFloat { + get { return unpackedFloat_; } + } + + /// Field number for the "unpacked_double" field. + public const int UnpackedDoubleFieldNumber = 100; + private static readonly pb::FieldCodec _repeated_unpackedDouble_codec + = pb::FieldCodec.ForDouble(801); + private readonly pbc::RepeatedField unpackedDouble_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedDouble { + get { return unpackedDouble_; } + } + + /// Field number for the "unpacked_bool" field. + public const int UnpackedBoolFieldNumber = 101; + private static readonly pb::FieldCodec _repeated_unpackedBool_codec + = pb::FieldCodec.ForBool(808); + private readonly pbc::RepeatedField unpackedBool_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedBool { + get { return unpackedBool_; } + } + + /// Field number for the "unpacked_nested_enum" field. + public const int UnpackedNestedEnumFieldNumber = 102; + private static readonly pb::FieldCodec _repeated_unpackedNestedEnum_codec + = pb::FieldCodec.ForEnum(816, x => (int) x, x => (global::ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.NestedEnum) x); + private readonly pbc::RepeatedField unpackedNestedEnum_ = new pbc::RepeatedField(); + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField UnpackedNestedEnum { + get { return unpackedNestedEnum_; } + } + /// Field number for the "map_int32_int32" field. public const int MapInt32Int32FieldNumber = 56; private static readonly pbc::MapField.Codec _map_mapInt32Int32_codec @@ -2044,6 +2379,34 @@ namespace ProtobufTestMessages.Proto2 { if(!repeatedForeignEnum_.Equals(other.repeatedForeignEnum_)) return false; if(!repeatedStringPiece_.Equals(other.repeatedStringPiece_)) return false; if(!repeatedCord_.Equals(other.repeatedCord_)) return false; + if(!packedInt32_.Equals(other.packedInt32_)) return false; + if(!packedInt64_.Equals(other.packedInt64_)) return false; + if(!packedUint32_.Equals(other.packedUint32_)) return false; + if(!packedUint64_.Equals(other.packedUint64_)) return false; + if(!packedSint32_.Equals(other.packedSint32_)) return false; + if(!packedSint64_.Equals(other.packedSint64_)) return false; + if(!packedFixed32_.Equals(other.packedFixed32_)) return false; + if(!packedFixed64_.Equals(other.packedFixed64_)) return false; + if(!packedSfixed32_.Equals(other.packedSfixed32_)) return false; + if(!packedSfixed64_.Equals(other.packedSfixed64_)) return false; + if(!packedFloat_.Equals(other.packedFloat_)) return false; + if(!packedDouble_.Equals(other.packedDouble_)) return false; + if(!packedBool_.Equals(other.packedBool_)) return false; + if(!packedNestedEnum_.Equals(other.packedNestedEnum_)) return false; + if(!unpackedInt32_.Equals(other.unpackedInt32_)) return false; + if(!unpackedInt64_.Equals(other.unpackedInt64_)) return false; + if(!unpackedUint32_.Equals(other.unpackedUint32_)) return false; + if(!unpackedUint64_.Equals(other.unpackedUint64_)) return false; + if(!unpackedSint32_.Equals(other.unpackedSint32_)) return false; + if(!unpackedSint64_.Equals(other.unpackedSint64_)) return false; + if(!unpackedFixed32_.Equals(other.unpackedFixed32_)) return false; + if(!unpackedFixed64_.Equals(other.unpackedFixed64_)) return false; + if(!unpackedSfixed32_.Equals(other.unpackedSfixed32_)) return false; + if(!unpackedSfixed64_.Equals(other.unpackedSfixed64_)) return false; + if(!unpackedFloat_.Equals(other.unpackedFloat_)) return false; + if(!unpackedDouble_.Equals(other.unpackedDouble_)) return false; + if(!unpackedBool_.Equals(other.unpackedBool_)) return false; + if(!unpackedNestedEnum_.Equals(other.unpackedNestedEnum_)) return false; if (!MapInt32Int32.Equals(other.MapInt32Int32)) return false; if (!MapInt64Int64.Equals(other.MapInt64Int64)) return false; if (!MapUint32Uint32.Equals(other.MapUint32Uint32)) return false; @@ -2144,6 +2507,34 @@ namespace ProtobufTestMessages.Proto2 { hash ^= repeatedForeignEnum_.GetHashCode(); hash ^= repeatedStringPiece_.GetHashCode(); hash ^= repeatedCord_.GetHashCode(); + hash ^= packedInt32_.GetHashCode(); + hash ^= packedInt64_.GetHashCode(); + hash ^= packedUint32_.GetHashCode(); + hash ^= packedUint64_.GetHashCode(); + hash ^= packedSint32_.GetHashCode(); + hash ^= packedSint64_.GetHashCode(); + hash ^= packedFixed32_.GetHashCode(); + hash ^= packedFixed64_.GetHashCode(); + hash ^= packedSfixed32_.GetHashCode(); + hash ^= packedSfixed64_.GetHashCode(); + hash ^= packedFloat_.GetHashCode(); + hash ^= packedDouble_.GetHashCode(); + hash ^= packedBool_.GetHashCode(); + hash ^= packedNestedEnum_.GetHashCode(); + hash ^= unpackedInt32_.GetHashCode(); + hash ^= unpackedInt64_.GetHashCode(); + hash ^= unpackedUint32_.GetHashCode(); + hash ^= unpackedUint64_.GetHashCode(); + hash ^= unpackedSint32_.GetHashCode(); + hash ^= unpackedSint64_.GetHashCode(); + hash ^= unpackedFixed32_.GetHashCode(); + hash ^= unpackedFixed64_.GetHashCode(); + hash ^= unpackedSfixed32_.GetHashCode(); + hash ^= unpackedSfixed64_.GetHashCode(); + hash ^= unpackedFloat_.GetHashCode(); + hash ^= unpackedDouble_.GetHashCode(); + hash ^= unpackedBool_.GetHashCode(); + hash ^= unpackedNestedEnum_.GetHashCode(); hash ^= MapInt32Int32.GetHashCode(); hash ^= MapInt64Int64.GetHashCode(); hash ^= MapUint32Uint32.GetHashCode(); @@ -2336,6 +2727,34 @@ namespace ProtobufTestMessages.Proto2 { mapStringForeignMessage_.WriteTo(output, _map_mapStringForeignMessage_codec); mapStringNestedEnum_.WriteTo(output, _map_mapStringNestedEnum_codec); mapStringForeignEnum_.WriteTo(output, _map_mapStringForeignEnum_codec); + packedInt32_.WriteTo(output, _repeated_packedInt32_codec); + packedInt64_.WriteTo(output, _repeated_packedInt64_codec); + packedUint32_.WriteTo(output, _repeated_packedUint32_codec); + packedUint64_.WriteTo(output, _repeated_packedUint64_codec); + packedSint32_.WriteTo(output, _repeated_packedSint32_codec); + packedSint64_.WriteTo(output, _repeated_packedSint64_codec); + packedFixed32_.WriteTo(output, _repeated_packedFixed32_codec); + packedFixed64_.WriteTo(output, _repeated_packedFixed64_codec); + packedSfixed32_.WriteTo(output, _repeated_packedSfixed32_codec); + packedSfixed64_.WriteTo(output, _repeated_packedSfixed64_codec); + packedFloat_.WriteTo(output, _repeated_packedFloat_codec); + packedDouble_.WriteTo(output, _repeated_packedDouble_codec); + packedBool_.WriteTo(output, _repeated_packedBool_codec); + packedNestedEnum_.WriteTo(output, _repeated_packedNestedEnum_codec); + unpackedInt32_.WriteTo(output, _repeated_unpackedInt32_codec); + unpackedInt64_.WriteTo(output, _repeated_unpackedInt64_codec); + unpackedUint32_.WriteTo(output, _repeated_unpackedUint32_codec); + unpackedUint64_.WriteTo(output, _repeated_unpackedUint64_codec); + unpackedSint32_.WriteTo(output, _repeated_unpackedSint32_codec); + unpackedSint64_.WriteTo(output, _repeated_unpackedSint64_codec); + unpackedFixed32_.WriteTo(output, _repeated_unpackedFixed32_codec); + unpackedFixed64_.WriteTo(output, _repeated_unpackedFixed64_codec); + unpackedSfixed32_.WriteTo(output, _repeated_unpackedSfixed32_codec); + unpackedSfixed64_.WriteTo(output, _repeated_unpackedSfixed64_codec); + unpackedFloat_.WriteTo(output, _repeated_unpackedFloat_codec); + unpackedDouble_.WriteTo(output, _repeated_unpackedDouble_codec); + unpackedBool_.WriteTo(output, _repeated_unpackedBool_codec); + unpackedNestedEnum_.WriteTo(output, _repeated_unpackedNestedEnum_codec); if (HasOneofUint32) { output.WriteRawTag(248, 6); output.WriteUInt32(OneofUint32); @@ -2547,6 +2966,34 @@ namespace ProtobufTestMessages.Proto2 { size += repeatedForeignEnum_.CalculateSize(_repeated_repeatedForeignEnum_codec); size += repeatedStringPiece_.CalculateSize(_repeated_repeatedStringPiece_codec); size += repeatedCord_.CalculateSize(_repeated_repeatedCord_codec); + size += packedInt32_.CalculateSize(_repeated_packedInt32_codec); + size += packedInt64_.CalculateSize(_repeated_packedInt64_codec); + size += packedUint32_.CalculateSize(_repeated_packedUint32_codec); + size += packedUint64_.CalculateSize(_repeated_packedUint64_codec); + size += packedSint32_.CalculateSize(_repeated_packedSint32_codec); + size += packedSint64_.CalculateSize(_repeated_packedSint64_codec); + size += packedFixed32_.CalculateSize(_repeated_packedFixed32_codec); + size += packedFixed64_.CalculateSize(_repeated_packedFixed64_codec); + size += packedSfixed32_.CalculateSize(_repeated_packedSfixed32_codec); + size += packedSfixed64_.CalculateSize(_repeated_packedSfixed64_codec); + size += packedFloat_.CalculateSize(_repeated_packedFloat_codec); + size += packedDouble_.CalculateSize(_repeated_packedDouble_codec); + size += packedBool_.CalculateSize(_repeated_packedBool_codec); + size += packedNestedEnum_.CalculateSize(_repeated_packedNestedEnum_codec); + size += unpackedInt32_.CalculateSize(_repeated_unpackedInt32_codec); + size += unpackedInt64_.CalculateSize(_repeated_unpackedInt64_codec); + size += unpackedUint32_.CalculateSize(_repeated_unpackedUint32_codec); + size += unpackedUint64_.CalculateSize(_repeated_unpackedUint64_codec); + size += unpackedSint32_.CalculateSize(_repeated_unpackedSint32_codec); + size += unpackedSint64_.CalculateSize(_repeated_unpackedSint64_codec); + size += unpackedFixed32_.CalculateSize(_repeated_unpackedFixed32_codec); + size += unpackedFixed64_.CalculateSize(_repeated_unpackedFixed64_codec); + size += unpackedSfixed32_.CalculateSize(_repeated_unpackedSfixed32_codec); + size += unpackedSfixed64_.CalculateSize(_repeated_unpackedSfixed64_codec); + size += unpackedFloat_.CalculateSize(_repeated_unpackedFloat_codec); + size += unpackedDouble_.CalculateSize(_repeated_unpackedDouble_codec); + size += unpackedBool_.CalculateSize(_repeated_unpackedBool_codec); + size += unpackedNestedEnum_.CalculateSize(_repeated_unpackedNestedEnum_codec); size += mapInt32Int32_.CalculateSize(_map_mapInt32Int32_codec); size += mapInt64Int64_.CalculateSize(_map_mapInt64Int64_codec); size += mapUint32Uint32_.CalculateSize(_map_mapUint32Uint32_codec); @@ -2760,6 +3207,34 @@ namespace ProtobufTestMessages.Proto2 { repeatedForeignEnum_.Add(other.repeatedForeignEnum_); repeatedStringPiece_.Add(other.repeatedStringPiece_); repeatedCord_.Add(other.repeatedCord_); + packedInt32_.Add(other.packedInt32_); + packedInt64_.Add(other.packedInt64_); + packedUint32_.Add(other.packedUint32_); + packedUint64_.Add(other.packedUint64_); + packedSint32_.Add(other.packedSint32_); + packedSint64_.Add(other.packedSint64_); + packedFixed32_.Add(other.packedFixed32_); + packedFixed64_.Add(other.packedFixed64_); + packedSfixed32_.Add(other.packedSfixed32_); + packedSfixed64_.Add(other.packedSfixed64_); + packedFloat_.Add(other.packedFloat_); + packedDouble_.Add(other.packedDouble_); + packedBool_.Add(other.packedBool_); + packedNestedEnum_.Add(other.packedNestedEnum_); + unpackedInt32_.Add(other.unpackedInt32_); + unpackedInt64_.Add(other.unpackedInt64_); + unpackedUint32_.Add(other.unpackedUint32_); + unpackedUint64_.Add(other.unpackedUint64_); + unpackedSint32_.Add(other.unpackedSint32_); + unpackedSint64_.Add(other.unpackedSint64_); + unpackedFixed32_.Add(other.unpackedFixed32_); + unpackedFixed64_.Add(other.unpackedFixed64_); + unpackedSfixed32_.Add(other.unpackedSfixed32_); + unpackedSfixed64_.Add(other.unpackedSfixed64_); + unpackedFloat_.Add(other.unpackedFloat_); + unpackedDouble_.Add(other.unpackedDouble_); + unpackedBool_.Add(other.unpackedBool_); + unpackedNestedEnum_.Add(other.unpackedNestedEnum_); mapInt32Int32_.Add(other.mapInt32Int32_); mapInt64Int64_.Add(other.mapInt64Int64_); mapUint32Uint32_.Add(other.mapUint32Uint32_); @@ -3158,6 +3633,146 @@ namespace ProtobufTestMessages.Proto2 { mapStringForeignEnum_.AddEntriesFrom(input, _map_mapStringForeignEnum_codec); break; } + case 602: + case 600: { + packedInt32_.AddEntriesFrom(input, _repeated_packedInt32_codec); + break; + } + case 610: + case 608: { + packedInt64_.AddEntriesFrom(input, _repeated_packedInt64_codec); + break; + } + case 618: + case 616: { + packedUint32_.AddEntriesFrom(input, _repeated_packedUint32_codec); + break; + } + case 626: + case 624: { + packedUint64_.AddEntriesFrom(input, _repeated_packedUint64_codec); + break; + } + case 634: + case 632: { + packedSint32_.AddEntriesFrom(input, _repeated_packedSint32_codec); + break; + } + case 642: + case 640: { + packedSint64_.AddEntriesFrom(input, _repeated_packedSint64_codec); + break; + } + case 650: + case 653: { + packedFixed32_.AddEntriesFrom(input, _repeated_packedFixed32_codec); + break; + } + case 658: + case 657: { + packedFixed64_.AddEntriesFrom(input, _repeated_packedFixed64_codec); + break; + } + case 666: + case 669: { + packedSfixed32_.AddEntriesFrom(input, _repeated_packedSfixed32_codec); + break; + } + case 674: + case 673: { + packedSfixed64_.AddEntriesFrom(input, _repeated_packedSfixed64_codec); + break; + } + case 682: + case 685: { + packedFloat_.AddEntriesFrom(input, _repeated_packedFloat_codec); + break; + } + case 690: + case 689: { + packedDouble_.AddEntriesFrom(input, _repeated_packedDouble_codec); + break; + } + case 698: + case 696: { + packedBool_.AddEntriesFrom(input, _repeated_packedBool_codec); + break; + } + case 706: + case 704: { + packedNestedEnum_.AddEntriesFrom(input, _repeated_packedNestedEnum_codec); + break; + } + case 714: + case 712: { + unpackedInt32_.AddEntriesFrom(input, _repeated_unpackedInt32_codec); + break; + } + case 722: + case 720: { + unpackedInt64_.AddEntriesFrom(input, _repeated_unpackedInt64_codec); + break; + } + case 730: + case 728: { + unpackedUint32_.AddEntriesFrom(input, _repeated_unpackedUint32_codec); + break; + } + case 738: + case 736: { + unpackedUint64_.AddEntriesFrom(input, _repeated_unpackedUint64_codec); + break; + } + case 746: + case 744: { + unpackedSint32_.AddEntriesFrom(input, _repeated_unpackedSint32_codec); + break; + } + case 754: + case 752: { + unpackedSint64_.AddEntriesFrom(input, _repeated_unpackedSint64_codec); + break; + } + case 762: + case 765: { + unpackedFixed32_.AddEntriesFrom(input, _repeated_unpackedFixed32_codec); + break; + } + case 770: + case 769: { + unpackedFixed64_.AddEntriesFrom(input, _repeated_unpackedFixed64_codec); + break; + } + case 778: + case 781: { + unpackedSfixed32_.AddEntriesFrom(input, _repeated_unpackedSfixed32_codec); + break; + } + case 786: + case 785: { + unpackedSfixed64_.AddEntriesFrom(input, _repeated_unpackedSfixed64_codec); + break; + } + case 794: + case 797: { + unpackedFloat_.AddEntriesFrom(input, _repeated_unpackedFloat_codec); + break; + } + case 802: + case 801: { + unpackedDouble_.AddEntriesFrom(input, _repeated_unpackedDouble_codec); + break; + } + case 810: + case 808: { + unpackedBool_.AddEntriesFrom(input, _repeated_unpackedBool_codec); + break; + } + case 818: + case 816: { + unpackedNestedEnum_.AddEntriesFrom(input, _repeated_unpackedNestedEnum_codec); + break; + } case 888: { OneofUint32 = input.ReadUInt32(); break; diff --git a/csharp/src/Google.Protobuf.Test/testprotos.pb b/csharp/src/Google.Protobuf.Test/testprotos.pb index 95fe4f345ef9221eb2e0361657823b6aaf035bdb..4404d162585edd6847a228df006fd61c6bb483aa 100644 GIT binary patch delta 96935 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