CartesianProductIterator< T > Class Template Reference

#include <CartesianProduct.h>

Inheritance diagram for CartesianProductIterator< T >:

Collaboration diagram for CartesianProductIterator< T >:

Public Member Functions
	CartesianProductIterator ()=delete
	Delete default constructor. More...
	CartesianProductIterator (T const &structure, std::size_t pos)
	Constructor setting the underlying iterator and position. More...

Private Types
using	OuterContainer = T
	Give types more descriptive names. More...
using	Container = typename T::value_type
using	Content = typename T::value_type::value_type

Private Member Functions
void	increment ()
	Increment iterator. More...
bool	equal (CartesianProductIterator< T > const &other) const
	Check for equality. More...
std::vector< Content > const &	dereference () const
	Dereference iterator. More...

Private Attributes
OuterContainer const &	structure_
	The part we are iterating over. More...
std::vector< typename Container::const_iterator >	position_
	The position in the Cartesian product. More...
std::size_t	absolutePosition_ = 0
	The position just indexed by an integer. More...
std::vector< typename Container::const_iterator >	cbegins_
	The begin iterators, saved for convenience and performance. More...
std::vector< typename Container::const_iterator >	cends_
	The end iterators, saved for convenience and performance. More...
std::vector< std::vector < Content > >	result_ {std::vector<Content>()}
	Used for returning references. More...
std::size_t	size_ = 0
	The size of the instance of OuterContainer. More...

Friends
class	boost::iterator_core_access
	Grant access to boost::iterator_facade. More...

Detailed Description

template<typename T>
class CartesianProductIterator< T >

Class iterating over the Cartesian product of a forward iterable container of forward iterable containers

Definition at line 30 of file CartesianProduct.h.

Member Typedef Documentation

template<typename T>

using CartesianProductIterator< T >::Container = typename T::value_type

private

Definition at line 51 of file CartesianProduct.h.

template<typename T>

using CartesianProductIterator< T >::Content = typename T::value_type::value_type

private

Definition at line 52 of file CartesianProduct.h.

template<typename T>

using CartesianProductIterator< T >::OuterContainer = T

private

Give types more descriptive names.

Definition at line 50 of file CartesianProduct.h.

Constructor & Destructor Documentation

template<typename T>

CartesianProductIterator< T >::CartesianProductIterator ( )

delete

Delete default constructor.

template<typename T >

CartesianProductIterator< T >::CartesianProductIterator ( T const &  structure, std::size_t  pos  )

explicit

Constructor setting the underlying iterator and position.

Parameters

[in]	structure	The underlying structure
[in]	pos	The position the iterator should be initialized to. std::numeric_limits<std::size_t>::max()stands for the end, the position after the last element.

Definition at line 99 of file CartesianProduct.h.

References CartesianProductIterator< T >::absolutePosition_, CartesianProductIterator< T >::cbegins_, CartesianProductIterator< T >::cends_, CartesianProductIterator< T >::increment(), CartesianProductIterator< T >::position_, CartesianProductIterator< T >::size_, and CartesianProductIterator< T >::structure_.

    : structure_(structure) {
  for (auto& entry : structure_) {
    cbegins_.push_back(entry.cbegin());
    cends_.push_back(entry.cend());
    ++size_;
  }

  if (pos == std::numeric_limits<std::size_t>::max() || size_ == 0) {
    absolutePosition_ = std::numeric_limits<std::size_t>::max();
    return;
  }

  // Initialize with all cbegin() position
  position_.reserve(size_);
  for (std::size_t i = 0; i != size_; ++i) {
    position_.push_back(cbegins_[i]);
    if (cbegins_[i] == cends_[i]) {
      // Empty member, so Cartesian product is empty
      absolutePosition_ = std::numeric_limits<std::size_t>::max();
      return;
    }
  }

  // Increment to wanted position
  for (std::size_t i = 0; i < pos; ++i) {
    increment();
  }
}

Here is the call graph for this function:

Member Function Documentation

template<typename T >

std::vector< typename T::value_type::value_type > const & CartesianProductIterator< T >::dereference ( ) const

private

Dereference iterator.

