sag_connectivity_threading.h

Go to the documentation of this file.

/*
 * Title:        sag_connectivity_threading.hpp
 * Description:  A cross-platform threading implementation for old compilers
 * $Copyright (c) 2015-2016, 2020 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.$
 * Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG
 * @Version:     $Id: sag_connectivity_threading.h 366779 2020-02-05 10:42:04Z matj $
 */

#ifndef _SAG_CONNECTIVITY_THREADS_HPP_
#define _SAG_CONNECTIVITY_THREADS_HPP_

#if defined(_WIN32) || defined(__WIN32) || defined(WIN32)

// Windows implementation using CriticalSections and _beginthreadex

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <process.h>
#include <io.h>

#define SAG_MUTEX_LOCK(m) EnterCriticalSection(&m)

#define SAG_MUTEX_UNLOCK(m) LeaveCriticalSection(&m)

#define SAG_MUTEX_INIT(m) InitializeCriticalSection(&m)

#define SAG_MUTEX_DESTROY(m) DeleteCriticalSection(&m)

#define SAG_MUTEX_T CRITICAL_SECTION

#define SAG_SEMA_WAIT(s) WaitForSingleObject(s, INFINITE)

#define SAG_SEMA_POST(s) ReleaseSemaphore(s, 1, NULL)

#define SAG_SEMA_INIT(s) s = CreateSemaphore(NULL, 0, 0x7FFFFFFF, NULL)

#define SAG_SEMA_DESTROY(s) CloseHandle(s)

#define SAG_SEMA_T HANDLE

#define SAG_THREAD_CREATE(id, func, params) (!(id = (HANDLE)_beginthreadex(NULL, 0, func, params, 0, NULL)))

#define SAG_THREAD_JOIN(id) WaitForSingleObject(id, INFINITE)

#define SAG_THREAD_RETURN return 0;

#define SAG_THREAD_T HANDLE 

#define SAG_THREAD_RET_T unsigned int __stdcall 

#else // defined(_WIN32) || defined(__WIN32) || defined(WIN32)

// Unix implementation using pthreads

#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <signal.h>


#define SAG_MUTEX_LOCK(m) pthread_mutex_lock(&m)

#define SAG_MUTEX_UNLOCK(m) pthread_mutex_unlock(&m)

#define SAG_MUTEX_INIT(m) pthread_mutex_init(&m, NULL)

#define SAG_MUTEX_DESTROY(m) pthread_mutex_destroy(&m)

#define SAG_MUTEX_T pthread_mutex_t

#define SAG_SEMA_WAIT(s) {while (sem_wait(&s));}

#define SAG_SEMA_POST(s) sem_post(&s)

#define SAG_SEMA_INIT(s) sem_init(&s, 0, 0)

#define SAG_SEMA_DESTROY(s) sem_destroy(&s)

#define SAG_SEMA_T sem_t

#define SAG_THREAD_CREATE(id, func, params) pthread_create(& id, NULL, func, params)

#define SAG_THREAD_JOIN(id) pthread_join(id, NULL)

#define SAG_THREAD_RETURN return NULL;

#define SAG_THREAD_T pthread_t

#define SAG_THREAD_RET_T void*


#endif // (else) defined(_WIN32) || defined(__WIN32) || defined(WIN32)

#ifdef __cplusplus

#include <stdexcept>

namespace com {
namespace softwareag {
namespace _DATAT_INTERNAL_CPP_NAMESPACE {

class SAG_LOCK_GUARD
{
public:
        SAG_LOCK_GUARD(SAG_MUTEX_T &mx)
                :mx(mx), locked(false)
        {
                lock();
        }

        ~SAG_LOCK_GUARD()
        { 
                if (locked)
                        unlock(); 
        }

        void lock() 
        {
                if (locked) throw std::runtime_error("Cannot lock a SAG_MUTEX_T that is already locked");
                locked = true;
                SAG_MUTEX_LOCK(mx);
        }
        void unlock() 
        {
                if (!locked) throw std::runtime_error("Cannot unlock a SAG_MUTEX_T that is already unlocked");
                locked = false;
                SAG_MUTEX_UNLOCK(mx);
        }
private:
        SAG_LOCK_GUARD(const SAG_LOCK_GUARD &other);
        SAG_LOCK_GUARD(SAG_LOCK_GUARD &&other);
        SAG_LOCK_GUARD& operator=(const SAG_LOCK_GUARD &other);
        SAG_LOCK_GUARD& operator=(SAG_LOCK_GUARD &&other);

        SAG_MUTEX_T &mx;
        bool locked;
};

}
namespace connectivity { using namespace _DATAT_INTERNAL_CPP_NAMESPACE; }
}} // com.softwareag.connectivity

#endif // __cplusplus

#endif // _SAG_CONNECTIVITY_THREADS_HPP_