internal Builder(MessageDescriptor type)
{
this.type = type;
this.fields = FieldSet.CreateInstance();
this.unknownFields = UnknownFieldSet.DefaultInstance;
this.oneofCase = new FieldDescriptor[type.Proto.OneofDeclCount];
}
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.");
}
FieldSet.VerifyType(field, value);
object obj;
if (!this.fields.TryGetValue(field, out obj))
{
throw new ArgumentOutOfRangeException();
}
((IList <object>)obj)[index] = value;
}
}
/// <summary>
/// Creates a DynamicMessage with the given FieldSet.
/// </summary>
/// <param name="type"></param>
/// <param name="fields"></param>
/// <param name="unknownFields"></param>
private DynamicMessage(MessageDescriptor type, FieldSet fields,
FieldDescriptor[] oneofCase, UnknownFieldSet unknownFields)
{
this.type = type;
this.fields = fields;
this.oneofCase = oneofCase;
this.unknownFields = unknownFields;
}
internal ExtensionWriter(ExtendableMessageLite <TMessage, TBuilder> message)
{
extensions = message.extensions;
iterator = message.extensions.GetEnumerator();
if (iterator.MoveNext())
{
next = iterator.Current;
}
}
public override DynamicMessage BuildPartial()
{
fields.MakeImmutable();
DynamicMessage result = new DynamicMessage(type, fields, unknownFields);
fields = null;
unknownFields = null;
return(result);
}
internal ExtensionWriter(ExtendableMessageLite <TMessage, TBuilder> message)
{
this.extensions = message.extensions;
this.iterator = message.extensions.GetEnumerator();
if (this.iterator.MoveNext())
{
this.next = new KeyValuePair <IFieldDescriptorLite, object>?(this.iterator.Current);
}
}
public void MergeFrom(FieldSet other)
{
using (IEnumerator <KeyValuePair <IFieldDescriptorLite, object> > enumerator = other.fields.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <IFieldDescriptorLite, object> current = enumerator.Current;
this.MergeField(current.Key, current.Value);
}
}
}
public override DynamicMessage BuildPartial()
{
if (fields == null)
{
throw new InvalidOperationException("Build() has already been called on this Builder.");
}
fields.MakeImmutable();
DynamicMessage result = new DynamicMessage(type, fields, unknownFields);
fields = null;
unknownFields = null;
return(result);
}
/// <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);
}
}
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;
}
}
protected override bool ParseUnknownField(CodedInputStream input,
ExtensionRegistry extensionRegistry, uint tag)
{
FieldSet extensions = MessageBeingBuilt.Extensions;
WireFormat.WireType wireType = WireFormat.GetTagWireType(tag);
int fieldNumber = WireFormat.GetTagFieldNumber(tag);
IGeneratedExtensionLite extension = extensionRegistry[DefaultInstanceForType, fieldNumber];
bool unknown = false;
bool packed = false;
if (extension == null)
{
unknown = true; // Unknown field.
}
else if (wireType == FieldMappingAttribute.WireTypeFromFieldType(extension.Descriptor.FieldType, false /* isPacked */))
{
packed = false; // Normal, unpacked value.
}
else if (extension.Descriptor.IsRepeated &&
//?? just returns true ?? extension.Descriptor.type.isPackable() &&
wireType == FieldMappingAttribute.WireTypeFromFieldType(extension.Descriptor.FieldType, true /* isPacked */))
{
packed = true; // Packed value.
}
else
{
unknown = true; // Wrong wire type.
}
if (unknown) // Unknown field or wrong wire type. Skip.
{
return(input.SkipField(tag));
}
if (packed)
{
int length = (int)Math.Min(int.MaxValue, input.ReadRawVarint32());
int limit = input.PushLimit(length);
if (extension.Descriptor.FieldType == FieldType.Enum)
{
while (!input.ReachedLimit)
{
int rawValue = input.ReadEnum();
Object value =
extension.Descriptor.EnumType.FindValueByNumber(rawValue);
if (value == null)
{
// If the number isn't recognized as a valid value for this
// enum, drop it (don't even add it to unknownFields).
return(true);
}
extensions.AddRepeatedField(extension.Descriptor, value);
}
}
else
{
while (!input.ReachedLimit)
{
Object value = input.ReadPrimitiveField(extension.Descriptor.FieldType);
extensions.AddRepeatedField(extension.Descriptor, value);
}
}
input.PopLimit(limit);
}
else
{
Object value;
switch (extension.Descriptor.MappedType)
{
case MappedType.Message: {
IBuilderLite subBuilder = null;
if (!extension.Descriptor.IsRepeated)
{
IMessageLite existingValue = extensions[extension.Descriptor] as IMessageLite;
if (existingValue != null)
{
subBuilder = existingValue.WeakToBuilder();
}
}
if (subBuilder == null)
{
subBuilder = extension.MessageDefaultInstance.WeakCreateBuilderForType();
}
if (extension.Descriptor.FieldType == FieldType.Group)
{
input.ReadGroup(extension.Number, subBuilder, extensionRegistry);
}
else
{
input.ReadMessage(subBuilder, extensionRegistry);
}
value = subBuilder.WeakBuild();
break;
}
case MappedType.Enum:
int rawValue = input.ReadEnum();
value = extension.Descriptor.EnumType.FindValueByNumber(rawValue);
// If the number isn't recognized as a valid value for this enum,
// drop it.
if (value == null)
{
return(true);
}
break;
default:
value = input.ReadPrimitiveField(extension.Descriptor.FieldType);
break;
}
if (extension.Descriptor.IsRepeated)
{
extensions.AddRepeatedField(extension.Descriptor, value);
}
else
{
extensions[extension.Descriptor] = value;
}
}
return(true);
}
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>
/// Creates a DynamicMessage with the given FieldSet.
/// </summary>
/// <param name="type"></param>
/// <param name="fields"></param>
/// <param name="unknownFields"></param>
private DynamicMessage(MessageDescriptor type, FieldSet fields, UnknownFieldSet unknownFields)
{
this.type = type;
this.fields = fields;
this.unknownFields = unknownFields;
}
internal Builder(MessageDescriptor type)
{
this.type = type;
this.fields = FieldSet.CreateInstance();
this.unknownFields = UnknownFieldSet.DefaultInstance;
}
/// <summary>
/// Like <see cref="MergeFrom(IMessage)"/>, but merges from another <c>FieldSet</c>.
/// </summary>
public void MergeFrom(FieldSet other)
{
MergeFields(other.fields);
}
/// <summary>
/// Like <see cref="MergeFrom(IMessage)"/>, but merges from another <c>FieldSet</c>.
/// </summary>
public void MergeFrom(FieldSet other)
{
MergeFields(other.fields);
}
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);
}