/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#ifndef _THREAD_HXX_
#define _THREAD_HXX_

#ifdef __cplusplus

#include <osl/time.h>


#include <osl/diagnose.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);

class Thread
{
	Thread( const Thread& );
	Thread& operator= ( const Thread& );
public:
	// these are here to force memory de/allocation to sal lib.
	inline static void * SAL_CALL operator new( size_t nSize ) SAL_THROW (())
		{ return ::rtl_allocateMemory( nSize ); }
	inline static void SAL_CALL operator delete( void * pMem ) SAL_THROW (())
		{ ::rtl_freeMemory( pMem ); }
	inline static void * SAL_CALL operator new( size_t, void * pMem ) SAL_THROW (())
		{ return pMem; }
	inline static void SAL_CALL operator delete( void *, void * ) SAL_THROW (())
		{}

	Thread(): m_hThread(0){}

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

	sal_Bool SAL_CALL create()
	{
		OSL_ASSERT(m_hThread == 0); // only one running thread per instance
		if( m_hThread )
			return sal_False;

		m_hThread = osl_createSuspendedThread( threadFunc, (void*)this);
		if( m_hThread )
			osl_resumeThread(m_hThread);

		return m_hThread != 0;
	}

	sal_Bool SAL_CALL createSuspended()
	{
		OSL_ASSERT(m_hThread == 0); // only one running thread per instance
		if( m_hThread )
			return sal_False;

		m_hThread= osl_createSuspendedThread( threadFunc, (void*)this);

		return m_hThread != 0;
	}

	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);
	}

	sal_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(0);
	}

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

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

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

	virtual sal_Bool SAL_CALL schedule()
	{
		return m_hThread ? osl_scheduleThread(m_hThread) : sal_False;
	}

	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= (Thread*)param;
		pObj->run();
		pObj->onTerminated();
}

class ThreadData
{
	ThreadData( const ThreadData& );
	ThreadData& operator= (const ThreadData& );
public:
 	/// Create a thread specific local data key
	ThreadData( oslThreadKeyCallbackFunction pCallback= 0 )
	{
		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
	*/
	sal_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
#endif