include/salhelper/timer.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #ifndef INCLUDED_SALHELPER_TIMER_HXX
  22 #define INCLUDED_SALHELPER_TIMER_HXX
  23
  24 #include <salhelper/simplereferenceobject.hxx>
  25 #include <osl/time.h>
  26 #include <salhelper/salhelperdllapi.h>
  27
  28 namespace salhelper
  29 {
  30
  31 /** Helper class for easier manipulation with TimeValue.
  32  *
  33  *  Times are seconds in UTC since 01.01.1970
  34  */
  35 struct SAL_WARN_UNUSED TTimeValue : public TimeValue
  36 {
  37     TTimeValue()
  38     {
  39         Seconds = 0;
  40         Nanosec = 0;
  41     }
  42
  43     TTimeValue( sal_uInt32 Secs, sal_uInt32 Nano )
  44     {
  45         Seconds = Secs;
  46         Nanosec = Nano;
  47
  48         normalize();
  49     }
  50
  51     TTimeValue(sal_uInt32 MilliSecs)
  52     {
  53         Seconds = MilliSecs / 1000L;
  54         Nanosec = (MilliSecs % 1000) * 1000000L;
  55
  56         normalize();
  57     }
  58
  59     TTimeValue( const TTimeValue& rTimeValue ):
  60         TimeValue(rTimeValue)
  61     {
  62         normalize();
  63     }
  64
  65     TTimeValue( const TimeValue& rTimeValue )
  66     {
  67         Seconds = rTimeValue.Seconds;
  68         Nanosec = rTimeValue.Nanosec;
  69
  70         normalize();
  71     }
  72
  73     void SAL_CALL normalize()
  74     {
  75         if ( Nanosec > 1000000000 )
  76         {
  77             Seconds += Nanosec / 1000000000;
  78             Nanosec %= 1000000000;
  79         }
  80     }
  81
  82     void SAL_CALL addTime( const TTimeValue& Delta )
  83     {
  84         Seconds += Delta.Seconds;
  85         Nanosec += Delta.Nanosec;
  86
  87         normalize();
  88     }
  89
  90     bool SAL_CALL isEmpty() const
  91     {
  92         return ( ( Seconds == 0 ) && ( Nanosec == 0 ) );
  93     }
  94 };
  95
  96 inline bool operator<( const TTimeValue& rTimeA, const TTimeValue& rTimeB )
  97 {
  98     if ( rTimeA.Seconds < rTimeB.Seconds )
  99         return true;
 100     else if ( rTimeA.Seconds > rTimeB.Seconds )
 101         return false;
 102     else
 103         return ( rTimeA.Nanosec < rTimeB.Nanosec );
 104 }
 105
 106 inline bool operator>( const TTimeValue& rTimeA, const TTimeValue& rTimeB )
 107 {
 108     if ( rTimeA.Seconds > rTimeB.Seconds )
 109         return true;
 110     else if ( rTimeA.Seconds < rTimeB.Seconds )
 111         return false;
 112     else
 113         return ( rTimeA.Nanosec > rTimeB.Nanosec );
 114 }
 115
 116 inline bool operator==( const TTimeValue& rTimeA, const TTimeValue& rTimeB )
 117 {
 118     return ( ( rTimeA.Seconds == rTimeB.Seconds ) &&
 119              ( rTimeA.Nanosec == rTimeB.Nanosec ) );
 120 }
 121
 122 class TimerManager;
 123
 124 /** Interface for the Timer and handling the event
 125 */
 126 class SALHELPER_DLLPUBLIC Timer : public salhelper::SimpleReferenceObject
 127 {
 128 public:
 129
 130     /** Constructor.
 131      */
 132     Timer();
 133
 134     /** Constructor.
 135      */
 136     Timer( const TTimeValue& Time );
 137
 138     /** Constructor.
 139      */
 140     Timer( const TTimeValue& Time, const TTimeValue& RepeatTime );
 141
 142     /** Start timer.
 143      */
 144     void        SAL_CALL start();
 145
 146     /** Abort timer prematurely.
 147      */
 148     void        SAL_CALL stop();
 149
 150     /** Returns sal_True if timer is running.
 151      */
 152     sal_Bool    SAL_CALL isTicking() const;
 153
 154     /** Is the timer expired?
 155      */
 156     sal_Bool    SAL_CALL isExpired() const;
 157
 158     /** Does pTimer expires before us?
 159      */
 160     sal_Bool    SAL_CALL expiresBefore( const Timer* pTimer ) const;
 161
 162     /** Set the absolute time when the timer should fire.
 163      */
 164     void        SAL_CALL setAbsoluteTime( const TTimeValue& Time );
 165
 166     /** Set the time to fire to 'now' + Remaining.
 167      */
 168     void        SAL_CALL setRemainingTime( const TTimeValue& Remaining );
 169
 170     /** Set the time to fire to 'now' + Remaining with repeat interveal
 171      * Repeat.
 172      */
 173     void        SAL_CALL setRemainingTime( const TTimeValue& Remaining, const TTimeValue& Repeat );
 174
 175     /** Adds Time to the 'fire time'.
 176      */
 177     void        SAL_CALL addTime( const TTimeValue& Time );
 178
 179     /** Returns the remaining time before timer expiration relative to now.
 180      */
 181     TTimeValue  SAL_CALL getRemainingTime() const;
 182
 183 protected:
 184
 185     /** Destructor.
 186      */
 187     virtual ~Timer() SAL_OVERRIDE;
 188
 189     /** What should be done when the 'timer fires'.
 190      */
 191     virtual void SAL_CALL onShot() = 0;
 192
 193 protected:
 194
 195     /** holds (initial) exparation time of this timer.
 196      */
 197     TTimeValue  m_aTimeOut;
 198
 199     /** holds the time of exparation of this timer.
 200      */
 201     TTimeValue  m_aExpired;
 202
 203     /** holds the time interveal of successive expirations.
 204      */
 205     TTimeValue  m_aRepeatDelta;
 206
 207     /** Pointer to the next timer (to fire).
 208      */
 209     Timer*      m_pNext;
 210
 211 private:
 212
 213     /** Copy constructor deleted.
 214      */
 215     Timer( const Timer& rTimer ) SAL_DELETED_FUNCTION;
 216
 217     /** Copy assignment operator deleted.
 218      */
 219     void SAL_CALL operator=( const Timer& rTimer ) SAL_DELETED_FUNCTION;
 220
 221     friend class TimerManager;
 222 };
 223
 224 }
 225
 226 #endif // INCLUDED_SALHELPER_TIMER_HXX
 227
 228 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */