public int m_index; //如果是数组类型时,改变的位置 public PropertyChangeEventArgs(PropertyChangeType changeTpye, object oldValue, object newValue, int index) { m_changeType = changeTpye; m_oldValue = oldValue; m_newValue = newValue; m_index = index; }
private void FormatPropertyChange(PSWhatIfPropertyChange propertyChange, int maxPathLength, int indentLevel) { //this.FormatHead(propertyChange, maxPathLength, indentLevel); PropertyChangeType propertyChangeType = propertyChange.PropertyChangeType; string path = propertyChange.Path; JToken before = propertyChange.Before; JToken after = propertyChange.After; IList <PSWhatIfPropertyChange> children = propertyChange.Children; switch (propertyChange.PropertyChangeType) { case PropertyChangeType.Create: this.FormatPropertyChangePath(propertyChangeType, path, after, children, maxPathLength, indentLevel); this.FormatPropertyCreate(after, indentLevel + 1); break; case PropertyChangeType.Delete: this.FormatPropertyChangePath(propertyChangeType, path, before, children, maxPathLength, indentLevel); this.FormatPropertyDelete(before, indentLevel + 1); break; case PropertyChangeType.Modify: this.FormatPropertyChangePath(propertyChangeType, path, before, children, maxPathLength, indentLevel); this.FormatPropertyModify(propertyChange, indentLevel + 1); break; case PropertyChangeType.Array: this.FormatPropertyArrayChange(propertyChange.Children, indentLevel + 1); break; default: throw new ArgumentOutOfRangeException(); } }
public void ObserveModelProperty() { int numEvents = 0; object[] recordedPath = null; PropertyChangeType recordedChangeType = PropertyChangeType.Property; object recordedValue = null; void onPropertyChanged(object[] path, PropertyChangeType changeType, object value) { numEvents++; recordedChangeType = changeType; recordedPath = path; recordedValue = value; TestContext.Out.WriteLine("Change {0} ({1}) -> {2}", string.Join('.', path), changeType, value); } DuetControlServer.Model.Observer.OnPropertyPathChanged += onPropertyChanged; // job.build[] Build newBuild = new Build(); Provider.Get.Job.Build = newBuild; Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { "job", "build" }, recordedPath); Assert.AreEqual(PropertyChangeType.Property, recordedChangeType); Assert.AreSame(newBuild, recordedValue); // End DuetControlServer.Model.Observer.OnPropertyPathChanged -= onPropertyChanged; }
private void FormatPropertyChangePath( PropertyChangeType propertyChangeType, string path, JToken valueAfterPath, IList <PSWhatIfPropertyChange> children, int maxPathLength, int indentLevel) { int paddingWidth = maxPathLength - path.Length + 1; bool hasChildren = children != null && children.Count > 0; if (valueAfterPath.IsNonEmptyArray() || (propertyChangeType == PropertyChangeType.Array && hasChildren)) { paddingWidth = 1; } if (valueAfterPath.IsNonEmptyObject()) { paddingWidth = 0; } if (propertyChangeType == PropertyChangeType.Modify && hasChildren) { paddingWidth = 0; } this.FormatPath( path, paddingWidth, indentLevel, () => this.FormatPropertyChangeType(propertyChangeType), this.FormatColon); }
private OrderChange CreateOrderChangeByChangedProperties(ChangedProperty changedPropery) { PropertyChangeType changeProperties = PropertyChangeType.None; if (string.Compare(changedPropery.AutoLimitPrice, this.AutoLimitPrice) != 0) { changeProperties |= PropertyChangeType.AutoLimitPrice; } if (string.Compare(changedPropery.AutoStopPrice, this.AutoStopPrice) != 0) { changeProperties |= PropertyChangeType.AutoStopPrice; } if (changedPropery.PaidPledge != this.PaidPledge) { changeProperties |= PropertyChangeType.PaidPledge; } if (changedPropery.PaidPledgeBalance != this.PaidPledgeBalance) { changeProperties |= PropertyChangeType.PaidPledgeBalance; } if (changedPropery.IsInstalmentOverdue != this.IsInstalmentOverdue) { changeProperties |= PropertyChangeType.HasOverdue; } if (changeProperties != PropertyChangeType.None) { return(new OrderChange(this, Protocal.Commands.OrderChangeType.Changed, changeProperties)); } return(null); }
/// <summary> /// Represents an event fired when a script object property has been changed. /// </summary> /// <param name="instance">The instance of the script object that contains the property.</param> /// <param name="changeType">The type of the change.</param> /// <param name="propertyName">The name of the property.</param> /// <param name="newValue">The new value of the property.</param> /// <param name="oldValue">The old value of the property.</param> public static void OnPropertyChange(ScriptObject instance, PropertyChangeType changeType, string propertyName, BoxedValue newValue, BoxedValue oldValue) { // Ignore identifier property if (propertyName == "$i") return; switch (changeType) { // Occurs when a new property is assigned to an object, either by // using the indexer, property access or array methods. case PropertyChangeType.Put: { // We need to make sure the new value is marked as observed // as well, so its members will notify us too. if (newValue.IsStrictlyObject) newValue.Object.Observe(); // Send the change through the current scope Channel.Current.SendPropertyChange(PropertyChangeType.Put, instance.Oid, propertyName, newValue); break; } // Occurs when a property change occurs, by using an assignment // operator, or the array indexer. case PropertyChangeType.Set: { // We need to unmark the old value and ignore it, as we no // longer require observations from that value. if (oldValue.IsStrictlyObject) oldValue.Object.Ignore(); // We need to make sure the new value is marked as observed // as well, so its members will notify us too. if (newValue.IsStrictlyObject) newValue.Object.Observe(); // Send the change through the current scope Channel.Current.SendPropertyChange(PropertyChangeType.Set, instance.Oid, propertyName, newValue); break; } // Occurs when a property was deleted from the object, either by // using a 'delete' keyword or the array removal methods. case PropertyChangeType.Delete: { // We need to unmark the old value and ignore it, as we no // longer require observations from that value. if (oldValue.IsStrictlyObject) oldValue.Object.Ignore(); // Send the change through the current scope Channel.Current.SendPropertyChange(PropertyChangeType.Delete, instance.Oid, propertyName, newValue); break; } } //Console.WriteLine("Observe: [{0}] {1} = {2}", changeType.ToString(), propertyName, propertyValue); }
internal WhatIfPropertyChange(string path, PropertyChangeType propertyChangeType, object before, object after, IReadOnlyList <WhatIfPropertyChange> children) { Path = path; PropertyChangeType = propertyChangeType; Before = before; After = after; Children = children; }
internal static WhatIfPropertyChange DeserializeWhatIfPropertyChange(JsonElement element) { string path = default; PropertyChangeType propertyChangeType = default; Optional <object> before = default; Optional <object> after = default; Optional <IReadOnlyList <WhatIfPropertyChange> > children = default; foreach (var property in element.EnumerateObject()) { if (property.NameEquals("path")) { path = property.Value.GetString(); continue; } if (property.NameEquals("propertyChangeType")) { propertyChangeType = property.Value.GetString().ToPropertyChangeType(); continue; } if (property.NameEquals("before")) { if (property.Value.ValueKind == JsonValueKind.Null) { property.ThrowNonNullablePropertyIsNull(); continue; } before = property.Value.GetObject(); continue; } if (property.NameEquals("after")) { if (property.Value.ValueKind == JsonValueKind.Null) { property.ThrowNonNullablePropertyIsNull(); continue; } after = property.Value.GetObject(); continue; } if (property.NameEquals("children")) { if (property.Value.ValueKind == JsonValueKind.Null) { property.ThrowNonNullablePropertyIsNull(); continue; } List <WhatIfPropertyChange> array = new List <WhatIfPropertyChange>(); foreach (var item in property.Value.EnumerateArray()) { array.Add(DeserializeWhatIfPropertyChange(item)); } children = array; continue; } } return(new WhatIfPropertyChange(path, propertyChangeType, before.Value, after.Value, Optional.ToList(children))); }
/// <summary> /// Initializes a new instance of the WhatIfPropertyChange class. /// </summary> /// <param name="path">The path of the property.</param> /// <param name="propertyChangeType">The type of property change. /// Possible values include: 'Create', 'Delete', 'Modify', 'Array', /// 'NoEffect'</param> /// <param name="before">The value of the property before the /// deployment is executed.</param> /// <param name="after">The value of the property after the deployment /// is executed.</param> /// <param name="children">Nested property changes.</param> public WhatIfPropertyChange(string path, PropertyChangeType propertyChangeType, object before = default(object), object after = default(object), IList <WhatIfPropertyChange> children = default(IList <WhatIfPropertyChange>)) { Path = path; PropertyChangeType = propertyChangeType; Before = before; After = after; Children = children; CustomInit(); }
/// <summary> /// Constructor. </summary> /// <param name="namespaceName"> the namespace of the key </param> /// <param name="propertyName"> the key whose value is changed </param> /// <param name="oldValue"> the value before change </param> /// <param name="newValue"> the value after change </param> /// <param name="changeType"> the change type </param> public ConfigChange(string namespaceName, string propertyName, string oldValue, string newValue, PropertyChangeType changeType) { _namespaceName = namespaceName; _propertyName = propertyName; _oldValue = oldValue; _newValue = newValue; _changeType = changeType; }
/// <summary> /// 构造 /// </summary> /// <param name="namespaceName">命名空间</param> /// <param name="propertyName">属性名</param> /// <param name="oldValue">修改前的值</param> /// <param name="newValue">修改后的值</param> /// <param name="changeType">变动类型</param> public ConfigChange(string namespaceName, string propertyName, string oldValue, string newValue, PropertyChangeType changeType) { Namespace = namespaceName; PropertyName = propertyName; OldValue = oldValue; NewValue = newValue; ChangeType = changeType; }
/// <summary> /// Constructor. </summary> /// <param name="namespace"> the namespace of the key </param> /// <param name="propertyName"> the key whose value is changed </param> /// <param name="oldValue"> the value before change </param> /// <param name="newValue"> the value after change </param> /// <param name="changeType"> the change type </param> public ConfigChange(string namespaceName, string propertyName, string oldValue, string newValue, PropertyChangeType changeType) { this.namespaceName = namespaceName; this.propertyName = propertyName; this.oldValue = oldValue; this.newValue = newValue; this.changeType = changeType; }
/// <summary> /// Constructor. </summary> /// <param name="config"> the config of the key </param> /// <param name="propertyName"> the key whose value is changed </param> /// <param name="oldValue"> the value before change </param> /// <param name="newValue"> the value after change </param> /// <param name="changeType"> the change type </param> public ConfigChange(IConfig config, string propertyName, string?oldValue, string?newValue, PropertyChangeType changeType) { Config = config; PropertyName = propertyName; OldValue = oldValue; NewValue = newValue; ChangeType = changeType; }
public void ObserveModelGrowingCollectiion() { int numEvents = 0; object[] recordedPath = null; PropertyChangeType recordedChangeType = PropertyChangeType.Property; object recordedValue = null; void onPropertyChanged(object[] path, PropertyChangeType changeType, object value) { numEvents++; recordedChangeType = changeType; recordedPath = path; recordedValue = value; TestContext.Out.WriteLine("Change {0} ({1}) -> {2}", string.Join('.', path), changeType, value); } DuetControlServer.Model.Observer.OnPropertyPathChanged += onPropertyChanged; // Add item TestContext.Out.WriteLine("Add item"); Message msg = new Message(MessageType.Success, "TEST"); Provider.Get.Messages.Add(msg); Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { "messages" }, recordedPath); Assert.AreEqual(PropertyChangeType.GrowingCollection, recordedChangeType); if (recordedValue is IList list) { Assert.AreSame(msg, list[0]); } else { Assert.Fail("Invalid change value type"); } // Reset numEvents = 0; recordedPath = null; recordedValue = null; TestContext.Out.WriteLine(); // Clear items TestContext.Out.WriteLine("Clear items"); Provider.Get.Messages.Clear(); Assert.AreEqual(1, numEvents); Assert.AreEqual(PropertyChangeType.GrowingCollection, recordedChangeType); Assert.AreEqual(new object[] { "messages" }, recordedPath); Assert.AreEqual(null, recordedValue); // End DuetControlServer.Model.Observer.OnPropertyPathChanged -= onPropertyChanged; }
internal WhatIfPropertyChange(string path, PropertyChangeType propertyChangeType) { if (path == null) { throw new ArgumentNullException(nameof(path)); } Path = path; PropertyChangeType = propertyChangeType; }
public static Color ToColor(this PropertyChangeType propertyChangeType) { bool success = ColorsByPropertyChangeType.TryGetValue(propertyChangeType, out Color colorCode); if (!success) { throw new ArgumentOutOfRangeException(nameof(propertyChangeType)); } return(colorCode); }
public static Symbol ToSymbol(this PropertyChangeType propertyChangeType) { bool success = SymbolsByPropertyChangeType.TryGetValue(propertyChangeType, out Symbol symbol); if (!success) { throw new ArgumentOutOfRangeException(nameof(propertyChangeType)); } return(symbol); }
public static PSChangeType ToPSChangeType(this PropertyChangeType propertyChangeType) { bool success = PSChangeTypesByPropertyChangeType.TryGetValue(propertyChangeType, out PSChangeType changeType); if (!success) { throw new ArgumentOutOfRangeException(nameof(propertyChangeType)); } return(changeType); }
internal WhatIfPropertyChange(string path, PropertyChangeType propertyChangeType) { if (path == null) { throw new ArgumentNullException(nameof(path)); } Path = path; PropertyChangeType = propertyChangeType; Children = new ChangeTrackingList <WhatIfPropertyChange>(); }
public void ObserveModelObjectDictionary() { int numEvents = 0; object[] recordedPath = null; PropertyChangeType recordedChangeType = PropertyChangeType.Property; object recordedValue = null; void onPropertyChanged(object[] path, PropertyChangeType changeType, object value) { numEvents++; recordedChangeType = changeType; recordedPath = path; recordedValue = value; TestContext.Out.WriteLine("Change {0} ({1}) -> {2}", string.Join('.', path), changeType, value); } DuetControlServer.Model.Observer.OnPropertyPathChanged += onPropertyChanged; // plugins Plugin plugin = new() { Id = "Foobar" }; Provider.Get.Plugins.Add("Foobar", plugin); Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { "plugins", "Foobar" }, recordedPath); Assert.AreEqual(PropertyChangeType.Property, recordedChangeType); Assert.AreSame(plugin, recordedValue); // plugins.foobar.pid plugin.Pid = 1234; Assert.AreEqual(2, numEvents); Assert.AreEqual(new object[] { "plugins", "Foobar", "pid" }, recordedPath); Assert.AreEqual(PropertyChangeType.Property, recordedChangeType); Assert.AreEqual(plugin.Pid, recordedValue); // delete item Provider.Get.Plugins.Remove("Foobar"); Assert.AreEqual(3, numEvents); Assert.AreEqual(new object[] { "plugins", "Foobar" }, recordedPath); Assert.AreEqual(PropertyChangeType.Property, recordedChangeType); Assert.IsNull(recordedValue); // End DuetControlServer.Model.Observer.OnPropertyPathChanged -= onPropertyChanged; Provider.Get.Plugins.Clear(); }
internal static string ToSerializedValue(this PropertyChangeType value) { switch (value) { case PropertyChangeType.Create: return("Create"); case PropertyChangeType.Delete: return("Delete"); case PropertyChangeType.Modify: return("Modify"); case PropertyChangeType.Array: return("Array"); } return(null); }
public void ObserveModelDictionary() { int numEvents = 0; object[] recordedPath = null; PropertyChangeType recordedChangeType = PropertyChangeType.Property; object recordedValue = null; void onPropertyChanged(object[] path, PropertyChangeType changeType, object value) { numEvents++; recordedChangeType = changeType; recordedPath = path; recordedValue = value; TestContext.Out.WriteLine("Change {0} ({1}) -> {2}", string.Join('.', path), changeType, value); } DuetControlServer.Model.Observer.OnPropertyPathChanged += onPropertyChanged; // plugins Plugin plugin = new() { Id = "Foobar" }; Provider.Get.Plugins.Add("Foobar", plugin); Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { "plugins", "Foobar" }, recordedPath); Assert.AreEqual(PropertyChangeType.Property, recordedChangeType); Assert.AreSame(plugin, recordedValue); // plugins.foobar.data.test JsonElement customData = new(); plugin.Data["test"] = customData; Assert.AreEqual(2, numEvents); Assert.AreEqual(new object[] { "plugins", "Foobar", "data", "test" }, recordedPath); Assert.AreEqual(PropertyChangeType.Property, recordedChangeType); Assert.AreEqual(customData, recordedValue); // End DuetControlServer.Model.Observer.OnPropertyPathChanged -= onPropertyChanged; Provider.Get.Plugins.Clear(); }
/// <summary> /// Initializes a new instance of the <see cref="com.rmc.projects.property_change_signal.vo.PropertyChangeSignalVO"/> class. /// </summary> /// <param name="aPropertyChangeType">A property change type.</param> /// <param name="aValue_object">A value_object.</param> public PropertyChangeSignalVO(PropertyChangeType aPropertyChangeType, object aValue_object) { //Debug.Log("--PropertyChangeSignalVO.constructor ("+aPropertyChangeType+","+aValue_object+")"); //THESE 2 TYPES REQUIRE 2 ARGUMENTS, ALWAYS // switch (aPropertyChangeType) { case PropertyChangeType.UPDATE: case PropertyChangeType.UPDATED: _propertyChangeType = aPropertyChangeType; _value_object = aValue_object; break; default: #pragma warning disable 0162 //ANY OTHER VALUES ARE NOT ACCEPTABLE IN THIS CONTEXT throw new SwitchStatementException(propertyChangeType.ToString()); break; #pragma warning restore 0162 } }
/// <summary> /// Method that is called when a property of the machine model has changed /// </summary> /// <param name="path">Path to the property</param> /// <param name="changeType">Type of the change</param> /// <param name="value">New value</param> private void MachineModelPropertyChanged(object[] path, PropertyChangeType changeType, object value) { if (!CheckFilters(path)) { return; } lock (_patch) { try { object node = GetPathNode(_patch, path); if (node == null) { // Skip this update if the underlying object is about to be fully transferred anyway return; } switch (changeType) { case PropertyChangeType.Property: // Set new property value Dictionary <string, object> propertyNode = (Dictionary <string, object>)node; string propertyName = (string)path[^ 1];
protected void OnPropertyChange(PropertyChangeType type, string name, double newValue, BoxedValue oldValue) { // Invoke the changed event if (ScriptObject.PropertyChange != null) ScriptObject.PropertyChange(this, type, name, BoxedValue.Box(newValue), oldValue); }
/// <summary> /// Initializes a new instance of the <see cref="com.rmc.projects.property_change_signal.vo.PropertyChangeSignalVO"/> class. /// </summary> /// <param name="aPropertyChangeType">A property change type.</param> /// <param name="aValue_object">A value_object.</param> public PropertyChangeSignalVO (PropertyChangeType aPropertyChangeType, object aValue_object ) { //Debug.Log("--PropertyChangeSignalVO.constructor ("+aPropertyChangeType+","+aValue_object+")"); //THESE 2 TYPES REQUIRE 2 ARGUMENTS, ALWAYS // switch (aPropertyChangeType) { case PropertyChangeType.UPDATE: case PropertyChangeType.UPDATED: _propertyChangeType = aPropertyChangeType; _value_object = aValue_object; break; default: #pragma warning disable 0162 //ANY OTHER VALUES ARE NOT ACCEPTABLE IN THIS CONTEXT throw new SwitchStatementException(propertyChangeType.ToString()); break; #pragma warning restore 0162 } }
internal OrderChange(Order source, Protocal.Commands.OrderChangeType changeType, PropertyChangeType changeProperties = PropertyChangeType.None) : base(changeType, source) { this.PropertyType = changeProperties; this.AffectedTrans = new List <Transaction>(); }
public void ObserveProperty() { int numEvents = 0; object[] recordedPath = null; PropertyChangeType recordedChangeType = PropertyChangeType.Property; object recordedValue = null; void onPropertyChanged(object[] path, PropertyChangeType changeType, object value) { numEvents++; recordedChangeType = changeType; recordedPath = path; recordedValue = value; TestContext.Out.WriteLine("Change {0} ({1}) -> {2}", string.Join('.', path), changeType, value); } DuetControlServer.Model.Observer.OnPropertyPathChanged += onPropertyChanged; // Simple property TestContext.Out.WriteLine("Simple property"); Provider.Get.State.Status = MachineStatus.Halted; Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { "state", "status" }, recordedPath); Assert.AreEqual(PropertyChangeType.Property, recordedChangeType); Assert.AreEqual(MachineStatus.Halted, recordedValue); // Nested item property TestContext.Out.WriteLine("Adding new item"); Board mainBoard = new Board(); Provider.Get.Boards.Add(mainBoard); // Reset numEvents = 0; recordedChangeType = PropertyChangeType.Property; recordedValue = null; TestContext.Out.WriteLine(); // Nested item propery TestContext.Out.WriteLine("Nested item property"); mainBoard.V12.Current = 123F; Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { new ItemPathNode("boards", 0, new object[1]), "v12", "current" }, recordedPath); Assert.AreEqual(123F, recordedValue); // Reset numEvents = 0; recordedChangeType = PropertyChangeType.Property; recordedValue = null; TestContext.Out.WriteLine(); // Nested item propery 2 TestContext.Out.WriteLine("Nested item property 2"); Provider.Get.Inputs.HTTP.State = InputChannelState.AwaitingAcknowledgement; Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { new ItemPathNode("inputs", (int)DuetAPI.CodeChannel.HTTP, new object[Inputs.Total]), "state" }, recordedPath); Assert.AreEqual(InputChannelState.AwaitingAcknowledgement, recordedValue); // Reset numEvents = 0; recordedChangeType = PropertyChangeType.Property; recordedValue = null; TestContext.Out.WriteLine(); // Replaceable model object TestContext.Out.WriteLine("Assign MessageBox"); MessageBox messageBox = new MessageBox { Message = "Test", Mode = MessageBoxMode.OkCancel, Title = "Test title" }; Provider.Get.State.MessageBox = messageBox; Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { "state", "messageBox" }, recordedPath); Assert.AreSame(messageBox, recordedValue); // Reset numEvents = 0; recordedChangeType = PropertyChangeType.Property; recordedValue = null; TestContext.Out.WriteLine(); // Replaceable model object property TestContext.Out.WriteLine("MessageBox property"); Provider.Get.State.MessageBox.Message = "asdf"; Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { "state", "messageBox", "message" }, recordedPath); Assert.AreEqual("asdf", recordedValue); // Reset numEvents = 0; recordedChangeType = PropertyChangeType.Property; recordedValue = null; TestContext.Out.WriteLine(); // Replaceable model object 2 TestContext.Out.WriteLine("Remove MessageBox"); Provider.Get.State.MessageBox = null; Assert.AreEqual(1, numEvents); Assert.AreEqual(new object[] { "state", "messageBox" }, recordedPath); Assert.AreEqual(null, recordedValue); // End DuetControlServer.Model.Observer.OnPropertyPathChanged -= onPropertyChanged; }
public void ObserveModelObjectCollection() { int numEvents = 0; PropertyChangeType recordedChangeType = PropertyChangeType.Property; object[] recordedPath = null; object recordedValue = null; void onPropertyChanged(object[] path, PropertyChangeType changeType, object value) { numEvents++; recordedChangeType = changeType; recordedPath = path; recordedValue = value; TestContext.Out.WriteLine("Change {0} ({1}) -> {2}", string.Join('.', path), changeType, value); } DuetControlServer.Model.Observer.OnPropertyPathChanged += onPropertyChanged; // Add first item TestContext.Out.WriteLine("Add item"); Heater newHeater = new Heater(); Provider.Get.Heat.Heaters.Add(newHeater); Assert.AreEqual(1, numEvents); Assert.AreEqual(PropertyChangeType.ObjectCollection, recordedChangeType); Assert.AreEqual(new object[] { "heat", new ItemPathNode("heaters", 0, new object[1]) }, recordedPath); Assert.AreSame(newHeater, recordedValue); // Reset numEvents = 0; recordedPath = null; recordedValue = null; TestContext.Out.WriteLine(); // Add second item TestContext.Out.WriteLine("Add item"); newHeater = new Heater(); Provider.Get.Heat.Heaters.Add(newHeater); Assert.AreEqual(1, numEvents); Assert.AreEqual(PropertyChangeType.ObjectCollection, recordedChangeType); Assert.AreEqual(new object[] { "heat", new ItemPathNode("heaters", 1, new object[2]) }, recordedPath); Assert.AreSame(newHeater, recordedValue); // Reset numEvents = 0; recordedPath = null; recordedValue = null; TestContext.Out.WriteLine(); // Modify first item TestContext.Out.WriteLine("Modify first item"); Provider.Get.Heat.Heaters[0].Active = 123F; Assert.AreEqual(1, numEvents); Assert.AreEqual(PropertyChangeType.Property, recordedChangeType); Assert.AreEqual(new object[] { "heat", new ItemPathNode("heaters", 0, new object[2]), "active" }, recordedPath); Assert.AreEqual(123F, recordedValue); // Reset numEvents = 0; recordedPath = null; recordedValue = null; TestContext.Out.WriteLine(); // Move item TestContext.Out.WriteLine("Move item"); Provider.Get.Heat.Heaters.Move(1, 0); Assert.AreEqual(2, numEvents); Assert.AreEqual(PropertyChangeType.ObjectCollection, recordedChangeType); Assert.AreEqual(new object[] { "heat", new ItemPathNode("heaters", 1, new object[2]) }, recordedPath); Assert.AreSame(Provider.Get.Heat.Heaters[1], recordedValue); // Reset numEvents = 0; recordedPath = null; recordedValue = null; TestContext.Out.WriteLine(); // Replace item TestContext.Out.WriteLine("Replace item"); newHeater = new Heater { Active = 10F }; Provider.Get.Heat.Heaters[0] = newHeater; Assert.AreEqual(1, numEvents); Assert.AreEqual(PropertyChangeType.ObjectCollection, recordedChangeType); Assert.AreEqual(new object[] { "heat", new ItemPathNode("heaters", 0, new object[2]) }, recordedPath); Assert.AreSame(newHeater, recordedValue); // Reset numEvents = 0; recordedPath = null; recordedValue = null; TestContext.Out.WriteLine(); // Insert item TestContext.Out.WriteLine("Insert item"); newHeater = new Heater { Standby = 20F }; Provider.Get.Heat.Heaters.Insert(0, newHeater); Assert.AreEqual(3, numEvents); Assert.AreEqual(PropertyChangeType.ObjectCollection, recordedChangeType); Assert.AreEqual(new object[] { "heat", new ItemPathNode("heaters", 2, new object[3]) }, recordedPath); Assert.AreEqual(Provider.Get.Heat.Heaters[2], recordedValue); // Reset numEvents = 0; recordedPath = null; recordedValue = null; TestContext.Out.WriteLine(); // Remove item TestContext.Out.WriteLine("Remove item"); Provider.Get.Heat.Heaters.RemoveAt(0); Assert.AreEqual(3, numEvents); Assert.AreEqual(PropertyChangeType.ObjectCollection, recordedChangeType); Assert.AreEqual(new object[] { "heat", new ItemPathNode("heaters", 1, new object[2]) }, recordedPath); Assert.AreEqual(Provider.Get.Heat.Heaters[1], recordedValue); // Reset numEvents = 0; recordedPath = null; recordedValue = null; TestContext.Out.WriteLine(); // Clear items TestContext.Out.WriteLine("Clear items"); Provider.Get.Heat.Heaters.Clear(); Assert.AreEqual(1, numEvents); Assert.AreEqual(PropertyChangeType.ObjectCollection, recordedChangeType); Assert.AreEqual(new object[] { "heat", new ItemPathNode("heaters", 0, Array.Empty <object>()) }, recordedPath); Assert.AreEqual(null, recordedValue); // End DuetControlServer.Model.Observer.OnPropertyPathChanged -= onPropertyChanged; }
internal static WhatIfPropertyChange DeserializeWhatIfPropertyChange(JsonElement element) { string path = default; PropertyChangeType propertyChangeType = default; object before = default; object after = default; IReadOnlyList <WhatIfPropertyChange> children = default; foreach (var property in element.EnumerateObject()) { if (property.NameEquals("path")) { path = property.Value.GetString(); continue; } if (property.NameEquals("propertyChangeType")) { propertyChangeType = property.Value.GetString().ToPropertyChangeType(); continue; } if (property.NameEquals("before")) { if (property.Value.ValueKind == JsonValueKind.Null) { continue; } before = property.Value.GetObject(); continue; } if (property.NameEquals("after")) { if (property.Value.ValueKind == JsonValueKind.Null) { continue; } after = property.Value.GetObject(); continue; } if (property.NameEquals("children")) { if (property.Value.ValueKind == JsonValueKind.Null) { continue; } List <WhatIfPropertyChange> array = new List <WhatIfPropertyChange>(); foreach (var item in property.Value.EnumerateArray()) { if (item.ValueKind == JsonValueKind.Null) { array.Add(null); } else { array.Add(DeserializeWhatIfPropertyChange(item)); } } children = array; continue; } } return(new WhatIfPropertyChange(path, propertyChangeType, before, after, children)); }
public void RecordPropertyChange(QualifiedTopicRevision topic, string propertyName, PropertyChangeType aType) { switch (aType) { case PropertyChangeType.PropertyAdd: AddToDictionaries(_addedPropertiesByProperty, _addedPropertiesByTopic, topic, propertyName); break; case PropertyChangeType.PropertyRemove: AddToDictionaries(_removedPropertiesByProperty, _removedPropertiesByTopic, topic, propertyName); break; case PropertyChangeType.PropertyUpdate: AddToDictionaries(_changedPropertiesByProperty, _changedPropertiesByTopic, topic, propertyName); break; } }
internal static bool Contains(this PropertyChangeType source, PropertyChangeType item) { return(source.HasFlag(item)); }
public PropertyChange(string name, PropertyChangeType changeType, object oldValue, object newValue) { Name = name; ChangeType = changeType; OldValue = oldValue; NewValue = newValue; }
public static void InvokePropertyChange(ScriptObject instance, PropertyChangeType type, string name, double newValue, BoxedValue oldValue) { // Invoke the changed event if (ScriptObject.PropertyChange != null) ScriptObject.PropertyChange(instance, type, name, BoxedValue.Box(newValue), oldValue); }
private void FormatPropertyChangeType(PropertyChangeType propertyChangeType) { this.Builder .Append(propertyChangeType.ToSymbol(), propertyChangeType.ToColor()) .Append(Symbol.WhiteSpace); }
public static string ToSerialString(this PropertyChangeType value) => value switch {