MultiLock.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <exception>
#include <map>
 
namespace precice::utils {
 
class MultiLockException : public std::runtime_error {
public:
  MultiLockException()
      : runtime_error("MultiLock") {}
};
 
class LockNotFoundException : public MultiLockException {
public:
  LockNotFoundException() = default;
  const char *what() const noexcept override
  {
    return "The multilock does not contain the requested lock!";
  }
};

template <typename Key>
class MultiLock {
public:
  using key_type = Key;

  using size_type = std::size_t;

  void add(Key name, bool state)
  {
    _locks.emplace(std::move(name), state);
  }

  template <typename K>
  void lock(const K &name)
  {
    auto iter = _locks.find(name);
    if (iter == _locks.end()) {
      throw LockNotFoundException{};
    } else {
      iter->second = true;
    }
  }

  void lockAll() noexcept
  {
    for (auto &kl : _locks) {
      kl.second = true;
    }
  }

  template <typename K>
  void unlock(const K &name)
  {
    auto iter = _locks.find(name);
    if (iter == _locks.end()) {
      throw LockNotFoundException{};
    } else {
      iter->second = false;
    }
  }

  void unlockAll() noexcept
  {
    for (auto &kl : _locks) {
      kl.second = false;
    }
  }

  void clear() noexcept
  {
    _locks.clear();
  }

  template <typename K>
  bool check(const K &name) const
  {
    auto iter = _locks.find(name);
    if (iter == _locks.end()) {
      throw LockNotFoundException{};
    } else {
      return iter->second;
    }
  }

  bool checkAll() const noexcept
  {
    using KL = typename decltype(_locks)::value_type;
    return std::all_of(_locks.begin(), _locks.end(), [](const KL &kl) {
      return kl.second;
    });
  }

  template <typename K>
  bool contains(const K &name) const noexcept
  {
    return _locks.find(name) != _locks.end();
  }

  size_type size() const noexcept
  {
    return _locks.size();
  }

  size_t countLocked() const
  {
    return std::count_if(_locks.begin(), _locks.end(), [](typename map_type::value_type const &kv) { return kv.second; });
  }

  size_t countUnlocked() const
  {
    return std::count_if(_locks.begin(), _locks.end(), [](typename map_type::value_type const &kv) { return not kv.second; });
  }
 
private:
  using map_type = typename std::map<Key, bool, std::less<>>;

  map_type _locks;
};
} // namespace precice::utils