include/osl/thread.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 #ifndef INCLUDED_OSL_THREAD_HXX
  21 #define INCLUDED_OSL_THREAD_HXX
  22
  23 #include <sal/config.h>
  24
  25 #include <cassert>
  26 #include <cstddef>
  27
  28 #include <osl/time.h>
  29 #include <osl/thread.h>
  30 #include <rtl/alloc.h>
  31
  32 namespace osl
  33 {
  34 /** threadFunc is the function which is executed by the threads
  35     created by the osl::Thread class. The function's signature
  36     matches the one of oslWorkerFunction which is declared in
  37     osl/thread.h .
  38 */
  39 extern "C" inline void SAL_CALL threadFunc( void* param);
  40
  41 /**
  42    A thread abstraction.
  43
  44    @deprecated use ::salhelper::Thread instead.  Only the static member
  45    functions ::osl::Thread::getCurrentIdentifier, ::osl::Thread::wait, and
  46    ::osl::Thread::yield are not deprecated.
  47  */
  48 class Thread
  49 {
  50     Thread( const Thread& ) SAL_DELETED_FUNCTION;
  51     Thread& operator= ( const Thread& ) SAL_DELETED_FUNCTION;
  52 public:
  53     // these are here to force memory de/allocation to sal lib.
  54     static void * SAL_CALL operator new( size_t nSize )
  55         { return ::rtl_allocateMemory( nSize ); }
  56     static void SAL_CALL operator delete( void * pMem )
  57         { ::rtl_freeMemory( pMem ); }
  58     static void * SAL_CALL operator new( size_t, void * pMem )
  59         { return pMem; }
  60     static void SAL_CALL operator delete( void *, void * )
  61         {}
  62
  63     Thread(): m_hThread(NULL){}
  64
  65     virtual  ~Thread()
  66     {
  67         osl_destroyThread( m_hThread);
  68     }
  69
  70     bool SAL_CALL create()
  71     {
  72         assert(m_hThread == NULL); // only one running thread per instance
  73         m_hThread = osl_createSuspendedThread( threadFunc, static_cast<void*>(this));
  74         if (m_hThread == NULL)
  75         {
  76             return false;
  77         }
  78         osl_resumeThread(m_hThread);
  79         return true;
  80     }
  81
  82     bool SAL_CALL createSuspended()
  83     {
  84         assert(m_hThread == NULL); // only one running thread per instance
  85         if( m_hThread)
  86             return false;
  87         m_hThread= osl_createSuspendedThread( threadFunc,
  88                                              static_cast<void*>(this));
  89         return m_hThread != NULL;
  90     }
  91
  92     virtual void SAL_CALL suspend()
  93     {
  94         if( m_hThread )
  95             osl_suspendThread(m_hThread);
  96     }
  97
  98     virtual void SAL_CALL resume()
  99     {
 100         if( m_hThread )
 101             osl_resumeThread(m_hThread);
 102     }
 103
 104     virtual void SAL_CALL terminate()
 105     {
 106         if( m_hThread )
 107             osl_terminateThread(m_hThread);
 108     }
 109
 110     virtual void SAL_CALL join()
 111     {
 112         osl_joinWithThread(m_hThread);
 113     }
 114
 115     bool SAL_CALL isRunning() const
 116     {
 117         return osl_isThreadRunning(m_hThread);
 118     }
 119
 120     void SAL_CALL setPriority( oslThreadPriority Priority)
 121     {
 122         if( m_hThread )
 123             osl_setThreadPriority(m_hThread, Priority);
 124     }
 125
 126     oslThreadPriority SAL_CALL getPriority() const
 127     {
 128         return m_hThread ? osl_getThreadPriority(m_hThread) : osl_Thread_PriorityUnknown;
 129     }
 130
 131     oslThreadIdentifier SAL_CALL getIdentifier() const
 132     {
 133         return osl_getThreadIdentifier(m_hThread);
 134     }
 135
 136     static oslThreadIdentifier SAL_CALL getCurrentIdentifier()
 137     {
 138         return osl_getThreadIdentifier(NULL);
 139     }
 140
 141     static void SAL_CALL wait(const TimeValue& Delay)
 142     {
 143         osl_waitThread(&Delay);
 144     }
 145
 146     static void SAL_CALL yield()
 147     {
 148         osl_yieldThread();
 149     }
 150
 151     static void setName(char const * name) throw () {
 152         osl_setThreadName(name);
 153     }
 154
 155     virtual bool SAL_CALL schedule()
 156     {
 157         return m_hThread && osl_scheduleThread(m_hThread);
 158     }
 159
 160     SAL_CALL operator oslThread() const
 161     {
 162         return m_hThread;
 163     }
 164
 165 protected:
 166
 167     /** The thread functions calls the protected functions
 168         run and onTerminated.
 169     */
 170     friend void SAL_CALL threadFunc( void* param);
 171
 172     virtual void SAL_CALL run() = 0;
 173
 174     virtual void SAL_CALL onTerminated()
 175     {
 176     }
 177
 178 private:
 179     oslThread m_hThread;
 180 };
 181
 182 extern "C" inline void SAL_CALL threadFunc( void* param)
 183 {
 184         Thread* pObj= static_cast<Thread*>(param);
 185         pObj->run();
 186         pObj->onTerminated();
 187 }
 188
 189 class ThreadData
 190 {
 191     ThreadData( const ThreadData& ) SAL_DELETED_FUNCTION;
 192     ThreadData& operator= (const ThreadData& ) SAL_DELETED_FUNCTION;
 193 public:
 194      /// Create a thread specific local data key
 195     ThreadData( oslThreadKeyCallbackFunction pCallback= NULL )
 196     {
 197         m_hKey = osl_createThreadKey( pCallback );
 198     }
 199
 200     /// Destroy a thread specific local data key
 201     ~ThreadData()
 202     {
 203            osl_destroyThreadKey(m_hKey);
 204     }
 205
 206     /** Set the data associated with the data key.
 207         @returns True if operation was successful
 208     */
 209     bool SAL_CALL setData(void *pData)
 210     {
 211            return (osl_setThreadKeyData(m_hKey, pData));
 212     }
 213
 214     /** Get the data associated with the data key.
 215         @returns The data associated with the data key or
 216         NULL if no data was set
 217     */
 218     void* SAL_CALL getData()
 219     {
 220            return osl_getThreadKeyData(m_hKey);
 221     }
 222
 223     operator oslThreadKey() const
 224     {
 225         return m_hKey;
 226     }
 227
 228 private:
 229     oslThreadKey m_hKey;
 230 };
 231
 232 } // end namespace osl
 233
 234 #endif
 235
 236 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */