TrigCompositeUtils/TrigCompositeUtils/Combinators.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TRIGCOMPOSITEUTILS_COMBINATORS_H
#define TRIGCOMPOSITEUTILS_COMBINATORS_H
 
#include <vector>
#include <set>
#include <functional>
 
namespace HLT {
  class CombinationGenerator {
  public:
    CombinationGenerator( const std::initializer_list<size_t>& collectionSizes );
    void add( size_t nextColl) { m_maxes.push_back( nextColl ); reset(); }
    void reset();
    size_t size() const { return m_maxes.size(); }
    const std::vector<size_t>& operator()() const { return m_current; }
    const std::vector<size_t>& current() const { return m_current; }
        
    void operator++();
        
    operator bool() const;
  private:
    std::vector<size_t> m_maxes;
    std::vector<size_t> m_current;
  };

  class UniqueCombinationGenerator {
  public:
    UniqueCombinationGenerator( size_t nelems, size_t comblen);
    void reset();
    size_t size() const { return m_combLen; }
    const std::vector<size_t>& operator()() const { return current(); }
    const std::vector<size_t>& current() const { return m_current; }
 
    void operator++();
    operator bool() const;
  private:
    size_t m_nElements;
    size_t m_combLen;
    std::vector<size_t> m_current;
    std::vector<bool> m_bitmask;
  };

  class NestedUniqueCombinationGenerator {
  public:
    void add( const UniqueCombinationGenerator& gen );
    void reset();
    size_t size() const;
    const std::vector<size_t>& operator()() const { return current(); }
    const std::vector<size_t>& current() const { return m_current; }
 
    void operator++();
    operator bool() const;
    
 
  private:
    std::vector<UniqueCombinationGenerator> m_generators;
    std::vector<size_t> m_current;
    void cache();
  };

  template<typename ... Collections>
  class CombinationIterator {
  public:
 
    CombinationIterator( Collections ... coll);
    ~CombinationIterator();
 
    template<typename ... Iterators>
    void operator()( Iterators ... iter ) const;
    
    void reset() {  }        
    operator bool() const;
            
    void operator++();    
  private:
    CombinationGenerator m_generator;
  };  
 

  typedef std::vector<size_t>  Index1DVec;
  typedef std::vector< Index1DVec > Index2DVec;
 
  void elementsInUniqueCombinations( const Index2DVec& indices,  std::set<size_t>& participants, const std::function<bool(const Index1DVec&)>& filter = [](const Index1DVec&){ return true; } );
  
  void findUniqueCombinations( const Index2DVec& indices,  std::vector<std::vector<size_t> >& combinations, const std::function<bool(const Index1DVec&)>& filter = [](const Index1DVec&){ return true; } );
 
 
  
}
 
#endif // DECISIONHANDLING_COMBINATORS_H