Thread.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2012 SCHUNK GmbH & Co. KG
 * Copyright (c) 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
 *
 * Licensed 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.
 */

#include "Thread.h"

#if defined(__LINUX__)  
void* threadFunction(void* pvThread)
{
        CThread* pclThread = (CThread*)pvThread;
        (pclThread->m_pfuThreadFunction)(pclThread);
        return NULL;
}
#endif

#if defined(__QNX__)    
void threadFunction(void* pvThread)
{
        CThread* pclThread = (CThread*)pvThread;
        (pclThread->m_pfuThreadFunction)(pclThread);
}
#endif

#if defined(_WIN32)     
unsigned int __stdcall threadFunction(void* pvThread)
{
        CThread* pclThread = (CThread*)pvThread;
        (pclThread->m_pfuThreadFunction)(pclThread);
        return 0;
}
#endif

// ========================================================================== ;
//                                                                            ;
// ---- constructors / destructor ------------------------------------------- ;
//                                                                            ;
// ========================================================================== ;

CThread::CThread(void) : CMessage("CThread", g_iDebugLevel, g_bDebug, g_bDebugFile),
                                                 m_uiStackSize(1228000), 
                                                 m_pcStack(0),
                                                 m_hThreadHandle(0),
                                                 m_bThreadRunFlag(false),
                                                 m_bThreadStopFlag(false),
                                                 m_pvThreadObject(0),
                                                 m_pfuThreadFunction(0)
{
}

CThread::CThread(const CThread& clThread)
{
        error(-1, "copy contructor : method should no be called!");
}

CThread::~CThread(void)
{
        debug(1, "destructed");
}

// ========================================================================== ;
//                                                                            ;
// ---- operators ----------------------------------------------------------- ;
//                                                                            ;
// ========================================================================== ;

CThread& CThread::operator=(const CThread& clThread)
{
        error(-1, "assignment operator : method should not be called!");
        return *this;
}

// ========================================================================== ;
//                                                                            ;
// ---- query functions ----------------------------------------------------- ;
//                                                                            ;
// ========================================================================== ;

// ========================================================================== ;
//                                                                            ;
// ---- modify functions ---------------------------------------------------- ;
//                                                                            ;
// ========================================================================== ;

void CThread::setThreadStackSize(unsigned int uiSize)
{
        m_uiStackSize = uiSize;
}

// ========================================================================== ;
//                                                                            ;
// ---- I/O functions ------------------------------------------------------- ;
//                                                                            ;
// ========================================================================== ;

// ========================================================================== ;
//                                                                            ;
// ---- exec functions ------------------------------------------------------ ;
//                                                                            ;
// ========================================================================== ;

int CThread::createThread(void (*pfuThreadFunction)(CThread*), void* pvThreadObject)
{
        m_bThreadStopFlag = false;
        m_pvThreadObject = pvThreadObject;
        m_pfuThreadFunction = pfuThreadFunction;
#if defined(_WIN32)                                     
        unsigned int iThreadId;

        m_hThreadHandle = (HANDLE)_beginthreadex(NULL, 0, threadFunction, (void*)this, 0, &iThreadId);

        if(m_hThreadHandle == NULL)
        {
                warning("createThread : creating thread failed!");
                m_bThreadRunFlag = false;
                return -1;
        }
        else
        {
                m_bThreadRunFlag = true;
                return 0;
        }
#endif
#if defined(__LINUX__)  
        pthread_attr_t Thread_attr;
        
    int retVal = pthread_create(&m_hThreadHandle, NULL, threadFunction, (void*)this);     
        if(retVal != 0)
        {
                warning("createThread : creating thread failed!");
                m_bThreadRunFlag = false; 
                return -1;      
        }
        else
        {
                m_bThreadRunFlag = true;
                return 0;
        }
#endif
#if defined(__QNX__)

        if(m_pcStack == NULL)
                m_pcStack = new char[m_uiStackSize];

        if(m_pcStack == NULL)
        {
                m_bThreadRunFlag = false;
                warning("createThread : creating stack failed!");
                return -1;
        }
        int iThreadId = _beginthread(threadFunction, m_pcStack, m_uiStackSize, (void*)this);
        debug(1,"CThread: create stacksize=%d\n",m_uiStackSize);

        if( iThreadId == 0)
        {
                warning("createThread : creating thread failed!");
                m_bThreadRunFlag = false;
                delete [] m_pcStack;
                return -1;
        }
        else
        {
                m_bThreadRunFlag = true;
                return 0;
        }

#endif
}

void CThread::exitThread()
{
        m_bThreadRunFlag = false;
        #if defined(__WIN32)
                 _endthreadex(0);
        #endif
        #if defined(__QNX__)
                 _endthread();
        #endif
}

void CThread::terminateThread()
{
        m_bThreadStopFlag = true;
}

bool CThread::checkThreadRun()
{
        return m_bThreadRunFlag;
}

bool CThread::checkThreadStop()
{
        return m_bThreadStopFlag;
}