/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qsystemlock.h"

#include "qsystemlock_p.h"

#include <qdebug.h>

/*! \class QSystemLocker

    \brief The QSystemLocker class is a convenience class that simplifies

    locking and unlocking system locks.

    The purpose of QSystemLocker is to simplify QSystemLock locking and

    unlocking.  Locking and unlocking a QSystemLock in complex functions and

    statements or in exception handling code is error-prone and difficult to

    debug.  QSystemLocker can be used in such situations to ensure that the

    state of the locks is always well-defined.

    QSystemLocker should be created within a function where a QSystemLock needs

    to be locked. The system lock is locked when QSystemLocker is created.  If

    locked, the system lock will be unlocked when the QSystemLocker is

    destroyed.  QSystemLocker can be unlocked with unlock() and relocked with

    relock().

    \sa QSystemLock

 */

/*! \fn QSystemLocker::QSystemLocker()

    Constructs a QSystemLocker and locks \a lock. The \a lock will be

    unlocked when the QSystemLocker is destroyed. If lock is zero,

    QSystemLocker does nothing.

    \sa QSystemLock::lock()

  */

/*! \fn QSystemLocker::~QSystemLocker()

    Destroys the QSystemLocker and unlocks it if it was

    locked in the constructor.

    \sa QSystemLock::unlock()

 */

/*! \fn QSystemLocker::systemLock()

    Returns a pointer to the lock that was locked in the constructor.

 */

/*! \fn QSystemLocker::relock()

    Relocks an unlocked locker.

    \sa unlock()

  */

/*! \fn QSystemLocker::unlock()

    Unlocks this locker. You can use relock() to lock it again.

    It does not need to be locked when destroyed.

    \sa relock()

 */

/*! \class QSystemLock

    \brief The QSystemLock class provides a system wide lock

    that can be used between threads or processes.

    The purpose of a QSystemLocker is to protect an object that can be

    accessed by multiple threads or processes such as shared memory or a file.

    For example, say there is a method which prints a message to a log file:

    void log(const QString &logText)

    {

        QSystemLock systemLock(QLatin1String("logfile"));

        systemLock.lock();

        QFile file(QDir::temp() + QLatin1String("/log"));

        if (file.open(QIODevice::Append)) {

            QTextStream out(&file);

            out << logText;

        }

        systemLock.unlock();

    }

    If this is called from two seperate processes the resulting log file is

    guaranteed to contain both lines.

    When you call lock(), other threads or processes that try to call lock()

    with the same key will block until the thread or process that got the lock

    calls unlock().

    A non-blocking alternative to lock() is tryLock().

 */

/*!

    Constructs a new system lock with \a key. The lock is created in an

    unlocked state.

    \sa lock(), key().

 */

QSystemLock::QSystemLock(const QString &key)

{

    d = new QSystemLockPrivate;

    setKey(key);

}

/*!

    Destroys a system lock.

    warning: This will not unlock the system lock if it has been locked.

*/

QSystemLock::~QSystemLock()

{

    d->cleanHandle();

    delete d;

}

/*!

    Sets a new key to this system lock.

    \sa key()

 */

void QSystemLock::setKey(const QString &key)

{

    if (key == d->key)

        return;

    d->cleanHandle();

    d->lockCount = 0;

    d->key = key;

    // cache the file name so it doesn't have to be generated all the time.

    d->fileName = d->makeKeyFileName();

    d->error = QSystemLock::NoError;

    d->errorString = QString();

    d->handle();

}

/*!

    Returns the key assigned to this system lock

    \sa setKey()

 */

QString QSystemLock::key() const

{

    return d->key;

}

/*!

    Locks the system lock.  Lock \a mode can either be ReadOnly or ReadWrite.

    If a mode is ReadOnly, attempts by other processes to obtain

    ReadOnly locks will succeed, and ReadWrite attempts will block until

    all of the ReadOnly locks are unlocked.  If locked as ReadWrite, all

    other attempts to lock will block until the lock is unlocked.  A given

    QSystemLock can be locked multiple times without blocking, and will

    only be unlocked after a corresponding number of unlock()

    calls are made.  Returns true on success; otherwise returns false.

    \sa unlock(), tryLock()

 */

bool QSystemLock::lock(LockMode mode)

{

    if (d->lockCount > 0 && mode == ReadOnly && d->lockedMode == ReadWrite) {

        qWarning() << "QSystemLock::lock readwrite lock on top of readonly lock.";

        return false;

    }

    return d->modifySemaphore(QSystemLockPrivate::Lock, mode);

}

/*!

    Unlocks the system lock.

    Returns true on success; otherwise returns false.

    \sa lock()

  */

bool QSystemLock::unlock()

{

    if (d->lockCount == 0) {

        qWarning() << "QSystemLock::unlock: unlock with no lock.";

        return false;

    }

    return d->modifySemaphore(QSystemLockPrivate::Unlock, d->lockedMode);

}

/*!

    Returns the type of error that occurred last or NoError.

    \sa errorString()

 */

QSystemLock::SystemLockError QSystemLock::error() const

{

    return d->error;

}

/*!

    Returns the human-readable message appropriate to the current error

    reported by error(). If no suitable string is available, an empty

    string is returned.

    \sa error()

 */

QString QSystemLock::errorString() const

{

    return d->errorString;

}