include/tools/datetime.hxx | 9 +
include/tools/duration.hxx | 72 +++++++++
sc/inc/table.hxx | 8 -
sc/source/core/data/documen3.cxx | 3
sc/source/core/data/table4.cxx | 117 +++++++++------
tools/CppunitTest_tools_test.mk | 1
tools/Library_tl.mk | 1
tools/qa/cppunit/test_duration.cxx | 278 +++++++++++++++++++++++++++++++++++++
tools/source/datetime/datetime.cxx | 38 ++---
tools/source/datetime/duration.cxx | 256 ++++++++++++++++++++++++++++++++++
10 files changed, 717 insertions(+), 66 deletions(-)
New commits:
commit 0770c99928fa0c4af23b06cbf694ee77ee78b836
Author: Eike Rathke <er...@redhat.com>
AuthorDate: Sat Jun 17 01:05:48 2023 +0200
Commit: Eike Rathke <er...@redhat.com>
CommitDate: Sat Jun 17 18:04:56 2023 +0200
Resolves: tdf#153517 Use tools::Duration for FillSeries with (date+)time
Change-Id: I18567fdac512ee786ce4b0785b01b2ae6da7450e
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/153203
Tested-by: Jenkins
Reviewed-by: Eike Rathke <er...@redhat.com>
(cherry picked from commit 45bee6b9a0e620758d0d4079d832d80095164b0a)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/153219
diff --git a/sc/inc/table.hxx b/sc/inc/table.hxx
index a2cc60f9d70e..0662053cb89c 100644
--- a/sc/inc/table.hxx
+++ b/sc/inc/table.hxx
@@ -715,7 +715,8 @@ public:
sc::UpdatedRangeNames& rIndexes) const;
void Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uInt64 nFillCount, FillDir eFillDir, FillCmd
eFillCmd, FillDateCmd eFillDateCmd,
- double nStepValue, double nMaxValue, ScProgress*
pProgress);
+ double nStepValue, const tools::Duration&
rDurationStep,
+ double nMaxValue, ScProgress* pProgress);
OUString GetAutoFillPreview( const ScRange& rSource, SCCOL nEndX, SCROW
nEndY );
void UpdateSelectionFunction( ScFunctionData& rData, const ScMarkData&
rMark );
@@ -1191,13 +1192,14 @@ private:
void FillSeries( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uInt64 nFillCount, FillDir eFillDir,
FillCmd eFillCmd,
FillDateCmd eFillDateCmd,
- double nStepValue, double nMaxValue,
sal_uInt16 nMinDigits,
+ double nStepValue, const tools::Duration&
rDurationStep,
+ double nMaxValue, sal_uInt16 nMinDigits,
bool bAttribs, ScProgress* pProgress,
bool bSkipOverlappedCells = false,
std::vector<sal_Int32>* pNonOverlappedCellIdx
= nullptr);
void FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW
nRow2,
FillCmd& rCmd, FillDateCmd& rDateCmd,
- double& rInc, sal_uInt16& rMinDigits,
+ double& rInc, tools::Duration& rDuration,
sal_uInt16& rMinDigits,
ScUserListData*& rListData, sal_uInt16&
rListIndex,
bool bHasFiltered, bool& rSkipOverlappedCells,
std::vector<sal_Int32>& rNonOverlappedCellIdx
);
diff --git a/sc/source/core/data/documen3.cxx b/sc/source/core/data/documen3.cxx
index b1cf5fe81b8c..8d0d2ba9a665 100644
--- a/sc/source/core/data/documen3.cxx
+++ b/sc/source/core/data/documen3.cxx
@@ -29,6 +29,7 @@
#include <vcl/svapp.hxx>
#include <osl/thread.hxx>
#include <osl/diagnose.h>
+#include <tools/duration.hxx>
#include <document.hxx>
#include <attrib.hxx>
#include <table.hxx>
@@ -1171,7 +1172,7 @@ void ScDocument::Fill(SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2, ScProg
{
maTabs[rTab]->Fill(nCol1, nRow1, nCol2, nRow2,
nFillCount, eFillDir, eFillCmd, eFillDateCmd,
- nStepValue, nMaxValue, pProgress);
+ nStepValue, tools::Duration(), nMaxValue,
pProgress);
RefreshAutoFilter(aRange.aStart.Col(), aRange.aStart.Row(),
aRange.aEnd.Col(), aRange.aEnd.Row(), rTab);
}
}
diff --git a/sc/source/core/data/table4.cxx b/sc/source/core/data/table4.cxx
index 10c27f8d2c84..9c6852990efe 100644
--- a/sc/source/core/data/table4.cxx
+++ b/sc/source/core/data/table4.cxx
@@ -28,6 +28,7 @@
#include <vcl/keycodes.hxx>
#include <rtl/math.hxx>
#include <unotools/charclass.hxx>
+#include <tools/duration.hxx>
#include <osl/diagnose.h>
#include <attrib.hxx>
@@ -215,32 +216,20 @@ double approxDiff( double a, double b )
return rtl::math::round(c, -std::max(nExp, nExpArg));
}
-double approxTimeDiff( double a, double b )
+double approxTypedDiff( double a, double b, bool bTime, tools::Duration&
rDuration )
{
- // Scale to hours, round to "nanohours" (multiple nanoseconds), scale back.
- // Get back 0.0416666666666667 instead of 0.041666666700621136 or
- // 0.041666666664241347 (raw a-b) for one hour, or worse the approxDiff()
- // 0.041666666659999997 value. Though there is no such correct value,
- // IEEE-754 nearest values are
- // 0.041666666666666664353702032030923874117434024810791015625
- // (0x3FA5555555555555) and
- // 0.04166666666666667129259593593815225176513195037841796875
- // (0x3FA5555555555556).
- // This works also for a diff of seconds, unless corner cases would be
- // discovered, which would make it necessary to ditch the floating point
- // and convert to/from time structure values instead.
- return rtl::math::round((a - b) * 24, 9) / 24;
-}
-
-double approxTypedDiff( double a, double b, bool bTime )
-{
- return bTime ? approxTimeDiff( a, b) : approxDiff( a, b);
+ if (bTime)
+ {
+ rDuration = tools::Duration(a - b);
+ return rDuration.GetInDays();
+ }
+ return approxDiff( a, b);
}
}
void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
FillCmd& rCmd, FillDateCmd& rDateCmd,
- double& rInc, sal_uInt16& rMinDigits,
+ double& rInc, tools::Duration& rDuration,
sal_uInt16& rMinDigits,
ScUserListData*& rListData, sal_uInt16& rListIndex,
bool bHasFiltered, bool& rSkipOverlappedCells,
std::vector<sal_Int32>& rNonOverlappedCellIdx)
@@ -248,6 +237,7 @@ void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2,
OSL_ENSURE( nCol1==nCol2 || nRow1==nRow2, "FillAnalyse: invalid range" );
rInc = 0.0;
+ rDuration = tools::Duration();
rMinDigits = 0;
rListData = nullptr;
rCmd = FILL_SIMPLE;
@@ -413,6 +403,7 @@ void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2,
}
else if (nValueCount >= 2)
{
+ tools::Duration aDuration;
for (SCSIZE i = 1; i < nValueCount && bVal; i++)
{
aPrevCell = aCurrCell;
@@ -421,11 +412,16 @@ void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1,
SCCOL nCol2, SCROW nRow2,
aCurrCell = GetCellValue(nColCurr, nRowCurr);
if (aCurrCell.getType() == CELLTYPE_VALUE)
{
+ const bool bTime = (nCurrCellFormatType ==
SvNumFormatType::TIME ||
+ nCurrCellFormatType ==
SvNumFormatType::DATETIME);
double nDiff =
approxTypedDiff(aCurrCell.getDouble(), aPrevCell.getDouble(),
- (nCurrCellFormatType ==
SvNumFormatType::TIME ||
- nCurrCellFormatType ==
SvNumFormatType::DATETIME));
+ bTime, aDuration);
if (i == 1)
+ {
rInc = nDiff;
+ if (bTime)
+ rDuration = aDuration;
+ }
if (!::rtl::math::approxEqual(nDiff, rInc, 13))
bVal = false;
else if ((aCurrCell.getDouble() == 0.0 ||
aCurrCell.getDouble() == 1.0)
@@ -645,9 +641,10 @@ void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2,
{
if (nCount > 1)
{
+ tools::Duration aDuration;
double nVal1 = aFirstCell.getDouble();
double nVal2 = GetValue(nCol+nAddX, nRow+nAddY);
- rInc = approxTypedDiff( nVal2, nVal1, bTime);
+ rInc = approxTypedDiff( nVal2, nVal1, bTime, aDuration);
nCol = sal::static_int_cast<SCCOL>( nCol + nAddX );
nRow = sal::static_int_cast<SCROW>( nRow + nAddY );
bool bVal = true;
@@ -657,7 +654,7 @@ void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2,
if (aCell.getType() == CELLTYPE_VALUE)
{
nVal2 = aCell.getDouble();
- double nDiff = approxTypedDiff( nVal2, nVal1, bTime);
+ double nDiff = approxTypedDiff( nVal2, nVal1, bTime,
aDuration);
if ( !::rtl::math::approxEqual( nDiff, rInc, 13 ) )
bVal = false;
else if ((nVal2 == 0.0 || nVal2 == 1.0) &&
@@ -670,6 +667,8 @@ void ScTable::FillAnalyse( SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2,
bVal = false;
nCol = sal::static_int_cast<SCCOL>( nCol + nAddX );
nRow = sal::static_int_cast<SCROW>( nRow + nAddY );
+ if (bVal && bTime)
+ rDuration = aDuration;
}
if (bVal)
rCmd = FILL_LINEAR;
@@ -1092,6 +1091,7 @@ void ScTable::FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2,
FillCmd eFillCmd;
FillDateCmd eDateCmd = {};
double nInc;
+ tools::Duration aDurationInc;
sal_uInt16 nMinDigits;
ScUserListData* pListData = nullptr;
sal_uInt16 nListIndex;
@@ -1100,12 +1100,12 @@ void ScTable::FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2,
if (bVertical)
FillAnalyse(static_cast<SCCOL>(nCol),nRow1,
static_cast<SCCOL>(nCol),nRow2, eFillCmd,eDateCmd,
- nInc, nMinDigits, pListData, nListIndex,
+ nInc, aDurationInc, nMinDigits, pListData, nListIndex,
bHasFiltered, bSkipOverlappedCells, aNonOverlappedCellIdx);
else
FillAnalyse(nCol1,static_cast<SCROW>(nRow),
nCol2,static_cast<SCROW>(nRow), eFillCmd,eDateCmd,
- nInc, nMinDigits, pListData, nListIndex,
+ nInc, aDurationInc, nMinDigits, pListData, nListIndex,
bHasFiltered, bSkipOverlappedCells, aNonOverlappedCellIdx);
if (pListData)
@@ -1214,17 +1214,20 @@ void ScTable::FillAuto( SCCOL nCol1, SCROW nRow1, SCCOL
nCol2, SCROW nRow2,
else
{
if (!bPositive)
+ {
nInc = -nInc;
+ aDurationInc = -aDurationInc;
+ }
double nEndVal = (nInc>=0.0) ? MAXDOUBLE : -MAXDOUBLE;
if (bVertical)
FillSeries( static_cast<SCCOL>(nCol), nRow1,
static_cast<SCCOL>(nCol), nRow2, nFillCount, eFillDir,
- eFillCmd, eDateCmd, nInc, nEndVal, nMinDigits, false,
+ eFillCmd, eDateCmd, nInc, aDurationInc, nEndVal,
nMinDigits, false,
pProgress, bSkipOverlappedCells,
&aNonOverlappedCellIdx);
else
FillSeries( nCol1, static_cast<SCROW>(nRow), nCol2,
static_cast<SCROW>(nRow), nFillCount, eFillDir,
- eFillCmd, eDateCmd, nInc, nEndVal, nMinDigits, false,
+ eFillCmd, eDateCmd, nInc, aDurationInc, nEndVal,
nMinDigits, false,
pProgress, bSkipOverlappedCells,
&aNonOverlappedCellIdx);
if (pProgress)
nProgress = pProgress->GetState();
@@ -1375,6 +1378,7 @@ OUString ScTable::GetAutoFillPreview( const ScRange&
rSource, SCCOL nEndX, SCROW
FillCmd eFillCmd;
FillDateCmd eDateCmd;
double nInc;
+ tools::Duration aDurationInc;
sal_uInt16 nMinDigits;
ScUserListData* pListData = nullptr;
sal_uInt16 nListIndex;
@@ -1385,7 +1389,7 @@ OUString ScTable::GetAutoFillPreview( const ScRange&
rSource, SCCOL nEndX, SCROW
// after FillAnalyse / FillSeries fully handle them.
// Now FillAnalyse called as if there are filtered rows, so it will
work in the old way.
FillAnalyse(nCol1, nRow1, nCol2, nRow2, eFillCmd, eDateCmd,
- nInc, nMinDigits, pListData, nListIndex,
+ nInc, aDurationInc, nMinDigits, pListData, nListIndex,
true, bSkipOverlappedCells, aNonOverlappedCellIdx);
if ( pListData ) // user defined list
@@ -1530,9 +1534,18 @@ OUString ScTable::GetAutoFillPreview( const ScRange&
rSource, SCCOL nEndX, SCROW
nStart = 0.0;
if ( eFillCmd == FILL_LINEAR )
{
- double nAdd = nInc;
- bValueOk = ( SubTotal::SafeMult( nAdd,
static_cast<double>(nIndex) ) &&
- SubTotal::SafePlus( nStart, nAdd ) );
+ if (aDurationInc)
+ {
+ bool bOverflow;
+ tools::Duration aDuration( aDurationInc.Mult( nIndex,
bOverflow));
+ bValueOk = SubTotal::SafePlus( nStart,
aDuration.GetInDays()) && !bOverflow;
+ }
+ else
+ {
+ double nAdd = nInc;
+ bValueOk = ( SubTotal::SafeMult( nAdd,
static_cast<double>(nIndex) ) &&
+ SubTotal::SafePlus( nStart, nAdd ) );
+ }
}
else // date
{
@@ -2153,7 +2166,8 @@ inline bool isOverflow( const double& rVal, const double&
rMax, const double& rS
void ScTable::FillSeries( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uInt64 nFillCount, FillDir eFillDir, FillCmd eFillCmd,
FillDateCmd eFillDateCmd,
- double nStepValue, double nMaxValue, sal_uInt16
nArgMinDigits,
+ double nStepValue, const tools::Duration& rDurationStep,
+ double nMaxValue, sal_uInt16 nArgMinDigits,
bool bAttribs, ScProgress* pProgress,
bool bSkipOverlappedCells, std::vector<sal_Int32>*
pNonOverlappedCellIdx )
{
@@ -2420,10 +2434,18 @@ void ScTable::FillSeries( SCCOL nCol1, SCROW nRow1,
SCCOL nCol2, SCROW nRow2,
// use multiplication instead of
repeated addition
// to avoid accumulating rounding
errors
nVal = nStartVal;
- double nAdd = nStepValue;
- if ( !SubTotal::SafeMult( nAdd,
static_cast<double>(++nIndex) ) ||
- !SubTotal::SafePlus( nVal,
nAdd ) )
- bError = true;
+ if (rDurationStep)
+ {
+ tools::Duration aDuration(
rDurationStep.Mult( ++nIndex, bError));
+ bError |= !SubTotal::SafePlus(
nVal, aDuration.GetInDays());
+ }
+ else
+ {
+ double nAdd = nStepValue;
+ if ( !SubTotal::SafeMult( nAdd,
static_cast<double>(++nIndex) ) ||
+ !SubTotal::SafePlus( nVal,
nAdd ) )
+ bError = true;
+ }
}
break;
case FILL_GROWTH:
@@ -2525,10 +2547,18 @@ void ScTable::FillSeries( SCCOL nCol1, SCROW nRow1,
SCCOL nCol2, SCROW nRow2,
// use multiplication instead of
repeated addition
// to avoid accumulating rounding
errors
nVal = nStartVal;
- double nAdd = nStepValue;
- if ( !SubTotal::SafeMult( nAdd,
static_cast<double>(++nIndex) ) ||
- !SubTotal::SafePlus( nVal,
nAdd ) )
- bError = true;
+ if (rDurationStep)
+ {
+ tools::Duration aDuration(
rDurationStep.Mult( ++nIndex, bError));
+ bError |= !SubTotal::SafePlus(
nVal, aDuration.GetInDays());
+ }
+ else
+ {
+ double nAdd = nStepValue;
+ if ( !SubTotal::SafeMult(
nAdd, static_cast<double>(++nIndex) ) ||
+ !SubTotal::SafePlus(
nVal, nAdd ) )
+ bError = true;
+ }
}
break;
case FILL_GROWTH:
@@ -2598,13 +2628,14 @@ void ScTable::FillSeries( SCCOL nCol1, SCROW nRow1,
SCCOL nCol2, SCROW nRow2,
void ScTable::Fill( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
sal_uInt64 nFillCount, FillDir eFillDir, FillCmd eFillCmd,
FillDateCmd eFillDateCmd,
- double nStepValue, double nMaxValue, ScProgress* pProgress)
+ double nStepValue, const tools::Duration& rDurationStep,
+ double nMaxValue, ScProgress* pProgress)
{
if (eFillCmd == FILL_AUTO)
FillAuto(nCol1, nRow1, nCol2, nRow2, nFillCount, eFillDir, pProgress);
else
FillSeries(nCol1, nRow1, nCol2, nRow2, nFillCount, eFillDir,
- eFillCmd, eFillDateCmd, nStepValue, nMaxValue, 0, true,
pProgress);
+ eFillCmd, eFillDateCmd, nStepValue, rDurationStep,
nMaxValue, 0, true, pProgress);
}
void ScTable::AutoFormatArea(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol,
SCROW nEndRow,
commit 69f757a4bb32a844f7754f6fc6b9970557297528
Author: Eike Rathke <er...@redhat.com>
AuthorDate: Sat Jun 17 00:57:42 2023 +0200
Commit: Eike Rathke <er...@redhat.com>
CommitDate: Sat Jun 17 18:04:45 2023 +0200
Related: tdf#153517 Introduce class tools::Duration
Change-Id: I73ea6e162c73382ba470a306ce2852dbff3d1314
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/153202
Reviewed-by: Eike Rathke <er...@redhat.com>
Tested-by: Jenkins
(cherry picked from commit eac63ab120a181a1dff6317ee3d223327080e992)
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/153218
diff --git a/include/tools/datetime.hxx b/include/tools/datetime.hxx
index dd435e3994ba..2194711dc208 100644
--- a/include/tools/datetime.hxx
+++ b/include/tools/datetime.hxx
@@ -26,6 +26,11 @@
#include <iomanip>
+namespace tools
+{
+class Duration;
+}
+
class SAL_WARN_UNUSED TOOLS_DLLPUBLIC DateTime : public Date, public
tools::Time
{
public:
@@ -83,6 +88,8 @@ public:
void AddTime( double fTimeInDays );
DateTime& operator +=( const tools::Time& rTime );
DateTime& operator -=( const tools::Time& rTime );
+ /** Duration can be negative, so adding it will subtract its value. */
+ DateTime& operator +=( const tools::Duration& rDuration );
private:
void NormalizeTimeRemainderAndApply( tools::Time& rTime );
public:
@@ -97,6 +104,8 @@ public:
TOOLS_DLLPUBLIC friend double operator -( const DateTime& rDateTime1,
const DateTime& rDateTime2 );
TOOLS_DLLPUBLIC friend sal_Int64 operator -( const DateTime& rDateTime,
const Date& rDate )
{ return static_cast<const Date&>(rDateTime) - rDate; }
+ /** Duration can be negative, so adding it will subtract its value. */
+ TOOLS_DLLPUBLIC friend DateTime operator +( const DateTime& rDateTime,
const tools::Duration& rDuration );
DateTime& operator =( const DateTime& rDateTime );
DateTime& operator =( const css::util::DateTime& rUDateTime );
diff --git a/include/tools/duration.hxx b/include/tools/duration.hxx
new file mode 100644
index 000000000000..83b9d12a77b3
--- /dev/null
+++ b/include/tools/duration.hxx
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4;
fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include <tools/time.hxx>
+
+class DateTime;
+
+namespace tools
+{
+/** Duration in days and time. Can be negative in which case days is 0 and time
+ is negative or both days and time are negative.
+*/
+class SAL_WARN_UNUSED TOOLS_DLLPUBLIC Duration
+{
+public:
+ Duration() {}
+
+ /** Assumes that DateTime are normalized and there are no Time out-of-range
+ field values. */
+ Duration(const ::DateTime& rStart, const ::DateTime& rEnd);
+
+ /** Time can be a limited duration as well. We don't cater for out-of-range
+ minutes and seconds values here though. */
+ Duration(const Time& rStart, const Time& rEnd);
+
+ /** Difference in days, like DateTime()-DateTime(). */
+ explicit Duration(double fTimeInDays);
+
+ bool IsNegative() const { return mnDays < 0 || maTime.GetTime() < 0; }
+ sal_Int32 GetDays() const { return mnDays; }
+ const Time& GetTime() const { return maTime; }
+ double GetInDays() const { return static_cast<double>(GetDays()) +
GetTime().GetTimeInDays(); }
+
+ /** Whether a duration is set. */
+ operator bool() const { return maTime.GetTime() != 0 || mnDays != 0; }
+
+ /** Unary minus. */
+ Duration operator-() const;
+
+ /** Add a duration to this instance. */
+ Duration& Add(const Duration& rDuration, bool& rbOverflow);
+
+ /** Get multiple of duration. */
+ Duration Mult(sal_Int32 nMult, bool& rbOverflow) const;
+
+private:
+ /** Internal days and Time values. */
+ Duration(sal_Int32 nDays, sal_Int64 nTime);
+
+ /** Prerequisite: mnDays is already correctly set and absolute value of
+ nanoseconds less than one day. */
+ void ApplyTime(sal_Int64 nNS);
+
+ /** Prerequisite: mnDays is already correctly set and Time hour values
+ are adjusted. */
+ void SetTimeDiff(const Time& rStart, const Time& rEnd);
+
+private:
+ Time maTime = Time(0);
+ sal_Int32 mnDays = 0;
+};
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s
cinkeys+=0=break: */
diff --git a/tools/CppunitTest_tools_test.mk b/tools/CppunitTest_tools_test.mk
index 9cf6c671fcef..d27f8c3efa58 100644
--- a/tools/CppunitTest_tools_test.mk
+++ b/tools/CppunitTest_tools_test.mk
@@ -17,6 +17,7 @@ $(eval $(call
gb_CppunitTest_add_exception_objects,tools_test, \
tools/qa/cppunit/test_bigint \
tools/qa/cppunit/test_date \
tools/qa/cppunit/test_time \
+ tools/qa/cppunit/test_duration \
tools/qa/cppunit/test_fract \
tools/qa/cppunit/test_inetmime \
tools/qa/cppunit/test_json_writer \
diff --git a/tools/Library_tl.mk b/tools/Library_tl.mk
index bccbf95a2a01..8269e6ae98bf 100644
--- a/tools/Library_tl.mk
+++ b/tools/Library_tl.mk
@@ -45,6 +45,7 @@ $(eval $(call gb_Library_use_libraries,tl,\
$(eval $(call gb_Library_add_exception_objects,tl,\
tools/source/datetime/datetime \
tools/source/datetime/datetimeutils \
+ tools/source/datetime/duration \
tools/source/datetime/systemdatetime \
tools/source/datetime/tdate \
tools/source/datetime/ttime \
diff --git a/tools/qa/cppunit/test_duration.cxx
b/tools/qa/cppunit/test_duration.cxx
new file mode 100644
index 000000000000..0f5a4e002219
--- /dev/null
+++ b/tools/qa/cppunit/test_duration.cxx
@@ -0,0 +1,278 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <cppunit/TestFixture.h>
+#include <cppunit/extensions/HelperMacros.h>
+
+#include <tools/duration.hxx>
+#include <tools/datetime.hxx>
+
+namespace tools
+{
+class DurationTest : public CppUnit::TestFixture
+{
+public:
+ void testDuration();
+
+ CPPUNIT_TEST_SUITE(DurationTest);
+ CPPUNIT_TEST(testDuration);
+ CPPUNIT_TEST_SUITE_END();
+};
+
+void DurationTest::testDuration()
+{
+ {
+ const Duration aD(Time(0), Time(12, 0, 0));
+ CPPUNIT_ASSERT_EQUAL(0.5, aD.GetInDays());
+ }
+ {
+ const Duration aD(Time(24, 0, 0), Time(12, 0, 0));
+ CPPUNIT_ASSERT_EQUAL(-0.5, aD.GetInDays());
+ }
+ {
+ const DateTime aS(Date(23, 11, 1999), Time(6, 0, 0));
+ const DateTime aE(Date(24, 11, 1999), Time(18, 0, 0));
+ const Duration aD(aS, aE);
+ CPPUNIT_ASSERT_EQUAL(1.5, aD.GetInDays());
+ DateTime aDT1(aS);
+ const DateTime aDT2 = aDT1 + aD;
+ CPPUNIT_ASSERT_EQUAL(aE, aDT2);
+ aDT1 += aD;
+ CPPUNIT_ASSERT_EQUAL(aE, aDT1);
+ aDT1 += aD;
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(26, 11, 1999), Time(6, 0, 0)),
aDT1);
+ }
+ {
+ const DateTime aS(Date(23, 11, 1999), Time(18, 0, 0));
+ const DateTime aE(Date(24, 11, 1999), Time(6, 0, 0));
+ const Duration aD(aS, aE);
+ CPPUNIT_ASSERT_EQUAL(0.5, aD.GetInDays());
+ DateTime aDT1(aS);
+ const DateTime aDT2 = aDT1 + aD;
+ CPPUNIT_ASSERT_EQUAL(aE, aDT2);
+ aDT1 += aD;
+ CPPUNIT_ASSERT_EQUAL(aE, aDT1);
+ aDT1 += aD;
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(24, 11, 1999), Time(18, 0, 0)),
aDT1);
+ }
+ {
+ const DateTime aS(Date(24, 11, 1999), Time(18, 0, 0));
+ const DateTime aE(Date(23, 11, 1999), Time(6, 0, 0));
+ const Duration aD(aS, aE);
+ CPPUNIT_ASSERT_EQUAL(-1.5, aD.GetInDays());
+ DateTime aDT1(aS);
+ const DateTime aDT2 = aDT1 + aD;
+ CPPUNIT_ASSERT_EQUAL(aE, aDT2);
+ aDT1 += aD;
+ CPPUNIT_ASSERT_EQUAL(aE, aDT1);
+ aDT1 += aD;
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(21, 11, 1999), Time(18, 0, 0)),
aDT1);
+ }
+ {
+ const DateTime aS(Date(24, 11, 1999), Time(6, 0, 0));
+ const DateTime aE(Date(23, 11, 1999), Time(18, 0, 0));
+ const Duration aD(aS, aE);
+ CPPUNIT_ASSERT_EQUAL(-0.5, aD.GetInDays());
+ DateTime aDT1(aS);
+ const DateTime aDT2 = aDT1 + aD;
+ CPPUNIT_ASSERT_EQUAL(aE, aDT2);
+ aDT1 += aD;
+ CPPUNIT_ASSERT_EQUAL(aE, aDT1);
+ aDT1 += aD;
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(23, 11, 1999), Time(6, 0, 0)),
aDT1);
+ }
+ {
+ const Duration aD(1.5);
+ CPPUNIT_ASSERT_EQUAL(1.5, aD.GetInDays());
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(24, 11, 1999), Time(18, 0, 0)),
+ DateTime(Date(23, 11, 1999), Time(6, 0, 0)) + aD);
+ }
+ {
+ const Duration aD(-1.5);
+ CPPUNIT_ASSERT_EQUAL(-1.5, aD.GetInDays());
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(23, 11, 1999), Time(6, 0, 0)),
+ DateTime(Date(24, 11, 1999), Time(18, 0, 0)) +
aD);
+ }
+ {
+ const Duration aD(-1.5);
+ const Duration aN = -aD;
+ CPPUNIT_ASSERT_EQUAL(1.5, aN.GetInDays());
+ }
+ { // Add()
+ const DateTime aS(Date(23, 11, 1999), Time(0, 0, 0));
+ const DateTime aE(Date(23, 11, 1999), Time(1, 23, 45));
+ const Duration aD(aS, aE);
+ Duration aV = aD;
+ bool bOverflow = true;
+ aV.Add(aD, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(23, 11, 1999), Time(2, 47, 30)),
+ DateTime(Date(23, 11, 1999), Time(0, 0, 0)) + aV);
+ for (int i = 0; i < 20; ++i)
+ aV.Add(aD, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(24, 11, 1999), Time(6, 42, 30)),
+ DateTime(Date(23, 11, 1999), Time(0, 0, 0)) + aV);
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1), aV.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(6),
aV.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(42),
aV.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(30),
aV.GetTime().GetSec());
+ CPPUNIT_ASSERT(aV.GetTime().GetTime() > 0);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(1.27951388888889, aV.GetInDays(), 1E-14);
+ // Negative duration.
+ const Duration aN(aE, aS);
+ aV = aN;
+ aV.Add(aN, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(22, 11, 1999), Time(21, 12, 30)),
+ DateTime(Date(23, 11, 1999), Time(0, 0, 0)) + aV);
+ for (int i = 0; i < 20; ++i)
+ aV.Add(aN, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(21, 11, 1999), Time(17, 17, 30)),
+ DateTime(Date(23, 11, 1999), Time(0, 0, 0)) + aV);
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-1), aV.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(6),
aV.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(42),
aV.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(30),
aV.GetTime().GetSec());
+ CPPUNIT_ASSERT(aV.GetTime().GetTime() < 0);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.27951388888889, aV.GetInDays(), 1E-14);
+ }
+ { // Mult()
+ const DateTime aS(Date(23, 11, 1999), Time(0, 0, 0));
+ const DateTime aE(Date(23, 11, 1999), Time(1, 23, 45));
+ const Duration aD(aS, aE);
+ bool bOverflow = true;
+ Duration aV = aD.Mult(22, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(24, 11, 1999), Time(6, 42, 30)),
+ DateTime(Date(23, 11, 1999), Time(0, 0, 0)) + aV);
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(1), aV.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(6),
aV.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(42),
aV.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(30),
aV.GetTime().GetSec());
+ CPPUNIT_ASSERT(aV.GetTime().GetTime() > 0);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(1.27951388888889, aV.GetInDays(), 1E-14);
+ // Negative duration.
+ const Duration aN(aE, aS);
+ bOverflow = true;
+ aV = aN.Mult(22, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_EQUAL(DateTime(Date(21, 11, 1999), Time(17, 17, 30)),
+ DateTime(Date(23, 11, 1999), Time(0, 0, 0)) + aV);
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(-1), aV.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(6),
aV.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(42),
aV.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(30),
aV.GetTime().GetSec());
+ CPPUNIT_ASSERT(aV.GetTime().GetTime() < 0);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(-1.27951388888889, aV.GetInDays(), 1E-14);
+ }
+ { // Mult() including days.
+ const Duration aD(1.5);
+ bool bOverflow = true;
+ Duration aV = aD.Mult(10, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(15.0, aV.GetInDays(), 0.0);
+ }
+ { // Mult() including days.
+ const Duration aD(-1.5);
+ bool bOverflow = true;
+ Duration aV = aD.Mult(10, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(-15.0, aV.GetInDays(), 0.0);
+ }
+ { // Mult() including days.
+ const Duration aD(1.5);
+ bool bOverflow = true;
+ Duration aV = aD.Mult(-10, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(-15.0, aV.GetInDays(), 0.0);
+ }
+ { // Mult() including days.
+ const Duration aD(-1.5);
+ bool bOverflow = true;
+ Duration aV = aD.Mult(-10, bOverflow);
+ CPPUNIT_ASSERT(!bOverflow);
+ CPPUNIT_ASSERT_DOUBLES_EQUAL(15.0, aV.GetInDays(), 0.0);
+ }
+ { // Mult() with overflow.
+ const Duration aD(SAL_MAX_INT32);
+ bool bOverflow = false;
+ Duration aV = aD.Mult(2, bOverflow);
+ CPPUNIT_ASSERT(bOverflow);
+ CPPUNIT_ASSERT_EQUAL(SAL_MAX_INT32, aV.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(23),
aV.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(59),
aV.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(59),
aV.GetTime().GetSec());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt32>(Time::nanoSecPerSec - 1),
+ aV.GetTime().GetNanoSec());
+ }
+ { // Mult() with overflow.
+ const Duration aD(SAL_MIN_INT32);
+ bool bOverflow = false;
+ Duration aV = aD.Mult(2, bOverflow);
+ CPPUNIT_ASSERT(bOverflow);
+ CPPUNIT_ASSERT_EQUAL(SAL_MIN_INT32, aV.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(23),
aV.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(59),
aV.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(59),
aV.GetTime().GetSec());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt32>(Time::nanoSecPerSec - 1),
+ aV.GetTime().GetNanoSec());
+ }
+ { // Mult() with overflow.
+ const Duration aD(SAL_MAX_INT32);
+ bool bOverflow = false;
+ Duration aV = aD.Mult(-2, bOverflow);
+ CPPUNIT_ASSERT(bOverflow);
+ CPPUNIT_ASSERT_EQUAL(SAL_MIN_INT32, aV.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(23),
aV.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(59),
aV.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(59),
aV.GetTime().GetSec());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt32>(Time::nanoSecPerSec - 1),
+ aV.GetTime().GetNanoSec());
+ }
+ { // Mult() with overflow.
+ const Duration aD(SAL_MIN_INT32);
+ bool bOverflow = false;
+ Duration aV = aD.Mult(-2, bOverflow);
+ CPPUNIT_ASSERT(bOverflow);
+ CPPUNIT_ASSERT_EQUAL(SAL_MAX_INT32, aV.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(23),
aV.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(59),
aV.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(59),
aV.GetTime().GetSec());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt32>(Time::nanoSecPerSec - 1),
+ aV.GetTime().GetNanoSec());
+ }
+ { // Inaccurate double yielding exact duration.
+ const Time aS(15, 0, 0);
+ const Time aE(16, 0, 0);
+ const Duration aD(aE.GetTimeInDays() - aS.GetTimeInDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(0), aD.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(1),
aD.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(0),
aD.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(0),
aD.GetTime().GetSec());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt32>(0),
aD.GetTime().GetNanoSec());
+ }
+ { // Inaccurate double yielding exact duration, negative.
+ const Time aS(15, 0, 0);
+ const Time aE(16, 0, 0);
+ const Duration aD(aS.GetTimeInDays() - aE.GetTimeInDays());
+ CPPUNIT_ASSERT(aD.IsNegative());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(0), aD.GetDays());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(1),
aD.GetTime().GetHour());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(0),
aD.GetTime().GetMin());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt16>(0),
aD.GetTime().GetSec());
+ CPPUNIT_ASSERT_EQUAL(static_cast<sal_uInt32>(0),
aD.GetTime().GetNanoSec());
+ }
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(DurationTest);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s
cinkeys+=0=break: */
diff --git a/tools/source/datetime/datetime.cxx
b/tools/source/datetime/datetime.cxx
index 47dc0555bc87..ec2c53673b17 100644
--- a/tools/source/datetime/datetime.cxx
+++ b/tools/source/datetime/datetime.cxx
@@ -17,6 +17,7 @@
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <tools/datetime.hxx>
+#include <tools/duration.hxx>
#include <rtl/math.hxx>
#include <sal/log.hxx>
@@ -136,6 +137,13 @@ DateTime& DateTime::operator -=( const tools::Time& rTime )
return *this;
}
+DateTime& DateTime::operator +=( const tools::Duration& rDuration )
+{
+ AddDays(rDuration.GetDays());
+ operator+=(rDuration.GetTime());
+ return *this;
+}
+
DateTime operator +( const DateTime& rDateTime, sal_Int32 nDays )
{
DateTime aDateTime( rDateTime );
@@ -164,27 +172,19 @@ DateTime operator -( const DateTime& rDateTime, const
tools::Time& rTime )
return aDateTime;
}
+DateTime operator +( const DateTime& rDateTime, const tools::Duration&
rDuration )
+{
+ DateTime aDateTime(rDateTime);
+ aDateTime.AddDays( rDuration.GetDays());
+ aDateTime += rDuration.GetTime();
+ return aDateTime;
+}
+
void DateTime::AddTime( double fTimeInDays )
{
- double fInt, fFrac;
- if ( fTimeInDays < 0.0 )
- {
- fInt = ::rtl::math::approxCeil( fTimeInDays );
- fFrac = fInt <= fTimeInDays ? 0.0 : fTimeInDays - fInt;
- }
- else
- {
- fInt = ::rtl::math::approxFloor( fTimeInDays );
- fFrac = fInt >= fTimeInDays ? 0.0 : fTimeInDays - fInt;
- }
- AddDays( sal_Int32(fInt) ); // full days
- if ( fFrac )
- {
- tools::Time aTime(0); // default ctor calls system time, we don't
need that
- fFrac *= ::tools::Time::nanoSecPerDay; // time expressed in
nanoseconds
- aTime.MakeTimeFromNS( static_cast<sal_Int64>(fFrac) ); // method
handles negative ns
- operator+=( aTime );
- }
+ // Use Duration to diminish floating point accuracy errors.
+ tools::Duration aDuration(fTimeInDays);
+ operator+=(aDuration);
}
DateTime operator +( const DateTime& rDateTime, double fTimeInDays )
diff --git a/tools/source/datetime/duration.cxx
b/tools/source/datetime/duration.cxx
new file mode 100644
index 000000000000..07f79929177f
--- /dev/null
+++ b/tools/source/datetime/duration.cxx
@@ -0,0 +1,256 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4;
fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <tools/duration.hxx>
+#include <tools/datetime.hxx>
+#include <rtl/math.hxx>
+#include <o3tl/safeint.hxx>
+#include <cmath>
+
+namespace tools
+{
+Duration::Duration(const ::DateTime& rStart, const ::DateTime& rEnd)
+ : mnDays(static_cast<const Date&>(rEnd) - static_cast<const Date&>(rStart))
+{
+ SetTimeDiff(rStart, rEnd);
+}
+
+Duration::Duration(const Time& rStart, const Time& rEnd)
+{
+ const sal_uInt16 nStartHour = rStart.GetHour();
+ const sal_uInt16 nEndHour = rEnd.GetHour();
+ if (nStartHour >= 24 || nEndHour >= 24)
+ {
+ Time aEnd(rEnd);
+ if (nEndHour >= 24)
+ {
+ mnDays = (nEndHour / 24) * (aEnd.GetTime() < 0 ? -1 : 1);
+ aEnd.SetHour(nEndHour % 24);
+ }
+ Time aStart(rStart);
+ if (nStartHour >= 24)
+ {
+ mnDays -= (nStartHour / 24) * (aStart.GetTime() < 0 ? -1 : 1);
+ aStart.SetHour(nStartHour % 24);
+ }
+ SetTimeDiff(aStart, aEnd);
+ }
+ else
+ {
+ SetTimeDiff(rStart, rEnd);
+ }
+}
+
+Duration::Duration(double fTimeInDays)
+{
+ double fInt, fFrac;
+ if (fTimeInDays < 0.0)
+ {
+ fInt = ::rtl::math::approxCeil(fTimeInDays);
+ fFrac = fInt <= fTimeInDays ? 0.0 : fTimeInDays - fInt;
+ }
+ else
+ {
+ fInt = ::rtl::math::approxFloor(fTimeInDays);
+ fFrac = fInt >= fTimeInDays ? 0.0 : fTimeInDays - fInt;
+ }
+ mnDays = static_cast<sal_Int32>(fInt);
+ if (fFrac)
+ {
+ fFrac *= Time::nanoSecPerDay;
+ fFrac = ::rtl::math::approxFloor(fFrac);
+ sal_Int64 nNS = static_cast<sal_Int64>(fFrac);
+ // Round by 1 nanosecond if it's just 1 off to a second, i.e.
+ // 0999999999 or 0000000001. This could be losened to rounding by 2 or
+ // such if necessary.
+ const sal_Int64 nN = nNS % Time::nanoSecPerSec;
+ if (std::abs(nN) == 1)
+ nNS -= (nNS < 0) ? -1 : 1;
+ else if (std::abs(nN) == Time::nanoSecPerSec - 1)
+ {
+ nNS += (nNS < 0) ? -1 : 1;
+ if (std::abs(nNS) >= Time::nanoSecPerDay)
+ {
+ mnDays += nNS / Time::nanoSecPerDay;
+ nNS %= Time::nanoSecPerDay;
+ }
+ }
+ maTime.MakeTimeFromNS(nNS);
+ assert(mnDays == 0 || maTime.GetTime() == 0 || (mnDays < 0) == (nNS <
0));
+ }
+}
+
+Duration::Duration(sal_Int32 nDays, sal_Int64 nTime)
+ : maTime(nTime)
+ , mnDays(nDays)
+{
+}
+
+void Duration::ApplyTime(sal_Int64 nNS)
+{
+ if (mnDays > 0 && nNS < 0)
+ {
+ --mnDays;
+ nNS = Time::nanoSecPerDay + nNS;
+ }
+ else if (mnDays < 0 && nNS > 0)
+ {
+ ++mnDays;
+ nNS = -Time::nanoSecPerDay + nNS;
+ }
+ maTime.MakeTimeFromNS(nNS);
+ assert(mnDays == 0 || maTime.GetTime() == 0 || (mnDays < 0) == (nNS < 0));
+}
+
+void Duration::SetTimeDiff(const Time& rStart, const Time& rEnd)
+{
+ const sal_Int64 nNS = rEnd.GetNSFromTime() - rStart.GetNSFromTime();
+ ApplyTime(nNS);
+}
+
+Duration Duration::operator-() const
+{
+ Duration aD(-mnDays, -maTime.GetTime());
+ return aD;
+}
+
+Duration& Duration::Add(const Duration& rDuration, bool& rbOverflow)
+{
+ rbOverflow = o3tl::checked_add(mnDays, rDuration.mnDays, mnDays);
+ // Duration is always normalized, time values >= 24h don't occur.
+ sal_Int64 nNS = maTime.GetNSFromTime() + rDuration.maTime.GetNSFromTime();
+ if (nNS < -Time::nanoSecPerDay)
+ {
+ rbOverflow |= o3tl::checked_sub(mnDays, sal_Int32(1), mnDays);
+ nNS += Time::nanoSecPerDay;
+ }
+ else if (nNS > Time::nanoSecPerDay)
+ {
+ rbOverflow |= o3tl::checked_add(mnDays, sal_Int32(1), mnDays);
+ nNS -= Time::nanoSecPerDay;
+ }
+ ApplyTime(nNS);
+ return *this;
+}
+
+Duration Duration::Mult(sal_Int32 nMult, bool& rbOverflow) const
+{
+ // First try a simple calculation in nanoseconds.
+ bool bBadNS = false;
+ sal_Int64 nNS;
+ sal_Int64 nDays;
+ if (o3tl::checked_multiply(static_cast<sal_Int64>(mnDays),
static_cast<sal_Int64>(nMult), nDays)
+ || o3tl::checked_multiply(nDays, Time::nanoSecPerDay, nDays)
+ || o3tl::checked_multiply(maTime.GetNSFromTime(),
static_cast<sal_Int64>(nMult), nNS)
+ || o3tl::checked_add(nDays, nNS, nNS))
+ {
+ bBadNS = rbOverflow = true;
+ }
+ else
+ {
+ const sal_Int64 nD = nNS / Time::nanoSecPerDay;
+ if (nD < SAL_MIN_INT32 || SAL_MAX_INT32 < nD)
+ rbOverflow = true;
+ else
+ {
+ rbOverflow = false;
+ nNS -= nD * Time::nanoSecPerDay;
+ Duration aD(static_cast<sal_Int32>(nD), 0);
+ aD.ApplyTime(nNS);
+ return aD;
+ }
+ }
+ if (bBadNS)
+ {
+ // Simple calculation in overall nanoseconds overflew, try with
+ // individual components.
+ const sal_uInt64 nMult64 = (nMult < 0) ? -nMult : nMult;
+ do
+ {
+ rbOverflow = true;
+ sal_uInt64 nN;
+ if
(o3tl::checked_multiply(static_cast<sal_uInt64>(maTime.GetNanoSec()), nMult64,
nN))
+ break;
+ sal_uInt64 nS;
+ if
(o3tl::checked_multiply(static_cast<sal_uInt64>(maTime.GetSec()), nMult64, nS))
+ break;
+ sal_uInt64 nM;
+ if
(o3tl::checked_multiply(static_cast<sal_uInt64>(maTime.GetMin()), nMult64, nM))
+ break;
+ sal_uInt64 nH;
+ if
(o3tl::checked_multiply(static_cast<sal_uInt64>(maTime.GetHour()), nMult64, nH))
+ break;
+ sal_uInt64 nD;
+ if (o3tl::checked_multiply(static_cast<sal_uInt64>(mnDays < 0 ?
-mnDays : mnDays),
+ nMult64, nD))
+ break;
+ if (nN > Time::nanoSecPerSec)
+ {
+ const sal_uInt64 nC = nN / Time::nanoSecPerSec;
+ if (o3tl::checked_add(nS, nC, nS))
+ break;
+ nN -= nC * Time::nanoSecPerSec;
+ }
+ if (nS > Time::secondPerMinute)
+ {
+ const sal_uInt64 nC = nS / Time::secondPerMinute;
+ if (o3tl::checked_add(nM, nC, nM))
+ break;
+ nS -= nC * Time::secondPerMinute;
+ }
+ if (nM > Time::minutePerHour)
+ {
+ const sal_uInt64 nC = nM / Time::minutePerHour;
+ if (o3tl::checked_add(nH, nC, nH))
+ break;
+ nM -= nC * Time::minutePerHour;
+ }
+ if (nH > Time::hourPerDay)
+ {
+ const sal_uInt64 nC = nH / Time::hourPerDay;
+ if (o3tl::checked_add(nD, nC, nD))
+ break;
+ nH -= nC * Time::hourPerDay;
+ }
+ if (IsNegative() ? (static_cast<sal_uInt64>(SAL_MAX_INT32) + 1) <
nD
+ || -static_cast<sal_Int64>(nD) <
SAL_MIN_INT32
+ : SAL_MAX_INT32 < nD)
+ break;
+
+ rbOverflow = false;
+ Time aTime(nH, nM, nS, nN);
+ if (IsNegative() == (nMult < 0))
+ {
+ Duration aD(nD, aTime.GetTime());
+ return aD;
+ }
+ else
+ {
+ Duration aD(-static_cast<sal_Int64>(nD), -aTime.GetTime());
+ return aD;
+ }
+ } while (false);
+ }
+ assert(rbOverflow);
+ if (IsNegative() == (nMult < 0))
+ {
+ Duration aD(SAL_MAX_INT32, 0);
+ aD.ApplyTime(Time::nanoSecPerDay - 1);
+ return aD;
+ }
+ else
+ {
+ Duration aD(SAL_MIN_INT32, 0);
+ aD.ApplyTime(-(Time::nanoSecPerDay - 1));
+ return aD;
+ }
+}
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s
cinkeys+=0=break: */
