public override void ApplySnapshot(INode node, IMap <string, S> snapshot) { StateTreeUtils.Typecheck(this, snapshot); var map = GetValue(node); var keysmap = map.Keys.Aggregate(new Map <string, bool>(), (acc, key) => { acc[key] = false; return(acc); }); foreach (var pair in snapshot) { map[pair.Key] = SubType.Create(pair.Value, Node.Environment); keysmap[pair.Key] = true; } foreach (var pair in keysmap) { if (!pair.Value) { map.Remove(pair.Key); } } }
public static INode ValueAsNode <Sx, Tx>(IType <Sx, Tx> type, ObjectNode parent, string subpath, object value, INode oldNode) { StateTreeUtils.Typecheck(type, value); // the new value has a MST node if (value.IsStateTreeNode()) { var node = value.GetStateTreeNode(); node.AssertAlive(); // the node lives here if (node.Parent != null && node.Parent == parent) { node.SetParent(parent, subpath); if (oldNode != null && oldNode != node) { oldNode.Dispose(); } return(node); } } // there is old node and new one is a value/snapshot if (oldNode != null) { var node = type.Reconcile(oldNode, value); node.SetParent(parent, subpath); return(node); } // nothing to do, create from scratch return(type.Instantiate(parent, subpath, parent.Environment, value)); }
private S GetDefaultValue() { var defaultValue = _DefaultValue != null?_DefaultValue() : default(S); StateTreeUtils.Typecheck(_Type, defaultValue); return(defaultValue); }
public T Create(S snapshot = default(S), IEnvironment environment = null) { snapshot = snapshot != null ? snapshot : GetDefaultSnapshot(); StateTreeUtils.Typecheck(this, snapshot); return((T)Instantiate(null, "", environment, snapshot).Value); }
public override void ApplySnapshot(INode node, S[] snapshot) { StateTreeUtils.Typecheck(this, snapshot); var values = snapshot.Select(snap => SubType.Create(snap, node.Environment)).ToArray(); GetValue(node).Replace(values); }
public override void ApplySnapshot(INode node, S snapshot) { var value = (S)ApplySnapshotPreProcessor(snapshot); StateTreeUtils.Typecheck(this, value); if (node.StoredValue is IObservableObject <T, INode> observable) { foreach (var property in PropertyNames) { observable.Write(property, GetPropertyValue(value, property)); } } }
private IObjectWillChange WillChange(IObjectWillChange change) { var node = change.Object.GetStateTreeNode(); node.AssertWritable(); // only properties are typed, state are stored as-is references var type = Properties.ContainsKey(change.Name) ? Properties[change.Name] : null; if (type != null) { StateTreeUtils.Typecheck(type, change.NewValue); change.NewValue = type.Reconcile(node.GetChildNode(change.Name), change.NewValue); } return(change); }
private IMapWillChange <string, INode> WillChange(IMapWillChange <string, INode> change) { var node = change.Object.GetStateTreeNode() as ObjectNode; node.AssertWritable(); var map = change.Object as IObservableMap <string, INode, T>; switch (change.Type) { case ChangeType.UPDATE: { var oldValue = map.GetValue(change.Name); if (change.NewValue == oldValue) { return(null); } StateTreeUtils.Typecheck(SubType, change.NewValue.StoredValue); change.NewValue = SubType.Reconcile(node.GetChildNode(change.Name), change.NewValue.StoredValue); ProcessIdentifier(change.Name, change.NewValue); } break; case ChangeType.ADD: { StateTreeUtils.Typecheck(SubType, change.NewValue); change.NewValue = SubType.Instantiate(node, change.Name, Node.Environment, change.NewValue.StoredValue); ProcessIdentifier(change.Name, change.NewValue); } break; } return(change); }