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") {}
  MultiLockException() {…}
};
class MultiLockException : public std::runtime_error {…};
 
class LockNotFoundException : public MultiLockException {
public:
  LockNotFoundException() = default;
  const char *what() const noexcept override
  {
    return "The multilock does not contain the requested lock!";
  }
  const char *what() const noexcept override {…}
};
class LockNotFoundException : public MultiLockException {…};
 
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);
  }
  void add(Key name, bool 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 lock(const K &name) {…}
 
  void lockAll() noexcept
  {
    for (auto &kl : _locks) {
      kl.second = true;
    }
  }
  void lockAll() noexcept {…}
 
  template <typename K>
  void unlock(const K &name)
  {
    auto iter = _locks.find(name);
    if (iter == _locks.end()) {
      throw LockNotFoundException{};
    } else {
      iter->second = false;
    }
  }
  void unlock(const K &name) {…}
 
  void unlockAll() noexcept
  {
    for (auto &kl : _locks) {
      kl.second = false;
    }
  }
  void unlockAll() noexcept {…}
 
  void clear() noexcept
  {
    _locks.clear();
  }
  void clear() noexcept {…}
 
  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 check(const K &name) const {…}
 
  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;
    });
  }
  bool checkAll() const noexcept {…}
 
  template <typename K>
  bool contains(const K &name) const noexcept
  {
    return _locks.find(name) != _locks.end();
  }
  bool contains(const K &name) const noexcept {…}
 
  size_type size() const noexcept
  {
    return _locks.size();
  }
  size_type size() const noexcept {…}
 
  size_t countLocked() const
  {
    return std::count_if(_locks.begin(), _locks.end(), [](typename map_type::value_type const &kv) { return kv.second; });
  }
  size_t countLocked() const {…}
 
  size_t countUnlocked() const
  {
    return std::count_if(_locks.begin(), _locks.end(), [](typename map_type::value_type const &kv) { return not kv.second; });
  }
  size_t countUnlocked() const {…}
 
private:
  using map_type = typename std::map<Key, bool, std::less<>>;
 
  map_type _locks;
};
class MultiLock {…};
} // namespace precice::utils