ConstRangeIterator Class Reference

#include <RangeIterator.h>

Collaboration diagram for ConstRangeIterator:

Public Types
using	iterator_category = std::forward_iterator_tag
using	difference_type = std::ptrdiff_t
using	value_type = ExpandedIdentifier
using	pointer = ExpandedIdentifier*
using	reference = ExpandedIdentifier&

Public Member Functions
	ConstRangeIterator ()=default
	ConstRangeIterator (const Range &range)
ConstRangeIterator	begin () const
ConstRangeIterator	end () const
ConstRangeIterator	operator++ ()
const ExpandedIdentifier &	operator* () const
bool	operator== (const ConstRangeIterator &other) const

Private Attributes
std::vector< std::size_t >	m_indices
ExpandedIdentifier	m_id
ExpandedIdentifier	m_min
ExpandedIdentifier	m_max
const Range *	m_range {}

Detailed Description

Definition at line 46 of file RangeIterator.h.

Member Typedef Documentation

difference_type

using ConstRangeIterator::difference_type = std::ptrdiff_t

Definition at line 49 of file RangeIterator.h.

iterator_category

using ConstRangeIterator::iterator_category = std::forward_iterator_tag

Definition at line 48 of file RangeIterator.h.

pointer

using ConstRangeIterator::pointer = ExpandedIdentifier*

Definition at line 51 of file RangeIterator.h.

reference

using ConstRangeIterator::reference = ExpandedIdentifier&

Definition at line 52 of file RangeIterator.h.

value_type

using ConstRangeIterator::value_type = ExpandedIdentifier

Definition at line 50 of file RangeIterator.h.

Constructor & Destructor Documentation

ConstRangeIterator() [1/2]

ConstRangeIterator::ConstRangeIterator ( )

default

ConstRangeIterator() [2/2]

ConstRangeIterator::ConstRangeIterator

(

const Range &

range

)

Fill all running identifiers m_id : the current id m_min : the set of low bounds m_max : the set of high bounds

Definition at line 151 of file RangeIterator.cxx.

                                                          :  
  m_range (&range) {  
  for (Range::size_type i = 0; i < range.fields (); ++i) { 
    Range::element_type minimum; 
    Range::element_type maximum; 
    m_indices.push_back (0); 
    const Range::field& f = range[i];
    if (f.empty()){
      m_id << 0; 
      m_min << 0; 
      m_max << 0; 
    } else {
      minimum = f.get_minimum (); 
      maximum = f.get_maximum (); 
      m_id << minimum; 
      m_min << minimum; 
      m_max << maximum; 
    }
  } 
} 

Member Function Documentation

begin()

ConstRangeIterator ConstRangeIterator::begin

(

)

const

Definition at line 18 of file RangeIterator.cxx.

                                { 
  return (*this); 
} 

end()

ConstRangeIterator ConstRangeIterator::end

(

)

const

Definition at line 32 of file RangeIterator.cxx.

                               { 
  static const Range r; 
  static const ConstRangeIterator factory(r); 
  return (factory); 
} 

operator*()

const ExpandedIdentifier & ConstRangeIterator::operator*

(

)

const

Definition at line 244 of file RangeIterator.cxx.

                                     { 
  return (m_id); 
} 

operator++()

ConstRangeIterator ConstRangeIterator::operator++

(

)

The local range is not exceeded. increase the value then reset the remaining fields.

The current range field was exhausted check the previous one.

Definition at line 181 of file RangeIterator.cxx.

                                { 
  if (m_id.fields () == 0) return *this; 
  Range::size_type fields = m_id.fields (); 
  Range::size_type i = fields - 1; 
  // 
  // Starting from the end, we try to increment the m_id fields 
  // If at a given position it's not possible (max reached) 
  // then we move back one pos and try again. 
  // 
  //  As soon as increment is possible, then the rest of the m_id 
  // is reset to min values. 
  // 
  for (;;){ 
      const Range::field& f = (*m_range)[i]; 
      bool done = false; 
      Range::element_type value = 0; 
 
      if (f.isEnumerated()) { 
          Range::size_type index = m_indices[i]; 
          index++; 
          if (index < f.get_indices ()) { 
              m_indices[i] = index; 
              value = f.get_value_at (index); 
              done = true; 
          } 
        }else { 
          value = m_id[i]; 
          if (value < m_max[i]){  
              ++value; 
              done = true; 
            } 
        } 
 
      if (done) { 
          m_id[i] = value; 
          for (++i; i < fields; ++i) { 
              m_indices[i] = 0; 
              m_id[i] = m_min[i]; 
          } 
          break; 
        } 
  
 
      if (i == 0) { 
          m_id.clear (); 
          break; 
      } 
      --i; 
        
    } 
    return *this;
} 

operator==()

bool ConstRangeIterator::operator==

(

const ConstRangeIterator &

other

)

const

Definition at line 250 of file RangeIterator.cxx.

                                                                      { 
  if (m_id == other.m_id) return (true); 
  return (false); 
}

Member Data Documentation

m_id

ExpandedIdentifier ConstRangeIterator::m_id

private

Definition at line 66 of file RangeIterator.h.

m_indices

std::vector<std::size_t> ConstRangeIterator::m_indices

private

Definition at line 65 of file RangeIterator.h.

m_max

ExpandedIdentifier ConstRangeIterator::m_max

private

Definition at line 68 of file RangeIterator.h.

m_min

ExpandedIdentifier ConstRangeIterator::m_min

private

Definition at line 67 of file RangeIterator.h.

m_range

const Range* ConstRangeIterator::m_range {}

private

Definition at line 69 of file RangeIterator.h.

{}; 

---

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

• RangeIterator.h
• RangeIterator.cxx