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