public T ReadNext(TickTime previous)
{
TickTime time;
T result = ReadNext(out time, previous);
return(result);
}
public bool ExitWait(string key, long timeout_ms = -1, int intensity_ms = 1)
{
TickTime start = TickTime.Now;
if (!this.Contains(key))
{
return(false);
}
if (!intensity_ms.InClosedInterval(1, int.MaxValue))
{
intensity_ms = 1;
}
while (!this.Exit(key))
{
if (timeout_ms > 0 && TickTime.Timeout(start, timeout_ms, TickTime.Unit.ms))
{
return(false);
}
try
{
Thread.Sleep(intensity_ms);
}
catch// (Exception ex)
{
//Exceptions.Write(ex);
return(false);
}
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="Timeout">timeout</param>
/// <param name="Unit">timeout unit</param>
/// <param name="Start">timer start time</param>
/// <param name="Enabled">defines if timeout shoud be enabled</param>
public TickTimeout(long Timeout, TickTime.Unit Unit, TickTime Start, bool Enabled = true)
{
this.Start = Start;
this.Timeout = Timeout;
this.Unit = Unit;
this.Enabled = Enabled;
}
public bool GetLastObject(out T data)
{
TickTime first = TickTime.Now;
int index = -1;
lock (locker)
{
for (int i = 0; i < Length; i++)
{
if (Times[i] < first && Times[i] > TickTime.Default)
{
first = Times[i];
index = i;
continue;
}
}
if (index >= 0)
{
data = Elements[index];
return(true);
}
else
{
data = default(T);
return(false);
}
}
}
public bool Read(out T data, out TickTime time)
{
TickTime first = TickTime.Now;
int index = -1;
lock (locker)
{
for (int i = 0; i < Length; i++)
{
if (!Reads[i] && Times[i] < first && Times[i] > TickTime.MinValue)
{
first = Times[i];
index = i;
continue;
}
}
if (index >= 0)
{
data = Elements[index];
time = Times[index];
Reads[index] = true;
return(true);
}
else
{
data = default(T);
time = TickTime.Default;
return(false);
}
}
}
public bool EnterWait(long timeout_ms = -1, int intensity_ms = 1)
{
TickTime start = TickTime.Now;
if (!intensity_ms.InClosedInterval(1, int.MaxValue))
{
intensity_ms = 1;
}
while (!this.Enter())
{
if (timeout_ms > 0 && start.Timeout(timeout_ms))
{
return(false);
}
try
{
Thread.Sleep(intensity_ms);
}
catch
{
return(false);
}
}
return(true);
}
public bool WaitForResponse(DataType responseType, TickTime init, int timeout_ms, bool waitForAnyIsCaseSensitive, params string[] waitForAny)
{
if (waitForAny.IsNullOrEmpty())
{
return(false);
}
var timeout = new TickTimeout(timeout_ms, TickTime.Unit.ms);
while (!timeout.IsTriggered)
{
if ((responseType & DataType.Output) > 0 &&
waitForAny != null &&
(OutputData.Any(p => p.Key > init && p.Value.ContainsAny(waitForAny, waitForAnyIsCaseSensitive == true))))
{
return(true);
}
if ((responseType & DataType.Error) > 0 &&
waitForAny != null &&
(ErrorData.Any(p => p.Key > init && p.Value.ContainsAny(waitForAny, waitForAnyIsCaseSensitive == true))))
{
return(true);
}
Thread.Sleep(10);
}
return(false);
}
public void Write(T data, TickTime time)
{
Cleanup();
Buffer.Add(time.Copy(), data, true);
_TickerWrite.SetNow();
}
public void Start()
{
lock (locker)
{
_StartTime = TickTime.Now;
IsStarded = true;
}
}
public void Write(T data, TickTime time)
{
if (Size > 0 && Buffer.Count > Size)
{
this.Cleanup();
}
Buffer.Add(time.Copy(), data);
_TickerWrite.SetNow();
}
/* public KeyValuePair<TickTime, string>[] GetNextData(TickTime init)
* {
* var data = new List<KeyValuePair<TickTime, string>>();
* data.AddRange(GetNextOutputs(init));
* data.AddRange(GetNextErrors(init));
* data.AddRange(GetNextInputs(init));
* return data.ToArray();
* }*/
public TickTime GetNextPointer(TickTime init)
{
var data = this.GetNextData(DataType.Any, init);
if (data.IsNullOrEmpty())
{
return(TickTime.Default);
}
return(data.Min(x => x.Key));
}
public void Reset(bool startNow = false)
{
lock (locker)
{
//Clear ticks on start
_Ticks = 0;
if (startNow)
{
this.Start();
}
else
{
_StartTime = TickTime.Default;
IsStarded = false;
}
}
}
public KeyValuePair <TickTime, string>[] GetNextData(DataType type, TickTime init)
{
ThreadedDictionary <TickTime, string> data = new ThreadedDictionary <TickTime, string>();
if ((type & DataType.Input) > 0)
{
data.AddRange(InputData.ToDictionary());
}
if ((type & DataType.Error) > 0)
{
data.AddRange(ErrorData.ToDictionary());
}
if ((type & DataType.Output) > 0)
{
data.AddRange(OutputData.ToDictionary());
}
return(data?.Where(x => x.Key > init)?.Select(x => { return new KeyValuePair <TickTime, string>(x.Key.Copy(), x.Value); })?.ToArray() ?? new KeyValuePair <TickTime, string> [0]);
}
public T ReadNext(out TickTime time, TickTime previous)
{
T result = default(T);
time = previous.Copy();
var keys = Buffer.KeysArray;
foreach (var key in keys)
{
if (key > time)
{
time = key;
result = Buffer[key];
}
}
_TickerRead.SetNow();
return(result);
}
public TickTime WriteLine(string cmd, int timeout_ms)
{
lock (_locker)
{
TickTime ttOutput = TickTime.Now, ttError = TickTime.Now, ttInit = TickTime.Now;
Process.StandardInput.WriteLine(cmd);
if (!cmd.IsNullOrEmpty())
{
if (InputData.Count >= MaxInputDataLength)
{
InputData.Remove(OutputData.FirstKey);
}
InputData.Add(ttInit, cmd);
}
if (timeout_ms <= 0)
{
return(ttInit);
}
TickTimeout timeout = new TickTimeout(timeout_ms, TickTime.Unit.ms);
List <string> output = new List <string>(), error = new List <string>();
while (!timeout.IsTriggered && !Process.HasExited)
{
var outputKeys = OutputData.KeysArray;
if (ErrorData.Any(x => x.Key > ttInit) || OutputData.Any(x => x.Key > ttInit))
{
break;
}
Thread.Sleep(10);
}
return(ttInit);
}
}
public (DataType type, string value) GetData(TickTime time)
{
if (!time.IsDefault)
{
lock (_locker)
{
if (InputData.ContainsKey(time))
{
return(DataType.Input, InputData[time]);
}
if (ErrorData.ContainsKey(time))
{
return(DataType.Error, ErrorData[time]);
}
if (OutputData.ContainsKey(time))
{
return(DataType.Output, OutputData[time]);
}
}
}
return(DataType.None, null);
}
public static decimal TimeoutSpan(this TickTime start, long timeout, TickTime.Unit unit, TickTime.Unit unit_result)
{
return(TickTime.TimeoutSpan(start, timeout, unit, unit_result));
}
public static bool Timeout(this TickTime start, long timeout, TickTime.Unit unit = TickTime.Unit.ms)
{
return(TickTime.Timeout(start, timeout, unit));
}
public T ReadNext(TickTime previous)
{
return(ReadNext(out TickTime time, previous));
}
public T ReadLast(out TickTime time)
{
return(this.ReadNext(out time, TickTime.Default));
}