icarus::details::IntegerRangesBase< T > Class Template Reference

A sequence of contiguous ranges of integral numbers. More...

#include <IntegerRanges.h>

Inheritance diagram for icarus::details::IntegerRangesBase< T >:

Classes
struct	Range_t

Public Types
using	Data_t = T
	Type of data for the range set. More...

Public Member Functions
void	clear () noexcept
	Removes all the entries and makes the set as default-constructed. More...
void	dump (std::ostream &out, std::string const &sep=" ", std::string const &inRangeSep="--") const
template<bool CheckGrowing, typename BIter , typename EIter >
auto	compactRange (BIter b, EIter e) -> std::vector< Range_t >
Queries
bool	empty () const noexcept
	Returns whether there is any element in the range set. More...
std::size_t	size () const noexcept
	Returns the number of elements in the ranges (gaps excluded). More...
std::size_t	nRanges () const noexcept
	Returns the number of non-contiguous ranges in the set. More...
decltype(auto)	ranges () const noexcept
	Returns an iterable object with all sorted ranges as elements. More...

Protected Member Functions
	IntegerRangesBase ()=default
	Default constructor: starts with no elements. More...
	IntegerRangesBase (std::vector< Range_t > ranges)
	Constructor for the derived classes. More...

Static Protected Member Functions
template<bool CheckGrowing, typename BIter , typename EIter >
static std::vector< Range_t >	compactRange (BIter b, EIter e)
	Fills the ranges. More...
static constexpr Data_t	plusOne (Data_t value) noexcept
	Returns value incremented by 1. More...
static constexpr Data_t	minusOne (Data_t value) noexcept
	Returns value decremented by 1. More...

Private Attributes
std::vector< Range_t >	fRanges
	List of current ranges. More...

Detailed Description

template<typename T = int>
class icarus::details::IntegerRangesBase< T >

A sequence of contiguous ranges of integral numbers.

Template Parameters

T	type of the integral numbers
CheckGrowing	if true, checks will be performed on construction

This class parses a sequence in input grouping the consecutive elements. The current interface is very simple, allowing only for query of groups ("ranges") and printing to a stream. The input is required and assumed to be a monotonously growing sequence, with the exception that duplicate consecutive entries are allowed (and ignored).

Each range is stored as a semi-open interval: [ lower, upper [.

Definition at line 29 of file IntegerRanges.h.

Member Typedef Documentation

template<typename T = int>

using icarus::details::IntegerRangesBase< T >::Data_t = T

Type of data for the range set.

Definition at line 79 of file IntegerRanges.h.

Constructor & Destructor Documentation

template<typename T = int>

icarus::details::IntegerRangesBase< T >::IntegerRangesBase ( )

protecteddefault

Default constructor: starts with no elements.

template<typename T >

icarus::details::IntegerRangesBase< T >::IntegerRangesBase ( std::vector< Range_t >  ranges )

protected

Constructor for the derived classes.

Definition at line 300 of file IntegerRanges.h.

                             : fRanges(std::move(ranges))
  {}

Member Function Documentation

template<typename T >

void icarus::details::IntegerRangesBase< T >::clear ( )

noexcept

Removes all the entries and makes the set as default-constructed.

Definition at line 306 of file IntegerRanges.h.

  { return fRanges.clear(); }

template<typename T = int>

template<bool CheckGrowing, typename BIter , typename EIter >

static std::vector<Range_t> icarus::details::IntegerRangesBase< T >::compactRange ( BIter  b, EIter  e  )

staticprotected

Fills the ranges.

template<typename T = int>

template<bool CheckGrowing, typename BIter , typename EIter >

auto icarus::details::IntegerRangesBase< T >::compactRange	(	BIter	b,
		EIter	e
	)		-> std::vector<Range_t>

Definition at line 341 of file IntegerRanges.h.

{
  if (b == e) return {};
  
  std::vector<Range_t> ranges;
  
  auto it = b;
  auto iPrev = it; // not sure if BIter default-constructible, so copy instead
  auto iFirst = b;
  
  while (it != e) {
    
    iPrev = it++;
    
    if (it != e) { // check current and previous elements
      if (*iPrev == *it) continue; // duplicate entry: quietly skip
      if constexpr (CheckGrowing) {
        if (*it < *iPrev) {
          using std::to_string;
          throw std::runtime_error{ "icarus::IntegerRanges"
            " initialized with non-monotonically growing sequence ("
            + to_string(*iPrev) + " then " + to_string(*it)
            + ")"
            };
        }
      } // if checking growth
    } // if not at the end
    
    auto const nextExpected = plusOne(*iPrev);
    
    if ((it != e) && (*it == nextExpected)) continue; // contiguous to previous
    
    ranges.emplace_back(*iFirst, nextExpected);
    
    iFirst = it;
    
  } // while
  
  return ranges;
} // icarus::details::IntegerRangesBase<>::compactRange()

template<typename T >

void icarus::details::IntegerRangesBase< T >::dump	(	std::ostream &	out,
		std::string const &	sep = " ",
		std::string const &	inRangeSep = "--"
	)		const

Prints the range into the specified stream.

Parameters

out	the stream to print into
sep	separator between ranges
inRangeSep	separator between lower and higher limit of each range

Definition at line 400 of file IntegerRanges.h.

        {
  
  if (empty()) return;
  
  auto iRange = fRanges.begin();
  auto const rend = fRanges.end();
  iRange->dump(out, inRangeSep, sep);
  while (++iRange != rend) iRange->dump(out << sep, inRangeSep, sep);
  
} // icarus::details::IntegerRangesBase<>::dump()

template<typename T >

bool icarus::details::IntegerRangesBase< T >::empty ( ) const

noexcept

Returns whether there is any element in the range set.

Definition at line 312 of file IntegerRanges.h.

  { return fRanges.empty(); }

template<typename T >

constexpr auto icarus::details::IntegerRangesBase< T >::minusOne ( Data_t  value )

staticprotectednoexcept

Returns value decremented by 1.

Definition at line 394 of file IntegerRanges.h.

  { return --value; }

template<typename T >

std::size_t icarus::details::IntegerRangesBase< T >::nRanges ( ) const

noexcept

Returns the number of non-contiguous ranges in the set.

Definition at line 328 of file IntegerRanges.h.

  { return fRanges.size(); }

template<typename T >

constexpr auto icarus::details::IntegerRangesBase< T >::plusOne ( Data_t  value )

staticprotectednoexcept

Returns value incremented by 1.

Definition at line 387 of file IntegerRanges.h.

  { return ++value; }

template<typename T = int>

decltype(auto) icarus::details::IntegerRangesBase< T >::ranges ( ) const

noexcept

Returns an iterable object with all sorted ranges as elements.

template<typename T >

std::size_t icarus::details::IntegerRangesBase< T >::size ( ) const

noexcept

Returns the number of elements in the ranges (gaps excluded).

Definition at line 318 of file IntegerRanges.h.

                                                                 {
  
  return std::accumulate(fRanges.begin(), fRanges.end(), 0U, 
    [](std::size_t s, Range_t const& r){ return s + r.size(); });
  
} // icarus::details::IntegerRangesBase<>::size()

Member Data Documentation

template<typename T = int>

std::vector<Range_t> icarus::details::IntegerRangesBase< T >::fRanges

private

List of current ranges.

Definition at line 158 of file IntegerRanges.h.

---

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

• IntegerRanges.h