#region Copyright notice and license | |
// Protocol Buffers - Google's data interchange format | |
// Copyright 2008 Google Inc. All rights reserved. | |
// http://github.com/jskeet/dotnet-protobufs/ | |
// Original C++/Java/Python code: | |
// http://code.google.com/p/protobuf/ | |
// | |
// 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; | |
using System.Collections.Generic; | |
using Google.ProtocolBuffers.Collections; | |
using Google.ProtocolBuffers.Descriptors; | |
namespace Google.ProtocolBuffers | |
{ | |
public interface IFieldDescriptorLite : IComparable<IFieldDescriptorLite> | |
{ | |
bool IsRepeated { get; } | |
bool IsRequired { get; } | |
bool IsPacked { get; } | |
bool IsExtension { get; } | |
bool MessageSetWireFormat { get; } //field.ContainingType.Options.MessageSetWireFormat | |
int FieldNumber { get; } | |
string Name { get; } | |
string FullName { get; } | |
IEnumLiteMap EnumType { get; } | |
FieldType FieldType { get; } | |
MappedType MappedType { get; } | |
object DefaultValue { get; } | |
} | |
/// <summary> | |
/// A class which represents an arbitrary set of fields of some message type. | |
/// This is used to implement DynamicMessage, and also to represent extensions | |
/// in GeneratedMessage. This class is internal, since outside users should probably | |
/// be using DynamicMessage. | |
/// | |
/// As in the Java implementation, this class goes against the rest of the framework | |
/// in terms of mutability. Instead of having a mutable Builder class and an immutable | |
/// FieldSet class, FieldSet just has a MakeImmutable() method. This is safe so long as | |
/// all callers are careful not to let a mutable FieldSet escape into the open. This would | |
/// be impossible to guarantee if this were a public class, of course. | |
/// | |
/// All repeated fields are stored as IList[object] even | |
/// TODO(jonskeet): Finish this comment! | |
/// </summary> | |
internal sealed class FieldSet | |
{ | |
private static readonly FieldSet defaultInstance = | |
new FieldSet(new Dictionary<IFieldDescriptorLite, object>()).MakeImmutable(); | |
private IDictionary<IFieldDescriptorLite, object> fields; | |
private FieldSet(IDictionary<IFieldDescriptorLite, object> fields) | |
{ | |
this.fields = fields; | |
} | |
public static FieldSet CreateInstance() | |
{ | |
// Use SortedList to keep fields in the canonical order | |
return new FieldSet(new SortedList<IFieldDescriptorLite, object>()); | |
} | |
/// <summary> | |
/// Makes this FieldSet immutable, and returns it for convenience. Any | |
/// mutable repeated fields are made immutable, as well as the map itself. | |
/// </summary> | |
internal FieldSet MakeImmutable() | |
{ | |
// First check if we have any repeated values | |
bool hasRepeats = false; | |
foreach (object value in fields.Values) | |
{ | |
IList<object> list = value as IList<object>; | |
if (list != null && !list.IsReadOnly) | |
{ | |
hasRepeats = true; | |
break; | |
} | |
} | |
if (hasRepeats) | |
{ | |
var tmp = new SortedList<IFieldDescriptorLite, object>(); | |
foreach (KeyValuePair<IFieldDescriptorLite, object> entry in fields) | |
{ | |
IList<object> list = entry.Value as IList<object>; | |
tmp[entry.Key] = list == null ? entry.Value : Lists.AsReadOnly(list); | |
} | |
fields = tmp; | |
} | |
fields = Dictionaries.AsReadOnly(fields); | |
return this; | |
} | |
/// <summary> | |
/// Returns the default, immutable instance with no fields defined. | |
/// </summary> | |
internal static FieldSet DefaultInstance | |
{ | |
get { return defaultInstance; } | |
} | |
/// <summary> | |
/// Returns an immutable mapping of fields. Note that although the mapping itself | |
/// is immutable, the entries may not be (i.e. any repeated values are represented by | |
/// mutable lists). The behaviour is not specified if the contents are mutated. | |
/// </summary> | |
internal IDictionary<IFieldDescriptorLite, object> AllFields | |
{ | |
get { return Dictionaries.AsReadOnly(fields); } | |
} | |
#if !LITE | |
/// <summary> | |
/// Force coercion to full descriptor dictionary. | |
/// </summary> | |
internal IDictionary<FieldDescriptor, object> AllFieldDescriptors | |
{ | |
get | |
{ | |
SortedList<FieldDescriptor, object> copy = | |
new SortedList<FieldDescriptor, object>(); | |
foreach (KeyValuePair<IFieldDescriptorLite, object> fd in fields) | |
{ | |
copy.Add((FieldDescriptor) fd.Key, fd.Value); | |
} | |
return Dictionaries.AsReadOnly(copy); | |
} | |
} | |
#endif | |
/// <summary> | |
/// See <see cref="IMessageLite.HasField"/>. | |
/// </summary> | |
public bool HasField(IFieldDescriptorLite field) | |
{ | |
if (field.IsRepeated) | |
{ | |
throw new ArgumentException("HasField() can only be called on non-repeated fields."); | |
} | |
return fields.ContainsKey(field); | |
} | |
/// <summary> | |
/// Clears all fields. | |
/// </summary> | |
internal void Clear() | |
{ | |
fields.Clear(); | |
} | |
/// <summary> | |
/// See <see cref="IMessageLite.Item(IFieldDescriptorLite)"/> | |
/// </summary> | |
/// <remarks> | |
/// If the field is not set, the behaviour when fetching this property varies by field type: | |
/// <list> | |
/// <item>For singular message values, null is returned.</item> | |
/// <item>For singular non-message values, the default value of the field is returned.</item> | |
/// <item>For repeated values, an empty immutable list is returned. This will be compatible | |
/// with IList[object], regardless of the type of the repeated item.</item> | |
/// </list> | |
/// This method returns null if the field is a singular message type | |
/// and is not set; in this case it is up to the caller to fetch the | |
/// message's default instance. For repeated fields of message types, | |
/// an empty collection is returned. For repeated fields of non-message | |
/// types, null is returned. | |
/// <para /> | |
/// When setting this property, any list values are copied, and each element is checked | |
/// to ensure it is of an appropriate type. | |
/// </remarks> | |
/// | |
internal object this[IFieldDescriptorLite field] | |
{ | |
get | |
{ | |
object result; | |
if (fields.TryGetValue(field, out result)) | |
{ | |
return result; | |
} | |
if (field.MappedType == MappedType.Message) | |
{ | |
if (field.IsRepeated) | |
{ | |
return new List<object>(); | |
} | |
else | |
{ | |
return null; | |
} | |
} | |
return field.DefaultValue; | |
} | |
set | |
{ | |
if (field.IsRepeated) | |
{ | |
List<object> list = value as List<object>; | |
if (list == null) | |
{ | |
throw new ArgumentException("Wrong object type used with protocol message reflection."); | |
} | |
// Wrap the contents in a new list so that the caller cannot change | |
// the list's contents after setting it. | |
List<object> newList = new List<object>(list); | |
foreach (object element in newList) | |
{ | |
VerifyType(field, element); | |
} | |
value = newList; | |
} | |
else | |
{ | |
VerifyType(field, value); | |
} | |
fields[field] = value; | |
} | |
} | |
/// <summary> | |
/// See <see cref="IMessageLite.Item(IFieldDescriptorLite,int)" /> | |
/// </summary> | |
internal object this[IFieldDescriptorLite field, int index] | |
{ | |
get | |
{ | |
if (!field.IsRepeated) | |
{ | |
throw new ArgumentException( | |
"Indexer specifying field and index can only be called on repeated fields."); | |
} | |
return ((IList<object>) this[field])[index]; | |
} | |
set | |
{ | |
if (!field.IsRepeated) | |
{ | |
throw new ArgumentException( | |
"Indexer specifying field and index can only be called on repeated fields."); | |
} | |
VerifyType(field, value); | |
object list; | |
if (!fields.TryGetValue(field, out list)) | |
{ | |
throw new ArgumentOutOfRangeException(); | |
} | |
((IList<object>) list)[index] = value; | |
} | |
} | |
/// <summary> | |
/// See <see cref="IBuilder{TMessage, TBuilder}.AddRepeatedField" /> | |
/// </summary> | |
internal void AddRepeatedField(IFieldDescriptorLite field, object value) | |
{ | |
if (!field.IsRepeated) | |
{ | |
throw new ArgumentException("AddRepeatedField can only be called on repeated fields."); | |
} | |
VerifyType(field, value); | |
object list; | |
if (!fields.TryGetValue(field, out list)) | |
{ | |
list = new List<object>(); | |
fields[field] = list; | |
} | |
((IList<object>) list).Add(value); | |
} | |
/// <summary> | |
/// Returns an enumerator for the field map. Used to write the fields out. | |
/// </summary> | |
internal IEnumerator<KeyValuePair<IFieldDescriptorLite, object>> GetEnumerator() | |
{ | |
return fields.GetEnumerator(); | |
} | |
/// <summary> | |
/// See <see cref="IMessageLite.IsInitialized" /> | |
/// </summary> | |
/// <remarks> | |
/// Since FieldSet itself does not have any way of knowing about | |
/// required fields that aren't actually present in the set, it is up | |
/// to the caller to check for genuinely required fields. This property | |
/// merely checks that any messages present are themselves initialized. | |
/// </remarks> | |
internal bool IsInitialized | |
{ | |
get | |
{ | |
foreach (KeyValuePair<IFieldDescriptorLite, object> entry in fields) | |
{ | |
IFieldDescriptorLite field = entry.Key; | |
if (field.MappedType == MappedType.Message) | |
{ | |
if (field.IsRepeated) | |
{ | |
foreach (IMessageLite message in (IEnumerable) entry.Value) | |
{ | |
if (!message.IsInitialized) | |
{ | |
return false; | |
} | |
} | |
} | |
else | |
{ | |
if (!((IMessageLite) entry.Value).IsInitialized) | |
{ | |
return false; | |
} | |
} | |
} | |
} | |
return true; | |
} | |
} | |
/// <summary> | |
/// Verifies whether all the required fields in the specified message | |
/// descriptor are present in this field set, as well as whether | |
/// all the embedded messages are themselves initialized. | |
/// </summary> | |
internal bool IsInitializedWithRespectTo(IEnumerable typeFields) | |
{ | |
foreach (IFieldDescriptorLite field in typeFields) | |
{ | |
if (field.IsRequired && !HasField(field)) | |
{ | |
return false; | |
} | |
} | |
return IsInitialized; | |
} | |
/// <summary> | |
/// See <see cref="IBuilder{TMessage, TBuilder}.ClearField" /> | |
/// </summary> | |
public void ClearField(IFieldDescriptorLite field) | |
{ | |
fields.Remove(field); | |
} | |
/// <summary> | |
/// See <see cref="IMessageLite.GetRepeatedFieldCount" /> | |
/// </summary> | |
public int GetRepeatedFieldCount(IFieldDescriptorLite field) | |
{ | |
if (!field.IsRepeated) | |
{ | |
throw new ArgumentException("GetRepeatedFieldCount() can only be called on repeated fields."); | |
} | |
return ((IList<object>) this[field]).Count; | |
} | |
#if !LITE | |
/// <summary> | |
/// See <see cref="IBuilder{TMessage, TBuilder}.MergeFrom(IMessageLite)" /> | |
/// </summary> | |
public void MergeFrom(IMessage other) | |
{ | |
foreach (KeyValuePair<FieldDescriptor, object> fd in other.AllFields) | |
{ | |
MergeField(fd.Key, fd.Value); | |
} | |
} | |
#endif | |
/// <summary> | |
/// Implementation of both <c>MergeFrom</c> methods. | |
/// </summary> | |
/// <param name="otherFields"></param> | |
public void MergeFrom(FieldSet other) | |
{ | |
// Note: We don't attempt to verify that other's fields have valid | |
// types. Doing so would be a losing battle. We'd have to verify | |
// all sub-messages as well, and we'd have to make copies of all of | |
// them to insure that they don't change after verification (since | |
// the IMessageLite interface itself cannot enforce immutability of | |
// implementations). | |
// TODO(jonskeet): Provide a function somewhere called MakeDeepCopy() | |
// which allows people to make secure deep copies of messages. | |
foreach (KeyValuePair<IFieldDescriptorLite, object> entry in other.fields) | |
{ | |
MergeField(entry.Key, entry.Value); | |
} | |
} | |
private void MergeField(IFieldDescriptorLite field, object mergeValue) | |
{ | |
object existingValue; | |
fields.TryGetValue(field, out existingValue); | |
if (field.IsRepeated) | |
{ | |
if (existingValue == null) | |
{ | |
existingValue = new List<object>(); | |
fields[field] = existingValue; | |
} | |
IList<object> list = (IList<object>) existingValue; | |
foreach (object otherValue in (IEnumerable) mergeValue) | |
{ | |
list.Add(otherValue); | |
} | |
} | |
else if (field.MappedType == MappedType.Message && existingValue != null) | |
{ | |
IMessageLite existingMessage = (IMessageLite) existingValue; | |
IMessageLite merged = existingMessage.WeakToBuilder() | |
.WeakMergeFrom((IMessageLite) mergeValue) | |
.WeakBuild(); | |
this[field] = merged; | |
} | |
else | |
{ | |
this[field] = mergeValue; | |
} | |
} | |
/// <summary> | |
/// See <see cref="IMessageLite.WriteTo(CodedOutputStream)" />. | |
/// </summary> | |
public void WriteTo(ICodedOutputStream output) | |
{ | |
foreach (KeyValuePair<IFieldDescriptorLite, object> entry in fields) | |
{ | |
WriteField(entry.Key, entry.Value, output); | |
} | |
} | |
/// <summary> | |
/// Writes a single field to a CodedOutputStream. | |
/// </summary> | |
public void WriteField(IFieldDescriptorLite field, Object value, ICodedOutputStream output) | |
{ | |
if (field.IsExtension && field.MessageSetWireFormat) | |
{ | |
output.WriteMessageSetExtension(field.FieldNumber, field.Name, (IMessageLite) value); | |
} | |
else | |
{ | |
if (field.IsRepeated) | |
{ | |
IEnumerable valueList = (IEnumerable) value; | |
if (field.IsPacked) | |
{ | |
output.WritePackedArray(field.FieldType, field.FieldNumber, field.Name, valueList); | |
} | |
else | |
{ | |
output.WriteArray(field.FieldType, field.FieldNumber, field.Name, valueList); | |
} | |
} | |
else | |
{ | |
output.WriteField(field.FieldType, field.FieldNumber, field.Name, value); | |
} | |
} | |
} | |
/// <summary> | |
/// See <see cref="IMessageLite.SerializedSize" />. It's up to the caller to | |
/// cache the resulting size if desired. | |
/// </summary> | |
public int SerializedSize | |
{ | |
get | |
{ | |
int size = 0; | |
foreach (KeyValuePair<IFieldDescriptorLite, object> entry in fields) | |
{ | |
IFieldDescriptorLite field = entry.Key; | |
object value = entry.Value; | |
if (field.IsExtension && field.MessageSetWireFormat) | |
{ | |
size += CodedOutputStream.ComputeMessageSetExtensionSize(field.FieldNumber, (IMessageLite) value); | |
} | |
else | |
{ | |
if (field.IsRepeated) | |
{ | |
IEnumerable valueList = (IEnumerable) value; | |
if (field.IsPacked) | |
{ | |
int dataSize = 0; | |
foreach (object element in valueList) | |
{ | |
dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element); | |
} | |
size += dataSize + CodedOutputStream.ComputeTagSize(field.FieldNumber) + | |
CodedOutputStream.ComputeRawVarint32Size((uint) dataSize); | |
} | |
else | |
{ | |
foreach (object element in valueList) | |
{ | |
size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, | |
element); | |
} | |
} | |
} | |
else | |
{ | |
size += CodedOutputStream.ComputeFieldSize(field.FieldType, field.FieldNumber, value); | |
} | |
} | |
} | |
return size; | |
} | |
} | |
/// <summary> | |
/// Verifies that the given object is of the correct type to be a valid | |
/// value for the given field. | |
/// </summary> | |
/// <remarks> | |
/// For repeated fields, this checks if the object is of the right | |
/// element type, not whether it's a list. | |
/// </remarks> | |
/// <exception cref="ArgumentException">The value is not of the right type.</exception> | |
/// <exception cref="ArgumentNullException">The value is null.</exception> | |
private static void VerifyType(IFieldDescriptorLite field, object value) | |
{ | |
ThrowHelper.ThrowIfNull(value, "value"); | |
bool isValid = false; | |
switch (field.MappedType) | |
{ | |
case MappedType.Int32: | |
isValid = value is int; | |
break; | |
case MappedType.Int64: | |
isValid = value is long; | |
break; | |
case MappedType.UInt32: | |
isValid = value is uint; | |
break; | |
case MappedType.UInt64: | |
isValid = value is ulong; | |
break; | |
case MappedType.Single: | |
isValid = value is float; | |
break; | |
case MappedType.Double: | |
isValid = value is double; | |
break; | |
case MappedType.Boolean: | |
isValid = value is bool; | |
break; | |
case MappedType.String: | |
isValid = value is string; | |
break; | |
case MappedType.ByteString: | |
isValid = value is ByteString; | |
break; | |
case MappedType.Enum: | |
IEnumLite enumValue = value as IEnumLite; | |
isValid = enumValue != null && field.EnumType.IsValidValue(enumValue); | |
break; | |
case MappedType.Message: | |
IMessageLite messageValue = value as IMessageLite; | |
isValid = messageValue != null; | |
#if !LITE | |
if (isValid && messageValue is IMessage && field is FieldDescriptor) | |
{ | |
isValid = ((IMessage) messageValue).DescriptorForType == ((FieldDescriptor) field).MessageType; | |
} | |
#endif | |
break; | |
} | |
if (!isValid) | |
{ | |
// When chaining calls to SetField(), it can be hard to tell from | |
// the stack trace which exact call failed, since the whole chain is | |
// considered one line of code. So, let's make sure to include the | |
// field name and other useful info in the exception. | |
string message = "Wrong object type used with protocol message reflection."; | |
#if !LITE | |
FieldDescriptor fieldinfo = | |
field as FieldDescriptor; | |
if (fieldinfo != null) | |
{ | |
message += "Message type \"" + fieldinfo.ContainingType.FullName; | |
message += "\", field \"" + (fieldinfo.IsExtension ? fieldinfo.FullName : fieldinfo.Name); | |
message += "\", value was type \"" + value.GetType().Name + "\"."; | |
} | |
#endif | |
throw new ArgumentException(message); | |
} | |
} | |
} | |
} |