commit 6e3ebc8dac7accec9b2ff2f68f655fd86b15ef69 Author: Jeremy Siek Date: Mon Sep 18 08:24:47 2000 +0000 pending stuff from Boost Graph Library [SVN r7704] diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..3e84d7c --- /dev/null +++ b/.gitattributes @@ -0,0 +1,96 @@ +* text=auto !eol svneol=native#text/plain +*.gitattributes text svneol=native#text/plain + +# Scriptish formats +*.bat text svneol=native#text/plain +*.bsh text svneol=native#text/x-beanshell +*.cgi text svneol=native#text/plain +*.cmd text svneol=native#text/plain +*.js text svneol=native#text/javascript +*.php text svneol=native#text/x-php +*.pl text svneol=native#text/x-perl +*.pm text svneol=native#text/x-perl +*.py text svneol=native#text/x-python +*.sh eol=lf svneol=LF#text/x-sh +configure eol=lf svneol=LF#text/x-sh + +# Image formats +*.bmp binary svneol=unset#image/bmp +*.gif binary svneol=unset#image/gif +*.ico binary svneol=unset#image/ico +*.jpeg binary svneol=unset#image/jpeg +*.jpg binary svneol=unset#image/jpeg +*.png binary svneol=unset#image/png +*.tif binary svneol=unset#image/tiff +*.tiff binary svneol=unset#image/tiff +*.svg text svneol=native#image/svg%2Bxml + +# Data formats +*.pdf binary svneol=unset#application/pdf +*.avi binary svneol=unset#video/avi +*.doc binary svneol=unset#application/msword +*.dsp text svneol=crlf#text/plain +*.dsw text svneol=crlf#text/plain +*.eps binary svneol=unset#application/postscript +*.gz binary svneol=unset#application/gzip +*.mov binary svneol=unset#video/quicktime +*.mp3 binary svneol=unset#audio/mpeg +*.ppt binary svneol=unset#application/vnd.ms-powerpoint +*.ps binary svneol=unset#application/postscript +*.psd binary svneol=unset#application/photoshop +*.rdf binary svneol=unset#text/rdf +*.rss text svneol=unset#text/xml +*.rtf binary svneol=unset#text/rtf +*.sln text svneol=native#text/plain +*.swf binary svneol=unset#application/x-shockwave-flash +*.tgz binary svneol=unset#application/gzip +*.vcproj text svneol=native#text/xml +*.vcxproj text svneol=native#text/xml +*.vsprops text svneol=native#text/xml +*.wav binary svneol=unset#audio/wav +*.xls binary svneol=unset#application/vnd.ms-excel +*.zip binary svneol=unset#application/zip + +# Text formats +.htaccess text svneol=native#text/plain +*.bbk text svneol=native#text/xml +*.cmake text svneol=native#text/plain +*.css text svneol=native#text/css +*.dtd text svneol=native#text/xml +*.htm text svneol=native#text/html +*.html text svneol=native#text/html +*.ini text svneol=native#text/plain +*.log text svneol=native#text/plain +*.mak text svneol=native#text/plain +*.qbk text svneol=native#text/plain +*.rst text svneol=native#text/plain +*.sql text svneol=native#text/x-sql +*.txt text svneol=native#text/plain +*.xhtml text svneol=native#text/xhtml%2Bxml +*.xml text svneol=native#text/xml +*.xsd text svneol=native#text/xml +*.xsl text svneol=native#text/xml +*.xslt text svneol=native#text/xml +*.xul text svneol=native#text/xul +*.yml text svneol=native#text/plain +boost-no-inspect text svneol=native#text/plain +CHANGES text svneol=native#text/plain +COPYING text svneol=native#text/plain +INSTALL text svneol=native#text/plain +Jamfile text svneol=native#text/plain +Jamroot text svneol=native#text/plain +Jamfile.v2 text svneol=native#text/plain +Jamrules text svneol=native#text/plain +Makefile* text svneol=native#text/plain +README text svneol=native#text/plain +TODO text svneol=native#text/plain + +# Code formats +*.c text svneol=native#text/plain +*.cpp text svneol=native#text/plain +*.h text svneol=native#text/plain +*.hpp text svneol=native#text/plain +*.ipp text svneol=native#text/plain +*.tpp text svneol=native#text/plain +*.jam text svneol=native#text/plain +*.java text svneol=native#text/plain diff --git a/include/boost/pending/concept_checks.hpp b/include/boost/pending/concept_checks.hpp new file mode 100644 index 0000000..c6aea29 --- /dev/null +++ b/include/boost/pending/concept_checks.hpp @@ -0,0 +1,868 @@ +// +//======================================================================= +// Copyright 1997, 1998, 1999, 2000 University of Notre Dame. +// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek +// +// This file is part of the Generic Graph Component Library +// +// You should have received a copy of the License Agreement for the +// Generic Graph Component Library along with the software; see the +// file LICENSE. If not, contact Office of Research, University of Notre +// Dame, Notre Dame, IN 46556. +// +// Permission to modify the code and to distribute modified code is +// granted, provided the text of this NOTICE is retained, a notice that +// the code was modified is included with the above COPYRIGHT NOTICE and +// with the COPYRIGHT NOTICE in the LICENSE file, and that the LICENSE +// file is distributed with the modified code. +// +// LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. +// By way of example, but not limitation, Licensor MAKES NO +// REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY +// PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS +// OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS +// OR OTHER RIGHTS. +//======================================================================= +// +#ifndef BOOST_GRAPH_DETAIL_CONCEPT_CHECKS_HPP +#define BOOST_GRAPH_DETAIL_CONCEPT_CHECKS_HPP + +#include +#include +#include + +#if defined(__GNUC__) || defined(__KCC) +#define _FPTR & +#else +#define _FPTR +#endif + +#define REQUIRE(__type_var, __concept) \ +do { \ + void (__concept##_concept <__type_var>::*__x)() = \ + _FPTR __concept##_concept <__type_var>::constraints; \ + __x = __x; } while (0) + +#define REQUIRE2(__type_var1, __type_var2, __concept) \ +do { \ + void (__concept##_concept <__type_var1, __type_var2>::*__x)() = \ + _FPTR __concept##_concept <__type_var1, __type_var2>::constraints; \ + __x = __x; } while (0) + +#define REQUIRE3(__type_var1, __type_var2, __type_var3,__concept) \ +do { \ + void (__concept##_concept <__type_var1, __type_var2, __type_var3>::*__x)() = \ + _FPTR __concept##_concept <__type_var1, __type_var2, __type_var3>::constraints; \ + __x = __x; } while (0) + +#define REQUIRE4(__type_var1, __type_var2, __type_var3,__type_var4,__concept) \ +do { \ + void (__concept##_concept <__type_var1,__type_var2,__type_var3,__type_var4>::*__x)() = \ + _FPTR __concept##_concept <__type_var1, __type_var2, __type_var3, __type_var4>::constraints;\ + __x = __x; } while (0) + + +#define CLASS_REQUIRES(__tv, __concept) \ + typedef void (__concept##_concept <__tv>::* __func##__tv##__concept)(); \ + template <__func##__tv##__concept _Tp1> \ + struct __dummy_struct_##__tv##__concept { }; \ + static __dummy_struct_##__tv##__concept< \ + _FPTR __concept##_concept <__tv>::constraints> \ + __dummy_ptr_##__tv##__concept + +#define CLASS_REQUIRES2(__tv1, __tv2, __concept) \ + typedef void (__concept##_concept <__tv1,__tv2>::* __func##__tv1##__tv2##__concept)(); \ + template <__func##__tv1##__tv2##__concept _Tp1> \ + struct __dummy_struct_##__tv1##__tv2##__concept { }; \ + static __dummy_struct_##__tv1##__tv2##__concept< \ + _FPTR __concept##_concept <__tv1,__tv2>::constraints> \ + __dummy_ptr_##__tv1##__tv2##__concept + +#define CLASS_REQUIRES3(__tv1, __tv2, __tv3, __concept) \ + typedef void (__concept##_concept <__tv1,__tv2,__tv3>::* __func##__tv1##__tv2##__tv3##__concept)(); \ + template <__func##__tv1##__tv2##__tv3##__concept _Tp1> \ + struct __dummy_struct_##__tv1##__tv2##__tv3##__concept { }; \ + static __dummy_struct_##__tv1##__tv2##__tv3##__concept< \ + _FPTR __concept##_concept <__tv1,__tv2,__tv3>::constraints> \ + __dummy_ptr_##__tv1##__tv2##__tv3##__concept + +#define CLASS_REQUIRES4(__tv1, __tv2, __tv3, __tv4, __concept) \ + typedef void (__concept##_concept <__tv1,__tv2,__tv3,__tv4>::* __func##__tv1##__tv2##__tv3##__tv4##__concept)(); \ + template <__func##__tv1##__tv2##__tv3##__tv4##__concept _Tp1> \ + struct __dummy_struct_##__tv1##__tv2##__tv3##__tv4##__concept { }; \ + static __dummy_struct_##__tv1##__tv2##__tv3##__tv4##__concept< \ + _FPTR __concept##_concept <__tv1,__tv2,__tv3,__tv4>::constraints> \ + __dummy_ptr_##__tv1##__tv2##__tv3##__tv4##__concept + + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +template +struct require_same_type { }; + +template +struct require_same_type { typedef T type; }; +#else +template +struct require_same_type { typedef T type; }; +#endif + +#define REQUIRE_SAME_TYPE(X,Y) \ + typedef typename require_same_type::type X##_same_##Y + +#define CLASS_REQUIRES_SAME_TYPE(X,Y) \ + typedef typename require_same_type::type X##_same_##Y + +template void ignore_unused_variable_warning(const T&) { } + + template + struct Integer_concept { + void constraints() { +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + error_the_type_must_be_an_integer_type(); +#endif + } + }; +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template <> struct Integer_concept { void constraints() {} }; + template <> struct Integer_concept { void constraints() {} }; + template <> struct Integer_concept { void constraints() {} }; + template <> struct Integer_concept { void constraints() {} }; + template <> struct Integer_concept { void constraints() {} }; + template <> struct Integer_concept { void constraints() {} }; + // etc. +#endif + + //=========================================================================== + // Basic Concepts + + template + struct Convertible_concept + { + void constraints() { + Y y = x; + ignore_unused_variable_warning(y); + } + X x; + }; + + template + struct Assignable_concept + { + void constraints() { +#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL + a = a; // require assignment operator +#endif + TT c(a); // require copy constructor + const_constraints(a); + ignore_unused_variable_warning(c); + } + void const_constraints(const TT& b) { +#if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL + a = b; // const required for argument to assignment +#endif + TT c(b); // const required for argument to copy constructor + ignore_unused_variable_warning(c); + } + TT a; + }; + + template + struct DefaultConstructible_concept + { + void constraints() { + TT a; // require default constructor + ignore_unused_variable_warning(a); + } + }; + + template + struct CopyConstructible_concept + { + void constraints() { + T a(b); // require copy constructor + T* ptr = &a; // require address of operator + const_constraints(a); + } + void const_constraints(const T& a) { + T c(a); // require const copy constructor + const T* ptr = &a; // require const address of operator + } + T b; + }; + + template + struct EqualityComparable_concept + { + void constraints() { + r = a == b; // require equality operator + r = a != b; // require inequality operator + } + TT a, b; + bool r; + }; + + template + struct LessThanComparable_concept + { + void constraints() { + // require comparison operators + r = a < b || a > b || a <= b || a >= b; + } + TT a, b; + bool r; + }; + + //=========================================================================== + // Iterator Concepts + + template + struct TrivialIterator_concept + { + void constraints() { + REQUIRE(TT, Assignable); + REQUIRE(TT, DefaultConstructible); + REQUIRE(TT, EqualityComparable); +#ifndef BOOST_NO_STD_ITERATOR_TRAITS + typedef typename std::iterator_traits::value_type V; +#endif + (void)*i; // require dereference operator + } + TT i; + }; + + template + struct Mutable_TrivialIterator_concept + { + void constraints() { + REQUIRE(TT, TrivialIterator); + *i = *j; // require dereference and assignment + } + TT i, j; + }; + + template + struct InputIterator_concept + { + void constraints() { + REQUIRE(TT, TrivialIterator); + // require iterator_traits typedef's +#ifndef BOOST_NO_STD_ITERATOR_TRAITS + typedef typename std::iterator_traits::difference_type D; + typedef typename std::iterator_traits::reference R; + typedef typename std::iterator_traits::pointer P; + typedef typename std::iterator_traits::iterator_category C; + REQUIRE2(typename std::iterator_traits::iterator_category, + std::input_iterator_tag, Convertible); +#endif + ++i; // require preincrement operator + i++; // require postincrement operator + } + TT i; + }; + + template + struct OutputIterator_concept + { + void constraints() { + REQUIRE(TT, Assignable); + ++i; // require preincrement operator + i++; // require postincrement operator + *i++ = t; // require postincrement and assignment + } + TT i, j; + ValueT t; + }; + + template + struct ForwardIterator_concept + { + void constraints() { + REQUIRE(TT, InputIterator); +#ifndef BOOST_NO_STD_ITERATOR_TRAITS + REQUIRE2(typename std::iterator_traits::iterator_category, + std::forward_iterator_tag, Convertible); + typedef typename std::iterator_traits::reference reference; + reference r = *i; + ignore_unused_variable_warning(r); +#endif + } + TT i; + }; + + template + struct Mutable_ForwardIterator_concept + { + void constraints() { + REQUIRE(TT, ForwardIterator); + *i++ = *i; // require postincrement and assignment + } + TT i; + }; + + template + struct BidirectionalIterator_concept + { + void constraints() { + REQUIRE(TT, ForwardIterator); +#ifndef BOOST_NO_STD_ITERATOR_TRAITS + REQUIRE2(typename std::iterator_traits::iterator_category, + std::bidirectional_iterator_tag, Convertible); +#endif + --i; // require predecrement operator + i--; // require postdecrement operator + } + TT i; + }; + + template + struct Mutable_BidirectionalIterator_concept + { + void constraints() { + REQUIRE(TT, BidirectionalIterator); + REQUIRE(TT, Mutable_ForwardIterator); + *i-- = *i; // require postdecrement and assignment + } + TT i; + }; + + + template + struct RandomAccessIterator_concept + { + void constraints() { + REQUIRE(TT, BidirectionalIterator); + REQUIRE(TT, LessThanComparable); +#ifndef BOOST_NO_STD_ITERATOR_TRAITS + REQUIRE2(typename std::iterator_traits::iterator_category, + std::random_access_iterator_tag, Convertible); + typedef typename std::iterator_traits::reference R; +#endif + + i += n; // require assignment addition operator + i = i + n; i = n + i; // require addition with difference type + i -= n; // require assignment subtraction operator + i = i - n; // require subtraction with difference type + n = i - j; // require difference operator + (void)i[n]; // require element access operator + } + TT a, b; + TT i, j; +#ifndef BOOST_NO_STD_ITERATOR_TRAITS + typename std::iterator_traits::difference_type n; +#else + std::ptrdiff_t n; +#endif + }; + + template + struct Mutable_RandomAccessIterator_concept + { + void constraints() { + REQUIRE(TT, RandomAccessIterator); + REQUIRE(TT, Mutable_BidirectionalIterator); + i[n] = *i; // require element access and assignment + } + TT i; +#ifndef BOOST_NO_STD_ITERATOR_TRAITS + typename std::iterator_traits::difference_type n; +#else + std::ptrdiff_t n; +#endif + }; + + //=========================================================================== + // Function Object Concepts + + template + struct Generator_concept + { + void constraints() { + __r = __f(); // require operator() member function + } + _Func __f; + _Ret __r; + }; + + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct Generator_concept<_Func,void> + { + void constraints() { + __f(); // require operator() member function + } + _Func __f; + }; +#endif + + template + struct UnaryFunction_concept + { + void constraints() { + __r = __f(__arg); // require operator() + } + _Func __f; + _Arg __arg; + _Ret __r; + }; + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct UnaryFunction_concept<_Func,void,_Arg> { + void constraints() { + __f(__arg); // require operator() + } + _Func __f; + }; +#endif + + template + struct BinaryFunction_concept + { + void constraints() { + __r = __f(__first, __second); // require operator() + } + _Func __f; + _First __first; + _Second __second; + _Ret __r; + }; + +#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + template + struct BinaryFunction_concept<_Func,void,_First,_Second> + { + void constraints() { + __f(__first, __second); // require operator() + } + _Func __f; + _First __first; + _Second __second; + }; +#endif + + template + struct UnaryPredicate_concept + { + void constraints() { + __r = __f(__arg); // require operator() returning bool + } + _Func __f; + _Arg __arg; + bool __r; + }; + + template + struct BinaryPredicate_concept + { + void constraints() { + __r = __f(__a, __b); // require operator() returning bool + } + _Func __f; + _First __a; + _Second __b; + bool __r; + }; + + // use this when functor is used inside a container class like std::set + template + struct Const_BinaryPredicate_concept { + void constraints() { + REQUIRE3(_Func,_First,_Second, BinaryPredicate); + bool __r = __f(__a,__b); // operator() must be a const member function + } + _Func __f; + _First __a; + _Second __b; + }; + +#define __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(_OP,_NAME) \ + template \ + struct _NAME##_concept { \ + void constraints() { (void)_constraints(); } \ + _Ret _constraints() { \ + return __a _OP __b; \ + } \ + _First __a; \ + _Second __b; \ + } + + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(==, _OP_EQUAL); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(!=, _OP_NOT_EQUAL); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(<, _OP_LESS_THAN); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(<=, _OP_LESS_EQUAL); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(>, _OP_GREATER_THAN); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(>=, _OP_GREATER_EQUAL); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, _OP_PLUS); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, _OP_TIMES); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, _OP_DIVIDE); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, _OP_SUBTRACT); + __STL_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, _OP_MOD); + + //=========================================================================== + // Container Concepts + + template + struct Container_concept + { + typedef typename Container::value_type value_type; + typedef typename Container::difference_type difference_type; + typedef typename Container::size_type size_type; + typedef typename Container::const_reference const_reference; + typedef typename Container::const_pointer const_pointer; + typedef typename Container::const_iterator const_iterator; + + void constraints() { + REQUIRE(const_iterator, InputIterator); + REQUIRE(Container, Assignable); + const Container c; + i = c.begin(); + i = c.end(); + n = c.size(); + n = c.max_size(); + b = c.empty(); + } + bool b; + const_iterator i; + size_type n; + }; + + template + struct Mutable_Container_concept + { + typedef typename Container::value_type value_type; + typedef typename Container::reference reference; + typedef typename Container::iterator iterator; + typedef typename Container::pointer pointer; + + void constraints() { + REQUIRE(Container, Container); + REQUIRE(value_type, Assignable); + REQUIRE(iterator, InputIterator); + + i = c.begin(); + i = c.end(); + c.swap(c2); + } + iterator i; + Container c, c2; + }; + + template + struct ForwardContainer_concept + { + void constraints() { + REQUIRE(ForwardContainer, Container); + typedef typename ForwardContainer::const_iterator const_iterator; + REQUIRE(const_iterator, ForwardIterator); + } + }; + + template + struct Mutable_ForwardContainer_concept + { + void constraints() { + REQUIRE(ForwardContainer, ForwardContainer); + REQUIRE(ForwardContainer, Mutable_Container); + typedef typename ForwardContainer::iterator iterator; + REQUIRE(iterator, Mutable_ForwardIterator); + } + }; + + template + struct ReversibleContainer_concept + { + typedef typename ReversibleContainer::const_iterator const_iterator; + typedef typename ReversibleContainer::const_reverse_iterator + const_reverse_iterator; + + void constraints() { + REQUIRE(ReversibleContainer, ForwardContainer); + REQUIRE(const_iterator, BidirectionalIterator); + REQUIRE(const_reverse_iterator, BidirectionalIterator); + + const ReversibleContainer c; + const_reverse_iterator i = c.rbegin(); + i = c.rend(); + } + }; + + template + struct Mutable_ReversibleContainer_concept + { + typedef typename ReversibleContainer::iterator iterator; + typedef typename ReversibleContainer::reverse_iterator reverse_iterator; + + void constraints() { + REQUIRE(ReversibleContainer, ReversibleContainer); + REQUIRE(ReversibleContainer, Mutable_ForwardContainer); + REQUIRE(iterator, Mutable_BidirectionalIterator); + REQUIRE(reverse_iterator, Mutable_BidirectionalIterator); + + reverse_iterator i = c.rbegin(); + i = c.rend(); + } + ReversibleContainer c; + }; + + template + struct RandomAccessContainer_concept + { + typedef typename RandomAccessContainer::size_type size_type; + typedef typename RandomAccessContainer::const_reference const_reference; + typedef typename RandomAccessContainer::const_iterator const_iterator; + typedef typename RandomAccessContainer::const_reverse_iterator + const_reverse_iterator; + + void constraints() { + REQUIRE(RandomAccessContainer, ReversibleContainer); + REQUIRE(const_iterator, RandomAccessIterator); + REQUIRE(const_reverse_iterator, RandomAccessIterator); + + const RandomAccessContainer c; + const_reference r = c[n]; + ignore_unused_variable_warning(r); + } + size_type n; + }; + + template + struct Mutable_RandomAccessContainer_concept + { + typedef typename RandomAccessContainer::size_type size_type; + typedef typename RandomAccessContainer::reference reference; + typedef typename RandomAccessContainer::iterator iterator; + typedef typename RandomAccessContainer::reverse_iterator reverse_iterator; + + void constraints() { + REQUIRE(RandomAccessContainer, RandomAccessContainer); + REQUIRE(RandomAccessContainer, Mutable_ReversibleContainer); + REQUIRE(iterator, Mutable_RandomAccessIterator); + REQUIRE(reverse_iterator, Mutable_RandomAccessIterator); + + reference r = c[i]; + ignore_unused_variable_warning(r); + } + size_type i; + RandomAccessContainer c; + }; + + // A Sequence is inherently mutable + template + struct Sequence_concept + { + // Matt put's DefaultConstructible here, the C++ standard + // places it in Container + // CLASS_REQUIRES(Sequence, DefaultConstructible); + + typedef typename Sequence::reference reference; + typedef typename Sequence::const_reference const_reference; + + void constraints() { + REQUIRE(Sequence, Mutable_ForwardContainer); + REQUIRE(Sequence, DefaultConstructible); + + Sequence + c(n), + c2(n, t), + c3(first, last); + + c.insert(p, t); + c.insert(p, n, t); + c.insert(p, first, last); + + c.erase(p); + c.erase(p, q); + + reference r = c.front(); + + ignore_unused_variable_warning(c); + ignore_unused_variable_warning(c2); + ignore_unused_variable_warning(c3); + ignore_unused_variable_warning(r); + const_constraints(c); + } + void const_constraints(const Sequence& c) { + const_reference r = c.front(); + ignore_unused_variable_warning(r); + } + typename Sequence::value_type t; + typename Sequence::size_type n; + typename Sequence::value_type* first, *last; + typename Sequence::iterator p, q; + }; + + template + struct FrontInsertionSequence_concept + { + void constraints() { + REQUIRE(FrontInsertionSequence, Sequence); + + c.push_front(t); + c.pop_front(); + } + FrontInsertionSequence c; + typename FrontInsertionSequence::value_type t; + }; + + template + struct BackInsertionSequence_concept + { + typedef typename BackInsertionSequence::reference reference; + typedef typename BackInsertionSequence::const_reference const_reference; + + void constraints() { + REQUIRE(BackInsertionSequence, Sequence); + + c.push_back(t); + c.pop_back(); + reference r = c.back(); + ignore_unused_variable_warning(r); + } + void const_constraints(const BackInsertionSequence& c) { + const_reference r = c.back(); + ignore_unused_variable_warning(r); + }; + BackInsertionSequence c; + typename BackInsertionSequence::value_type t; + }; + + template + struct AssociativeContainer_concept + { + void constraints() { + REQUIRE(AssociativeContainer, ForwardContainer); + REQUIRE(AssociativeContainer, DefaultConstructible); + + i = c.find(k); + r = c.equal_range(k); + c.erase(k); + c.erase(i); + c.erase(r.first, r.second); + const_constraints(c); + } + void const_constraints(const AssociativeContainer& c) { + ci = c.find(k); + n = c.count(k); + cr = c.equal_range(k); + } + typedef typename AssociativeContainer::iterator iterator; + typedef typename AssociativeContainer::const_iterator const_iterator; + + AssociativeContainer c; + iterator i; + std::pair r; + const_iterator ci; + std::pair cr; + typename AssociativeContainer::key_type k; + typename AssociativeContainer::size_type n; + }; + + template + struct UniqueAssociativeContainer_concept + { + void constraints() { + REQUIRE(UniqueAssociativeContainer, AssociativeContainer); + + UniqueAssociativeContainer c(first, last); + + pos_flag = c.insert(t); + c.insert(first, last); + + ignore_unused_variable_warning(c); + } + std::pair pos_flag; + typename UniqueAssociativeContainer::value_type t; + typename UniqueAssociativeContainer::value_type* first, *last; + }; + + template + struct MultipleAssociativeContainer_concept + { + void constraints() { + REQUIRE(MultipleAssociativeContainer, AssociativeContainer); + + MultipleAssociativeContainer c(first, last); + + pos = c.insert(t); + c.insert(first, last); + + ignore_unused_variable_warning(c); + ignore_unused_variable_warning(pos); + } + typename MultipleAssociativeContainer::iterator pos; + typename MultipleAssociativeContainer::value_type t; + typename MultipleAssociativeContainer::value_type* first, *last; + }; + + template + struct SimpleAssociativeContainer_concept + { + void constraints() { + REQUIRE(SimpleAssociativeContainer, AssociativeContainer); + typedef typename SimpleAssociativeContainer::key_type key_type; + typedef typename SimpleAssociativeContainer::value_type value_type; + CLASS_REQUIRES_SAME_TYPE(key_type, value_type); + } + }; + + template + struct PairAssociativeContainer_concept + { + void constraints() { + REQUIRE(SimpleAssociativeContainer, AssociativeContainer); + typedef typename SimpleAssociativeContainer::key_type key_type; + typedef typename SimpleAssociativeContainer::value_type value_type; + typedef typename SimpleAssociativeContainer::mapped_type mapped_type; + typedef std::pair required_value_type; + CLASS_REQUIRES_SAME_TYPE(value_type, required_value_type); + } + }; + + template + struct SortedAssociativeContainer_concept + { + void constraints() { + REQUIRE(SortedAssociativeContainer, AssociativeContainer); + REQUIRE(SortedAssociativeContainer, ReversibleContainer); + + SortedAssociativeContainer + c(kc), + c2(first, last), + c3(first, last, kc); + + p = c.upper_bound(k); + p = c.lower_bound(k); + r = c.equal_range(k); + + c.insert(p, t); + + ignore_unused_variable_warning(c); + ignore_unused_variable_warning(c2); + ignore_unused_variable_warning(c3); + } + void const_constraints(const SortedAssociativeContainer& c) { + kc = c.key_comp(); + vc = c.value_comp(); + + cp = c.upper_bound(k); + cp = c.lower_bound(k); + cr = c.equal_range(k); + } + typename SortedAssociativeContainer::key_compare kc; + typename SortedAssociativeContainer::value_compare vc; + typename SortedAssociativeContainer::value_type t; + typename SortedAssociativeContainer::key_type k; + typedef typename SortedAssociativeContainer::iterator iterator; + typedef typename SortedAssociativeContainer::const_iterator const_iterator; + iterator p; + const_iterator cp; + std::pair r; + std::pair cr; + typename SortedAssociativeContainer::value_type* first, *last; + }; + + // HashedAssociativeContainer + +#endif /* BOOST_GRAPH_DETAIL_CONCEPT_CHECKS_H */ + diff --git a/include/boost/pending/concept_skeletons.hpp b/include/boost/pending/concept_skeletons.hpp new file mode 100644 index 0000000..5fcc491 --- /dev/null +++ b/include/boost/pending/concept_skeletons.hpp @@ -0,0 +1,153 @@ +// $COPYRIGHT + +#ifndef BOOST_CONCEPT_SKELETONS_HPP +#define BOOST_CONCEPT_SKELETONS_HPP + +#include + +namespace boost { + template + struct input_proxy { + operator const T&() { return t; } + static T t; + }; + template + class trivial_iterator_skeleton + { + typedef trivial_iterator_skeleton self; + public: +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + typedef T value_type; + typedef void reference; + typedef void pointer; + typedef void difference_type; + typedef void iterator_category; +#endif + trivial_iterator_skeleton() { } + self& operator=(const self&) { return *this; } + bool operator==(const self&) const { return true; } + bool operator!=(const self&) const { return true; } + input_proxy operator*() { return input_proxy(); } + }; +} + +#ifndef BOOST_O_TEMPLATE_PARTIAL_SPECIALIZATION +namespace std { + template + struct iterator_traits< boost::trivial_iterator_skeleton > + { + typedef T value_type; + }; +} +#endif + +namespace boost { + template + struct input_output_proxy { + input_output_proxy& operator=(const T&) { return *this; } + operator T() { return t; } + T t; + }; + template + class mutable_trivial_iterator_skeleton + { + typedef mutable_trivial_iterator_skeleton self; + public: +#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION + typedef T value_type; + typedef void reference; + typedef void pointer; + typedef void difference_type; + typedef void iterator_category; +#endif + mutable_trivial_iterator_skeleton() { } + self& operator=(const self&) { return *this; } + bool operator==(const self&) const { return true; } + bool operator!=(const self&) const { return true; } + input_output_proxy operator*() { return input_output_proxy(); } + T x; + }; +} + +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +namespace std { + template + struct iterator_traits< boost::mutable_trivial_iterator_skeleton > + { + typedef T value_type; + }; +} +#endif + +namespace boost { + + template + class input_iterator_skeleton + { + public: + typedef input_iterator_skeleton self; + public: + typedef std::input_iterator_tag iterator_category; + typedef T value_type; + typedef const T& reference; + typedef const T* pointer; + typedef void difference_type; + input_iterator_skeleton() { } + self& operator=(const self&) { return *this; } + bool operator==(const self&) const { return true; } + bool operator!=(const self&) const { return true; } + reference operator*() { return x; } + self& operator++() { return *this; } + self operator++(int) { return *this; } + T x; + }; + + struct output_proxy { + template + output_proxy& operator=(const T&) { return *this; } + }; + + class output_iterator_skeleton + { + public: + typedef output_iterator_skeleton self; + public: + typedef std::output_iterator_tag iterator_category; + typedef output_proxy value_type; + typedef output_proxy reference; + typedef void pointer; + typedef void difference_type; + output_iterator_skeleton() { } + self& operator=(const self&) { return *this; } + bool operator==(const self&) const { return true; } + bool operator!=(const self&) const { return true; } + reference operator*() { return output_proxy(); } + self& operator++() { return *this; } + self operator++(int) { return *this; } + }; + + template + class forward_iterator_skeleton + { + public: + typedef forward_iterator_skeleton self; + public: + typedef std::forward_iterator_tag iterator_category; + typedef T value_type; + typedef T& reference; + typedef T* pointer; + typedef void difference_type; + forward_iterator_skeleton() { } + self& operator=(const self&) { return *this; } + bool operator==(const self&) const { return true; } + bool operator!=(const self&) const { return true; } + reference operator*() { return x; } + self& operator++() { return *this; } + self operator++(int) { return *this; } + T x; + }; + + +} // namespace boost + +#endif // BOOST_CONCEPT_SKELETONS_H