salhelper/source/timer.cxx

   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 #include <salhelper/timer.hxx>
  20
  21 #include <osl/diagnose.h>
  22 #include <salhelper/simplereferenceobject.hxx>
  23 #include <osl/thread.hxx>
  24 #include <osl/conditn.hxx>
  25 #include <osl/mutex.hxx>
  26 #include <rtl/instance.hxx>
  27
  28 using namespace salhelper;
  29
  30 class salhelper::TimerManager : public osl::Thread
  31 {
  32
  33 public:
  34
  35     ///
  36     TimerManager();
  37
  38     ///
  39     ~TimerManager();
  40
  41     /// register timer
  42     sal_Bool SAL_CALL registerTimer(salhelper::Timer* pTimer);
  43
  44     /// unregister timer
  45     sal_Bool SAL_CALL unregisterTimer(salhelper::Timer* pTimer);
  46
  47     /// lookup timer
  48     sal_Bool SAL_CALL lookupTimer(const salhelper::Timer* pTimer);
  49
  50     /// retrieves the "Singleton" TimerManager Instance
  51     static TimerManager* SAL_CALL getTimerManager();
  52
  53
  54 protected:
  55
  56     /// worker-function of thread
  57     virtual void SAL_CALL run();
  58
  59     // Checking and triggering of a timer event
  60     void SAL_CALL checkForTimeout();
  61
  62     // cleanup Method
  63     virtual void SAL_CALL onTerminated();
  64
  65     // sorted-queue data
  66     salhelper::Timer*       m_pHead;
  67     // List Protection
  68     osl::Mutex                  m_Lock;
  69     // Signal the insertion of a timer
  70     osl::Condition              m_notEmpty;
  71
  72     // "Singleton Pattern"
  73     static salhelper::TimerManager* m_pManager;
  74
  75 };
  76
  77 /////////////////////////////////////////////////////////////////////////////
  78 //
  79 // Timer class
  80 //
  81
  82 Timer::Timer()
  83     : m_aTimeOut( 0 ),
  84       m_aExpired( 0 ),
  85       m_aRepeatDelta( 0 ),
  86       m_pNext( NULL )
  87 {
  88 }
  89
  90 Timer::Timer( const TTimeValue& Time )
  91     : m_aTimeOut( Time ),
  92       m_aExpired( 0 ),
  93       m_aRepeatDelta( 0 ),
  94       m_pNext( NULL )
  95 {
  96 }
  97
  98 Timer::Timer( const TTimeValue& Time, const TTimeValue& Repeat )
  99     : m_aTimeOut( Time ),
 100       m_aExpired( 0 ),
 101       m_aRepeatDelta( Repeat ),
 102       m_pNext( NULL )
 103 {
 104 }
 105
 106 Timer::~Timer()
 107 {
 108     stop();
 109 }
 110
 111 void Timer::start()
 112 {
 113     if (! isTicking())
 114     {
 115         if (! m_aTimeOut.isEmpty())
 116             setRemainingTime(m_aTimeOut);
 117
 118         TimerManager *pManager = TimerManager::getTimerManager();
 119
 120         OSL_ASSERT(pManager);
 121
 122         if ( pManager != 0 )
 123         {
 124             pManager->registerTimer(this);
 125         }
 126     }
 127 }
 128
 129 void Timer::stop()
 130 {
 131     TimerManager *pManager = TimerManager::getTimerManager();
 132
 133     OSL_ASSERT(pManager);
 134
 135     if ( pManager != 0 )
 136     {
 137         pManager->unregisterTimer(this);
 138     }
 139 }
 140
 141 sal_Bool Timer::isTicking() const
 142 {
 143     TimerManager *pManager = TimerManager::getTimerManager();
 144
 145     OSL_ASSERT(pManager);
 146
 147     if (pManager)
 148         return pManager->lookupTimer(this);
 149     else
 150         return sal_False;
 151
 152 }
 153
 154 sal_Bool Timer::isExpired() const
 155 {
 156     TTimeValue Now;
 157
 158     osl_getSystemTime(&Now);
 159
 160     return !(Now < m_aExpired);
 161 }
 162
 163 sal_Bool Timer::expiresBefore(const Timer* pTimer) const
 164 {
 165     OSL_ASSERT(pTimer);
 166
 167     if ( pTimer != 0 )
 168     {
 169         return m_aExpired < pTimer->m_aExpired;
 170     }
 171     else
 172     {
 173         return sal_False;
 174     }
 175 }
 176
 177 void Timer::setAbsoluteTime(const TTimeValue& Time)
 178 {
 179     m_aTimeOut     = 0;
 180     m_aExpired     = Time;
 181     m_aRepeatDelta = 0;
 182
 183     m_aExpired.normalize();
 184 }
 185
 186 void Timer::setRemainingTime(const TTimeValue& Remaining)
 187 {
 188     osl_getSystemTime(&m_aExpired);
 189
 190     m_aExpired.addTime(Remaining);
 191 }
 192
 193 void Timer::setRemainingTime(const TTimeValue& Remaining, const TTimeValue& Repeat)
 194 {
 195     osl_getSystemTime(&m_aExpired);
 196
 197     m_aExpired.addTime(Remaining);
 198
 199     m_aRepeatDelta = Repeat;
 200 }
 201
 202 void Timer::addTime(const TTimeValue& Delta)
 203 {
 204     m_aExpired.addTime(Delta);
 205 }
 206
 207 TTimeValue Timer::getRemainingTime() const
 208 {
 209     TTimeValue Now;
 210
 211     osl_getSystemTime(&Now);
 212
 213     sal_Int32 secs = m_aExpired.Seconds - Now.Seconds;
 214
 215     if (secs < 0)
 216         return TTimeValue(0, 0);
 217
 218     sal_Int32 nsecs = m_aExpired.Nanosec - Now.Nanosec;
 219
 220     if (nsecs < 0)
 221     {
 222         if (secs > 0)
 223         {
 224             secs  -= 1;
 225             nsecs += 1000000000L;
 226         }
 227         else
 228             return TTimeValue(0, 0);
 229     }
 230
 231     return TTimeValue(secs, nsecs);
 232 }
 233
 234
 235 /////////////////////////////////////////////////////////////////////////////
 236 //
 237 // Timer manager
 238 //
 239 namespace
 240 {
 241     // Synchronize access to TimerManager
 242     struct theTimerManagerMutex : public rtl::Static< osl::Mutex, theTimerManagerMutex> {};
 243 }
 244
 245 TimerManager* salhelper::TimerManager::m_pManager = NULL;
 246
 247 TimerManager::TimerManager()
 248 {
 249     osl::MutexGuard Guard(theTimerManagerMutex::get());
 250
 251     OSL_ASSERT(m_pManager == 0);
 252
 253     m_pManager = this;
 254
 255     m_pHead= 0;
 256
 257     m_notEmpty.reset();
 258
 259     // start thread
 260     create();
 261 }
 262
 263 TimerManager::~TimerManager()
 264 {
 265     osl::MutexGuard Guard(theTimerManagerMutex::get());
 266
 267     if ( m_pManager == this )
 268         m_pManager = 0;
 269 }
 270
 271 void TimerManager::onTerminated()
 272 {
 273     delete this; // mfe: AAARRRGGGHHH!!!
 274 }
 275
 276 TimerManager* TimerManager::getTimerManager()
 277 {
 278     osl::MutexGuard Guard(theTimerManagerMutex::get());
 279
 280     if (! m_pManager)
 281         new TimerManager;
 282
 283     return m_pManager;
 284 }
 285
 286 sal_Bool TimerManager::registerTimer(Timer* pTimer)
 287 {
 288     OSL_ASSERT(pTimer);
 289
 290     if ( pTimer == 0 )
 291     {
 292         return sal_False;
 293     }
 294
 295     osl::MutexGuard Guard(m_Lock);
 296
 297     // try to find one with equal or lower remaining time.
 298     Timer** ppIter = &m_pHead;
 299
 300     while (*ppIter)
 301     {
 302         if (pTimer->expiresBefore(*ppIter))
 303         {
 304             // next element has higher remaining time,
 305             // => insert new timer before
 306             break;
 307         }
 308         ppIter= &((*ppIter)->m_pNext);
 309     }
 310
 311     // next element has higher remaining time,
 312     // => insert new timer before
 313     pTimer->m_pNext= *ppIter;
 314     *ppIter = pTimer;
 315
 316
 317     if (pTimer == m_pHead)
 318     {
 319         // it was inserted as new head
 320         // signal it to TimerManager Thread
 321         m_notEmpty.set();
 322     }
 323
 324     return sal_True;
 325 }
 326
 327 sal_Bool TimerManager::unregisterTimer(Timer* pTimer)
 328 {
 329     OSL_ASSERT(pTimer);
 330
 331     if ( pTimer == 0 )
 332     {
 333         return sal_False;
 334     }
 335
 336     // lock access
 337     osl::MutexGuard Guard(m_Lock);
 338
 339     Timer** ppIter = &m_pHead;
 340
 341     while (*ppIter)
 342     {
 343         if (pTimer == (*ppIter))
 344         {
 345             // remove timer from list
 346             *ppIter = (*ppIter)->m_pNext;
 347             return sal_True;
 348         }
 349         ppIter= &((*ppIter)->m_pNext);
 350     }
 351
 352     return sal_False;
 353 }
 354
 355 sal_Bool TimerManager::lookupTimer(const Timer* pTimer)
 356 {
 357     OSL_ASSERT(pTimer);
 358
 359     if ( pTimer == 0 )
 360     {
 361         return sal_False;
 362     }
 363
 364     // lock access
 365     osl::MutexGuard Guard(m_Lock);
 366
 367     // check the list
 368     for (Timer* pIter = m_pHead; pIter != 0; pIter= pIter->m_pNext)
 369     {
 370         if (pIter == pTimer)
 371         {
 372             return sal_True;
 373         }
 374     }
 375
 376     return sal_False;
 377 }
 378
 379 void TimerManager::checkForTimeout()
 380 {
 381
 382     m_Lock.acquire();
 383
 384     if ( m_pHead == 0 )
 385     {
 386         m_Lock.release();
 387         return;
 388     }
 389
 390     Timer* pTimer = m_pHead;
 391
 392     if (pTimer->isExpired())
 393     {
 394         // remove expired timer
 395         m_pHead = pTimer->m_pNext;
 396
 397         pTimer->acquire();
 398
 399         m_Lock.release();
 400
 401         pTimer->onShot();
 402
 403         // restart timer if specified
 404         if ( ! pTimer->m_aRepeatDelta.isEmpty() )
 405         {
 406             TTimeValue Now;
 407
 408             osl_getSystemTime(&Now);
 409
 410             Now.Seconds += pTimer->m_aRepeatDelta.Seconds;
 411             Now.Nanosec += pTimer->m_aRepeatDelta.Nanosec;
 412
 413             pTimer->m_aExpired = Now;
 414
 415             registerTimer(pTimer);
 416         }
 417         pTimer->release();
 418     }
 419     else
 420     {
 421         m_Lock.release();
 422     }
 423
 424
 425     return;
 426 }
 427
 428 void TimerManager::run()
 429 {
 430     setPriority( osl_Thread_PriorityBelowNormal );
 431
 432     while (schedule())
 433     {
 434         TTimeValue      delay;
 435         TTimeValue*     pDelay=0;
 436
 437
 438         m_Lock.acquire();
 439
 440         if (m_pHead != 0)
 441         {
 442             delay = m_pHead->getRemainingTime();
 443             pDelay=&delay;
 444         }
 445         else
 446         {
 447             pDelay=0;
 448         }
 449
 450
 451         m_notEmpty.reset();
 452
 453         m_Lock.release();
 454
 455
 456         m_notEmpty.wait(pDelay);
 457
 458         checkForTimeout();
 459     }
 460
 461 }
 462
 463
 464 /////////////////////////////////////////////////////////////////////////////
 465 //
 466 // Timer manager cleanup
 467 //
 468
 469 // jbu:
 470 // The timer manager cleanup has been removed (no thread is killed anymore).
 471 // So the thread leaks.
 472 // This will result in a GPF in case the salhelper-library gets unloaded before
 473 // process termination.
 474 // -> TODO : rewrite this file, so that the timerManager thread gets destroyed,
 475 //           when there are no timers anymore !
 476
 477 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */