/// <summary>
/// this constructor enables timeout if it is possible (timeout > 0), else timeout is disabled
/// </summary>
/// <param name="Timeout"></param>
/// <param name="Unit"></param>
public TickTimeout(long Timeout, TickTime.Unit Unit)
{
this.Start = TickTime.Now;
this.Timeout = Timeout;
this.Unit = Unit;
this.Enabled = (Timeout > 0);
}
/// <summary>
/// Waits for timeout
/// </summary>
/// <param name="start"></param>
/// <param name="timeout"></param>
/// <param name="unit"></param>
/// <param name="intensity"></param>
public static void Sleep(TickTime start, long timeout, TickTime.Unit timeoutUnit = TickTime.Unit.ms)
{
if (timeoutUnit < TickTime.Unit.ms)
{
throw new Exception("timeoutUnit is to small, must be greater or equal to ms");
}
long end = start.Ticks + ((long)timeoutUnit * timeout);
long now = TickTime.NowTicks;
if (end <= now)
{
return;
}
/*while (end > now)
* {
* Thread.Sleep(1);
* now = TickTime.NowTicks;
* }*/
long wait = end - now;
int sleep = (int)(wait / (long)TickTime.Unit.ms);
if (sleep <= 0)
{
return;
}
Thread.Sleep(sleep);
}
/// <summary>
/// Start time is set to now
/// </summary>
/// <param name="Timeout"></param>
/// <param name="Unit"></param>
public TickTimeout(long Timeout, TickTime.Unit Unit, bool Enabled)
{
this.Start = TickTime.Now;
this.Timeout = Timeout;
this.Unit = Unit;
this.Enabled = Enabled;
}
/// <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 ThreadedAntiFlood(TickTime Start, long Interval, TickTime.Unit Unit)
{
this.Start = Start;
this.Interval = Interval;
this.Unit = Unit;
locker = new object();
}
public void SetTimeout(long Timeout, TickTime.Unit Unit)
{
lock (locker)
{
this.Timeout = Timeout;
this.Unit = Unit;
}
}
public void WaitForResponse(int timeout, TickTime.Unit unit = TickTime.Unit.ms)
{
TickTime start = TickTime.Now;
while (!TickTime.Timeout(start, timeout, unit) && !Compleated)
{
Thread.Sleep(100);
}
}
public int StartSpan(TickTime.Unit unit = TickTime.Unit.ms)
{
if (TimeStart.IsUndefined)
{
return(-1);
}
return((int)(TimeStart.Span() / (long)unit));
}
public static int GetBase(this TickTime.Unit unit)
{
switch (unit)
{
case TickTime.Unit.us: return(1000);
case TickTime.Unit.ms: return(1000);
case TickTime.Unit.s: return(60);
case TickTime.Unit.m: return(60);
case TickTime.Unit.h: return(24);
case TickTime.Unit.d: return(7);
case TickTime.Unit.w: return(1);
default: return(-1);
}
}
public static void Sleep(ref TickTime start, long timeout, TickTime.Unit timeoutUnit = TickTime.Unit.ms)
{
if (timeoutUnit < TickTime.Unit.ms)
{
throw new Exception("timeoutUnit is to small, must be greater or equal to ms");
}
long end = start.Ticks + ((long)timeoutUnit * timeout);
long now = TickTime.NowTicks;
if (end <= now)
{
return;
}
while (end > now)
{
Thread.Sleep(1);
end = start.Ticks + ((long)timeoutUnit * timeout);
now = TickTime.NowTicks;
}
}
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 TickBuffer(int size, long timeout, TickTime.Unit unit = TickTime.Unit.ms)
{
this.Size = size;
this.Timeout = timeout;
this.TimeoutUnit = unit;
}
//---------------------------------------------------------------------------
// ADD NOW
//---------------------------------------------------------------------------
public static TickTime AddNow(long value, TickTime.Unit unit)
{
return(new TickTime(TickTime.NowTicks + (value * (long)unit)));
}
public TickTime Add(long value, TickTime.Unit unit)
{
return(new TickTime(this.Ticks + (value * (long)unit)));
}
public decimal Span(TickTime.Unit unit)
{
return((decimal)(TickTime.Now.Ticks - this.Ticks) / (decimal)unit);
}
