Jie Luo
7 years ago
committed by
GitHub
parent
0a7120ac32
commit
bfd254e14f
32 changed files with 3017 additions and 345 deletions
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,128 @@ |
||||
#region Copyright notice and license |
||||
// 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. |
||||
#endregion |
||||
|
||||
using System; |
||||
using Google.Protobuf.TestProtos; |
||||
using NUnit.Framework; |
||||
|
||||
namespace Google.Protobuf |
||||
{ |
||||
public class UnknownFieldSetTest |
||||
{ |
||||
[Test] |
||||
public void EmptyUnknownFieldSet() |
||||
{ |
||||
UnknownFieldSet unknownFields = new UnknownFieldSet(); |
||||
Assert.AreEqual(0, unknownFields.CalculateSize()); |
||||
} |
||||
|
||||
[Test] |
||||
public void MergeUnknownFieldSet() |
||||
{ |
||||
UnknownFieldSet unknownFields = new UnknownFieldSet(); |
||||
UnknownField field = new UnknownField(); |
||||
field.AddFixed32(123); |
||||
unknownFields.AddOrReplaceField(1, field); |
||||
UnknownFieldSet otherUnknownFields = new UnknownFieldSet(); |
||||
Assert.IsFalse(otherUnknownFields.HasField(1)); |
||||
UnknownFieldSet.MergeFrom(otherUnknownFields, unknownFields); |
||||
Assert.IsTrue(otherUnknownFields.HasField(1)); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestMergeCodedInput() |
||||
{ |
||||
var message = SampleMessages.CreateFullTestAllTypes(); |
||||
var emptyMessage = new TestEmptyMessage(); |
||||
emptyMessage.MergeFrom(message.ToByteArray()); |
||||
Assert.AreEqual(message.CalculateSize(), emptyMessage.CalculateSize()); |
||||
Assert.AreEqual(message.ToByteArray(), emptyMessage.ToByteArray()); |
||||
|
||||
var newMessage = new TestAllTypes(); |
||||
newMessage.MergeFrom(emptyMessage.ToByteArray()); |
||||
Assert.AreEqual(message, newMessage); |
||||
Assert.AreEqual(message.CalculateSize(), newMessage.CalculateSize()); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestMergeMessage() |
||||
{ |
||||
var message = SampleMessages.CreateFullTestAllTypes(); |
||||
var emptyMessage = new TestEmptyMessage(); |
||||
var otherEmptyMessage = new TestEmptyMessage(); |
||||
emptyMessage.MergeFrom(message.ToByteArray()); |
||||
otherEmptyMessage.MergeFrom(emptyMessage); |
||||
|
||||
Assert.AreEqual(message.CalculateSize(), otherEmptyMessage.CalculateSize()); |
||||
Assert.AreEqual(message.ToByteArray(), otherEmptyMessage.ToByteArray()); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestEquals() |
||||
{ |
||||
var message = SampleMessages.CreateFullTestAllTypes(); |
||||
var emptyMessage = new TestEmptyMessage(); |
||||
var otherEmptyMessage = new TestEmptyMessage(); |
||||
Assert.AreEqual(emptyMessage, otherEmptyMessage); |
||||
emptyMessage.MergeFrom(message.ToByteArray()); |
||||
Assert.AreNotEqual(emptyMessage.CalculateSize(), |
||||
otherEmptyMessage.CalculateSize()); |
||||
Assert.AreNotEqual(emptyMessage, otherEmptyMessage); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestHashCode() |
||||
{ |
||||
var message = SampleMessages.CreateFullTestAllTypes(); |
||||
var emptyMessage = new TestEmptyMessage(); |
||||
int hashCode = emptyMessage.GetHashCode(); |
||||
emptyMessage.MergeFrom(message.ToByteArray()); |
||||
Assert.AreNotEqual(hashCode, emptyMessage.GetHashCode()); |
||||
} |
||||
|
||||
[Test] |
||||
public void TestClone() |
||||
{ |
||||
var emptyMessage = new TestEmptyMessage(); |
||||
var otherEmptyMessage = new TestEmptyMessage(); |
||||
otherEmptyMessage = emptyMessage.Clone(); |
||||
Assert.AreEqual(emptyMessage.CalculateSize(), otherEmptyMessage.CalculateSize()); |
||||
Assert.AreEqual(emptyMessage.ToByteArray(), otherEmptyMessage.ToByteArray()); |
||||
|
||||
var message = SampleMessages.CreateFullTestAllTypes(); |
||||
emptyMessage.MergeFrom(message.ToByteArray()); |
||||
otherEmptyMessage = emptyMessage.Clone(); |
||||
Assert.AreEqual(message.CalculateSize(), otherEmptyMessage.CalculateSize()); |
||||
Assert.AreEqual(message.ToByteArray(), otherEmptyMessage.ToByteArray()); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,89 @@ |
||||
#region Copyright notice and license |
||||
// Protocol Buffers - Google's data interchange format |
||||
// Copyright 2017 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.Collections.Generic; |
||||
using System.Collections.ObjectModel; |
||||
|
||||
namespace Google.Protobuf.Collections |
||||
{ |
||||
/// <summary> |
||||
/// Utility to compare if two Lists are the same, and the hash code |
||||
/// of a List. |
||||
/// </summary> |
||||
public static class Lists |
||||
{ |
||||
/// <summary> |
||||
/// Checks if two lists are equal. |
||||
/// </summary> |
||||
public static bool Equals<T>(List<T> left, List<T> right) |
||||
{ |
||||
if (left == right) |
||||
{ |
||||
return true; |
||||
} |
||||
if (left == null || right == null) |
||||
{ |
||||
return false; |
||||
} |
||||
if (left.Count != right.Count) |
||||
{ |
||||
return false; |
||||
} |
||||
IEqualityComparer<T> comparer = EqualityComparer<T>.Default; |
||||
for (int i = 0; i < left.Count; i++) |
||||
{ |
||||
if (!comparer.Equals(left[i], right[i])) |
||||
{ |
||||
return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Gets the list's hash code. |
||||
/// </summary> |
||||
public static int GetHashCode<T>(List<T> list) |
||||
{ |
||||
if (list == null) |
||||
{ |
||||
return 0; |
||||
} |
||||
int hash = 31; |
||||
foreach (T element in list) |
||||
{ |
||||
hash = hash * 29 + element.GetHashCode(); |
||||
} |
||||
return hash; |
||||
} |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,263 @@ |
||||
#region Copyright notice and license |
||||
// Protocol Buffers - Google's data interchange format |
||||
// Copyright 2017 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 System.Collections.Generic; |
||||
using System.Collections.ObjectModel; |
||||
using Google.Protobuf.Collections; |
||||
|
||||
namespace Google.Protobuf |
||||
{ |
||||
/// <summary> |
||||
/// Represents a single field in an UnknownFieldSet. |
||||
/// |
||||
/// An UnknownField consists of four lists of values. The lists correspond |
||||
/// to the four "wire types" used in the protocol buffer binary format. |
||||
/// Normally, only one of the four lists will contain any values, since it |
||||
/// is impossible to define a valid message type that declares two different |
||||
/// types for the same field number. However, the code is designed to allow |
||||
/// for the case where the same unknown field number is encountered using |
||||
/// multiple different wire types. |
||||
/// |
||||
/// </summary> |
||||
internal sealed class UnknownField |
||||
{ |
||||
private List<ulong> varintList; |
||||
private List<uint> fixed32List; |
||||
private List<ulong> fixed64List; |
||||
private List<ByteString> lengthDelimitedList; |
||||
|
||||
/// <summary> |
||||
/// Creates a new UnknownField. |
||||
/// </summary> |
||||
public UnknownField() |
||||
{ |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Checks if two unknown field are equal. |
||||
/// </summary> |
||||
public override bool Equals(object other) |
||||
{ |
||||
if (ReferenceEquals(this, other)) |
||||
{ |
||||
return true; |
||||
} |
||||
UnknownField otherField = other as UnknownField; |
||||
return otherField != null |
||||
&& Lists.Equals(varintList, otherField.varintList) |
||||
&& Lists.Equals(fixed32List, otherField.fixed32List) |
||||
&& Lists.Equals(fixed64List, otherField.fixed64List) |
||||
&& Lists.Equals(lengthDelimitedList, otherField.lengthDelimitedList); |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Get the hash code of the unknown field. |
||||
/// </summary> |
||||
public override int GetHashCode() |
||||
{ |
||||
int hash = 43; |
||||
hash = hash * 47 + Lists.GetHashCode(varintList); |
||||
hash = hash * 47 + Lists.GetHashCode(fixed32List); |
||||
hash = hash * 47 + Lists.GetHashCode(fixed64List); |
||||
hash = hash * 47 + Lists.GetHashCode(lengthDelimitedList); |
||||
return hash; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Serializes the field, including the field number, and writes it to |
||||
/// <paramref name="output"/> |
||||
/// </summary> |
||||
/// <param name="fieldNumber">The unknown field number.</param> |
||||
/// <param name="output">The CodedOutputStream to write to.</param> |
||||
internal void WriteTo(int fieldNumber, CodedOutputStream output) |
||||
{ |
||||
if (varintList != null) |
||||
{ |
||||
foreach (ulong value in varintList) |
||||
{ |
||||
output.WriteTag(fieldNumber, WireFormat.WireType.Varint); |
||||
output.WriteUInt64(value); |
||||
} |
||||
} |
||||
if (fixed32List != null) |
||||
{ |
||||
foreach (uint value in fixed32List) |
||||
{ |
||||
output.WriteTag(fieldNumber, WireFormat.WireType.Fixed32); |
||||
output.WriteFixed32(value); |
||||
} |
||||
} |
||||
if (fixed64List != null) |
||||
{ |
||||
foreach (ulong value in fixed64List) |
||||
{ |
||||
output.WriteTag(fieldNumber, WireFormat.WireType.Fixed64); |
||||
output.WriteFixed64(value); |
||||
} |
||||
} |
||||
if (lengthDelimitedList != null) |
||||
{ |
||||
foreach (ByteString value in lengthDelimitedList) |
||||
{ |
||||
output.WriteTag(fieldNumber, WireFormat.WireType.LengthDelimited); |
||||
output.WriteBytes(value); |
||||
} |
||||
} |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Computes the number of bytes required to encode this field, including field |
||||
/// number. |
||||
/// </summary> |
||||
internal int GetSerializedSize(int fieldNumber) |
||||
{ |
||||
int result = 0; |
||||
if (varintList != null) |
||||
{ |
||||
result += CodedOutputStream.ComputeTagSize(fieldNumber) * varintList.Count; |
||||
foreach (ulong value in varintList) |
||||
{ |
||||
result += CodedOutputStream.ComputeUInt64Size(value); |
||||
} |
||||
} |
||||
if (fixed32List != null) |
||||
{ |
||||
result += CodedOutputStream.ComputeTagSize(fieldNumber) * fixed32List.Count; |
||||
result += CodedOutputStream.ComputeFixed32Size(1) * fixed32List.Count; |
||||
} |
||||
if (fixed64List != null) |
||||
{ |
||||
result += CodedOutputStream.ComputeTagSize(fieldNumber) * fixed64List.Count; |
||||
result += CodedOutputStream.ComputeFixed64Size(1) * fixed64List.Count; |
||||
} |
||||
if (lengthDelimitedList != null) |
||||
{ |
||||
result += CodedOutputStream.ComputeTagSize(fieldNumber) * lengthDelimitedList.Count; |
||||
foreach (ByteString value in lengthDelimitedList) |
||||
{ |
||||
result += CodedOutputStream.ComputeBytesSize(value); |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Merge the values in <paramref name="other" /> into this field. For each list |
||||
/// of values, <paramref name="other"/>'s values are append to the ones in this |
||||
/// field. |
||||
/// </summary> |
||||
internal UnknownField MergeFrom(UnknownField other) |
||||
{ |
||||
varintList = AddAll(varintList, other.varintList); |
||||
fixed32List = AddAll(fixed32List, other.fixed32List); |
||||
fixed64List = AddAll(fixed64List, other.fixed64List); |
||||
lengthDelimitedList = AddAll(lengthDelimitedList, other.lengthDelimitedList); |
||||
return this; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Returns a new list containing all of the given specified values from |
||||
/// both the <paramref name="current"/> and <paramref name="extras"/> lists. |
||||
/// If <paramref name="current" /> is null and <paramref name="extras"/> is empty, |
||||
/// null is returned. Otherwise, either a new list is created (if <paramref name="current" /> |
||||
/// is null) or the elements of <paramref name="extras"/> are added to <paramref name="current" />. |
||||
/// </summary> |
||||
private static List<T> AddAll<T>(List<T> current, IList<T> extras) |
||||
{ |
||||
if (extras.Count == 0) |
||||
{ |
||||
return current; |
||||
} |
||||
if (current == null) |
||||
{ |
||||
current = new List<T>(extras); |
||||
} |
||||
else |
||||
{ |
||||
current.AddRange(extras); |
||||
} |
||||
return current; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Adds a varint value. |
||||
/// </summary> |
||||
internal UnknownField AddVarint(ulong value) |
||||
{ |
||||
varintList = Add(varintList, value); |
||||
return this; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Adds a fixed32 value. |
||||
/// </summary> |
||||
internal UnknownField AddFixed32(uint value) |
||||
{ |
||||
fixed32List = Add(fixed32List, value); |
||||
return this; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Adds a fixed64 value. |
||||
/// </summary> |
||||
internal UnknownField AddFixed64(ulong value) |
||||
{ |
||||
fixed64List = Add(fixed64List, value); |
||||
return this; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Adds a length-delimited value. |
||||
/// </summary> |
||||
internal UnknownField AddLengthDelimited(ByteString value) |
||||
{ |
||||
lengthDelimitedList = Add(lengthDelimitedList, value); |
||||
return this; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Adds <paramref name="value"/> to the <paramref name="list"/>, creating |
||||
/// a new list if <paramref name="list"/> is null. The list is returned - either |
||||
/// the original reference or the new list. |
||||
/// </summary> |
||||
private static List<T> Add<T>(List<T> list, T value) |
||||
{ |
||||
if (list == null) |
||||
{ |
||||
list = new List<T>(); |
||||
} |
||||
list.Add(value); |
||||
return list; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,324 @@ |
||||
#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 System.Collections.Generic; |
||||
using System.IO; |
||||
using Google.Protobuf.Reflection; |
||||
|
||||
namespace Google.Protobuf |
||||
{ |
||||
/// <summary> |
||||
/// Used to keep track of fields which were seen when parsing a protocol message |
||||
/// but whose field numbers or types are unrecognized. This most frequently |
||||
/// occurs when new fields are added to a message type and then messages containing |
||||
/// those fields are read by old software that was built before the new types were |
||||
/// added. |
||||
/// |
||||
/// Most users will never need to use this class directly. |
||||
/// </summary> |
||||
public sealed partial class UnknownFieldSet |
||||
{ |
||||
private readonly IDictionary<int, UnknownField> fields; |
||||
|
||||
/// <summary> |
||||
/// Creates a new UnknownFieldSet. |
||||
/// </summary> |
||||
internal UnknownFieldSet() |
||||
{ |
||||
this.fields = new Dictionary<int, UnknownField>(); |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Checks whether or not the given field number is present in the set. |
||||
/// </summary> |
||||
internal bool HasField(int field) |
||||
{ |
||||
return fields.ContainsKey(field); |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Serializes the set and writes it to <paramref name="output"/>. |
||||
/// </summary> |
||||
public void WriteTo(CodedOutputStream output) |
||||
{ |
||||
foreach (KeyValuePair<int, UnknownField> entry in fields) |
||||
{ |
||||
entry.Value.WriteTo(entry.Key, output); |
||||
} |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Gets the number of bytes required to encode this set. |
||||
/// </summary> |
||||
public int CalculateSize() |
||||
{ |
||||
int result = 0; |
||||
foreach (KeyValuePair<int, UnknownField> entry in fields) |
||||
{ |
||||
result += entry.Value.GetSerializedSize(entry.Key); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Checks if two unknown field sets are equal. |
||||
/// </summary> |
||||
public override bool Equals(object other) |
||||
{ |
||||
if (ReferenceEquals(this, other)) |
||||
{ |
||||
return true; |
||||
} |
||||
UnknownFieldSet otherSet = other as UnknownFieldSet; |
||||
IDictionary<int, UnknownField> otherFields = otherSet.fields; |
||||
if (fields.Count != otherFields.Count) |
||||
{ |
||||
return false; |
||||
} |
||||
foreach (KeyValuePair<int, UnknownField> leftEntry in fields) |
||||
{ |
||||
UnknownField rightValue; |
||||
if (!otherFields.TryGetValue(leftEntry.Key, out rightValue)) |
||||
{ |
||||
return false; |
||||
} |
||||
if (!leftEntry.Value.Equals(rightValue)) |
||||
{ |
||||
return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Gets the unknown field set's hash code. |
||||
/// </summary> |
||||
public override int GetHashCode() |
||||
{ |
||||
int ret = 1; |
||||
foreach (KeyValuePair<int, UnknownField> field in fields) |
||||
{ |
||||
// Use ^ here to make the field order irrelevant. |
||||
int hash = field.Key.GetHashCode() ^ field.Value.GetHashCode(); |
||||
ret ^= hash; |
||||
} |
||||
return ret; |
||||
} |
||||
|
||||
// Optimization: We keep around the last field that was |
||||
// modified so that we can efficiently add to it multiple times in a |
||||
// row (important when parsing an unknown repeated field). |
||||
private int lastFieldNumber; |
||||
private UnknownField lastField; |
||||
|
||||
private UnknownField GetOrAddField(int number) |
||||
{ |
||||
if (lastField != null && number == lastFieldNumber) |
||||
{ |
||||
return lastField; |
||||
} |
||||
if (number == 0) |
||||
{ |
||||
return null; |
||||
} |
||||
|
||||
UnknownField existing; |
||||
if (fields.TryGetValue(number, out existing)) |
||||
{ |
||||
return existing; |
||||
} |
||||
lastField = new UnknownField(); |
||||
AddOrReplaceField(number, lastField); |
||||
lastFieldNumber = number; |
||||
return lastField; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Adds a field to the set. If a field with the same number already exists, it |
||||
/// is replaced. |
||||
/// </summary> |
||||
internal UnknownFieldSet AddOrReplaceField(int number, UnknownField field) |
||||
{ |
||||
if (number == 0) |
||||
{ |
||||
throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number."); |
||||
} |
||||
fields[number] = field; |
||||
return this; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Parse a single field from <paramref name="input"/> and merge it |
||||
/// into this set. |
||||
/// </summary> |
||||
/// <param name="input">The coded input stream containing the field</param> |
||||
/// <returns>false if the tag is an "end group" tag, true otherwise</returns> |
||||
private void MergeFieldFrom(CodedInputStream input) |
||||
{ |
||||
uint tag = input.LastTag; |
||||
int number = WireFormat.GetTagFieldNumber(tag); |
||||
switch (WireFormat.GetTagWireType(tag)) |
||||
{ |
||||
case WireFormat.WireType.Varint: |
||||
{ |
||||
ulong uint64 = input.ReadUInt64(); |
||||
GetOrAddField(number).AddVarint(uint64); |
||||
return; |
||||
} |
||||
case WireFormat.WireType.Fixed32: |
||||
{ |
||||
uint uint32 = input.ReadFixed32(); |
||||
GetOrAddField(number).AddFixed32(uint32); |
||||
return; |
||||
} |
||||
case WireFormat.WireType.Fixed64: |
||||
{ |
||||
ulong uint64 = input.ReadFixed64(); |
||||
GetOrAddField(number).AddFixed64(uint64); |
||||
return; |
||||
} |
||||
case WireFormat.WireType.LengthDelimited: |
||||
{ |
||||
ByteString bytes = input.ReadBytes(); |
||||
GetOrAddField(number).AddLengthDelimited(bytes); |
||||
return; |
||||
} |
||||
case WireFormat.WireType.StartGroup: |
||||
{ |
||||
input.SkipGroup(tag); |
||||
return; |
||||
} |
||||
case WireFormat.WireType.EndGroup: |
||||
{ |
||||
throw new InvalidProtocolBufferException("Merge an unknown field of end-group tag, indicating that the corresponding start-group was missing."); |
||||
} |
||||
default: |
||||
throw new InvalidOperationException("Wire Type is invalid."); |
||||
} |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Create a new UnknownFieldSet if unknownFields is null. |
||||
/// Parse a single field from <paramref name="input"/> and merge it |
||||
/// into unknownFields. |
||||
/// </summary> |
||||
/// <param name="unknownFields">The UnknownFieldSet which need to be merged</param> |
||||
/// <param name="input">The coded input stream containing the field</param> |
||||
/// <returns>The merged UnknownFieldSet</returns> |
||||
public static UnknownFieldSet MergeFieldFrom(UnknownFieldSet unknownFields, |
||||
CodedInputStream input) |
||||
{ |
||||
if (unknownFields == null) |
||||
{ |
||||
unknownFields = new UnknownFieldSet(); |
||||
} |
||||
unknownFields.MergeFieldFrom(input); |
||||
return unknownFields; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Merges the fields from <paramref name="other"/> into this set. |
||||
/// If a field number exists in both sets, the values in <paramref name="other"/> |
||||
/// will be appended to the values in this set. |
||||
/// </summary> |
||||
private UnknownFieldSet MergeFrom(UnknownFieldSet other) |
||||
{ |
||||
if (other != null) |
||||
{ |
||||
foreach (KeyValuePair<int, UnknownField> entry in other.fields) |
||||
{ |
||||
MergeField(entry.Key, entry.Value); |
||||
} |
||||
} |
||||
return this; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Created a new UnknownFieldSet to <paramref name="unknownFields"/> if |
||||
/// needed and merges the fields from <paramref name="other"/> into the first set. |
||||
/// If a field number exists in both sets, the values in <paramref name="other"/> |
||||
/// will be appended to the values in this set. |
||||
/// </summary> |
||||
public static UnknownFieldSet MergeFrom(UnknownFieldSet unknownFields, |
||||
UnknownFieldSet other) |
||||
{ |
||||
if (other == null) |
||||
{ |
||||
return unknownFields; |
||||
} |
||||
if (unknownFields == null) |
||||
{ |
||||
unknownFields = new UnknownFieldSet(); |
||||
} |
||||
unknownFields.MergeFrom(other); |
||||
return unknownFields; |
||||
} |
||||
|
||||
|
||||
/// <summary> |
||||
/// Adds a field to the unknown field set. If a field with the same |
||||
/// number already exists, the two are merged. |
||||
/// </summary> |
||||
private UnknownFieldSet MergeField(int number, UnknownField field) |
||||
{ |
||||
if (number == 0) |
||||
{ |
||||
throw new ArgumentOutOfRangeException("number", "Zero is not a valid field number."); |
||||
} |
||||
if (HasField(number)) |
||||
{ |
||||
GetOrAddField(number).MergeFrom(field); |
||||
} |
||||
else |
||||
{ |
||||
AddOrReplaceField(number, field); |
||||
} |
||||
return this; |
||||
} |
||||
|
||||
/// <summary> |
||||
/// Clone an unknown field set from <paramref name="other"/>. |
||||
/// </summary> |
||||
public static UnknownFieldSet Clone(UnknownFieldSet other) |
||||
{ |
||||
if (other == null) |
||||
{ |
||||
return null; |
||||
} |
||||
UnknownFieldSet unknownFields = new UnknownFieldSet(); |
||||
unknownFields.MergeFrom(other); |
||||
return unknownFields; |
||||
} |
||||
} |
||||
} |
||||
|
||||
Loading…
Reference in new issue