370 lines
12 KiB
C++
370 lines
12 KiB
C++
#pragma once
|
|
|
|
#ifndef TCG_ANY_ITERATOR_H
|
|
#define TCG_ANY_ITERATOR_H
|
|
|
|
#include "base.h"
|
|
|
|
/*
|
|
\file any_iterator.h
|
|
|
|
\brief This file contains the implementation of a type-erased iterator
|
|
template class.
|
|
|
|
\details Type erasure is a C++ idiom about allocating an interface
|
|
to an object who is then hidden as the interface's implementation
|
|
detail.
|
|
|
|
The cost of using a type-erased object instead of its actual type is
|
|
typically
|
|
measured in a heap access at construction and destruction, and one
|
|
virtual
|
|
function call per method invocation.
|
|
|
|
A type-erased iterator can be useful to hide implementation details
|
|
about container
|
|
choices, yet providing an iterator-like interface to access the
|
|
stored data.
|
|
*/
|
|
|
|
#ifndef TCG_RVALUES_SUPPORT
|
|
#include <boost/config.hpp>
|
|
|
|
#ifdef BOOST_NO_RVALUE_REFERENCES
|
|
#define TCG_RVALUES_SUPPORT 0
|
|
#else
|
|
#define TCG_RVALUES_SUPPORT 1
|
|
#endif
|
|
#endif
|
|
|
|
namespace tcg {
|
|
|
|
//****************************************************************************
|
|
// any_iterator_concept (ie the interface)
|
|
//****************************************************************************
|
|
|
|
template <typename Val, typename ValRef, typename ValPtr, typename Dist>
|
|
class any_iterator_concept {
|
|
public:
|
|
virtual ~any_iterator_concept() {}
|
|
|
|
virtual any_iterator_concept *clone() const = 0;
|
|
|
|
virtual ValRef operator*() const = 0;
|
|
virtual ValPtr operator->() const = 0;
|
|
|
|
virtual bool operator==(const any_iterator_concept &other) const = 0;
|
|
virtual bool operator!=(const any_iterator_concept &other) const = 0;
|
|
|
|
virtual void operator++() = 0;
|
|
virtual any_iterator_concept *operator++(int) {
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
|
|
virtual void operator--() { assert(false); }
|
|
virtual any_iterator_concept *operator--(int) {
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
|
|
virtual bool operator<(const any_iterator_concept &) const {
|
|
assert(false);
|
|
return false;
|
|
}
|
|
virtual bool operator>(const any_iterator_concept &) const {
|
|
assert(false);
|
|
return false;
|
|
}
|
|
virtual bool operator<=(const any_iterator_concept &) const {
|
|
assert(false);
|
|
return false;
|
|
}
|
|
virtual bool operator>=(const any_iterator_concept &) const {
|
|
assert(false);
|
|
return false;
|
|
}
|
|
|
|
virtual any_iterator_concept *operator+(Dist) const {
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
virtual void operator+=(Dist d) { assert(false); }
|
|
|
|
virtual any_iterator_concept *operator-(Dist) const {
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
virtual void operator-=(Dist d) { assert(false); }
|
|
|
|
virtual Dist operator-(const any_iterator_concept &) const {
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
|
|
virtual ValRef operator[](Dist) const {
|
|
assert(false);
|
|
return *(Val *)0;
|
|
}
|
|
};
|
|
|
|
//****************************************************************************
|
|
// any_iterator_model (ie the concrete interface implementations)
|
|
//****************************************************************************
|
|
|
|
template <typename It, typename iterator_cat, typename Val, typename ValRef,
|
|
typename ValPtr, typename Dist>
|
|
class any_iterator_model
|
|
: public any_iterator_concept<Val, ValRef, ValPtr, Dist> {
|
|
typedef any_iterator_concept<Val, ValRef, ValPtr, Dist> any_it_concept;
|
|
|
|
public:
|
|
any_iterator_model() : m_it() {}
|
|
any_iterator_model(const It &it) : m_it(it) {}
|
|
|
|
any_it_concept *clone() const {
|
|
return new any_iterator_model<It, iterator_cat, Val, ValRef, ValPtr, Dist>(
|
|
*this);
|
|
}
|
|
|
|
ValRef operator*() const { return m_it.operator*(); }
|
|
ValPtr operator->() const { return m_it.operator->(); }
|
|
|
|
bool operator==(const any_it_concept &other) const {
|
|
return m_it == static_cast<const any_iterator_model &>(other).m_it;
|
|
}
|
|
bool operator!=(const any_it_concept &other) const {
|
|
return m_it != static_cast<const any_iterator_model &>(other).m_it;
|
|
}
|
|
|
|
void operator++() { ++m_it; }
|
|
any_it_concept *operator++(int) {
|
|
return new any_iterator_model<It, iterator_cat, Val, ValRef, ValPtr, Dist>(
|
|
m_it++);
|
|
}
|
|
|
|
protected:
|
|
It m_it;
|
|
};
|
|
|
|
template <typename It, typename Val, typename ValRef, typename ValPtr,
|
|
typename Dist>
|
|
class any_iterator_model<It, std::bidirectional_iterator_tag, Val, ValRef,
|
|
ValPtr, Dist>
|
|
: public any_iterator_model<It, std::forward_iterator_tag, Val, ValRef,
|
|
ValPtr, Dist> {
|
|
typedef any_iterator_concept<Val, ValRef, ValPtr, Dist> any_it_concept;
|
|
|
|
using any_iterator_model<It, std::forward_iterator_tag, Val, ValRef, ValPtr,
|
|
Dist>::m_it;
|
|
|
|
public:
|
|
any_iterator_model() {}
|
|
any_iterator_model(const It &it)
|
|
: any_iterator_model<It, std::forward_iterator_tag, Val, ValRef, ValPtr,
|
|
Dist>(it) {}
|
|
|
|
any_it_concept *clone() const {
|
|
return new any_iterator_model<It, std::bidirectional_iterator_tag, Val,
|
|
ValRef, ValPtr, Dist>(*this);
|
|
}
|
|
|
|
void operator--() { --m_it; }
|
|
any_it_concept *operator--(int) {
|
|
return new any_iterator_model<It, std::bidirectional_iterator_tag, Val,
|
|
ValRef, ValPtr, Dist>(m_it--);
|
|
}
|
|
};
|
|
|
|
template <typename It, typename Val, typename ValRef, typename ValPtr,
|
|
typename Dist>
|
|
class any_iterator_model<It, std::random_access_iterator_tag, Val, ValRef,
|
|
ValPtr, Dist>
|
|
: public any_iterator_model<It, std::bidirectional_iterator_tag, Val,
|
|
ValRef, ValPtr, Dist> {
|
|
typedef any_iterator_concept<Val, ValRef, ValPtr, Dist> any_it_concept;
|
|
|
|
using any_iterator_model<It, std::forward_iterator_tag, Val, ValRef, ValPtr,
|
|
Dist>::m_it;
|
|
|
|
public:
|
|
any_iterator_model() {}
|
|
any_iterator_model(const It &it)
|
|
: any_iterator_model<It, std::bidirectional_iterator_tag, Val, ValRef,
|
|
ValPtr, Dist>(it) {}
|
|
|
|
any_it_concept *clone() const {
|
|
return new any_iterator_model<It, std::random_access_iterator_tag, Val,
|
|
ValRef, ValPtr, Dist>(*this);
|
|
}
|
|
|
|
bool operator<(const any_it_concept &other) const {
|
|
return m_it < static_cast<const any_iterator_model &>(other).m_it;
|
|
}
|
|
bool operator>(const any_it_concept &other) const {
|
|
return m_it > static_cast<const any_iterator_model &>(other).m_it;
|
|
}
|
|
bool operator<=(const any_it_concept &other) const {
|
|
return m_it <= static_cast<const any_iterator_model &>(other).m_it;
|
|
}
|
|
bool operator>=(const any_it_concept &other) const {
|
|
return m_it >= static_cast<const any_iterator_model &>(other).m_it;
|
|
}
|
|
|
|
any_it_concept *operator+(Dist d) const {
|
|
return new any_iterator_model<It, std::random_access_iterator_tag, Val,
|
|
ValRef, ValPtr, Dist>(m_it + d);
|
|
}
|
|
void operator+=(Dist d) { m_it += d; }
|
|
|
|
any_it_concept *operator-(Dist d) const {
|
|
return new any_iterator_model<It, std::random_access_iterator_tag, Val,
|
|
ValRef, ValPtr, Dist>(m_it - d);
|
|
}
|
|
void operator-=(Dist d) { m_it -= d; }
|
|
|
|
Dist operator-(const any_it_concept &other) const {
|
|
return m_it - static_cast<const any_iterator_model &>(other).m_it;
|
|
}
|
|
|
|
ValRef operator[](Dist d) const { return m_it[d]; }
|
|
};
|
|
|
|
//****************************************************************************
|
|
// any_iterator (ie the wrapper to the interface)
|
|
//****************************************************************************
|
|
|
|
template <typename Val, typename iterator_cat = tcg::empty_type,
|
|
typename ValRef = Val &, typename ValPtr = Val *,
|
|
typename Dist = std::ptrdiff_t>
|
|
class any_iterator
|
|
: public std::iterator<iterator_cat, Val, Dist, ValPtr, ValRef> {
|
|
any_iterator_concept<Val, ValRef, ValPtr, Dist> *m_model;
|
|
|
|
public:
|
|
any_iterator() : m_model(0) {}
|
|
any_iterator(any_iterator_concept<Val, ValRef, ValPtr, Dist> *model)
|
|
: m_model(model) {}
|
|
|
|
template <typename It>
|
|
any_iterator(const It &it)
|
|
: m_model(
|
|
new any_iterator_model<It, iterator_cat, Val, ValRef, ValPtr, Dist>(
|
|
it)) {}
|
|
|
|
any_iterator(const any_iterator &other) : m_model(other.m_model->clone()) {}
|
|
any_iterator &operator=(any_iterator other) {
|
|
swap(*this, other);
|
|
return *this;
|
|
}
|
|
|
|
~any_iterator() { delete m_model; }
|
|
|
|
friend void swap(any_iterator &a, any_iterator &b) {
|
|
std::swap(a.m_model, b.m_model);
|
|
}
|
|
|
|
ValRef operator*() const { return m_model->operator*(); }
|
|
ValPtr operator->() const { return m_model->operator->(); }
|
|
|
|
bool operator==(const any_iterator &other) const {
|
|
return m_model->operator==(*other.m_model);
|
|
}
|
|
bool operator!=(const any_iterator &other) const {
|
|
return m_model->operator!=(*other.m_model);
|
|
}
|
|
|
|
any_iterator &operator++() {
|
|
++*m_model;
|
|
return *this;
|
|
}
|
|
any_iterator operator++(int) { return any_iterator((*m_model)++); }
|
|
|
|
any_iterator &operator--() {
|
|
--*m_model;
|
|
return *this;
|
|
}
|
|
any_iterator operator--(int) { return any_iterator((*m_model)--); }
|
|
|
|
bool operator<(const any_iterator &other) const {
|
|
return m_model->operator<(*other.m_model);
|
|
}
|
|
bool operator>(const any_iterator &other) const {
|
|
return m_model->operator>(*other.m_model);
|
|
}
|
|
bool operator<=(const any_iterator &other) const {
|
|
return m_model->operator<=(*other.m_model);
|
|
}
|
|
bool operator>=(const any_iterator &other) const {
|
|
return m_model->operator>=(*other.m_model);
|
|
}
|
|
|
|
any_iterator operator+(Dist d) const { return any_iterator((*m_model) + d); }
|
|
any_iterator &operator+=(Dist d) {
|
|
(*m_model) += d;
|
|
return *this;
|
|
}
|
|
|
|
any_iterator operator-(Dist d) const { return any_iterator((*m_model) - d); }
|
|
any_iterator &operator-=(Dist d) {
|
|
(*m_model) -= d;
|
|
return *this;
|
|
}
|
|
|
|
Dist operator-(const any_iterator &other) const {
|
|
return m_model->operator-(*other.m_model);
|
|
}
|
|
|
|
ValRef operator[](Dist d) const { return m_model->operator[](d); }
|
|
|
|
#if (TCG_RVALUES_SUPPORT > 0)
|
|
|
|
any_iterator(any_iterator &&other) : m_model(other.m_model) {
|
|
other.m_model = 0;
|
|
}
|
|
|
|
#endif
|
|
};
|
|
|
|
//-------------------------------------------------------------------------------
|
|
|
|
template <typename Val, typename iterator_cat, typename ValRef, typename ValPtr,
|
|
typename Dist>
|
|
any_iterator<Val, iterator_cat, ValRef, ValPtr, Dist> operator+(
|
|
Dist d, const any_iterator<Val, iterator_cat, ValRef, ValPtr, Dist> &it) {
|
|
return it + d;
|
|
}
|
|
|
|
//****************************************************************************
|
|
// Additional typedefs to the actual types
|
|
//****************************************************************************
|
|
|
|
template <typename Val>
|
|
struct any_iterator<Val, tcg::empty_type> {
|
|
typedef any_iterator<Val, std::input_iterator_tag> input;
|
|
typedef any_iterator<Val, std::output_iterator_tag> output;
|
|
typedef any_iterator<Val, std::forward_iterator_tag> forward;
|
|
typedef any_iterator<Val, std::bidirectional_iterator_tag> bidirectional;
|
|
typedef any_iterator<Val, std::random_access_iterator_tag> random;
|
|
};
|
|
|
|
template <typename Val, typename ValRef = Val &, typename ValPtr = Val *,
|
|
typename Dist = std::ptrdiff_t>
|
|
struct any_it {
|
|
typedef any_iterator<Val, std::input_iterator_tag, ValRef, ValPtr, Dist>
|
|
input;
|
|
typedef any_iterator<Val, std::output_iterator_tag, ValRef, ValPtr, Dist>
|
|
output;
|
|
typedef any_iterator<Val, std::forward_iterator_tag, ValRef, ValPtr, Dist>
|
|
forward;
|
|
typedef any_iterator<Val, std::bidirectional_iterator_tag, ValRef, ValPtr,
|
|
Dist>
|
|
bidirectional;
|
|
typedef any_iterator<Val, std::random_access_iterator_tag, ValRef, ValPtr,
|
|
Dist>
|
|
random;
|
|
};
|
|
|
|
} // namespace tcg
|
|
|
|
#endif // TCG_ANY_ITERATOR_H
|