Nodes.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2023 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Decays/Decay.h>
#include <Gaudi/Decays/iNode.h>
#include <Gaudi/ParticleID.h>
#include <GaudiKernel/Kernel.h>
#include <GaudiKernel/SmartIF.h>
#include <GaudiKernel/StatusCode.h>
#include <algorithm>
 
namespace Gaudi::Decays {
  template <typename Iterator>
  bool valid( Iterator begin, Iterator end ) {
    return std::all_of( begin, end, []( const auto& i ) { return i.valid(); } );
  }
  template <typename Container>
  bool valid( Container const& c ) {
    return valid( c.begin(), c.end() );
  }
 
  template <class Iterator>
  StatusCode validate( Iterator begin, Iterator end, const Gaudi::Interfaces::IParticlePropertySvc* svc ) {
    for ( ; begin != end; ++begin ) {
      StatusCode sc = begin->validate( svc );
      if ( sc.isFailure() ) { return sc; }
    }
    return StatusCode::SUCCESS;
  }
  template <class TREE>
  StatusCode validate( TREE const& tree, const Gaudi::Interfaces::IParticlePropertySvc* svc ) {
    return validate( tree.begin(), tree.end(), svc );
  }
 
  class NodeList;
 
  namespace Nodes {
    class GAUDI_API Invalid : public Decays::iNode {
    public:
      Invalid() = default;
      Invalid* clone() const override;
      bool operator()( const Gaudi::ParticleID& /* p */ ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
    };
 
    class GAUDI_API _Node {
    public:
      _Node();
      _Node( const iNode& node ) : m_node( node ) {}
      _Node( const Node& node ) : m_node( node ) {}
      // default copy constructor
      _Node( const _Node& node ) = default;
      inline bool valid() const { return m_node.node().valid(); }
      inline StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const {
        return m_node.node().validate( svc );
      }
      inline bool operator()( const Gaudi::ParticleID& pid ) const { return m_node.node( pid ); }
 
      inline bool operator==( const Gaudi::ParticleID& pid ) const { return m_node.node( pid ); }
 
      inline bool operator!=( const Gaudi::ParticleID& pid ) const { return !m_node.node( pid ); }
 
      _Node& operator=( const Node& right ) {
        m_node = right;
        return *this;
      }
      _Node& operator=( const iNode& right ) {
        m_node = right;
        return *this;
      }
      _Node& operator=( const _Node& right ) {
        m_node = right.m_node;
        return *this;
      }
 
      _Node& operator|=( const iNode& right ) {
        m_node |= right;
        return *this;
      }
      _Node& operator&=( const iNode& right ) {
        m_node &= right;
        return *this;
      }
 
      _Node& operator|=( const NodeList& right ) { return op_or( right ); }
      _Node& operator&=( const NodeList& right ) { return op_and( right ); }
 
      _Node& operator|=( const _Node& right ) {
        m_node |= right;
        return *this;
      }
      _Node& operator&=( const _Node& right ) {
        m_node &= right;
        return *this;
      }
 
      const Decays::iNode& node() const { return m_node.node(); }
      operator const Decays::iNode&() const { return node(); }
 
    private:
      _Node& op_or( const NodeList& right );
      _Node& op_and( const NodeList& right );
      Decays::Node m_node;
    };
  } // namespace Nodes
 
  class GAUDI_API NodeList {
  public:
    typedef std::vector<Decays::Nodes::_Node> Nodes_;
    typedef Nodes_::const_iterator            const_iterator;
    typedef Nodes_::iterator                  iterator;
    typedef Nodes_::value_type                value_type;
 
    NodeList( const Nodes_& nodes = Nodes_() );
 
    void push_back( const Decays::Nodes::_Node& node );
    void push_back( const Decays::iNode& node );
    void push_back( const Nodes_& nodes );
    void push_back( const NodeList& nodes );
    void clear() { m_nodes.clear(); }
 
    NodeList& operator=( const Decays::Nodes::_Node& node );
    NodeList& operator=( const Decays::iNode& node );
 
    NodeList& operator+=( const Decays::Nodes::_Node& node ) {
      push_back( node );
      return *this;
    }
    NodeList& operator+=( const Decays::iNode& node ) {
      push_back( node );
      return *this;
    }
    NodeList& operator+=( const Nodes_& nodes ) {
      push_back( nodes );
      return *this;
    }
    NodeList& operator+=( const NodeList& nodes ) {
      push_back( nodes );
      return *this;
    }
 
    size_t         size() const { return m_nodes.size(); }
    bool           empty() const { return m_nodes.empty(); }
    iterator       begin() { return m_nodes.begin(); }
    iterator       end() { return m_nodes.end(); }
    const_iterator begin() const { return m_nodes.begin(); }
    const_iterator end() const { return m_nodes.end(); }
 
    operator const Nodes_&() const { return m_nodes; }
 
  private:
    Nodes_ m_nodes;
  };
 
  namespace Nodes {
    class GAUDI_API Or : public Decays::iNode {
    public:
      Or( const Decays::iNode& n1, const Decays::iNode& n2 );
      Or( const Decays::iNode& n1, const Decays::iNode& n2, const Decays::iNode& n3 );
      Or( const Decays::iNode& n1, const Decays::iNode& n2, const Decays::iNode& n3, const Decays::iNode& n4 );
      Or( const Decays::NodeList& nodes );
      Or* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
 