Definition at line 157 of file CartesianProduct.h.

References run_benchmark_import::result.

                                               {
  if (absolutePosition_ == std::numeric_limits<std::size_t>::max()) {
    throw new std::out_of_range("Out of bound dereference in CartesianProductIterator\n");
  }
  auto& result = result_[absolutePosition_];
  if (result.empty()) {
    result.reserve(size_);
    for (auto& iterator : position_) {
      result.push_back(*iterator);
    }
  }

  return result;
}

template<typename T >

bool CartesianProductIterator< T >::equal ( CartesianProductIterator< T > const &  other ) const

private

Check for equality.

Definition at line 173 of file CartesianProduct.h.

References CartesianProductIterator< T >::absolutePosition_, and CartesianProductIterator< T >::structure_.

                                                                                      {
  return absolutePosition_ == other.absolutePosition_ && structure_ == other.structure_;
}

template<typename T >

void CartesianProductIterator< T >::increment ( )

private

Increment iterator.

Definition at line 131 of file CartesianProduct.h.

Referenced by CartesianProductIterator< T >::CartesianProductIterator().

                                            {
  if (absolutePosition_ == std::numeric_limits<std::size_t>::max()) {
    return;
  }

  std::size_t pos = size_ - 1;

  // Descend as far as necessary
  while (++(position_[pos]) == cends_[pos] && pos != 0) {
    --pos;
  }
  if (position_[pos] == cends_[pos]) {
    assert(pos == 0);
    absolutePosition_ = std::numeric_limits<std::size_t>::max();
    return;
  }
  // Set all to begin behind pos
  for (++pos; pos != size_; ++pos) {
    position_[pos] = cbegins_[pos];
  }
  ++absolutePosition_;
  result_.emplace_back();
}

Here is the caller graph for this function:

Friends And Related Function Documentation

template<typename T>

friend class boost::iterator_core_access

friend

Grant access to boost::iterator_facade.

Definition at line 56 of file CartesianProduct.h.

Member Data Documentation

template<typename T>

std::size_t CartesianProductIterator< T >::absolutePosition_ = 0

private

The position just indexed by an integer.

Definition at line 79 of file CartesianProduct.h.

Referenced by CartesianProductIterator< T >::CartesianProductIterator(), and CartesianProductIterator< T >::equal().

template<typename T>

std::vector<typename Container::const_iterator> CartesianProductIterator< T >::cbegins_

private

The begin iterators, saved for convenience and performance.

Definition at line 82 of file CartesianProduct.h.

Referenced by CartesianProductIterator< T >::CartesianProductIterator().

template<typename T>

std::vector<typename Container::const_iterator> CartesianProductIterator< T >::cends_

private

The end iterators, saved for convenience and performance.

Definition at line 85 of file CartesianProduct.h.

Referenced by CartesianProductIterator< T >::CartesianProductIterator().

template<typename T>

std::vector<typename Container::const_iterator> CartesianProductIterator< T >::position_

private

The position in the Cartesian product.

For each element of structure_, give the position in it. The empty vector represents the end position. Note that this vector has a size equal to structure->size(), or is empty.

Definition at line 76 of file CartesianProduct.h.

Referenced by CartesianProductIterator< T >::CartesianProductIterator().

template<typename T>

std::vector<std::vector<Content> > CartesianProductIterator< T >::result_ {std::vector<Content>()}

mutableprivate

Used for returning references.

We initialize with one empty element, so that we only need to add more elements in increment().

Definition at line 92 of file CartesianProduct.h.

template<typename T>

std::size_t CartesianProductIterator< T >::size_ = 0

private

The size of the instance of OuterContainer.

Definition at line 95 of file CartesianProduct.h.

Referenced by CartesianProductIterator< T >::CartesianProductIterator().

template<typename T>

OuterContainer const& CartesianProductIterator< T >::structure_

private

The part we are iterating over.

Definition at line 68 of file CartesianProduct.h.

Referenced by CartesianProductIterator< T >::CartesianProductIterator(), and CartesianProductIterator< T >::equal().

---

The documentation for this class was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/CartesianProduct.h