static Dictionary <string, JsonMemberSetter> LoadMemberDeserializationSettings(JsonMemberSetter d, IReflectionController controller)
{
var member = d.Member.MemberInfo;
var sd = new Dictionary <string, JsonMemberSetter> ();
d.Converter = controller.GetMemberConverter(member);
d.ItemConverter = controller.GetMemberItemConverter(member);
var tn = controller.GetSerializedNames(member);
if (tn == null)
{
sd.Add(d.MemberName, d);
return(sd);
}
sd.Add(String.IsNullOrEmpty(tn.DefaultName) ? d.MemberName : tn.DefaultName, d);
// polymorphic deserialization
foreach (var item in tn)
{
var st = item.Key;
var sn = item.Value;
var dt = new JsonMemberSetter(new MemberCache(st, d.MemberName, d.Member));
dt.Converter = d.Converter;
dt.ItemConverter = d.ItemConverter;
sd.Add(sn, dt);
}
return(sd);
}
static Dictionary <string, JsonMemberSetter> GetSetters(Type type, MemberCache[] members, IReflectionController controller)
{
var sd = new Dictionary <string, JsonMemberSetter> (StringComparer.OrdinalIgnoreCase);
foreach (var p in members)
{
var d = new JsonMemberSetter(p);
var dp = GetDeserializingProperties(d, controller);
if (dp == null)
{
continue;
}
foreach (var item in dp)
{
AddPropertyInfo(sd, item.Key, item.Value);
}
}
return(sd);
}
static Dictionary <string, JsonMemberSetter> GetDeserializingProperties(JsonMemberSetter d, IReflectionController controller)
{
var member = d.Member.MemberInfo;
if (controller == null)
{
return(new Dictionary <string, JsonMemberSetter> ()
{
{ d.MemberName, d }
});
}
if (controller.IsMemberDeserializable(member, d.Member) == false)
{
d.CanWrite = false;
if (d.Member.MemberTypeReflection.AppendItem == null || member is PropertyInfo == false)
{
return(null);
}
}
return(LoadMemberDeserializationSettings(d, controller));
}
void ConvertProperty(object o, JsonMemberSetter pi, JsonItem ji)
{
var pc = pi.Converter ?? pi.Member.MemberTypeReflection.Converter;
var rt = pc.GetReversiveType(ji);
var xv = ji._Value;
if (xv != null && rt != null && pi.Member.MemberType.Equals(xv.GetType()) == false)
{
var c = _manager.GetReflectionCache(rt);
var jt = Reflection.GetJsonDataType(rt);
if (jt != JsonDataType.Undefined)
{
xv = c.DeserializeMethod(this, xv, c);
}
else if (xv is JsonDict)
{
xv = CreateObject((JsonDict)xv, c, pi.Member.Getter(o));
}
}
ji._Value = xv;
pc.DeserializationConvert(ji);
}
static bool ConvertItems(JsonMemberSetter pi, JsonItem ji)
{
var vl = ji._Value as IList;
var l = vl.Count;
var converted = false;
var ai = new JsonItem(ji._Name, null, false);
for (int i = 0; i < l; i++)
{
var vi = vl[i];
ai._Value = vi;
pi.ItemConverter.DeserializationConvert(ai);
if (ReferenceEquals(vi, ai._Value) == false)
{
vl[i] = ai._Value;
converted = true;
}
}
if (converted)
{
if (pi.Member.JsonDataType == JsonDataType.Array)
{
ji._Value = Array.CreateInstance(pi.Member.ElementType, l);
vl.CopyTo((Array)ji._Value, 0);
}
else if (pi.Member.JsonDataType == JsonDataType.List)
{
ji._Value = pi.Member.MemberTypeReflection.Instantiate();
var gl = ji._Value as IList;
for (int i = 0; i < l; i++)
{
gl.Add(vl[i]);
}
}
}
return(converted);
}
private static void OverrideJsonPropertyInfo(Dictionary <string, JsonMemberSetter> s, MemberOverride mo, JsonMemberSetter mp)
{
foreach (var item in s)
{
mp = item.Value;
if (mp.MemberName == mo.MemberName)
{
if (mo.OverrideConverter)
{
mp.Converter = mo.Converter;
}
if (mo.OverrideItemConverter)
{
mp.ItemConverter = mo.ItemConverter;
}
if (mo.Deserializable.HasValue)
{
mp.CanWrite = mo.Deserializable == true;
}
}
}
}
void OverridePropInfo(Type type, Dictionary <string, JsonMemberSetter> s, MemberOverride mo, JsonMemberGetter g)
{
JsonMemberSetter mp = null;
if (mo.OverrideTypedNames)
{
// remove previous polymorphic deserialization info
var rt = new List <string> ();
foreach (var item in s)
{
if (item.Value.MemberName == mo.MemberName)
{
if (Equals(item.Value.Member.MemberType, g.Member.MemberType) == false)
{
rt.Add(item.Key);
}
// find an item with the same member name
mp = item.Value;
}
}
if (mp == null)
{
throw new MissingMemberException(g.Member.MemberType.FullName, mo.MemberName);
}
foreach (var item in rt)
{
s.Remove(item);
}
// add new polymorphic deserialization info
if (mo.TypedNames.Count > 0)
{
foreach (var item in mo.TypedNames)
{
var t = item.Key;
if (g.Member.MemberType.IsAssignableFrom(t) == false)
{
throw new InvalidCastException("The type (" + t.FullName + ") does not derive from the member type (" + g.Member.MemberType.FullName + ")");
}
var n = item.Value;
var p = new JsonMemberSetter(new MemberCache(t, g.MemberName, mp.Member)
{
MemberTypeReflection = GetReflectionCache(t)
});
JsonMemberSetter tp;
if (s.TryGetValue(n, out tp) && Equals(tp.Member.MemberType, g.Member.MemberType))
{
s[n] = p;
}
else
{
s.Add(n, p);
}
}
}
}
else if (mo.OverrideSerializedName && g.SerializedName != mo.SerializedName)
{
if (s.TryGetValue(g.SerializedName, out mp))
{
s.Remove(g.SerializedName);
s.Add(mo.SerializedName, mp);
}
}
OverrideJsonPropertyInfo(s, mo, mp);
if (mo.OverrideSerializedName)
{
g.SerializedName = mo.SerializedName;
}
}
static void AddPropertyInfo(Dictionary <string, JsonMemberSetter> sd, string name, JsonMemberSetter item)
{
if (String.IsNullOrEmpty(name))
{
throw new JsonSerializationException(item.MemberName + " should not be serialized to an empty name");
}
if (sd.ContainsKey(name))
{
throw new JsonSerializationException(name + " has been used by another member");
}
sd.Add(name, item);
}
/// <summary>
/// Overrides reflection result with <see cref="TypeOverride"/> for the specific type and optionally purge existing overrides.
/// </summary>
/// <param name="type">The type to be overridden.</param>
/// <param name="overrideInfo">The override info of the type.</param>
/// <param name="purgeExisting">If this value is true, the reflection engine will reflect the type again and apply the <paramref name="overrideInfo"/>, otherwise, <paramref name="overrideInfo"/> is merged into the existing reflection cache.</param>
/// <remarks>
/// <para>At this moment, the override only affects the registered type.</para>
/// <para>If a class has its subclasses, the override will not be applied to its subclasses.</para>
/// </remarks>
/// <exception cref="ArgumentNullException">The parameter <paramref name="type"/> or <paramref name="overrideInfo"/> is null.</exception>
/// <exception cref="MissingMemberException">No member is found for a <see cref="MemberOverride"/> in <paramref name="overrideInfo"/>.</exception>
public void Override(Type type, TypeOverride overrideInfo, bool purgeExisting)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (overrideInfo == null)
{
throw new ArgumentNullException("overrideInfo");
}
var c = GetReflectionCache(type);
if (purgeExisting)
{
ControlTypeSerializationSettings(type, c);
}
if (overrideInfo.OverrideInterceptor)
{
c.Interceptor = overrideInfo.Interceptor;
}
if (overrideInfo.OverrideConverter)
{
c.Converter = overrideInfo.Converter;
}
if (overrideInfo.OverrideContainerName)
{
c.CollectionName = overrideInfo.CollectionContainer;
c.DeserializeMethod = overrideInfo.CollectionContainer == null
? JsonDeserializer.GetReadJsonMethod(type)
: new CompoundDeserializer(c.CollectionName, c.DeserializeMethod).Deserialize;
}
if (overrideInfo.Deserializable.HasValue)
{
c.AlwaysDeserializable = overrideInfo.Deserializable == true;
}
if (overrideInfo._MemberOverrides == null || overrideInfo._MemberOverrides.Count == 0)
{
return;
}
var s = c.Setters;
// add properties ignored by _controller in GetProperties method
foreach (var ov in overrideInfo._MemberOverrides)
{
if (ov.Deserializable != true)
{
continue;
}
var p = c.FindProperties(ov.MemberName);
if (p.Count == 0)
{
var m = c.FindMemberCache(ov.MemberName);
if (m == null)
{
throw new MissingMemberException(c.TypeName, ov.MemberName);
}
var pi = new JsonMemberSetter(m);
// TODO: load serialization control settings
var ds = LoadMemberDeserializationSettings(pi, _controller);
if (ds != null)
{
foreach (var item in ds)
{
item.Value.Member.MemberTypeReflection = GetReflectionCache(item.Value.Member.MemberType);
AddPropertyInfo(c.Setters, item.Key, item.Value);
}
}
}
}
foreach (var ov in overrideInfo._MemberOverrides)
{
var g = c.FindGetters(ov.MemberName);
if (g == null)
{
throw new MissingMemberException(type.FullName, ov.MemberName);
}
OverrideGetters(g, ov);
OverridePropInfo(type, s, ov, g);
}
}
