http://www.ousob.com --- Legacy Redefined OuSob - File: /wwwroot/clipx/usr/include/boost/concept_archetype.hpp

// // (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