private void DeserializeAndApplyChangeValue(Change change, DeserializingContext context) { var path = change.Path.Split('/'); if (path[1].Length == 0) { RootChange(change, context); return; } var handler = _rootHandler; for (int q = 1; q < path.Length - 1; q++) { if (handler.TryGetValue(path[q], out var obj)) { handler = ((IEntityHandlerProvider)obj).GetHandler(); } else { change.Ignored = true; DeserializeIgnoredValue(context, change, "Path not reachable"); Log.Warning($"Change '{change.Path}:{change.Type}' is ignored"); return; } } change.Key = path[path.Length - 1]; handler.DeserializeAndApplyChangeValue(change, context); change.Handler = handler; }
private Change DeserializeAndApplyChange(DeserializingContext context) { var result = new Change(); while (context.Reader.Read() && context.Reader.TokenType != JsonToken.EndObject) { if (!(context.Reader.Value is string)) { Log.Error($"Unexpected serialization '{context.Reader.Value?.GetType()}=context.Reader.Value'"); } string property = (string)context.Reader.Value; context.Reader.Read(); switch (property) { case "op": result.Type = (ChangeType)Enum.Parse(typeof(ChangeType), (string)context.Reader.Value, true); break; case "path": result.Path = (string)context.Reader.Value; if (result.Type == ChangeType.Remove) { DeserializeAndApplyChangeValue(result, context); } break; case "value": DeserializeAndApplyChangeValue(result, context); break; } } return(result); }
private void RootChange(Change change, DeserializingContext context) { _root = DeserializeAndApplyReplace(null, "", _root, _configurations[_rootHandler.ProxyType], change, context); _rootHandler = ((IEntityHandlerProvider)_root).GetHandler(); RootChanged?.Invoke(this, EventArgs.Empty); }
public List <Change> ApplyChanges(ModelClient sourceClient, string changesData) { lock (this) { var otherClients = _clients.Where(s => s != sourceClient).ToList(); List <Change> changes = new List <Change>(); using (var context = DeserializingContext.FromString(changesData, _serializer)) { context.Reader.Read(); while (context.Reader.Read() && context.Reader.TokenType != JsonToken.EndArray) { var change = DeserializeAndApplyChange(context); if (!change.Ignored) // ignored change due to unsync { Subscriptions.NotifyChange(sourceClient, change.Type, change.Handler, change.Key, change.Value); if (change.OldValue != null) { DetachOldItem(sourceClient, change.OldValue); } if (change.Value != null) { AttachNewItem(sourceClient, change.Value); } otherClients.ForEach(client => AddChange(client, change.Type, change.Path, change.Handler, change.Key, change.Value)); changes.Add(change); } } } return(changes); } }
public object Deserialize(Type type, string str) { using (var context = DeserializingContext.FromString(str, _serializer)) { context.Reader.Read(); return(DeserializeMemeberValue(_configurations[type], null, null, context)); } }
public static DeserializingContext FromString(string content, JsonSerializer serializer) { var result = new DeserializingContext(); result._textReader = new StringReader(content); result.Reader = new JsonTextReader(result._textReader); result.Serializer = serializer; return result; }
public void Deserialize(DeserializingContext context) { while (context.Reader.Read() && context.Reader.TokenType != Newtonsoft.Json.JsonToken.EndObject) { string key = (string)context.Reader.Value; context.Reader.Read(); var o = _manager.DeserializeMemeberValue(_typeConfig.ValueType, this, key, context); _inner.Add(key, o); } }
public void DeserializeIgnoredValue(DeserializingContext context, Change change, string reason) { var res = context.Serializer.Deserialize(context.Reader); if (change != null) { Log.Warning($"Deserializing ignored value {change.Path}={res} ({change.Type}), reason:{reason}"); } else { Log.Warning($"Deserializing ignored value, reason:{reason}"); } }
public void DeserializeAndApplyChangeValue(Change change, DeserializingContext context) { var property = change.Key; if (_values.TryGetValue(property, out var value)) { switch (change.Type) { case ChangeType.Add: _manager.DeserializeIgnoredValue(context, change, "Unsync on add"); break; case ChangeType.Remove: _manager.DeserializeAndApplyRemove(value, change); _values.Remove(property); _propertyChangedHandler?.Invoke(Proxy, new PropertyChangedEventArgs(property)); break; case ChangeType.Replace: _values[property] = _manager.DeserializeAndApplyReplace(this, property, value, _typeConfig.Members[property].TypeConfiguration, change, context); _propertyChangedHandler?.Invoke(Proxy, new PropertyChangedEventArgs(property)); break; } } else { if (_typeConfig.Members.TryGetValue(property, out var memConfig)) { if (change.Type == ChangeType.Add) { _values.Add(property, _manager.DeserializeAndApplyAdd(this, property, memConfig.TypeConfiguration, change, context)); _propertyChangedHandler?.Invoke(Proxy, new PropertyChangedEventArgs(property)); } else { if (change.Type == ChangeType.Replace) { _manager.DeserializeIgnoredValue(context, change, "Unsync on replace"); } } } else { if (change.Type != ChangeType.Remove) { _manager.DeserializeIgnoredValue(context, change, "Unknown property"); } } } }
public void Deserialize(DeserializingContext context) { while (context.Reader.Read() && context.Reader.TokenType != Newtonsoft.Json.JsonToken.EndObject) { string property = (string)context.Reader.Value; context.Reader.Read(); if (_typeConfig.Members.TryGetValue(property, out var memberConfig)) { _values[property] = _manager.DeserializeMemeberValue(memberConfig.TypeConfiguration, this, property, context); } else { _manager.DeserializeIgnoredValue(context, null, $"Unsync on Deserialize '{property}'"); } } }
public void DeserializeAndApplyChangeValue(Change change, DeserializingContext context) { var property = change.Key; if (_inner.TryGetValue(property, out var oldValue)) { switch (change.Type) { case ChangeType.Add: _manager.DeserializeIgnoredValue(context, change, "Unsync on dict add"); break; case ChangeType.Remove: _manager.DeserializeAndApplyRemove(oldValue, change); InternalRemove(property, oldValue); break; case ChangeType.Replace: InternalReplace(property, oldValue, _manager.DeserializeAndApplyReplace(this, property, oldValue, _typeConfig.ValueType, change, context)); break; } } else { if (change.Type == ChangeType.Add) { InternalAdd(property, _manager.DeserializeAndApplyAdd(this, property, _typeConfig.ValueType, change, context)); } else { if (change.Type == ChangeType.Replace) { _manager.DeserializeIgnoredValue(context, change, "Unsync on dict replace"); } } } }
public object DeserializeAndApplyReplace(IEntityHandler parent, string key, object oldValue, TypeConfiguration typeConfig, Change change, DeserializingContext context) { change.OldValue = oldValue; SetObjectParent(oldValue, null, null); change.Value = DeserializeMemeberValue(typeConfig, parent, key, context); return(change.Value); }
public object DeserializeAndApplyAdd(IEntityHandler parent, string key, TypeConfiguration typeConfig, Change change, DeserializingContext context) { change.Value = DeserializeMemeberValue(typeConfig, parent, key, context); return(change.Value); }
public object DeserializeMemeberValue(TypeConfiguration typeConfig, IEntityHandler parent, string property, DeserializingContext context) { if (typeConfig.IsExternalType) { return(context.Serializer.Deserialize(context.Reader, typeConfig.Type)); } else if (typeConfig.Creator != null) { var result = typeConfig.Creator(parent, property); var handler = (IEntityHandlerProvider)result; handler.GetHandler().Deserialize(context); return(result); } else { throw new Exception(); } }