public static ILiveValue<double> ToLiveRateOfChange(this ILiveValue<double> source, TimeSpan unitTimeSpan, TimeSpan windowTimeSpan) { var unitSize = HiResTimer.FromTimeSpan(unitTimeSpan); var windowSize = HiResTimer.FromTimeSpan(windowTimeSpan); var window = new List<Tuple<long, double>>(); LiveObserver<IValueState<double>> observer = null; return LiveValueObservable<double>.Create( innerChanged => source.Subscribe(observer = source.CreateObserver(innerChanged)), () => observer.GetNotify(), (innerChanged, oldState) => { // get source change var state = observer.GetState(); // create new change var result = new ValueState<double>(); if (state.Status.IsConnected()) { var now = HiResTimer.Now(); // clip window - but always leave at least one item var removeItems = 0; while (removeItems < (window.Count - 1) && window[removeItems].Item1 < (now - windowSize)) removeItems++; window.RemoveRange(0, removeItems); // add to window window.Add(new Tuple<long, double>(now, state.NewValue)); // enough data? result.Status = window.Count < 2 ? StateStatus.Disconnected : StateStatus.Connected; if (result.Status != StateStatus.Disconnected) { var ratesPassed = ((double)now - window[0].Item1) / unitSize; result.NewValue = ratesPassed == 0 ? 0 : (state.NewValue - window[0].Item2) / ratesPassed; result.LastUpdated = state.LastUpdated; } } else { result.Status = state.Status; window.Clear(); } return result; }, () => observer.Dispose()); }
/// <summary> /// Updates the list with the specified value. /// </summary> private void UpdateList( ref int index, ref bool overwrite, object value, object componentValue, object componentId, string name, string type) { // get the list item to update. ListViewItem listitem = GetListItem(index, ref overwrite, name, type); // update list item. listitem.SubItems[1].Text = GetValueText(componentValue); // move to next item. index++; ValueState state = listitem.Tag as ValueState; // recursively update sub-values if item is expanded. if (overwrite) { if (state.Expanded && state.Expandable) { m_depth++; ShowValue(ref index, ref overwrite, componentValue); m_depth--; } } // update state. state.Expandable = IsExpandableType(componentValue); state.Value = value; state.Component = componentValue; state.ComponentId = componentId; state.ComponentIndex = index; if (!state.Expandable) { listitem.ImageKey = CollapseIcon; } }
private void ReadIntKeepValue(byte[] buffer) { if (this.Scale != 1) { MakeFail("地址:" + this.Address + "整数型的倍率必须为1"); return; } int index = GetSingleBufferIndex(this.Address); if (!this.CheckAddrIndex(index, buffer.Length, out string errMsg)) { MakeFail(errMsg); return; } switch (this.Length) { case 16: { this.Value = DataUtil.ToDoubleByScale(ByteUtil.GetUshortValue(buffer, index), 1); this.state = ValueState.Success; return; } case 32: { this.Value = DataUtil.ToDoubleByScale(ByteUtil.Get32BitValue(buffer, index), 1); this.state = ValueState.Success; return; } case 48: { this.Value = DataUtil.ToDoubleByScale(ByteUtil.Get48BitValue(buffer, index), 1); this.state = ValueState.Success; return; } default: MakeFail("地址:" + this.Address + "未知的数据长度"); break; } }
/// <summary> /// Reads next row of data if available. /// </summary> /// <returns>Null when end of file is reached, or array of strings for each column.</returns> public string[] ReadNextRow() { if (ValueState.EndOfFile == _lastState) { return(null); } _row.Clear(); _chars.Clear(); while (ValueState.HasMore == (_lastState = ReadNextValue())) { _row.Add(Str()); _chars.Clear(); } _row.Add(Str()); return(_row.ToArray()); }
private void ReadGroupKeepValue(byte[] buffer) { string[] addrs = this.Address.Split(';'); if (addrs.Length != 3) { MakeFail("地址:" + this.Address + "组合地址非法,必须为三个非开关型的点位"); return; } double lowVal = 0; double middleVal = 0; double highVal = 0; // 地址循环检查 int i = 0; foreach (string addr in addrs) { int index = GetSingleBufferIndex(addr); if (!this.CheckAddrIndex(index, buffer.Length, out string errMsg)) { MakeFail(errMsg); return; } if (i == 0) { lowVal = DataUtil.ToDoubleByScale(ByteUtil.GetUshortValue(buffer, index), 1); } else if (i == 1) { middleVal = DataUtil.ToDoubleByScale(ByteUtil.GetUshortValue(buffer, index), 1); } else if (i == 2) { highVal = DataUtil.ToDoubleByScale(ByteUtil.GetUshortValue(buffer, index), 1); } i++; } // 注意地址存放顺序,低在前,中在中,高在后 this.Value = DataUtil.ToDoubleByScale(DataUtil.ToDouble(lowVal + middleVal * 10000 + highVal * 100000000), this.Scale); this.state = ValueState.Success; }
/// <summary> /// Shows the components of a value in the control. /// </summary> private void ShowChildren(ListViewItem listItem) { ValueState state = listItem.Tag as ValueState; if (state == null || !state.Expandable || state.Expanded) { return; } m_expanding = true; m_depth = listItem.IndentCount + 1; state.Expanded = true; listItem.ImageKey = CollapseIcon; int index = listItem.Index + 1; bool overwrite = false; ShowValue(ref index, ref overwrite, state.Component); AdjustColumns(); }
private void ReadFloatKeepValue(byte[] buffer) { int index = GetSingleBufferIndex(this.Address); if (!this.CheckAddrIndex(index, buffer.Length, out string errMsg)) { MakeFail(errMsg); return; } switch (this.Length) { case 16: { this.Value = DataUtil.ToDoubleByScale(ByteUtil.GetUshortValue(buffer, index), this.Scale); this.state = ValueState.Success; return; } case 32: { this.Value = DataUtil.ToDoubleByScale(ByteUtil.Get32BitValue(buffer, index), this.Scale); this.state = ValueState.Success; return; } case 48: { this.Value = DataUtil.ToDoubleByScale(ByteUtil.Get48BitValue(buffer, index), this.Scale); this.state = ValueState.Success; return; } default: this.mess = "未知的数据长度"; this.state = ValueState.Fail; break; } }
/* * private void MonitoredItem_Notification(object sender, EventArgs e) * { * if (InvokeRequired) * { * BeginInvoke(m_MonitoredItemNotification, sender, e); * return; * } * else if (!IsHandleCreated) * { * return; * } * * try * { * if (!Object.ReferenceEquals(sender, m_monitoredItem)) * { * return; * } * * MonitoredItemEventArgs args = e as MonitoredItemEventArgs; * * if (args == null) * { * return; * } * * m_expanding = false; * * int index = 0; * bool overwrite = true; * * ShowValue(ref index, ref overwrite, args.NotificationValue); * AdjustColumns(); * } * catch (Exception exception) * { * GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception); * } * } */ private void ItemsLV_MouseClick(object sender, MouseEventArgs e) { try { if (e.Button != MouseButtons.Left) { return; } ListViewItem listItem = ItemsLV.GetItemAt(e.X, e.Y); if (listItem == null) { return; } ValueState state = listItem.Tag as ValueState; if (state == null || !state.Expandable) { return; } if (state.Expanded) { HideChildren(listItem); } else { ShowChildren(listItem); } } catch (Exception exception) { GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception); } }
/// <summary> /// Hides the components of a value in the control. /// </summary> private void HideChildren(ListViewItem listItem) { ValueState state = listItem.Tag as ValueState; if (state == null || !state.Expandable || !state.Expanded) { return; } for (int ii = listItem.Index + 1; ii < ItemsLV.Items.Count;) { ListViewItem childItem = ItemsLV.Items[ii]; if (childItem.IndentCount <= listItem.IndentCount) { break; } childItem.Remove(); } state.Expanded = false; listItem.ImageKey = ExpandIcon; }
protected virtual void ProcessOnEvaluate() { var prevState = State; if (HadException) { LastValueWasNull = true; LastValueType = FallbackType; State = ValueState.Exception; } else if (Value.IsNullOrDestroyed()) { LastValueWasNull = true; State = GetStateForType(FallbackType); } else { LastValueWasNull = false; State = GetStateForType(Value.GetActualType()); } if (IValue != null) { // If we changed states (always needs IValue change) // or if the value is null, and the fallback type isnt string (we always want to edit strings). if (State != prevState || (State != ValueState.String && Value.IsNullOrDestroyed())) { // need to return IValue ReleaseIValue(); SubContentShowWanted = false; } } // Set label text this.ValueLabelText = GetValueLabel(); }
/// <summary> /// Update value of control /// </summary> /// <param name="state"></param> protected virtual void UpdateValueState(ValueState state) { }
private void EditMI_Click(object sender, EventArgs e) { try { if (ItemsLV.SelectedItems.Count != 1) { return; } ValueState state = ItemsLV.SelectedItems[0].Tag as ValueState; if (!IsEditableType(state.Component)) { return; } object value = new SimpleValueEditDlg().ShowDialog(state.Component, state.Component.GetType()); if (value == null) { return; } if (state.Value is IEncodeable) { PropertyInfo property = (PropertyInfo)state.ComponentId; MethodInfo[] accessors = property.GetAccessors(); for (int ii = 0; ii < accessors.Length; ii++) { if (accessors[ii].ReturnType == typeof(void)) { accessors[ii].Invoke(state.Value, new object[] { value }); state.Component = value; break; } } } DataValue datavalue = state.Value as DataValue; if (datavalue != null) { int component = (int)state.ComponentId; switch (component) { case 0: { datavalue.Value = value; break; } } } if (state.Value is IList) { int ii = (int)state.ComponentId; ((IList)state.Value)[ii] = value; state.Component = value; } m_expanding = false; int index = 0; bool overwrite = true; ShowValue(ref index, ref overwrite, state.Value); } catch (Exception exception) { GuiUtils.HandleException(this.Text, MethodBase.GetCurrentMethod(), exception); } }
public Value(ValueState state) { Values = (byte)state; Width = 1; }
private void MakeFail(string errMsg) { this.mess = errMsg; this.Value = 0; this.state = ValueState.Fail; }
public Lazy(T value) { this.value = value; valueState = ValueState.Created; }
private void CreateAutoma() { ValueState value = new ValueState(); RuleProductionState rule = new RuleProductionState(); rule.Source = GrammarLine.VariableStart; rule.Destiny = GrammarLine.GetRules(rule.Source)[0].Destiny; rule.Id = GrammarLine.GetRules(rule.Source)[0].Id; rule.TypeName = GrammarLine.GetRules(rule.Source)[0].TypeName; rule.Pointer = 0; rule.Pertinence = 1; rule.Lookahead = Symbol.TapeFinal; rule.Parent = GrammarLine.GetRules(rule.Source)[0].Parent; value.Rules.Add(rule); State<Symbol> state = new State<Symbol>(0, "I000", 1, 0, Closure(value)); FirstState = state; // Rules.AddRange(state.GetValue<ValueState>().Rules); Automa.States.Add(state); bool change = true; // while (change) { change = false; for (int i = 0; i < Automa.States.Count; i++) { var stateActualI = Automa.States[i]; SymbolList symbols = Grammar.Symbols; for (int j = 0; j < symbols.Count; j++) { var symbolX = symbols[j]; var valStateI = stateActualI.GetValue<ValueState>(); var valueGoto = Goto(valStateI, symbolX); if (valueGoto.Rules.Count > 0) { //var item = value.Rules // foreach (var item in value.Rules) { state = Automa.States.FirstOrDefault(s => s.GetValue<ValueState>().Equals(valueGoto)); if (state == null) { state = new State<Symbol>(-1, "Temp", 1, 0, valueGoto); state.Name = string.Format("I{0:000}", state.Id); Automa.States.Add(state); } // Rules.AddRange(value.Rules); Transition<Symbol> transition = new Transition<Symbol>(); transition.From = stateActualI; stateActualI.Transitions.Add(transition); transition.To = state; var sir = new SimpleIncludeRule<Symbol>(symbolX, 1); // sir.Pertinence = item.Pertinence * Automa.States[i].GetValue<ValueState>().Rules[0].Pertinence; transition.Rule = sir; Automa.Transitions.Add(transition); change = true; } } } } } }
public ValueState Goto(ValueState i, Symbol x) { ValueState j = new ValueState(); foreach (var ruleI in i.Rules) { if (ruleI.Destiny.Contains(x)) { if (ruleI.Pointer < ruleI.Destiny.Count) { var destiny = ruleI.Destiny[ruleI.Pointer]; if (destiny == x) { RuleProductionState rule = new RuleProductionState(); rule.Id = ruleI.Id; rule.Source = ruleI.Source; rule.Lookahead = ruleI.Lookahead; rule.Destiny.AddRange(ruleI.Destiny); rule.Parent = ruleI.Parent; rule.Pertinence = ruleI.Pertinence; rule.TypeName = ruleI.TypeName; rule.Pointer = ruleI.Pointer + 1; rule.CalculateHash(); if (!j.HashCodeRules.ContainsKey(rule.HashCode)) { j.AddRule(rule); } } } } } return Closure(j); }
public ValueState Closure(ValueState state) { // ValueState returns = new ValueState(); bool change = true; //while (change) { change = false; // for (int i = 0; i < state.Rules.Count; i++) { //A->alphaBbeta, a Symbol A = state.Rules[i].Source; List<Symbol> alpha = state.Rules[i].Destiny.Take(state.Rules[i].Pointer).ToList(); if (alpha.Count == 0) { alpha.Add(Symbol.EmptySymbol); } Symbol B = Symbol.EmptySymbol; if (state.Rules[i].Destiny.Count > state.Rules[i].Pointer) { B = state.Rules[i].Destiny[state.Rules[i].Pointer]; } Symbol beta = Symbol.TapeFinal; if (state.Rules[i].Pointer + 1 < state.Rules[i].Destiny.Count) beta = state.Rules[i].Destiny[state.Rules[i].Pointer + 1]; Symbol a = state.Rules[i].Lookahead; var rolesB = GrammarLine.GetRules(B); for (int j = 0; j < rolesB.Count; j++) { var first = First(beta, a); for (int k = 0; k < first.Count; k++) { if (first[k].Terminal || first[k] == Symbol.TapeFinal) { RuleProductionState rule = new RuleProductionState(); rule.Id = rolesB[j].Id; rule.TypeName = rolesB[j].TypeName; rule.Source = B; rule.Destiny.AddRange(rolesB[j].Destiny); rule.Pointer = 0; rule.Lookahead = first[k]; rule.Parent = rolesB[j].Parent; rule.CalculateHash(); // state.Rules[i].Pertinence; if (!state.HashCodeRules.ContainsKey(rule.HashCode)) //if (!state.Rules.Any(r => r.Equals(rule))) { rule.Pertinence = rolesB[j].Pertinence;// *state.Rules[i].Pertinence;// 0.8; state.AddRule(rule); change = true; } } } } } } return state; }
internal void OnValueStateUpdate(ValueState state) { UpdateValueState(state); OnStateChange?.Invoke(this, Context.ContextParent); }
public Lazy(Func <T> valueFactory) { this.valueFactory = valueFactory; this.isThreadSafe = false; valueState = ValueState.NotCreated; }
public Lazy(Func <T> valueFactory, bool isThreadSafe) { this.valueFactory = valueFactory; this.isThreadSafe = isThreadSafe; valueState = ValueState.NotCreated; value = default !;
// ------------------------------------------------------------- #endregion ctor // ------------------------------------------------------------- #region methods // ------------------------------------------------------------- /** * Diese übernimmt das überwachen des Gpio */ public void Listen( ) { this.CurrentValue = this.ListenGpio.Value ? ValueState.HIGH : ValueState.LOW; }