/// <summary>
/// Initializes a new instance of the <see cref="ReportingPeriod"/> class.
/// </summary>
/// <param name="start">The start of the reporting period.</param>
/// <param name="end">The end of the reporting period.</param>
/// <exception cref="ArgumentNullException"><paramref name="start"/> or <paramref name="end"/> are null.</exception>
/// <exception cref="ArgumentException"><paramref name="start"/> and <paramref name="end"/> are bounded and are different concrete types of units-of-time.</exception>
/// <exception cref="ArgumentException"><paramref name="start"/> and/or <paramref name="end"/> is unbounded and are different kinds of units-of-time.</exception>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="start"/> is greater than <paramref name="end"/>.</exception>
public ReportingPeriod(
UnitOfTime start,
UnitOfTime end)
{
if (start == null)
{
throw new ArgumentNullException(nameof(start));
}
if (end == null)
{
throw new ArgumentNullException(nameof(end));
}
if ((start is IAmUnboundedTime) || (end is IAmUnboundedTime))
{
if (start.UnitOfTimeKind != end.UnitOfTimeKind)
{
throw new ArgumentException(Invariant($"{nameof(start)} and/or {nameof(end)} is unbounded and are different kinds of units-of-time."));
}
}
else
{
if (start.GetType() != end.GetType())
{
throw new ArgumentException(Invariant($"{nameof(start)} and {nameof(end)} are bounded and are different concrete types of units-of-time."));
}
if (start > end)
{
throw new ArgumentOutOfRangeException(nameof(start), Invariant($"{nameof(start)} is greater than {nameof(end)}."));
}
}
this.Start = start;
this.End = end;
}
/// <inheritdoc />
public override RelativeSortOrder CompareToForRelativeSortOrder(UnitOfTime other)
{
if (ReferenceEquals(other, null))
{
return(RelativeSortOrder.ThisInstanceFollowsTheOtherInstance);
}
if (!(other is CalendarMonth otherAsCalendarMonth))
{
throw new ArgumentException(Invariant($"Attempting to compare objects of different types. This object is of type 'CalendarMonth' whereas the other object is of type '{other.GetType().ToStringReadable()}'."));
}
var result = this.CompareToForRelativeSortOrder(otherAsCalendarMonth);
return(result);
}
/// <summary>
/// Serializes a <see cref="UnitOfTime"/> to a sortable string.
/// </summary>
/// <param name="unitOfTime">The unit-of-time to serialize.</param>
/// <returns>
/// Gets a string representation of a unit-of-time that can be deserialized
/// into the same unit-of-time and which sorts in the same way that the
/// other unit-of-times (of the same type) would sort (earlier time first, later time last).
/// </returns>
/// <exception cref="ArgumentNullException"><paramref name="unitOfTime"/> is null.</exception>
public static string SerializeToSortableString(
this UnitOfTime unitOfTime)
{
if (unitOfTime == null)
{
throw new ArgumentNullException(nameof(unitOfTime));
}
var unitOfTimeType = unitOfTime.GetType();
switch (unitOfTime)
{
case CalendarDay unitOfTimeAsCalendarDay:
{
var result = Invariant($"c-{unitOfTimeAsCalendarDay.Year:D4}-{(int)unitOfTimeAsCalendarDay.MonthNumber:D2}-{(int)unitOfTimeAsCalendarDay.DayOfMonth:D2}");
return(result);
}
case CalendarMonth unitOfTimeAsCalendarMonth:
{
var result = Invariant($"c-{unitOfTimeAsCalendarMonth.Year:D4}-{(int)unitOfTimeAsCalendarMonth.MonthNumber:D2}");
return(result);
}
case CalendarQuarter unitOfTimeAsCalendarQuarter:
{
var result = Invariant($"c-{unitOfTimeAsCalendarQuarter.Year:D4}-Q{(int)unitOfTimeAsCalendarQuarter.QuarterNumber}");
return(result);
}
case CalendarYear unitOfTimeAsCalendarYear:
{
var result = Invariant($"c-{unitOfTimeAsCalendarYear.Year:D4}");
return(result);
}
case CalendarUnbounded _:
{
var result = "c-unbounded";
return(result);
}
case FiscalMonth unitOfTimeAsFiscalMonth:
{
var result = Invariant($"f-{unitOfTimeAsFiscalMonth.Year:D4}-{(int)unitOfTimeAsFiscalMonth.MonthNumber:D2}");
return(result);
}
case FiscalQuarter unitOfTimeAsFiscalQuarter:
{
var result = Invariant($"f-{unitOfTimeAsFiscalQuarter.Year:D4}-Q{(int)unitOfTimeAsFiscalQuarter.QuarterNumber}");
return(result);
}
case FiscalYear unitOfTimeAsFiscalYear:
{
var result = Invariant($"f-{unitOfTimeAsFiscalYear.Year:D4}");
return(result);
}
case FiscalUnbounded _:
{
var result = "f-unbounded";
return(result);
}
case GenericMonth unitOfTimeAsGenericMonth:
{
var result = Invariant($"g-{unitOfTimeAsGenericMonth.Year:D4}-{(int)unitOfTimeAsGenericMonth.MonthNumber:D2}");
return(result);
}
case GenericQuarter unitOfTimeAsGenericQuarter:
{
var result = Invariant($"g-{unitOfTimeAsGenericQuarter.Year:D4}-Q{(int)unitOfTimeAsGenericQuarter.QuarterNumber}");
return(result);
}
case GenericYear unitOfTimeAsGenericYear:
{
var result = Invariant($"g-{unitOfTimeAsGenericYear.Year:D4}");
return(result);
}
case GenericUnbounded _:
{
var result = "g-unbounded";
return(result);
}
default:
throw new NotSupportedException("this type of unit-of-time is not supported: " + unitOfTimeType);
}
}
/// <summary>
/// Adds the specified number of units to a unit-of-time.
/// </summary>
/// <param name="unitOfTime">The unit-of-time to add to.</param>
/// <param name="unitsToAdd">The number of units to add (use negative numbers to subtract units).</param>
/// <returns>
/// The result of adding the specified number of units to the specified units-of-time.
/// </returns>
/// <exception cref="ArgumentNullException"><paramref name="unitOfTime"/> is null.</exception>
/// <exception cref="InvalidOperationException"><paramref name="unitOfTime"/> is unbounded.</exception>
public static UnitOfTime Plus(
this UnitOfTime unitOfTime,
int unitsToAdd)
{
switch (unitOfTime)
{
case null:
throw new ArgumentNullException(nameof(unitOfTime));
case CalendarDay unitOfTimeAsCalendarDay:
return(unitOfTimeAsCalendarDay.Plus(unitsToAdd));
case CalendarMonth unitOfTimeAsCalendarMonth:
return(unitOfTimeAsCalendarMonth.Plus(unitsToAdd));
case CalendarQuarter unitOfTimeAsCalendarQuarter:
return(unitOfTimeAsCalendarQuarter.Plus(unitsToAdd));
case CalendarYear unitOfTimeAsCalendarYear:
return(unitOfTimeAsCalendarYear.Plus(unitsToAdd));
case CalendarUnbounded _:
throw new InvalidOperationException("Cannot add to unbounded time.");
case FiscalMonth unitOfTimeAsFiscalMonth:
return(unitOfTimeAsFiscalMonth.Plus(unitsToAdd));
case FiscalQuarter unitOfTimeAsFiscalQuarter:
return(unitOfTimeAsFiscalQuarter.Plus(unitsToAdd));
case FiscalYear unitOfTimeAsFiscalYear:
return(unitOfTimeAsFiscalYear.Plus(unitsToAdd));
case FiscalUnbounded _:
throw new InvalidOperationException("Cannot add to unbounded time.");
case GenericMonth unitOfTimeAsGenericMonth:
return(unitOfTimeAsGenericMonth.Plus(unitsToAdd));
case GenericQuarter unitOfTimeAsGenericQuarter:
return(unitOfTimeAsGenericQuarter.Plus(unitsToAdd));
case GenericYear unitOfTimeAsGenericYear:
return(unitOfTimeAsGenericYear.Plus(unitsToAdd));
case GenericUnbounded _:
throw new InvalidOperationException("Cannot add to unbounded time.");
}
throw new NotSupportedException("this type of unit-of-time is not supported: " + unitOfTime.GetType());
}
