private void Add(ExtensionInfo extension)
{
if (readOnly)
{
throw new InvalidOperationException("Cannot add entries to a read-only extension registry");
}
if (!extension.Descriptor.IsExtension)
{
throw new ArgumentException("ExtensionRegistry.add() was given a FieldDescriptor for a "
+ "regular (non-extension) field.");
}
IGeneratedExtensionLite liteExtension = extension;
Add(liteExtension);
FieldDescriptor field = extension.Descriptor;
if (field.ContainingType.Options.MessageSetWireFormat &&
field.FieldType == FieldType.Message &&
field.IsOptional &&
field.ExtensionScope == field.MessageType)
{
// This is an extension of a MessageSet type defined within the extension
// type's own scope. For backwards-compatibility, allow it to be looked
// up by type name.
Dictionary <string, IGeneratedExtensionLite> map;
if (extensionsByName.TryGetValue(liteExtension.ContainingType, out map))
{
map[field.MessageType.FullName] = extension;
}
}
}
/// <summary>
/// 注册扩展
/// </summary>
/// <param name="extension">protobuf扩展消息</param>
public void RegisterExtension(IGeneratedExtensionLite extension)
{
if (_extensionRegistry == null)
{
throw new Exception("ExtensionRegistry must using InitProtobufDecoder method to initialize. ");
}
_extensionRegistry.Add(extension);
}
/// <summary>
/// Add an extension from a generated file to the registry.
/// </summary>
public void Add(IGeneratedExtensionLite extension)
{
if (readOnly)
{
throw new InvalidOperationException("Cannot add entries to a read-only extension registry");
}
throw new Exception("Extension is disabled.");
}
/// <summary>
/// Add an extension from a generated file to the registry.
/// </summary>
public void Add(IGeneratedExtensionLite extension)
{
if (readOnly)
{
throw new InvalidOperationException("Cannot add entries to a read-only extension registry");
}
extensionsByNumber.Add(
new ExtensionIntPair(extension.ContainingType, extension.Number),
extension);
}
private IGeneratedExtensionLite FindExtensionByName(object forwhat, string fieldName)
{
IGeneratedExtensionLite extension = null;
Dictionary <string, IGeneratedExtensionLite> map;
if (extensionsByName.TryGetValue(forwhat, out map) && map.TryGetValue(fieldName, out extension))
{
return(extension);
}
return(null);
}
private IGeneratedExtensionLite FindExtensionByName(object forwhat, string fieldName)
{
IGeneratedExtensionLite result = null;
Dictionary <string, IGeneratedExtensionLite> dictionary;
if (this.extensionsByName.TryGetValue(forwhat, out dictionary) && dictionary.TryGetValue(fieldName, out result))
{
return(result);
}
return(null);
}
public void Add(IGeneratedExtensionLite extension)
{
if (this.readOnly)
{
throw new InvalidOperationException("Cannot add entries to a read-only extension registry");
}
this.extensionsByNumber.Add(new ExtensionRegistry.ExtensionIntPair(extension.ContainingType, extension.Number), extension);
Dictionary <string, IGeneratedExtensionLite> dictionary;
if (!this.extensionsByName.TryGetValue(extension.ContainingType, out dictionary))
{
this.extensionsByName.Add(extension.ContainingType, dictionary = new Dictionary <string, IGeneratedExtensionLite>());
}
dictionary[extension.Descriptor.Name] = extension;
dictionary[extension.Descriptor.FullName] = extension;
}
/// <summary>
/// Add an extension from a generated file to the registry.
/// </summary>
public void Add(IGeneratedExtensionLite extension)
{
if (readOnly)
{
throw new InvalidOperationException("Cannot add entries to a read-only extension registry");
}
extensionsByNumber.Add(new ExtensionIntPair(extension.ContainingType, extension.Number), extension);
Dictionary <string, IGeneratedExtensionLite> map;
if (!extensionsByName.TryGetValue(extension.ContainingType, out map))
{
extensionsByName.Add(extension.ContainingType, map = new Dictionary <string, IGeneratedExtensionLite>());
}
map[extension.Descriptor.Name] = extension;
map[extension.Descriptor.FullName] = extension;
}
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);
}
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);
}
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);
}
