lockguards.h

Go to the documentation of this file.

#ifndef ION_BASE_LOCKGUARDS_H_
#define ION_BASE_LOCKGUARDS_H_

#include "base/macros.h"
#include "ion/base/readwritelock.h"
#include "ion/base/spinmutex.h"
#include "ion/port/mutex.h"

namespace ion {
namespace base {


template <class MutexT>
class ION_API GenericLockGuardBase {
 public:
  bool IsLocked() const { return is_locked_; }

  void Lock() {
    if (!is_locked_) {
      mutex_.Lock();
      is_locked_ = true;
    }
  }

  bool TryLock() {
    if (!is_locked_) {
      is_locked_ = mutex_.TryLock();
    }
    return is_locked_;
  }

  void Unlock() {
    if (is_locked_) {
      mutex_.Unlock();
      is_locked_ = false;
    }
  }

 protected:
  explicit GenericLockGuardBase(MutexT* m) : mutex_(*m), is_locked_(false) {}

  ~GenericLockGuardBase() { Unlock(); }

  MutexT& mutex_;
  bool is_locked_;

 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(GenericLockGuardBase);
};

template <class MutexT>
class ION_API GenericLockGuard : public GenericLockGuardBase<MutexT> {
 public:
  explicit GenericLockGuard(MutexT* m) : GenericLockGuardBase<MutexT>(m) {
    this->mutex_.Lock();
    this->is_locked_ = true;
  }

 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(GenericLockGuard);
};

template <class MutexT>
class ION_API GenericTryLockGuard : public GenericLockGuardBase<MutexT> {
 public:
  explicit GenericTryLockGuard(MutexT* m) : GenericLockGuardBase<MutexT>(m) {
    this->TryLock();
  }

 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(GenericTryLockGuard);
};

template <class MutexT>
class ION_API GenericUnlockGuard {
 public:
  explicit GenericUnlockGuard(MutexT* m) : mutex_(*m) {
    mutex_.Unlock();
  }

  ~GenericUnlockGuard() {
    mutex_.Lock();
  }

 private:
  MutexT& mutex_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(GenericUnlockGuard);
};

template <typename T>
class ION_API ManualLockGuard : public GenericLockGuardBase<port::Mutex> {
 public:
  explicit ManualLockGuard(const T& initial_value)
      : GenericLockGuardBase<port::Mutex>(&local_mutex_),
        initial_value_(initial_value),
        current_value_(initial_value) {
    is_locked_ = false;
  }

  ~ManualLockGuard() { Unlock(); }

  void SetAndLock(const T& new_value) {
    Lock();
    current_value_ = new_value;
  }

  const T ResetAndUnlock() {
    const T ret = current_value_;
    current_value_ = initial_value_;
    Unlock();
    return ret;
  }

  const T GetCurrentValue() {
    Lock();
    T ret = current_value_;
    Unlock();
    return ret;
  }

 private:
  port::Mutex local_mutex_;
  T initial_value_;
  T current_value_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(ManualLockGuard);
};

typedef GenericLockGuard<port::Mutex> LockGuard;
typedef GenericUnlockGuard<port::Mutex> UnlockGuard;
typedef GenericTryLockGuard<port::Mutex> TryLockGuard;

typedef GenericLockGuard<SpinMutex> SpinLockGuard;
typedef GenericUnlockGuard<SpinMutex> SpinUnlockGuard;
typedef GenericTryLockGuard<SpinMutex> SpinTryLockGuard;

typedef GenericLockGuard<ReadLock> ReadGuard;
typedef GenericLockGuard<WriteLock> WriteGuard;

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_LOCKGUARDS_H_