private static CalendarDay GetLastCalendarDay(
this CalendarDay day)
{
var result = day;
return(result);
}
/// <summary>
/// Converts a <see cref="DateTime"/> into a <see cref="CalendarDay"/>.
/// </summary>
/// <param name="value">The date/time to convert.</param>
/// <returns>
/// A <see cref="CalendarDay"/> converted from a <see cref="DateTime"/>.
/// </returns>
public static CalendarDay ToCalendarDay(
this DateTime value)
{
var result = new CalendarDay(value.Year, (MonthOfYear)value.Month, (DayOfMonth)value.Day);
return(result);
}
private static CalendarDay GetLastCalendarDay(
this CalendarYear year)
{
var result = new CalendarDay(year.Year, MonthOfYear.December, DayOfMonth.ThirtyOne);
return(result);
}
private static CalendarDay GetFirstCalendarDay(
this CalendarYear year)
{
var result = new CalendarDay(year.Year, MonthOfYear.January, DayOfMonth.One);
return(result);
}
private static CalendarDay GetFirstCalendarDay(
this CalendarQuarter quarter)
{
var result = new CalendarDay(quarter.Year, (MonthOfYear)((((int)quarter.QuarterNumber - 1) * 3) + 1), DayOfMonth.One);
return(result);
}
private static CalendarDay GetFirstCalendarDay(
this CalendarMonth month)
{
var result = new CalendarDay(month.Year, month.MonthOfYear, DayOfMonth.One);
return(result);
}
private static CalendarDay GetLastCalendarDay(
this CalendarMonth month)
{
var daysInMonth = DateTime.DaysInMonth(month.Year, (int)month.MonthNumber);
var result = new CalendarDay(month.Year, month.MonthOfYear, (DayOfMonth)daysInMonth);
return(result);
}
private static CalendarDay Plus(
this CalendarDay unitOfTime,
int unitsToAdd)
{
var dayAsDateTime = unitOfTime.ToDateTime().AddDays(unitsToAdd);
var result = new CalendarDay(dayAsDateTime.Year, (MonthOfYear)dayAsDateTime.Month, (DayOfMonth)dayAsDateTime.Day);
return(result);
}
/// <inheritdoc />
/// <exception cref="ArgumentNullException"><paramref name="fiscalYear"/> is null.</exception>
public override ReportingPeriod <CalendarDay> GetReportingPeriodForFiscalYear(
FiscalYear fiscalYear)
{
if (fiscalYear == null)
{
throw new ArgumentNullException(nameof(fiscalYear));
}
var januaryFirst = new CalendarDay(fiscalYear.Year, MonthOfYear.January, DayOfMonth.One);
var decemberThirtyFirst = new CalendarDay(fiscalYear.Year, MonthOfYear.December, DayOfMonth.ThirtyOne);
var result = new ReportingPeriod <CalendarDay>(januaryFirst, decemberThirtyFirst);
return(result);
}
public static UnitOfTime DeserializeFromSortableString(
this string unitOfTime,
Type type)
{
if (!type.IsUnitOfTimeType())
{
throw new NotSupportedException(Invariant($"Unsupported type {type?.FullName ?? "<NULL TYPE>"}, expected an implmenter {nameof(UnitOfTime)}"));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (unitOfTime == null)
{
throw new ArgumentNullException(nameof(unitOfTime));
}
if (string.IsNullOrWhiteSpace(unitOfTime))
{
throw new ArgumentException(Invariant($"'{nameof(unitOfTime)}' is white space"));
}
var serializationFormatMatch = SerializationFormatByType.Select(_ => new { Match = _.Regex.Match(unitOfTime), SerializationFormat = _ }).SingleOrDefault(_ => _.Match.Success);
if (serializationFormatMatch == null)
{
throw new InvalidOperationException("Cannot deserialize string; it is not valid unit-of-time.");
}
var serializedType = serializationFormatMatch.SerializationFormat.Type;
if (!type.IsAssignableFrom(serializedType))
{
throw new InvalidOperationException(Invariant($"The unit-of-time appears to be a {serializedType.Name} which cannot be casted to a {type.Name}."));
}
string errorMessage = Invariant($"Cannot deserialize string; it appears to be a {serializedType.Name} but it is malformed.");
var tokens = serializationFormatMatch.SerializationFormat.Regex.GetGroupNames().Skip(1).Select(_ => serializationFormatMatch.Match.Groups[_].Value).ToArray();
if (serializedType == typeof(CalendarDay))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
var month = ParseEnumOrThrow <MonthOfYear>(tokens[1], errorMessage);
var day = ParseEnumOrThrow <DayOfMonth>(tokens[2], errorMessage);
try
{
var result = new CalendarDay(year, month, day);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(CalendarMonth))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
var month = ParseEnumOrThrow <MonthOfYear>(tokens[1], errorMessage);
try
{
var result = new CalendarMonth(year, month);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(CalendarQuarter))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
var quarter = ParseEnumOrThrow <QuarterNumber>(tokens[1], errorMessage);
try
{
var result = new CalendarQuarter(year, quarter);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(CalendarYear))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
try
{
var result = new CalendarYear(year);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(CalendarUnbounded))
{
var result = new CalendarUnbounded();
return(result);
}
if (serializedType == typeof(FiscalMonth))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
var month = ParseEnumOrThrow <MonthNumber>(tokens[1], errorMessage);
try
{
var result = new FiscalMonth(year, month);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(FiscalQuarter))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
var quarter = ParseEnumOrThrow <QuarterNumber>(tokens[1], errorMessage);
try
{
var result = new FiscalQuarter(year, quarter);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(FiscalYear))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
try
{
var result = new FiscalYear(year);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(FiscalUnbounded))
{
var result = new FiscalUnbounded();
return(result);
}
if (serializedType == typeof(GenericMonth))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
var month = ParseEnumOrThrow <MonthNumber>(tokens[1], errorMessage);
try
{
var result = new GenericMonth(year, month);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(GenericQuarter))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
var quarter = ParseEnumOrThrow <QuarterNumber>(tokens[1], errorMessage);
try
{
var result = new GenericQuarter(year, quarter);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(GenericYear))
{
var year = ParseIntOrThrow(tokens[0], errorMessage);
try
{
var result = new GenericYear(year);
return(result);
}
catch (ArgumentException)
{
throw new InvalidOperationException(errorMessage);
}
}
if (serializedType == typeof(GenericUnbounded))
{
var result = new GenericUnbounded();
return(result);
}
throw new NotSupportedException("this type of unit-of-time is not supported: " + serializedType);
}
private static CalendarDay GetLastCalendarDay(
this CalendarDay day)
{
return(day);
}
