GCSynch.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//  (c) 2006 by Basler Vision Technologies
//  Section: Vision Components
//  Project: GenApi
//  Author:  Hartmut Nebelung
//  $Header$
//
//  License: This file is published under the license of the EMVA GenICam  Standard Group.
//  A text file describing the legal terms is included in  your installation as 'GenICam_license.pdf'.
//  If for some reason you are missing  this file please contact the EMVA or visit the website
//  (http://www.genicam.org) for a full copy.
//
//  THIS SOFTWARE IS PROVIDED BY THE EMVA GENICAM STANDARD GROUP "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 EMVA GENICAM STANDARD  GROUP
//  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.
//-----------------------------------------------------------------------------
#ifndef GENAPI_GCSYNCH_H
#define GENAPI_GCSYNCH_H
 
#include <Base/GCTypes.h>
#include <Base/GCException.h>
 
#if defined (_WIN32)
#   include <windows.h>
#   include <winbase.h>
#elif defined (__GNUC__) && (defined (__linux__) || defined (__APPLE__))
#   include <semaphore.h>
#   include <pthread.h>
#   include <errno.h>
#   include <list>
#elif defined(VXWORKS)
   #include <vxworks.h>
   #include <taskLib.h>
#else
#   error No/unknown platform thread support
#endif
 
namespace GENICAM_NAMESPACE
{
 
    //-----------------------------------------------------------------
    // CLock
    //-----------------------------------------------------------------
 
    class GCBASE_API CLock
    {
    public:
        CLock();
 
        ~CLock();
 
        bool TryLock();
 
        void Lock();
 
        void Unlock();
 
    private:
        CLock( const CLock& );
 
        CLock& operator=( const CLock& );
 
    protected:
 
#if defined (_WIN32)
        CRITICAL_SECTION m_csObject;
#elif defined (__GNUC__) && (defined (__linux__) || defined (__APPLE__))
        pthread_mutex_t m_mtxObject;
#elif defined(VXWORKS)
        SEM_ID m_sem;
#else
#       error No/unknown platform thread support
#endif
 
    };
 
 
    class GCBASE_API CLockEx : public CLock
    {
    public:
 
#       if defined (_WIN32)
 
            int64_t GetLockCount();
 
            int64_t GetRecursionCount();
 
#       elif defined (__GNUC__) && (defined (__linux__) || defined (__APPLE__) || defined(VXWORKS))
            // nothing implemented for Unix
#       else
#           error No/unknown platform support
#       endif
 
    private:
        CLockEx( const CLockEx& );
 
        CLockEx& operator=( const CLockEx& );
 
    };
 
 
    //-----------------------------------------------------------------
    // AutoLock
    //-----------------------------------------------------------------
    class AutoLock
    {
        CLock& m_Lock;
    public:
        AutoLock(CLock& lock)
            : m_Lock(lock)
        {
            m_Lock.Lock();
        }
 
        ~AutoLock()
        {
            m_Lock.Unlock();
        }
 
    private:
        AutoLock& operator=(const AutoLock&);
        AutoLock(const AutoLock&);
    };
 
 
    //-----------------------------------------------------------------
    // template LockableObject<Object,ThreadingModel>
    //-----------------------------------------------------------------
 
    template< class Object>
    class LockableObject
    {
    public:
        mutable CLock m_Lock;
 
        class Lock;
        friend class Lock;
 
        class Lock
        {
            const LockableObject<Object> &m_Object;
        public:
            Lock( const LockableObject<Object>& obj) : m_Object(obj) {
                m_Object.m_Lock.Lock();
            }
 
            ~Lock(){
                m_Object.m_Lock.Unlock();
            }
        private:
            Lock& operator=( const Lock& );
        };
 
        Lock GetLock() const
        {
            return Lock( *this );
        }
    };
 
 
    class GCBASE_API CGlobalLock
    {
    public:
        explicit CGlobalLock(const char* pszName);
#if     defined(_WIN32) && ! defined(PHARLAP_WIN32)
        explicit CGlobalLock(const wchar_t* pszName);
#endif 
        explicit CGlobalLock(const GENICAM_NAMESPACE::gcstring& strName);
 
        ~CGlobalLock();
 
    public:
        bool IsValid(void) const;
 
        bool Lock(unsigned int timeout_ms);
 
        bool TryLock(void);
 
        void Unlock(void);
 
#if defined (__GNUC__) && (defined (__linux__) || defined (__APPLE__))
        // creates a hashed name instead of the real name
        void HashSemName(const GENICAM_NAMESPACE::gcstring& strName);
#endif
 
    protected:
#if defined(_WIN32)
        HANDLE m_handle;
#elif defined (__GNUC__) && (defined (__linux__) || defined (__APPLE__))
        GENICAM_NAMESPACE::gcstring m_semName;
        sem_t* m_handle;
#elif VXWORKS
        // There are no named locks on VxWorks. While we could use a single global lock, we
        // will just rely on the caller to add their own locking in
#else
#       error No/unknown platform thread support
#endif
 
        // This is for debugging/assertions only
        // the d'tor check whether this is 0 in debug builds
        // in release builds this is always 0
        mutable long m_DebugCount;
 
    private:
        // not copyable
        CGlobalLock(const CGlobalLock&);
        CGlobalLock& operator=(const CGlobalLock&);
    };
 
 
    //-----------------------------------------------------------------
    // unlocks the global lock object on destruction
    // this is for automatic UNLOCKING only.
    // we can't do automatic locking here since we don't get a returnvalue from the c'tor
    //-----------------------------------------------------------------
    class GCBASE_API CGlobalLockUnlocker
    {
    protected:
        CGlobalLock&    m_Lock;
        bool            m_enabled;
 
    public:
        CGlobalLockUnlocker(CGlobalLock& lock)
            : m_Lock(lock)
            , m_enabled(true) // this allows the auto unlock to be turned off for messy code structures
        {
            // explicitly don't lock the object here since we want to do this manually and handle the return value properly
        }
 
        ~CGlobalLockUnlocker()
        {
            UnlockEarly();
        }
 
        void UnlockEarly(void)
        {
            if (m_enabled)
            {
                m_enabled = false;
                m_Lock.Unlock();
            }
        }
 
    private:
        CGlobalLockUnlocker& operator=(const CGlobalLockUnlocker&);
        CGlobalLockUnlocker(const CGlobalLockUnlocker&);
    };
 
} // namespace GenICam
 
#endif // GENAPI_GCSYNCH_H