TeamLocality.h

#ifndef DASH__UTIL__TEAM_LOCALITY_H__INCLUDED
#define DASH__UTIL__TEAM_LOCALITY_H__INCLUDED

#include <dash/util/Locality.h>
#include <dash/util/LocalityDomain.h>
#include <dash/util/UnitLocality.h>

#include <dash/dart/if/dart_types.h>
#include <dash/dart/if/dart_locality.h>

#include <dash/algorithm/internal/String.h>

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

#include <string>
#include <vector>
#include <unordered_map>
#include <utility>
#include <iterator>
#include <algorithm>


namespace dash {
namespace util {

class TeamLocality
{
private:
  typedef TeamLocality                    self_t;
  typedef dash::util::Locality::Scope     Scope_t;
  typedef dash::util::LocalityDomain      LocalityDomain_t;

public:
  TeamLocality(
    dash::Team       & team,
    Scope_t            scope      = Scope_t::Global,
    std::string        domain_tag = ".");

  TeamLocality(
    dash::Team       & team,
    LocalityDomain_t & domain);

  TeamLocality()                           = default;

  TeamLocality(const self_t & other)       = default;

  self_t & operator=(const self_t & other) = default;

  inline const LocalityDomain_t & domain() const
  {
    return _domain;
  }

  inline LocalityDomain_t & domain()
  {
    return _domain;
  }

  //inline const dash::util::UnitLocality & unit_locality(
  //  team_unit_t unit) const
  //{
  //  return _domain.unit_locality(unit);
  //}
  //
  //inline dash::util::UnitLocality & unit_locality(
  //  team_unit_t unit)
  //{
  //  return _domain.unit_locality(unit);
  //}

  inline self_t & split(Scope_t scope, int num_split_parts = 0)
  {
    _domain.split(scope, num_split_parts);
    return *this;
  }

  inline self_t & split_groups()
  {
    _domain.split_groups();
    return *this;
  }

  inline std::vector<LocalityDomain_t::iterator> & groups()
  {
    return _domain.groups();
  }

  inline const std::vector<LocalityDomain_t::iterator> & groups() const
  {
    return _domain.groups();
  }

  inline std::vector<LocalityDomain_t> & parts()
  {
    return _domain.parts();
  }

  inline const std::vector<LocalityDomain_t> & parts() const
  {
    return _domain.parts();
  }

  inline size_t num_nodes() const
  {
    return _domain.size();
  }

  inline size_t num_cores() const
  {
    return _domain.num_cores();
  }

  inline dash::Team & team() const
  {
    return (nullptr == _team) ? dash::Team::Null() : *_team;
  }

  inline const std::vector<global_unit_t> & global_units() const
  {
    return _domain.units();
  }

  inline dash::util::UnitLocality unit_locality(
    team_unit_t unit_id) const
  {
    return dash::util::UnitLocality(*_team, unit_id);
  }

  inline dash::util::UnitLocality unit_locality(
    global_unit_t unit_id) const
  {
    team_unit_t l_unit_id;
    dart_team_unit_g2l(_team->dart_id(), unit_id, &l_unit_id);
    return dash::util::UnitLocality(*_team, l_unit_id);
  }

  inline LocalityDomain_t & group(
    const std::vector<std::string> & group_subdomain_tags)
  {
    return _domain.group(group_subdomain_tags);
  }

  inline self_t & select(
    const std::vector<std::string> & domain_tags)
  {
    _domain.select(domain_tags);
    return *this;
  }

  inline self_t & exclude(
    const std::vector<std::string> & domain_tags)
  {
    _domain.exclude(domain_tags);
    return *this;
  }

private:
  dash::Team                        * _team          = nullptr;
  Scope_t                             _scope         = Scope_t::Undefined;
  LocalityDomain_t                    _domain;

}; // class TeamLocality

}  // namespace util
}  // namespace dash

#endif // DASH__UTIL__TEAM_LOCALITY_H__INCLUDED