execute move of global headers

see https://gerrit.libreoffice.org/#/c/3367/
and Change-Id: I00c96fa77d04b33a6f8c8cd3490dfcd9bdc9e84a for details

Change-Id: I199a75bc4042af20817265d5ef85b1134a96ff5a

1 files changed, 136 insertions, 0 deletions

diff --git a/include/tools/time.hxx b/include/tools/time.hxx
new file mode 100644
index 000000000000..64751af42284
--- /dev/null
+++ b/include/tools/time.hxx
@@ -0,0 +1,136 @@
+/* -*- 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef _TOOLS_TIME_HXX
+#define _TOOLS_TIME_HXX
+
+#include "tools/toolsdllapi.h"
+#include <tools/solar.h>
+
+class ResId;
+
+/**
+ @WARNING: This class can serve both as wall clock time and time duration, and
+           the mixing of these concepts leads to problems such as there being
+           25 hours or 10 minus 20 seconds being (non-negative) 10 seconds.
+*/
+
+class TOOLS_DLLPUBLIC SAL_WARN_UNUSED Time
+{
+private:
+    sal_Int64       nTime;
+
+public:
+    enum TimeInitSystem
+    {
+        SYSTEM
+    };
+
+    // temporary until all uses are inspected and resolved
+    enum TimeInitEmpty
+    {
+        EMPTY
+    };
+    static const sal_Int64 hourPerDay = 24;
+    static const sal_Int64 minutePerHour = 60;
+    static const sal_Int64 secondPerMinute = 60;
+    static const sal_Int64 nanoSecPerSec = 1000000000;
+    static const sal_Int64 nanoSecPerMinute = nanoSecPerSec * secondPerMinute;
+    static const sal_Int64 nanoSecPerHour = nanoSecPerSec * secondPerMinute * minutePerHour;
+    static const sal_Int64 nanoSecPerDay = nanoSecPerSec * secondPerMinute * minutePerHour * hourPerDay;
+    static const sal_Int64 secondPerHour = secondPerMinute * minutePerHour;
+    static const sal_Int64 secondPerDay  = secondPerMinute * minutePerHour * hourPerDay;
+    static const sal_Int64 minutePerDay  = minutePerHour * hourPerDay;
+    static const sal_Int64 nanoPerMicro  = 1000;
+    static const sal_Int64 nanoPerMilli  = 1000000;
+    static const sal_Int64 nanoPerCenti  = 10000000;
+
+                    Time( TimeInitEmpty )
+                        { nTime = 0; }
+                    Time( TimeInitSystem );
+                    Time( const ResId & rResId );
+                    Time( sal_Int64 _nTime ) { Time::nTime = _nTime; }
+                    Time( const Time& rTime );
+                    Time( sal_uInt32 nHour, sal_uInt32 nMin,
+                          sal_uInt32 nSec = 0, sal_uInt64 nNanoSec = 0 );
+
+    void            SetTime( sal_Int64 nNewTime ) { nTime = nNewTime; }
+    sal_Int64       GetTime() const { return nTime; }
+
+    void            SetHour( sal_uInt16 nNewHour );
+    void            SetMin( sal_uInt16 nNewMin );
+    void            SetSec( sal_uInt16 nNewSec );
+    void            SetNanoSec( sal_uInt32 nNewNanoSec );
+    sal_uInt16      GetHour() const
+                    { sal_uInt64 nTempTime = (nTime >= 0) ? nTime : -nTime;
+                      return static_cast<sal_uInt16>(nTempTime / SAL_CONST_UINT64(10000000000000)); }
+    sal_uInt16      GetMin() const
+                    { sal_uInt64 nTempTime = (nTime >= 0) ? nTime : -nTime;
+                      return static_cast<sal_uInt16>((nTempTime / SAL_CONST_UINT64(100000000000)) % 100); }
+    sal_uInt16      GetSec() const
+                    { sal_uInt64 nTempTime = (nTime >= 0) ? nTime : -nTime;
+                      return static_cast<sal_uInt16>((nTempTime / SAL_CONST_UINT64(1000000000)) % 100); }
+    sal_uInt32      GetNanoSec() const
+                    { sal_uInt64 nTempTime = (nTime >= 0) ? nTime : -nTime;
+                      return static_cast<sal_uInt32>( nTempTime % SAL_CONST_UINT64(1000000000)); }
+
+    // TODO: consider removing GetMSFromTime and MakeTimeFromMS?
+    sal_Int32       GetMSFromTime() const;
+    void            MakeTimeFromMS( sal_Int32 nMS );
+    sal_Int64       GetNSFromTime() const;
+    void            MakeTimeFromNS( sal_Int64 nNS );
+
+                    /// 12 hours == 0.5 days
+    double          GetTimeInDays() const;
+
+    sal_Bool        IsBetween( const Time& rFrom, const Time& rTo ) const
+                    { return ((nTime >= rFrom.nTime) && (nTime <= rTo.nTime)); }
+
+    sal_Bool        IsEqualIgnoreNanoSec( const Time& rTime ) const;
+
+    sal_Bool        operator ==( const Time& rTime ) const
+                    { return (nTime == rTime.nTime); }
+    sal_Bool        operator !=( const Time& rTime ) const
+                    { return (nTime != rTime.nTime); }
+    sal_Bool        operator  >( const Time& rTime ) const
+                    { return (nTime > rTime.nTime); }
+    sal_Bool        operator  <( const Time& rTime ) const
+                    { return (nTime < rTime.nTime); }
+    sal_Bool        operator >=( const Time& rTime ) const
+                    { return (nTime >= rTime.nTime); }
+    sal_Bool        operator <=( const Time& rTime ) const
+                    { return (nTime <= rTime.nTime); }
+
+    static Time     GetUTCOffset();
+    static sal_uIntPtr  GetSystemTicks();       // Elapsed time
+
+    void            ConvertToUTC()       { *this -= Time::GetUTCOffset(); }
+    void            ConvertToLocalTime() { *this += Time::GetUTCOffset(); }
+
+    Time&           operator =( const Time& rTime );
+    Time            operator -() const
+                        { return Time( -nTime ); }
+    Time&           operator +=( const Time& rTime );
+    Time&           operator -=( const Time& rTime );
+    TOOLS_DLLPUBLIC friend Time     operator +( const Time& rTime1, const Time& rTime2 );
+    TOOLS_DLLPUBLIC friend Time     operator -( const Time& rTime1, const Time& rTime2 );
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */