Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.

boost/detail/winapi/synchronization.hpp

//  synchronizaion.hpp  --------------------------------------------------------------//

//  Copyright 2010 Vicente J. Botet Escriba

//  Distributed under the Boost Software License, Version 1.0.
//  See http://www.boost.org/LICENSE_1_0.txt


#ifndef BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP
#define BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP

#include <boost/detail/winapi/basic_types.hpp>

#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif

namespace boost
{
namespace detail
{
namespace winapi
{
#if defined( BOOST_USE_WINDOWS_H )
    typedef ::CRITICAL_SECTION CRITICAL_SECTION_;
    typedef ::PAPCFUNC PAPCFUNC_;

#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
    typedef ::INIT_ONCE INIT_ONCE_;
    typedef ::PINIT_ONCE PINIT_ONCE_;
    typedef ::LPINIT_ONCE LPINIT_ONCE_;
    #define BOOST_DETAIL_WINAPI_INIT_ONCE_STATIC_INIT INIT_ONCE_STATIC_INIT
    typedef ::PINIT_ONCE_FN PINIT_ONCE_FN_;

    typedef ::SRWLOCK SRWLOCK_;
    typedef ::PSRWLOCK PSRWLOCK_;
    #define BOOST_DETAIL_WINAPI_SRWLOCK_INIT SRWLOCK_INIT

    typedef ::CONDITION_VARIABLE CONDITION_VARIABLE_;
    typedef ::PCONDITION_VARIABLE PCONDITION_VARIABLE_;
    #define BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_INIT CONDITION_VARIABLE_INIT
#endif

    using ::InitializeCriticalSection;
#if BOOST_USE_WINAPI_VERSION >= 0x0403
    using ::InitializeCriticalSectionAndSpinCount;
#endif
    using ::EnterCriticalSection;
    using ::TryEnterCriticalSection;
    using ::LeaveCriticalSection;
    using ::DeleteCriticalSection;

# ifdef BOOST_NO_ANSI_APIS
    using ::CreateMutexW;
    using ::OpenMutexW;
    using ::CreateEventW;
    using ::OpenEventW;
    using ::CreateSemaphoreW;
    using ::OpenSemaphoreW;
# else
    using ::CreateMutexA;
    using ::OpenMutexA;
    using ::CreateEventA;
    using ::OpenEventA;
    using ::CreateSemaphoreA;
    using ::OpenSemaphoreA;
# endif
    using ::ReleaseMutex;
    using ::ReleaseSemaphore;
    using ::SetEvent;
    using ::ResetEvent;
    using ::WaitForMultipleObjects;
    using ::WaitForSingleObject;
    using ::QueueUserAPC;

#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
    using ::InitOnceInitialize;
    using ::InitOnceExecuteOnce;
    using ::InitOnceBeginInitialize;
    using ::InitOnceComplete;

    using ::InitializeSRWLock;
    using ::AcquireSRWLockExclusive;
    using ::TryAcquireSRWLockExclusive;
    using ::ReleaseSRWLockExclusive;
    using ::AcquireSRWLockShared;
    using ::TryAcquireSRWLockShared;
    using ::ReleaseSRWLockShared;

    using ::InitializeConditionVariable;
    using ::WakeConditionVariable;
    using ::WakeAllConditionVariable;
    using ::SleepConditionVariableCS;
    using ::SleepConditionVariableSRW;
#endif

    const DWORD_ infinite       = INFINITE;
    const DWORD_ wait_abandoned = WAIT_ABANDONED;
    const DWORD_ wait_object_0  = WAIT_OBJECT_0;
    const DWORD_ wait_timeout   = WAIT_TIMEOUT;
    const DWORD_ wait_failed    = WAIT_FAILED;

#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
    const DWORD_ init_once_async = INIT_ONCE_ASYNC;
    const DWORD_ init_once_check_only = INIT_ONCE_CHECK_ONLY;
    const DWORD_ init_once_init_failed = INIT_ONCE_INIT_FAILED;
    const DWORD_ init_once_ctx_reserved_bits = INIT_ONCE_CTX_RESERVED_BITS;

    const ULONG_ condition_variable_lockmode_shared = CONDITION_VARIABLE_LOCKMODE_SHARED;
#endif

#else // defined( BOOST_USE_WINDOWS_H )

extern "C" {

    typedef struct CRITICAL_SECTION_
    {
        struct critical_section_debug * DebugInfo;
        long LockCount;
        long RecursionCount;
        void * OwningThread;
        void * LockSemaphore;
    #if defined(_WIN64)
        unsigned __int64 SpinCount;
    #else
        unsigned long SpinCount;
    #endif
    }
    *PCRITICAL_SECTION_;

#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
    typedef union INIT_ONCE_
    {
        PVOID_ Ptr;
    }
    *PINIT_ONCE_, *LPINIT_ONCE_;
    #define BOOST_DETAIL_WINAPI_INIT_ONCE_STATIC_INIT {0}
    typedef BOOL_ (WINAPI *PINIT_ONCE_FN_)(PINIT_ONCE_ InitOnce, PVOID_ Parameter, PVOID_ *Context);

    typedef struct SRWLOCK_
    {
        PVOID_ Ptr;
    }
    * PSRWLOCK_;
    #define BOOST_DETAIL_WINAPI_SRWLOCK_INIT {0}

    typedef struct CONDITION_VARIABLE_
    {
        PVOID_ Ptr;
    }
    * PCONDITION_VARIABLE_;
    #define BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_INIT {0}

#endif

    __declspec(dllimport) void WINAPI
        InitializeCriticalSection(PCRITICAL_SECTION_);
#if BOOST_USE_WINAPI_VERSION >= 0x0403
    __declspec(dllimport) BOOL_ WINAPI
        InitializeCriticalSectionAndSpinCount(CRITICAL_SECTION_* lpCS, DWORD_ dwSpinCount);
#endif
    __declspec(dllimport) void WINAPI
        EnterCriticalSection(PCRITICAL_SECTION_);
    __declspec(dllimport) BOOL_ WINAPI
        TryEnterCriticalSection(PCRITICAL_SECTION_);
    __declspec(dllimport) void WINAPI
        LeaveCriticalSection(PCRITICAL_SECTION_);
    __declspec(dllimport) void WINAPI
        DeleteCriticalSection(PCRITICAL_SECTION_);

     struct _SECURITY_ATTRIBUTES;
# ifdef BOOST_NO_ANSI_APIS
    __declspec(dllimport) HANDLE_ WINAPI
        CreateMutexW(_SECURITY_ATTRIBUTES*, BOOL_, LPCWSTR_);
    __declspec(dllimport) HANDLE_ WINAPI
        OpenMutexW(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCWSTR_ lpName);
    __declspec(dllimport) HANDLE_ WINAPI
        CreateSemaphoreW(_SECURITY_ATTRIBUTES*, LONG_, LONG_, LPCWSTR_);
    __declspec(dllimport) HANDLE_ WINAPI
        OpenSemaphoreW(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCWSTR_ lpName);
    __declspec(dllimport) HANDLE_ WINAPI
        CreateEventW(_SECURITY_ATTRIBUTES*, BOOL_, BOOL_, LPCWSTR_);
    __declspec(dllimport) HANDLE_ WINAPI
        OpenEventW(DWORD_, BOOL_, LPCWSTR_);
# else
    __declspec(dllimport) HANDLE_ WINAPI
        CreateMutexA(_SECURITY_ATTRIBUTES*, BOOL_, LPCSTR_);
    __declspec(dllimport) HANDLE_ WINAPI
        OpenMutexA(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCSTR_ lpName);
    __declspec(dllimport) HANDLE_ WINAPI
        CreateSemaphoreA(_SECURITY_ATTRIBUTES*, LONG_, LONG_, LPCSTR_);
    __declspec(dllimport) HANDLE_ WINAPI
        OpenSemaphoreA(DWORD_ dwDesiredAccess, BOOL_ bInheritHandle, LPCSTR_ lpName);
    __declspec(dllimport) HANDLE_ WINAPI
        CreateEventA(_SECURITY_ATTRIBUTES*, BOOL_, BOOL_, LPCSTR_);
    __declspec(dllimport) HANDLE_ WINAPI
        OpenEventA(DWORD_, BOOL_, LPCSTR_);
# endif
    __declspec(dllimport) BOOL_ WINAPI
        ReleaseMutex(HANDLE_);
    __declspec(dllimport) DWORD_ WINAPI
        WaitForSingleObject(HANDLE_, DWORD_);
    __declspec(dllimport) DWORD_ WINAPI
        WaitForMultipleObjects(DWORD_ nCount,
                HANDLE_ const * lpHandles,
                BOOL_ bWaitAll,
                DWORD_ dwMilliseconds);
    __declspec(dllimport) BOOL_ WINAPI
        ReleaseSemaphore(HANDLE_, LONG_, LONG_*);
    __declspec(dllimport) BOOL_ WINAPI
        SetEvent(HANDLE_);
    __declspec(dllimport) BOOL_ WINAPI
        ResetEvent(HANDLE_);

    typedef void (__stdcall *PAPCFUNC_)(ULONG_PTR_);
    __declspec(dllimport) DWORD_ WINAPI
        QueueUserAPC(PAPCFUNC_, HANDLE_, ULONG_PTR_);

#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
    __declspec(dllimport) void WINAPI InitOnceInitialize(PINIT_ONCE_);
    __declspec(dllimport) BOOL_ WINAPI InitOnceExecuteOnce(PINIT_ONCE_ InitOnce, PINIT_ONCE_FN_ InitFn, PVOID_ Parameter, LPVOID_* Context);
    __declspec(dllimport) BOOL_ WINAPI InitOnceBeginInitialize(LPINIT_ONCE_ lpInitOnce, DWORD_ dwFlags, BOOL_* fPending, LPVOID_* lpContext);
    __declspec(dllimport) BOOL_ WINAPI InitOnceComplete(LPINIT_ONCE_ lpInitOnce, DWORD_ dwFlags, LPVOID_* lpContext);


    __declspec(dllimport) void WINAPI InitializeSRWLock(PSRWLOCK_ SRWLock);
    __declspec(dllimport) void WINAPI AcquireSRWLockExclusive(PSRWLOCK_ SRWLock);
    __declspec(dllimport) BOOLEAN_ WINAPI TryAcquireSRWLockExclusive(PSRWLOCK_ SRWLock);
    __declspec(dllimport) void WINAPI ReleaseSRWLockExclusive(PSRWLOCK_ SRWLock);
    __declspec(dllimport) void WINAPI AcquireSRWLockShared(PSRWLOCK_ SRWLock);
    __declspec(dllimport) BOOLEAN_ WINAPI TryAcquireSRWLockShared(PSRWLOCK_ SRWLock);
    __declspec(dllimport) void WINAPI ReleaseSRWLockShared(PSRWLOCK_ SRWLock);

    __declspec(dllimport) void WINAPI InitializeConditionVariable(PCONDITION_VARIABLE_ ConditionVariable);
    __declspec(dllimport) void WINAPI WakeConditionVariable(PCONDITION_VARIABLE_ ConditionVariable);
    __declspec(dllimport) void WINAPI WakeAllConditionVariable(PCONDITION_VARIABLE_ ConditionVariable);
    __declspec(dllimport) BOOL_ WINAPI SleepConditionVariableCS(PCONDITION_VARIABLE_ ConditionVariable, PCRITICAL_SECTION_ CriticalSection, DWORD_ dwMilliseconds);
    __declspec(dllimport) BOOL_ WINAPI SleepConditionVariableSRW(PCONDITION_VARIABLE_ ConditionVariable, PSRWLOCK_ SRWLock, DWORD_ dwMilliseconds, ULONG_ Flags);
#endif

} // extern "C"

const DWORD_ infinite       = (DWORD_)0xFFFFFFFF;
const DWORD_ wait_abandoned = 0x00000080L;
const DWORD_ wait_object_0  = 0x00000000L;
const DWORD_ wait_timeout   = 0x00000102L;
const DWORD_ wait_failed    = (DWORD_)0xFFFFFFFF;

#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6
const DWORD_ init_once_async = 0x00000002UL;
const DWORD_ init_once_check_only = 0x00000001UL;
const DWORD_ init_once_init_failed = 0x00000004UL;
const DWORD_ init_once_ctx_reserved_bits = 2;

const ULONG_ condition_variable_lockmode_shared = 0x00000001;
#endif

#endif // defined( BOOST_USE_WINDOWS_H )

const DWORD_ max_non_infinite_wait = (DWORD_)0xFFFFFFFE;

BOOST_FORCEINLINE HANDLE_ create_anonymous_mutex(_SECURITY_ATTRIBUTES* lpAttributes, BOOL_ bInitialOwner)
{
#ifdef BOOST_NO_ANSI_APIS
    return CreateMutexW(lpAttributes, bInitialOwner, 0);
#else
    return CreateMutexA(lpAttributes, bInitialOwner, 0);
#endif
}

BOOST_FORCEINLINE HANDLE_ create_anonymous_semaphore(_SECURITY_ATTRIBUTES* lpAttributes, LONG_ lInitialCount, LONG_ lMaximumCount)
{
#ifdef BOOST_NO_ANSI_APIS
    return CreateSemaphoreW(lpAttributes, lInitialCount, lMaximumCount, 0);
#else
    return CreateSemaphoreA(lpAttributes, lInitialCount, lMaximumCount, 0);
#endif
}

BOOST_FORCEINLINE HANDLE_ create_anonymous_event(_SECURITY_ATTRIBUTES* lpAttributes, BOOL_ bManualReset, BOOL_ bInitialState)
{
#ifdef BOOST_NO_ANSI_APIS
    return CreateEventW(lpAttributes, bManualReset, bInitialState, 0);
#else
    return CreateEventA(lpAttributes, bManualReset, bInitialState, 0);
#endif
}

}
}
}

#endif // BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP