IteratorBehavior.h

Go to the documentation of this file.

 
#pragma once
 
#include <set>
 
#include "autopas/options/Option.h"
#include "autopas/particles/OwnershipState.h"
 
namespace autopas {
inline namespace options {
class IteratorBehavior : public Option<IteratorBehavior> {
 public:
  using Value_t = unsigned int;
 
  enum Value : Value_t {
    owned = 0b00001,
    halo = 0b00010,
    ownedOrHalo = 0b00011,
    dummy = 0b00100,
    ownedOrHaloOrDummy = 0b00111,
    forceSequential = 0b01000,
    containerOnly = 0b10000,
  };
 
  // sanity checks
  // combined values should be equivalent to the disjunction of their elements
  static_assert((owned | halo) == ownedOrHalo, "Iterator behaviors are defined with non matching values!");
  static_assert((owned | halo | dummy) == ownedOrHaloOrDummy,
                "Iterator behaviors are defined with non matching values!");
  // forceSequential must not overlap with anything else
  static_assert((ownedOrHaloOrDummy & forceSequential) == 0,
                "Iterator behaviors are defined with non matching values!");
  // containerOnly must not overlap with anything else
  static_assert(((ownedOrHaloOrDummy | forceSequential) & containerOnly) == 0,
                "Iterator behaviors are defined with non matching values!");
 
  IteratorBehavior() = default;
 
  constexpr IteratorBehavior(Value option) : _value(option) {}
 
  constexpr IteratorBehavior(Value_t option) : _value(static_cast<IteratorBehavior::Value>(option)) {}
 
  constexpr operator Value() const { return _value; }
 
  static std::set<IteratorBehavior> getDiscouragedOptions() {
    return {IteratorBehavior::dummy, IteratorBehavior::ownedOrHaloOrDummy, IteratorBehavior::forceSequential,
            IteratorBehavior::containerOnly};
  }
 
  static std::map<IteratorBehavior, std::string> getOptionNames() {
    return {
        {IteratorBehavior::owned, "owned"},
        {IteratorBehavior::halo, "halo"},
        {IteratorBehavior::ownedOrHalo, "ownedOrHalo"},
        {IteratorBehavior::containerOnly, "containerOnly"},
        {IteratorBehavior::dummy, "dummy"},
        {IteratorBehavior::ownedOrHaloOrDummy, "ownedOrHaloOrDummy"},
        {IteratorBehavior::forceSequential, "forceSequential"},
    };
  }
 
  template <typename ParticleType>
  bool contains(ParticleType &particle) {
    switch (this->_value) {
      case options::IteratorBehavior::ownedOrHaloOrDummy:
        return true;
      case options::IteratorBehavior::ownedOrHalo:
        return not particle.isDummy();
      case options::IteratorBehavior::halo:
        return particle.isHalo();
      case options::IteratorBehavior::owned:
        return particle.isOwned();
      case options::IteratorBehavior::dummy:
        return particle.isDummy();
      default:
        utils::ExceptionHandler::exception("IteratorBehavior::contains() Unknown IteratorBehavior: {}.",
                                           getOptionNames()[this->_value]);
        return false;
    }
  }
 
 private:
  Value _value{Value(-1)};
};
}  // namespace options
}  // namespace autopas