moved winix directories to winixd subdirectory

git-svn-id: svn://ttmath.org/publicrep/winix/trunk@1027 e52654a7-88a9-db11-a3e9-0013d4bc506e

winixd/core/basethread.cpp

@@ -0,0 +1,271 @@
+/*
+ * This file is a part of Winix
+ * and is distributed under the 2-Clause BSD licence.
+ * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ */
+
+/* 
+ * Copyright (c) 2010-2014, Tomasz Sowa
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+ 
+#include <errno.h>
+#include "basethread.h"
+
+
+namespace Winix
+{
+
+
+BaseThread::BaseThread() : thread_signal(PTHREAD_COND_INITIALIZER)
+{
+	synchro         = 0;
+	thread_id       = 0;
+	work_mode       = 0;
+	wake_up_was_called = false;
+}
+
+
+
+void BaseThread::SetSynchro(Synchro * psynchro)
+{
+	synchro = psynchro;
+}
+
+
+
+void BaseThread::Mode(int mode)
+{
+	work_mode = mode;
+}
+
+
+pthread_t BaseThread::ThreadId()
+{
+	return thread_id;
+}
+
+
+
+bool BaseThread::Lock()
+{
+	return synchro->Lock();
+}
+
+
+void BaseThread::Unlock()
+{
+	synchro->Unlock();
+}
+
+
+
+bool BaseThread::IsExitSignal()
+{
+bool res = true;
+
+	if( Lock() )
+	{
+		res = synchro->was_stop_signal;
+		Unlock();
+	}
+
+return res;
+}
+
+
+bool BaseThread::BaseInit()
+{
+bool init_status = false;
+
+	if( Lock() )
+	{
+		init_status = Init();	// your virtual method
+		Unlock();
+	}
+
+return init_status;
+}
+
+
+void BaseThread::BaseUninit()
+{
+	if( Lock() )
+	{
+		Uninit();		// your virtual method
+		Unlock();
+	}
+}
+
+
+
+
+bool BaseThread::BaseSignalReceived()
+{
+bool make_do = false;
+
+	wake_up_was_called = false;
+
+	try
+	{
+		make_do = SignalReceived(); // your short-time virtual method (objects are locked)
+	}
+	catch(...)
+	{
+	}
+
+return make_do;
+}
+
+
+// this is called only if your SignalReceived() returned true
+void BaseThread::BaseDo()
+{
+	try
+	{
+		Do(); // your long-time virtual method (objects are *not* locked)
+	}
+	catch(...)
+	{
+	}
+}
+
+
+// use it with Lock and Unlock
+bool BaseThread::WaitForSignal()
+{
+	if( synchro->was_stop_signal || wake_up_was_called )
+		return true;
+
+	return pthread_cond_wait(&thread_signal, &synchro->mutex) == 0;
+}
+
+
+
+// you should use this method with: synchro->Lock() and Unlock()
+void BaseThread::WakeUpThread()
+{
+	wake_up_was_called = true;
+	pthread_cond_signal(&thread_signal);
+}
+
+
+// use it with Lock and Unlock
+// it breaks only if there was a stop signal or the time has expired
+bool BaseThread::WaitForSignalSleep(time_t second)
+{
+timespec t;
+int res;
+
+	if( synchro->was_stop_signal )
+		return true;
+
+	t.tv_sec  = time(0) + second;
+	t.tv_nsec = 0;
+
+	do
+	{
+		res = pthread_cond_timedwait(&thread_signal, &synchro->mutex, &t);
+	}
+	while( res == 0 && !synchro->was_stop_signal );
+	// above condition means there was a signal
+	// but it was not a stop signal so we should still wait
+
+return res == 0 || res == ETIMEDOUT;
+}
+
+
+void BaseThread::WaitForThread()
+{
+	pthread_join(thread_id, 0);
+}
+
+
+void BaseThread::SignalLoop()
+{
+bool make_do;
+
+	do
+	{
+		if( Lock() )
+		{
+			make_do = false;
+
+			if( WaitForSignal() )					// automatically unlock, wait and lock again when signal comes
+				if( !synchro->was_stop_signal )
+					make_do = BaseSignalReceived();	// your short-time virtual method will be called (objects locked)
+	
+			Unlock();								// unlocking from WaitForSignal()
+
+			if( make_do )
+				BaseDo();							// your long-time virtual method will be called (objects *not* locked)
+		}
+	}
+	while( !IsExitSignal() );
+}
+
+
+void * BaseThread::StartRoutine(void * this_object)
+{
+	BaseThread * base = reinterpret_cast<BaseThread*>(this_object);
+
+	if( base->synchro )
+	{
+		if( base->BaseInit() )
+		{
+			if( base->work_mode == 0 )
+				base->SignalLoop();
+			else
+				base->Work();
+
+			base->BaseUninit();
+		}
+	}
+
+	pthread_exit(0);
+	return 0;
+}
+
+
+
+bool BaseThread::StartThread()
+{
+pthread_attr_t attr;
+
+	pthread_attr_init(&attr);
+	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+	int res = pthread_create(&thread_id, &attr, StartRoutine, this);
+
+	pthread_attr_destroy(&attr);
+
+return res == 0;
+}
+
+
+} // namespace Winix
+
+