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); } }