/* -*- 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 .
 */

/*
 * This file is part of LibreOffice published API.
 */

#ifndef INCLUDED_OSL_THREAD_HXX
#define INCLUDED_OSL_THREAD_HXX

#include "sal/config.h"

#include <cassert>
#include <cstddef>

#include "osl/time.h"
#include "osl/thread.h"
#include "rtl/alloc.h"

namespace osl
{
/** threadFunc is the function which is executed by the threads
    created by the osl::Thread class. The function's signature
    matches the one of oslWorkerFunction which is declared in
    osl/thread.h
*/
extern "C" inline void SAL_CALL threadFunc( void* param);

/**
   A thread abstraction.

   @deprecated use ::salhelper::Thread instead.  Only the static member
   functions ::osl::Thread::getCurrentIdentifier, ::osl::Thread::wait, and
   ::osl::Thread::yield are not deprecated.
 */
class Thread
{
    Thread( const Thread& ) SAL_DELETED_FUNCTION;
    Thread& operator= ( const Thread& ) SAL_DELETED_FUNCTION;
public:
    // these are here to force memory de/allocation to sal lib.
    static void * SAL_CALL operator new( size_t nSize )
        { return ::rtl_allocateMemory( nSize ); }
    static void SAL_CALL operator delete( void * pMem )
        { ::rtl_freeMemory( pMem ); }
    static void * SAL_CALL operator new( size_t, void * pMem )
        { return pMem; }
    static void SAL_CALL operator delete( void *, void * )
        {}

    Thread(): m_hThread(NULL){}

    virtual  ~Thread() COVERITY_NOEXCEPT_FALSE
    {
        osl_destroyThread( m_hThread);
    }

    bool SAL_CALL create()
    {
        assert(m_hThread == NULL); // only one running thread per instance
        m_hThread = osl_createSuspendedThread( threadFunc, static_cast<void*>(this));
        if (m_hThread == NULL)
        {
            return false;
        }
        osl_resumeThread(m_hThread);
        return true;
    }

    bool SAL_CALL createSuspended()
    {
        assert(m_hThread == NULL); // only one running thread per instance
        if( m_hThread)
            return false;
        m_hThread= osl_createSuspendedThread( threadFunc,
                                             static_cast<void*>(this));
        return m_hThread != NULL;
    }

    virtual void SAL_CALL suspend()
    {
        if( m_hThread )
            osl_suspendThread(m_hThread);
    }

    virtual void SAL_CALL resume()
    {
        if( m_hThread )
            osl_resumeThread(m_hThread);
    }

    virtual void SAL_CALL terminate()
    {
        if( m_hThread )
            osl_terminateThread(m_hThread);
    }

    virtual void SAL_CALL join()
    {
        osl_joinWithThread(m_hThread);
    }

    bool SAL_CALL isRunning() const
    {
        return osl_isThreadRunning(m_hThread);
    }

    void SAL_CALL setPriority( oslThreadPriority Priority)
    {
        if( m_hThread )
            osl_setThreadPriority(m_hThread, Priority);
    }

    oslThreadPriority SAL_CALL getPriority() const
    {
        return m_hThread ? osl_getThreadPriority(m_hThread) : osl_Thread_PriorityUnknown;
    }

    oslThreadIdentifier SAL_CALL getIdentifier() const
    {
        return osl_getThreadIdentifier(m_hThread);
    }

    static oslThreadIdentifier SAL_CALL getCurrentIdentifier()
    {
        return osl_getThreadIdentifier(NULL);
    }

    static void SAL_CALL wait(const TimeValue& Delay)
    {
        osl_waitThread(&Delay);
    }

    static void SAL_CALL yield()
    {
        osl_yieldThread();
    }

    static void setName(char const * name) SAL_NOEXCEPT {
        osl_setThreadName(name);
    }

    virtual bool SAL_CALL schedule()
    {
        return m_hThread && osl_scheduleThread(m_hThread);
    }

    SAL_CALL operator oslThread() const
    {
        return m_hThread;
    }

protected:

    /** The thread functions calls the protected functions
        run and onTerminated.
    */
    friend void SAL_CALL threadFunc( void* param);

    virtual void SAL_CALL run() = 0;

    virtual void SAL_CALL onTerminated()
    {
    }

private:
    oslThread m_hThread;
};

extern "C" inline void SAL_CALL threadFunc( void* param)
{
        Thread* pObj= static_cast<Thread*>(param);
        pObj->run();
        pObj->onTerminated();
}

class ThreadData
{
    ThreadData( const ThreadData& ) SAL_DELETED_FUNCTION;
    ThreadData& operator= (const ThreadData& ) SAL_DELETED_FUNCTION;
public:
     /// Create a thread specific local data key
    ThreadData( oslThreadKeyCallbackFunction pCallback= NULL )
    {
        m_hKey = osl_createThreadKey( pCallback );
    }

    /// Destroy a thread specific local data key
    ~ThreadData()
    {
           osl_destroyThreadKey(m_hKey);
    }

    /** Set the data associated with the data key.
        @returns True if operation was successful
    */
    bool SAL_CALL setData(void *pData)
    {
           return osl_setThreadKeyData(m_hKey, pData);
    }

    /** Get the data associated with the data key.
        @returns The data associated with the data key or
        NULL if no data was set
    */
    void* SAL_CALL getData()
    {
           return osl_getThreadKeyData(m_hKey);
    }

    operator oslThreadKey() const
    {
        return m_hKey;
    }

private:
    oslThreadKey m_hKey;
};

} // end namespace osl

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */