public TimePartLocalization(TimePart part, string singular, string plural, string abbreviation)
{
Singular = singular;
Plural = plural;
Abbreviation = abbreviation;
Part = part;
}
public long Dividend(TimePart format)
{
long time = Milliseconds;
if (format == TimePart.Millionth)
{
time = this.Milliseconds / perMillion;
}
else
if (format == TimePart.Thousanth)
{
time = this.Milliseconds / perThousand;
}
else
if (format == TimePart.Second)
{
time = this.Milliseconds / perSecond;
}
else
if (format == TimePart.Minute)
{
time = this.Milliseconds / perMinute;
}
else
if (format == TimePart.Hour)
{
time = this.Milliseconds / perHour;
}
else
if (format == TimePart.Day)
{
time = this.Milliseconds / perDay;
}
return(new TimeFormat(time));
}
public TimeFormat(int value, TimePart part)
{
switch (part)
{
case TimePart.Millionth:
Milliseconds = (value);
break;
case TimePart.Thousanth:
Milliseconds = (value * perThousand);
break;
case TimePart.Second:
Milliseconds = (value * perSecond);
break;
case TimePart.Minute:
Milliseconds = (value * perMinute);
break;
case TimePart.Hour:
Milliseconds = (value * perHour);
break;
case TimePart.Day:
Milliseconds = (value * perDay);
break;
default:
break;
}
}
public static double DateTimeToDouble(DateTime dateTime, TimePart timePart)
{
double ticks = dateTime.Ticks;
switch (timePart)
{
case TimePart.Tick:
return ticks;
case TimePart.Second:
return ticks / TimeSpan.TicksPerSecond;
case TimePart.Minute:
return ticks / TimeSpan.TicksPerMinute;
case TimePart.Hour:
return ticks / TimeSpan.TicksPerHour;
case TimePart.Day:
return ticks / TimeSpan.TicksPerDay;
default:
return ticks / TimeSpan.TicksPerMillisecond;
}
}
/// <summary>
/// Creates a new absolute time format.
/// </summary>
/// <param name="token">The string expression of the absolute time format.</param>
/// <remarks>To create the format, use a string such as "[h], [m], [s]".</remarks>
public ABSTimeFormatPart(string token) : base(token)
{
if (!EvaluateFormat(token))
{
throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError);
}
this.token = token.ToLower();
if (this.token[1] == HoursABSContent)
{
this.type = TimePart.Hour;
}
else if (this.token[1] == MinuteABSContent)
{
this.type = TimePart.Minute;
}
else
{
if (this.token[1] != SecondABSContent)
{
throw new ArgumentException(ResourceStrings.FormatterIllegaTokenError);
}
this.type = TimePart.Second;
}
StringBuilder builder = new StringBuilder();
for (int i = 0; i < (this.token.Length - 2); i++)
{
builder.Append("0");
}
this.formatString = builder.ToString();
}
public static DateTime Add(this DateTime date, TimePart part, int value)
{
switch (part)
{
case TimePart.Millisecond:
return(date.AddMilliseconds(value));
case TimePart.Second:
return(date.AddSeconds(value));
case TimePart.Minute:
return(date.AddMinutes(value));
case TimePart.Hour:
return(date.AddHours(value));
case TimePart.Day:
return(date.AddDays(value));
case TimePart.Week:
return(date.AddDays(7 * value));
case TimePart.Decade:
return(date.AddDays(10 * value));
case TimePart.Fortnight:
return(date.AddDays(14 * value));
default:
return(date);
}
}
public long Multiply(long value, TimePart part)
{
long time = Milliseconds;
switch (part)
{
case TimePart.Millionth:
time *= (value);
break;
case TimePart.Thousanth:
time *= (value * perThousand);
break;
case TimePart.Second:
time *= (value * perSecond);
break;
case TimePart.Minute:
time *= (value * perMinute);
break;
case TimePart.Hour:
time *= (value * perHour);
break;
case TimePart.Day:
time *= (value * perDay);
break;
default:
break;
}
return(new TimeFormat(time));
}
/// <summary>
/// The do optimize time ratio.
/// </summary>
/// <param name="interval">
/// The interval.
/// </param>
/// <param name="units">
/// The units.
/// </param>
/// <param name="timePart">
/// The time part.
/// </param>
/// <returns>
/// The <see cref="double"/>.
/// </returns>
private static double DoOptimizeTimeRatio(TimeSpan interval, double units, out TimePart timePart)
{
if ((interval.TotalMilliseconds >= 1.0) && (units > 0.0))
{
while (units < 1.0)
{
var totalDays = interval.TotalDays;
if (totalDays >= 1.0)
{
timePart = TimePart.Days;
return(units / totalDays);
}
interval = interval.Multiply(10L);
units *= 10.0;
}
timePart = TimePart.Milliseconds;
var num2 = units / interval.TotalMilliseconds;
while (num2 < 1.0)
{
switch (timePart)
{
case TimePart.Milliseconds:
num2 *= 1000.0;
timePart = TimePart.Seconds;
break;
case TimePart.Seconds:
num2 *= 60.0;
timePart = TimePart.Minutes;
break;
case TimePart.Minutes:
num2 *= 60.0;
timePart = TimePart.Hours;
break;
case TimePart.Hours:
num2 *= 24.0;
timePart = TimePart.Days;
break;
case TimePart.Days:
return(num2);
}
}
return(num2);
}
timePart = TimePart.Undefined;
return(double.NaN);
}
public TimeSpanFormatter(
ITimeLocalization?localization = default,
TimePart precision = TimePart.Second,
bool compact = false,
string separator = ", ")
{
Localization = localization ?? TimeLocalization.Create("en");
Precision = precision;
Compact = compact;
Separator = separator;
}
public static Booking Create(string contactId, DateTime date, TimePart startTime, TimeSpan length, Room room, Rate rate, Product product)
{
return new Booking
{
MainContactId = contactId,
Date = date,
StartTime = startTime,
Length = length,
Rooms = new List<Room> { room },
Rate = rate,
Product = product
};
}
/// <summary>
/// Convenient function to format a TimeSpan to something like "1 week, 2 hours"
/// </summary>
/// <param name="timeSpan">value to format</param>
/// <param name="twoLetterLanguageCode">used localization for the formatted string</param>
/// <param name="precision">precision of the formatted string</param>
/// <param name="compact">use abbreviations for the units</param>
/// <param name="separator">used separator between parts</param>
/// <returns></returns>
public static string ToFormattedString(
this TimeSpan timeSpan,
string twoLetterLanguageCode = "en",
TimePart precision = TimePart.Minute,
bool compact = false,
string separator = ", ")
{
return(new TimeSpanFormatter(
localization: TimeLocalization.Create(twoLetterLanguageCode),
precision: precision,
compact: compact,
separator: separator)
.WriteToString(timeSpan));
}
/// <summary>
/// Attempt to match a time part.
/// </summary>
/// <param name="expected">The time part that is expected.</param>
/// <returns>true if the time part could be matched, false if not.</returns>
bool TryMakeTimePart(TimePart expected)
{
var dictionary = new Dictionary <string, TimePart>
{
{ "y", TimePart.Year },
{ "mo", TimePart.Month },
{ "d", TimePart.Day },
{ "h", TimePart.Hour },
{ "m", TimePart.Minute },
{ "s", TimePart.Second },
};
Enumerator.TakeWhile(TokenKind.Space);
TimePart part;
return(dictionary.TryGetValue(Enumerator.Take().Text, out part) && part == expected);
}
public long Remainder(TimePart format)
{
long tday, thour, tmin, tsec, ttsec, tmsec;
//
tday = Dividend(TimePart.Day);
thour = Dividend(TimePart.Hour);
tmin = Dividend(TimePart.Minute);
tsec = Dividend(TimePart.Second);
ttsec = Dividend(TimePart.Thousanth);
tmsec = Dividend(TimePart.Millionth);
if (format == TimePart.Millionth)
{
return(this - (tsec * perSecond));
}
else
if (format == TimePart.Thousanth)
{
return((this - (tsec * perSecond)) / perThousand);
}
else
if (format == TimePart.Second)
{
return(tsec % 60);
}
else
if (format == TimePart.Minute)
{
return(tmin % 60);
}
else
if (format == TimePart.Hour)
{
return(thour % 24);
}
else
if (format == TimePart.Day)
{
return(tday);
}
return(0);
}
private void WriteValue(
TextWriter writer,
TimePart part,
int value)
{
var force = part == Precision;
if (!_outputStarted && value == 0 && !force)
{
return;
}
if (_outputStarted)
{
writer.Write(Separator);
}
_outputStarted = true;
Localization
.GetPartLocalization(part)
.WriteValue(writer, value, Compact);
}
public static TimeSpan DoubleToTimeSpan(double value, TimePart timePart)
{
switch (timePart)
{
case TimePart.Tick:
return TimeSpan.FromTicks((long)value);
case TimePart.Minute:
return TimeSpan.FromMinutes(value);
case TimePart.Second:
return TimeSpan.FromSeconds(value);
case TimePart.Hour:
return TimeSpan.FromHours(value);
case TimePart.Day:
return TimeSpan.FromDays(value);
default:
return TimeSpan.FromMilliseconds(value);
}
}
/// <summary>
/// The time span to double.
/// </summary>
/// <param name="value">
/// The value.
/// </param>
/// <param name="timePart">
/// The time part.
/// </param>
/// <returns>
/// The <see cref="double"/>.
/// </returns>
public static double TimeSpanToDouble(TimeSpan value, TimePart timePart)
{
switch (timePart)
{
case TimePart.Milliseconds:
return(value.TotalMilliseconds);
case TimePart.Seconds:
return(value.TotalSeconds);
case TimePart.Minutes:
return(value.TotalMinutes);
case TimePart.Hours:
return(value.TotalHours);
case TimePart.Days:
return(value.TotalDays);
}
ThrowTimeSpanConversionError(timePart);
return(double.NaN);
}
/// <summary>
/// The double to time span.
/// </summary>
/// <param name="value">
/// The value.
/// </param>
/// <param name="timePart">
/// The time part.
/// </param>
/// <returns>
/// The <see cref="TimeSpan"/>.
/// </returns>
public static TimeSpan DoubleToTimeSpan(double value, TimePart timePart)
{
switch (timePart)
{
case TimePart.Milliseconds:
return(TimeSpan.FromMilliseconds(value));
case TimePart.Seconds:
return(TimeSpan.FromSeconds(value));
case TimePart.Minutes:
return(TimeSpan.FromMinutes(value));
case TimePart.Hours:
return(TimeSpan.FromHours(value));
case TimePart.Days:
return(TimeSpan.FromDays(value));
}
ThrowTimeSpanConversionError(timePart);
return(TimeSpan.Zero);
}
public static DateTime DoubleToDateTime(double value, TimePart timePart)
{
switch (timePart)
{
case TimePart.Tick:
return new DateTime((long)value);
case TimePart.Second:
return new DateTime((long)(TimeSpan.TicksPerSecond * value));
case TimePart.Minute:
return new DateTime((long)(TimeSpan.TicksPerMinute * value));
case TimePart.Hour:
return new DateTime((long)(TimeSpan.TicksPerHour * value));
case TimePart.Day:
return new DateTime((long)(TimeSpan.TicksPerDay * value));
default:
return new DateTime((long)(TimeSpan.TicksPerMillisecond * value));
}
}
public int Parse(string input, TimePart timePart)
{
var match = _timeRegex.Match(input);
return(int.Parse(match.Groups[timePart.ToString()].Value));
}
protected ATimeParser(TimePart timePart)
{
_timePart = timePart;
}
public SetTimerEventArgs(TimePart timePart)
{
TimePart = timePart;
}
/// <summary>
/// The throw time span conversion error.
/// </summary>
/// <param name="timePart">
/// The time part.
/// </param>
/// <exception cref="InvalidCastException">
/// </exception>
private static void ThrowTimeSpanConversionError(TimePart timePart)
{
throw new InvalidCastException(string.Format("Неизвестный тип преобразования: {0}", timePart));
}
/// <summary>
/// The time span to string.
/// </summary>
/// <param name="value">
/// The value.
/// </param>
/// <param name="timePart">
/// The time part.
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
public static string TimeSpanToString(TimeSpan value, TimePart timePart)
{
return(TimeSpanToDouble(value, timePart).ToString());
}
void DrawTimeTrackGrid(List<TimeTrackPart> timeTrackParts, Grid grid)
{
if (timeTrackParts.Count > 0)
{
double current = 0;
var timeParts = new List<TimePart>();
for (int i = 0; i < timeTrackParts.Count; i++)
{
var timeTrackPart = timeTrackParts[i];
var startTimePart = new TimePart();
startTimePart.Delta = timeTrackPart.StartTime.TotalSeconds - current;
startTimePart.IsInterval = false;
timeParts.Add(startTimePart);
var endTimePart = new TimePart();
endTimePart.Delta = timeTrackPart.EndTime.TotalSeconds - timeTrackPart.StartTime.TotalSeconds;
endTimePart.IsInterval = timeTrackPart.TimeTrackPartType != TimeTrackType.None;
endTimePart.TimeTrackType = timeTrackPart.TimeTrackPartType;
endTimePart.Tooltip = timeTrackPart.Tooltip;
timeParts.Add(endTimePart);
current = timeTrackPart.EndTime.TotalSeconds;
}
var lastTimePart = new TimePart();
lastTimePart.Delta = 24 * 60 * 60 - current;
lastTimePart.IsInterval = false;
timeParts.Add(lastTimePart);
DrawGrid(timeParts, grid);
}
}
/// <summary>
/// The string to time span.
/// </summary>
/// <param name="strValue">
/// The str value.
/// </param>
/// <param name="timePart">
/// The time part.
/// </param>
/// <returns>
/// The <see cref="TimeSpan"/>.
/// </returns>
public static TimeSpan StringToTimeSpan(string strValue, TimePart timePart)
{
return(DoubleToTimeSpan(StringToValue <double>(strValue), timePart));
}
public static Duration DoubleToDuration(double value, TimePart timePart)
{
return new Duration(DoubleToTimeSpan(value, timePart));
}
/// <summary>
/// Attempt to make a decimal duration segment.
/// </summary>
/// <param name="expected">The time part that was expected.</param>
/// <param name="duration">The decimal duration that was made.</param>
/// <returns>true if the decimal duration was made, false if not.</returns>
bool TryMakeSegment(TimePart expected, out decimal duration)
{
Enumerator.TakeWhile(TokenKind.Space);
return(TryMakeDecimal(out duration) && TryMakeTimePart(expected));
}
public ITimePartLocalization GetPartLocalization(TimePart part)
{
return(_dictionary[part]);
}
public static double TimeSpanToDouble(TimeSpan value, TimePart timePart)
{
switch (timePart)
{
case TimePart.Tick:
return value.Ticks;
case TimePart.Second:
return value.TotalSeconds;
case TimePart.Minute:
return value.TotalMinutes;
case TimePart.Hour:
return value.TotalHours;
case TimePart.Day:
return value.TotalDays;
default:
return value.TotalMilliseconds;
}
}
public static double DurationToDouble(Duration value, TimePart timePart)
{
if (value.HasTimeSpan)
{
return TimeSpanToDouble(value.TimeSpan, timePart);
}
return 0.0;
}
