diff options
Diffstat (limited to 'csharp/src/ProtocolBuffers/FieldSet.cs')
| -rw-r--r-- | csharp/src/ProtocolBuffers/FieldSet.cs | 632 |
1 files changed, 632 insertions, 0 deletions
diff --git a/csharp/src/ProtocolBuffers/FieldSet.cs b/csharp/src/ProtocolBuffers/FieldSet.cs new file mode 100644 index 00000000..f3c08cf5 --- /dev/null +++ b/csharp/src/ProtocolBuffers/FieldSet.cs @@ -0,0 +1,632 @@ +#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);
+ }
+ }
+ }
+}
\ No newline at end of file |