individual_iterator.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_GP_INDIVIDUAL_EXON_VIEW_TCC)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_GP_INDIVIDUAL_ITERATOR_TCC)
#define      ULTRA_GP_INDIVIDUAL_ITERATOR_TCC
 
class individual;
 
namespace internal
{

template<bool is_const>
class basic_exon_iterator
{
public:
  using iterator_concept = std::input_iterator_tag;
  using iterator_category = std::input_iterator_tag;
 
  using difference_type = std::ptrdiff_t;
  using value_type = gene;
  using pointer = value_type *;
  using const_pointer = const value_type *;
  using reference = value_type &;
  using const_reference = const value_type &;
 
  using ptr= std::conditional_t<is_const, const_pointer, pointer>;
  using ref= std::conditional_t<is_const, const_reference, reference>;
  using ind= std::conditional_t<is_const, const gp::individual, gp::individual>;

  explicit basic_exon_iterator(ind &id) : ind_(std::addressof(id))
  {
    if (!id.empty())
      loci_.insert(id.start());
  }

  basic_exon_iterator &operator++()
  {
    if (!loci_.empty())
    {
      const auto &g(operator*());  // must be evaluated before erase()
 
      // Erasing first makes the tree shallower and reduces comparison work
      // during subsequent insertions: we remove the comparison hotspot and
      // the erased element was the one most likely to be compared against.
      loci_.erase(loci_.begin());
 
      for (const auto &a : g.args)
        if (a.index() == d_address)
          loci_.insert(g.locus_of_argument(a));
    }
 
    return *this;
  }

  basic_exon_iterator operator++(int)
  {
    const auto tmp(*this);
    operator++();
    return tmp;
  }

  [[nodiscard]] bool operator==(std::default_sentinel_t) const noexcept
  {
    return loci_.empty();
  }

  [[nodiscard]] ref &operator*() const
  {
    return ind_->genome_(locus());
  }

  [[nodiscard]] ptr operator->() const
  {
    return &operator*();
  }

  [[nodiscard]] ultra::locus locus() const
  {
    return *loci_.cbegin();
  }
 
private:
  // For different implementation see `test/speed_gp_individual_iterator.cc`.
 
  // Ordered frontier of active loci.
  std::set<ultra::locus, std::greater<ultra::locus>> loci_ {};
 
  // Pointer to the individual being iterated.
  ind *ind_ {nullptr};
};
 
}  // namespace internal
 
#endif  // include guard