forked from boostorg/concept_check
Move tests into subdirectory
This commit is contained in:
1 parent
a2e63dad4c
commit
6284402a2d
16 files changed
No files matched your search
@@ -0,0 +1,25 @@
|
||||
# Copyright David Abrahams, Jeremy Siek, Vladimir Prus
|
||||
# 2006. 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)
|
||||
import testing ;
|
||||
|
||||
test-suite concept_check
|
||||
: [ run stl_concept_covering.cpp ]
|
||||
[ run stl_concept_check.cpp ]
|
||||
[ run concept_check_test.cpp ]
|
||||
[ run class_concept_check_test.cpp ]
|
||||
[ compile-fail concept_check_fail_expected.cpp ]
|
||||
[ compile-fail class_concept_fail_expected.cpp ]
|
||||
|
||||
[ run where.cpp ]
|
||||
[ compile-fail where_fail.cpp ]
|
||||
[ compile-fail usage_fail.cpp ]
|
||||
|
||||
# Backward compatibility tests
|
||||
[ run old_concept_pass.cpp ]
|
||||
[ compile-fail function_requires_fail.cpp ]
|
||||
[ compile-fail old_concept_function_fail.cpp ]
|
||||
[ compile-fail old_concept_class_fail.cpp ]
|
||||
;
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
// (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)
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
|
||||
/*
|
||||
|
||||
This file verifies that the BOOST_CLASS_REQUIRE macro of the Boost
|
||||
Concept Checking Library does not cause errors when it is not suppose
|
||||
to.
|
||||
|
||||
*/
|
||||
|
||||
struct foo { bool operator()(int) { return true; } };
|
||||
struct bar { bool operator()(int, char) { return true; } };
|
||||
|
||||
class class_requires_test
|
||||
{
|
||||
BOOST_CONCEPT_ASSERT((boost::EqualityComparable<int>));
|
||||
typedef int* int_ptr; typedef const int* const_int_ptr;
|
||||
BOOST_CONCEPT_ASSERT((boost::EqualOp<int_ptr,const_int_ptr>));
|
||||
BOOST_CONCEPT_ASSERT((boost::UnaryFunction<foo,bool,int>));
|
||||
BOOST_CONCEPT_ASSERT((boost::BinaryFunction<bar,bool,int,char>));
|
||||
};
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
class_requires_test x;
|
||||
boost::ignore_unused_variable_warning(x);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
// (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
|
||||
// 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)
|
||||
//
|
||||
// Change Log:
|
||||
// 20 Jan 2001 - Added warning suppression (David Abrahams)
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
|
||||
/*
|
||||
|
||||
This file verifies that class_requires of the Boost Concept Checking
|
||||
Library catches errors when it is supposed to.
|
||||
|
||||
*/
|
||||
|
||||
struct foo { };
|
||||
|
||||
template <class T>
|
||||
class class_requires_test
|
||||
{
|
||||
BOOST_CONCEPT_ASSERT((boost::EqualityComparable<foo>));
|
||||
};
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
class_requires_test<int> x;
|
||||
(void)x; // suppress unused variable warning
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
// (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
|
||||
// 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)
|
||||
|
||||
#ifdef NDEBUG
|
||||
# undef NDEBUG
|
||||
#endif
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
|
||||
/*
|
||||
|
||||
This file verifies that BOOST_CONCEPT_ASSERT catches errors in
|
||||
function context.
|
||||
|
||||
*/
|
||||
|
||||
struct foo { };
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
BOOST_CONCEPT_ASSERT((boost::EqualityComparable<foo>));
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
// (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)
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
#include <boost/concept_archetype.hpp>
|
||||
|
||||
/*
|
||||
|
||||
This file verifies that function_requires() of the Boost Concept
|
||||
Checking Library does not cause errors when it is not suppose to
|
||||
and verifies that the concept archetypes meet the requirements of
|
||||
their matching concepts.
|
||||
|
||||
*/
|
||||
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
//===========================================================================
|
||||
// Basic Concepts
|
||||
{
|
||||
typedef default_constructible_archetype<> foo;
|
||||
function_requires< DefaultConstructible<foo> >();
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> foo;
|
||||
function_requires< Assignable<foo> >();
|
||||
}
|
||||
{
|
||||
typedef copy_constructible_archetype<> foo;
|
||||
function_requires< CopyConstructible<foo> >();
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> foo;
|
||||
function_requires< SGIAssignable<foo> >();
|
||||
}
|
||||
{
|
||||
typedef copy_constructible_archetype<> foo;
|
||||
typedef convertible_to_archetype<foo> convertible_to_foo;
|
||||
function_requires< Convertible<convertible_to_foo, foo> >();
|
||||
}
|
||||
{
|
||||
function_requires< Convertible<boolean_archetype, bool> >();
|
||||
}
|
||||
{
|
||||
typedef equality_comparable_archetype<> foo;
|
||||
function_requires< EqualityComparable<foo> >();
|
||||
}
|
||||
{
|
||||
typedef less_than_comparable_archetype<> foo;
|
||||
function_requires< LessThanComparable<foo> >();
|
||||
}
|
||||
{
|
||||
typedef comparable_archetype<> foo;
|
||||
function_requires< Comparable<foo> >();
|
||||
}
|
||||
{
|
||||
typedef equal_op_first_archetype<> First;
|
||||
typedef equal_op_second_archetype<> Second;
|
||||
function_requires< EqualOp<First, Second> >();
|
||||
}
|
||||
{
|
||||
typedef not_equal_op_first_archetype<> First;
|
||||
typedef not_equal_op_second_archetype<> Second;
|
||||
function_requires< NotEqualOp<First, Second> >();
|
||||
}
|
||||
{
|
||||
typedef less_than_op_first_archetype<> First;
|
||||
typedef less_than_op_second_archetype<> Second;
|
||||
function_requires< LessThanOp<First, Second> >();
|
||||
}
|
||||
{
|
||||
typedef less_equal_op_first_archetype<> First;
|
||||
typedef less_equal_op_second_archetype<> Second;
|
||||
function_requires< LessEqualOp<First, Second> >();
|
||||
}
|
||||
{
|
||||
typedef greater_than_op_first_archetype<> First;
|
||||
typedef greater_than_op_second_archetype<> Second;
|
||||
function_requires< GreaterThanOp<First, Second> >();
|
||||
}
|
||||
{
|
||||
typedef greater_equal_op_first_archetype<> First;
|
||||
typedef greater_equal_op_second_archetype<> Second;
|
||||
function_requires< GreaterEqualOp<First, Second> >();
|
||||
}
|
||||
|
||||
{
|
||||
typedef copy_constructible_archetype<> Return;
|
||||
typedef plus_op_first_archetype<Return> First;
|
||||
typedef plus_op_second_archetype<Return> Second;
|
||||
function_requires< PlusOp<Return, First, Second> >();
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
// Function Object Concepts
|
||||
|
||||
{
|
||||
typedef generator_archetype<null_archetype<> > foo;
|
||||
function_requires< Generator<foo, null_archetype<> > >();
|
||||
}
|
||||
#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||
{
|
||||
function_requires< Generator< void_generator_archetype, void > >();
|
||||
}
|
||||
#endif
|
||||
{
|
||||
typedef unary_function_archetype<int, int> F;
|
||||
function_requires< UnaryFunction<F, int, int> >();
|
||||
}
|
||||
{
|
||||
typedef binary_function_archetype<int, int, int> F;
|
||||
function_requires< BinaryFunction<F, int, int, int> >();
|
||||
}
|
||||
{
|
||||
typedef unary_predicate_archetype<int> F;
|
||||
function_requires< UnaryPredicate<F, int> >();
|
||||
}
|
||||
{
|
||||
typedef binary_predicate_archetype<int, int> F;
|
||||
function_requires< BinaryPredicate<F, int, int> >();
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
// Iterator Concepts
|
||||
{
|
||||
typedef input_iterator_archetype<null_archetype<> > Iter;
|
||||
function_requires< InputIterator<Iter> >();
|
||||
}
|
||||
{
|
||||
typedef output_iterator_archetype<int> Iter;
|
||||
function_requires< OutputIterator<Iter, int> >();
|
||||
}
|
||||
{
|
||||
typedef input_output_iterator_archetype<int> Iter;
|
||||
function_requires< InputIterator<Iter> >();
|
||||
function_requires< OutputIterator<Iter, int> >();
|
||||
}
|
||||
{
|
||||
typedef forward_iterator_archetype<null_archetype<> > Iter;
|
||||
function_requires< ForwardIterator<Iter> >();
|
||||
}
|
||||
{
|
||||
typedef mutable_forward_iterator_archetype<assignable_archetype<> > Iter;
|
||||
function_requires< Mutable_ForwardIterator<Iter> >();
|
||||
}
|
||||
{
|
||||
typedef bidirectional_iterator_archetype<null_archetype<> > Iter;
|
||||
function_requires< BidirectionalIterator<Iter> >();
|
||||
}
|
||||
{
|
||||
typedef mutable_bidirectional_iterator_archetype<assignable_archetype<> >
|
||||
Iter;
|
||||
function_requires< Mutable_BidirectionalIterator<Iter> >();
|
||||
}
|
||||
{
|
||||
typedef random_access_iterator_archetype<null_archetype<> > Iter;
|
||||
function_requires< RandomAccessIterator<Iter> >();
|
||||
}
|
||||
{
|
||||
typedef mutable_random_access_iterator_archetype<assignable_archetype<> >
|
||||
Iter;
|
||||
function_requires< Mutable_RandomAccessIterator<Iter> >();
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
// Container Concepts
|
||||
|
||||
// UNDER CONSTRUCTION
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
// Copyright David Abrahams 2006. 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)
|
||||
#ifndef BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
|
||||
# define BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
|
||||
|
||||
# include <boost/detail/iterator.hpp>
|
||||
# include <boost/concept/requires.hpp>
|
||||
# include <boost/concept_check.hpp>
|
||||
|
||||
namespace fake
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
template<typename RanIter>
|
||||
BOOST_CONCEPT_REQUIRES(
|
||||
((Mutable_RandomAccessIterator<RanIter>))
|
||||
((LessThanComparable<typename Mutable_RandomAccessIterator<RanIter>::value_type>))
|
||||
|
||||
, (void))
|
||||
sort(RanIter,RanIter)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif // BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
|
||||
@@ -0,0 +1,26 @@
|
||||
// (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)
|
||||
|
||||
#ifdef NDEBUG
|
||||
# undef NDEBUG
|
||||
#endif
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
|
||||
/*
|
||||
|
||||
This file verifies that function_requires() of the Boost Concept
|
||||
Checking Library catches errors when it is suppose to.
|
||||
|
||||
*/
|
||||
|
||||
struct foo { };
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
boost::function_requires< boost::EqualityComparable<foo> >();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
// (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
|
||||
// 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)
|
||||
//
|
||||
// Change Log:
|
||||
// 20 Jan 2001 - Added warning suppression (David Abrahams)
|
||||
|
||||
#include "old_concepts.hpp"
|
||||
|
||||
// This file verifies that concepts written the old way still catch
|
||||
// errors in class context. This is not expected to work on compilers
|
||||
// without SFINAE support.
|
||||
|
||||
struct foo { };
|
||||
|
||||
class class_requires_test
|
||||
{
|
||||
BOOST_CLASS_REQUIRE(foo, old, EqualityComparableConcept);
|
||||
};
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
class_requires_test x;
|
||||
(void)x; // suppress unused variable warning
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
// (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)
|
||||
|
||||
#ifdef NDEBUG
|
||||
# undef NDEBUG
|
||||
#endif
|
||||
|
||||
#include "old_concepts.hpp"
|
||||
|
||||
// This file verifies that concepts written the old way still catch
|
||||
// errors in function context. This is not expected to work on
|
||||
// compilers without SFINAE support.
|
||||
|
||||
struct foo { };
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
boost::function_requires< old::EqualityComparableConcept<foo> >();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
// (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
|
||||
// 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)
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
#include "old_concepts.hpp"
|
||||
|
||||
// This test verifies that use of the old-style concept checking
|
||||
// classes still compiles (but not that it detects constraint
|
||||
// violations). We check them with the old-style macros just for
|
||||
// completeness, since those macros stranslate into
|
||||
// BOOST_CONCEPT_ASSERTs.
|
||||
|
||||
struct foo { bool operator()(int) { return true; } };
|
||||
struct bar { bool operator()(int, char) { return true; } };
|
||||
|
||||
|
||||
class class_requires_test
|
||||
{
|
||||
BOOST_CLASS_REQUIRE(int, old, EqualityComparableConcept);
|
||||
typedef int* int_ptr; typedef const int* const_int_ptr;
|
||||
BOOST_CLASS_REQUIRE2(int_ptr, const_int_ptr, old, EqualOpConcept);
|
||||
BOOST_CLASS_REQUIRE3(foo, bool, int, old, UnaryFunctionConcept);
|
||||
BOOST_CLASS_REQUIRE4(bar, bool, int, char, old, BinaryFunctionConcept);
|
||||
};
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
class_requires_test x;
|
||||
boost::ignore_unused_variable_warning(x);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
// Copyright Jeremy Siek, David Abrahams 2000-2006. 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)
|
||||
#ifndef BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP
|
||||
# define BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
|
||||
namespace old
|
||||
{
|
||||
template <class TT>
|
||||
void require_boolean_expr(const TT& t) {
|
||||
bool x = t;
|
||||
boost::ignore_unused_variable_warning(x);
|
||||
}
|
||||
|
||||
template <class TT>
|
||||
struct EqualityComparableConcept
|
||||
{
|
||||
void constraints() {
|
||||
boost::require_boolean_expr(a == b);
|
||||
boost::require_boolean_expr(a != b);
|
||||
}
|
||||
TT a, b;
|
||||
};
|
||||
|
||||
template <class Func, class Return, class Arg>
|
||||
struct UnaryFunctionConcept
|
||||
{
|
||||
// required in case any of our template args are const-qualified:
|
||||
UnaryFunctionConcept();
|
||||
|
||||
void constraints() {
|
||||
r = f(arg); // require operator()
|
||||
}
|
||||
Func f;
|
||||
Arg arg;
|
||||
Return r;
|
||||
};
|
||||
|
||||
template <class Func, class Return, class First, class Second>
|
||||
struct BinaryFunctionConcept
|
||||
{
|
||||
void constraints() {
|
||||
r = f(first, second); // require operator()
|
||||
}
|
||||
Func f;
|
||||
First first;
|
||||
Second second;
|
||||
Return r;
|
||||
};
|
||||
|
||||
#define DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \
|
||||
template <class First, class Second> \
|
||||
struct NAME { \
|
||||
void constraints() { (void)constraints_(); } \
|
||||
bool constraints_() { \
|
||||
return a OP b; \
|
||||
} \
|
||||
First a; \
|
||||
Second b; \
|
||||
}
|
||||
|
||||
DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOpConcept);
|
||||
}
|
||||
|
||||
#endif // BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP
|
||||
@@ -0,0 +1,93 @@
|
||||
// (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)
|
||||
|
||||
//
|
||||
// This file checks to see if various standard container
|
||||
// implementations live up to requirements specified in the C++
|
||||
// standard. As many implementations do not live to the requirements,
|
||||
// it is not uncommon for this file to fail to compile. The
|
||||
// BOOST_HIDE_EXPECTED_ERRORS macro is provided here if you want to
|
||||
// see as much of this file compile as possible.
|
||||
//
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
|
||||
#include <iterator>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <deque>
|
||||
#if 0
|
||||
#include <slist>
|
||||
#endif
|
||||
|
||||
// Define this macro if you want to hide the expected error, that is,
|
||||
// error in the various C++ standard library implementations.
|
||||
//
|
||||
//#define BOOST_HIDE_EXPECTED_ERRORS
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
#if defined(_ITERATOR_) && defined(BOOST_HIDE_EXPECTED_ERRORS)
|
||||
// VC++ STL implementation is not standard conformant and
|
||||
// fails to pass these concept checks
|
||||
#else
|
||||
typedef std::vector<int> Vector;
|
||||
typedef std::deque<int> Deque;
|
||||
typedef std::list<int> List;
|
||||
|
||||
// VC++ missing pointer and const_pointer typedefs
|
||||
function_requires< Mutable_RandomAccessContainer<Vector> >();
|
||||
function_requires< BackInsertionSequence<Vector> >();
|
||||
|
||||
#if !(defined(__GNUC__) && defined(BOOST_HIDE_EXPECTED_ERRORS))
|
||||
#if !((defined(__sgi) || (defined(__DECCXX) && defined(_RWSTD_VER) && _RWSTD_VER <= 0x0203)) \
|
||||
&& defined(BOOST_HIDE_EXPECTED_ERRORS))
|
||||
// old deque iterator missing n + iter operation
|
||||
function_requires< Mutable_RandomAccessContainer<Deque> >();
|
||||
#endif
|
||||
// warnings about signed and unsigned in old deque version
|
||||
function_requires< FrontInsertionSequence<Deque> >();
|
||||
function_requires< BackInsertionSequence<Deque> >();
|
||||
#endif
|
||||
|
||||
// VC++ missing pointer and const_pointer typedefs
|
||||
function_requires< Mutable_ReversibleContainer<List> >();
|
||||
function_requires< FrontInsertionSequence<List> >();
|
||||
function_requires< BackInsertionSequence<List> >();
|
||||
|
||||
#if 0
|
||||
typedef BOOST_STD_EXTENSION_NAMESPACE::slist<int> SList;
|
||||
function_requires< FrontInsertionSequence<SList> >();
|
||||
#endif
|
||||
|
||||
typedef std::set<int> Set;
|
||||
typedef std::multiset<int> MultiSet;
|
||||
typedef std::map<int,int> Map;
|
||||
typedef std::multimap<int,int> MultiMap;
|
||||
|
||||
function_requires< SortedAssociativeContainer<Set> >();
|
||||
function_requires< SimpleAssociativeContainer<Set> >();
|
||||
function_requires< UniqueAssociativeContainer<Set> >();
|
||||
|
||||
function_requires< SortedAssociativeContainer<MultiSet> >();
|
||||
function_requires< SimpleAssociativeContainer<MultiSet> >();
|
||||
function_requires< MultipleAssociativeContainer<MultiSet> >();
|
||||
|
||||
function_requires< SortedAssociativeContainer<Map> >();
|
||||
function_requires< UniqueAssociativeContainer<Map> >();
|
||||
function_requires< PairAssociativeContainer<Map> >();
|
||||
|
||||
function_requires< SortedAssociativeContainer<MultiMap> >();
|
||||
function_requires< MultipleAssociativeContainer<MultiMap> >();
|
||||
function_requires< PairAssociativeContainer<MultiMap> >();
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,916 @@
|
||||
// (C) Copyright Jeremy Siek 2000-2002.
|
||||
// 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)
|
||||
|
||||
// This file doesn't work on other compilers.
|
||||
#if defined(__GNUC__) || defined(__KCC)
|
||||
|
||||
#include <algorithm>
|
||||
#include <numeric>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/concept_check.hpp>
|
||||
#include <boost/concept_archetype.hpp>
|
||||
|
||||
/*
|
||||
|
||||
This file uses the archetype classes to find out which concepts
|
||||
actually *cover* the STL algorithms true requirements. The
|
||||
archetypes/concepts chosen do not necessarily match the C++ standard
|
||||
or the SGI STL documentation, but instead were chosen based on the
|
||||
minimal concepts that current STL implementations require, which in
|
||||
many cases is less stringent than the standard. In some places there
|
||||
was significant differences in the implementations' requirements and
|
||||
in those places macros were used to select different requirements,
|
||||
the purpose being to document what the requirements of various
|
||||
implementations are. It is an open issue as to whether the C++
|
||||
standard should be changed to reflect these weaker requirements.
|
||||
|
||||
*/
|
||||
|
||||
boost::detail::dummy_constructor dummy_cons;
|
||||
|
||||
// This is a special concept needed for std::swap_ranges.
|
||||
// It is mutually convertible, and also SGIAssignable
|
||||
template <class T>
|
||||
class mutually_convertible_archetype
|
||||
{
|
||||
private:
|
||||
mutually_convertible_archetype() { }
|
||||
public:
|
||||
mutually_convertible_archetype(const mutually_convertible_archetype&) { }
|
||||
mutually_convertible_archetype&
|
||||
operator=(const mutually_convertible_archetype&)
|
||||
{ return *this; }
|
||||
mutually_convertible_archetype(boost::detail::dummy_constructor) { }
|
||||
|
||||
template <class U>
|
||||
mutually_convertible_archetype&
|
||||
operator=(const mutually_convertible_archetype<U>&)
|
||||
{ return *this; }
|
||||
|
||||
};
|
||||
|
||||
|
||||
// for std::accumulate
|
||||
namespace accum
|
||||
{
|
||||
typedef boost::sgi_assignable_archetype<> Ret;
|
||||
struct T {
|
||||
T(const Ret&) { }
|
||||
T(boost::detail::dummy_constructor x) { }
|
||||
};
|
||||
typedef boost::null_archetype<> Tin;
|
||||
Ret operator+(const T&, const Tin&) {
|
||||
return Ret(dummy_cons);
|
||||
}
|
||||
}
|
||||
|
||||
// for std::inner_product
|
||||
namespace inner_prod
|
||||
{
|
||||
typedef boost::sgi_assignable_archetype<> RetAdd;
|
||||
typedef boost::sgi_assignable_archetype<> RetMult;
|
||||
struct T {
|
||||
T(const RetAdd&) { }
|
||||
T(boost::detail::dummy_constructor x) { }
|
||||
};
|
||||
typedef boost::null_archetype<int> Tin1;
|
||||
typedef boost::null_archetype<char> Tin2;
|
||||
}
|
||||
|
||||
namespace boost { // so Koenig lookup will find
|
||||
|
||||
inner_prod::RetMult
|
||||
operator*(const inner_prod::Tin1&, const inner_prod::Tin2&) {
|
||||
return inner_prod::RetMult(dummy_cons);
|
||||
}
|
||||
inner_prod::RetAdd
|
||||
operator+(const inner_prod::T&,
|
||||
const inner_prod::RetMult&) {
|
||||
return inner_prod::RetAdd(dummy_cons);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// for std::partial_sum and adj_diff
|
||||
namespace part_sum
|
||||
{
|
||||
class T {
|
||||
public:
|
||||
typedef boost::sgi_assignable_archetype<> Ret;
|
||||
T(const Ret&) { }
|
||||
T(boost::detail::dummy_constructor x) { }
|
||||
private:
|
||||
T() { }
|
||||
};
|
||||
T::Ret operator+(const T&, const T&) {
|
||||
return T::Ret(dummy_cons);
|
||||
}
|
||||
T::Ret operator-(const T&, const T&) {
|
||||
return T::Ret(dummy_cons);
|
||||
}
|
||||
}
|
||||
|
||||
// for std::power
|
||||
|
||||
namespace power_stuff {
|
||||
struct monoid_archetype {
|
||||
monoid_archetype(boost::detail::dummy_constructor x) { }
|
||||
};
|
||||
|
||||
boost::multipliable_archetype<monoid_archetype>
|
||||
identity_element
|
||||
(std::multiplies< boost::multipliable_archetype<monoid_archetype> >)
|
||||
{
|
||||
return boost::multipliable_archetype<monoid_archetype>(dummy_cons);
|
||||
}
|
||||
}
|
||||
|
||||
struct tag1 { };
|
||||
struct tag2 { };
|
||||
|
||||
|
||||
int
|
||||
main()
|
||||
{
|
||||
using namespace boost;
|
||||
|
||||
//===========================================================================
|
||||
// Non-mutating Algorithms
|
||||
{
|
||||
input_iterator_archetype< null_archetype<> > in;
|
||||
unary_function_archetype< null_archetype<> , null_archetype<> >
|
||||
f(dummy_cons);
|
||||
std::for_each(in, in, f);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
input_iterator_archetype< Left > in;
|
||||
equality_comparable2_second_archetype<> value(dummy_cons);
|
||||
in = std::find(in, in, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> T;
|
||||
input_iterator_archetype<T> in;
|
||||
unary_predicate_archetype<T> pred(dummy_cons);
|
||||
in = std::find_if(in, in, pred);
|
||||
}
|
||||
{
|
||||
forward_iterator_archetype< equality_comparable_archetype<> > fo;
|
||||
fo = std::adjacent_find(fo, fo);
|
||||
}
|
||||
{
|
||||
forward_iterator_archetype<
|
||||
convertible_to_archetype< null_archetype<> > > fo;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
fo = std::adjacent_find(fo, fo, pred);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
typedef equal_op_first_archetype<> Left;
|
||||
input_iterator_archetype<Left> in;
|
||||
typedef equal_op_second_archetype<> Right;
|
||||
forward_iterator_archetype<Right> fo;
|
||||
in = std::find_first_of(in, in, fo, fo);
|
||||
}
|
||||
{
|
||||
typedef equal_op_first_archetype<> Left;
|
||||
typedef input_iterator_archetype<Left> InIter;
|
||||
InIter in;
|
||||
function_requires< InputIterator<InIter> >();
|
||||
equal_op_second_archetype<> value(dummy_cons);
|
||||
std::iterator_traits<InIter>::difference_type
|
||||
n = std::count(in, in, value);
|
||||
ignore_unused_variable_warning(n);
|
||||
}
|
||||
{
|
||||
typedef input_iterator_archetype< null_archetype<> > InIter;
|
||||
InIter in;
|
||||
unary_predicate_archetype<null_archetype<> > pred(dummy_cons);
|
||||
std::iterator_traits<InIter>::difference_type
|
||||
n = std::count_if(in, in, pred);
|
||||
ignore_unused_variable_warning(n);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
typedef equal_op_first_archetype<> Left;
|
||||
typedef input_iterator_archetype<Left> InIter1;
|
||||
InIter1 in1;
|
||||
typedef equal_op_second_archetype<> Right;
|
||||
typedef input_iterator_archetype<Right> InIter2;
|
||||
InIter2 in2;
|
||||
std::pair<InIter1, InIter2> p = std::mismatch(in1, in1, in2);
|
||||
ignore_unused_variable_warning(p);
|
||||
}
|
||||
{
|
||||
typedef input_iterator_archetype<null_archetype<> > InIter;
|
||||
InIter in1, in2;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
std::pair<InIter, InIter> p = std::mismatch(in1, in1, in2, pred);
|
||||
ignore_unused_variable_warning(p);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
input_iterator_archetype<Left> in1;
|
||||
typedef equality_comparable2_second_archetype<> Right;
|
||||
input_iterator_archetype<Right> in2;
|
||||
bool b = std::equal(in1, in1, in2);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
input_iterator_archetype< null_archetype<> >
|
||||
in1, in2;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
bool b = std::equal(in1, in1, in2, pred);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
forward_iterator_archetype<Left> fo1;
|
||||
typedef equality_comparable2_second_archetype<> Right;
|
||||
forward_iterator_archetype<Right> fo2;
|
||||
fo1 = std::search(fo1, fo1, fo2, fo2);
|
||||
}
|
||||
{
|
||||
typedef equality_comparable2_first_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > Left;
|
||||
forward_iterator_archetype<Left> fo1;
|
||||
typedef equality_comparable2_second_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > Right;
|
||||
forward_iterator_archetype<Right> fo2;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
fo1 = std::search(fo1, fo1, fo2, fo2, pred);
|
||||
}
|
||||
{
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
forward_iterator_archetype<Left> fo;
|
||||
equality_comparable2_second_archetype<> value(dummy_cons);
|
||||
int n = 1;
|
||||
fo = std::search_n(fo, fo, n, value);
|
||||
}
|
||||
{
|
||||
forward_iterator_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > fo;
|
||||
convertible_to_archetype<null_archetype<> > value(dummy_cons);
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
int n = 1;
|
||||
fo = std::search_n(fo, fo, n, value, pred);
|
||||
}
|
||||
{
|
||||
typedef equality_comparable2_first_archetype<> Left;
|
||||
forward_iterator_archetype<Left> fo1;
|
||||
typedef equality_comparable2_second_archetype<null_archetype<> > Right;
|
||||
forward_iterator_archetype<Right> fo2;
|
||||
fo1 = std::find_end(fo1, fo1, fo2, fo2);
|
||||
}
|
||||
{
|
||||
// equality comparable required because find_end() calls search
|
||||
typedef equality_comparable2_first_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > Left;
|
||||
forward_iterator_archetype<Left> fo1;
|
||||
typedef equality_comparable2_second_archetype<
|
||||
convertible_to_archetype<null_archetype<> > > Right;
|
||||
forward_iterator_archetype<Right> fo2;
|
||||
binary_predicate_archetype<null_archetype<> , null_archetype<> >
|
||||
pred(dummy_cons);
|
||||
fo1 = std::find_end(fo1, fo1, fo2, fo2, pred);
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
// Mutating Algorithms
|
||||
|
||||
{
|
||||
typedef null_archetype<> T;
|
||||
input_iterator_archetype<T> in;
|
||||
output_iterator_archetype<T> out(dummy_cons);
|
||||
out = std::copy(in, in, out);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> OutT;
|
||||
typedef convertible_to_archetype<OutT> InT;
|
||||
bidirectional_iterator_archetype<InT> bid_in;
|
||||
mutable_bidirectional_iterator_archetype<OutT> bid_out;
|
||||
bid_out = std::copy_backward(bid_in, bid_in, bid_out);
|
||||
}
|
||||
{
|
||||
sgi_assignable_archetype<> a(dummy_cons), b(dummy_cons);
|
||||
std::swap(a, b);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
mutable_forward_iterator_archetype<T> a, b;
|
||||
std::iter_swap(a, b);
|
||||
}
|
||||
{
|
||||
typedef mutually_convertible_archetype<int> Tin;
|
||||
typedef mutually_convertible_archetype<char> Tout;
|
||||
mutable_forward_iterator_archetype<Tin> fi1;
|
||||
mutable_forward_iterator_archetype<Tout> fi2;
|
||||
fi2 = std::swap_ranges(fi1, fi1, fi2);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Tin;
|
||||
typedef null_archetype<char> Tout;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
unary_function_archetype<null_archetype<> ,
|
||||
convertible_to_archetype<Tout> > op(dummy_cons);
|
||||
out = std::transform(in, in, out, op);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Tin1;
|
||||
typedef null_archetype<char> Tin2;
|
||||
typedef null_archetype<double> Tout;
|
||||
input_iterator_archetype<Tin1> in1;
|
||||
input_iterator_archetype<Tin2> in2;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
binary_function_archetype<Tin1, Tin2,
|
||||
convertible_to_archetype<Tout> > op(dummy_cons);
|
||||
out = std::transform(in1, in1, in2, out, op);
|
||||
}
|
||||
{
|
||||
typedef equality_comparable2_first_archetype<
|
||||
assignable_archetype<> > FT;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
equality_comparable2_second_archetype<
|
||||
convertible_to_archetype<FT> > value(dummy_cons);
|
||||
std::replace(fi, fi, value, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> PredArg;
|
||||
typedef assignable_archetype<
|
||||
convertible_to_archetype<PredArg> > FT;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
convertible_to_archetype<FT> value(dummy_cons);
|
||||
std::replace_if(fi, fi, pred, value);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
// Issue, the use of ?: inside replace_copy() complicates things
|
||||
typedef equal_op_first_archetype<> Tin;
|
||||
typedef null_archetype<> Tout;
|
||||
typedef equal_op_second_archetype< convertible_to_archetype<Tout> > T;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
T value(dummy_cons);
|
||||
out = std::replace_copy(in, in, out, value, value);
|
||||
}
|
||||
{
|
||||
// The issue of ?: also affects this function
|
||||
typedef null_archetype<> Tout;
|
||||
typedef assignable_archetype< convertible_to_archetype<Tout> > Tin;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
unary_predicate_archetype<Tin> pred(dummy_cons);
|
||||
Tin value(dummy_cons);
|
||||
out = std::replace_copy_if(in, in, out, pred, value);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> FT;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
typedef convertible_to_archetype<FT> T;
|
||||
T value(dummy_cons);
|
||||
std::fill(fi, fi, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> T;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
T value(dummy_cons);
|
||||
int n = 1;
|
||||
out = std::fill_n(out, n, value);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> FT;
|
||||
typedef convertible_to_archetype<FT> Ret;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
generator_archetype<Ret> gen;
|
||||
std::generate(fi, fi, gen);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> FT;
|
||||
typedef convertible_to_archetype<FT> Ret;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
generator_archetype<Ret> gen;
|
||||
int n = 1;
|
||||
std::generate_n(fi, n, gen);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype< equality_comparable2_first_archetype<> > FT;
|
||||
typedef equality_comparable2_second_archetype<> T;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
T value(dummy_cons);
|
||||
fi = std::remove(fi, fi, value);
|
||||
}
|
||||
{
|
||||
typedef assignable_archetype<> FT;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
typedef null_archetype<> PredArg;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
fi = std::remove_if(fi, fi, pred);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
typedef equality_comparable2_first_archetype<
|
||||
convertible_to_archetype<Tout> > Tin;
|
||||
typedef equality_comparable2_second_archetype<> T;
|
||||
input_iterator_archetype<Tin> in;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
T value(dummy_cons);
|
||||
out = std::remove_copy(in, in, out, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> T;
|
||||
input_iterator_archetype<T> in;
|
||||
output_iterator_archetype<T> out(dummy_cons);
|
||||
unary_predicate_archetype<T> pred(dummy_cons);
|
||||
out = std::remove_copy_if(in, in, out, pred);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype< equality_comparable_archetype<> > T;
|
||||
mutable_forward_iterator_archetype<T> fi;
|
||||
fi = std::unique(fi, fi);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg1,
|
||||
convertible_to_archetype<Arg2> > > FT;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons);
|
||||
fi = std::unique(fi, fi, pred);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
typedef equality_comparable_archetype< sgi_assignable_archetype<> > T;
|
||||
input_iterator_archetype<T> in;
|
||||
output_iterator_archetype<T> out(dummy_cons);
|
||||
out = std::unique_copy(in, in, out);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
input_iterator_archetype<T> in;
|
||||
output_iterator_archetype<T> out(dummy_cons);
|
||||
binary_predicate_archetype<T, T> pred(dummy_cons);
|
||||
out = std::unique_copy(in, in, out, pred);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
mutable_bidirectional_iterator_archetype<T> bi;
|
||||
std::reverse(bi, bi);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> Tin;
|
||||
bidirectional_iterator_archetype<Tin> bi;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
out = std::reverse_copy(bi, bi, out);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
mutable_forward_iterator_archetype<T> fi;
|
||||
// Issue, SGI STL is not have void return type, C++ standard does
|
||||
std::rotate(fi, fi, fi);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
typedef convertible_to_archetype<Tout> FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
out = std::rotate_copy(fi, fi, fi, out);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
std::random_shuffle(ri, ri);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
unary_function_archetype<std::ptrdiff_t, std::ptrdiff_t> ran(dummy_cons);
|
||||
std::random_shuffle(ri, ri, ran);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> PredArg;
|
||||
typedef sgi_assignable_archetype<convertible_to_archetype<PredArg> > FT;
|
||||
mutable_bidirectional_iterator_archetype<FT> bi;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
bi = std::partition(bi, bi, pred);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> PredArg;
|
||||
typedef sgi_assignable_archetype<convertible_to_archetype<PredArg> > FT;
|
||||
mutable_forward_iterator_archetype<FT> fi;
|
||||
unary_predicate_archetype<PredArg> pred(dummy_cons);
|
||||
fi = std::stable_partition(fi, fi, pred);
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
// Sorting Algorithms
|
||||
{
|
||||
typedef sgi_assignable_archetype<
|
||||
less_than_comparable_archetype<> > T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
std::sort(ri, ri);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Arg;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg> > T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
|
||||
std::sort(ri, ri, comp);
|
||||
}
|
||||
{
|
||||
typedef less_than_comparable_archetype<
|
||||
sgi_assignable_archetype<> > ValueType;
|
||||
mutable_random_access_iterator_archetype<ValueType> ri;
|
||||
std::stable_sort(ri, ri);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Arg;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg> > ValueType;
|
||||
mutable_random_access_iterator_archetype<ValueType> ri;
|
||||
binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
|
||||
std::stable_sort(ri, ri, comp);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<
|
||||
less_than_comparable_archetype<> > T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
std::partial_sort(ri, ri, ri);
|
||||
}
|
||||
|
||||
{
|
||||
typedef null_archetype<> Arg;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg> > T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
|
||||
std::partial_sort(ri, ri, ri, comp);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
// This could be formulated so that the two iterators are not
|
||||
// required to have the same value type, but it is messy.
|
||||
typedef sgi_assignable_archetype<
|
||||
less_than_comparable_archetype<> > T;
|
||||
input_iterator_archetype<T> in;
|
||||
mutable_random_access_iterator_archetype<T> ri_out;
|
||||
ri_out = std::partial_sort_copy(in, in , ri_out, ri_out);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
input_iterator_archetype<T> in;
|
||||
mutable_random_access_iterator_archetype<T> ri_out;
|
||||
binary_predicate_archetype<T, T> comp(dummy_cons);
|
||||
ri_out = std::partial_sort_copy(in, in , ri_out, ri_out, comp);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype< less_than_comparable_archetype<> > T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
std::nth_element(ri, ri, ri);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg1,
|
||||
convertible_to_archetype<Arg2> > > T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
|
||||
std::nth_element(ri, ri, ri, comp);
|
||||
}
|
||||
{
|
||||
#if defined(__GNUC__)
|
||||
typedef less_than_op_first_archetype<> FT;
|
||||
typedef less_than_op_second_archetype<> T;
|
||||
#elif defined(__KCC)
|
||||
// The KAI version of this uses a one-argument less-than function
|
||||
// object.
|
||||
typedef less_than_comparable_archetype<> T;
|
||||
typedef convertible_to_archetype<T> FT;
|
||||
#endif
|
||||
forward_iterator_archetype<FT> fi;
|
||||
T value(dummy_cons);
|
||||
fi = std::lower_bound(fi, fi, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
typedef convertible_to_archetype<Arg1> FT;
|
||||
typedef convertible_to_archetype<Arg2> T;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
T value(dummy_cons);
|
||||
binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
|
||||
fi = std::lower_bound(fi, fi, value, comp);
|
||||
}
|
||||
{
|
||||
#if defined(__GNUC__)
|
||||
// Note, order of T,FT is flipped from lower_bound
|
||||
typedef less_than_op_second_archetype<> FT;
|
||||
typedef less_than_op_first_archetype<> T;
|
||||
#elif defined(__KCC)
|
||||
typedef less_than_comparable_archetype<> T;
|
||||
typedef convertible_to_archetype<T> FT;
|
||||
#endif
|
||||
forward_iterator_archetype<FT> fi;
|
||||
T value(dummy_cons);
|
||||
fi = std::upper_bound(fi, fi, value);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
// Note, order of T,FT is flipped from lower_bound
|
||||
typedef convertible_to_archetype<Arg1> T;
|
||||
typedef convertible_to_archetype<Arg2> FT;
|
||||
forward_iterator_archetype<FT> fi;
|
||||
T value(dummy_cons);
|
||||
binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
|
||||
fi = std::upper_bound(fi, fi, value, comp);
|
||||
}
|
||||
{
|
||||
#if defined(__GNUC__)
|
||||
typedef less_than_op_first_archetype<
|
||||
less_than_op_second_archetype< null_archetype<>, optag2>, optag1> FT;
|
||||
typedef less_than_op_second_archetype<
|
||||
less_than_op_first_archetype< null_archetype<>, optag2>, optag1> T;
|
||||
#elif defined(__KCC)
|
||||
typedef less_than_comparable_archetype<> T;
|
||||
typedef convertible_to_archetype<T> FT;
|
||||
#endif
|
||||
typedef forward_iterator_archetype<FT> FIter;
|
||||
FIter fi;
|
||||
T value(dummy_cons);
|
||||
std::pair<FIter,FIter> p = std::equal_range(fi, fi, value);
|
||||
ignore_unused_variable_warning(p);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
typedef convertible_to_archetype<Arg1,
|
||||
convertible_to_archetype<Arg2> > FT;
|
||||
typedef convertible_to_archetype<Arg2,
|
||||
convertible_to_archetype<Arg1> > T;
|
||||
typedef forward_iterator_archetype<FT> FIter;
|
||||
FIter fi;
|
||||
T value(dummy_cons);
|
||||
binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
|
||||
std::pair<FIter,FIter> p = std::equal_range(fi, fi, value, comp);
|
||||
ignore_unused_variable_warning(p);
|
||||
}
|
||||
{
|
||||
#if defined(__GNUC__)
|
||||
typedef less_than_op_first_archetype<
|
||||
less_than_op_second_archetype<null_archetype<>, optag2>, optag1> FT;
|
||||
typedef less_than_op_second_archetype<
|
||||
less_than_op_first_archetype<null_archetype<>, optag2>, optag1> T;
|
||||
#elif defined(__KCC)
|
||||
typedef less_than_op_first_archetype< less_than_comparable_archetype<> > T;
|
||||
typedef less_than_op_second_archetype< convertible_to_archetype<T> > FT;
|
||||
#endif
|
||||
forward_iterator_archetype<FT> fi;
|
||||
T value(dummy_cons);
|
||||
bool b = std::binary_search(fi, fi, value);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
#if defined(__GNUC__) || defined(__KCC)
|
||||
typedef convertible_to_archetype<Arg1,
|
||||
convertible_to_archetype<Arg2> > FT;
|
||||
typedef convertible_to_archetype<Arg2,
|
||||
convertible_to_archetype<Arg1> > T;
|
||||
#endif
|
||||
typedef forward_iterator_archetype<FT> FIter;
|
||||
FIter fi;
|
||||
T value(dummy_cons);
|
||||
binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
|
||||
bool b = std::binary_search(fi, fi, value, comp);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Tout;
|
||||
#if defined(__GNUC__) || defined(__KCC)
|
||||
typedef less_than_op_first_archetype<
|
||||
less_than_op_second_archetype<
|
||||
convertible_to_archetype<Tout>, optag2>, optag1 > Tin1;
|
||||
typedef less_than_op_second_archetype<
|
||||
less_than_op_first_archetype<
|
||||
convertible_to_archetype<Tout>, optag2> ,optag1> Tin2;
|
||||
#endif
|
||||
// gcc bug
|
||||
input_iterator_archetype<Tin1> in1;
|
||||
input_iterator_archetype<Tin2> in2;
|
||||
output_iterator_archetype<Tout> out(dummy_cons);
|
||||
out = std::merge(in1, in1, in2, in2, out);
|
||||
out = std::set_union(in1, in1, in2, in2, out);
|
||||
out = std::set_intersection(in1, in1, in2, in2, out);
|
||||
out = std::set_difference(in1, in1, in2, in2, out);
|
||||
out = std::set_symmetric_difference(in1, in1, in2, in2, out);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> T;
|
||||
input_iterator_archetype<T> in1;
|
||||
input_iterator_archetype<T,2> in2;
|
||||
typedef convertible_from_archetype<T> Tout;
|
||||
output_iterator_archetype<T> out(dummy_cons);
|
||||
binary_predicate_archetype<T, T> comp(dummy_cons);
|
||||
out = std::merge(in1, in1, in2, in2, out, comp);
|
||||
out = std::set_union(in1, in1, in2, in2, out, comp);
|
||||
out = std::set_intersection(in1, in1, in2, in2, out, comp);
|
||||
out = std::set_difference(in1, in1, in2, in2, out, comp);
|
||||
out = std::set_symmetric_difference(in1, in1, in2, in2, out, comp);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<
|
||||
less_than_comparable_archetype<> > T;
|
||||
mutable_bidirectional_iterator_archetype<T> bi;
|
||||
std::inplace_merge(bi, bi, bi);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Arg;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg> > T;
|
||||
mutable_bidirectional_iterator_archetype<T> bi;
|
||||
binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
|
||||
std::inplace_merge(bi, bi, bi, comp);
|
||||
}
|
||||
// gcc bug
|
||||
{
|
||||
typedef less_than_op_first_archetype<
|
||||
less_than_op_second_archetype<null_archetype<>, optag1>, optag2> Tin1;
|
||||
typedef less_than_op_second_archetype<
|
||||
less_than_op_first_archetype<null_archetype<>, optag1>, optag2> Tin2;
|
||||
input_iterator_archetype<Tin1> in1;
|
||||
input_iterator_archetype<Tin2> in2;
|
||||
bool b = std::includes(in1, in1, in2, in2);
|
||||
b = std::lexicographical_compare(in1, in1, in2, in2);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Tin;
|
||||
input_iterator_archetype<Tin> in1;
|
||||
input_iterator_archetype<Tin,1> in2;
|
||||
binary_predicate_archetype<Tin, Tin> comp(dummy_cons);
|
||||
bool b = std::includes(in1, in1, in2, in2, comp);
|
||||
b = std::lexicographical_compare(in1, in1, in2, in2, comp);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<
|
||||
less_than_comparable_archetype<> > T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
std::push_heap(ri, ri);
|
||||
std::pop_heap(ri, ri);
|
||||
std::make_heap(ri, ri);
|
||||
std::sort_heap(ri, ri);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Arg;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg> > T;
|
||||
mutable_random_access_iterator_archetype<T> ri;
|
||||
binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
|
||||
std::push_heap(ri, ri, comp);
|
||||
std::pop_heap(ri, ri, comp);
|
||||
std::make_heap(ri, ri, comp);
|
||||
std::sort_heap(ri, ri, comp);
|
||||
}
|
||||
{
|
||||
typedef less_than_comparable_archetype<> T;
|
||||
T a(dummy_cons), b(dummy_cons);
|
||||
BOOST_USING_STD_MIN();
|
||||
BOOST_USING_STD_MAX();
|
||||
const T& c = min BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
|
||||
const T& d = max BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
|
||||
ignore_unused_variable_warning(c);
|
||||
ignore_unused_variable_warning(d);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Arg;
|
||||
binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
|
||||
typedef convertible_to_archetype<Arg> T;
|
||||
T a(dummy_cons), b(dummy_cons);
|
||||
BOOST_USING_STD_MIN();
|
||||
BOOST_USING_STD_MAX();
|
||||
const T& c = min BOOST_PREVENT_MACRO_SUBSTITUTION(a, b, comp);
|
||||
const T& d = max BOOST_PREVENT_MACRO_SUBSTITUTION(a, b, comp);
|
||||
ignore_unused_variable_warning(c);
|
||||
ignore_unused_variable_warning(d);
|
||||
}
|
||||
{
|
||||
typedef less_than_comparable_archetype<> T;
|
||||
forward_iterator_archetype<T> fi;
|
||||
fi = std::min_element(fi, fi);
|
||||
fi = std::max_element(fi, fi);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Arg;
|
||||
binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
|
||||
typedef convertible_to_archetype<Arg> T;
|
||||
forward_iterator_archetype<T> fi;
|
||||
fi = std::min_element(fi, fi, comp);
|
||||
fi = std::max_element(fi, fi, comp);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<
|
||||
less_than_comparable_archetype<> > T;
|
||||
mutable_bidirectional_iterator_archetype<T> bi;
|
||||
bool b = std::next_permutation(bi, bi);
|
||||
b = std::prev_permutation(bi, bi);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<> Arg;
|
||||
binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg> > T;
|
||||
mutable_bidirectional_iterator_archetype<T> bi;
|
||||
bool b = std::next_permutation(bi, bi, comp);
|
||||
b = std::prev_permutation(bi, bi, comp);
|
||||
ignore_unused_variable_warning(b);
|
||||
}
|
||||
//===========================================================================
|
||||
// Generalized Numeric Algorithms
|
||||
|
||||
{
|
||||
// Bummer, couldn't use plus_op because of a problem with
|
||||
// mutually recursive types.
|
||||
input_iterator_archetype<accum::Tin> in;
|
||||
accum::T init(dummy_cons);
|
||||
init = std::accumulate(in, in, init);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> Arg1;
|
||||
typedef null_archetype<char> Arg2;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<Arg1> > T;
|
||||
typedef convertible_to_archetype<T> Ret;
|
||||
input_iterator_archetype<Arg2> in;
|
||||
T init(dummy_cons);
|
||||
binary_function_archetype<Arg1, Arg2, Ret> op(dummy_cons);
|
||||
init = std::accumulate(in, in, init, op);
|
||||
}
|
||||
{
|
||||
input_iterator_archetype<inner_prod::Tin1> in1;
|
||||
input_iterator_archetype<inner_prod::Tin2> in2;
|
||||
inner_prod::T init(dummy_cons);
|
||||
init = std::inner_product(in1, in1, in2, init);
|
||||
}
|
||||
{
|
||||
typedef null_archetype<int> MultArg1;
|
||||
typedef null_archetype<char> MultArg2;
|
||||
typedef null_archetype<short> AddArg1;
|
||||
typedef null_archetype<long> AddArg2;
|
||||
typedef sgi_assignable_archetype<
|
||||
convertible_to_archetype<AddArg1> > T;
|
||||
typedef convertible_to_archetype<AddArg2> RetMult;
|
||||
typedef convertible_to_archetype<T> RetAdd;
|
||||
input_iterator_archetype<MultArg1> in1;
|
||||
input_iterator_archetype<MultArg2> in2;
|
||||
T init(dummy_cons);
|
||||
binary_function_archetype<MultArg1, MultArg2, RetMult> mult_op(dummy_cons);
|
||||
binary_function_archetype<AddArg1, AddArg2, RetAdd> add_op(dummy_cons);
|
||||
init = std::inner_product(in1, in1, in2, init, add_op, mult_op);
|
||||
}
|
||||
{
|
||||
input_iterator_archetype<part_sum::T> in;
|
||||
output_iterator_archetype<part_sum::T> out(dummy_cons);
|
||||
out = std::partial_sum(in, in, out);
|
||||
}
|
||||
{
|
||||
typedef sgi_assignable_archetype<> T;
|
||||
input_iterator_archetype<T> in;
|
||||
output_iterator_archetype<T> out(dummy_cons);
|
||||
binary_function_archetype<T, T, T> add_op(dummy_cons);
|
||||
out = std::partial_sum(in, in, out, add_op);
|
||||
binary_function_archetype<T, T, T> subtract_op(dummy_cons);
|
||||
out = std::adjacent_difference(in, in, out, subtract_op);
|
||||
}
|
||||
{
|
||||
input_iterator_archetype<part_sum::T> in;
|
||||
output_iterator_archetype<part_sum::T> out(dummy_cons);
|
||||
out = std::adjacent_difference(in, in, out);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
int main() {}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,22 @@
|
||||
// Copyright David Abrahams 2006. 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)
|
||||
|
||||
#include <boost/concept/usage.hpp>
|
||||
|
||||
template <class T>
|
||||
struct StringInitializable
|
||||
{
|
||||
typedef int associated;
|
||||
BOOST_CONCEPT_USAGE(StringInitializable)
|
||||
{
|
||||
T x = "foo";
|
||||
}
|
||||
};
|
||||
|
||||
// Test that accessing an associated type will actually exercise usage
|
||||
// requirements
|
||||
typedef StringInitializable<int>::associated tee;
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
// Copyright David Abrahams 2006. 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)
|
||||
#include <vector>
|
||||
#undef NDEBUG
|
||||
#include "fake_sort.hpp"
|
||||
|
||||
int main()
|
||||
{
|
||||
std::vector<int> v;
|
||||
fake::sort(v.begin(), v.end());
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
// Copyright David Abrahams 2006. 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)
|
||||
#include <list>
|
||||
#undef NDEBUG
|
||||
#include "fake_sort.hpp"
|
||||
|
||||
int main()
|
||||
{
|
||||
std::list<int> v;
|
||||
fake::sort(v.begin(), v.end());
|
||||
return 0;
|
||||
}
|
||||
Reference in new issue
Block a user