Such a class wouldn't be that difficult to write, here's something that
I cobbled together just now (standard warning applies; hasn't been
tested, yadda, yadda, yadda), should give you an idea where to start
----Begin code ---
#include <deque>
#include <utility>
template<typena me Iterator>
class DisjointIterato r
{
public:
typedef std::input_iter ator_tag iterator_catego ry;
typedef typename std::iterator_t raits<Iterator> ::value_type
value_type;
typedef typename std::iterator_t raits<Iterator> ::difference_ty pe
difference_type ;
typedef typename std::iterator_t raits<Iterator> ::pointer pointer;
typedef typename std::iterator_t raits<Iterator> ::reference reference;
typedef const reference const_reference ;
typedef const pointer const_pointer;
private:
bool m_is_end;
std::deque<std: :pair<Iterator, Iterator> > m_iters; //Pairs of begin
and end iterators
Iterator m_iter;
Iterator m_next_end;
void pop_next_iterat or_range()
{
m_is_end = m_iters.empty() ;
if(!m_is_end)
{
m_iter = m_iters.front() .first;
m_next_end = m_iters.front() .second;
m_iters.pop_fro nt();
}
}
public:
DisjointIterato r() : m_is_end(true) {}
DisjointIterato r(const DisjointIterato r &other) :
m_is_end(other. m_is_end), m_iters(other.m _iters), m_iter(other.m_ iter),
m_next_end(othe r.m_next_end) {}
template<typena me IteratorListInp utIterator> //Should be an
InputIterator into a sequence of std::pair<Itera tor,Iterator>
DisjointIterato r(IteratorListI nputIterator iter,
IteratorListInp utIterator end)
{
for(;iter != end; ++iter)
{
if(iter->first != iter->second)
{
m_iters.push_ba ck(*iter);
}
}
pop_next_iterat or_range();
}
DisjointIterato r &operator=(cons t DisjointIterato r &other)
{
m_is_end = other.m_is_end;
m_iters = other.m_iters;
m_iter = other.m_iter;
m_next_end = other.m_next_en d;
return *this;
}
DisjointIterato r &operator++( )
{
if(!m_is_end)
{
++m_iter;
if(m_iter == m_next_end)
{
pop_next_iterat or_range();
}
}
return *this;
}
DisjointIterato r operator++(int)
{
DisjointIterato r temp(*this);
++*this;
return temp;
}
bool operator==(cons t DisjointIterato r &other) const
{
if(m_is_end)
{
return other.m_is_end;
}
else
{
return m_iter == other.m_iter;
}
}
bool operator!=(cons t DisjointIterato r &other) const { return
!operator==(oth er); }
reference operator*() { return *m_iter; }
const_reference operator*() const { return *m_iter; }
pointer operator->() { return &(operator*( )); }
const_pointer operator->() const { return &(operator*( )); }
};
---- end code ----
And, for a sanity check, I just used it like so:
---- begin code ----
#include <vector>
using std::vector;
#include <utility>
using std::pair;
using std::make_pair;
#include <iterator>
using std::ostream_it erator;
#include <iostream>
using std::cout;
int main()
{
vector<int> vec;
for(int i = 0; i<100; ++i)
{
vec.push_back(i );
}
vector<pair<vec tor<int>::itera tor, vector<int>::it erator> > iters;
iters.push_back (make_pair(vec. begin(), vec.begin()+3)) ;
iters.push_back (make_pair(vec. begin()+20, vec.begin()+20) );
iters.push_back (make_pair(vec. begin()+21, vec.begin()+30) );
iters.push_back (make_pair(vec. begin()+90, vec.end()));
iters.push_back (make_pair(vec. begin()+20, vec.begin()+25) );
DisjointIterato r<vector<int>:: iterator>
disjoint_begin( iters.begin(), iters.end());
DisjointIterato r<vector<int>:: iterator> disjoint_end;
std::copy(disjo int_begin, disjoint_end, ostream_iterato r<int>(cout,
", "));
cout << "\n";
return 0;
}
---- end code ----
Which produced the following output:
0, 1, 2, 21, 22, 23, 24, 25, 26, 27, 28, 29, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 20, 21, 22, 23, 24,
[ See
http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]
