Hello GitHub

src/CalcViewModel/Common/DateCalculator.cpp

@@ -0,0 +1,292 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "DateCalculator.h"
+
+using namespace Platform;
+using namespace Windows::Foundation;
+using namespace Windows::Globalization;
+using namespace CalculatorApp::Common::DateCalculation;
+
+DateCalculationEngine::DateCalculationEngine(_In_ String^ calendarIdentifier)
+{
+    m_calendar = ref new Calendar();
+    m_calendar->ChangeCalendarSystem(calendarIdentifier);
+}
+
+// Adding Duration to a Date 
+// Returns: True if function succeeds to calculate the date else returns False
+bool DateCalculationEngine::AddDuration(_In_ DateTime startDate, _In_ const DateDifference& duration, _Out_ DateTime *endDate)
+{
+    try
+    {
+        m_calendar->SetDateTime(startDate);
+
+        if (duration.year != 0)
+        {
+            m_calendar->AddYears(duration.year);
+        }
+        if (duration.month != 0)
+        {
+            m_calendar->AddMonths(duration.month);
+        }
+        if (duration.day != 0)
+        {
+            m_calendar->AddDays(duration.day);
+        }
+
+        *endDate = m_calendar->GetDateTime();
+    }
+    catch (Platform::InvalidArgumentException^ ex)
+    {
+        // Do nothing
+        return false;
+    }
+
+    return true;
+}
+
+// Subtracting Duration from a Date
+// Returns: True if function succeeds to calculate the date else returns False
+bool DateCalculationEngine::SubtractDuration(_In_ DateTime startDate, _In_ const DateDifference& duration, _Out_ DateTime *endDate)
+{
+    // For Subtract the Algorithm is different than Add. Here the smaller units are subtracted first
+    // and then the larger units. 
+    try
+    {
+        m_calendar->SetDateTime(startDate);
+
+        if (duration.day != 0)
+        {
+            m_calendar->AddDays(-duration.day);
+        }
+        if (duration.month != 0)
+        {
+            m_calendar->AddMonths(-duration.month);
+        }
+        if (duration.year != 0)
+        {
+            m_calendar->AddYears(-duration.year);
+        }
+
+        *endDate = m_calendar->GetDateTime();
+    }
+    catch (Platform::InvalidArgumentException^ ex)
+    {
+        // Do nothing
+        return false;
+    }
+
+    // Check that the UniversalTime value is not negative
+    return (endDate->UniversalTime >= 0);
+}
+
+// Calculate the difference between two dates
+void DateCalculationEngine::GetDateDifference(_In_ DateTime date1, _In_ DateTime date2, _In_ DateUnit outputFormat, _Out_ DateDifference *difference)
+{
+    DateTime startDate;
+    DateTime endDate;
+    DateTime pivotDate;
+    DateTime tempPivotDate;
+    UINT daysDiff = 0;
+    UINT differenceInDates[c_unitsOfDate] = { 0 };
+
+    if (date1.UniversalTime < date2.UniversalTime)
+    {
+        startDate = date1;
+        endDate = date2;
+    }
+    else
+    {
+        startDate = date2;
+        endDate = date1;
+    }
+
+    pivotDate = startDate;
+
+    daysDiff = GetDifferenceInDays(startDate, endDate);
+
+    // If output has units other than days
+    // 0th bit: Year, 1st bit: Month, 2nd bit: Week, 3rd bit: Day
+    if (static_cast<int>(outputFormat) & 7)
+    {
+        UINT daysInMonth;
+        UINT approximateDaysInYear;
+
+        // If we're unable to calculate the days-in-month or days-in-year, we'll leave the values at 0.
+        if (TryGetCalendarDaysInMonth(startDate, daysInMonth)
+            && TryGetCalendarDaysInYear(endDate, approximateDaysInYear))
+        {
+            UINT daysIn[c_unitsOfDate] = { approximateDaysInYear, daysInMonth, c_daysInWeek, 1 };
+
+            for (int unitIndex = 0; unitIndex < c_unitsGreaterThanDays; unitIndex++)
+            {
+                tempPivotDate = pivotDate;
+
+                // Check if the bit flag is set for the date unit
+                DateUnit dateUnit = static_cast<DateUnit>(1 << unitIndex);
+
+                if (static_cast<int>(outputFormat & dateUnit))
+                {
+                    bool isEndDateHit = false;
+                    differenceInDates[unitIndex] = (daysDiff / daysIn[unitIndex]);
+
+                    if (differenceInDates[unitIndex] != 0)
+                    {
+                        try
+                        {
+                            pivotDate = AdjustCalendarDate(pivotDate, dateUnit, static_cast<int>(differenceInDates[unitIndex]));
+                        }
+                        catch (Platform::InvalidArgumentException^)
+                        {
+                            // Operation failed due to out of bound result
+                            // Do nothing
+                            differenceInDates[unitIndex] = 0;
+                        }
+                    }
+
+                    int tempDaysDiff;
+
+                    do
+                    {
+                        tempDaysDiff = GetDifferenceInDays(pivotDate, endDate);
+
+                        if (tempDaysDiff < 0)
+                        {
+                            // pivotDate has gone over the end date; start from the begining of this unit
+                            differenceInDates[unitIndex] -= 1;
+                            pivotDate = tempPivotDate;
+                            pivotDate = AdjustCalendarDate(pivotDate, dateUnit, static_cast<int>(differenceInDates[unitIndex]));
+                            isEndDateHit = true;
+                        }
+                        else if (tempDaysDiff > 0)
+                        {
+                            if (isEndDateHit)
+                            {
+                                // This is the closest the pivot can get to the end date for this unit
+                                break;
+                            }
+
+                            // pivotDate is still below the end date
+                            try
+                            {
+                                pivotDate = AdjustCalendarDate(pivotDate, dateUnit, 1);
+                                differenceInDates[unitIndex] += 1;
+                            }
+                            catch (Platform::InvalidArgumentException^)
+                            {
+                                // handling for 31st Dec, 9999 last valid date
+                                // Do nothing - break out
+                                break;
+                            }
+                        }
+                    } while (tempDaysDiff != 0); // dates are the same - exit the loop
+
+                    tempPivotDate = AdjustCalendarDate(tempPivotDate, dateUnit, static_cast<int>(differenceInDates[unitIndex]));
+                    pivotDate = tempPivotDate;
+                    daysDiff = GetDifferenceInDays(pivotDate, endDate);
+                }
+            }
+        }
+    }
+
+    differenceInDates[3] = daysDiff;
+
+    difference->year = differenceInDates[0];
+    difference->month = differenceInDates[1];
+    difference->week = differenceInDates[2];
+    difference->day = differenceInDates[3];
+}
+
+
+// Private Methods
+
+// Gets number of days between the two date time values
+int DateCalculationEngine::GetDifferenceInDays(DateTime date1, DateTime date2)
+{
+    // A tick is defined as the number of 100 nanoseconds
+    long long ticksDifference = date2.UniversalTime - date1.UniversalTime;
+    return static_cast<int>(ticksDifference / static_cast<long long>(c_day));
+}
+
+// Gets number of Calendar days in the month in which this date falls.
+// Returns true if successful, false otherwise.
+bool DateCalculationEngine::TryGetCalendarDaysInMonth(_In_ DateTime date, _Out_ UINT& daysInMonth)
+{
+    bool result = false;
+    m_calendar->SetDateTime(date);
+
+    // NumberOfDaysInThisMonth returns -1 if unknown.
+    int daysInThisMonth = m_calendar->NumberOfDaysInThisMonth;
+    if (daysInThisMonth != -1)
+    {
+        daysInMonth = static_cast<UINT>(daysInThisMonth);
+        result = true;
+    }
+
+    return result;
+}
+
+// Gets number of Calendar days in the year in which this date falls.
+// Returns true if successful, false otherwise.
+bool DateCalculationEngine::TryGetCalendarDaysInYear(_In_ DateTime date, _Out_ UINT& daysInYear)
+{
+    bool result = false;
+    UINT days = 0;
+
+    m_calendar->SetDateTime(date);
+
+    // NumberOfMonthsInThisYear returns -1 if unknown.
+    int monthsInYear = m_calendar->NumberOfMonthsInThisYear;
+    if (monthsInYear != -1)
+    {
+        bool monthResult = true;
+
+        // Not all years begin with Month 1.
+        int firstMonthThisYear = m_calendar->FirstMonthInThisYear;
+        for (int month = 0; month < monthsInYear; month++)
+        {
+            m_calendar->Month = firstMonthThisYear + month;
+
+            // NumberOfDaysInThisMonth returns -1 if unknown.
+            int daysInMonth = m_calendar->NumberOfDaysInThisMonth;
+            if (daysInMonth == -1)
+            {
+                monthResult = false;
+                break;
+            }
+
+            days += daysInMonth;
+        }
+
+        if (monthResult)
+        {
+            daysInYear = days;
+            result = true;
+        }
+    }
+
+    return result;
+}
+
+// Adds/Subtracts certain value for a particular date unit
+DateTime DateCalculationEngine::AdjustCalendarDate(Windows::Foundation::DateTime date, DateUnit dateUnit, int difference)
+{
+    m_calendar->SetDateTime(date);
+
+    switch (dateUnit)
+    {
+    case DateUnit::Year:
+        m_calendar->AddYears(difference);
+        break;
+    case DateUnit::Month:
+        m_calendar->AddMonths(difference);
+        break;
+    case DateUnit::Week:
+        m_calendar->AddWeeks(difference);
+        break;
+    }
+
+    return m_calendar->GetDateTime();
+}