Merge pull request #611 from jskeet/csharp-wrappers
C# wrapper types
diff --git a/BUILD b/BUILD
index 5177e43..5cfed33 100644
--- a/BUILD
+++ b/BUILD
@@ -162,10 +162,10 @@
"src/google/protobuf/compiler/cpp/cpp_string_field.cc",
"src/google/protobuf/compiler/csharp/csharp_enum.cc",
"src/google/protobuf/compiler/csharp/csharp_enum_field.cc",
- "src/google/protobuf/compiler/csharp/csharp_extension.cc",
"src/google/protobuf/compiler/csharp/csharp_field_base.cc",
"src/google/protobuf/compiler/csharp/csharp_generator.cc",
"src/google/protobuf/compiler/csharp/csharp_helpers.cc",
+ "src/google/protobuf/compiler/csharp/csharp_map_field.cc",
"src/google/protobuf/compiler/csharp/csharp_message.cc",
"src/google/protobuf/compiler/csharp/csharp_message_field.cc",
"src/google/protobuf/compiler/csharp/csharp_primitive_field.cc",
@@ -174,7 +174,7 @@
"src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc",
"src/google/protobuf/compiler/csharp/csharp_source_generator_base.cc",
"src/google/protobuf/compiler/csharp/csharp_umbrella_class.cc",
- "src/google/protobuf/compiler/csharp/csharp_writer.cc",
+ "src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc",
"src/google/protobuf/compiler/java/java_context.cc",
"src/google/protobuf/compiler/java/java_doc_comment.cc",
"src/google/protobuf/compiler/java/java_enum.cc",
diff --git a/cmake/libprotoc.cmake b/cmake/libprotoc.cmake
index 8bf0a1f..f8fa7ad 100644
--- a/cmake/libprotoc.cmake
+++ b/cmake/libprotoc.cmake
@@ -28,6 +28,7 @@
${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_repeated_primitive_field.cc
${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_source_generator_base.cc
${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_umbrella_class.cc
+ ${protobuf_source_dir}/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc
${protobuf_source_dir}/src/google/protobuf/compiler/java/java_context.cc
${protobuf_source_dir}/src/google/protobuf/compiler/java/java_doc_comment.cc
${protobuf_source_dir}/src/google/protobuf/compiler/java/java_enum.cc
diff --git a/csharp/generate_protos.sh b/csharp/generate_protos.sh
index b7f837e..7978166 100755
--- a/csharp/generate_protos.sh
+++ b/csharp/generate_protos.sh
@@ -58,7 +58,8 @@
src/google/protobuf/map_unittest_proto3.proto \
src/google/protobuf/unittest_proto3.proto \
src/google/protobuf/unittest_import_proto3.proto \
- src/google/protobuf/unittest_import_public_proto3.proto
+ src/google/protobuf/unittest_import_public_proto3.proto \
+ src/google/protobuf/unittest_well_known_types.proto
$PROTOC -Icsharp/protos/extest --csharp_out=csharp/src/ProtocolBuffers.Test/TestProtos \
diff --git a/csharp/src/ProtocolBuffers.Test/ByteStringTest.cs b/csharp/src/ProtocolBuffers.Test/ByteStringTest.cs
index dadd0d3..685e130 100644
--- a/csharp/src/ProtocolBuffers.Test/ByteStringTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/ByteStringTest.cs
@@ -39,6 +39,34 @@
public class ByteStringTest
{
[Test]
+ public void Equality()
+ {
+ ByteString b1 = ByteString.CopyFrom(1, 2, 3);
+ ByteString b2 = ByteString.CopyFrom(1, 2, 3);
+ ByteString b3 = ByteString.CopyFrom(1, 2, 4);
+ ByteString b4 = ByteString.CopyFrom(1, 2, 3, 4);
+ EqualityTester.AssertEquality(b1, b1);
+ EqualityTester.AssertEquality(b1, b2);
+ EqualityTester.AssertInequality(b1, b3);
+ EqualityTester.AssertInequality(b1, b4);
+ EqualityTester.AssertInequality(b1, null);
+#pragma warning disable 1718 // Deliberately calling ==(b1, b1) and !=(b1, b1)
+ Assert.IsTrue(b1 == b1);
+ Assert.IsTrue(b1 == b2);
+ Assert.IsFalse(b1 == b3);
+ Assert.IsFalse(b1 == b4);
+ Assert.IsFalse(b1 == null);
+ Assert.IsTrue((ByteString) null == null);
+ Assert.IsFalse(b1 != b1);
+ Assert.IsFalse(b1 != b2);
+#pragma warning disable 1718
+ Assert.IsTrue(b1 != b3);
+ Assert.IsTrue(b1 != b4);
+ Assert.IsTrue(b1 != null);
+ Assert.IsFalse((ByteString) null != null);
+ }
+
+ [Test]
public void EmptyByteStringHasZeroSize()
{
Assert.AreEqual(0, ByteString.Empty.Length);
diff --git a/csharp/src/ProtocolBuffers.Test/Collections/MapFieldTest.cs b/csharp/src/ProtocolBuffers.Test/Collections/MapFieldTest.cs
index d43bed3..46d3bd9 100644
--- a/csharp/src/ProtocolBuffers.Test/Collections/MapFieldTest.cs
+++ b/csharp/src/ProtocolBuffers.Test/Collections/MapFieldTest.cs
@@ -103,6 +103,31 @@
}
[Test]
+ public void NullValues()
+ {
+ TestNullValues<int?>(0);
+ TestNullValues("");
+ TestNullValues(new TestAllTypes());
+ }
+
+ private void TestNullValues<T>(T nonNullValue)
+ {
+ var map = new MapField<int, T>(false);
+ var nullValue = (T) (object) null;
+ Assert.Throws<ArgumentNullException>(() => map.Add(0, nullValue));
+ Assert.Throws<ArgumentNullException>(() => map[0] = nullValue);
+ map.Add(1, nonNullValue);
+ map[1] = nonNullValue;
+
+ // Doesn't throw...
+ map = new MapField<int, T>(true);
+ map.Add(0, nullValue);
+ map[0] = nullValue;
+ map.Add(1, nonNullValue);
+ map[1] = nonNullValue;
+ }
+
+ [Test]
public void Add_ForbidsNullKeys()
{
var map = new MapField<string, ForeignMessage>();
@@ -110,56 +135,12 @@
}
[Test]
- public void Add_AcceptsNullMessageValues()
- {
- var map = new MapField<string, ForeignMessage>();
- map.Add("missing", null);
- Assert.IsNull(map["missing"]);
- }
-
- [Test]
- public void Add_ForbidsNullStringValues()
- {
- var map = new MapField<string, string>();
- Assert.Throws<ArgumentNullException>(() => map.Add("missing", null));
- }
-
- [Test]
- public void Add_ForbidsNullByteStringValues()
- {
- var map = new MapField<string, ByteString>();
- Assert.Throws<ArgumentNullException>(() => map.Add("missing", null));
- }
-
- [Test]
public void Indexer_ForbidsNullKeys()
{
var map = new MapField<string, ForeignMessage>();
Assert.Throws<ArgumentNullException>(() => map[null] = new ForeignMessage());
}
-
- [Test]
- public void Indexer_AcceptsNullMessageValues()
- {
- var map = new MapField<string, ForeignMessage>();
- map["missing"] = null;
- Assert.IsNull(map["missing"]);
- }
-
- [Test]
- public void Indexer_ForbidsNullStringValues()
- {
- var map = new MapField<string, string>();
- Assert.Throws<ArgumentNullException>(() => map["missing"] = null);
- }
-
- [Test]
- public void Indexer_ForbidsNullByteStringValues()
- {
- var map = new MapField<string, ByteString>();
- Assert.Throws<ArgumentNullException>(() => map["missing"] = null);
- }
-
+
[Test]
public void AddPreservesInsertionOrder()
{
@@ -528,6 +509,30 @@
Assert.Throws<NotSupportedException>(() => dictionary["a"] = "c");
}
+ [Test]
+ public void AllowNullValues_Property()
+ {
+ // Non-message reference type values are non-nullable by default, but can be overridden
+ Assert.IsFalse(new MapField<int, string>().AllowsNullValues);
+ Assert.IsFalse(new MapField<int, string>(false).AllowsNullValues);
+ Assert.IsTrue(new MapField<int, string>(true).AllowsNullValues);
+
+ // Non-nullable value type values are never nullable
+ Assert.IsFalse(new MapField<int, int>().AllowsNullValues);
+ Assert.IsFalse(new MapField<int, int>(false).AllowsNullValues);
+ Assert.Throws<ArgumentException>(() => new MapField<int, int>(true));
+
+ // Message type values are nullable by default, but can be overridden
+ Assert.IsTrue(new MapField<int, TestAllTypes>().AllowsNullValues);
+ Assert.IsFalse(new MapField<int, TestAllTypes>(false).AllowsNullValues);
+ Assert.IsTrue(new MapField<int, TestAllTypes>(true).AllowsNullValues);
+
+ // Nullable value type values are nullable by default, but can be overridden
+ Assert.IsTrue(new MapField<int, int?>().AllowsNullValues);
+ Assert.IsFalse(new MapField<int, int?>(false).AllowsNullValues);
+ Assert.IsTrue(new MapField<int, int?>(true).AllowsNullValues);
+ }
+
private static KeyValuePair<TKey, TValue> NewKeyValuePair<TKey, TValue>(TKey key, TValue value)
{
return new KeyValuePair<TKey, TValue>(key, value);
diff --git a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
index 45c75ba..a425ad8 100644
--- a/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
+++ b/csharp/src/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj
@@ -93,6 +93,8 @@
<Compile Include="IssuesTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="TestCornerCases.cs" />
+ <Compile Include="TestProtos\UnittestWellKnownTypes.cs" />
+ <Compile Include="WellKnownTypes\WrappersTest.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
diff --git a/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestWellKnownTypes.cs b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestWellKnownTypes.cs
new file mode 100644
index 0000000..af7d83b
--- /dev/null
+++ b/csharp/src/ProtocolBuffers.Test/TestProtos/UnittestWellKnownTypes.cs
@@ -0,0 +1,2453 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: google/protobuf/unittest_well_known_types.proto
+#pragma warning disable 1591, 0612, 3021
+#region Designer generated code
+
+using pb = global::Google.Protobuf;
+using pbc = global::Google.Protobuf.Collections;
+using pbr = global::Google.Protobuf.Reflection;
+using scg = global::System.Collections.Generic;
+namespace Google.Protobuf.TestProtos {
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ public static partial class UnittestWellKnownTypes {
+
+ #region Static variables
+ internal static pbr::FieldAccessorTable internal__static_protobuf_unittest_TestWellKnownTypes__FieldAccessorTable;
+ internal static pbr::FieldAccessorTable internal__static_protobuf_unittest_RepeatedWellKnownTypes__FieldAccessorTable;
+ internal static pbr::FieldAccessorTable internal__static_protobuf_unittest_OneofWellKnownTypes__FieldAccessorTable;
+ internal static pbr::FieldAccessorTable internal__static_protobuf_unittest_MapWellKnownTypes__FieldAccessorTable;
+ #endregion
+ #region Descriptor
+ public static pbr::FileDescriptor Descriptor {
+ get { return descriptor; }
+ }
+ private static pbr::FileDescriptor descriptor;
+
+ static UnittestWellKnownTypes() {
+ byte[] descriptorData = global::System.Convert.FromBase64String(
+ string.Concat(
+ "Ci9nb29nbGUvcHJvdG9idWYvdW5pdHRlc3Rfd2VsbF9rbm93bl90eXBlcy5w",
+ "cm90bxIRcHJvdG9idWZfdW5pdHRlc3QaGWdvb2dsZS9wcm90b2J1Zi9hbnku",
+ "cHJvdG8aGWdvb2dsZS9wcm90b2J1Zi9hcGkucHJvdG8aHmdvb2dsZS9wcm90",
+ "b2J1Zi9kdXJhdGlvbi5wcm90bxobZ29vZ2xlL3Byb3RvYnVmL2VtcHR5LnBy",
+ "b3RvGiBnb29nbGUvcHJvdG9idWYvZmllbGRfbWFzay5wcm90bxokZ29vZ2xl",
+ "L3Byb3RvYnVmL3NvdXJjZV9jb250ZXh0LnByb3RvGhxnb29nbGUvcHJvdG9i",
+ "dWYvc3RydWN0LnByb3RvGh9nb29nbGUvcHJvdG9idWYvdGltZXN0YW1wLnBy",
+ "b3RvGhpnb29nbGUvcHJvdG9idWYvdHlwZS5wcm90bxoeZ29vZ2xlL3Byb3Rv",
+ "YnVmL3dyYXBwZXJzLnByb3RvIpEHChJUZXN0V2VsbEtub3duVHlwZXMSJwoJ",
+ "YW55X2ZpZWxkGAEgASgLMhQuZ29vZ2xlLnByb3RvYnVmLkFueRInCglhcGlf",
+ "ZmllbGQYAiABKAsyFC5nb29nbGUucHJvdG9idWYuQXBpEjEKDmR1cmF0aW9u",
+ "X2ZpZWxkGAMgASgLMhkuZ29vZ2xlLnByb3RvYnVmLkR1cmF0aW9uEisKC2Vt",
+ "cHR5X2ZpZWxkGAQgASgLMhYuZ29vZ2xlLnByb3RvYnVmLkVtcHR5EjQKEGZp",
+ "ZWxkX21hc2tfZmllbGQYBSABKAsyGi5nb29nbGUucHJvdG9idWYuRmllbGRN",
+ "YXNrEjwKFHNvdXJjZV9jb250ZXh0X2ZpZWxkGAYgASgLMh4uZ29vZ2xlLnBy",
+ "b3RvYnVmLlNvdXJjZUNvbnRleHQSLQoMc3RydWN0X2ZpZWxkGAcgASgLMhcu",
+ "Z29vZ2xlLnByb3RvYnVmLlN0cnVjdBIzCg90aW1lc3RhbXBfZmllbGQYCCAB",
+ "KAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEikKCnR5cGVfZmllbGQY",
+ "CSABKAsyFS5nb29nbGUucHJvdG9idWYuVHlwZRIyCgxkb3VibGVfZmllbGQY",
+ "CiABKAsyHC5nb29nbGUucHJvdG9idWYuRG91YmxlVmFsdWUSMAoLZmxvYXRf",
+ "ZmllbGQYCyABKAsyGy5nb29nbGUucHJvdG9idWYuRmxvYXRWYWx1ZRIwCgtp",
+ "bnQ2NF9maWVsZBgMIAEoCzIbLmdvb2dsZS5wcm90b2J1Zi5JbnQ2NFZhbHVl",
+ "EjIKDHVpbnQ2NF9maWVsZBgNIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5VSW50",
+ "NjRWYWx1ZRIwCgtpbnQzMl9maWVsZBgOIAEoCzIbLmdvb2dsZS5wcm90b2J1",
+ "Zi5JbnQzMlZhbHVlEjIKDHVpbnQzMl9maWVsZBgPIAEoCzIcLmdvb2dsZS5w",
+ "cm90b2J1Zi5VSW50MzJWYWx1ZRIuCgpib29sX2ZpZWxkGBAgASgLMhouZ29v",
+ "Z2xlLnByb3RvYnVmLkJvb2xWYWx1ZRIyCgxzdHJpbmdfZmllbGQYESABKAsy",
+ "HC5nb29nbGUucHJvdG9idWYuU3RyaW5nVmFsdWUSMAoLYnl0ZXNfZmllbGQY",
+ "EiABKAsyGy5nb29nbGUucHJvdG9idWYuQnl0ZXNWYWx1ZSKVBwoWUmVwZWF0",
+ "ZWRXZWxsS25vd25UeXBlcxInCglhbnlfZmllbGQYASADKAsyFC5nb29nbGUu",
+ "cHJvdG9idWYuQW55EicKCWFwaV9maWVsZBgCIAMoCzIULmdvb2dsZS5wcm90",
+ "b2J1Zi5BcGkSMQoOZHVyYXRpb25fZmllbGQYAyADKAsyGS5nb29nbGUucHJv",
+ "dG9idWYuRHVyYXRpb24SKwoLZW1wdHlfZmllbGQYBCADKAsyFi5nb29nbGUu",
+ "cHJvdG9idWYuRW1wdHkSNAoQZmllbGRfbWFza19maWVsZBgFIAMoCzIaLmdv",
+ "b2dsZS5wcm90b2J1Zi5GaWVsZE1hc2sSPAoUc291cmNlX2NvbnRleHRfZmll",
+ "bGQYBiADKAsyHi5nb29nbGUucHJvdG9idWYuU291cmNlQ29udGV4dBItCgxz",
+ "dHJ1Y3RfZmllbGQYByADKAsyFy5nb29nbGUucHJvdG9idWYuU3RydWN0EjMK",
+ "D3RpbWVzdGFtcF9maWVsZBgIIAMoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1l",
+ "c3RhbXASKQoKdHlwZV9maWVsZBgJIAMoCzIVLmdvb2dsZS5wcm90b2J1Zi5U",
+ "eXBlEjIKDGRvdWJsZV9maWVsZBgKIAMoCzIcLmdvb2dsZS5wcm90b2J1Zi5E",
+ "b3VibGVWYWx1ZRIwCgtmbG9hdF9maWVsZBgLIAMoCzIbLmdvb2dsZS5wcm90",
+ "b2J1Zi5GbG9hdFZhbHVlEjAKC2ludDY0X2ZpZWxkGAwgAygLMhsuZ29vZ2xl",
+ "LnByb3RvYnVmLkludDY0VmFsdWUSMgoMdWludDY0X2ZpZWxkGA0gAygLMhwu",
+ "Z29vZ2xlLnByb3RvYnVmLlVJbnQ2NFZhbHVlEjAKC2ludDMyX2ZpZWxkGA4g",
+ "AygLMhsuZ29vZ2xlLnByb3RvYnVmLkludDMyVmFsdWUSMgoMdWludDMyX2Zp",
+ "ZWxkGA8gAygLMhwuZ29vZ2xlLnByb3RvYnVmLlVJbnQzMlZhbHVlEi4KCmJv",
+ "b2xfZmllbGQYECADKAsyGi5nb29nbGUucHJvdG9idWYuQm9vbFZhbHVlEjIK",
+ "DHN0cmluZ19maWVsZBgRIAMoCzIcLmdvb2dsZS5wcm90b2J1Zi5TdHJpbmdW",
+ "YWx1ZRIwCgtieXRlc19maWVsZBgSIAMoCzIbLmdvb2dsZS5wcm90b2J1Zi5C",
+ "eXRlc1ZhbHVlIsUHChNPbmVvZldlbGxLbm93blR5cGVzEikKCWFueV9maWVs",
+ "ZBgBIAEoCzIULmdvb2dsZS5wcm90b2J1Zi5BbnlIABIpCglhcGlfZmllbGQY",
+ "AiABKAsyFC5nb29nbGUucHJvdG9idWYuQXBpSAASMwoOZHVyYXRpb25fZmll",
+ "bGQYAyABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb25IABItCgtlbXB0",
+ "eV9maWVsZBgEIAEoCzIWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eUgAEjYKEGZp",
+ "ZWxkX21hc2tfZmllbGQYBSABKAsyGi5nb29nbGUucHJvdG9idWYuRmllbGRN",
+ "YXNrSAASPgoUc291cmNlX2NvbnRleHRfZmllbGQYBiABKAsyHi5nb29nbGUu",
+ "cHJvdG9idWYuU291cmNlQ29udGV4dEgAEi8KDHN0cnVjdF9maWVsZBgHIAEo",
+ "CzIXLmdvb2dsZS5wcm90b2J1Zi5TdHJ1Y3RIABI1Cg90aW1lc3RhbXBfZmll",
+ "bGQYCCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wSAASKwoKdHlw",
+ "ZV9maWVsZBgJIAEoCzIVLmdvb2dsZS5wcm90b2J1Zi5UeXBlSAASNAoMZG91",
+ "YmxlX2ZpZWxkGAogASgLMhwuZ29vZ2xlLnByb3RvYnVmLkRvdWJsZVZhbHVl",
+ "SAASMgoLZmxvYXRfZmllbGQYCyABKAsyGy5nb29nbGUucHJvdG9idWYuRmxv",
+ "YXRWYWx1ZUgAEjIKC2ludDY0X2ZpZWxkGAwgASgLMhsuZ29vZ2xlLnByb3Rv",
+ "YnVmLkludDY0VmFsdWVIABI0Cgx1aW50NjRfZmllbGQYDSABKAsyHC5nb29n",
+ "bGUucHJvdG9idWYuVUludDY0VmFsdWVIABIyCgtpbnQzMl9maWVsZBgOIAEo",
+ "CzIbLmdvb2dsZS5wcm90b2J1Zi5JbnQzMlZhbHVlSAASNAoMdWludDMyX2Zp",
+ "ZWxkGA8gASgLMhwuZ29vZ2xlLnByb3RvYnVmLlVJbnQzMlZhbHVlSAASMAoK",
+ "Ym9vbF9maWVsZBgQIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5Cb29sVmFsdWVI",
+ "ABI0CgxzdHJpbmdfZmllbGQYESABKAsyHC5nb29nbGUucHJvdG9idWYuU3Ry",
+ "aW5nVmFsdWVIABIyCgtieXRlc19maWVsZBgSIAEoCzIbLmdvb2dsZS5wcm90",
+ "b2J1Zi5CeXRlc1ZhbHVlSABCDQoLb25lb2ZfZmllbGQilhYKEU1hcFdlbGxL",
+ "bm93blR5cGVzEkUKCWFueV9maWVsZBgBIAMoCzIyLnByb3RvYnVmX3VuaXR0",
+ "ZXN0Lk1hcFdlbGxLbm93blR5cGVzLkFueUZpZWxkRW50cnkSRQoJYXBpX2Zp",
+ "ZWxkGAIgAygLMjIucHJvdG9idWZfdW5pdHRlc3QuTWFwV2VsbEtub3duVHlw",
+ "ZXMuQXBpRmllbGRFbnRyeRJPCg5kdXJhdGlvbl9maWVsZBgDIAMoCzI3LnBy",
+ "b3RvYnVmX3VuaXR0ZXN0Lk1hcFdlbGxLbm93blR5cGVzLkR1cmF0aW9uRmll",
+ "bGRFbnRyeRJJCgtlbXB0eV9maWVsZBgEIAMoCzI0LnByb3RvYnVmX3VuaXR0",
+ "ZXN0Lk1hcFdlbGxLbm93blR5cGVzLkVtcHR5RmllbGRFbnRyeRJSChBmaWVs",
+ "ZF9tYXNrX2ZpZWxkGAUgAygLMjgucHJvdG9idWZfdW5pdHRlc3QuTWFwV2Vs",
+ "bEtub3duVHlwZXMuRmllbGRNYXNrRmllbGRFbnRyeRJaChRzb3VyY2VfY29u",
+ "dGV4dF9maWVsZBgGIAMoCzI8LnByb3RvYnVmX3VuaXR0ZXN0Lk1hcFdlbGxL",
+ "bm93blR5cGVzLlNvdXJjZUNvbnRleHRGaWVsZEVudHJ5EksKDHN0cnVjdF9m",
+ "aWVsZBgHIAMoCzI1LnByb3RvYnVmX3VuaXR0ZXN0Lk1hcFdlbGxLbm93blR5",
+ "cGVzLlN0cnVjdEZpZWxkRW50cnkSUQoPdGltZXN0YW1wX2ZpZWxkGAggAygL",
+ "MjgucHJvdG9idWZfdW5pdHRlc3QuTWFwV2VsbEtub3duVHlwZXMuVGltZXN0",
+ "YW1wRmllbGRFbnRyeRJHCgp0eXBlX2ZpZWxkGAkgAygLMjMucHJvdG9idWZf",
+ "dW5pdHRlc3QuTWFwV2VsbEtub3duVHlwZXMuVHlwZUZpZWxkRW50cnkSSwoM",
+ "ZG91YmxlX2ZpZWxkGAogAygLMjUucHJvdG9idWZfdW5pdHRlc3QuTWFwV2Vs",
+ "bEtub3duVHlwZXMuRG91YmxlRmllbGRFbnRyeRJJCgtmbG9hdF9maWVsZBgL",
+ "IAMoCzI0LnByb3RvYnVmX3VuaXR0ZXN0Lk1hcFdlbGxLbm93blR5cGVzLkZs",
+ "b2F0RmllbGRFbnRyeRJJCgtpbnQ2NF9maWVsZBgMIAMoCzI0LnByb3RvYnVm",
+ "X3VuaXR0ZXN0Lk1hcFdlbGxLbm93blR5cGVzLkludDY0RmllbGRFbnRyeRJL",
+ "Cgx1aW50NjRfZmllbGQYDSADKAsyNS5wcm90b2J1Zl91bml0dGVzdC5NYXBX",
+ "ZWxsS25vd25UeXBlcy5VaW50NjRGaWVsZEVudHJ5EkkKC2ludDMyX2ZpZWxk",
+ "GA4gAygLMjQucHJvdG9idWZfdW5pdHRlc3QuTWFwV2VsbEtub3duVHlwZXMu",
+ "SW50MzJGaWVsZEVudHJ5EksKDHVpbnQzMl9maWVsZBgPIAMoCzI1LnByb3Rv",
+ "YnVmX3VuaXR0ZXN0Lk1hcFdlbGxLbm93blR5cGVzLlVpbnQzMkZpZWxkRW50",
+ "cnkSRwoKYm9vbF9maWVsZBgQIAMoCzIzLnByb3RvYnVmX3VuaXR0ZXN0Lk1h",
+ "cFdlbGxLbm93blR5cGVzLkJvb2xGaWVsZEVudHJ5EksKDHN0cmluZ19maWVs",
+ "ZBgRIAMoCzI1LnByb3RvYnVmX3VuaXR0ZXN0Lk1hcFdlbGxLbm93blR5cGVz",
+ "LlN0cmluZ0ZpZWxkRW50cnkSSQoLYnl0ZXNfZmllbGQYEiADKAsyNC5wcm90",
+ "b2J1Zl91bml0dGVzdC5NYXBXZWxsS25vd25UeXBlcy5CeXRlc0ZpZWxkRW50",
+ "cnkaRQoNQW55RmllbGRFbnRyeRILCgNrZXkYASABKAUSIwoFdmFsdWUYAiAB",
+ "KAsyFC5nb29nbGUucHJvdG9idWYuQW55OgI4ARpFCg1BcGlGaWVsZEVudHJ5",
+ "EgsKA2tleRgBIAEoBRIjCgV2YWx1ZRgCIAEoCzIULmdvb2dsZS5wcm90b2J1",
+ "Zi5BcGk6AjgBGk8KEkR1cmF0aW9uRmllbGRFbnRyeRILCgNrZXkYASABKAUS",
+ "KAoFdmFsdWUYAiABKAsyGS5nb29nbGUucHJvdG9idWYuRHVyYXRpb246AjgB",
+ "GkkKD0VtcHR5RmllbGRFbnRyeRILCgNrZXkYASABKAUSJQoFdmFsdWUYAiAB",
+ "KAsyFi5nb29nbGUucHJvdG9idWYuRW1wdHk6AjgBGlEKE0ZpZWxkTWFza0Zp",
+ "ZWxkRW50cnkSCwoDa2V5GAEgASgFEikKBXZhbHVlGAIgASgLMhouZ29vZ2xl",
+ "LnByb3RvYnVmLkZpZWxkTWFzazoCOAEaWQoXU291cmNlQ29udGV4dEZpZWxk",
+ "RW50cnkSCwoDa2V5GAEgASgFEi0KBXZhbHVlGAIgASgLMh4uZ29vZ2xlLnBy",
+ "b3RvYnVmLlNvdXJjZUNvbnRleHQ6AjgBGksKEFN0cnVjdEZpZWxkRW50cnkS",
+ "CwoDa2V5GAEgASgFEiYKBXZhbHVlGAIgASgLMhcuZ29vZ2xlLnByb3RvYnVm",
+ "LlN0cnVjdDoCOAEaUQoTVGltZXN0YW1wRmllbGRFbnRyeRILCgNrZXkYASAB",
+ "KAUSKQoFdmFsdWUYAiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1w",
+ "OgI4ARpHCg5UeXBlRmllbGRFbnRyeRILCgNrZXkYASABKAUSJAoFdmFsdWUY",
+ "AiABKAsyFS5nb29nbGUucHJvdG9idWYuVHlwZToCOAEaUAoQRG91YmxlRmll",
+ "bGRFbnRyeRILCgNrZXkYASABKAUSKwoFdmFsdWUYAiABKAsyHC5nb29nbGUu",
+ "cHJvdG9idWYuRG91YmxlVmFsdWU6AjgBGk4KD0Zsb2F0RmllbGRFbnRyeRIL",
+ "CgNrZXkYASABKAUSKgoFdmFsdWUYAiABKAsyGy5nb29nbGUucHJvdG9idWYu",
+ "RmxvYXRWYWx1ZToCOAEaTgoPSW50NjRGaWVsZEVudHJ5EgsKA2tleRgBIAEo",
+ "BRIqCgV2YWx1ZRgCIAEoCzIbLmdvb2dsZS5wcm90b2J1Zi5JbnQ2NFZhbHVl",
+ "OgI4ARpQChBVaW50NjRGaWVsZEVudHJ5EgsKA2tleRgBIAEoBRIrCgV2YWx1",
+ "ZRgCIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5VSW50NjRWYWx1ZToCOAEaTgoP",
+ "SW50MzJGaWVsZEVudHJ5EgsKA2tleRgBIAEoBRIqCgV2YWx1ZRgCIAEoCzIb",
+ "Lmdvb2dsZS5wcm90b2J1Zi5JbnQzMlZhbHVlOgI4ARpQChBVaW50MzJGaWVs",
+ "ZEVudHJ5EgsKA2tleRgBIAEoBRIrCgV2YWx1ZRgCIAEoCzIcLmdvb2dsZS5w",
+ "cm90b2J1Zi5VSW50MzJWYWx1ZToCOAEaTAoOQm9vbEZpZWxkRW50cnkSCwoD",
+ "a2V5GAEgASgFEikKBXZhbHVlGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLkJv",
+ "b2xWYWx1ZToCOAEaUAoQU3RyaW5nRmllbGRFbnRyeRILCgNrZXkYASABKAUS",
+ "KwoFdmFsdWUYAiABKAsyHC5nb29nbGUucHJvdG9idWYuU3RyaW5nVmFsdWU6",
+ "AjgBGk4KD0J5dGVzRmllbGRFbnRyeRILCgNrZXkYASABKAUSKgoFdmFsdWUY",
+ "AiABKAsyGy5nb29nbGUucHJvdG9idWYuQnl0ZXNWYWx1ZToCOAFCOQoYY29t",
+ "Lmdvb2dsZS5wcm90b2J1Zi50ZXN0UAGqAhpHb29nbGUuUHJvdG9idWYuVGVz",
+ "dFByb3Rvc2IGcHJvdG8z"));
+ descriptor = pbr::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
+ new pbr::FileDescriptor[] {
+ global::Google.Protobuf.WellKnownTypes.Proto.Any.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Proto.Api.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Proto.Duration.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Proto.Empty.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Proto.FieldMask.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Proto.SourceContext.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Proto.Struct.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Proto.Timestamp.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Proto.Type.Descriptor,
+ global::Google.Protobuf.WellKnownTypes.Wrappers.Descriptor,
+ });
+ internal__static_protobuf_unittest_TestWellKnownTypes__FieldAccessorTable =
+ new pbr::FieldAccessorTable(typeof(global::Google.Protobuf.TestProtos.TestWellKnownTypes), descriptor.MessageTypes[0],
+ new string[] { "AnyField", "ApiField", "DurationField", "EmptyField", "FieldMaskField", "SourceContextField", "StructField", "TimestampField", "TypeField", "DoubleField", "FloatField", "Int64Field", "Uint64Field", "Int32Field", "Uint32Field", "BoolField", "StringField", "BytesField", }, new string[] { });
+ internal__static_protobuf_unittest_RepeatedWellKnownTypes__FieldAccessorTable =
+ new pbr::FieldAccessorTable(typeof(global::Google.Protobuf.TestProtos.RepeatedWellKnownTypes), descriptor.MessageTypes[1],
+ new string[] { "AnyField", "ApiField", "DurationField", "EmptyField", "FieldMaskField", "SourceContextField", "StructField", "TimestampField", "TypeField", "DoubleField", "FloatField", "Int64Field", "Uint64Field", "Int32Field", "Uint32Field", "BoolField", "StringField", "BytesField", }, new string[] { });
+ internal__static_protobuf_unittest_OneofWellKnownTypes__FieldAccessorTable =
+ new pbr::FieldAccessorTable(typeof(global::Google.Protobuf.TestProtos.OneofWellKnownTypes), descriptor.MessageTypes[2],
+ new string[] { "AnyField", "ApiField", "DurationField", "EmptyField", "FieldMaskField", "SourceContextField", "StructField", "TimestampField", "TypeField", "DoubleField", "FloatField", "Int64Field", "Uint64Field", "Int32Field", "Uint32Field", "BoolField", "StringField", "BytesField", }, new string[] { "OneofField", });
+ internal__static_protobuf_unittest_MapWellKnownTypes__FieldAccessorTable =
+ new pbr::FieldAccessorTable(typeof(global::Google.Protobuf.TestProtos.MapWellKnownTypes), descriptor.MessageTypes[3],
+ new string[] { "AnyField", "ApiField", "DurationField", "EmptyField", "FieldMaskField", "SourceContextField", "StructField", "TimestampField", "TypeField", "DoubleField", "FloatField", "Int64Field", "Uint64Field", "Int32Field", "Uint32Field", "BoolField", "StringField", "BytesField", }, new string[] { });
+ }
+ #endregion
+
+ }
+ #region Messages
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ public sealed partial class TestWellKnownTypes : pb::IMessage<TestWellKnownTypes> {
+ private static readonly pb::MessageParser<TestWellKnownTypes> _parser = new pb::MessageParser<TestWellKnownTypes>(() => new TestWellKnownTypes());
+ public static pb::MessageParser<TestWellKnownTypes> Parser { get { return _parser; } }
+
+ private static readonly string[] _fieldNames = new string[] { "any_field", "api_field", "bool_field", "bytes_field", "double_field", "duration_field", "empty_field", "field_mask_field", "float_field", "int32_field", "int64_field", "source_context_field", "string_field", "struct_field", "timestamp_field", "type_field", "uint32_field", "uint64_field" };
+ private static readonly uint[] _fieldTags = new uint[] { 10, 18, 130, 146, 82, 26, 34, 42, 90, 114, 98, 50, 138, 58, 66, 74, 122, 106 };
+ public static pbr::MessageDescriptor Descriptor {
+ get { return global::Google.Protobuf.TestProtos.UnittestWellKnownTypes.Descriptor.MessageTypes[0]; }
+ }
+
+ pbr::FieldAccessorTable pb::IReflectedMessage.Fields {
+ get { return global::Google.Protobuf.TestProtos.UnittestWellKnownTypes.internal__static_protobuf_unittest_TestWellKnownTypes__FieldAccessorTable; }
+ }
+
+ private bool _frozen = false;
+ public bool IsFrozen { get { return _frozen; } }
+
+ public TestWellKnownTypes() {
+ OnConstruction();
+ }
+
+ partial void OnConstruction();
+
+ public TestWellKnownTypes(TestWellKnownTypes other) : this() {
+ AnyField = other.anyField_ != null ? other.AnyField.Clone() : null;
+ ApiField = other.apiField_ != null ? other.ApiField.Clone() : null;
+ DurationField = other.durationField_ != null ? other.DurationField.Clone() : null;
+ EmptyField = other.emptyField_ != null ? other.EmptyField.Clone() : null;
+ FieldMaskField = other.fieldMaskField_ != null ? other.FieldMaskField.Clone() : null;
+ SourceContextField = other.sourceContextField_ != null ? other.SourceContextField.Clone() : null;
+ StructField = other.structField_ != null ? other.StructField.Clone() : null;
+ TimestampField = other.timestampField_ != null ? other.TimestampField.Clone() : null;
+ TypeField = other.typeField_ != null ? other.TypeField.Clone() : null;
+ DoubleField = other.DoubleField;
+ FloatField = other.FloatField;
+ Int64Field = other.Int64Field;
+ Uint64Field = other.Uint64Field;
+ Int32Field = other.Int32Field;
+ Uint32Field = other.Uint32Field;
+ BoolField = other.BoolField;
+ StringField = other.StringField;
+ BytesField = other.BytesField;
+ }
+
+ public TestWellKnownTypes Clone() {
+ return new TestWellKnownTypes(this);
+ }
+
+ public void Freeze() {
+ if (IsFrozen) {
+ return;
+ }
+ _frozen = true;
+ if (anyField_ != null) AnyField.Freeze();
+ if (apiField_ != null) ApiField.Freeze();
+ if (durationField_ != null) DurationField.Freeze();
+ if (emptyField_ != null) EmptyField.Freeze();
+ if (fieldMaskField_ != null) FieldMaskField.Freeze();
+ if (sourceContextField_ != null) SourceContextField.Freeze();
+ if (structField_ != null) StructField.Freeze();
+ if (timestampField_ != null) TimestampField.Freeze();
+ if (typeField_ != null) TypeField.Freeze();
+ }
+
+ public const int AnyFieldFieldNumber = 1;
+ private global::Google.Protobuf.WellKnownTypes.Any anyField_;
+ public global::Google.Protobuf.WellKnownTypes.Any AnyField {
+ get { return anyField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ anyField_ = value;
+ }
+ }
+
+ public const int ApiFieldFieldNumber = 2;
+ private global::Google.Protobuf.WellKnownTypes.Api apiField_;
+ public global::Google.Protobuf.WellKnownTypes.Api ApiField {
+ get { return apiField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ apiField_ = value;
+ }
+ }
+
+ public const int DurationFieldFieldNumber = 3;
+ private global::Google.Protobuf.WellKnownTypes.Duration durationField_;
+ public global::Google.Protobuf.WellKnownTypes.Duration DurationField {
+ get { return durationField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ durationField_ = value;
+ }
+ }
+
+ public const int EmptyFieldFieldNumber = 4;
+ private global::Google.Protobuf.WellKnownTypes.Empty emptyField_;
+ public global::Google.Protobuf.WellKnownTypes.Empty EmptyField {
+ get { return emptyField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ emptyField_ = value;
+ }
+ }
+
+ public const int FieldMaskFieldFieldNumber = 5;
+ private global::Google.Protobuf.WellKnownTypes.FieldMask fieldMaskField_;
+ public global::Google.Protobuf.WellKnownTypes.FieldMask FieldMaskField {
+ get { return fieldMaskField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ fieldMaskField_ = value;
+ }
+ }
+
+ public const int SourceContextFieldFieldNumber = 6;
+ private global::Google.Protobuf.WellKnownTypes.SourceContext sourceContextField_;
+ public global::Google.Protobuf.WellKnownTypes.SourceContext SourceContextField {
+ get { return sourceContextField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ sourceContextField_ = value;
+ }
+ }
+
+ public const int StructFieldFieldNumber = 7;
+ private global::Google.Protobuf.WellKnownTypes.Struct structField_;
+ public global::Google.Protobuf.WellKnownTypes.Struct StructField {
+ get { return structField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ structField_ = value;
+ }
+ }
+
+ public const int TimestampFieldFieldNumber = 8;
+ private global::Google.Protobuf.WellKnownTypes.Timestamp timestampField_;
+ public global::Google.Protobuf.WellKnownTypes.Timestamp TimestampField {
+ get { return timestampField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ timestampField_ = value;
+ }
+ }
+
+ public const int TypeFieldFieldNumber = 9;
+ private global::Google.Protobuf.WellKnownTypes.Type typeField_;
+ public global::Google.Protobuf.WellKnownTypes.Type TypeField {
+ get { return typeField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ typeField_ = value;
+ }
+ }
+
+ public const int DoubleFieldFieldNumber = 10;
+ private static readonly pb::FieldCodec<double?> _single_doubleField_codec = pb::FieldCodec.ForStructWrapper<double>(82);
+ private double? doubleField_;
+ public double? DoubleField {
+ get { return doubleField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ doubleField_ = value;
+ }
+ }
+
+ public const int FloatFieldFieldNumber = 11;
+ private static readonly pb::FieldCodec<float?> _single_floatField_codec = pb::FieldCodec.ForStructWrapper<float>(90);
+ private float? floatField_;
+ public float? FloatField {
+ get { return floatField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ floatField_ = value;
+ }
+ }
+
+ public const int Int64FieldFieldNumber = 12;
+ private static readonly pb::FieldCodec<long?> _single_int64Field_codec = pb::FieldCodec.ForStructWrapper<long>(98);
+ private long? int64Field_;
+ public long? Int64Field {
+ get { return int64Field_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ int64Field_ = value;
+ }
+ }
+
+ public const int Uint64FieldFieldNumber = 13;
+ private static readonly pb::FieldCodec<ulong?> _single_uint64Field_codec = pb::FieldCodec.ForStructWrapper<ulong>(106);
+ private ulong? uint64Field_;
+ public ulong? Uint64Field {
+ get { return uint64Field_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ uint64Field_ = value;
+ }
+ }
+
+ public const int Int32FieldFieldNumber = 14;
+ private static readonly pb::FieldCodec<int?> _single_int32Field_codec = pb::FieldCodec.ForStructWrapper<int>(114);
+ private int? int32Field_;
+ public int? Int32Field {
+ get { return int32Field_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ int32Field_ = value;
+ }
+ }
+
+ public const int Uint32FieldFieldNumber = 15;
+ private static readonly pb::FieldCodec<uint?> _single_uint32Field_codec = pb::FieldCodec.ForStructWrapper<uint>(122);
+ private uint? uint32Field_;
+ public uint? Uint32Field {
+ get { return uint32Field_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ uint32Field_ = value;
+ }
+ }
+
+ public const int BoolFieldFieldNumber = 16;
+ private static readonly pb::FieldCodec<bool?> _single_boolField_codec = pb::FieldCodec.ForStructWrapper<bool>(130);
+ private bool? boolField_;
+ public bool? BoolField {
+ get { return boolField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ boolField_ = value;
+ }
+ }
+
+ public const int StringFieldFieldNumber = 17;
+ private static readonly pb::FieldCodec<string> _single_stringField_codec = pb::FieldCodec.ForClassWrapper<string>(138);
+ private string stringField_;
+ public string StringField {
+ get { return stringField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ stringField_ = value;
+ }
+ }
+
+ public const int BytesFieldFieldNumber = 18;
+ private static readonly pb::FieldCodec<pb::ByteString> _single_bytesField_codec = pb::FieldCodec.ForClassWrapper<pb::ByteString>(146);
+ private pb::ByteString bytesField_;
+ public pb::ByteString BytesField {
+ get { return bytesField_; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ bytesField_ = value;
+ }
+ }
+
+ public override bool Equals(object other) {
+ return Equals(other as TestWellKnownTypes);
+ }
+
+ public bool Equals(TestWellKnownTypes other) {
+ if (ReferenceEquals(other, null)) {
+ return false;
+ }
+ if (ReferenceEquals(other, this)) {
+ return true;
+ }
+ if (!object.Equals(AnyField, other.AnyField)) return false;
+ if (!object.Equals(ApiField, other.ApiField)) return false;
+ if (!object.Equals(DurationField, other.DurationField)) return false;
+ if (!object.Equals(EmptyField, other.EmptyField)) return false;
+ if (!object.Equals(FieldMaskField, other.FieldMaskField)) return false;
+ if (!object.Equals(SourceContextField, other.SourceContextField)) return false;
+ if (!object.Equals(StructField, other.StructField)) return false;
+ if (!object.Equals(TimestampField, other.TimestampField)) return false;
+ if (!object.Equals(TypeField, other.TypeField)) return false;
+ if (DoubleField != other.DoubleField) return false;
+ if (FloatField != other.FloatField) return false;
+ if (Int64Field != other.Int64Field) return false;
+ if (Uint64Field != other.Uint64Field) return false;
+ if (Int32Field != other.Int32Field) return false;
+ if (Uint32Field != other.Uint32Field) return false;
+ if (BoolField != other.BoolField) return false;
+ if (StringField != other.StringField) return false;
+ if (BytesField != other.BytesField) return false;
+ return true;
+ }
+
+ public override int GetHashCode() {
+ int hash = 1;
+ if (anyField_ != null) hash ^= AnyField.GetHashCode();
+ if (apiField_ != null) hash ^= ApiField.GetHashCode();
+ if (durationField_ != null) hash ^= DurationField.GetHashCode();
+ if (emptyField_ != null) hash ^= EmptyField.GetHashCode();
+ if (fieldMaskField_ != null) hash ^= FieldMaskField.GetHashCode();
+ if (sourceContextField_ != null) hash ^= SourceContextField.GetHashCode();
+ if (structField_ != null) hash ^= StructField.GetHashCode();
+ if (timestampField_ != null) hash ^= TimestampField.GetHashCode();
+ if (typeField_ != null) hash ^= TypeField.GetHashCode();
+ if (doubleField_ != null) hash ^= DoubleField.GetHashCode();
+ if (floatField_ != null) hash ^= FloatField.GetHashCode();
+ if (int64Field_ != null) hash ^= Int64Field.GetHashCode();
+ if (uint64Field_ != null) hash ^= Uint64Field.GetHashCode();
+ if (int32Field_ != null) hash ^= Int32Field.GetHashCode();
+ if (uint32Field_ != null) hash ^= Uint32Field.GetHashCode();
+ if (boolField_ != null) hash ^= BoolField.GetHashCode();
+ if (stringField_ != null) hash ^= StringField.GetHashCode();
+ if (bytesField_ != null) hash ^= BytesField.GetHashCode();
+ return hash;
+ }
+
+ public override string ToString() {
+ return pb::JsonFormatter.Default.Format(this);
+ }
+
+ public void WriteTo(pb::CodedOutputStream output) {
+ if (anyField_ != null) {
+ output.WriteRawTag(10);
+ output.WriteMessage(AnyField);
+ }
+ if (apiField_ != null) {
+ output.WriteRawTag(18);
+ output.WriteMessage(ApiField);
+ }
+ if (durationField_ != null) {
+ output.WriteRawTag(26);
+ output.WriteMessage(DurationField);
+ }
+ if (emptyField_ != null) {
+ output.WriteRawTag(34);
+ output.WriteMessage(EmptyField);
+ }
+ if (fieldMaskField_ != null) {
+ output.WriteRawTag(42);
+ output.WriteMessage(FieldMaskField);
+ }
+ if (sourceContextField_ != null) {
+ output.WriteRawTag(50);
+ output.WriteMessage(SourceContextField);
+ }
+ if (structField_ != null) {
+ output.WriteRawTag(58);
+ output.WriteMessage(StructField);
+ }
+ if (timestampField_ != null) {
+ output.WriteRawTag(66);
+ output.WriteMessage(TimestampField);
+ }
+ if (typeField_ != null) {
+ output.WriteRawTag(74);
+ output.WriteMessage(TypeField);
+ }
+ if (doubleField_ != null) {
+ _single_doubleField_codec.WriteTagAndValue(output, DoubleField);
+ }
+ if (floatField_ != null) {
+ _single_floatField_codec.WriteTagAndValue(output, FloatField);
+ }
+ if (int64Field_ != null) {
+ _single_int64Field_codec.WriteTagAndValue(output, Int64Field);
+ }
+ if (uint64Field_ != null) {
+ _single_uint64Field_codec.WriteTagAndValue(output, Uint64Field);
+ }
+ if (int32Field_ != null) {
+ _single_int32Field_codec.WriteTagAndValue(output, Int32Field);
+ }
+ if (uint32Field_ != null) {
+ _single_uint32Field_codec.WriteTagAndValue(output, Uint32Field);
+ }
+ if (boolField_ != null) {
+ _single_boolField_codec.WriteTagAndValue(output, BoolField);
+ }
+ if (stringField_ != null) {
+ _single_stringField_codec.WriteTagAndValue(output, StringField);
+ }
+ if (bytesField_ != null) {
+ _single_bytesField_codec.WriteTagAndValue(output, BytesField);
+ }
+ }
+
+ public int CalculateSize() {
+ int size = 0;
+ if (anyField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(AnyField);
+ }
+ if (apiField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(ApiField);
+ }
+ if (durationField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(DurationField);
+ }
+ if (emptyField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(EmptyField);
+ }
+ if (fieldMaskField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(FieldMaskField);
+ }
+ if (sourceContextField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(SourceContextField);
+ }
+ if (structField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(StructField);
+ }
+ if (timestampField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(TimestampField);
+ }
+ if (typeField_ != null) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(TypeField);
+ }
+ if (doubleField_ != null) {
+ size += _single_doubleField_codec.CalculateSizeWithTag(DoubleField);
+ }
+ if (floatField_ != null) {
+ size += _single_floatField_codec.CalculateSizeWithTag(FloatField);
+ }
+ if (int64Field_ != null) {
+ size += _single_int64Field_codec.CalculateSizeWithTag(Int64Field);
+ }
+ if (uint64Field_ != null) {
+ size += _single_uint64Field_codec.CalculateSizeWithTag(Uint64Field);
+ }
+ if (int32Field_ != null) {
+ size += _single_int32Field_codec.CalculateSizeWithTag(Int32Field);
+ }
+ if (uint32Field_ != null) {
+ size += _single_uint32Field_codec.CalculateSizeWithTag(Uint32Field);
+ }
+ if (boolField_ != null) {
+ size += _single_boolField_codec.CalculateSizeWithTag(BoolField);
+ }
+ if (stringField_ != null) {
+ size += _single_stringField_codec.CalculateSizeWithTag(StringField);
+ }
+ if (bytesField_ != null) {
+ size += _single_bytesField_codec.CalculateSizeWithTag(BytesField);
+ }
+ return size;
+ }
+
+ public void MergeFrom(TestWellKnownTypes other) {
+ if (other == null) {
+ return;
+ }
+ if (other.anyField_ != null) {
+ if (anyField_ == null) {
+ anyField_ = new global::Google.Protobuf.WellKnownTypes.Any();
+ }
+ AnyField.MergeFrom(other.AnyField);
+ }
+ if (other.apiField_ != null) {
+ if (apiField_ == null) {
+ apiField_ = new global::Google.Protobuf.WellKnownTypes.Api();
+ }
+ ApiField.MergeFrom(other.ApiField);
+ }
+ if (other.durationField_ != null) {
+ if (durationField_ == null) {
+ durationField_ = new global::Google.Protobuf.WellKnownTypes.Duration();
+ }
+ DurationField.MergeFrom(other.DurationField);
+ }
+ if (other.emptyField_ != null) {
+ if (emptyField_ == null) {
+ emptyField_ = new global::Google.Protobuf.WellKnownTypes.Empty();
+ }
+ EmptyField.MergeFrom(other.EmptyField);
+ }
+ if (other.fieldMaskField_ != null) {
+ if (fieldMaskField_ == null) {
+ fieldMaskField_ = new global::Google.Protobuf.WellKnownTypes.FieldMask();
+ }
+ FieldMaskField.MergeFrom(other.FieldMaskField);
+ }
+ if (other.sourceContextField_ != null) {
+ if (sourceContextField_ == null) {
+ sourceContextField_ = new global::Google.Protobuf.WellKnownTypes.SourceContext();
+ }
+ SourceContextField.MergeFrom(other.SourceContextField);
+ }
+ if (other.structField_ != null) {
+ if (structField_ == null) {
+ structField_ = new global::Google.Protobuf.WellKnownTypes.Struct();
+ }
+ StructField.MergeFrom(other.StructField);
+ }
+ if (other.timestampField_ != null) {
+ if (timestampField_ == null) {
+ timestampField_ = new global::Google.Protobuf.WellKnownTypes.Timestamp();
+ }
+ TimestampField.MergeFrom(other.TimestampField);
+ }
+ if (other.typeField_ != null) {
+ if (typeField_ == null) {
+ typeField_ = new global::Google.Protobuf.WellKnownTypes.Type();
+ }
+ TypeField.MergeFrom(other.TypeField);
+ }
+ if (other.doubleField_ != null) {
+ if (doubleField_ == null || other.DoubleField != 0D) {
+ DoubleField = other.DoubleField;
+ }
+ }
+ if (other.floatField_ != null) {
+ if (floatField_ == null || other.FloatField != 0F) {
+ FloatField = other.FloatField;
+ }
+ }
+ if (other.int64Field_ != null) {
+ if (int64Field_ == null || other.Int64Field != 0L) {
+ Int64Field = other.Int64Field;
+ }
+ }
+ if (other.uint64Field_ != null) {
+ if (uint64Field_ == null || other.Uint64Field != 0UL) {
+ Uint64Field = other.Uint64Field;
+ }
+ }
+ if (other.int32Field_ != null) {
+ if (int32Field_ == null || other.Int32Field != 0) {
+ Int32Field = other.Int32Field;
+ }
+ }
+ if (other.uint32Field_ != null) {
+ if (uint32Field_ == null || other.Uint32Field != 0) {
+ Uint32Field = other.Uint32Field;
+ }
+ }
+ if (other.boolField_ != null) {
+ if (boolField_ == null || other.BoolField != false) {
+ BoolField = other.BoolField;
+ }
+ }
+ if (other.stringField_ != null) {
+ if (stringField_ == null || other.StringField != "") {
+ StringField = other.StringField;
+ }
+ }
+ if (other.bytesField_ != null) {
+ if (bytesField_ == null || other.BytesField != pb::ByteString.Empty) {
+ BytesField = other.BytesField;
+ }
+ }
+ }
+
+ public void MergeFrom(pb::CodedInputStream input) {
+ uint tag;
+ while (input.ReadTag(out tag)) {
+ switch(tag) {
+ case 0:
+ throw pb::InvalidProtocolBufferException.InvalidTag();
+ default:
+ if (pb::WireFormat.IsEndGroupTag(tag)) {
+ return;
+ }
+ break;
+ case 10: {
+ if (anyField_ == null) {
+ anyField_ = new global::Google.Protobuf.WellKnownTypes.Any();
+ }
+ input.ReadMessage(anyField_);
+ break;
+ }
+ case 18: {
+ if (apiField_ == null) {
+ apiField_ = new global::Google.Protobuf.WellKnownTypes.Api();
+ }
+ input.ReadMessage(apiField_);
+ break;
+ }
+ case 26: {
+ if (durationField_ == null) {
+ durationField_ = new global::Google.Protobuf.WellKnownTypes.Duration();
+ }
+ input.ReadMessage(durationField_);
+ break;
+ }
+ case 34: {
+ if (emptyField_ == null) {
+ emptyField_ = new global::Google.Protobuf.WellKnownTypes.Empty();
+ }
+ input.ReadMessage(emptyField_);
+ break;
+ }
+ case 42: {
+ if (fieldMaskField_ == null) {
+ fieldMaskField_ = new global::Google.Protobuf.WellKnownTypes.FieldMask();
+ }
+ input.ReadMessage(fieldMaskField_);
+ break;
+ }
+ case 50: {
+ if (sourceContextField_ == null) {
+ sourceContextField_ = new global::Google.Protobuf.WellKnownTypes.SourceContext();
+ }
+ input.ReadMessage(sourceContextField_);
+ break;
+ }
+ case 58: {
+ if (structField_ == null) {
+ structField_ = new global::Google.Protobuf.WellKnownTypes.Struct();
+ }
+ input.ReadMessage(structField_);
+ break;
+ }
+ case 66: {
+ if (timestampField_ == null) {
+ timestampField_ = new global::Google.Protobuf.WellKnownTypes.Timestamp();
+ }
+ input.ReadMessage(timestampField_);
+ break;
+ }
+ case 74: {
+ if (typeField_ == null) {
+ typeField_ = new global::Google.Protobuf.WellKnownTypes.Type();
+ }
+ input.ReadMessage(typeField_);
+ break;
+ }
+ case 82: {
+ double? value = _single_doubleField_codec.Read(input);
+ if (doubleField_ == null || value != 0D) {
+ DoubleField = value;
+ }
+ break;
+ }
+ case 90: {
+ float? value = _single_floatField_codec.Read(input);
+ if (floatField_ == null || value != 0F) {
+ FloatField = value;
+ }
+ break;
+ }
+ case 98: {
+ long? value = _single_int64Field_codec.Read(input);
+ if (int64Field_ == null || value != 0L) {
+ Int64Field = value;
+ }
+ break;
+ }
+ case 106: {
+ ulong? value = _single_uint64Field_codec.Read(input);
+ if (uint64Field_ == null || value != 0UL) {
+ Uint64Field = value;
+ }
+ break;
+ }
+ case 114: {
+ int? value = _single_int32Field_codec.Read(input);
+ if (int32Field_ == null || value != 0) {
+ Int32Field = value;
+ }
+ break;
+ }
+ case 122: {
+ uint? value = _single_uint32Field_codec.Read(input);
+ if (uint32Field_ == null || value != 0) {
+ Uint32Field = value;
+ }
+ break;
+ }
+ case 130: {
+ bool? value = _single_boolField_codec.Read(input);
+ if (boolField_ == null || value != false) {
+ BoolField = value;
+ }
+ break;
+ }
+ case 138: {
+ string value = _single_stringField_codec.Read(input);
+ if (stringField_ == null || value != "") {
+ StringField = value;
+ }
+ break;
+ }
+ case 146: {
+ pb::ByteString value = _single_bytesField_codec.Read(input);
+ if (bytesField_ == null || value != pb::ByteString.Empty) {
+ BytesField = value;
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ public sealed partial class RepeatedWellKnownTypes : pb::IMessage<RepeatedWellKnownTypes> {
+ private static readonly pb::MessageParser<RepeatedWellKnownTypes> _parser = new pb::MessageParser<RepeatedWellKnownTypes>(() => new RepeatedWellKnownTypes());
+ public static pb::MessageParser<RepeatedWellKnownTypes> Parser { get { return _parser; } }
+
+ private static readonly string[] _fieldNames = new string[] { "any_field", "api_field", "bool_field", "bytes_field", "double_field", "duration_field", "empty_field", "field_mask_field", "float_field", "int32_field", "int64_field", "source_context_field", "string_field", "struct_field", "timestamp_field", "type_field", "uint32_field", "uint64_field" };
+ private static readonly uint[] _fieldTags = new uint[] { 10, 18, 130, 146, 82, 26, 34, 42, 90, 114, 98, 50, 138, 58, 66, 74, 122, 106 };
+ public static pbr::MessageDescriptor Descriptor {
+ get { return global::Google.Protobuf.TestProtos.UnittestWellKnownTypes.Descriptor.MessageTypes[1]; }
+ }
+
+ pbr::FieldAccessorTable pb::IReflectedMessage.Fields {
+ get { return global::Google.Protobuf.TestProtos.UnittestWellKnownTypes.internal__static_protobuf_unittest_RepeatedWellKnownTypes__FieldAccessorTable; }
+ }
+
+ private bool _frozen = false;
+ public bool IsFrozen { get { return _frozen; } }
+
+ public RepeatedWellKnownTypes() {
+ OnConstruction();
+ }
+
+ partial void OnConstruction();
+
+ public RepeatedWellKnownTypes(RepeatedWellKnownTypes other) : this() {
+ anyField_ = other.anyField_.Clone();
+ apiField_ = other.apiField_.Clone();
+ durationField_ = other.durationField_.Clone();
+ emptyField_ = other.emptyField_.Clone();
+ fieldMaskField_ = other.fieldMaskField_.Clone();
+ sourceContextField_ = other.sourceContextField_.Clone();
+ structField_ = other.structField_.Clone();
+ timestampField_ = other.timestampField_.Clone();
+ typeField_ = other.typeField_.Clone();
+ doubleField_ = other.doubleField_.Clone();
+ floatField_ = other.floatField_.Clone();
+ int64Field_ = other.int64Field_.Clone();
+ uint64Field_ = other.uint64Field_.Clone();
+ int32Field_ = other.int32Field_.Clone();
+ uint32Field_ = other.uint32Field_.Clone();
+ boolField_ = other.boolField_.Clone();
+ stringField_ = other.stringField_.Clone();
+ bytesField_ = other.bytesField_.Clone();
+ }
+
+ public RepeatedWellKnownTypes Clone() {
+ return new RepeatedWellKnownTypes(this);
+ }
+
+ public void Freeze() {
+ if (IsFrozen) {
+ return;
+ }
+ _frozen = true;
+ anyField_.Freeze();
+ apiField_.Freeze();
+ durationField_.Freeze();
+ emptyField_.Freeze();
+ fieldMaskField_.Freeze();
+ sourceContextField_.Freeze();
+ structField_.Freeze();
+ timestampField_.Freeze();
+ typeField_.Freeze();
+ doubleField_.Freeze();
+ floatField_.Freeze();
+ int64Field_.Freeze();
+ uint64Field_.Freeze();
+ int32Field_.Freeze();
+ uint32Field_.Freeze();
+ boolField_.Freeze();
+ stringField_.Freeze();
+ bytesField_.Freeze();
+ }
+
+ public const int AnyFieldFieldNumber = 1;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.Any> _repeated_anyField_codec
+ = pb::FieldCodec.ForMessage(10, global::Google.Protobuf.WellKnownTypes.Any.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Any> anyField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Any>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Any> AnyField {
+ get { return anyField_; }
+ }
+
+ public const int ApiFieldFieldNumber = 2;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.Api> _repeated_apiField_codec
+ = pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Api.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Api> apiField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Api>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Api> ApiField {
+ get { return apiField_; }
+ }
+
+ public const int DurationFieldFieldNumber = 3;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.Duration> _repeated_durationField_codec
+ = pb::FieldCodec.ForMessage(26, global::Google.Protobuf.WellKnownTypes.Duration.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Duration> durationField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Duration>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Duration> DurationField {
+ get { return durationField_; }
+ }
+
+ public const int EmptyFieldFieldNumber = 4;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.Empty> _repeated_emptyField_codec
+ = pb::FieldCodec.ForMessage(34, global::Google.Protobuf.WellKnownTypes.Empty.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Empty> emptyField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Empty>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Empty> EmptyField {
+ get { return emptyField_; }
+ }
+
+ public const int FieldMaskFieldFieldNumber = 5;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.FieldMask> _repeated_fieldMaskField_codec
+ = pb::FieldCodec.ForMessage(42, global::Google.Protobuf.WellKnownTypes.FieldMask.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.FieldMask> fieldMaskField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.FieldMask>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.FieldMask> FieldMaskField {
+ get { return fieldMaskField_; }
+ }
+
+ public const int SourceContextFieldFieldNumber = 6;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.SourceContext> _repeated_sourceContextField_codec
+ = pb::FieldCodec.ForMessage(50, global::Google.Protobuf.WellKnownTypes.SourceContext.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.SourceContext> sourceContextField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.SourceContext>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.SourceContext> SourceContextField {
+ get { return sourceContextField_; }
+ }
+
+ public const int StructFieldFieldNumber = 7;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.Struct> _repeated_structField_codec
+ = pb::FieldCodec.ForMessage(58, global::Google.Protobuf.WellKnownTypes.Struct.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Struct> structField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Struct>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Struct> StructField {
+ get { return structField_; }
+ }
+
+ public const int TimestampFieldFieldNumber = 8;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.Timestamp> _repeated_timestampField_codec
+ = pb::FieldCodec.ForMessage(66, global::Google.Protobuf.WellKnownTypes.Timestamp.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Timestamp> timestampField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Timestamp>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Timestamp> TimestampField {
+ get { return timestampField_; }
+ }
+
+ public const int TypeFieldFieldNumber = 9;
+ private static readonly pb::FieldCodec<global::Google.Protobuf.WellKnownTypes.Type> _repeated_typeField_codec
+ = pb::FieldCodec.ForMessage(74, global::Google.Protobuf.WellKnownTypes.Type.Parser);
+ private readonly pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Type> typeField_ = new pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Type>();
+ public pbc::RepeatedField<global::Google.Protobuf.WellKnownTypes.Type> TypeField {
+ get { return typeField_; }
+ }
+
+ public const int DoubleFieldFieldNumber = 10;
+ private static readonly pb::FieldCodec<double?> _repeated_doubleField_codec
+ = pb::FieldCodec.ForStructWrapper<double>(82);
+ private readonly pbc::RepeatedField<double?> doubleField_ = new pbc::RepeatedField<double?>();
+ public pbc::RepeatedField<double?> DoubleField {
+ get { return doubleField_; }
+ }
+
+ public const int FloatFieldFieldNumber = 11;
+ private static readonly pb::FieldCodec<float?> _repeated_floatField_codec
+ = pb::FieldCodec.ForStructWrapper<float>(90);
+ private readonly pbc::RepeatedField<float?> floatField_ = new pbc::RepeatedField<float?>();
+ public pbc::RepeatedField<float?> FloatField {
+ get { return floatField_; }
+ }
+
+ public const int Int64FieldFieldNumber = 12;
+ private static readonly pb::FieldCodec<long?> _repeated_int64Field_codec
+ = pb::FieldCodec.ForStructWrapper<long>(98);
+ private readonly pbc::RepeatedField<long?> int64Field_ = new pbc::RepeatedField<long?>();
+ public pbc::RepeatedField<long?> Int64Field {
+ get { return int64Field_; }
+ }
+
+ public const int Uint64FieldFieldNumber = 13;
+ private static readonly pb::FieldCodec<ulong?> _repeated_uint64Field_codec
+ = pb::FieldCodec.ForStructWrapper<ulong>(106);
+ private readonly pbc::RepeatedField<ulong?> uint64Field_ = new pbc::RepeatedField<ulong?>();
+ public pbc::RepeatedField<ulong?> Uint64Field {
+ get { return uint64Field_; }
+ }
+
+ public const int Int32FieldFieldNumber = 14;
+ private static readonly pb::FieldCodec<int?> _repeated_int32Field_codec
+ = pb::FieldCodec.ForStructWrapper<int>(114);
+ private readonly pbc::RepeatedField<int?> int32Field_ = new pbc::RepeatedField<int?>();
+ public pbc::RepeatedField<int?> Int32Field {
+ get { return int32Field_; }
+ }
+
+ public const int Uint32FieldFieldNumber = 15;
+ private static readonly pb::FieldCodec<uint?> _repeated_uint32Field_codec
+ = pb::FieldCodec.ForStructWrapper<uint>(122);
+ private readonly pbc::RepeatedField<uint?> uint32Field_ = new pbc::RepeatedField<uint?>();
+ public pbc::RepeatedField<uint?> Uint32Field {
+ get { return uint32Field_; }
+ }
+
+ public const int BoolFieldFieldNumber = 16;
+ private static readonly pb::FieldCodec<bool?> _repeated_boolField_codec
+ = pb::FieldCodec.ForStructWrapper<bool>(130);
+ private readonly pbc::RepeatedField<bool?> boolField_ = new pbc::RepeatedField<bool?>();
+ public pbc::RepeatedField<bool?> BoolField {
+ get { return boolField_; }
+ }
+
+ public const int StringFieldFieldNumber = 17;
+ private static readonly pb::FieldCodec<string> _repeated_stringField_codec
+ = pb::FieldCodec.ForClassWrapper<string>(138);
+ private readonly pbc::RepeatedField<string> stringField_ = new pbc::RepeatedField<string>();
+ public pbc::RepeatedField<string> StringField {
+ get { return stringField_; }
+ }
+
+ public const int BytesFieldFieldNumber = 18;
+ private static readonly pb::FieldCodec<pb::ByteString> _repeated_bytesField_codec
+ = pb::FieldCodec.ForClassWrapper<pb::ByteString>(146);
+ private readonly pbc::RepeatedField<pb::ByteString> bytesField_ = new pbc::RepeatedField<pb::ByteString>();
+ public pbc::RepeatedField<pb::ByteString> BytesField {
+ get { return bytesField_; }
+ }
+
+ public override bool Equals(object other) {
+ return Equals(other as RepeatedWellKnownTypes);
+ }
+
+ public bool Equals(RepeatedWellKnownTypes other) {
+ if (ReferenceEquals(other, null)) {
+ return false;
+ }
+ if (ReferenceEquals(other, this)) {
+ return true;
+ }
+ if(!anyField_.Equals(other.anyField_)) return false;
+ if(!apiField_.Equals(other.apiField_)) return false;
+ if(!durationField_.Equals(other.durationField_)) return false;
+ if(!emptyField_.Equals(other.emptyField_)) return false;
+ if(!fieldMaskField_.Equals(other.fieldMaskField_)) return false;
+ if(!sourceContextField_.Equals(other.sourceContextField_)) return false;
+ if(!structField_.Equals(other.structField_)) return false;
+ if(!timestampField_.Equals(other.timestampField_)) return false;
+ if(!typeField_.Equals(other.typeField_)) return false;
+ if(!doubleField_.Equals(other.doubleField_)) return false;
+ if(!floatField_.Equals(other.floatField_)) return false;
+ if(!int64Field_.Equals(other.int64Field_)) return false;
+ if(!uint64Field_.Equals(other.uint64Field_)) return false;
+ if(!int32Field_.Equals(other.int32Field_)) return false;
+ if(!uint32Field_.Equals(other.uint32Field_)) return false;
+ if(!boolField_.Equals(other.boolField_)) return false;
+ if(!stringField_.Equals(other.stringField_)) return false;
+ if(!bytesField_.Equals(other.bytesField_)) return false;
+ return true;
+ }
+
+ public override int GetHashCode() {
+ int hash = 1;
+ hash ^= anyField_.GetHashCode();
+ hash ^= apiField_.GetHashCode();
+ hash ^= durationField_.GetHashCode();
+ hash ^= emptyField_.GetHashCode();
+ hash ^= fieldMaskField_.GetHashCode();
+ hash ^= sourceContextField_.GetHashCode();
+ hash ^= structField_.GetHashCode();
+ hash ^= timestampField_.GetHashCode();
+ hash ^= typeField_.GetHashCode();
+ hash ^= doubleField_.GetHashCode();
+ hash ^= floatField_.GetHashCode();
+ hash ^= int64Field_.GetHashCode();
+ hash ^= uint64Field_.GetHashCode();
+ hash ^= int32Field_.GetHashCode();
+ hash ^= uint32Field_.GetHashCode();
+ hash ^= boolField_.GetHashCode();
+ hash ^= stringField_.GetHashCode();
+ hash ^= bytesField_.GetHashCode();
+ return hash;
+ }
+
+ public override string ToString() {
+ return pb::JsonFormatter.Default.Format(this);
+ }
+
+ public void WriteTo(pb::CodedOutputStream output) {
+ anyField_.WriteTo(output, _repeated_anyField_codec);
+ apiField_.WriteTo(output, _repeated_apiField_codec);
+ durationField_.WriteTo(output, _repeated_durationField_codec);
+ emptyField_.WriteTo(output, _repeated_emptyField_codec);
+ fieldMaskField_.WriteTo(output, _repeated_fieldMaskField_codec);
+ sourceContextField_.WriteTo(output, _repeated_sourceContextField_codec);
+ structField_.WriteTo(output, _repeated_structField_codec);
+ timestampField_.WriteTo(output, _repeated_timestampField_codec);
+ typeField_.WriteTo(output, _repeated_typeField_codec);
+ doubleField_.WriteTo(output, _repeated_doubleField_codec);
+ floatField_.WriteTo(output, _repeated_floatField_codec);
+ int64Field_.WriteTo(output, _repeated_int64Field_codec);
+ uint64Field_.WriteTo(output, _repeated_uint64Field_codec);
+ int32Field_.WriteTo(output, _repeated_int32Field_codec);
+ uint32Field_.WriteTo(output, _repeated_uint32Field_codec);
+ boolField_.WriteTo(output, _repeated_boolField_codec);
+ stringField_.WriteTo(output, _repeated_stringField_codec);
+ bytesField_.WriteTo(output, _repeated_bytesField_codec);
+ }
+
+ public int CalculateSize() {
+ int size = 0;
+ size += anyField_.CalculateSize(_repeated_anyField_codec);
+ size += apiField_.CalculateSize(_repeated_apiField_codec);
+ size += durationField_.CalculateSize(_repeated_durationField_codec);
+ size += emptyField_.CalculateSize(_repeated_emptyField_codec);
+ size += fieldMaskField_.CalculateSize(_repeated_fieldMaskField_codec);
+ size += sourceContextField_.CalculateSize(_repeated_sourceContextField_codec);
+ size += structField_.CalculateSize(_repeated_structField_codec);
+ size += timestampField_.CalculateSize(_repeated_timestampField_codec);
+ size += typeField_.CalculateSize(_repeated_typeField_codec);
+ size += doubleField_.CalculateSize(_repeated_doubleField_codec);
+ size += floatField_.CalculateSize(_repeated_floatField_codec);
+ size += int64Field_.CalculateSize(_repeated_int64Field_codec);
+ size += uint64Field_.CalculateSize(_repeated_uint64Field_codec);
+ size += int32Field_.CalculateSize(_repeated_int32Field_codec);
+ size += uint32Field_.CalculateSize(_repeated_uint32Field_codec);
+ size += boolField_.CalculateSize(_repeated_boolField_codec);
+ size += stringField_.CalculateSize(_repeated_stringField_codec);
+ size += bytesField_.CalculateSize(_repeated_bytesField_codec);
+ return size;
+ }
+
+ public void MergeFrom(RepeatedWellKnownTypes other) {
+ if (other == null) {
+ return;
+ }
+ anyField_.Add(other.anyField_);
+ apiField_.Add(other.apiField_);
+ durationField_.Add(other.durationField_);
+ emptyField_.Add(other.emptyField_);
+ fieldMaskField_.Add(other.fieldMaskField_);
+ sourceContextField_.Add(other.sourceContextField_);
+ structField_.Add(other.structField_);
+ timestampField_.Add(other.timestampField_);
+ typeField_.Add(other.typeField_);
+ doubleField_.Add(other.doubleField_);
+ floatField_.Add(other.floatField_);
+ int64Field_.Add(other.int64Field_);
+ uint64Field_.Add(other.uint64Field_);
+ int32Field_.Add(other.int32Field_);
+ uint32Field_.Add(other.uint32Field_);
+ boolField_.Add(other.boolField_);
+ stringField_.Add(other.stringField_);
+ bytesField_.Add(other.bytesField_);
+ }
+
+ public void MergeFrom(pb::CodedInputStream input) {
+ uint tag;
+ while (input.ReadTag(out tag)) {
+ switch(tag) {
+ case 0:
+ throw pb::InvalidProtocolBufferException.InvalidTag();
+ default:
+ if (pb::WireFormat.IsEndGroupTag(tag)) {
+ return;
+ }
+ break;
+ case 10: {
+ anyField_.AddEntriesFrom(input, _repeated_anyField_codec);
+ break;
+ }
+ case 18: {
+ apiField_.AddEntriesFrom(input, _repeated_apiField_codec);
+ break;
+ }
+ case 26: {
+ durationField_.AddEntriesFrom(input, _repeated_durationField_codec);
+ break;
+ }
+ case 34: {
+ emptyField_.AddEntriesFrom(input, _repeated_emptyField_codec);
+ break;
+ }
+ case 42: {
+ fieldMaskField_.AddEntriesFrom(input, _repeated_fieldMaskField_codec);
+ break;
+ }
+ case 50: {
+ sourceContextField_.AddEntriesFrom(input, _repeated_sourceContextField_codec);
+ break;
+ }
+ case 58: {
+ structField_.AddEntriesFrom(input, _repeated_structField_codec);
+ break;
+ }
+ case 66: {
+ timestampField_.AddEntriesFrom(input, _repeated_timestampField_codec);
+ break;
+ }
+ case 74: {
+ typeField_.AddEntriesFrom(input, _repeated_typeField_codec);
+ break;
+ }
+ case 82: {
+ doubleField_.AddEntriesFrom(input, _repeated_doubleField_codec);
+ break;
+ }
+ case 90: {
+ floatField_.AddEntriesFrom(input, _repeated_floatField_codec);
+ break;
+ }
+ case 98: {
+ int64Field_.AddEntriesFrom(input, _repeated_int64Field_codec);
+ break;
+ }
+ case 106: {
+ uint64Field_.AddEntriesFrom(input, _repeated_uint64Field_codec);
+ break;
+ }
+ case 114: {
+ int32Field_.AddEntriesFrom(input, _repeated_int32Field_codec);
+ break;
+ }
+ case 122: {
+ uint32Field_.AddEntriesFrom(input, _repeated_uint32Field_codec);
+ break;
+ }
+ case 130: {
+ boolField_.AddEntriesFrom(input, _repeated_boolField_codec);
+ break;
+ }
+ case 138: {
+ stringField_.AddEntriesFrom(input, _repeated_stringField_codec);
+ break;
+ }
+ case 146: {
+ bytesField_.AddEntriesFrom(input, _repeated_bytesField_codec);
+ break;
+ }
+ }
+ }
+ }
+
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ public sealed partial class OneofWellKnownTypes : pb::IMessage<OneofWellKnownTypes> {
+ private static readonly pb::MessageParser<OneofWellKnownTypes> _parser = new pb::MessageParser<OneofWellKnownTypes>(() => new OneofWellKnownTypes());
+ public static pb::MessageParser<OneofWellKnownTypes> Parser { get { return _parser; } }
+
+ private static readonly string[] _fieldNames = new string[] { "any_field", "api_field", "bool_field", "bytes_field", "double_field", "duration_field", "empty_field", "field_mask_field", "float_field", "int32_field", "int64_field", "source_context_field", "string_field", "struct_field", "timestamp_field", "type_field", "uint32_field", "uint64_field" };
+ private static readonly uint[] _fieldTags = new uint[] { 10, 18, 130, 146, 82, 26, 34, 42, 90, 114, 98, 50, 138, 58, 66, 74, 122, 106 };
+ public static pbr::MessageDescriptor Descriptor {
+ get { return global::Google.Protobuf.TestProtos.UnittestWellKnownTypes.Descriptor.MessageTypes[2]; }
+ }
+
+ pbr::FieldAccessorTable pb::IReflectedMessage.Fields {
+ get { return global::Google.Protobuf.TestProtos.UnittestWellKnownTypes.internal__static_protobuf_unittest_OneofWellKnownTypes__FieldAccessorTable; }
+ }
+
+ private bool _frozen = false;
+ public bool IsFrozen { get { return _frozen; } }
+
+ public OneofWellKnownTypes() {
+ OnConstruction();
+ }
+
+ partial void OnConstruction();
+
+ public OneofWellKnownTypes(OneofWellKnownTypes other) : this() {
+ switch (other.OneofFieldCase) {
+ case OneofFieldOneofCase.AnyField:
+ AnyField = other.AnyField.Clone();
+ break;
+ case OneofFieldOneofCase.ApiField:
+ ApiField = other.ApiField.Clone();
+ break;
+ case OneofFieldOneofCase.DurationField:
+ DurationField = other.DurationField.Clone();
+ break;
+ case OneofFieldOneofCase.EmptyField:
+ EmptyField = other.EmptyField.Clone();
+ break;
+ case OneofFieldOneofCase.FieldMaskField:
+ FieldMaskField = other.FieldMaskField.Clone();
+ break;
+ case OneofFieldOneofCase.SourceContextField:
+ SourceContextField = other.SourceContextField.Clone();
+ break;
+ case OneofFieldOneofCase.StructField:
+ StructField = other.StructField.Clone();
+ break;
+ case OneofFieldOneofCase.TimestampField:
+ TimestampField = other.TimestampField.Clone();
+ break;
+ case OneofFieldOneofCase.TypeField:
+ TypeField = other.TypeField.Clone();
+ break;
+ case OneofFieldOneofCase.DoubleField:
+ DoubleField = other.DoubleField;
+ break;
+ case OneofFieldOneofCase.FloatField:
+ FloatField = other.FloatField;
+ break;
+ case OneofFieldOneofCase.Int64Field:
+ Int64Field = other.Int64Field;
+ break;
+ case OneofFieldOneofCase.Uint64Field:
+ Uint64Field = other.Uint64Field;
+ break;
+ case OneofFieldOneofCase.Int32Field:
+ Int32Field = other.Int32Field;
+ break;
+ case OneofFieldOneofCase.Uint32Field:
+ Uint32Field = other.Uint32Field;
+ break;
+ case OneofFieldOneofCase.BoolField:
+ BoolField = other.BoolField;
+ break;
+ case OneofFieldOneofCase.StringField:
+ StringField = other.StringField;
+ break;
+ case OneofFieldOneofCase.BytesField:
+ BytesField = other.BytesField;
+ break;
+ }
+
+ }
+
+ public OneofWellKnownTypes Clone() {
+ return new OneofWellKnownTypes(this);
+ }
+
+ public void Freeze() {
+ if (IsFrozen) {
+ return;
+ }
+ _frozen = true;
+ if (oneofField_ is IFreezable) ((IFreezable) oneofField_).Freeze();
+ }
+
+ public const int AnyFieldFieldNumber = 1;
+ public global::Google.Protobuf.WellKnownTypes.Any AnyField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.AnyField ? (global::Google.Protobuf.WellKnownTypes.Any) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.AnyField;
+ }
+ }
+
+ public const int ApiFieldFieldNumber = 2;
+ public global::Google.Protobuf.WellKnownTypes.Api ApiField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.ApiField ? (global::Google.Protobuf.WellKnownTypes.Api) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.ApiField;
+ }
+ }
+
+ public const int DurationFieldFieldNumber = 3;
+ public global::Google.Protobuf.WellKnownTypes.Duration DurationField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.DurationField ? (global::Google.Protobuf.WellKnownTypes.Duration) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.DurationField;
+ }
+ }
+
+ public const int EmptyFieldFieldNumber = 4;
+ public global::Google.Protobuf.WellKnownTypes.Empty EmptyField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.EmptyField ? (global::Google.Protobuf.WellKnownTypes.Empty) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.EmptyField;
+ }
+ }
+
+ public const int FieldMaskFieldFieldNumber = 5;
+ public global::Google.Protobuf.WellKnownTypes.FieldMask FieldMaskField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.FieldMaskField ? (global::Google.Protobuf.WellKnownTypes.FieldMask) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.FieldMaskField;
+ }
+ }
+
+ public const int SourceContextFieldFieldNumber = 6;
+ public global::Google.Protobuf.WellKnownTypes.SourceContext SourceContextField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.SourceContextField ? (global::Google.Protobuf.WellKnownTypes.SourceContext) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.SourceContextField;
+ }
+ }
+
+ public const int StructFieldFieldNumber = 7;
+ public global::Google.Protobuf.WellKnownTypes.Struct StructField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.StructField ? (global::Google.Protobuf.WellKnownTypes.Struct) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.StructField;
+ }
+ }
+
+ public const int TimestampFieldFieldNumber = 8;
+ public global::Google.Protobuf.WellKnownTypes.Timestamp TimestampField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.TimestampField ? (global::Google.Protobuf.WellKnownTypes.Timestamp) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.TimestampField;
+ }
+ }
+
+ public const int TypeFieldFieldNumber = 9;
+ public global::Google.Protobuf.WellKnownTypes.Type TypeField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.TypeField ? (global::Google.Protobuf.WellKnownTypes.Type) oneofField_ : null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.TypeField;
+ }
+ }
+
+ public const int DoubleFieldFieldNumber = 10;
+ private static readonly pb::FieldCodec<double?> _oneof_doubleField_codec = pb::FieldCodec.ForStructWrapper<double>(82);
+ public double? DoubleField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.DoubleField ? (double?) oneofField_ : (double?) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.DoubleField;
+ }
+ }
+
+ public const int FloatFieldFieldNumber = 11;
+ private static readonly pb::FieldCodec<float?> _oneof_floatField_codec = pb::FieldCodec.ForStructWrapper<float>(90);
+ public float? FloatField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.FloatField ? (float?) oneofField_ : (float?) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.FloatField;
+ }
+ }
+
+ public const int Int64FieldFieldNumber = 12;
+ private static readonly pb::FieldCodec<long?> _oneof_int64Field_codec = pb::FieldCodec.ForStructWrapper<long>(98);
+ public long? Int64Field {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.Int64Field ? (long?) oneofField_ : (long?) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.Int64Field;
+ }
+ }
+
+ public const int Uint64FieldFieldNumber = 13;
+ private static readonly pb::FieldCodec<ulong?> _oneof_uint64Field_codec = pb::FieldCodec.ForStructWrapper<ulong>(106);
+ public ulong? Uint64Field {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.Uint64Field ? (ulong?) oneofField_ : (ulong?) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.Uint64Field;
+ }
+ }
+
+ public const int Int32FieldFieldNumber = 14;
+ private static readonly pb::FieldCodec<int?> _oneof_int32Field_codec = pb::FieldCodec.ForStructWrapper<int>(114);
+ public int? Int32Field {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.Int32Field ? (int?) oneofField_ : (int?) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.Int32Field;
+ }
+ }
+
+ public const int Uint32FieldFieldNumber = 15;
+ private static readonly pb::FieldCodec<uint?> _oneof_uint32Field_codec = pb::FieldCodec.ForStructWrapper<uint>(122);
+ public uint? Uint32Field {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.Uint32Field ? (uint?) oneofField_ : (uint?) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.Uint32Field;
+ }
+ }
+
+ public const int BoolFieldFieldNumber = 16;
+ private static readonly pb::FieldCodec<bool?> _oneof_boolField_codec = pb::FieldCodec.ForStructWrapper<bool>(130);
+ public bool? BoolField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.BoolField ? (bool?) oneofField_ : (bool?) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.BoolField;
+ }
+ }
+
+ public const int StringFieldFieldNumber = 17;
+ private static readonly pb::FieldCodec<string> _oneof_stringField_codec = pb::FieldCodec.ForClassWrapper<string>(138);
+ public string StringField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.StringField ? (string) oneofField_ : (string) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.StringField;
+ }
+ }
+
+ public const int BytesFieldFieldNumber = 18;
+ private static readonly pb::FieldCodec<pb::ByteString> _oneof_bytesField_codec = pb::FieldCodec.ForClassWrapper<pb::ByteString>(146);
+ public pb::ByteString BytesField {
+ get { return oneofFieldCase_ == OneofFieldOneofCase.BytesField ? (pb::ByteString) oneofField_ : (pb::ByteString) null; }
+ set {
+ pb::Freezable.CheckMutable(this);
+ oneofField_ = value;
+ oneofFieldCase_ = value == null ? OneofFieldOneofCase.None : OneofFieldOneofCase.BytesField;
+ }
+ }
+
+ private object oneofField_;
+ public enum OneofFieldOneofCase {
+ None = 0,
+ AnyField = 1,
+ ApiField = 2,
+ DurationField = 3,
+ EmptyField = 4,
+ FieldMaskField = 5,
+ SourceContextField = 6,
+ StructField = 7,
+ TimestampField = 8,
+ TypeField = 9,
+ DoubleField = 10,
+ FloatField = 11,
+ Int64Field = 12,
+ Uint64Field = 13,
+ Int32Field = 14,
+ Uint32Field = 15,
+ BoolField = 16,
+ StringField = 17,
+ BytesField = 18,
+ }
+ private OneofFieldOneofCase oneofFieldCase_ = OneofFieldOneofCase.None;
+ public OneofFieldOneofCase OneofFieldCase {
+ get { return oneofFieldCase_; }
+ }
+
+ public void ClearOneofField() {
+ pb::Freezable.CheckMutable(this);
+ oneofFieldCase_ = OneofFieldOneofCase.None;
+ oneofField_ = null;
+ }
+
+ public override bool Equals(object other) {
+ return Equals(other as OneofWellKnownTypes);
+ }
+
+ public bool Equals(OneofWellKnownTypes other) {
+ if (ReferenceEquals(other, null)) {
+ return false;
+ }
+ if (ReferenceEquals(other, this)) {
+ return true;
+ }
+ if (!object.Equals(AnyField, other.AnyField)) return false;
+ if (!object.Equals(ApiField, other.ApiField)) return false;
+ if (!object.Equals(DurationField, other.DurationField)) return false;
+ if (!object.Equals(EmptyField, other.EmptyField)) return false;
+ if (!object.Equals(FieldMaskField, other.FieldMaskField)) return false;
+ if (!object.Equals(SourceContextField, other.SourceContextField)) return false;
+ if (!object.Equals(StructField, other.StructField)) return false;
+ if (!object.Equals(TimestampField, other.TimestampField)) return false;
+ if (!object.Equals(TypeField, other.TypeField)) return false;
+ if (DoubleField != other.DoubleField) return false;
+ if (FloatField != other.FloatField) return false;
+ if (Int64Field != other.Int64Field) return false;
+ if (Uint64Field != other.Uint64Field) return false;
+ if (Int32Field != other.Int32Field) return false;
+ if (Uint32Field != other.Uint32Field) return false;
+ if (BoolField != other.BoolField) return false;
+ if (StringField != other.StringField) return false;
+ if (BytesField != other.BytesField) return false;
+ return true;
+ }
+
+ public override int GetHashCode() {
+ int hash = 1;
+ if (oneofFieldCase_ == OneofFieldOneofCase.AnyField) hash ^= AnyField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.ApiField) hash ^= ApiField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.DurationField) hash ^= DurationField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.EmptyField) hash ^= EmptyField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.FieldMaskField) hash ^= FieldMaskField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.SourceContextField) hash ^= SourceContextField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.StructField) hash ^= StructField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.TimestampField) hash ^= TimestampField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.TypeField) hash ^= TypeField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.DoubleField) hash ^= DoubleField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.FloatField) hash ^= FloatField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.Int64Field) hash ^= Int64Field.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.Uint64Field) hash ^= Uint64Field.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.Int32Field) hash ^= Int32Field.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.Uint32Field) hash ^= Uint32Field.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.BoolField) hash ^= BoolField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.StringField) hash ^= StringField.GetHashCode();
+ if (oneofFieldCase_ == OneofFieldOneofCase.BytesField) hash ^= BytesField.GetHashCode();
+ return hash;
+ }
+
+ public override string ToString() {
+ return pb::JsonFormatter.Default.Format(this);
+ }
+
+ public void WriteTo(pb::CodedOutputStream output) {
+ if (oneofFieldCase_ == OneofFieldOneofCase.AnyField) {
+ output.WriteRawTag(10);
+ output.WriteMessage(AnyField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.ApiField) {
+ output.WriteRawTag(18);
+ output.WriteMessage(ApiField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.DurationField) {
+ output.WriteRawTag(26);
+ output.WriteMessage(DurationField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.EmptyField) {
+ output.WriteRawTag(34);
+ output.WriteMessage(EmptyField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.FieldMaskField) {
+ output.WriteRawTag(42);
+ output.WriteMessage(FieldMaskField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.SourceContextField) {
+ output.WriteRawTag(50);
+ output.WriteMessage(SourceContextField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.StructField) {
+ output.WriteRawTag(58);
+ output.WriteMessage(StructField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.TimestampField) {
+ output.WriteRawTag(66);
+ output.WriteMessage(TimestampField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.TypeField) {
+ output.WriteRawTag(74);
+ output.WriteMessage(TypeField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.DoubleField) {
+ _oneof_doubleField_codec.WriteTagAndValue(output, (double?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.FloatField) {
+ _oneof_floatField_codec.WriteTagAndValue(output, (float?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Int64Field) {
+ _oneof_int64Field_codec.WriteTagAndValue(output, (long?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Uint64Field) {
+ _oneof_uint64Field_codec.WriteTagAndValue(output, (ulong?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Int32Field) {
+ _oneof_int32Field_codec.WriteTagAndValue(output, (int?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Uint32Field) {
+ _oneof_uint32Field_codec.WriteTagAndValue(output, (uint?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.BoolField) {
+ _oneof_boolField_codec.WriteTagAndValue(output, (bool?) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.StringField) {
+ _oneof_stringField_codec.WriteTagAndValue(output, (string) oneofField_);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.BytesField) {
+ _oneof_bytesField_codec.WriteTagAndValue(output, (pb::ByteString) oneofField_);
+ }
+ }
+
+ public int CalculateSize() {
+ int size = 0;
+ if (oneofFieldCase_ == OneofFieldOneofCase.AnyField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(AnyField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.ApiField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(ApiField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.DurationField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(DurationField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.EmptyField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(EmptyField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.FieldMaskField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(FieldMaskField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.SourceContextField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(SourceContextField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.StructField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(StructField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.TimestampField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(TimestampField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.TypeField) {
+ size += 1 + pb::CodedOutputStream.ComputeMessageSize(TypeField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.DoubleField) {
+ size += _oneof_doubleField_codec.CalculateSizeWithTag(DoubleField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.FloatField) {
+ size += _oneof_floatField_codec.CalculateSizeWithTag(FloatField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Int64Field) {
+ size += _oneof_int64Field_codec.CalculateSizeWithTag(Int64Field);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Uint64Field) {
+ size += _oneof_uint64Field_codec.CalculateSizeWithTag(Uint64Field);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Int32Field) {
+ size += _oneof_int32Field_codec.CalculateSizeWithTag(Int32Field);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.Uint32Field) {
+ size += _oneof_uint32Field_codec.CalculateSizeWithTag(Uint32Field);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.BoolField) {
+ size += _oneof_boolField_codec.CalculateSizeWithTag(BoolField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.StringField) {
+ size += _oneof_stringField_codec.CalculateSizeWithTag(StringField);
+ }
+ if (oneofFieldCase_ == OneofFieldOneofCase.BytesField) {
+ size += _oneof_bytesField_codec.CalculateSizeWithTag(BytesField);
+ }
+ return size;
+ }
+
+ public void MergeFrom(OneofWellKnownTypes other) {
+ if (other == null) {
+ return;
+ }
+ switch (other.OneofFieldCase) {
+ case OneofFieldOneofCase.AnyField:
+ AnyField = other.AnyField;
+ break;
+ case OneofFieldOneofCase.ApiField:
+ ApiField = other.ApiField;
+ break;
+ case OneofFieldOneofCase.DurationField:
+ DurationField = other.DurationField;
+ break;
+ case OneofFieldOneofCase.EmptyField:
+ EmptyField = other.EmptyField;
+ break;
+ case OneofFieldOneofCase.FieldMaskField:
+ FieldMaskField = other.FieldMaskField;
+ break;
+ case OneofFieldOneofCase.SourceContextField:
+ SourceContextField = other.SourceContextField;
+ break;
+ case OneofFieldOneofCase.StructField:
+ StructField = other.StructField;
+ break;
+ case OneofFieldOneofCase.TimestampField:
+ TimestampField = other.TimestampField;
+ break;
+ case OneofFieldOneofCase.TypeField:
+ TypeField = other.TypeField;
+ break;
+ case OneofFieldOneofCase.DoubleField:
+ DoubleField = other.DoubleField;
+ break;
+ case OneofFieldOneofCase.FloatField:
+ FloatField = other.FloatField;
+ break;
+ case OneofFieldOneofCase.Int64Field:
+ Int64Field = other.Int64Field;
+ break;
+ case OneofFieldOneofCase.Uint64Field:
+ Uint64Field = other.Uint64Field;
+ break;
+ case OneofFieldOneofCase.Int32Field:
+ Int32Field = other.Int32Field;
+ break;
+ case OneofFieldOneofCase.Uint32Field:
+ Uint32Field = other.Uint32Field;
+ break;
+ case OneofFieldOneofCase.BoolField:
+ BoolField = other.BoolField;
+ break;
+ case OneofFieldOneofCase.StringField:
+ StringField = other.StringField;
+ break;
+ case OneofFieldOneofCase.BytesField:
+ BytesField = other.BytesField;
+ break;
+ }
+
+ }
+
+ public void MergeFrom(pb::CodedInputStream input) {
+ uint tag;
+ while (input.ReadTag(out tag)) {
+ switch(tag) {
+ case 0:
+ throw pb::InvalidProtocolBufferException.InvalidTag();
+ default:
+ if (pb::WireFormat.IsEndGroupTag(tag)) {
+ return;
+ }
+ break;
+ case 10: {
+ global::Google.Protobuf.WellKnownTypes.Any subBuilder = new global::Google.Protobuf.WellKnownTypes.Any();
+ if (oneofFieldCase_ == OneofFieldOneofCase.AnyField) {
+ subBuilder.MergeFrom(AnyField);
+ }
+ input.ReadMessage(subBuilder);
+ AnyField = subBuilder;
+ break;
+ }
+ case 18: {
+ global::Google.Protobuf.WellKnownTypes.Api subBuilder = new global::Google.Protobuf.WellKnownTypes.Api();
+ if (oneofFieldCase_ == OneofFieldOneofCase.ApiField) {
+ subBuilder.MergeFrom(ApiField);
+ }
+ input.ReadMessage(subBuilder);
+ ApiField = subBuilder;
+ break;
+ }
+ case 26: {
+ global::Google.Protobuf.WellKnownTypes.Duration subBuilder = new global::Google.Protobuf.WellKnownTypes.Duration();
+ if (oneofFieldCase_ == OneofFieldOneofCase.DurationField) {
+ subBuilder.MergeFrom(DurationField);
+ }
+ input.ReadMessage(subBuilder);
+ DurationField = subBuilder;
+ break;
+ }
+ case 34: {
+ global::Google.Protobuf.WellKnownTypes.Empty subBuilder = new global::Google.Protobuf.WellKnownTypes.Empty();
+ if (oneofFieldCase_ == OneofFieldOneofCase.EmptyField) {
+ subBuilder.MergeFrom(EmptyField);
+ }
+ input.ReadMessage(subBuilder);
+ EmptyField = subBuilder;
+ break;
+ }
+ case 42: {
+ global::Google.Protobuf.WellKnownTypes.FieldMask subBuilder = new global::Google.Protobuf.WellKnownTypes.FieldMask();
+ if (oneofFieldCase_ == OneofFieldOneofCase.FieldMaskField) {
+ subBuilder.MergeFrom(FieldMaskField);
+ }
+ input.ReadMessage(subBuilder);
+ FieldMaskField = subBuilder;
+ break;
+ }
+ case 50: {
+ global::Google.Protobuf.WellKnownTypes.SourceContext subBuilder = new global::Google.Protobuf.WellKnownTypes.SourceContext();
+ if (oneofFieldCase_ == OneofFieldOneofCase.SourceContextField) {
+ subBuilder.MergeFrom(SourceContextField);
+ }
+ input.ReadMessage(subBuilder);
+ SourceContextField = subBuilder;
+ break;
+ }
+ case 58: {
+ global::Google.Protobuf.WellKnownTypes.Struct subBuilder = new global::Google.Protobuf.WellKnownTypes.Struct();
+ if (oneofFieldCase_ == OneofFieldOneofCase.StructField) {
+ subBuilder.MergeFrom(StructField);
+ }
+ input.ReadMessage(subBuilder);
+ StructField = subBuilder;
+ break;
+ }
+ case 66: {
+ global::Google.Protobuf.WellKnownTypes.Timestamp subBuilder = new global::Google.Protobuf.WellKnownTypes.Timestamp();
+ if (oneofFieldCase_ == OneofFieldOneofCase.TimestampField) {
+ subBuilder.MergeFrom(TimestampField);
+ }
+ input.ReadMessage(subBuilder);
+ TimestampField = subBuilder;
+ break;
+ }
+ case 74: {
+ global::Google.Protobuf.WellKnownTypes.Type subBuilder = new global::Google.Protobuf.WellKnownTypes.Type();
+ if (oneofFieldCase_ == OneofFieldOneofCase.TypeField) {
+ subBuilder.MergeFrom(TypeField);
+ }
+ input.ReadMessage(subBuilder);
+ TypeField = subBuilder;
+ break;
+ }
+ case 82: {
+ DoubleField = _oneof_doubleField_codec.Read(input);
+ break;
+ }
+ case 90: {
+ FloatField = _oneof_floatField_codec.Read(input);
+ break;
+ }
+ case 98: {
+ Int64Field = _oneof_int64Field_codec.Read(input);
+ break;
+ }
+ case 106: {
+ Uint64Field = _oneof_uint64Field_codec.Read(input);
+ break;
+ }
+ case 114: {
+ Int32Field = _oneof_int32Field_codec.Read(input);
+ break;
+ }
+ case 122: {
+ Uint32Field = _oneof_uint32Field_codec.Read(input);
+ break;
+ }
+ case 130: {
+ BoolField = _oneof_boolField_codec.Read(input);
+ break;
+ }
+ case 138: {
+ StringField = _oneof_stringField_codec.Read(input);
+ break;
+ }
+ case 146: {
+ BytesField = _oneof_bytesField_codec.Read(input);
+ break;
+ }
+ }
+ }
+ }
+
+ }
+
+ [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+ public sealed partial class MapWellKnownTypes : pb::IMessage<MapWellKnownTypes> {
+ private static readonly pb::MessageParser<MapWellKnownTypes> _parser = new pb::MessageParser<MapWellKnownTypes>(() => new MapWellKnownTypes());
+ public static pb::MessageParser<MapWellKnownTypes> Parser { get { return _parser; } }
+
+ private static readonly string[] _fieldNames = new string[] { "any_field", "api_field", "bool_field", "bytes_field", "double_field", "duration_field", "empty_field", "field_mask_field", "float_field", "int32_field", "int64_field", "source_context_field", "string_field", "struct_field", "timestamp_field", "type_field", "uint32_field", "uint64_field" };
+ private static readonly uint[] _fieldTags = new uint[] { 10, 18, 130, 146, 82, 26, 34, 42, 90, 114, 98, 50, 138, 58, 66, 74, 122, 106 };
+ public static pbr::MessageDescriptor Descriptor {
+ get { return global::Google.Protobuf.TestProtos.UnittestWellKnownTypes.Descriptor.MessageTypes[3]; }
+ }
+
+ pbr::FieldAccessorTable pb::IReflectedMessage.Fields {
+ get { return global::Google.Protobuf.TestProtos.UnittestWellKnownTypes.internal__static_protobuf_unittest_MapWellKnownTypes__FieldAccessorTable; }
+ }
+
+ private bool _frozen = false;
+ public bool IsFrozen { get { return _frozen; } }
+
+ public MapWellKnownTypes() {
+ OnConstruction();
+ }
+
+ partial void OnConstruction();
+
+ public MapWellKnownTypes(MapWellKnownTypes other) : this() {
+ anyField_ = other.anyField_.Clone();
+ apiField_ = other.apiField_.Clone();
+ durationField_ = other.durationField_.Clone();
+ emptyField_ = other.emptyField_.Clone();
+ fieldMaskField_ = other.fieldMaskField_.Clone();
+ sourceContextField_ = other.sourceContextField_.Clone();
+ structField_ = other.structField_.Clone();
+ timestampField_ = other.timestampField_.Clone();
+ typeField_ = other.typeField_.Clone();
+ doubleField_ = other.doubleField_.Clone();
+ floatField_ = other.floatField_.Clone();
+ int64Field_ = other.int64Field_.Clone();
+ uint64Field_ = other.uint64Field_.Clone();
+ int32Field_ = other.int32Field_.Clone();
+ uint32Field_ = other.uint32Field_.Clone();
+ boolField_ = other.boolField_.Clone();
+ stringField_ = other.stringField_.Clone();
+ bytesField_ = other.bytesField_.Clone();
+ }
+
+ public MapWellKnownTypes Clone() {
+ return new MapWellKnownTypes(this);
+ }
+
+ public void Freeze() {
+ if (IsFrozen) {
+ return;
+ }
+ _frozen = true;
+ anyField_.Freeze();
+ apiField_.Freeze();
+ durationField_.Freeze();
+ emptyField_.Freeze();
+ fieldMaskField_.Freeze();
+ sourceContextField_.Freeze();
+ structField_.Freeze();
+ timestampField_.Freeze();
+ typeField_.Freeze();
+ doubleField_.Freeze();
+ floatField_.Freeze();
+ int64Field_.Freeze();
+ uint64Field_.Freeze();
+ int32Field_.Freeze();
+ uint32Field_.Freeze();
+ boolField_.Freeze();
+ stringField_.Freeze();
+ bytesField_.Freeze();
+ }
+
+ public const int AnyFieldFieldNumber = 1;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Any>.Codec _map_anyField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Any>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Any.Parser), 10);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Any> anyField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Any>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Any> AnyField {
+ get { return anyField_; }
+ }
+
+ public const int ApiFieldFieldNumber = 2;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Api>.Codec _map_apiField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Api>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Api.Parser), 18);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Api> apiField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Api>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Api> ApiField {
+ get { return apiField_; }
+ }
+
+ public const int DurationFieldFieldNumber = 3;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Duration>.Codec _map_durationField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Duration>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Duration.Parser), 26);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Duration> durationField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Duration>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Duration> DurationField {
+ get { return durationField_; }
+ }
+
+ public const int EmptyFieldFieldNumber = 4;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Empty>.Codec _map_emptyField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Empty>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Empty.Parser), 34);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Empty> emptyField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Empty>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Empty> EmptyField {
+ get { return emptyField_; }
+ }
+
+ public const int FieldMaskFieldFieldNumber = 5;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.FieldMask>.Codec _map_fieldMaskField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.FieldMask>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.FieldMask.Parser), 42);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.FieldMask> fieldMaskField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.FieldMask>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.FieldMask> FieldMaskField {
+ get { return fieldMaskField_; }
+ }
+
+ public const int SourceContextFieldFieldNumber = 6;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.SourceContext>.Codec _map_sourceContextField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.SourceContext>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.SourceContext.Parser), 50);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.SourceContext> sourceContextField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.SourceContext>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.SourceContext> SourceContextField {
+ get { return sourceContextField_; }
+ }
+
+ public const int StructFieldFieldNumber = 7;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Struct>.Codec _map_structField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Struct>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Struct.Parser), 58);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Struct> structField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Struct>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Struct> StructField {
+ get { return structField_; }
+ }
+
+ public const int TimestampFieldFieldNumber = 8;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Timestamp>.Codec _map_timestampField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Timestamp>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Timestamp.Parser), 66);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Timestamp> timestampField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Timestamp>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Timestamp> TimestampField {
+ get { return timestampField_; }
+ }
+
+ public const int TypeFieldFieldNumber = 9;
+ private static readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Type>.Codec _map_typeField_codec
+ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Type>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForMessage(18, global::Google.Protobuf.WellKnownTypes.Type.Parser), 74);
+ private readonly pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Type> typeField_ = new pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Type>();
+ public pbc::MapField<int, global::Google.Protobuf.WellKnownTypes.Type> TypeField {
+ get { return typeField_; }
+ }
+
+ public const int DoubleFieldFieldNumber = 10;
+ private static readonly pbc::MapField<int, double?>.Codec _map_doubleField_codec
+ = new pbc::MapField<int, double?>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForStructWrapper<double>(18), 82);
+ private readonly pbc::MapField<int, double?> doubleField_ = new pbc::MapField<int, double?>(true);
+ public pbc::MapField<int, double?> DoubleField {
+ get { return doubleField_; }
+ }
+
+ public const int FloatFieldFieldNumber = 11;
+ private static readonly pbc::MapField<int, float?>.Codec _map_floatField_codec
+ = new pbc::MapField<int, float?>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForStructWrapper<float>(18), 90);
+ private readonly pbc::MapField<int, float?> floatField_ = new pbc::MapField<int, float?>(true);
+ public pbc::MapField<int, float?> FloatField {
+ get { return floatField_; }
+ }
+
+ public const int Int64FieldFieldNumber = 12;
+ private static readonly pbc::MapField<int, long?>.Codec _map_int64Field_codec
+ = new pbc::MapField<int, long?>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForStructWrapper<long>(18), 98);
+ private readonly pbc::MapField<int, long?> int64Field_ = new pbc::MapField<int, long?>(true);
+ public pbc::MapField<int, long?> Int64Field {
+ get { return int64Field_; }
+ }
+
+ public const int Uint64FieldFieldNumber = 13;
+ private static readonly pbc::MapField<int, ulong?>.Codec _map_uint64Field_codec
+ = new pbc::MapField<int, ulong?>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForStructWrapper<ulong>(18), 106);
+ private readonly pbc::MapField<int, ulong?> uint64Field_ = new pbc::MapField<int, ulong?>(true);
+ public pbc::MapField<int, ulong?> Uint64Field {
+ get { return uint64Field_; }
+ }
+
+ public const int Int32FieldFieldNumber = 14;
+ private static readonly pbc::MapField<int, int?>.Codec _map_int32Field_codec
+ = new pbc::MapField<int, int?>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForStructWrapper<int>(18), 114);
+ private readonly pbc::MapField<int, int?> int32Field_ = new pbc::MapField<int, int?>(true);
+ public pbc::MapField<int, int?> Int32Field {
+ get { return int32Field_; }
+ }
+
+ public const int Uint32FieldFieldNumber = 15;
+ private static readonly pbc::MapField<int, uint?>.Codec _map_uint32Field_codec
+ = new pbc::MapField<int, uint?>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForStructWrapper<uint>(18), 122);
+ private readonly pbc::MapField<int, uint?> uint32Field_ = new pbc::MapField<int, uint?>(true);
+ public pbc::MapField<int, uint?> Uint32Field {
+ get { return uint32Field_; }
+ }
+
+ public const int BoolFieldFieldNumber = 16;
+ private static readonly pbc::MapField<int, bool?>.Codec _map_boolField_codec
+ = new pbc::MapField<int, bool?>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForStructWrapper<bool>(18), 130);
+ private readonly pbc::MapField<int, bool?> boolField_ = new pbc::MapField<int, bool?>(true);
+ public pbc::MapField<int, bool?> BoolField {
+ get { return boolField_; }
+ }
+
+ public const int StringFieldFieldNumber = 17;
+ private static readonly pbc::MapField<int, string>.Codec _map_stringField_codec
+ = new pbc::MapField<int, string>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForClassWrapper<string>(18), 138);
+ private readonly pbc::MapField<int, string> stringField_ = new pbc::MapField<int, string>(true);
+ public pbc::MapField<int, string> StringField {
+ get { return stringField_; }
+ }
+
+ public const int BytesFieldFieldNumber = 18;
+ private static readonly pbc::MapField<int, pb::ByteString>.Codec _map_bytesField_codec
+ = new pbc::MapField<int, pb::ByteString>.Codec(pb::FieldCodec.ForInt32(8), pb::FieldCodec.ForClassWrapper<pb::ByteString>(18), 146);
+ private readonly pbc::MapField<int, pb::ByteString> bytesField_ = new pbc::MapField<int, pb::ByteString>(true);
+ public pbc::MapField<int, pb::ByteString> BytesField {
+ get { return bytesField_; }
+ }
+
+ public override bool Equals(object other) {
+ return Equals(other as MapWellKnownTypes);
+ }
+
+ public bool Equals(MapWellKnownTypes other) {
+ if (ReferenceEquals(other, null)) {
+ return false;
+ }
+ if (ReferenceEquals(other, this)) {
+ return true;
+ }
+ if (!AnyField.Equals(other.AnyField)) return false;
+ if (!ApiField.Equals(other.ApiField)) return false;
+ if (!DurationField.Equals(other.DurationField)) return false;
+ if (!EmptyField.Equals(other.EmptyField)) return false;
+ if (!FieldMaskField.Equals(other.FieldMaskField)) return false;
+ if (!SourceContextField.Equals(other.SourceContextField)) return false;
+ if (!StructField.Equals(other.StructField)) return false;
+ if (!TimestampField.Equals(other.TimestampField)) return false;
+ if (!TypeField.Equals(other.TypeField)) return false;
+ if (!DoubleField.Equals(other.DoubleField)) return false;
+ if (!FloatField.Equals(other.FloatField)) return false;
+ if (!Int64Field.Equals(other.Int64Field)) return false;
+ if (!Uint64Field.Equals(other.Uint64Field)) return false;
+ if (!Int32Field.Equals(other.Int32Field)) return false;
+ if (!Uint32Field.Equals(other.Uint32Field)) return false;
+ if (!BoolField.Equals(other.BoolField)) return false;
+ if (!StringField.Equals(other.StringField)) return false;
+ if (!BytesField.Equals(other.BytesField)) return false;
+ return true;
+ }
+
+ public override int GetHashCode() {
+ int hash = 1;
+ hash ^= AnyField.GetHashCode();
+ hash ^= ApiField.GetHashCode();
+ hash ^= DurationField.GetHashCode();
+ hash ^= EmptyField.GetHashCode();
+ hash ^= FieldMaskField.GetHashCode();
+ hash ^= SourceContextField.GetHashCode();
+ hash ^= StructField.GetHashCode();
+ hash ^= TimestampField.GetHashCode();
+ hash ^= TypeField.GetHashCode();
+ hash ^= DoubleField.GetHashCode();
+ hash ^= FloatField.GetHashCode();
+ hash ^= Int64Field.GetHashCode();
+ hash ^= Uint64Field.GetHashCode();
+ hash ^= Int32Field.GetHashCode();
+ hash ^= Uint32Field.GetHashCode();
+ hash ^= BoolField.GetHashCode();
+ hash ^= StringField.GetHashCode();
+ hash ^= BytesField.GetHashCode();
+ return hash;
+ }
+
+ public override string ToString() {
+ return pb::JsonFormatter.Default.Format(this);
+ }
+
+ public void WriteTo(pb::CodedOutputStream output) {
+ anyField_.WriteTo(output, _map_anyField_codec);
+ apiField_.WriteTo(output, _map_apiField_codec);
+ durationField_.WriteTo(output, _map_durationField_codec);
+ emptyField_.WriteTo(output, _map_emptyField_codec);
+ fieldMaskField_.WriteTo(output, _map_fieldMaskField_codec);
+ sourceContextField_.WriteTo(output, _map_sourceContextField_codec);
+ structField_.WriteTo(output, _map_structField_codec);
+ timestampField_.WriteTo(output, _map_timestampField_codec);
+ typeField_.WriteTo(output, _map_typeField_codec);
+ doubleField_.WriteTo(output, _map_doubleField_codec);
+ floatField_.WriteTo(output, _map_floatField_codec);
+ int64Field_.WriteTo(output, _map_int64Field_codec);
+ uint64Field_.WriteTo(output, _map_uint64Field_codec);
+ int32Field_.WriteTo(output, _map_int32Field_codec);
+ uint32Field_.WriteTo(output, _map_uint32Field_codec);
+ boolField_.WriteTo(output, _map_boolField_codec);
+ stringField_.WriteTo(output, _map_stringField_codec);
+ bytesField_.WriteTo(output, _map_bytesField_codec);
+ }
+
+ public int CalculateSize() {
+ int size = 0;
+ size += anyField_.CalculateSize(_map_anyField_codec);
+ size += apiField_.CalculateSize(_map_apiField_codec);
+ size += durationField_.CalculateSize(_map_durationField_codec);
+ size += emptyField_.CalculateSize(_map_emptyField_codec);
+ size += fieldMaskField_.CalculateSize(_map_fieldMaskField_codec);
+ size += sourceContextField_.CalculateSize(_map_sourceContextField_codec);
+ size += structField_.CalculateSize(_map_structField_codec);
+ size += timestampField_.CalculateSize(_map_timestampField_codec);
+ size += typeField_.CalculateSize(_map_typeField_codec);
+ size += doubleField_.CalculateSize(_map_doubleField_codec);
+ size += floatField_.CalculateSize(_map_floatField_codec);
+ size += int64Field_.CalculateSize(_map_int64Field_codec);
+ size += uint64Field_.CalculateSize(_map_uint64Field_codec);
+ size += int32Field_.CalculateSize(_map_int32Field_codec);
+ size += uint32Field_.CalculateSize(_map_uint32Field_codec);
+ size += boolField_.CalculateSize(_map_boolField_codec);
+ size += stringField_.CalculateSize(_map_stringField_codec);
+ size += bytesField_.CalculateSize(_map_bytesField_codec);
+ return size;
+ }
+
+ public void MergeFrom(MapWellKnownTypes other) {
+ if (other == null) {
+ return;
+ }
+ anyField_.Add(other.anyField_);
+ apiField_.Add(other.apiField_);
+ durationField_.Add(other.durationField_);
+ emptyField_.Add(other.emptyField_);
+ fieldMaskField_.Add(other.fieldMaskField_);
+ sourceContextField_.Add(other.sourceContextField_);
+ structField_.Add(other.structField_);
+ timestampField_.Add(other.timestampField_);
+ typeField_.Add(other.typeField_);
+ doubleField_.Add(other.doubleField_);
+ floatField_.Add(other.floatField_);
+ int64Field_.Add(other.int64Field_);
+ uint64Field_.Add(other.uint64Field_);
+ int32Field_.Add(other.int32Field_);
+ uint32Field_.Add(other.uint32Field_);
+ boolField_.Add(other.boolField_);
+ stringField_.Add(other.stringField_);
+ bytesField_.Add(other.bytesField_);
+ }
+
+ public void MergeFrom(pb::CodedInputStream input) {
+ uint tag;
+ while (input.ReadTag(out tag)) {
+ switch(tag) {
+ case 0:
+ throw pb::InvalidProtocolBufferException.InvalidTag();
+ default:
+ if (pb::WireFormat.IsEndGroupTag(tag)) {
+ return;
+ }
+ break;
+ case 10: {
+ anyField_.AddEntriesFrom(input, _map_anyField_codec);
+ break;
+ }
+ case 18: {
+ apiField_.AddEntriesFrom(input, _map_apiField_codec);
+ break;
+ }
+ case 26: {
+ durationField_.AddEntriesFrom(input, _map_durationField_codec);
+ break;
+ }
+ case 34: {
+ emptyField_.AddEntriesFrom(input, _map_emptyField_codec);
+ break;
+ }
+ case 42: {
+ fieldMaskField_.AddEntriesFrom(input, _map_fieldMaskField_codec);
+ break;
+ }
+ case 50: {
+ sourceContextField_.AddEntriesFrom(input, _map_sourceContextField_codec);
+ break;
+ }
+ case 58: {
+ structField_.AddEntriesFrom(input, _map_structField_codec);
+ break;
+ }
+ case 66: {
+ timestampField_.AddEntriesFrom(input, _map_timestampField_codec);
+ break;
+ }
+ case 74: {
+ typeField_.AddEntriesFrom(input, _map_typeField_codec);
+ break;
+ }
+ case 82: {
+ doubleField_.AddEntriesFrom(input, _map_doubleField_codec);
+ break;
+ }
+ case 90: {
+ floatField_.AddEntriesFrom(input, _map_floatField_codec);
+ break;
+ }
+ case 98: {
+ int64Field_.AddEntriesFrom(input, _map_int64Field_codec);
+ break;
+ }
+ case 106: {
+ uint64Field_.AddEntriesFrom(input, _map_uint64Field_codec);
+ break;
+ }
+ case 114: {
+ int32Field_.AddEntriesFrom(input, _map_int32Field_codec);
+ break;
+ }
+ case 122: {
+ uint32Field_.AddEntriesFrom(input, _map_uint32Field_codec);
+ break;
+ }
+ case 130: {
+ boolField_.AddEntriesFrom(input, _map_boolField_codec);
+ break;
+ }
+ case 138: {
+ stringField_.AddEntriesFrom(input, _map_stringField_codec);
+ break;
+ }
+ case 146: {
+ bytesField_.AddEntriesFrom(input, _map_bytesField_codec);
+ break;
+ }
+ }
+ }
+ }
+
+ }
+
+ #endregion
+
+}
+
+#endregion Designer generated code
diff --git a/csharp/src/ProtocolBuffers.Test/WellKnownTypes/WrappersTest.cs b/csharp/src/ProtocolBuffers.Test/WellKnownTypes/WrappersTest.cs
new file mode 100644
index 0000000..ad88c4e
--- /dev/null
+++ b/csharp/src/ProtocolBuffers.Test/WellKnownTypes/WrappersTest.cs
@@ -0,0 +1,326 @@
+#region Copyright notice and license
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+using Google.Protobuf.TestProtos;
+using NUnit.Framework;
+using System.Collections;
+using System.IO;
+
+namespace Google.Protobuf.WellKnownTypes
+{
+ public class WrappersTest
+ {
+ [Test]
+ public void NullIsDefault()
+ {
+ var message = new TestWellKnownTypes();
+ Assert.IsNull(message.StringField);
+ Assert.IsNull(message.BytesField);
+ Assert.IsNull(message.BoolField);
+ Assert.IsNull(message.FloatField);
+ Assert.IsNull(message.DoubleField);
+ Assert.IsNull(message.Int32Field);
+ Assert.IsNull(message.Int64Field);
+ Assert.IsNull(message.Uint32Field);
+ Assert.IsNull(message.Uint64Field);
+ }
+
+ [Test]
+ public void NonDefaultSingleValues()
+ {
+ var message = new TestWellKnownTypes
+ {
+ StringField = "x",
+ BytesField = ByteString.CopyFrom(1, 2, 3),
+ BoolField = true,
+ FloatField = 12.5f,
+ DoubleField = 12.25d,
+ Int32Field = 1,
+ Int64Field = 2,
+ Uint32Field = 3,
+ Uint64Field = 4
+ };
+
+ var bytes = message.ToByteArray();
+ var parsed = TestWellKnownTypes.Parser.ParseFrom(bytes);
+
+ Assert.AreEqual("x", parsed.StringField);
+ Assert.AreEqual(ByteString.CopyFrom(1, 2, 3), parsed.BytesField);
+ Assert.AreEqual(true, parsed.BoolField);
+ Assert.AreEqual(12.5f, parsed.FloatField);
+ Assert.AreEqual(12.25d, parsed.DoubleField);
+ Assert.AreEqual(1, parsed.Int32Field);
+ Assert.AreEqual(2L, parsed.Int64Field);
+ Assert.AreEqual(3U, parsed.Uint32Field);
+ Assert.AreEqual(4UL, parsed.Uint64Field);
+ }
+
+ [Test]
+ public void NonNullDefaultIsPreservedThroughSerialization()
+ {
+ var message = new TestWellKnownTypes
+ {
+ StringField = "",
+ BytesField = ByteString.Empty,
+ BoolField = false,
+ FloatField = 0f,
+ DoubleField = 0d,
+ Int32Field = 0,
+ Int64Field = 0,
+ Uint32Field = 0,
+ Uint64Field = 0
+ };
+
+ var bytes = message.ToByteArray();
+ var parsed = TestWellKnownTypes.Parser.ParseFrom(bytes);
+
+ Assert.AreEqual("", parsed.StringField);
+ Assert.AreEqual(ByteString.Empty, parsed.BytesField);
+ Assert.AreEqual(false, parsed.BoolField);
+ Assert.AreEqual(0f, parsed.FloatField);
+ Assert.AreEqual(0d, parsed.DoubleField);
+ Assert.AreEqual(0, parsed.Int32Field);
+ Assert.AreEqual(0L, parsed.Int64Field);
+ Assert.AreEqual(0U, parsed.Uint32Field);
+ Assert.AreEqual(0UL, parsed.Uint64Field);
+ }
+
+ [Test]
+ public void RepeatedWrappersProhibitNullItems()
+ {
+ var message = new RepeatedWellKnownTypes();
+ Assert.Throws<ArgumentNullException>(() => message.BoolField.Add((bool?) null));
+ Assert.Throws<ArgumentNullException>(() => message.Int32Field.Add((int?) null));
+ Assert.Throws<ArgumentNullException>(() => message.StringField.Add((string) null));
+ Assert.Throws<ArgumentNullException>(() => message.BytesField.Add((ByteString) null));
+ }
+
+ [Test]
+ public void RepeatedWrappersSerializeDeserialize()
+ {
+ var message = new RepeatedWellKnownTypes
+ {
+ BoolField = { true, false },
+ BytesField = { ByteString.CopyFrom(1, 2, 3), ByteString.CopyFrom(4, 5, 6), ByteString.Empty },
+ DoubleField = { 12.5, -1.5, 0d },
+ FloatField = { 123.25f, -20f, 0f },
+ Int32Field = { int.MaxValue, int.MinValue, 0 },
+ Int64Field = { long.MaxValue, long.MinValue, 0L },
+ StringField = { "First", "Second", "" },
+ Uint32Field = { uint.MaxValue, uint.MinValue, 0U },
+ Uint64Field = { ulong.MaxValue, ulong.MinValue, 0UL },
+ };
+ var bytes = message.ToByteArray();
+ var parsed = RepeatedWellKnownTypes.Parser.ParseFrom(bytes);
+
+ Assert.AreEqual(message, parsed);
+ // Just to test a single value for sanity...
+ Assert.AreEqual("Second", message.StringField[1]);
+ }
+
+ [Test]
+ public void MapWrappersSerializeDeserialize()
+ {
+ var message = new MapWellKnownTypes
+ {
+ BoolField = { { 10, false }, { 20, true } },
+ BytesField = {
+ { -1, ByteString.CopyFrom(1, 2, 3) },
+ { 10, ByteString.CopyFrom(4, 5, 6) },
+ { 1000, ByteString.Empty },
+ { 10000, null }
+ },
+ DoubleField = { { 1, 12.5 }, { 10, -1.5 }, { 20, 0d } },
+ FloatField = { { 2, 123.25f }, { 3, -20f }, { 4, 0f } },
+ Int32Field = { { 5, int.MaxValue }, { 6, int.MinValue }, { 7, 0 } },
+ Int64Field = { { 8, long.MaxValue }, { 9, long.MinValue }, { 10, 0L } },
+ StringField = { { 11, "First" }, { 12, "Second" }, { 13, "" }, { 14, null } },
+ Uint32Field = { { 15, uint.MaxValue }, { 16, uint.MinValue }, { 17, 0U } },
+ Uint64Field = { { 18, ulong.MaxValue }, { 19, ulong.MinValue }, { 20, 0UL } },
+ };
+
+ var bytes = message.ToByteArray();
+ var parsed = MapWellKnownTypes.Parser.ParseFrom(bytes);
+
+ Assert.AreEqual(message, parsed);
+ // Just to test a single value for sanity...
+ Assert.AreEqual("Second", message.StringField[12]);
+ }
+
+ [Test]
+ public void Reflection_SingleValues()
+ {
+ var message = new TestWellKnownTypes
+ {
+ StringField = "x",
+ BytesField = ByteString.CopyFrom(1, 2, 3),
+ BoolField = true,
+ FloatField = 12.5f,
+ DoubleField = 12.25d,
+ Int32Field = 1,
+ Int64Field = 2,
+ Uint32Field = 3,
+ Uint64Field = 4
+ };
+ var fields = ((IReflectedMessage) message).Fields;
+
+ Assert.AreEqual("x", fields[TestWellKnownTypes.StringFieldFieldNumber].GetValue(message));
+ Assert.AreEqual(ByteString.CopyFrom(1, 2, 3), fields[TestWellKnownTypes.BytesFieldFieldNumber].GetValue(message));
+ Assert.AreEqual(true, fields[TestWellKnownTypes.BoolFieldFieldNumber].GetValue(message));
+ Assert.AreEqual(12.5f, fields[TestWellKnownTypes.FloatFieldFieldNumber].GetValue(message));
+ Assert.AreEqual(12.25d, fields[TestWellKnownTypes.DoubleFieldFieldNumber].GetValue(message));
+ Assert.AreEqual(1, fields[TestWellKnownTypes.Int32FieldFieldNumber].GetValue(message));
+ Assert.AreEqual(2L, fields[TestWellKnownTypes.Int64FieldFieldNumber].GetValue(message));
+ Assert.AreEqual(3U, fields[TestWellKnownTypes.Uint32FieldFieldNumber].GetValue(message));
+ Assert.AreEqual(4UL, fields[TestWellKnownTypes.Uint64FieldFieldNumber].GetValue(message));
+
+ // And a couple of null fields...
+ message.StringField = null;
+ message.FloatField = null;
+ Assert.IsNull(fields[TestWellKnownTypes.StringFieldFieldNumber].GetValue(message));
+ Assert.IsNull(fields[TestWellKnownTypes.FloatFieldFieldNumber].GetValue(message));
+ }
+
+ [Test]
+ public void Reflection_RepeatedFields()
+ {
+ // Just a single example... note that we can't have a null value here
+ var message = new RepeatedWellKnownTypes { Int32Field = { 1, 2 } };
+ var fields = ((IReflectedMessage) message).Fields;
+ var list = (IList) fields[RepeatedWellKnownTypes.Int32FieldFieldNumber].GetValue(message);
+ CollectionAssert.AreEqual(new[] { 1, 2 }, list);
+ }
+
+ [Test]
+ public void Reflection_MapFields()
+ {
+ // Just a single example... note that we can't have a null value here
+ var message = new MapWellKnownTypes { Int32Field = { { 1, 2 }, { 3, null } } };
+ var fields = ((IReflectedMessage) message).Fields;
+ var dictionary = (IDictionary) fields[MapWellKnownTypes.Int32FieldFieldNumber].GetValue(message);
+ Assert.AreEqual(2, dictionary[1]);
+ Assert.IsNull(dictionary[3]);
+ Assert.IsTrue(dictionary.Contains(3));
+ }
+
+ [Test]
+ public void Oneof()
+ {
+ var message = new OneofWellKnownTypes { EmptyField = new Empty() };
+ // Start off with a non-wrapper
+ Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.EmptyField, message.OneofFieldCase);
+ AssertOneofRoundTrip(message);
+
+ message.StringField = "foo";
+ Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.StringField, message.OneofFieldCase);
+ AssertOneofRoundTrip(message);
+
+ message.StringField = "foo";
+ Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.StringField, message.OneofFieldCase);
+ AssertOneofRoundTrip(message);
+
+ message.DoubleField = 0.0f;
+ Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.DoubleField, message.OneofFieldCase);
+ AssertOneofRoundTrip(message);
+
+ message.DoubleField = 1.0f;
+ Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.DoubleField, message.OneofFieldCase);
+ AssertOneofRoundTrip(message);
+
+ message.ClearOneofField();
+ Assert.AreEqual(OneofWellKnownTypes.OneofFieldOneofCase.None, message.OneofFieldCase);
+ AssertOneofRoundTrip(message);
+ }
+
+ private void AssertOneofRoundTrip(OneofWellKnownTypes message)
+ {
+ // Normal roundtrip, but explicitly checking the case...
+ var bytes = message.ToByteArray();
+ var parsed = OneofWellKnownTypes.Parser.ParseFrom(bytes);
+ Assert.AreEqual(message, parsed);
+ Assert.AreEqual(message.OneofFieldCase, parsed.OneofFieldCase);
+ }
+
+ [Test]
+ [TestCase("x", "y", "y")]
+ [TestCase("x", "", "x")]
+ [TestCase("x", null, "x")]
+ [TestCase("", "y", "y")]
+ [TestCase("", "", "")]
+ [TestCase("", null, "")]
+ [TestCase(null, "y", "y")]
+ [TestCase(null, "", "")]
+ [TestCase(null, null, null)]
+ public void Merging(string original, string merged, string expected)
+ {
+ var originalMessage = new TestWellKnownTypes { StringField = original };
+ var mergingMessage = new TestWellKnownTypes { StringField = merged };
+ originalMessage.MergeFrom(mergingMessage);
+ Assert.AreEqual(expected, originalMessage.StringField);
+
+ // Try it using MergeFrom(CodedInputStream) too...
+ originalMessage = new TestWellKnownTypes { StringField = original };
+ originalMessage.MergeFrom(mergingMessage.ToByteArray());
+ Assert.AreEqual(expected, originalMessage.StringField);
+ }
+
+ // Merging is odd with wrapper types, due to the way that default values aren't emitted in
+ // the binary stream. In fact we cheat a little bit - a message with an explicitly present default
+ // value will have that default value ignored.
+ [Test]
+ public void MergingCornerCase()
+ {
+ var message = new TestWellKnownTypes { Int32Field = 5 };
+
+ // Create a byte array which has the data of an Int32Value explicitly containing a value of 0.
+ // This wouldn't normally happen.
+ byte[] bytes;
+ var wrapperTag = WireFormat.MakeTag(TestWellKnownTypes.Int32FieldFieldNumber, WireFormat.WireType.LengthDelimited);
+ var valueTag = WireFormat.MakeTag(Int32Value.ValueFieldNumber, WireFormat.WireType.Varint);
+ using (var stream = new MemoryStream())
+ {
+ var coded = CodedOutputStream.CreateInstance(stream);
+ coded.WriteTag(wrapperTag);
+ coded.WriteLength(2); // valueTag + a value 0, each one byte
+ coded.WriteTag(valueTag);
+ coded.WriteInt32(0);
+ coded.Flush();
+ bytes = stream.ToArray();
+ }
+
+ message.MergeFrom(bytes);
+ // A normal implementation would have 0 now, as the explicit default would have been overwritten the 5.
+ Assert.AreEqual(5, message.Int32Field);
+ }
+ }
+}
diff --git a/csharp/src/ProtocolBuffers/ByteString.cs b/csharp/src/ProtocolBuffers/ByteString.cs
index 738f020..329f47f 100644
--- a/csharp/src/ProtocolBuffers/ByteString.cs
+++ b/csharp/src/ProtocolBuffers/ByteString.cs
@@ -212,11 +212,22 @@
{
return true;
}
- if (ReferenceEquals(lhs, null))
+ if (ReferenceEquals(lhs, null) || ReferenceEquals(rhs, null))
{
return false;
}
- return lhs.Equals(rhs);
+ if (lhs.bytes.Length != rhs.bytes.Length)
+ {
+ return false;
+ }
+ for (int i = 0; i < lhs.Length; i++)
+ {
+ if (rhs.bytes[i] != lhs.bytes[i])
+ {
+ return false;
+ }
+ }
+ return true;
}
public static bool operator !=(ByteString lhs, ByteString rhs)
@@ -228,12 +239,7 @@
public override bool Equals(object obj)
{
- ByteString other = obj as ByteString;
- if (obj == null)
- {
- return false;
- }
- return Equals(other);
+ return this == (obj as ByteString);
}
public override int GetHashCode()
@@ -248,18 +254,7 @@
public bool Equals(ByteString other)
{
- if (other.bytes.Length != bytes.Length)
- {
- return false;
- }
- for (int i = 0; i < bytes.Length; i++)
- {
- if (other.bytes[i] != bytes[i])
- {
- return false;
- }
- }
- return true;
+ return this == other;
}
/// <summary>
diff --git a/csharp/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs b/csharp/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs
index a3e7c1b..bf221c9 100644
--- a/csharp/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs
+++ b/csharp/src/ProtocolBuffers/CodedOutputStream.ComputeSize.cs
@@ -129,8 +129,7 @@
public static int ComputeStringSize(String value)
{
int byteArraySize = Utf8Encoding.GetByteCount(value);
- return ComputeRawVarint32Size((uint) byteArraySize) +
- byteArraySize;
+ return ComputeLengthSize(byteArraySize) + byteArraySize;
}
/// <summary>
@@ -149,7 +148,7 @@
public static int ComputeMessageSize(IMessage value)
{
int size = value.CalculateSize();
- return ComputeRawVarint32Size((uint) size) + size;
+ return ComputeLengthSize(size) + size;
}
/// <summary>
@@ -158,8 +157,7 @@
/// </summary>
public static int ComputeBytesSize(ByteString value)
{
- return ComputeRawVarint32Size((uint) value.Length) +
- value.Length;
+ return ComputeLengthSize(value.Length) + value.Length;
}
/// <summary>
diff --git a/csharp/src/ProtocolBuffers/CodedOutputStream.cs b/csharp/src/ProtocolBuffers/CodedOutputStream.cs
index 53f04c7..b91d6d7 100644
--- a/csharp/src/ProtocolBuffers/CodedOutputStream.cs
+++ b/csharp/src/ProtocolBuffers/CodedOutputStream.cs
@@ -274,7 +274,7 @@
/// <param name="value">The value to write</param>
public void WriteMessage(IMessage value)
{
- WriteRawVarint32((uint) value.CalculateSize());
+ WriteLength(value.CalculateSize());
value.WriteTo(this);
}
@@ -285,7 +285,7 @@
/// <param name="value">The value to write</param>
public void WriteBytes(ByteString value)
{
- WriteRawVarint32((uint) value.Length);
+ WriteLength(value.Length);
value.WriteRawBytesTo(this);
}
diff --git a/csharp/src/ProtocolBuffers/Collections/MapField.cs b/csharp/src/ProtocolBuffers/Collections/MapField.cs
index 0f379ea..f5e4fd3 100644
--- a/csharp/src/ProtocolBuffers/Collections/MapField.cs
+++ b/csharp/src/ProtocolBuffers/Collections/MapField.cs
@@ -51,14 +51,38 @@
public sealed class MapField<TKey, TValue> : IDeepCloneable<MapField<TKey, TValue>>, IFreezable, IDictionary<TKey, TValue>, IEquatable<MapField<TKey, TValue>>, IDictionary
{
// TODO: Don't create the map/list until we have an entry. (Assume many maps will be empty.)
+ private readonly bool allowNullValues;
private bool frozen;
private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> map =
new Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>>();
private readonly LinkedList<KeyValuePair<TKey, TValue>> list = new LinkedList<KeyValuePair<TKey, TValue>>();
+ /// <summary>
+ /// Constructs a new map field, defaulting the value nullability to only allow null values for message types
+ /// and non-nullable value types.
+ /// </summary>
+ public MapField() : this(typeof(IMessage).IsAssignableFrom(typeof(TValue)) || Nullable.GetUnderlyingType(typeof(TValue)) != null)
+ {
+ }
+
+ /// <summary>
+ /// Constructs a new map field, overriding the choice of whether null values are permitted in the map.
+ /// This is used by wrapper types, where maps with string and bytes wrappers as the value types
+ /// support null values.
+ /// </summary>
+ /// <param name="allowNullValues">Whether null values are permitted in the map or not.</param>
+ public MapField(bool allowNullValues)
+ {
+ if (allowNullValues && typeof(TValue).IsValueType && Nullable.GetUnderlyingType(typeof(TValue)) == null)
+ {
+ throw new ArgumentException("allowNullValues", "Non-nullable value types do not support null values");
+ }
+ this.allowNullValues = allowNullValues;
+ }
+
public MapField<TKey, TValue> Clone()
{
- var clone = new MapField<TKey, TValue>();
+ var clone = new MapField<TKey, TValue>(allowNullValues);
// Keys are never cloneable. Values might be.
if (typeof(IDeepCloneable<TValue>).IsAssignableFrom(typeof(TValue)))
{
@@ -138,7 +162,8 @@
set
{
ThrowHelper.ThrowIfNull(key, "key");
- if (value == null && (typeof(TValue) == typeof(ByteString) || typeof(TValue) == typeof(string)))
+ // value == null check here is redundant, but avoids boxing.
+ if (value == null && !allowNullValues)
{
ThrowHelper.ThrowIfNull(value, "value");
}
@@ -225,6 +250,11 @@
}
}
+ /// <summary>
+ /// Returns whether or not this map allows values to be null.
+ /// </summary>
+ public bool AllowsNullValues { get { return allowNullValues; } }
+
public int Count { get { return list.Count; } }
public bool IsReadOnly { get { return frozen; } }
diff --git a/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs b/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
index 8375ae0..9bab41e 100644
--- a/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
+++ b/csharp/src/ProtocolBuffers/Collections/RepeatedField.cs
@@ -123,7 +123,7 @@
{
int dataSize = CalculatePackedDataSize(codec);
return CodedOutputStream.ComputeRawVarint32Size(tag) +
- CodedOutputStream.ComputeRawVarint32Size((uint)dataSize) +
+ CodedOutputStream.ComputeLengthSize(dataSize) +
dataSize;
}
else
diff --git a/csharp/src/ProtocolBuffers/FieldCodec.cs b/csharp/src/ProtocolBuffers/FieldCodec.cs
index c72a3e7..8546278 100644
--- a/csharp/src/ProtocolBuffers/FieldCodec.cs
+++ b/csharp/src/ProtocolBuffers/FieldCodec.cs
@@ -29,7 +29,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion
-
+
using System;
using System.Collections.Generic;
@@ -43,7 +43,7 @@
// TODO: Avoid the "dual hit" of lambda expressions: create open delegates instead. (At least test...)
public static FieldCodec<string> ForString(uint tag)
{
- return new FieldCodec<string>(input => input.ReadString(), (output, value) => output.WriteString(value), CodedOutputStream.ComputeStringSize, tag);
+ return new FieldCodec<string>(input => input.ReadString(), (output, value) => output.WriteString(value), CodedOutputStream.ComputeStringSize, tag);
}
public static FieldCodec<ByteString> ForBytes(uint tag)
@@ -131,6 +131,116 @@
return new FieldCodec<T>(input => { T message = parser.CreateTemplate(); input.ReadMessage(message); return message; },
(output, value) => output.WriteMessage(value), message => CodedOutputStream.ComputeMessageSize(message), tag);
}
+
+ /// <summary>
+ /// Creates a codec for a wrapper type of a class - which must be string or ByteString.
+ /// </summary>
+ public static FieldCodec<T> ForClassWrapper<T>(uint tag) where T : class
+ {
+ var nestedCodec = WrapperCodecs.GetCodec<T>();
+ return new FieldCodec<T>(
+ input => WrapperCodecs.Read<T>(input, nestedCodec),
+ (output, value) => WrapperCodecs.Write<T>(output, value, nestedCodec),
+ value => WrapperCodecs.CalculateSize<T>(value, nestedCodec),
+ tag,
+ null); // Default value for the wrapper
+ }
+
+ /// <summary>
+ /// Creates a codec for a wrapper type of a struct - which must be Int32, Int64, UInt32, UInt64,
+ /// Bool, Single or Double.
+ /// </summary>
+ public static FieldCodec<T?> ForStructWrapper<T>(uint tag) where T : struct
+ {
+ var nestedCodec = WrapperCodecs.GetCodec<T>();
+ return new FieldCodec<T?>(
+ input => WrapperCodecs.Read<T>(input, nestedCodec),
+ (output, value) => WrapperCodecs.Write<T>(output, value.Value, nestedCodec),
+ value => value == null ? 0 : WrapperCodecs.CalculateSize<T>(value.Value, nestedCodec),
+ tag,
+ null); // Default value for the wrapper
+ }
+
+ /// <summary>
+ /// Helper code to create codecs for wrapper types.
+ /// </summary>
+ /// <remarks>
+ /// Somewhat ugly with all the static methods, but the conversions involved to/from nullable types make it
+ /// slightly tricky to improve. So long as we keep the public API (ForClassWrapper, ForStructWrapper) in place,
+ /// we can refactor later if we come up with something cleaner.
+ /// </remarks>
+ private static class WrapperCodecs
+ {
+ // All the field numbers are the same (1).
+ private const int WrapperValueFieldNumber = Google.Protobuf.WellKnownTypes.Int32Value.ValueFieldNumber;
+
+ private static readonly Dictionary<Type, object> Codecs = new Dictionary<Type, object>
+ {
+ { typeof(bool), ForBool(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+ { typeof(int), ForInt32(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+ { typeof(long), ForInt64(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+ { typeof(uint), ForUInt32(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+ { typeof(ulong), ForUInt64(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Varint)) },
+ { typeof(float), ForFloat(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Fixed32)) },
+ { typeof(double), ForDouble(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.Fixed64)) },
+ { typeof(string), ForString(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.LengthDelimited)) },
+ { typeof(ByteString), ForBytes(WireFormat.MakeTag(WrapperValueFieldNumber, WireFormat.WireType.LengthDelimited)) }
+ };
+
+ /// <summary>
+ /// Returns a field codec which effectively wraps a value of type T in a message.
+ ///
+ /// </summary>
+ internal static FieldCodec<T> GetCodec<T>()
+ {
+ object value;
+ if (!Codecs.TryGetValue(typeof(T), out value))
+ {
+ throw new InvalidOperationException("Invalid type argument requested for wrapper codec: " + typeof(T));
+ }
+ return (FieldCodec<T>) value;
+ }
+
+ internal static T Read<T>(CodedInputStream input, FieldCodec<T> codec)
+ {
+ int length = input.ReadLength();
+ int oldLimit = input.PushLimit(length);
+
+ uint tag;
+ T value = codec.DefaultValue;
+ while (input.ReadTag(out tag))
+ {
+ if (tag == 0)
+ {
+ throw InvalidProtocolBufferException.InvalidTag();
+ }
+ if (tag == codec.Tag)
+ {
+ value = codec.Read(input);
+ }
+ if (WireFormat.IsEndGroupTag(tag))
+ {
+ break;
+ }
+ }
+ input.CheckLastTagWas(0);
+ input.PopLimit(oldLimit);
+
+ return value;
+ }
+
+ internal static void Write<T>(CodedOutputStream output, T value, FieldCodec<T> codec)
+ {
+ output.WriteLength(codec.CalculateSizeWithTag(value));
+ codec.WriteTagAndValue(output, value);
+ }
+
+ internal static int CalculateSize<T>(T value, FieldCodec<T> codec)
+ {
+ int fieldLength = codec.CalculateSizeWithTag(value);
+ return CodedOutputStream.ComputeLengthSize(fieldLength) + fieldLength;
+ }
+ }
}
/// <summary>
@@ -144,31 +254,19 @@
/// </remarks>
public sealed class FieldCodec<T>
{
- private static readonly Func<T, bool> IsDefault;
- private static readonly T Default;
+ private static readonly T DefaultDefault;
static FieldCodec()
{
if (typeof(T) == typeof(string))
{
- Default = (T)(object)"";
- IsDefault = CreateDefaultValueCheck<string>(x => x.Length == 0);
+ DefaultDefault = (T)(object)"";
}
else if (typeof(T) == typeof(ByteString))
{
- Default = (T)(object)ByteString.Empty;
- IsDefault = CreateDefaultValueCheck<ByteString>(x => x.Length == 0);
+ DefaultDefault = (T)(object)ByteString.Empty;
}
- else if (!typeof(T).IsValueType)
- {
- // Default default
- IsDefault = CreateDefaultValueCheck<T>(x => x == null);
- }
- else
- {
- // Default default
- IsDefault = CreateDefaultValueCheck<T>(x => EqualityComparer<T>.Default.Equals(x, default(T)));
- }
+ // Otherwise it's the default value of the CLR type
}
private static Func<T, bool> CreateDefaultValueCheck<TTmp>(Func<TTmp, bool> check)
@@ -182,18 +280,32 @@
private readonly uint tag;
private readonly int tagSize;
private readonly int fixedSize;
+ // Default value for this codec. Usually the same for every instance of the same type, but
+ // for string/ByteString wrapper fields the codec's default value is null, whereas for
+ // other string/ByteString fields it's "" or ByteString.Empty.
+ private readonly T defaultValue;
internal FieldCodec(
Func<CodedInputStream, T> reader,
Action<CodedOutputStream, T> writer,
Func<T, int> sizeCalculator,
- uint tag)
+ uint tag) : this(reader, writer, sizeCalculator, tag, DefaultDefault)
+ {
+ }
+
+ internal FieldCodec(
+ Func<CodedInputStream, T> reader,
+ Action<CodedOutputStream, T> writer,
+ Func<T, int> sizeCalculator,
+ uint tag,
+ T defaultValue)
{
this.reader = reader;
this.writer = writer;
this.sizeCalculator = sizeCalculator;
this.fixedSize = 0;
this.tag = tag;
+ this.defaultValue = defaultValue;
tagSize = CodedOutputStream.ComputeRawVarint32Size(tag);
}
@@ -234,7 +346,7 @@
public uint Tag { get { return tag; } }
- public T DefaultValue { get { return Default; } }
+ public T DefaultValue { get { return defaultValue; } }
/// <summary>
/// Write a tag and the given value, *if* the value is not the default.
@@ -260,6 +372,11 @@
public int CalculateSizeWithTag(T value)
{
return IsDefault(value) ? 0 : sizeCalculator(value) + tagSize;
- }
+ }
+
+ private bool IsDefault(T value)
+ {
+ return EqualityComparer<T>.Default.Equals(value, defaultValue);
+ }
}
}
diff --git a/src/Makefile.am b/src/Makefile.am
index 18e2777..865e78d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -442,7 +442,9 @@
google/protobuf/compiler/csharp/csharp_source_generator_base.cc \
google/protobuf/compiler/csharp/csharp_source_generator_base.h \
google/protobuf/compiler/csharp/csharp_umbrella_class.cc \
- google/protobuf/compiler/csharp/csharp_umbrella_class.h
+ google/protobuf/compiler/csharp/csharp_umbrella_class.h \
+ google/protobuf/compiler/csharp/csharp_wrapper_field.cc \
+ google/protobuf/compiler/csharp/csharp_wrapper_field.h
bin_PROGRAMS = protoc
protoc_LDADD = $(PTHREAD_LIBS) libprotobuf.la libprotoc.la
diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.cc b/src/google/protobuf/compiler/csharp/csharp_field_base.cc
index c9791c1..89d4eb1 100644
--- a/src/google/protobuf/compiler/csharp/csharp_field_base.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_field_base.cc
@@ -169,6 +169,18 @@
return GetClassName(descriptor->enum_type());
case FieldDescriptor::TYPE_MESSAGE:
case FieldDescriptor::TYPE_GROUP:
+ if (IsWrapperType(descriptor)) {
+ const FieldDescriptor* wrapped_field = descriptor->message_type()->field(0);
+ string wrapped_field_type_name = type_name(wrapped_field);
+ // String and ByteString go to the same type; other wrapped types go to the
+ // nullable equivalent.
+ if (wrapped_field->type() == FieldDescriptor::TYPE_STRING ||
+ wrapped_field->type() == FieldDescriptor::TYPE_BYTES) {
+ return wrapped_field_type_name;
+ } else {
+ return wrapped_field_type_name + "?";
+ }
+ }
return GetClassName(descriptor->message_type());
case FieldDescriptor::TYPE_DOUBLE:
return "double";
@@ -298,14 +310,23 @@
}
std::string FieldGeneratorBase::default_value() {
- switch (descriptor_->type()) {
+ return default_value(descriptor_);
+}
+
+std::string FieldGeneratorBase::default_value(const FieldDescriptor* descriptor) {
+ switch (descriptor->type()) {
case FieldDescriptor::TYPE_ENUM:
- return type_name() + "." + descriptor_->default_value_enum()->name();
+ return type_name() + "." + descriptor->default_value_enum()->name();
case FieldDescriptor::TYPE_MESSAGE:
case FieldDescriptor::TYPE_GROUP:
- return type_name() + ".DefaultInstance";
+ if (IsWrapperType(descriptor)) {
+ const FieldDescriptor* wrapped_field = descriptor->message_type()->field(0);
+ return default_value(wrapped_field);
+ } else {
+ return "null";
+ }
case FieldDescriptor::TYPE_DOUBLE: {
- double value = descriptor_->default_value_double();
+ double value = descriptor->default_value_double();
if (value == numeric_limits<double>::infinity()) {
return "double.PositiveInfinity";
} else if (value == -numeric_limits<double>::infinity()) {
@@ -316,7 +337,7 @@
return SimpleDtoa(value) + "D";
}
case FieldDescriptor::TYPE_FLOAT: {
- float value = descriptor_->default_value_float();
+ float value = descriptor->default_value_float();
if (value == numeric_limits<float>::infinity()) {
return "float.PositiveInfinity";
} else if (value == -numeric_limits<float>::infinity()) {
@@ -327,17 +348,17 @@
return SimpleFtoa(value) + "F";
}
case FieldDescriptor::TYPE_INT64:
- return SimpleItoa(descriptor_->default_value_int64()) + "L";
+ return SimpleItoa(descriptor->default_value_int64()) + "L";
case FieldDescriptor::TYPE_UINT64:
- return SimpleItoa(descriptor_->default_value_uint64()) + "UL";
+ return SimpleItoa(descriptor->default_value_uint64()) + "UL";
case FieldDescriptor::TYPE_INT32:
- return SimpleItoa(descriptor_->default_value_int32());
+ return SimpleItoa(descriptor->default_value_int32());
case FieldDescriptor::TYPE_FIXED64:
- return SimpleItoa(descriptor_->default_value_uint64()) + "UL";
+ return SimpleItoa(descriptor->default_value_uint64()) + "UL";
case FieldDescriptor::TYPE_FIXED32:
- return SimpleItoa(descriptor_->default_value_uint32());
+ return SimpleItoa(descriptor->default_value_uint32());
case FieldDescriptor::TYPE_BOOL:
- if (descriptor_->default_value_bool()) {
+ if (descriptor->default_value_bool()) {
return "true";
} else {
return "false";
@@ -347,15 +368,15 @@
case FieldDescriptor::TYPE_BYTES:
return GetBytesDefaultValueInternal();
case FieldDescriptor::TYPE_UINT32:
- return SimpleItoa(descriptor_->default_value_uint32());
+ return SimpleItoa(descriptor->default_value_uint32());
case FieldDescriptor::TYPE_SFIXED32:
- return SimpleItoa(descriptor_->default_value_int32());
+ return SimpleItoa(descriptor->default_value_int32());
case FieldDescriptor::TYPE_SFIXED64:
- return SimpleItoa(descriptor_->default_value_int64()) + "L";
+ return SimpleItoa(descriptor->default_value_int64()) + "L";
case FieldDescriptor::TYPE_SINT32:
- return SimpleItoa(descriptor_->default_value_int32());
+ return SimpleItoa(descriptor->default_value_int32());
case FieldDescriptor::TYPE_SINT64:
- return SimpleItoa(descriptor_->default_value_int64()) + "L";
+ return SimpleItoa(descriptor->default_value_int64()) + "L";
default:
GOOGLE_LOG(FATAL)<< "Unknown field type.";
return "";
diff --git a/src/google/protobuf/compiler/csharp/csharp_field_base.h b/src/google/protobuf/compiler/csharp/csharp_field_base.h
index bffa206..4761dc4 100644
--- a/src/google/protobuf/compiler/csharp/csharp_field_base.h
+++ b/src/google/protobuf/compiler/csharp/csharp_field_base.h
@@ -82,6 +82,7 @@
bool has_default_value();
bool is_nullable_type();
std::string default_value();
+ std::string default_value(const FieldDescriptor* descriptor);
std::string number();
std::string capitalized_type_name();
std::string field_ordinal();
diff --git a/src/google/protobuf/compiler/csharp/csharp_helpers.cc b/src/google/protobuf/compiler/csharp/csharp_helpers.cc
index 8ecd1dc..1c7a24a 100644
--- a/src/google/protobuf/compiler/csharp/csharp_helpers.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_helpers.cc
@@ -52,6 +52,7 @@
#include <google/protobuf/compiler/csharp/csharp_repeated_enum_field.h>
#include <google/protobuf/compiler/csharp/csharp_repeated_message_field.h>
#include <google/protobuf/compiler/csharp/csharp_repeated_primitive_field.h>
+#include <google/protobuf/compiler/csharp/csharp_wrapper_field.h>
namespace google {
namespace protobuf {
@@ -366,31 +367,39 @@
return new RepeatedMessageFieldGenerator(descriptor, fieldOrdinal);
}
} else {
- if (descriptor->containing_oneof()) {
- return new MessageOneofFieldGenerator(descriptor, fieldOrdinal);
- } else {
- return new MessageFieldGenerator(descriptor, fieldOrdinal);
- }
+ if (IsWrapperType(descriptor)) {
+ if (descriptor->containing_oneof()) {
+ return new WrapperOneofFieldGenerator(descriptor, fieldOrdinal);
+ } else {
+ return new WrapperFieldGenerator(descriptor, fieldOrdinal);
+ }
+ } else {
+ if (descriptor->containing_oneof()) {
+ return new MessageOneofFieldGenerator(descriptor, fieldOrdinal);
+ } else {
+ return new MessageFieldGenerator(descriptor, fieldOrdinal);
+ }
+ }
}
case FieldDescriptor::TYPE_ENUM:
if (descriptor->is_repeated()) {
return new RepeatedEnumFieldGenerator(descriptor, fieldOrdinal);
} else {
- if (descriptor->containing_oneof()) {
- return new EnumOneofFieldGenerator(descriptor, fieldOrdinal);
- } else {
- return new EnumFieldGenerator(descriptor, fieldOrdinal);
- }
+ if (descriptor->containing_oneof()) {
+ return new EnumOneofFieldGenerator(descriptor, fieldOrdinal);
+ } else {
+ return new EnumFieldGenerator(descriptor, fieldOrdinal);
+ }
}
default:
if (descriptor->is_repeated()) {
return new RepeatedPrimitiveFieldGenerator(descriptor, fieldOrdinal);
} else {
- if (descriptor->containing_oneof()) {
- return new PrimitiveOneofFieldGenerator(descriptor, fieldOrdinal);
- } else {
- return new PrimitiveFieldGenerator(descriptor, fieldOrdinal);
- }
+ if (descriptor->containing_oneof()) {
+ return new PrimitiveOneofFieldGenerator(descriptor, fieldOrdinal);
+ } else {
+ return new PrimitiveFieldGenerator(descriptor, fieldOrdinal);
+ }
}
}
}
diff --git a/src/google/protobuf/compiler/csharp/csharp_helpers.h b/src/google/protobuf/compiler/csharp/csharp_helpers.h
index 111feab..653ff99 100644
--- a/src/google/protobuf/compiler/csharp/csharp_helpers.h
+++ b/src/google/protobuf/compiler/csharp/csharp_helpers.h
@@ -119,6 +119,15 @@
return descriptor->name() == "google/protobuf/descriptor_proto_file.proto";
}
+inline bool IsMapEntry(const Descriptor* descriptor) {
+ return descriptor->options().map_entry();
+}
+
+inline bool IsWrapperType(const FieldDescriptor* descriptor) {
+ return descriptor->type() == FieldDescriptor::TYPE_MESSAGE &&
+ descriptor->message_type()->file()->name() == "google/protobuf/wrappers.proto";
+}
+
} // namespace csharp
} // namespace compiler
} // namespace protobuf
diff --git a/src/google/protobuf/compiler/csharp/csharp_map_field.cc b/src/google/protobuf/compiler/csharp/csharp_map_field.cc
index 32c0523..cba24a5 100644
--- a/src/google/protobuf/compiler/csharp/csharp_map_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_map_field.cc
@@ -61,6 +61,7 @@
descriptor_->message_type()->FindFieldByName("value");
variables_["key_type_name"] = type_name(key_descriptor);
variables_["value_type_name"] = type_name(value_descriptor);
+ variables_["true_for_wrappers"] = IsWrapperType(value_descriptor) ? "true" : "";
scoped_ptr<FieldGeneratorBase> key_generator(CreateFieldGenerator(key_descriptor, 1));
scoped_ptr<FieldGeneratorBase> value_generator(CreateFieldGenerator(value_descriptor, 2));
@@ -74,7 +75,7 @@
printer->Print(
variables_,
", $tag$);\n"
- "private readonly pbc::MapField<$key_type_name$, $value_type_name$> $name$_ = new pbc::MapField<$key_type_name$, $value_type_name$>();\n");
+ "private readonly pbc::MapField<$key_type_name$, $value_type_name$> $name$_ = new pbc::MapField<$key_type_name$, $value_type_name$>($true_for_wrappers$);\n");
AddDeprecatedFlag(printer);
printer->Print(
variables_,
diff --git a/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc b/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
index 6d4e698..d939fc7 100644
--- a/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
+++ b/src/google/protobuf/compiler/csharp/csharp_repeated_message_field.cc
@@ -39,6 +39,8 @@
#include <google/protobuf/compiler/csharp/csharp_helpers.h>
#include <google/protobuf/compiler/csharp/csharp_repeated_message_field.h>
+#include <google/protobuf/compiler/csharp/csharp_message_field.h>
+#include <google/protobuf/compiler/csharp/csharp_wrapper_field.h>
namespace google {
namespace protobuf {
@@ -58,7 +60,18 @@
printer->Print(
variables_,
"private static readonly pb::FieldCodec<$type_name$> _repeated_$name$_codec\n"
- " = pb::FieldCodec.ForMessage($tag$, $type_name$.Parser);\n");
+ " = ");
+ // Don't want to duplicate the codec code here... maybe we should have a
+ // "create single field generator for this repeated field"
+ // function, but it doesn't seem worth it for just this.
+ if (IsWrapperType(descriptor_)) {
+ scoped_ptr<FieldGeneratorBase> single_generator(new WrapperFieldGenerator(descriptor_, fieldOrdinal_));
+ single_generator->GenerateCodecCode(printer);
+ } else {
+ scoped_ptr<FieldGeneratorBase> single_generator(new MessageFieldGenerator(descriptor_, fieldOrdinal_));
+ single_generator->GenerateCodecCode(printer);
+ }
+ printer->Print(";\n");
printer->Print(
variables_,
"private readonly pbc::RepeatedField<$type_name$> $name$_ = new pbc::RepeatedField<$type_name$>();\n");
diff --git a/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc b/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc
new file mode 100644
index 0000000..75ef5e5
--- /dev/null
+++ b/src/google/protobuf/compiler/csharp/csharp_wrapper_field.cc
@@ -0,0 +1,209 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include <sstream>
+
+#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/compiler/plugin.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/io/printer.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+
+#include <google/protobuf/compiler/csharp/csharp_helpers.h>
+#include <google/protobuf/compiler/csharp/csharp_wrapper_field.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace csharp {
+
+WrapperFieldGenerator::WrapperFieldGenerator(const FieldDescriptor* descriptor,
+ int fieldOrdinal)
+ : FieldGeneratorBase(descriptor, fieldOrdinal) {
+ variables_["has_property_check"] = name() + "_ != null";
+ variables_["has_not_property_check"] = name() + "_ == null";
+ const FieldDescriptor* wrapped_field = descriptor->message_type()->field(0);
+ is_value_type = wrapped_field->type() != FieldDescriptor::TYPE_STRING &&
+ wrapped_field->type() != FieldDescriptor::TYPE_BYTES;
+ if (is_value_type) {
+ variables_["nonnullable_type_name"] = type_name(wrapped_field);
+ }
+}
+
+WrapperFieldGenerator::~WrapperFieldGenerator() {
+}
+
+void WrapperFieldGenerator::GenerateMembers(io::Printer* printer) {
+ printer->Print(
+ variables_,
+ "private static readonly pb::FieldCodec<$type_name$> _single_$name$_codec = ");
+ GenerateCodecCode(printer);
+ printer->Print(
+ variables_,
+ ";\n"
+ "private $type_name$ $name$_;\n");
+ AddDeprecatedFlag(printer);
+ printer->Print(
+ variables_,
+ "$access_level$ $type_name$ $property_name$ {\n"
+ " get { return $name$_; }\n"
+ " set {\n"
+ " pb::Freezable.CheckMutable(this);\n"
+ " $name$_ = value;\n"
+ " }\n"
+ "}\n");
+}
+
+void WrapperFieldGenerator::GenerateMergingCode(io::Printer* printer) {
+ printer->Print(
+ variables_,
+ "if (other.$has_property_check$) {\n"
+ " if ($has_not_property_check$ || other.$property_name$ != $default_value$) {\n"
+ " $property_name$ = other.$property_name$;\n"
+ " }\n"
+ "}\n");
+}
+
+void WrapperFieldGenerator::GenerateParsingCode(io::Printer* printer) {
+ printer->Print(
+ variables_,
+ "$type_name$ value = _single_$name$_codec.Read(input);\n"
+ "if ($has_not_property_check$ || value != $default_value$) {\n"
+ " $property_name$ = value;\n"
+ "}\n");
+}
+
+void WrapperFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
+ printer->Print(
+ variables_,
+ "if ($has_property_check$) {\n"
+ " _single_$name$_codec.WriteTagAndValue(output, $property_name$);\n"
+ "}\n");
+}
+
+void WrapperFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
+ printer->Print(
+ variables_,
+ "if ($has_property_check$) {\n"
+ " size += _single_$name$_codec.CalculateSizeWithTag($property_name$);\n"
+ "}\n");
+}
+
+void WrapperFieldGenerator::WriteHash(io::Printer* printer) {
+ printer->Print(
+ variables_,
+ "if ($has_property_check$) hash ^= $property_name$.GetHashCode();\n");
+}
+
+void WrapperFieldGenerator::WriteEquals(io::Printer* printer) {
+ printer->Print(
+ variables_,
+ "if ($property_name$ != other.$property_name$) return false;\n");
+}
+
+void WrapperFieldGenerator::WriteToString(io::Printer* printer) {
+ // TODO: Implement if we ever actually need it...
+}
+
+void WrapperFieldGenerator::GenerateCloningCode(io::Printer* printer) {
+ printer->Print(variables_,
+ "$property_name$ = other.$property_name$;\n");
+}
+
+void WrapperFieldGenerator::GenerateCodecCode(io::Printer* printer) {
+ if (is_value_type) {
+ printer->Print(
+ variables_,
+ "pb::FieldCodec.ForStructWrapper<$nonnullable_type_name$>($tag$)");
+ } else {
+ printer->Print(
+ variables_,
+ "pb::FieldCodec.ForClassWrapper<$type_name$>($tag$)");
+ }
+}
+
+WrapperOneofFieldGenerator::WrapperOneofFieldGenerator(const FieldDescriptor* descriptor,
+ int fieldOrdinal)
+ : WrapperFieldGenerator(descriptor, fieldOrdinal) {
+ SetCommonOneofFieldVariables(&variables_);
+}
+
+WrapperOneofFieldGenerator::~WrapperOneofFieldGenerator() {
+}
+
+void WrapperOneofFieldGenerator::GenerateMembers(io::Printer* printer) {
+ // Note: deliberately _oneof_$name$_codec, not _$oneof_name$_codec... we have one codec per field.
+ printer->Print(
+ variables_,
+ "private static readonly pb::FieldCodec<$type_name$> _oneof_$name$_codec = ");
+ GenerateCodecCode(printer);
+ printer->Print(";\n");
+ AddDeprecatedFlag(printer);
+ printer->Print(
+ variables_,
+ "$access_level$ $type_name$ $property_name$ {\n"
+ " get { return $has_property_check$ ? ($type_name$) $oneof_name$_ : ($type_name$) null; }\n"
+ " set {\n"
+ " pb::Freezable.CheckMutable(this);\n"
+ " $oneof_name$_ = value;\n"
+ " $oneof_name$Case_ = value == null ? $oneof_property_name$OneofCase.None : $oneof_property_name$OneofCase.$property_name$;\n"
+ " }\n"
+ "}\n");
+}
+
+void WrapperOneofFieldGenerator::GenerateParsingCode(io::Printer* printer) {
+ printer->Print(
+ variables_,
+ "$property_name$ = _oneof_$name$_codec.Read(input);\n");
+}
+
+void WrapperOneofFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
+ // TODO: I suspect this is wrong...
+ printer->Print(
+ variables_,
+ "if ($has_property_check$) {\n"
+ " _oneof_$name$_codec.WriteTagAndValue(output, ($type_name$) $oneof_name$_);\n"
+ "}\n");
+}
+
+void WrapperOneofFieldGenerator::GenerateSerializedSizeCode(io::Printer* printer) {
+ // TODO: I suspect this is wrong...
+ printer->Print(
+ variables_,
+ "if ($has_property_check$) {\n"
+ " size += _oneof_$name$_codec.CalculateSizeWithTag($property_name$);\n"
+ "}\n");
+}
+
+} // namespace csharp
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
diff --git a/src/google/protobuf/compiler/csharp/csharp_wrapper_field.h b/src/google/protobuf/compiler/csharp/csharp_wrapper_field.h
new file mode 100644
index 0000000..6e2414a
--- /dev/null
+++ b/src/google/protobuf/compiler/csharp/csharp_wrapper_field.h
@@ -0,0 +1,85 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_WRAPPER_FIELD_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_WRAPPER_FIELD_H__
+
+#include <string>
+
+#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/compiler/csharp/csharp_field_base.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace csharp {
+
+class WrapperFieldGenerator : public FieldGeneratorBase {
+ public:
+ WrapperFieldGenerator(const FieldDescriptor* descriptor, int fieldOrdinal);
+ ~WrapperFieldGenerator();
+
+ virtual void GenerateCodecCode(io::Printer* printer);
+ virtual void GenerateCloningCode(io::Printer* printer);
+ virtual void GenerateMembers(io::Printer* printer);
+ virtual void GenerateMergingCode(io::Printer* printer);
+ virtual void GenerateParsingCode(io::Printer* printer);
+ virtual void GenerateSerializationCode(io::Printer* printer);
+ virtual void GenerateSerializedSizeCode(io::Printer* printer);
+
+ virtual void WriteHash(io::Printer* printer);
+ virtual void WriteEquals(io::Printer* printer);
+ virtual void WriteToString(io::Printer* printer);
+
+ private:
+ bool is_value_type; // True for int32 etc; false for bytes and string
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WrapperFieldGenerator);
+};
+
+class WrapperOneofFieldGenerator : public WrapperFieldGenerator {
+ public:
+ WrapperOneofFieldGenerator(const FieldDescriptor* descriptor, int fieldOrdinal);
+ ~WrapperOneofFieldGenerator();
+
+ virtual void GenerateMembers(io::Printer* printer);
+ virtual void GenerateParsingCode(io::Printer* printer);
+ virtual void GenerateSerializationCode(io::Printer* printer);
+ virtual void GenerateSerializedSizeCode(io::Printer* printer);
+
+ private:
+ GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WrapperOneofFieldGenerator);
+};
+
+} // namespace csharp
+} // namespace compiler
+} // namespace protobuf
+} // namespace google
+
+#endif // GOOGLE_PROTOBUF_COMPILER_CSHARP_WRAPPER_FIELD_H__
diff --git a/src/google/protobuf/unittest_well_known_types.proto b/src/google/protobuf/unittest_well_known_types.proto
index e157260..2cb7775 100644
--- a/src/google/protobuf/unittest_well_known_types.proto
+++ b/src/google/protobuf/unittest_well_known_types.proto
@@ -2,6 +2,7 @@
package protobuf_unittest;
+option csharp_namespace = "Google.Protobuf.TestProtos";
option java_multiple_files = true;
option java_package = "com.google.protobuf.test";
@@ -17,6 +18,8 @@
import "google/protobuf/wrappers.proto";
// Test that we can include all well-known types.
+// Each wrapper type is included separately, as languages
+// map handle different wrappers in different ways.
message TestWellKnownTypes {
google.protobuf.Any any_field = 1;
google.protobuf.Api api_field = 2;
@@ -27,5 +30,83 @@
google.protobuf.Struct struct_field = 7;
google.protobuf.Timestamp timestamp_field = 8;
google.protobuf.Type type_field = 9;
- google.protobuf.Int32Value int32_field = 10;
+ google.protobuf.DoubleValue double_field = 10;
+ google.protobuf.FloatValue float_field = 11;
+ google.protobuf.Int64Value int64_field = 12;
+ google.protobuf.UInt64Value uint64_field = 13;
+ google.protobuf.Int32Value int32_field = 14;
+ google.protobuf.UInt32Value uint32_field = 15;
+ google.protobuf.BoolValue bool_field = 16;
+ google.protobuf.StringValue string_field = 17;
+ google.protobuf.BytesValue bytes_field = 18;
+}
+
+// A repeated field for each well-known type.
+message RepeatedWellKnownTypes {
+ repeated google.protobuf.Any any_field = 1;
+ repeated google.protobuf.Api api_field = 2;
+ repeated google.protobuf.Duration duration_field = 3;
+ repeated google.protobuf.Empty empty_field = 4;
+ repeated google.protobuf.FieldMask field_mask_field = 5;
+ repeated google.protobuf.SourceContext source_context_field = 6;
+ repeated google.protobuf.Struct struct_field = 7;
+ repeated google.protobuf.Timestamp timestamp_field = 8;
+ repeated google.protobuf.Type type_field = 9;
+ // These don't actually make a lot of sense, but they're not prohibited...
+ repeated google.protobuf.DoubleValue double_field = 10;
+ repeated google.protobuf.FloatValue float_field = 11;
+ repeated google.protobuf.Int64Value int64_field = 12;
+ repeated google.protobuf.UInt64Value uint64_field = 13;
+ repeated google.protobuf.Int32Value int32_field = 14;
+ repeated google.protobuf.UInt32Value uint32_field = 15;
+ repeated google.protobuf.BoolValue bool_field = 16;
+ repeated google.protobuf.StringValue string_field = 17;
+ repeated google.protobuf.BytesValue bytes_field = 18;
+}
+
+message OneofWellKnownTypes {
+ oneof oneof_field {
+ google.protobuf.Any any_field = 1;
+ google.protobuf.Api api_field = 2;
+ google.protobuf.Duration duration_field = 3;
+ google.protobuf.Empty empty_field = 4;
+ google.protobuf.FieldMask field_mask_field = 5;
+ google.protobuf.SourceContext source_context_field = 6;
+ google.protobuf.Struct struct_field = 7;
+ google.protobuf.Timestamp timestamp_field = 8;
+ google.protobuf.Type type_field = 9;
+ google.protobuf.DoubleValue double_field = 10;
+ google.protobuf.FloatValue float_field = 11;
+ google.protobuf.Int64Value int64_field = 12;
+ google.protobuf.UInt64Value uint64_field = 13;
+ google.protobuf.Int32Value int32_field = 14;
+ google.protobuf.UInt32Value uint32_field = 15;
+ google.protobuf.BoolValue bool_field = 16;
+ google.protobuf.StringValue string_field = 17;
+ google.protobuf.BytesValue bytes_field = 18;
+ }
+}
+
+// A map field for each well-known type. We only
+// need to worry about the value part of the map being the
+// well-known types, as messages can't be map keys.
+message MapWellKnownTypes {
+ map<int32,google.protobuf.Any> any_field = 1;
+ map<int32,google.protobuf.Api> api_field = 2;
+ map<int32,google.protobuf.Duration> duration_field = 3;
+ map<int32,google.protobuf.Empty> empty_field = 4;
+ map<int32,google.protobuf.FieldMask> field_mask_field = 5;
+ map<int32,google.protobuf.SourceContext> source_context_field = 6;
+ map<int32,google.protobuf.Struct> struct_field = 7;
+ map<int32,google.protobuf.Timestamp> timestamp_field = 8;
+ map<int32,google.protobuf.Type> type_field = 9;
+ map<int32,google.protobuf.DoubleValue> double_field = 10;
+ map<int32,google.protobuf.FloatValue> float_field = 11;
+ map<int32,google.protobuf.Int64Value> int64_field = 12;
+ map<int32,google.protobuf.UInt64Value> uint64_field = 13;
+ map<int32,google.protobuf.Int32Value> int32_field = 14;
+ map<int32,google.protobuf.UInt32Value> uint32_field = 15;
+ map<int32,google.protobuf.BoolValue> bool_field = 16;
+ map<int32,google.protobuf.StringValue> string_field = 17;
+ map<int32,google.protobuf.BytesValue> bytes_field = 18;
}
