670 lines
24 KiB
Plaintext
670 lines
24 KiB
Plaintext
//
|
|
// (C) Copyright Jeremy Siek 2000.
|
|
// Distributed under the Boost Software License, Version 1.0. (See
|
|
// accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
// Revision History:
|
|
//
|
|
// 17 July 2001: Added const to some member functions. (Jeremy Siek)
|
|
// 05 May 2001: Removed static dummy_cons object. (Jeremy Siek)
|
|
|
|
// See http://www.boost.org/libs/concept_check for documentation.
|
|
|
|
#ifndef BOOST_CONCEPT_ARCHETYPES_HPP
|
|
#define BOOST_CONCEPT_ARCHETYPES_HPP
|
|
|
|
#include <boost/config.hpp>
|
|
#include <boost/iterator.hpp>
|
|
#include <boost/mpl/identity.hpp>
|
|
#include <functional>
|
|
|
|
namespace boost {
|
|
|
|
//===========================================================================
|
|
// Basic Archetype Classes
|
|
|
|
namespace detail {
|
|
class dummy_constructor { };
|
|
}
|
|
|
|
// A type that models no concept. The template parameter
|
|
// is only there so that null_archetype types can be created
|
|
// that have different type.
|
|
template <class T = int>
|
|
class null_archetype {
|
|
private:
|
|
null_archetype() { }
|
|
null_archetype(const null_archetype&) { }
|
|
null_archetype& operator=(const null_archetype&) { return *this; }
|
|
public:
|
|
null_archetype(detail::dummy_constructor) { }
|
|
#ifndef __MWERKS__
|
|
template <class TT>
|
|
friend void dummy_friend(); // just to avoid warnings
|
|
#endif
|
|
};
|
|
|
|
// This is a helper class that provides a way to get a reference to
|
|
// an object. The get() function will never be called at run-time
|
|
// (nothing in this file will) so this seemingly very bad function
|
|
// is really quite innocent. The name of this class needs to be
|
|
// changed.
|
|
template <class T>
|
|
class static_object
|
|
{
|
|
public:
|
|
static T& get()
|
|
{
|
|
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
|
|
return *reinterpret_cast<T*>(0);
|
|
#else
|
|
static char d[sizeof(T)];
|
|
return *reinterpret_cast<T*>(d);
|
|
#endif
|
|
}
|
|
};
|
|
|
|
template <class Base = null_archetype<> >
|
|
class default_constructible_archetype : public Base {
|
|
public:
|
|
default_constructible_archetype()
|
|
: Base(static_object<detail::dummy_constructor>::get()) { }
|
|
default_constructible_archetype(detail::dummy_constructor x) : Base(x) { }
|
|
};
|
|
|
|
template <class Base = null_archetype<> >
|
|
class assignable_archetype : public Base {
|
|
assignable_archetype() { }
|
|
assignable_archetype(const assignable_archetype&) { }
|
|
public:
|
|
assignable_archetype& operator=(const assignable_archetype&) {
|
|
return *this;
|
|
}
|
|
assignable_archetype(detail::dummy_constructor x) : Base(x) { }
|
|
};
|
|
|
|
template <class Base = null_archetype<> >
|
|
class copy_constructible_archetype : public Base {
|
|
public:
|
|
copy_constructible_archetype()
|
|
: Base(static_object<detail::dummy_constructor>::get()) { }
|
|
copy_constructible_archetype(const copy_constructible_archetype&)
|
|
: Base(static_object<detail::dummy_constructor>::get()) { }
|
|
copy_constructible_archetype(detail::dummy_constructor x) : Base(x) { }
|
|
};
|
|
|
|
template <class Base = null_archetype<> >
|
|
class sgi_assignable_archetype : public Base {
|
|
public:
|
|
sgi_assignable_archetype(const sgi_assignable_archetype&)
|
|
: Base(static_object<detail::dummy_constructor>::get()) { }
|
|
sgi_assignable_archetype& operator=(const sgi_assignable_archetype&) {
|
|
return *this;
|
|
}
|
|
sgi_assignable_archetype(const detail::dummy_constructor& x) : Base(x) { }
|
|
};
|
|
|
|
struct default_archetype_base {
|
|
default_archetype_base(detail::dummy_constructor) { }
|
|
};
|
|
|
|
// Careful, don't use same type for T and Base. That results in the
|
|
// conversion operator being invalid. Since T is often
|
|
// null_archetype, can't use null_archetype for Base.
|
|
template <class T, class Base = default_archetype_base>
|
|
class convertible_to_archetype : public Base {
|
|
private:
|
|
convertible_to_archetype() { }
|
|
convertible_to_archetype(const convertible_to_archetype& ) { }
|
|
convertible_to_archetype& operator=(const convertible_to_archetype&)
|
|
{ return *this; }
|
|
public:
|
|
convertible_to_archetype(detail::dummy_constructor x) : Base(x) { }
|
|
operator const T&() const { return static_object<T>::get(); }
|
|
};
|
|
|
|
template <class T, class Base = default_archetype_base>
|
|
class convertible_from_archetype : public Base {
|
|
private:
|
|
convertible_from_archetype() { }
|
|
convertible_from_archetype(const convertible_from_archetype& ) { }
|
|
convertible_from_archetype& operator=(const convertible_from_archetype&)
|
|
{ return *this; }
|
|
public:
|
|
convertible_from_archetype(detail::dummy_constructor x) : Base(x) { }
|
|
convertible_from_archetype(const T&) { }
|
|
convertible_from_archetype& operator=(const T&)
|
|
{ return *this; }
|
|
};
|
|
|
|
class boolean_archetype {
|
|
public:
|
|
boolean_archetype(const boolean_archetype&) { }
|
|
operator bool() const { return true; }
|
|
boolean_archetype(detail::dummy_constructor) { }
|
|
private:
|
|
boolean_archetype() { }
|
|
boolean_archetype& operator=(const boolean_archetype&) { return *this; }
|
|
};
|
|
|
|
template <class Base = null_archetype<> >
|
|
class equality_comparable_archetype : public Base {
|
|
public:
|
|
equality_comparable_archetype(detail::dummy_constructor x) : Base(x) { }
|
|
};
|
|
template <class Base>
|
|
boolean_archetype
|
|
operator==(const equality_comparable_archetype<Base>&,
|
|
const equality_comparable_archetype<Base>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
template <class Base>
|
|
boolean_archetype
|
|
operator!=(const equality_comparable_archetype<Base>&,
|
|
const equality_comparable_archetype<Base>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
|
|
|
|
template <class Base = null_archetype<> >
|
|
class equality_comparable2_first_archetype : public Base {
|
|
public:
|
|
equality_comparable2_first_archetype(detail::dummy_constructor x)
|
|
: Base(x) { }
|
|
};
|
|
template <class Base = null_archetype<> >
|
|
class equality_comparable2_second_archetype : public Base {
|
|
public:
|
|
equality_comparable2_second_archetype(detail::dummy_constructor x)
|
|
: Base(x) { }
|
|
};
|
|
template <class Base1, class Base2>
|
|
boolean_archetype
|
|
operator==(const equality_comparable2_first_archetype<Base1>&,
|
|
const equality_comparable2_second_archetype<Base2>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
template <class Base1, class Base2>
|
|
boolean_archetype
|
|
operator!=(const equality_comparable2_first_archetype<Base1>&,
|
|
const equality_comparable2_second_archetype<Base2>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
|
|
|
|
template <class Base = null_archetype<> >
|
|
class less_than_comparable_archetype : public Base {
|
|
public:
|
|
less_than_comparable_archetype(detail::dummy_constructor x) : Base(x) { }
|
|
};
|
|
template <class Base>
|
|
boolean_archetype
|
|
operator<(const less_than_comparable_archetype<Base>&,
|
|
const less_than_comparable_archetype<Base>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
|
|
|
|
|
|
template <class Base = null_archetype<> >
|
|
class comparable_archetype : public Base {
|
|
public:
|
|
comparable_archetype(detail::dummy_constructor x) : Base(x) { }
|
|
};
|
|
template <class Base>
|
|
boolean_archetype
|
|
operator<(const comparable_archetype<Base>&,
|
|
const comparable_archetype<Base>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
template <class Base>
|
|
boolean_archetype
|
|
operator<=(const comparable_archetype<Base>&,
|
|
const comparable_archetype<Base>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
template <class Base>
|
|
boolean_archetype
|
|
operator>(const comparable_archetype<Base>&,
|
|
const comparable_archetype<Base>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
template <class Base>
|
|
boolean_archetype
|
|
operator>=(const comparable_archetype<Base>&,
|
|
const comparable_archetype<Base>&)
|
|
{
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get());
|
|
}
|
|
|
|
|
|
// The purpose of the optags is so that one can specify
|
|
// exactly which types the operator< is defined between.
|
|
// This is useful for allowing the operations:
|
|
//
|
|
// A a; B b;
|
|
// a < b
|
|
// b < a
|
|
//
|
|
// without also allowing the combinations:
|
|
//
|
|
// a < a
|
|
// b < b
|
|
//
|
|
struct optag1 { };
|
|
struct optag2 { };
|
|
struct optag3 { };
|
|
|
|
#define BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(OP, NAME) \
|
|
template <class Base = null_archetype<>, class Tag = optag1 > \
|
|
class NAME##_first_archetype : public Base { \
|
|
public: \
|
|
NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \
|
|
}; \
|
|
\
|
|
template <class Base = null_archetype<>, class Tag = optag1 > \
|
|
class NAME##_second_archetype : public Base { \
|
|
public: \
|
|
NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \
|
|
}; \
|
|
\
|
|
template <class BaseFirst, class BaseSecond, class Tag> \
|
|
boolean_archetype \
|
|
operator OP (const NAME##_first_archetype<BaseFirst, Tag>&, \
|
|
const NAME##_second_archetype<BaseSecond, Tag>&) \
|
|
{ \
|
|
return boolean_archetype(static_object<detail::dummy_constructor>::get()); \
|
|
}
|
|
|
|
BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(==, equal_op)
|
|
BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(!=, not_equal_op)
|
|
BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<, less_than_op)
|
|
BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<=, less_equal_op)
|
|
BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>, greater_than_op)
|
|
BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>=, greater_equal_op)
|
|
|
|
#define BOOST_DEFINE_OPERATOR_ARCHETYPE(OP, NAME) \
|
|
template <class Base = null_archetype<> > \
|
|
class NAME##_archetype : public Base { \
|
|
public: \
|
|
NAME##_archetype(detail::dummy_constructor x) : Base(x) { } \
|
|
NAME##_archetype(const NAME##_archetype&) \
|
|
: Base(static_object<detail::dummy_constructor>::get()) { } \
|
|
NAME##_archetype& operator=(const NAME##_archetype&) { return *this; } \
|
|
}; \
|
|
template <class Base> \
|
|
NAME##_archetype<Base> \
|
|
operator OP (const NAME##_archetype<Base>&,\
|
|
const NAME##_archetype<Base>&) \
|
|
{ \
|
|
return \
|
|
NAME##_archetype<Base>(static_object<detail::dummy_constructor>::get()); \
|
|
}
|
|
|
|
BOOST_DEFINE_OPERATOR_ARCHETYPE(+, addable)
|
|
BOOST_DEFINE_OPERATOR_ARCHETYPE(-, subtractable)
|
|
BOOST_DEFINE_OPERATOR_ARCHETYPE(*, multipliable)
|
|
BOOST_DEFINE_OPERATOR_ARCHETYPE(/, dividable)
|
|
BOOST_DEFINE_OPERATOR_ARCHETYPE(%, modable)
|
|
|
|
// As is, these are useless because of the return type.
|
|
// Need to invent a better way...
|
|
#define BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(OP, NAME) \
|
|
template <class Return, class Base = null_archetype<> > \
|
|
class NAME##_first_archetype : public Base { \
|
|
public: \
|
|
NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \
|
|
}; \
|
|
\
|
|
template <class Return, class Base = null_archetype<> > \
|
|
class NAME##_second_archetype : public Base { \
|
|
public: \
|
|
NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \
|
|
}; \
|
|
\
|
|
template <class Return, class BaseFirst, class BaseSecond> \
|
|
Return \
|
|
operator OP (const NAME##_first_archetype<Return, BaseFirst>&, \
|
|
const NAME##_second_archetype<Return, BaseSecond>&) \
|
|
{ \
|
|
return Return(static_object<detail::dummy_constructor>::get()); \
|
|
}
|
|
|
|
BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(+, plus_op)
|
|
BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(*, time_op)
|
|
BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(/, divide_op)
|
|
BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(-, subtract_op)
|
|
BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(%, mod_op)
|
|
|
|
//===========================================================================
|
|
// Function Object Archetype Classes
|
|
|
|
template <class Return>
|
|
class generator_archetype {
|
|
public:
|
|
const Return& operator()() {
|
|
return static_object<Return>::get();
|
|
}
|
|
};
|
|
|
|
class void_generator_archetype {
|
|
public:
|
|
void operator()() { }
|
|
};
|
|
|
|
template <class Arg, class Return>
|
|
class unary_function_archetype {
|
|
private:
|
|
unary_function_archetype() { }
|
|
public:
|
|
unary_function_archetype(detail::dummy_constructor) { }
|
|
const Return& operator()(const Arg&) const {
|
|
return static_object<Return>::get();
|
|
}
|
|
};
|
|
|
|
template <class Arg1, class Arg2, class Return>
|
|
class binary_function_archetype {
|
|
private:
|
|
binary_function_archetype() { }
|
|
public:
|
|
binary_function_archetype(detail::dummy_constructor) { }
|
|
const Return& operator()(const Arg1&, const Arg2&) const {
|
|
return static_object<Return>::get();
|
|
}
|
|
};
|
|
|
|
template <class Arg>
|
|
class unary_predicate_archetype {
|
|
typedef boolean_archetype Return;
|
|
unary_predicate_archetype() { }
|
|
public:
|
|
unary_predicate_archetype(detail::dummy_constructor) { }
|
|
const Return& operator()(const Arg&) const {
|
|
return static_object<Return>::get();
|
|
}
|
|
};
|
|
|
|
template <class Arg1, class Arg2, class Base = null_archetype<> >
|
|
class binary_predicate_archetype {
|
|
typedef boolean_archetype Return;
|
|
binary_predicate_archetype() { }
|
|
public:
|
|
binary_predicate_archetype(detail::dummy_constructor) { }
|
|
const Return& operator()(const Arg1&, const Arg2&) const {
|
|
return static_object<Return>::get();
|
|
}
|
|
};
|
|
|
|
//===========================================================================
|
|
// Iterator Archetype Classes
|
|
|
|
template <class T, int I = 0>
|
|
class input_iterator_archetype
|
|
{
|
|
private:
|
|
typedef input_iterator_archetype self;
|
|
public:
|
|
typedef std::input_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
struct reference {
|
|
operator const value_type&() const { return static_object<T>::get(); }
|
|
};
|
|
typedef const T* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return reference(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
};
|
|
|
|
template <class T>
|
|
class input_iterator_archetype_no_proxy
|
|
{
|
|
private:
|
|
typedef input_iterator_archetype_no_proxy self;
|
|
public:
|
|
typedef std::input_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef const T& reference;
|
|
typedef const T* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return static_object<T>::get(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
};
|
|
|
|
template <class T>
|
|
struct output_proxy {
|
|
output_proxy& operator=(const T&) { return *this; }
|
|
};
|
|
|
|
template <class T>
|
|
class output_iterator_archetype
|
|
{
|
|
public:
|
|
typedef output_iterator_archetype self;
|
|
public:
|
|
typedef std::output_iterator_tag iterator_category;
|
|
typedef output_proxy<T> value_type;
|
|
typedef output_proxy<T> reference;
|
|
typedef void pointer;
|
|
typedef void difference_type;
|
|
output_iterator_archetype(detail::dummy_constructor) { }
|
|
output_iterator_archetype(const self&) { }
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return output_proxy<T>(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
private:
|
|
output_iterator_archetype() { }
|
|
};
|
|
|
|
template <class T>
|
|
class input_output_iterator_archetype
|
|
{
|
|
private:
|
|
typedef input_output_iterator_archetype self;
|
|
struct in_out_tag : public std::input_iterator_tag, public std::output_iterator_tag { };
|
|
public:
|
|
typedef in_out_tag iterator_category;
|
|
typedef T value_type;
|
|
struct reference {
|
|
reference& operator=(const T&) { return *this; }
|
|
operator value_type() { return static_object<T>::get(); }
|
|
};
|
|
typedef const T* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
input_output_iterator_archetype() { }
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return reference(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
};
|
|
|
|
template <class T>
|
|
class forward_iterator_archetype
|
|
{
|
|
public:
|
|
typedef forward_iterator_archetype self;
|
|
public:
|
|
typedef std::forward_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef const T& reference;
|
|
typedef T const* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
forward_iterator_archetype() { }
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return static_object<T>::get(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
};
|
|
|
|
template <class T>
|
|
class mutable_forward_iterator_archetype
|
|
{
|
|
public:
|
|
typedef mutable_forward_iterator_archetype self;
|
|
public:
|
|
typedef std::forward_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef T& reference;
|
|
typedef T* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
mutable_forward_iterator_archetype() { }
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return static_object<T>::get(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
};
|
|
|
|
template <class T>
|
|
class bidirectional_iterator_archetype
|
|
{
|
|
public:
|
|
typedef bidirectional_iterator_archetype self;
|
|
public:
|
|
typedef std::bidirectional_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef const T& reference;
|
|
typedef T* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
bidirectional_iterator_archetype() { }
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return static_object<T>::get(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
self& operator--() { return *this; }
|
|
self operator--(int) { return *this; }
|
|
};
|
|
|
|
template <class T>
|
|
class mutable_bidirectional_iterator_archetype
|
|
{
|
|
public:
|
|
typedef mutable_bidirectional_iterator_archetype self;
|
|
public:
|
|
typedef std::bidirectional_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef T& reference;
|
|
typedef T* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
mutable_bidirectional_iterator_archetype() { }
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return static_object<T>::get(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
self& operator--() { return *this; }
|
|
self operator--(int) { return *this; }
|
|
};
|
|
|
|
template <class T>
|
|
class random_access_iterator_archetype
|
|
{
|
|
public:
|
|
typedef random_access_iterator_archetype self;
|
|
public:
|
|
typedef std::random_access_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef const T& reference;
|
|
typedef T* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
random_access_iterator_archetype() { }
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return static_object<T>::get(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
self& operator--() { return *this; }
|
|
self operator--(int) { return *this; }
|
|
reference operator[](difference_type) const
|
|
{ return static_object<T>::get(); }
|
|
self& operator+=(difference_type) { return *this; }
|
|
self& operator-=(difference_type) { return *this; }
|
|
difference_type operator-(const self&) const
|
|
{ return difference_type(); }
|
|
self operator+(difference_type) const { return *this; }
|
|
self operator-(difference_type) const { return *this; }
|
|
bool operator<(const self&) const { return true; }
|
|
bool operator<=(const self&) const { return true; }
|
|
bool operator>(const self&) const { return true; }
|
|
bool operator>=(const self&) const { return true; }
|
|
};
|
|
template <class T>
|
|
random_access_iterator_archetype<T>
|
|
operator+(typename random_access_iterator_archetype<T>::difference_type,
|
|
const random_access_iterator_archetype<T>& x)
|
|
{ return x; }
|
|
|
|
|
|
template <class T>
|
|
class mutable_random_access_iterator_archetype
|
|
{
|
|
public:
|
|
typedef mutable_random_access_iterator_archetype self;
|
|
public:
|
|
typedef std::random_access_iterator_tag iterator_category;
|
|
typedef T value_type;
|
|
typedef T& reference;
|
|
typedef T* pointer;
|
|
typedef std::ptrdiff_t difference_type;
|
|
mutable_random_access_iterator_archetype() { }
|
|
self& operator=(const self&) { return *this; }
|
|
bool operator==(const self&) const { return true; }
|
|
bool operator!=(const self&) const { return true; }
|
|
reference operator*() const { return static_object<T>::get(); }
|
|
self& operator++() { return *this; }
|
|
self operator++(int) { return *this; }
|
|
self& operator--() { return *this; }
|
|
self operator--(int) { return *this; }
|
|
reference operator[](difference_type) const
|
|
{ return static_object<T>::get(); }
|
|
self& operator+=(difference_type) { return *this; }
|
|
self& operator-=(difference_type) { return *this; }
|
|
difference_type operator-(const self&) const
|
|
{ return difference_type(); }
|
|
self operator+(difference_type) const { return *this; }
|
|
self operator-(difference_type) const { return *this; }
|
|
bool operator<(const self&) const { return true; }
|
|
bool operator<=(const self&) const { return true; }
|
|
bool operator>(const self&) const { return true; }
|
|
bool operator>=(const self&) const { return true; }
|
|
};
|
|
template <class T>
|
|
mutable_random_access_iterator_archetype<T>
|
|
operator+
|
|
(typename mutable_random_access_iterator_archetype<T>::difference_type,
|
|
const mutable_random_access_iterator_archetype<T>& x)
|
|
{ return x; }
|
|
|
|
} // namespace boost
|
|
|
|
#endif // BOOST_CONCEPT_ARCHETYPES_H
|