internal bool IsInitializedWithRespectTo(IEnumerable typeFields)
{
IEnumerator enumerator = typeFields.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
IFieldDescriptorLite fieldDescriptorLite = (IFieldDescriptorLite)enumerator.Current;
if (fieldDescriptorLite.IsRequired && !this.HasField(fieldDescriptorLite))
{
return(false);
}
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
return(this.IsInitialized);
}
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>
/// 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.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;
}
}
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);
}
public bool HasField(IFieldDescriptorLite field)
{
if (field.IsRepeated)
{
throw new ArgumentException("HasField() can only be called on non-repeated fields.");
}
return(this.fields.ContainsKey(field));
}
public void TestIndexedByDescriptorAndOrdinalOutOfRange()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
Assert.AreEqual(0, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor;
Assert.Throws <ArgumentOutOfRangeException>(() => builder[f, 0] = 123);
}
public void TestIndexedByDescriptorAndOrdinalOutOfRange()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder();
Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;
builder[f, 0] = 123;
}
public TBuilder AddRepeatedField(IFieldDescriptorLite field, object value)
{
if (field.IsExtension)
{
ExtendableMessageLite <TMessage, TBuilder> extendableMessageLite = this.MessageBeingBuilt;
extendableMessageLite.Extensions.AddRepeatedField(field, value);
return(this.ThisBuilder);
}
throw new NotSupportedException("Not supported in the lite runtime.");
}
public void TestClearFieldByDescriptor()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite, 0);
Assert.AreEqual(1, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnitTestLiteProtoFile.RepeatedInt32ExtensionLite.Descriptor;
builder.ClearField(f);
Assert.AreEqual(0, builder.GetExtensionCount(UnitTestLiteProtoFile.RepeatedInt32ExtensionLite));
}
public void TestAddRepeatedFieldByDescriptor()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0);
Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor;
builder.AddRepeatedField(f, 123);
Assert.AreEqual(2, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
Assert.AreEqual(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 1));
}
public void TestIndexedByDescriptorAndOrdinal()
{
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.CreateBuilder()
.AddExtension(UnittestLite.RepeatedInt32ExtensionLite, 0);
Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
IFieldDescriptorLite f = UnittestLite.RepeatedInt32ExtensionLite.Descriptor;
builder[f, 0] = 123;
Assert.AreEqual(1, builder.GetExtensionCount(UnittestLite.RepeatedInt32ExtensionLite));
Assert.AreEqual(123, builder.GetExtension(UnittestLite.RepeatedInt32ExtensionLite, 0));
}
public TBuilder ClearField(IFieldDescriptorLite field)
{
if (field.IsExtension)
{
ExtendableMessageLite <TMessage, TBuilder> message = MessageBeingBuilt;
message.Extensions.ClearField(field);
return(ThisBuilder);
}
else
{
throw new NotSupportedException("Not supported in the lite runtime.");
}
}
public object this[IFieldDescriptorLite field, int index]
{
set
{
if (field.IsExtension)
{
ExtendableMessageLite <TMessage, TBuilder> extendableMessageLite = this.MessageBeingBuilt;
extendableMessageLite.Extensions[field, index] = value;
return;
}
throw new NotSupportedException("Not supported in the lite runtime.");
}
}
public object this[IFieldDescriptorLite field] {
set {
if (field.IsExtension)
{
ExtendableMessageLite <TMessage, TBuilder> message = MessageBeingBuilt;
message.Extensions[field] = value;
}
else
{
throw new NotSupportedException("Not supported in the lite runtime.");
}
}
}
/// <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="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);
}
internal void AddRepeatedField(IFieldDescriptorLite field, object value)
{
if (!field.IsRepeated)
{
throw new ArgumentException("AddRepeatedField can only be called on repeated fields.");
}
FieldSet.VerifyType(field, value);
object obj;
if (!this.fields.TryGetValue(field, out obj))
{
obj = new List <object>();
this.fields[field] = obj;
}
((IList <object>)obj).Add(value);
}
internal object this[IFieldDescriptorLite field]
{
get
{
object result;
if (this.fields.TryGetValue(field, out result))
{
return(result);
}
if (field.MappedType != MappedType.Message)
{
return(field.DefaultValue);
}
if (field.IsRepeated)
{
return(new List <object>());
}
return(null);
}
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.");
}
List <object> list2 = new List <object>(list);
using (List <object> .Enumerator enumerator = list2.GetEnumerator())
{
while (enumerator.MoveNext())
{
object current = enumerator.Current;
FieldSet.VerifyType(field, current);
}
}
value = list2;
}
else
{
FieldSet.VerifyType(field, value);
}
this.fields[field] = value;
}
}
private void MergeField(IFieldDescriptorLite field, object mergeValue)
{
object obj;
this.fields.TryGetValue(field, out obj);
if (field.IsRepeated)
{
if (obj == null)
{
obj = new List <object>();
this.fields[field] = obj;
}
IList <object> list = (IList <object>)obj;
IEnumerator enumerator = ((IEnumerable)mergeValue).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object current = enumerator.Current;
list.Add(current);
}
return;
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
if (field.MappedType == MappedType.Message && obj != null)
{
IMessageLite messageLite = (IMessageLite)obj;
IMessageLite value = messageLite.WeakToBuilder().WeakMergeFrom((IMessageLite)mergeValue).WeakBuild();
this[field] = value;
return;
}
this[field] = mergeValue;
}
/// <summary>
/// Writes a single field to a CodedOutputStream.
/// </summary>
public void WriteField(IFieldDescriptorLite field, Object value, CodedOutputStream output)
{
if (field.IsExtension && field.MessageSetWireFormat)
{
output.WriteMessageSetExtension(field.FieldNumber, (IMessageLite)value);
}
else
{
if (field.IsRepeated)
{
IEnumerable valueList = (IEnumerable)value;
if (field.IsPacked)
{
output.WriteTag(field.FieldNumber, WireFormat.WireType.LengthDelimited);
// Compute the total data size so the length can be written.
int dataSize = 0;
foreach (object element in valueList)
{
dataSize += CodedOutputStream.ComputeFieldSizeNoTag(field.FieldType, element);
}
output.WriteRawVarint32((uint)dataSize);
// Write the data itself, without any tags.
foreach (object element in valueList)
{
output.WriteFieldNoTag(field.FieldType, element);
}
}
else
{
foreach (object element in valueList)
{
output.WriteField(field.FieldType, field.FieldNumber, element);
}
}
}
else
{
output.WriteField(field.FieldType, field.FieldNumber, value);
}
}
}
private static void VerifyType(IFieldDescriptorLite field, object value)
{
ThrowHelper.ThrowIfNull(value, "value");
bool flag = false;
switch (field.MappedType)
{
case MappedType.Int32:
flag = (value is int);
break;
case MappedType.Int64:
flag = (value is long);
break;
case MappedType.UInt32:
flag = (value is uint);
break;
case MappedType.UInt64:
flag = (value is ulong);
break;
case MappedType.Single:
flag = (value is float);
break;
case MappedType.Double:
flag = (value is double);
break;
case MappedType.Boolean:
flag = (value is bool);
break;
case MappedType.String:
flag = (value is string);
break;
case MappedType.ByteString:
flag = (value is ByteString);
break;
case MappedType.Message:
{
IMessageLite messageLite = value as IMessageLite;
flag = (messageLite != null);
break;
}
case MappedType.Enum:
{
IEnumLite enumLite = value as IEnumLite;
flag = (enumLite != null && field.EnumType.IsValidValue(enumLite));
break;
}
}
if (!flag)
{
string text = "Wrong object type used with protocol message reflection.";
throw new ArgumentException(text);
}
}
/// <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
Google.ProtocolBuffers.Descriptors.FieldDescriptor fieldinfo = field as Google.ProtocolBuffers.Descriptors.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);
}
}
protected override bool ParseUnknownField(ICodedInputStream input, ExtensionRegistry extensionRegistry, uint tag, string fieldName)
{
TMessage messageBeingBuilt = this.MessageBeingBuilt;
FieldSet extensions = messageBeingBuilt.Extensions;
WireFormat.WireType tagWireType = WireFormat.GetTagWireType(tag);
int tagFieldNumber = WireFormat.GetTagFieldNumber(tag);
IGeneratedExtensionLite generatedExtensionLite = extensionRegistry[this.DefaultInstanceForType, tagFieldNumber];
if (generatedExtensionLite == null)
{
return(input.SkipField());
}
IFieldDescriptorLite descriptor = generatedExtensionLite.Descriptor;
if (descriptor == null)
{
return(input.SkipField());
}
WireFormat.WireType wireType = descriptor.IsPacked ? WireFormat.WireType.LengthDelimited : WireFormat.GetWireType(descriptor.FieldType);
if (tagWireType != wireType)
{
wireType = WireFormat.GetWireType(descriptor.FieldType);
if (tagWireType != wireType && (!descriptor.IsRepeated || tagWireType != WireFormat.WireType.LengthDelimited || (wireType != WireFormat.WireType.Varint && wireType != WireFormat.WireType.Fixed32 && wireType != WireFormat.WireType.Fixed64)))
{
return(input.SkipField());
}
}
if (!descriptor.IsRepeated && tagWireType != WireFormat.GetWireType(descriptor.FieldType))
{
return(input.SkipField());
}
FieldType fieldType = descriptor.FieldType;
switch (fieldType)
{
case FieldType.Group:
case FieldType.Message:
{
if (descriptor.IsRepeated)
{
List <IMessageLite> list = new List <IMessageLite>();
if (descriptor.FieldType == FieldType.Group)
{
input.ReadGroupArray <IMessageLite>(tag, fieldName, list, generatedExtensionLite.MessageDefaultInstance, extensionRegistry);
}
else
{
input.ReadMessageArray <IMessageLite>(tag, fieldName, list, generatedExtensionLite.MessageDefaultInstance, extensionRegistry);
}
using (List <IMessageLite> .Enumerator enumerator = list.GetEnumerator())
{
while (enumerator.MoveNext())
{
IMessageLite current = enumerator.Current;
extensions.AddRepeatedField(descriptor, current);
}
}
return(true);
}
IMessageLite messageLite = extensions[generatedExtensionLite.Descriptor] as IMessageLite;
IBuilderLite builderLite = (messageLite ?? generatedExtensionLite.MessageDefaultInstance).WeakToBuilder();
if (descriptor.FieldType == FieldType.Group)
{
input.ReadGroup(descriptor.FieldNumber, builderLite, extensionRegistry);
}
else
{
input.ReadMessage(builderLite, extensionRegistry);
}
extensions[descriptor] = builderLite.WeakBuild();
break;
}
default:
if (fieldType == FieldType.Enum)
{
if (!descriptor.IsRepeated)
{
IEnumLite value = null;
object obj;
if (input.ReadEnum(ref value, out obj, descriptor.EnumType))
{
extensions[descriptor] = value;
break;
}
break;
}
else
{
List <IEnumLite> list2 = new List <IEnumLite>();
ICollection <object> collection;
input.ReadEnumArray(tag, fieldName, list2, out collection, descriptor.EnumType);
using (List <IEnumLite> .Enumerator enumerator2 = list2.GetEnumerator())
{
while (enumerator2.MoveNext())
{
IEnumLite current2 = enumerator2.Current;
extensions.AddRepeatedField(descriptor, current2);
}
break;
}
}
}
if (!descriptor.IsRepeated)
{
object value2 = null;
if (input.ReadPrimitiveField(descriptor.FieldType, ref value2))
{
extensions[descriptor] = value2;
}
}
else
{
List <object> list3 = new List <object>();
input.ReadPrimitiveArray(descriptor.FieldType, tag, fieldName, list3);
using (List <object> .Enumerator enumerator3 = list3.GetEnumerator())
{
while (enumerator3.MoveNext())
{
object current3 = enumerator3.Current;
extensions.AddRepeatedField(descriptor, current3);
}
}
}
break;
}
return(true);
}
/// <summary>
/// See <see cref="IBuilder{TMessage, TBuilder}.ClearField" />
/// </summary>
public void ClearField(IFieldDescriptorLite field)
{
fields.Remove(field);
}
protected override bool ParseUnknownField(ICodedInputStream input,
ExtensionRegistry extensionRegistry, uint tag, string fieldName)
{
FieldSet extensions = MessageBeingBuilt.Extensions;
WireFormat.WireType wireType = WireFormat.GetTagWireType(tag);
int fieldNumber = WireFormat.GetTagFieldNumber(tag);
IGeneratedExtensionLite extension = extensionRegistry[DefaultInstanceForType, fieldNumber];
if (extension == null) //unknown field
{
return(input.SkipField());
}
IFieldDescriptorLite field = extension.Descriptor;
// Unknown field or wrong wire type. Skip.
if (field == null)
{
return(input.SkipField());
}
WireFormat.WireType expectedType = field.IsPacked
? WireFormat.WireType.LengthDelimited
: WireFormat.GetWireType(field.FieldType);
if (wireType != expectedType)
{
expectedType = WireFormat.GetWireType(field.FieldType);
if (wireType == expectedType)
{
//Allowed as of 2.3, this is unpacked data for a packed array
}
else if (field.IsRepeated && wireType == WireFormat.WireType.LengthDelimited &&
(expectedType == WireFormat.WireType.Varint || expectedType == WireFormat.WireType.Fixed32 ||
expectedType == WireFormat.WireType.Fixed64))
{
//Allowed as of 2.3, this is packed data for an unpacked array
}
else
{
return(input.SkipField());
}
}
if (!field.IsRepeated && wireType != WireFormat.GetWireType(field.FieldType)) //invalid wire type
{
return(input.SkipField());
}
switch (field.FieldType)
{
case FieldType.Group:
case FieldType.Message:
{
if (!field.IsRepeated)
{
IMessageLite message = extensions[extension.Descriptor] as IMessageLite;
IBuilderLite subBuilder = (message ?? extension.MessageDefaultInstance).WeakToBuilder();
if (field.FieldType == FieldType.Group)
{
input.ReadGroup(field.FieldNumber, subBuilder, extensionRegistry);
}
else
{
input.ReadMessage(subBuilder, extensionRegistry);
}
extensions[field] = subBuilder.WeakBuild();
}
else
{
List <IMessageLite> list = new List <IMessageLite>();
if (field.FieldType == FieldType.Group)
{
input.ReadGroupArray(tag, fieldName, list, extension.MessageDefaultInstance,
extensionRegistry);
}
else
{
input.ReadMessageArray(tag, fieldName, list, extension.MessageDefaultInstance,
extensionRegistry);
}
foreach (IMessageLite m in list)
{
extensions.AddRepeatedField(field, m);
}
return(true);
}
break;
}
case FieldType.Enum:
{
if (!field.IsRepeated)
{
object unknown;
IEnumLite value = null;
if (input.ReadEnum(ref value, out unknown, field.EnumType))
{
extensions[field] = value;
}
}
else
{
ICollection <object> unknown;
List <IEnumLite> list = new List <IEnumLite>();
input.ReadEnumArray(tag, fieldName, list, out unknown, field.EnumType);
foreach (IEnumLite en in list)
{
extensions.AddRepeatedField(field, en);
}
}
break;
}
default:
{
if (!field.IsRepeated)
{
object value = null;
if (input.ReadPrimitiveField(field.FieldType, ref value))
{
extensions[field] = value;
}
}
else
{
List <object> list = new List <object>();
input.ReadPrimitiveArray(field.FieldType, tag, fieldName, list);
foreach (object oval in list)
{
extensions.AddRepeatedField(field, oval);
}
}
break;
}
}
return(true);
}
/// <summary>
/// Compares this descriptor with another one, ordering in "canonical" order
/// which simply means ascending order by field number. <paramref name="other"/>
/// must be a field of the same type, i.e. the <see cref="ContainingType"/> of
/// both fields must be the same.
/// </summary>
public int CompareTo(IFieldDescriptorLite other)
{
return(FieldNumber - other.FieldNumber);
}
/// <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;
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.";
throw new ArgumentException(message);
}
}
