gls_mutex.h

Go to the documentation of this file.

/*! \file
  \brief  A cross platform mutex implementation.

  \par Copyright Information

  Copyright (c) 2015 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.

*/

#ifndef INCLUDED_DISTI_MUTEX_H
#define INCLUDED_DISTI_MUTEX_H

#include "disti_include.h"

namespace disti
{

/**
    Provide a cross platform Mutex class to provide data locking capability in 
    a multithreaded environment. Uses the pimpl idiom to hide details.
*/
class Mutex
{
public:

    /// Constructor
    DISTI_EXPORT Mutex();

    /// Destructor
    virtual DISTI_EXPORT ~Mutex();

    /// Blocks to acquire the mutex
    DISTI_EXPORT void Lock();

    /// Attemps to acquire the mutex without blocking
    /// \return whether the lock succeeded
    DISTI_EXPORT bool TryLock();

    /// Releases the mutex, allowing another process to lock it
    DISTI_EXPORT void Unlock();

    /// A lock class to automagically un/lock a mutex within its scope
    class ScopedLock
    {
    public:
        /// Lock the given mutex (blocks on failure to acquire)
        ScopedLock( Mutex& mut ):
            _mut( mut )
        {
            _mut.Lock();
        }

        /// Releases the mutex automatically
        ~ScopedLock()
        {
            _mut.Unlock();
        }
    private:
        Mutex& _mut;
    };

    /// A lock to automagically try to lock and, if applicable, unlock a mutex within its scope.
    class ScopedTryLock
    {
    public:
        /// Tries to lock the given mutex
        ScopedTryLock( Mutex& mut ):
            _mut( mut ),
            _locked( _mut.TryLock() )
        {}

        /// Returns whether the lock succeeded
        bool IsLocked() const { return _locked; }

        /// Releases the mutex automatically, if needed
        ~ScopedTryLock()
        {
            if( _locked )
            {
                _mut.Unlock();
            }
        }
    private:
        Mutex& _mut;
        bool   _locked;
    };

private:
    // The pimpl idiom
    class Impl;
    Impl* const _impl;

    // Disable copying
    Mutex( const Mutex& );
    void operator=( const Mutex& );
};

} // namespace disti

#endif