diff options
Diffstat (limited to 'src/third_party/boost-1.56.0/boost/concept_archetype.hpp')
-rw-r--r-- | src/third_party/boost-1.56.0/boost/concept_archetype.hpp | 669 |
1 files changed, 0 insertions, 669 deletions
diff --git a/src/third_party/boost-1.56.0/boost/concept_archetype.hpp b/src/third_party/boost-1.56.0/boost/concept_archetype.hpp deleted file mode 100644 index f21c817384f..00000000000 --- a/src/third_party/boost-1.56.0/boost/concept_archetype.hpp +++ /dev/null @@ -1,669 +0,0 @@ -// -// (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 |