SelectorBase.h

// -*- C++ -*-
//
// SelectorBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_SelectorBase_H
#define ThePEG_SelectorBase_H
// This is the declaration of the SelectorBase class.


#include "EventConfig.h"

namespace ThePEG {

class SelectorBase {

public:

  virtual ~SelectorBase() {}

  static bool Check(const Particle &) { return true; }

  static bool Intermediate() { return true; }

  static bool FinalState() { return true; }

  static bool AllSteps() { return true; }

  static bool AllCollisions() { return true; }

  virtual bool check(const Particle &  p) const { return Check(p); }

  virtual bool finalState() const { return FinalState(); }

  virtual bool intermediate() const { return Intermediate(); }

  virtual bool allSteps() const { return AllSteps(); }

  virtual bool allCollisions() const { return AllCollisions(); }

};

template <class T>
struct ParticleSelector: public SelectorBase {

  static bool Check(const Particle & p) { return T::Check(p); }

  static bool Intermediate() { return T::Intermediate(); }

  static bool FinalState() { return T::FinalState(); }

  static bool AllSteps() { return T::AllSteps(); }

  static bool AllCollisions() { return T::AllCollisions(); }

  virtual bool check(const Particle &  p) const { return Check(p); }

  virtual bool finalState() const { return FinalState(); }

  virtual bool intermediate() const { return Intermediate(); }

  virtual bool allSteps() const { return AllSteps(); }

  virtual bool allCollisions() const { return AllCollisions(); }

};  

class SelectIfNot: public SelectorBase {

public:

  explicit SelectIfNot(const SelectorBase & S) : s(S) {}

  virtual bool check(const Particle &  p) const { return !s.check(p); }

  virtual bool finalState() const { return !s.finalState(); }

  virtual bool intermediate() const { return !s.intermediate(); }

  virtual bool allSteps() const { return !s.allSteps(); }

  virtual bool allCollisions() const { return !s.allCollisions(); }

private:

  const SelectorBase & s;
};

class SelectIfBoth: public SelectorBase {

public:

  SelectIfBoth(const SelectorBase & S1, const SelectorBase & S2)
    : s1(S1), s2(S2) {}

  virtual bool check(const Particle &  p) const {
    return s1.check(p) && s2.check(p);
  }

  virtual bool finalState() const {
    return s1.finalState() && s2.finalState();
  }

  virtual bool intermediate() const {
    return s1.intermediate() && s2.intermediate();
  }

  virtual bool allSteps() const {
    return s1.allSteps() && s2.allSteps();
  }

  virtual bool allCollisions() const {
    return s1.allCollisions() && s2.allCollisions();
  }

private:

  const SelectorBase & s1;

  const SelectorBase & s2;

};

class SelectIfEither: public SelectorBase {

public:

  SelectIfEither(const SelectorBase & S1, const SelectorBase & S2)
    : s1(S1), s2(S2) {}

  virtual bool check(const Particle &  p) const {
    return s1.check(p) || s2.check(p);
  }

  virtual bool finalState() const {
    return s1.finalState() || s2.finalState();
  }

  virtual bool intermediate() const {
    return s1.intermediate() || s2.intermediate();
  }

  virtual bool allSteps() const {
    return s1.allSteps() || s2.allSteps();
  }

  virtual bool allCollisions() const {
    return s1.allCollisions() || s2.allCollisions();
  }

private:

  const SelectorBase & s1;

  const SelectorBase & s2;

};

template <typename OutputIterator, typename Container>
inline void copyIfCheck(OutputIterator r, const Container & c,
                        const SelectorBase & s) {
  for ( typename Container::const_iterator it = c.begin();
        it != c.end(); ++it )
    if ( s.check(**it) ) *r++ = *it;
}

}

#endif /* ThePEG_SelectorBase_H */