    protected:
      size_t add( const Decays::iNode& node );
      size_t add( const Decays::NodeList& nodes );
 
    public:
      Or& operator+=( const Decays::iNode& node );
      Or& operator+=( const Decays::NodeList& node );
 
    private:
      Or(); // the default constructor is disabled
 
      Decays::NodeList m_nodes;
    };
 
    class GAUDI_API And : public Decays::iNode {
    public:
      And( const Decays::iNode& n1, const Decays::iNode& n2 );
      And( const Decays::iNode& n1, const Decays::iNode& n2, const Decays::iNode& n3 );
      And( const Decays::iNode& n1, const Decays::iNode& n2, const Decays::iNode& n3, const Decays::iNode& n4 );
      And( const Decays::NodeList& nodes );
      And* clone() const override;
      bool operator()( const Gaudi::ParticleID& p ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
 
    protected:
      size_t add( const Decays::iNode& node );
      size_t add( const Decays::NodeList& nodes );
 
    public:
      And& operator+=( const Decays::iNode& node );
      And& operator+=( const Decays::NodeList& nodes );
 
    private:
      NodeList m_nodes;
    };
 
    class GAUDI_API Not : public Decays::iNode {
    public:
      Not( const Decays::iNode& node );
      Not* clone() const override;
      bool operator()( const Gaudi::ParticleID& pid ) const override;
      std::ostream& fillStream( std::ostream& s ) const override;
      bool valid() const override;
      StatusCode validate( const Gaudi::Interfaces::IParticlePropertySvc* svc ) const override;
 
    public:
      const Decays::iNode& node() const { return m_node.node(); }
 
    private:
      Decays::Node m_node;
    };
 
    inline Decays::Nodes::Not operator!( const Decays::Nodes::Not& o ) { return Decays::Node( o.node() ); }
 
    inline std::ostream& operator<<( std::ostream& s, const Decays::Nodes::_Node& n ) { return s << n.node(); }
  } // namespace Nodes
 
  inline Decays::Nodes::Or operator||( const Decays::iNode& o1, const Decays::iNode& o2 ) {
    return Decays::Nodes::Or( o1, o2 );
  }
 
  inline Decays::Nodes::Or operator|( const Decays::iNode& o1, const Decays::iNode& o2 ) {
    return Decays::Nodes::Or( o1, o2 );
  }
 
  inline Decays::Nodes::And operator&&( const Decays::iNode& o1, const Decays::iNode& o2 ) {
    return Decays::Nodes::And( o1, o2 );
  }
 
  inline Decays::Nodes::And operator&( const Decays::iNode& o1, const Decays::iNode& o2 ) {
    return Decays::Nodes::And( o1, o2 );
  }
 
  inline Decays::Nodes::Not operator~( const Decays::iNode& o ) { return Decays::Nodes::Not( o ); }
 
  GAUDI_API
  Decays::Nodes::Or operator||( const Decays::iNode& o1, const std::string& o2 );
 
  GAUDI_API
  Decays::Nodes::Or operator||( const Decays::iNode& o1, const Gaudi::ParticleID& o2 );
 
  GAUDI_API
  Decays::Nodes::Or operator||( const Decays::iNode& o1, const Decays::Decay::Item& o2 );
 
  GAUDI_API
  Decays::Nodes::Or operator||( const Decays::iNode& o1, const Gaudi::ParticleProperty* o2 );
 
  GAUDI_API
  Decays::Nodes::Or operator||( const std::string& o2, const Decays::iNode& o1 );
 
  GAUDI_API
  Decays::Nodes::Or operator||( const Gaudi::ParticleID& o2, const Decays::iNode& o1 );
 
  GAUDI_API
  Decays::Nodes::Or operator||( const Decays::Decay::Item& o2, const Decays::iNode& o1 );
 
  GAUDI_API
  Decays::Nodes::Or operator||( const Gaudi::ParticleProperty* o2, const Decays::iNode& o1 );
 
  GAUDI_API
  Decays::Nodes::And operator&&( const Decays::iNode& o1, const std::string& o2 );
 
  GAUDI_API
  Decays::Nodes::And operator&&( const Decays::iNode& o1, const Gaudi::ParticleID& o2 );
 
  GAUDI_API
  Decays::Nodes::And operator&&( const Decays::iNode& o1, const Decays::Decay::Item& o2 );
 
  GAUDI_API
  Decays::Nodes::And operator&&( const Decays::iNode& o1, const Gaudi::ParticleProperty* o2 );
 
  GAUDI_API
  Decays::Nodes::And operator&&( const std::string& o2, const Decays::iNode& o1 );
 
  GAUDI_API
  Decays::Nodes::And operator&&( const Gaudi::ParticleID& o2, const Decays::iNode& o1 );
 
  GAUDI_API
  Decays::Nodes::And operator&&( const Decays::Decay::Item& o2, const Decays::iNode& o1 );
 
  GAUDI_API
  Decays::Nodes::And operator&&( const Gaudi::ParticleProperty* o2, const Decays::iNode& o1 );
 
} // namespace Gaudi::Decays