/// <summary>
/// Creates a new ValueMember instance
/// </summary>
public ValueMember(
MemberMainSettingsValue memberSettings, ValueSerializationSettings valueSerializationSettings, MemberInfo member, Type parentType, RuntimeTypeModel model, bool isAccessHandledOutside = false, bool canHaveDefaultValue = true)
{
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
if (parentType == null)
{
throw new ArgumentNullException(nameof(parentType));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
MemberType = valueSerializationSettings.GetSettingsCopy(0).Basic.EffectiveType ?? Helpers.GetMemberType(member);
Member = member;
ParentType = parentType;
_model = model;
_canHaveDefaultValue = canHaveDefaultValue;
_main = memberSettings;
_isAccessHandledOutside = isAccessHandledOutside;
_vsByClient = valueSerializationSettings.Clone();
if (!canHaveDefaultValue && _vsByClient.DefaultValue != null)
{
throw new ArgumentException("Default value was already set but the member " + Name + " can't have a default value", nameof(valueSerializationSettings));
}
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
if (s.Input.IsEnumValueMember)
{
return(MemberHandlerResult.NotFound);
}
// always consider ProtoMember if not strict Aqla
// even if no [ProtoContract] was declared!
if (!s.Input.CanUse(AttributeType.ProtoBuf))
{
return(MemberHandlerResult.NotFound);
}
if (HasProtobufNetIgnore(s.Input.Attributes, model))
{
return(MemberHandlerResult.Ignore);
}
var attrib = AttributeMap.GetAttribute(s.Input.Attributes, "ProtoBuf.ProtoMemberAttribute");
if (attrib != null)
{
var r = _strategy.TryRead(attrib, s, member, model);
// we have ref!
main = s.MainValue;
return(r);
}
return(MemberHandlerResult.NotFound);
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
if (s.Input.IsEnumValueMember)
{
return(MemberHandlerResult.NotFound);
}
if (!s.Input.CanUse(AttributeType.Aqla))
{
return(MemberHandlerResult.NotFound);
}
if (HasAqlaIgnore(s.Input.Attributes, model))
{
return(MemberHandlerResult.Ignore);
}
MemberHandlerResult result = MemberHandlerResult.NotFound;
foreach (AttributeMap ppma in s.Input.PartialMembers)
{
object tmp;
if (!ppma.TryGet("MemberName", out tmp) || tmp as string != member.Name)
{
continue;
}
if (ppma.AttributeType.FullName == "AqlaSerializer.PartialNonSerializableMemberAttribute" && CheckAqlaModelId(ppma, model))
{
return(MemberHandlerResult.Ignore);
}
MemberHandlerResult newResult;
if (Helpers.IsAssignableFrom(model.MapType(typeof(SerializablePartialMemberAttribute)), ppma.AttributeType))
{
var attr = ppma.GetRuntimeAttribute <SerializablePartialMemberAttribute>(model);
main = attr.MemberSettings;
s.SerializationSettings.DefaultValue = attr.DefaultValue;
s.SerializationSettings.SetSettings(attr.LevelSettings, 0);
s.TagIsPinned = main.Tag > 0;
newResult = s.TagIsPinned ? MemberHandlerResult.Done : MemberHandlerResult.Partial;
}
else
{
newResult = MemberHandlerResult.NotFound;
}
if (newResult == MemberHandlerResult.Done)
{
return(MemberHandlerResult.Done);
}
if (newResult == MemberHandlerResult.Partial)
{
result = newResult;
}
}
return(result);
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
if (s.Input.IsEnumValueMember)
{
return(MemberHandlerResult.NotFound);
}
if (!s.Input.CanUse(AttributeType.ProtoBuf))
{
return(MemberHandlerResult.NotFound);
}
if (HasProtobufNetIgnore(s.Input.Attributes, model))
{
return(MemberHandlerResult.Ignore);
}
MemberHandlerResult result = MemberHandlerResult.NotFound;
foreach (AttributeMap ppma in s.Input.PartialMembers)
{
object tmp;
if (!ppma.TryGet("MemberName", out tmp) || tmp as string != member.Name)
{
continue;
}
if (ppma.AttributeType.FullName == "ProtoBuf.ProtoPartialIgnoreAttribute")
{
return(MemberHandlerResult.Ignore);
}
MemberHandlerResult newResult;
if (ppma.AttributeType.FullName == "ProtoBuf.ProtoPartialMemberAttribute")
{
newResult = _strategy.TryRead(ppma, s, member, model);
// we have ref!
main = s.MainValue;
}
else
{
newResult = MemberHandlerResult.NotFound;
}
if (newResult == MemberHandlerResult.Done)
{
return(MemberHandlerResult.Done);
}
if (newResult == MemberHandlerResult.Partial)
{
result = newResult;
}
}
return(result);
}
internal MetaType(RuntimeTypeModel model, Type type, MethodInfo factory)
{
this._factory = factory;
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
this._model = model;
IProtoSerializer coreSerializer = model.TryGetBasicTypeSerializer(type);
if (coreSerializer != null)
{
throw InbuiltType(type);
}
this.Type = type;
#if WINRT
this._typeInfo = type.GetTypeInfo();
#endif
MemberInfo[] members;
_tupleCtor = ResolveTupleConstructor(Type, out members);
if (_tupleCtor != null)
{
foreach (MemberInfo memberInfo in members)
{
var level = new MemberLevelSettingsValue();
var vs = new ValueSerializationSettings();
vs.SetSettings(new ValueSerializationSettings.LevelValue(level)
{
IsNotAssignable = true
}, 0);
vs.DefaultLevel = new ValueSerializationSettings.LevelValue(level.MakeDefaultNestedLevel());
var main = new MemberMainSettingsValue()
{
Name = memberInfo.Name
};
var vm = new ValueMember(main, vs, memberInfo, Type, model, canHaveDefaultValue: false, isAccessHandledOutside: true);
AddTupleField(vm);
}
}
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
if (s.Input.IsEnumValueMember)
{
return(MemberHandlerResult.NotFound);
}
// always consider SerializableMember if not strict ProtoBuf
// even if no [SerializableType] was declared!
if (!s.Input.CanUse(AttributeType.Aqla))
{
return(MemberHandlerResult.NotFound);
}
if (HasAqlaIgnore(s.Input.Attributes, model))
{
return(MemberHandlerResult.Ignore);
}
var memberRtAttr = AttributeMap.CreateRuntime <SerializableMemberAttribute>(model, member, true).FirstOrDefault(attr => CheckAqlaModelId(attr, model));
if (memberRtAttr == null)
{
return(MemberHandlerResult.NotFound);
}
SerializableMemberNestedAttribute[] nested = AttributeMap
.CreateRuntime <SerializableMemberNestedAttribute>(model, member, true)
.Where(a => a.ModelId == model.ModelId)
.ToArray();
main = memberRtAttr.MemberSettings;
s.SerializationSettings.SetSettings(memberRtAttr.LevelSettings, 0);
s.SerializationSettings.DefaultValue = memberRtAttr.DefaultValue;
foreach (var lvl in nested)
{
if (s.SerializationSettings.HasSettingsSpecified(lvl.Level))
{
throw new InvalidOperationException("Level " + lvl.Level + " settings for member " + member + " has been already initialized");
}
s.SerializationSettings.SetSettings(lvl.LevelSettings, lvl.Level);
}
s.TagIsPinned = memberRtAttr.Tag > 0;
return(s.TagIsPinned ? MemberHandlerResult.Done : MemberHandlerResult.Partial);
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
if (s.Input.IsEnumValueMember)
{
return(MemberHandlerResult.NotFound);
}
if (!s.Input.CanUse(AttributeType.SystemNonSerialized))
{
return(MemberHandlerResult.NotFound);
}
var attrib = AttributeMap.GetAttribute(s.Input.Attributes, "System.NonSerializedAttribute");
if (attrib != null)
{
return(MemberHandlerResult.Ignore);
}
return(MemberHandlerResult.NotFound);
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
if (s.Input.IsEnumValueMember)
{
return(MemberHandlerResult.NotFound);
}
if (!s.Input.CanUse(AttributeType.DataContract))
{
return(MemberHandlerResult.NotFound);
}
if (!s.Input.HasFamily(MetaType.AttributeFamily.DataContractSerialier))
{
return(MemberHandlerResult.NotFound);
}
var attrib = AttributeMap.GetAttribute(s.Input.Attributes, "System.Runtime.Serialization.DataMemberAttribute");
if (attrib == null)
{
return(MemberHandlerResult.NotFound);
}
if (main.Tag <= 0)
{
attrib.TryGetNotDefault("Order", ref main.Tag);
}
if (string.IsNullOrEmpty(main.Name))
{
attrib.TryGetNotEmpty("Name", ref main.Name);
}
if (!main.IsRequiredInSchema)
{
attrib.TryGetNotDefault("IsRequired", ref main.IsRequiredInSchema);
}
bool done = main.Tag >= s.MinAcceptFieldNumber;
if (done)
{
main.Tag += s.Input.DataMemberOffset; // dataMemberOffset only applies to DCS flags, to allow us to "bump" WCF by a notch
return(MemberHandlerResult.Done);
}
return(MemberHandlerResult.Partial);
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
if (s.Input.IsEnumValueMember ||
s.MainValue.Tag > 0 ||
s.TagIsPinned ||
s.SerializationSettings.MaxSpecifiedNestedLevel != -1 ||
s.Input.Family != MetaType.AttributeFamily.ProtoBuf ||
!s.Input.IsForced)
{
return(MemberHandlerResult.NotFound);
}
var l = s.SerializationSettings.GetSettingsCopy(0);
l.Basic.DefaultsMode = MemberDefaultsMode.Legacy;
_strategy.SetLegacyFormat(ref l.Basic, member, model);
s.SerializationSettings.SetSettings(l, 0);
return(MemberHandlerResult.Partial);
}
public virtual MappedMember Map(MemberArgsValue args)
{
if (args.Member == null || (args.Family == MetaType.AttributeFamily.None && !args.IsEnumValueMember))
{
return(null);
}
if (args.Member.Name == "Values")
{
}
if (args.IsEnumValueMember)
{
args.IsForced = true;
}
var state = new MemberState(args);
MemberMainSettingsValue m = state.MainValue;
m.Tag = int.MinValue;
state.MainValue = m;
if (ProcessHandlers(state) == MemberHandlerResult.Ignore || (state.MainValue.Tag < state.MinAcceptFieldNumber && !state.Input.IsForced))
{
return(null);
}
if (!state.SerializationSettings.HasSettingsSpecified(0))
{
state.SerializationSettings.SetSettings(state.SerializationSettings.GetSettingsCopy(0), 0);
}
if (state.SerializationSettings.DefaultLevel == null)
{
state.SerializationSettings.DefaultLevel = new ValueSerializationSettings.LevelValue(state.SerializationSettings.GetSettingsCopy(0).Basic.MakeDefaultNestedLevel());
}
return(new MappedMember(state)
{
ForcedTag = state.Input.IsForced || state.Input.InferTagByName
});
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
if (s.Input.IsEnumValueMember)
{
return(MemberHandlerResult.NotFound);
}
if (!s.Input.CanUse(AttributeType.Xml))
{
return(MemberHandlerResult.NotFound);
}
if (AttributeMap.GetAttribute(s.Input.Attributes, "System.Xml.Serialization.XmlIgnoreAttribute") != null)
{
return(MemberHandlerResult.Ignore);
}
if (!s.Input.HasFamily(MetaType.AttributeFamily.XmlSerializer))
{
return(MemberHandlerResult.NotFound);
}
var attrib = AttributeMap.GetAttribute(s.Input.Attributes, "System.Xml.Serialization.XmlElementAttribute")
?? AttributeMap.GetAttribute(s.Input.Attributes, "System.Xml.Serialization.XmlArrayAttribute");
if (attrib == null)
{
return(MemberHandlerResult.NotFound);
}
if (main.Tag <= 0)
{
attrib.TryGetNotDefault("Order", ref main.Tag);
}
if (string.IsNullOrEmpty(main.Name))
{
attrib.TryGetNotEmpty("ElementName", ref main.Name);
}
return(main.Tag >= s.MinAcceptFieldNumber ? MemberHandlerResult.Done : MemberHandlerResult.Partial);
}
protected abstract MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model);
private ValueMember AddField(int fieldNumber, string memberName, Type itemType, Type defaultType, object defaultValue)
{
if (Type.IsArray)
{
throw new InvalidOperationException("Can't add fields to array type");
}
MemberInfo mi = null;
#if WINRT
mi = Helpers.IsEnum(Type) ? Type.GetTypeInfo().GetDeclaredField(memberName) : Helpers.GetInstanceMember(Type.GetTypeInfo(), memberName);
#else
MemberInfo[] members = Type.GetMember(memberName, Helpers.IsEnum(Type) ? BindingFlags.Static | BindingFlags.Public : BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (members != null && members.Length == 1)
{
mi = members[0];
}
#endif
if (mi == null)
{
throw new ArgumentException("Unable to determine member: " + memberName, nameof(memberName));
}
Type miType;
#if WINRT || PORTABLE
PropertyInfo pi = mi as PropertyInfo;
if (pi == null)
{
FieldInfo fi = mi as FieldInfo;
if (fi == null)
{
throw new NotSupportedException(mi.GetType().Name);
}
else
{
miType = fi.FieldType;
}
}
else
{
miType = pi.PropertyType;
}
#else
switch (mi.MemberType)
{
case MemberTypes.Field:
miType = ((FieldInfo)mi).FieldType; break;
case MemberTypes.Property:
miType = ((PropertyInfo)mi).PropertyType; break;
default:
throw new NotSupportedException(mi.MemberType.ToString());
}
#endif
// we can't check IgnoreListHandling (because of recursion when adding type) but we don't need to
// it will be checked in ValueSerializedBuilder.CompleteLevel stage
ResolveListTypes(_model, miType, ref itemType, ref defaultType);
var serializationSettings = new ValueSerializationSettings();
var memberSettings = new MemberMainSettingsValue {
Tag = fieldNumber
};
var level0 = serializationSettings.GetSettingsCopy(0).Basic;
level0.Collection.ConcreteType = defaultType;
level0.Collection.ItemType = itemType;
serializationSettings.SetSettings(level0, 0);
serializationSettings.DefaultValue = defaultValue;
var def = serializationSettings.DefaultLevel.GetValueOrDefault();
def.Basic = level0.MakeDefaultNestedLevel();
serializationSettings.DefaultLevel = def;
ValueMember newField = new ValueMember(memberSettings, serializationSettings, mi, Type, _model);
Add(newField);
return(newField);
}
protected override MemberHandlerResult TryMap(MemberState s, ref MemberMainSettingsValue main, MemberInfo member, RuntimeTypeModel model)
{
// always consider SerializableMember if not strict ProtoBuf
if (!s.Input.IsEnumValueMember)
{
return(MemberHandlerResult.NotFound);
}
if (main.Tag <= 0)
{
try
{
main.Tag = Helpers.GetEnumMemberUnderlyingValue(member);
}
catch (OverflowException)
{
// should use EnumPassthrough for this value
return(MemberHandlerResult.NotFound);
}
}
if (!s.Input.CanUse(RequiredAttributeType))
{
return(MemberHandlerResult.Partial);
}
if (HasIgnore(s))
{
return(MemberHandlerResult.Ignore);
}
AttributeMap attrib = GetAttribute(s);
if (attrib == null)
{
return(MemberHandlerResult.Partial);
}
if (string.IsNullOrEmpty(main.Name))
{
attrib.TryGetNotEmpty("Name", ref main.Name);
}
#if !FEAT_IKVM // IKVM can't access HasValue, but conveniently, Value will only be returned if set via ctor or property
if ((bool)Helpers.GetInstanceMethod(
attrib.AttributeType
#if WINRT
.GetTypeInfo()
#endif
,
"HasValue").Invoke(attrib.Target, null))
#endif
{
object tmp;
if (attrib.TryGet("Value", out tmp))
{
main.Tag = (int)tmp;
}
}
s.TagIsPinned = main.Tag > 0;
return(s.TagIsPinned ? MemberHandlerResult.Done : MemberHandlerResult.Partial);
}
