Comutex.h

#ifndef COMUTEX_H_INCLUDED
#define COMUTEX_H_INCLUDED

#include <dash/Exception.h>
#include <dash/Team.h>
#include <dash/Mutex.h>

#include <vector>

namespace dash {

class Comutex {
private:
  using _storage_type = std::vector<dash::Mutex>;
public:
  // Types
  using iterator       = typename _storage_type::iterator;
  using const_iterator = typename _storage_type::const_iterator;
  using reference      = typename _storage_type::reference;
  using size_type      = typename _storage_type::size_type;

public:

  explicit Comutex(Team & team = dash::Team::All()) {
    if(dash::is_initialized()){
      initialize(team);
    }
  }

  iterator begin() noexcept {
    return _mutexes.begin();
  }

  const_iterator begin() const noexcept {
    return _mutexes.begin();
  }

  iterator end() noexcept {
    return _mutexes.end();
  }

  const_iterator end() const noexcept {
    return _mutexes.end();
  }

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

  inline void initialize(Team & team){
    if(!_is_initialized){
      _team = &team;
      _mutexes.reserve(team.size());
      for(decltype(team.size()) i = 0; i<team.size(); ++i){
        _mutexes.emplace_back(team);
      }
    } else {
      DASH_ASSERT_MSG((team == *_team),
                      "Comutex was initialized with a different team");
    }
    _is_initialized = true;
  }

  inline Team & team() {
    return *_team;
  }

  inline reference operator()(const int & unit) {
    DASH_ASSERT_MSG(_is_initialized, "Comutex is not initialized");
    return _mutexes.at(unit);
  }

  inline reference operator()(const team_unit_t & unit) {
    return this->operator()(static_cast<int>(unit));
  }

private:
  _storage_type  _mutexes;
  Team         * _team{};
  bool           _is_initialized = false;
};

} // namespace dash

#endif /* COMUTEX_H_INCLUDED */