public Jpeg2000LosslessActionItem(int time, TimeUnit unit, Expression exprScheduledTime) : base("JPEG 2000 Lossless compression action") { _offsetTime = time; _units = unit; _exprScheduledTime = exprScheduledTime; }
public String Code(TimeUnit unit) { switch (unit) { case TimeUnit.SECONDS: return "sec"; case TimeUnit.MINUTES: return "min"; case TimeUnit.HOURS: return "hr"; case TimeUnit.DAYS: return "d"; case TimeUnit.WEEKS: return "w"; case TimeUnit.FORTNIGHTS: return "fn"; case TimeUnit.MONTHS: return "m"; case TimeUnit.YEARS: return "y"; case TimeUnit.DECADES: return "dec"; case TimeUnit.SCORES: return "sc"; case TimeUnit.CENTURIES: return "c"; case TimeUnit.MILLENNIA: return "m"; default: return "unk"; } }
public String Plural(TimeUnit unit) { switch (unit) { case TimeUnit.SECONDS: return "seconds"; case TimeUnit.MINUTES: return "minutes"; case TimeUnit.HOURS: return "hours"; case TimeUnit.DAYS: return "days"; case TimeUnit.WEEKS: return "weeks"; case TimeUnit.FORTNIGHTS: return "fortnights"; case TimeUnit.MONTHS: return "months"; case TimeUnit.YEARS: return "years"; case TimeUnit.DECADES: return "decades"; case TimeUnit.SCORES: return "scores"; case TimeUnit.CENTURIES: return "centures"; case TimeUnit.MILLENNIA: return "millennia"; default: return "unknowns"; } }
/// <summary> /// Turns a TimeSpan into a human readable form. E.g. 1 day. /// </summary> /// <param name="timeSpan"></param> /// <param name="precision">The maximum number of time units to return.</param> /// <param name="countEmptyUnits">Controls whether empty time units should be counted towards maximum number of time units. Leading empty time units never count.</param> /// <param name="culture">Culture to use. If null, current thread's UI culture is used.</param> /// <param name="maxUnit">The maximum unit of time to output.</param> /// <param name="minUnit">The minimum unit of time to output.</param> /// <returns></returns> public static string Humanize(this TimeSpan timeSpan, int precision, bool countEmptyUnits, CultureInfo culture = null, TimeUnit maxUnit = TimeUnit.Week, TimeUnit minUnit = TimeUnit.Millisecond) { var timeParts = CreateTheTimePartsWithUperAndLowerLimits(timeSpan, culture, maxUnit, minUnit); timeParts = SetPrecisionOfTimeSpan(timeParts, precision, countEmptyUnits); return ConcatenateTimeSpanParts(timeParts); }
private static string BuildFormatTimePart(IFormatter cultureFormatter, TimeUnit timeUnitType, int amountOfTimeUnits) { // Always use positive units to account for negative timespans return amountOfTimeUnits != 0 ? cultureFormatter.TimeSpanHumanize(timeUnitType, Math.Abs(amountOfTimeUnits)) : null; }
public String Plural(TimeUnit unit) { switch (unit) { case TimeUnit.Seconds: return "seconds"; case TimeUnit.Minutes: return "minutes"; case TimeUnit.Hours: return "hours"; case TimeUnit.Days: return "days"; case TimeUnit.Weeks: return "weeks"; case TimeUnit.Fortnights: return "fortnights"; case TimeUnit.Months: return "months"; case TimeUnit.Years: return "years"; case TimeUnit.Decades: return "decades"; case TimeUnit.Scores: return "scores"; case TimeUnit.Centuries: return "centures"; case TimeUnit.Millennia: return "millennia"; default: return "unknowns"; } }
public static void Verify(string expectedString, int unit, TimeUnit timeUnit, Tense tense) { var deltaFromNow = new TimeSpan(); unit = Math.Abs(unit); if (tense == Tense.Past) unit = -unit; switch (timeUnit) { case TimeUnit.Second: deltaFromNow = TimeSpan.FromSeconds(unit); break; case TimeUnit.Minute: deltaFromNow = TimeSpan.FromMinutes(unit); break; case TimeUnit.Hour: deltaFromNow = TimeSpan.FromHours(unit); break; case TimeUnit.Day: deltaFromNow = TimeSpan.FromDays(unit); break; case TimeUnit.Month: deltaFromNow = TimeSpan.FromDays(unit*31); break; case TimeUnit.Year: deltaFromNow = TimeSpan.FromDays(unit*366); break; } VerifyWithCurrentDate(expectedString, deltaFromNow); VerifyWithDateInjection(expectedString, deltaFromNow); }
/// <summary> /// Initializes a new instance of the <see cref=" Meter"/> class by using /// the specified meter name, rate unit and clock. /// </summary> /// <param name="config"> /// A <see cref="MetricConfig"/> containing the configuration settings /// for the metric. /// </param> /// <param name="rate_unit"> /// The time unit of the meter's rate. /// </param> /// <param name="context"> /// A <see cref="MetricContext"/> that contains the shared /// <see cref="Mailbox{T}"/> and <see cref="Clock"/>. /// </param> internal Meter(MetricConfig config, TimeUnit rate_unit, MetricContext context) : base(config, context) { const string kStatistic = "statistic"; mean_rate_ = new MeanRate( config.WithAdditionalTag(new Tag(kStatistic, "mean_rate")), rate_unit, context); ewma_1_rate_ = ExponentialWeightedMovingAverage .ForOneMinute( config.WithAdditionalTag(new Tag(kStatistic, "ewma_m1_rate")), rate_unit, context); ewma_5_rate_ = ExponentialWeightedMovingAverage .ForFiveMinutes( config.WithAdditionalTag(new Tag(kStatistic, "ewma_m5_rate")), rate_unit, context); ewma_15_rate_ = ExponentialWeightedMovingAverage .ForFifteenMinutes( config.WithAdditionalTag(new Tag(kStatistic, "ewma_m15_rate")), rate_unit, context); metrics_ = new ReadOnlyCollection<IMetric>( new IMetric[] { mean_rate_, ewma_1_rate_, ewma_5_rate_, ewma_15_rate_ }); }
/// <summary> /// Initializes a new instance of the <see cref="MarketMLDataSet"/> class. /// </summary> /// <param name="loader">The loader.</param> /// <param name="inputWindowSize">Size of the input window.</param> /// <param name="predictWindowSize">Size of the predict window.</param> /// <param name="unit">The time unit to use.</param> public MarketMLDataSet(IMarketLoader loader, int inputWindowSize, int predictWindowSize, TimeUnit unit) : base(inputWindowSize, predictWindowSize) { _loader = loader; SequenceGrandularity =unit; }
public TimeLine(c000069 p0) : base(p0) { this.f00027b = 10.0; this.f00027c = 2.5; this.f00000a = true; this.f0000b3 = TimeUnit.f0000b4; this.f000031 = 0.6f; this.f000033 = 0.6f; this.f00000b = 15; this.f00005b = new List<string>(); this.f000059 = null; this.f00087c = new float[1]; this.f00087d = new float[1]; this.f000069 = 0.0; this.f000074 = double.PositiveInfinity; this.f000075 = 0.0; this.f00007d = 100.0; base.f000031 = 10f; base.f000033 = 1.5f; this.f00002a = new c00006a(base.f000029); this.m000097(this.f00002a); this.f00002a.m000375(0.5f); this.f00002a.m000376(1f); this.f00002a.m00037f(new delegate06f(this.m0000a8)); this.f00002a.m000386(0f, this.m000150()); this.f00002a.f00002a = new struct055(0f, 0.8789063f); this.f00002a.f0000bf = new struct055(0.00390625f, 0.8789063f); this.f00002a.f0000c0 = new struct055(0.00390625f, 0.8828125f); this.f00002a.f000243 = new struct055(0f, 0.8828125f); this.f00002a.m00007f("TimeLine position bar"); this.m0003ae(); base.m0000d0(new delegate06f(this.m0000a6)); }
public virtual void addTrace(string name, long time, TimeUnit unit) { if (log.isTraceEnabled()) { log.trace("Trace: " + name + " - " + TimeUnit.MILLISECONDS.convert(time, unit) + " ms"); } }
/// <summary> /// Returns the string representation of the provided TimeSpan /// </summary> /// <param name="timeUnit">Must be less than or equal to TimeUnit.Week</param> /// <param name="unit"></param> /// <param name="strategy">Optional TimeSpanFormatStrategy, default is Long</param> /// <returns></returns> /// <exception cref="System.ArgumentOutOfRangeException">Is thrown when timeUnit is larger than TimeUnit.Week</exception> public virtual string TimeSpanHumanize(TimeUnit timeUnit, int unit, TimeSpanFormatStrategy strategy = TimeSpanFormatStrategy.Long) { if (timeUnit > TimeUnit.Week) throw new ArgumentOutOfRangeException("timeUnit", "There's no meaningful way to humanize passed timeUnit."); return GetResourceForTimeSpan(timeUnit, unit, strategy); }
public MarketMLDataSet(IMarketLoader loader, int inputWindowSize, int predictWindowSize, TimeUnit unit) : base(inputWindowSize, predictWindowSize) { this._xa2ee854ac63ea89c = new Dictionary<int, TemporalPoint>(); this._x5cd320770c3df353 = loader; this.SequenceGrandularity = unit; }
public String Code(TimeUnit unit) { switch (unit) { case TimeUnit.Seconds: return "sec"; case TimeUnit.Minutes: return "min"; case TimeUnit.Hours: return "hr"; case TimeUnit.Days: return "d"; case TimeUnit.Weeks: return "w"; case TimeUnit.Fortnights: return "fn"; case TimeUnit.Months: return "m"; case TimeUnit.Years: return "y"; case TimeUnit.Decades: return "dec"; case TimeUnit.Scores: return "sc"; case TimeUnit.Centuries: return "c"; case TimeUnit.Millennia: return "m"; default: return "unk"; } }
// ---------------------------------------------------------------------- public static DateTime CalcTimeMoment( DateTime baseMoment, TimeUnit offsetUnit, long offsetCount = 1, ITimeCalendar calendar = null ) { switch ( offsetUnit ) { case TimeUnit.Tick: return baseMoment.AddTicks( offsetCount ); case TimeUnit.Millisecond: DateTime offsetMillisecond = baseMoment.AddSeconds( offsetCount ); return TimeTrim.Millisecond( offsetMillisecond, offsetMillisecond.Millisecond ); case TimeUnit.Second: DateTime offsetSecond = baseMoment.AddSeconds( offsetCount ); return TimeTrim.Second( offsetSecond, offsetSecond.Second ); case TimeUnit.Minute: return new Minute(baseMoment, calendar).AddMinutes( ToInt( offsetCount ) ).Start; case TimeUnit.Hour: return new Hour( baseMoment, calendar ).AddHours( ToInt( offsetCount ) ).Start; case TimeUnit.Day: return new Day( baseMoment, calendar ).AddDays( ToInt( offsetCount ) ).Start; case TimeUnit.Week: return new Week( baseMoment, calendar ).AddWeeks( ToInt( offsetCount ) ).Start; case TimeUnit.Month: return new Month( baseMoment, calendar ).AddMonths( ToInt( offsetCount ) ).Start; case TimeUnit.Quarter: return new Quarter( baseMoment, calendar ).AddQuarters( ToInt( offsetCount ) ).Start; case TimeUnit.Halfyear: return new Halfyear( baseMoment, calendar ).AddHalfyears( ToInt( offsetCount ) ).Start; case TimeUnit.Year: return new Year( baseMoment, calendar ).AddYears( ToInt( offsetCount ) ).Start; default: throw new InvalidOperationException(); } }
/// <summary> /// Initializes a new instance of the <see cref="MarketMLDataSet"/> class. /// </summary> /// <param name="loader">The loader.</param> /// <param name="inputWindowSize">Size of the input window.</param> /// <param name="predictWindowSize">Size of the predict window.</param> /// <param name="unit">The time unit to use.</param> public MarketMLDataSet(IMarketLoader loader, Int64 inputWindowSize, Int64 predictWindowSize, TimeUnit unit) : base((int)inputWindowSize, (int)predictWindowSize) { _loader = loader; SequenceGrandularity =unit; }
public long GetSpan(TimeUnit unit) { switch (unit) { case TimeUnit.Ticks: return GetSpanTicks(); case TimeUnit.Seconds: return GetSpanSeconds(); case TimeUnit.Minutes: return GetSpanMinutes(); case TimeUnit.Hours: return GetSpanHours(); case TimeUnit.Days: return GetSpanDays(); case TimeUnit.Weeks: return GetSpanWeeks(); case TimeUnit.Fortnights: return GetSpanFortnights(); case TimeUnit.Months: return GetSpanMonths(); case TimeUnit.Years: return GetSpanYears(); case TimeUnit.Scores: return GetSpanScores(); case TimeUnit.Centuries: return GetSpanCenturies(); case TimeUnit.Millennia: return GetSpanMillennia(); default: return 0; } }
protected override void ReportTimer(string name, TimerValue value, Unit unit, TimeUnit rateUnit, TimeUnit durationUnit, MetricTags tags) { this.WriteMetricName(name); this.WriteValue("Active Sessions", value.ActiveSessions.ToString()); this.WriteMeter(value.Rate, unit, rateUnit); this.WriteHistogram(value.Histogram, unit, durationUnit); }
/// <summary> /// Calculate rate for the quantity of bytes and interval defined by this instance /// </summary> /// <param name="timeUnit">Unit of time to calculate rate for (defaults is per second)</param> /// <param name="format">The string format to use for the number of bytes</param> /// <returns></returns> public string Humanize(string format, TimeUnit timeUnit = TimeUnit.Second) { TimeSpan displayInterval; string displayUnit; if (timeUnit == TimeUnit.Second) { displayInterval = TimeSpan.FromSeconds(1); displayUnit = "s"; } else if (timeUnit == TimeUnit.Minute) { displayInterval = TimeSpan.FromMinutes(1); displayUnit = "min"; } else if (timeUnit == TimeUnit.Hour) { displayInterval = TimeSpan.FromHours(1); displayUnit = "hour"; } else throw new NotSupportedException("timeUnit must be Second, Minute, or Hour"); return new ByteSize(Size.Bytes / Interval.TotalSeconds * displayInterval.TotalSeconds) .Humanize(format) + '/' + displayUnit; }
public Domain.ISpectrum GetAveragedSpectrum(double startRt, double endRt, TimeUnit timeUnits, double mzLower, double mzUpper) { List<int> scanList = GetScanList(startRt, endRt); SpectrumList spectrumList = run.spectrumList; int timePoints = spectrumList.size(); List<Domain.ISpectrum> msValuesList = new List<Domain.ISpectrum>(); List<int> tempScanList = new List<int>(); if (scanList == null) { // If scan list is empty then take entire chromatographic range. for (int i = 0; i < timePoints; i++) { tempScanList.Add(i); } } else { tempScanList = scanList; } for (int i = 0; i < tempScanList.Count; i++) { msValuesList.Add(spectrumExtractor.GetSpectrum(tempScanList[i], timeUnits, mzLower, mzUpper)); } // Merge scans return SpectrumHelper.CreateAveragedSpectrum(msValuesList); }
/// <summary> /// ArrayFormat elapsed time to a nice format /// if (forceTimeUnit is null) /// the timeInSecond will be formated to min, ms, microSec or nanoSec base on its value /// otherwise /// it will display the timeInSecond in the forceTimeUnit /// </summary> public static string GetElapsedString(double timeInSecond, TimeUnit? forceTimeUnit = null) { if (forceTimeUnit.HasValue) { switch (forceTimeUnit) { case TimeUnit.MicroSecond: return (timeInSecond*1000000.0).ToString("0") + " mcs"; case TimeUnit.Second: return (timeInSecond).ToString("0.##") + " s"; default: return (timeInSecond*1000.0).ToString("0.##") + " ms"; } } if (timeInSecond >= 60) { return (timeInSecond/60.0).ToString("0.#") + " min"; } if (timeInSecond >= 1) { return timeInSecond.ToString("0.#") + " s"; } if (timeInSecond >= 0.001) { return (timeInSecond*1000.0).ToString("0") + " ms"; } if (timeInSecond >= 0.000001) { return (timeInSecond*1000000.0).ToString("0") + " mcs"; } return (timeInSecond*1000000000.0).ToString("0") + " ns"; }
protected override void ReportTimer(string name, TimerValue value, Unit unit, TimeUnit rateUnit, TimeUnit durationUnit) { var values = MeterValues(value.Rate.Scale(rateUnit), unit, rateUnit) .Concat(HistogramValues(value.Histogram.Scale(durationUnit), unit, durationUnit)); Write("Timer", name, values); }
/// <summary> /// Returns the string representation of the provided TimeSpan /// </summary> /// <param name="timeUnit">Must be less than or equal to TimeUnit.Week</param> /// <param name="unit"></param> /// <returns></returns> /// <exception cref="System.ArgumentOutOfRangeException">Is thrown when timeUnit is larger than TimeUnit.Week</exception> public virtual string TimeSpanHumanize(TimeUnit timeUnit, int unit) { if (timeUnit > TimeUnit.Week) throw new ArgumentOutOfRangeException(nameof(timeUnit), "There's no meaningful way to humanize passed timeUnit."); return GetResourceForTimeSpan(timeUnit, unit); }
public Jpeg2000LossyActionItem(int time, TimeUnit unit, Expression exprScheduledTime, float ratio) : base("JPEG 2000 Lossy compression action") { _offsetTime = time; _units = unit; _exprScheduledTime = exprScheduledTime; _ratio = ratio; }
protected override void ReportTimer(string name, TimerValue value, Unit unit, TimeUnit rateUnit, TimeUnit durationUnit, MetricTags tags) { var values = MeterValues(value.Rate, unit, rateUnit) .Concat(HistogramValues(value.Histogram, unit, durationUnit)) .Concat(new[] { new Value("Active Sessions", value.ActiveSessions) }); Write("Timer", name, values); }
public void Advance(TimeUnit unit, long value) { this.nanoseconds += unit.ToNanoseconds(value); if (Advanced != null) { Advanced(this, EventArgs.Empty); } }
/// <summary> /// 创建心跳时段。 /// </summary> /// <param name="thisTime"></param> /// <param name="timeUnit"></param> /// <param name="timeLength"></param> /// <returns></returns> public static BeatTimeRange CrateBeatTimeRange(DateTime thisTime, TimeUnit timeUnit, int timeLength) { BeatTimeRange timeRange = new BeatTimeRange(); FillTimeRange(timeRange, thisTime, timeUnit, timeLength); return timeRange; }
private void CheckConvertOneWay(double value1, TimeUnit unit1, double value2, TimeUnit unit2) { var convertedValue2 = TimeUnit.Convert(value1, unit1, unit2); output.WriteLine($"Expected: {value1} {unit1.Name} = {value2} {unit2.Name}"); output.WriteLine($"Actual: {value1} {unit1.Name} = {convertedValue2} {unit2.Name}"); output.WriteLine(""); Assert.Equal(value2, convertedValue2, 4); }
private schedule(Runnable task, long delay, TimeUnit unit) { Preconditions.checkState(isOpen.get(), "CloseableExecutorService is closed"); InternalFutureTask<void> futureTask = new InternalFutureTask<void>(new FutureTask<void>(task, null)); scheduledExecutorService.schedule(futureTask, delay, unit); return futureTask; }
public override void ReportMeter(string name, Meter meter, Unit unit, TimeUnit rateUnit) { this.callback(string.Format(@"Meter. Name:{0}. Value:{1} {2}/{3}/n" , name , meter.Value.ToString("F2", CultureInfo.InvariantCulture) , unit , rateUnit)); }
public static void AwaitForever(System.Func <bool> condition, long checkInterval, TimeUnit unit) { long sleep = unit.toNanos(checkInterval); do { if (condition()) { return; } LockSupport.parkNanos(sleep); } while (true); }
/// <summary> /// <p> /// Keep trying a limited number of times, waiting a growing amount of time between attempts, /// and then fail by re-throwing the exception. /// </summary> /// <remarks> /// <p> /// Keep trying a limited number of times, waiting a growing amount of time between attempts, /// and then fail by re-throwing the exception. /// The time between attempts is <code>sleepTime</code> mutliplied by a random /// number in the range of [0, 2 to the number of retries) /// </p> /// </remarks> public static RetryPolicy ExponentialBackoffRetry(int maxRetries, long sleepTime, TimeUnit timeUnit) { return(new RetryPolicies.ExponentialBackoffRetry(maxRetries, sleepTime, timeUnit)); }
public RetryUpToMaximumTimeWithFixedSleep(long maxTime, long sleepTime, TimeUnit timeUnit) : base((int)(maxTime / sleepTime), sleepTime, timeUnit) { }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static <EXCEPTION extends Exception> void awaitEx(ThrowingSupplier<bool,EXCEPTION> condition, long timeout, java.util.concurrent.TimeUnit unit) throws java.util.concurrent.TimeoutException, EXCEPTION public static void AwaitEx <EXCEPTION>(ThrowingSupplier <bool, EXCEPTION> condition, long timeout, TimeUnit unit) where EXCEPTION : Exception { AwaitEx(condition, timeout, unit, DEFAULT_POLL_INTERVAL, TimeUnit.MILLISECONDS); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static <EXCEPTION extends Exception> void awaitEx(ThrowingSupplier<bool,EXCEPTION> condition, long timeout, java.util.concurrent.TimeUnit unit, long pollInterval, java.util.concurrent.TimeUnit pollUnit) throws java.util.concurrent.TimeoutException, EXCEPTION public static void AwaitEx <EXCEPTION>(ThrowingSupplier <bool, EXCEPTION> condition, long timeout, TimeUnit unit, long pollInterval, TimeUnit pollUnit) where EXCEPTION : Exception { if (!TryAwaitEx(condition, timeout, unit, pollInterval, pollUnit)) { throw new TimeoutException("Waited for " + timeout + " " + unit + ", but " + condition + " was not accepted."); } }
/// <summary> /// Returns the string representation of the provided DateTime /// </summary> /// <param name="timeUnit"></param> /// <param name="timeUnitTense"></param> /// <param name="unit"></param> /// <returns></returns> public virtual string DateHumanize(TimeUnit timeUnit, Tense timeUnitTense, int unit) { return(GetResourceForDate(timeUnit, timeUnitTense, unit)); }
private string GetResourceForDate(TimeUnit unit, Tense timeUnitTense, int count) { string resourceKey = ResourceKeys.DateHumanize.GetResourceKey(unit, timeUnitTense: timeUnitTense, count: count); return(count == 1 ? Format(resourceKey) : Format(resourceKey, count)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static <TYPE> TYPE await(System.Func<TYPE> supplier, System.Predicate<TYPE> predicate, long timeout, java.util.concurrent.TimeUnit timeoutUnit, long pollInterval, java.util.concurrent.TimeUnit pollUnit) throws java.util.concurrent.TimeoutException public static TYPE Await <TYPE>(System.Func <TYPE> supplier, System.Predicate <TYPE> predicate, long timeout, TimeUnit timeoutUnit, long pollInterval, TimeUnit pollUnit) { return(AwaitEx(supplier.get, predicate.test, timeout, timeoutUnit, pollInterval, pollUnit)); }
private string GetResourceForTimeSpan(TimeUnit unit, int count) { string resourceKey = ResourceKeys.TimeSpanHumanize.GetResourceKey(unit, count); return(count == 1 ? Format(resourceKey) : Format(resourceKey, count)); }
/// <summary> /// <p> /// Keep trying a limited number of times, waiting a fixed time between attempts, /// and then fail by re-throwing the exception. /// </summary> /// <remarks> /// <p> /// Keep trying a limited number of times, waiting a fixed time between attempts, /// and then fail by re-throwing the exception. /// </p> /// </remarks> public static RetryPolicy RetryUpToMaximumCountWithFixedSleep(int maxRetries, long sleepTime, TimeUnit timeUnit) { return(new RetryPolicies.RetryUpToMaximumCountWithFixedSleep(maxRetries, sleepTime , timeUnit)); }
public RetryUpToMaximumCountWithProportionalSleep(int maxRetries, long sleepTime, TimeUnit timeUnit) : base(maxRetries, sleepTime, timeUnit) { }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static <EXCEPTION extends Exception> boolean tryAwaitEx(ThrowingSupplier<bool,EXCEPTION> condition, long timeout, java.util.concurrent.TimeUnit timeoutUnit, long pollInterval, java.util.concurrent.TimeUnit pollUnit, java.time.Clock clock) throws EXCEPTION public static bool TryAwaitEx <EXCEPTION>(ThrowingSupplier <bool, EXCEPTION> condition, long timeout, TimeUnit timeoutUnit, long pollInterval, TimeUnit pollUnit, Clock clock) where EXCEPTION : Exception { long deadlineMillis = clock.millis() + timeoutUnit.toMillis(timeout); long pollIntervalNanos = pollUnit.toNanos(pollInterval); do { if (condition.Get()) { return(true); } LockSupport.parkNanos(pollIntervalNanos); } while (clock.millis() < deadlineMillis); return(false); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static <EXCEPTION extends Exception> boolean tryAwaitEx(ThrowingSupplier<bool,EXCEPTION> condition, long timeout, java.util.concurrent.TimeUnit timeoutUnit, long pollInterval, java.util.concurrent.TimeUnit pollUnit) throws EXCEPTION public static bool TryAwaitEx <EXCEPTION>(ThrowingSupplier <bool, EXCEPTION> condition, long timeout, TimeUnit timeoutUnit, long pollInterval, TimeUnit pollUnit) where EXCEPTION : Exception { return(TryAwaitEx(condition, timeout, timeoutUnit, pollInterval, pollUnit, Clock.systemUTC())); }
/// <summary> /// Advances the given date of the given number of business days and /// returns the result. /// </summary> /// <remarks>The input date is not modified</remarks> public DateTime advance(DateTime d, int n, TimeUnit unit, BusinessDayConvention c = BusinessDayConvention.Following, bool endOfMonth = false) { if (d == null) { throw new ArgumentException("null date"); } if (n == 0) { return(adjust(d, c)); } else if (unit == TimeUnit.Days) { DateTime d1 = d; if (n > 0) { while (n > 0) { d1 = d1.AddDays(1); while (isHoliday(d1)) { d1 = d1.AddDays(1); } n--; } } else { while (n < 0) { d1 = d1.AddDays(-1); while (isHoliday(d1)) { d1 = d1.AddDays(-1); } n++; } } return(d1); } else if (unit == TimeUnit.Weeks) { DateTime d1 = d.AddDays(n * 7); return(adjust(d1, c)); } else if (unit == TimeUnit.Months) { DateTime d1 = d.AddMonths(n); if (endOfMonth && unit == TimeUnit.Months && isEndOfMonth(d)) { return(this.endOfMonth(d1)); } return(adjust(d1, c)); } else // Years { DateTime d1 = d.AddYears(n); if (endOfMonth && unit == TimeUnit.Years && isEndOfMonth(d)) { return(this.endOfMonth(d1)); } return(adjust(d1, c)); } }
public static string Name(this TimeUnit timeUnit) => timeUnit.AsString(EnumFormat.DisplayName);
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static <TYPE, EXCEPTION extends Exception> TYPE awaitEx(ThrowingSupplier<TYPE,? extends EXCEPTION> supplier, ThrowingPredicate<TYPE, ? extends EXCEPTION> predicate, long timeout, java.util.concurrent.TimeUnit timeoutUnit) throws java.util.concurrent.TimeoutException, EXCEPTION public static TYPE AwaitEx <TYPE, EXCEPTION, T1, T2>(ThrowingSupplier <T1> supplier, ThrowingPredicate <T2> predicate, long timeout, TimeUnit timeoutUnit) where EXCEPTION : Exception where T1 : EXCEPTION where T2 : EXCEPTION { Suppliers.ThrowingCapturingSupplier <TYPE, EXCEPTION> composed = Suppliers.Compose(supplier, predicate); AwaitEx(composed, timeout, timeoutUnit); return(composed.LastInput()); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static void await(System.Func<boolean> condition, long timeout, java.util.concurrent.TimeUnit timeoutUnit, long pollInterval, java.util.concurrent.TimeUnit pollUnit) throws java.util.concurrent.TimeoutException public static void Await(System.Func <bool> condition, long timeout, TimeUnit timeoutUnit, long pollInterval, TimeUnit pollUnit) { AwaitEx(condition.getAsBoolean, timeout, timeoutUnit, pollInterval, pollUnit); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static <TYPE> TYPE await(System.Func<TYPE> supplier, System.Predicate<TYPE> predicate, long timeout, java.util.concurrent.TimeUnit timeoutUnit) throws java.util.concurrent.TimeoutException public static TYPE Await <TYPE>(System.Func <TYPE> supplier, System.Predicate <TYPE> predicate, long timeout, TimeUnit timeoutUnit) { return(AwaitEx(throwingSupplier(supplier), throwingPredicate(predicate), timeout, timeoutUnit)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static void await(System.Func<boolean> condition, long timeout, java.util.concurrent.TimeUnit unit) throws java.util.concurrent.TimeoutException public static void Await(System.Func <bool> condition, long timeout, TimeUnit unit) { AwaitEx(condition.getAsBoolean, timeout, unit); }
public RetryUpToMaximumCountWithFixedSleep(int maxRetries, long sleepTime, TimeUnit timeUnit) : base(maxRetries, sleepTime, timeUnit) { }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public static <TYPE, EXCEPTION extends Exception> TYPE awaitEx(ThrowingSupplier<TYPE,EXCEPTION> supplier, ThrowingPredicate<TYPE,EXCEPTION> predicate, long timeout, java.util.concurrent.TimeUnit timeoutUnit, long pollInterval, java.util.concurrent.TimeUnit pollUnit) throws java.util.concurrent.TimeoutException, EXCEPTION public static TYPE AwaitEx <TYPE, EXCEPTION>(ThrowingSupplier <TYPE, EXCEPTION> supplier, ThrowingPredicate <TYPE, EXCEPTION> predicate, long timeout, TimeUnit timeoutUnit, long pollInterval, TimeUnit pollUnit) where EXCEPTION : Exception { Suppliers.ThrowingCapturingSupplier <TYPE, EXCEPTION> composed = Suppliers.Compose(supplier, predicate); AwaitEx(composed, timeout, timeoutUnit, pollInterval, pollUnit); return(composed.LastInput()); }
public static string Description(this TimeUnit timeUnit) => timeUnit.AsString(EnumFormat.Description);
/// <summary> /// Returns the rate in the given units of time. /// </summary> public double Rate(TimeUnit rateUnit) { var nanos = rateUnit.ToNanos(1); return(_rate * nanos); }
/// <summary> /// <p> /// Keep trying for a maximum time, waiting a fixed time between attempts, /// and then fail by re-throwing the exception. /// </summary> /// <remarks> /// <p> /// Keep trying for a maximum time, waiting a fixed time between attempts, /// and then fail by re-throwing the exception. /// </p> /// </remarks> public static RetryPolicy RetryUpToMaximumTimeWithFixedSleep(long maxTime, long sleepTime , TimeUnit timeUnit) { return(new RetryPolicies.RetryUpToMaximumTimeWithFixedSleep(maxTime, sleepTime, timeUnit )); }
[PublicAPI] public string ToTimeStr(TimeUnit unit = null, Encoding encoding = null) { encoding = encoding ?? Encoding.ASCII; return($"[P95: {P95.ToTimeStr(unit, encoding)}] [P0: {P0.ToTimeStr(unit, encoding)}]; [P50: {P50.ToTimeStr(unit, encoding)}]; [P100: {P100.ToTimeStr(unit, encoding)})]"); }
private MeterMetric(string eventType, TimeUnit rateUnit) { EventType = eventType; RateUnit = rateUnit; }
/// <summary> /// Delete banker's order /// </summary> public static string Init_HKCDL(ConnectionDetails connectionDetails, string OrderId, string Receiver, string ReceiverIBAN, string ReceiverBIC, decimal Amount, string Usage, DateTime FirstTimeExecutionDay, TimeUnit timeUnit, string Rota, int ExecutionDay) { Log.Write("Starting job HKCDL: Delete bankers order"); string segments = "HKCDL:" + SEGNUM.SETVal(3) + ":1+" + connectionDetails.IBAN + ":" + connectionDetails.BIC + "+urn?:iso?:std?:iso?:20022?:tech?:xsd?:pain.001.001.03+@@"; var sepaMessage = pain00100103.Create(connectionDetails.AccountHolder, connectionDetails.IBAN, connectionDetails.BIC, Receiver, ReceiverIBAN, ReceiverBIC, Amount, Usage, new DateTime(1999, 1, 1)).Replace("'", ""); segments = segments.Replace("@@", "@" + sepaMessage.Length + "@") + sepaMessage; segments += "++" + OrderId + "+" + FirstTimeExecutionDay.ToString("yyyyMMdd") + ":" + (char)timeUnit + ":" + Rota + ":" + ExecutionDay + "'"; segments = HKTAN.Init_HKTAN(segments); SEG.NUM = SEGNUM.SETInt(4); string message = FinTSMessage.Create(connectionDetails.HBCIVersion, Segment.HNHBS, Segment.HNHBK, connectionDetails.BlzPrimary, connectionDetails.UserId, connectionDetails.Pin, Segment.HISYN, segments, Segment.HIRMS, SEG.NUM); var TAN = FinTSMessage.Send(connectionDetails.Url, message); Segment.HITAN = Helper.Parse_String(Helper.Parse_String(TAN, "HITAN", "'").Replace("?+", "??"), "++", "+").Replace("??", "?+"); Helper.Parse_Message(TAN); return(TAN); }
public IActionItem <ServerActionContext> Compile(XmlElement xmlNode) { if (xmlNode.Attributes["time"] == null) { throw new XmlActionCompilerException( "Unexpected missing time attribute for jpeg-extended scheduling action"); } if (xmlNode.Attributes["unit"] == null) { throw new XmlActionCompilerException( "Unexpected missing unit attribute for jpeg-extended scheduling action"); } int quality; if (false == int.TryParse(xmlNode.Attributes["quality"].Value, out quality)) { throw new XmlActionCompilerException("Unable to parse quality value for jpeg-extended scheduling rule"); } int time; if (false == int.TryParse(xmlNode.Attributes["time"].Value, out time)) { throw new XmlActionCompilerException("Unable to parse time value for jpeg-extended scheduling rule"); } string xmlUnit = xmlNode.Attributes["unit"].Value; // this will throw exception if the unit is not defined TimeUnit unit = (TimeUnit)Enum.Parse(typeof(TimeUnit), xmlUnit, true); string refValue = xmlNode.Attributes["refValue"] != null ? xmlNode.Attributes["refValue"].Value : null; bool convertFromPalette = false; if (xmlNode.Attributes["convertFromPalette"] != null) { if (false == bool.TryParse(xmlNode.Attributes["convertFromPalette"].Value, out convertFromPalette)) { throw new XmlActionCompilerException("Unable to parse convertFromPalette value for jpeg-extended scheduling rule"); } } if (!String.IsNullOrEmpty(refValue)) { if (xmlNode["expressionLanguage"] != null) { string language = xmlNode["expressionLanguage"].Value; Expression scheduledTime = CreateExpression(refValue, language); return(new JpegExtendedActionItem(time, unit, scheduledTime, quality, convertFromPalette)); } else { Expression scheduledTime = CreateExpression(refValue); return(new JpegExtendedActionItem(time, unit, scheduledTime, quality, convertFromPalette)); } } return(new JpegExtendedActionItem(time, unit, quality, convertFromPalette)); }
public void Advance(TimeUnit unit, long value) { // DEVNOTE: Use test clock to advance the timer for testing purposes }
/// <summary>Creates a new away time that measures the time in the specified time unit.</summary> public NumberAwayTime(TimeUnit unit) { TimeUnit = unit; }