]>
Commit | Line | Data |
---|---|---|
1 | // (C) Copyright John Maddock 2008. | |
2 | // Use, modification and distribution are subject to the | |
3 | // Boost Software License, Version 1.0. (See accompanying file | |
4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
5 | ||
6 | #include "boost/concept_check.hpp" | |
7 | #include "boost/concept_archetype.hpp" | |
8 | #include "verify_return.hpp" | |
9 | ||
10 | namespace boost{ | |
11 | ||
12 | template <class Arg, class Return> | |
13 | class default_constructible_unary_function_archetype { | |
14 | public: | |
15 | const Return& operator()(const Arg&) const { | |
16 | return static_object<Return>::get(); | |
17 | } | |
18 | }; | |
19 | ||
20 | template <class Arg1, class Arg2, class Base = null_archetype<> > | |
21 | class default_constructible_binary_predicate_archetype { | |
22 | typedef boolean_archetype Return; | |
23 | public: | |
24 | const Return& operator()(const Arg1&, const Arg2&) const { | |
25 | return static_object<Return>::get(); | |
26 | } | |
27 | }; | |
28 | ||
29 | template <class Unordered> | |
30 | struct UnorderedContainer | |
31 | { | |
32 | void constraints() | |
33 | { | |
34 | function_requires<Container<Unordered> >(); | |
35 | ||
36 | typedef typename Unordered::key_type key_type; | |
37 | typedef typename Unordered::hasher hasher; | |
38 | typedef typename Unordered::key_equal key_equal; | |
39 | typedef typename Unordered::local_iterator local_iterator; | |
40 | typedef typename Unordered::const_local_iterator const_local_iterator; | |
41 | typedef typename Unordered::value_type value_type; | |
42 | typedef typename Unordered::iterator iterator; | |
43 | typedef typename Unordered::const_iterator const_iterator; | |
44 | typedef typename Unordered::size_type size_type; | |
45 | ||
46 | function_requires<Assignable<key_type> >(); | |
47 | function_requires<CopyConstructible<key_type> >(); | |
48 | function_requires<UnaryFunction<hasher, std::size_t, key_type> >(); | |
49 | function_requires<BinaryPredicate<key_equal, key_type, key_type> >(); | |
50 | function_requires<ForwardIterator<local_iterator> >(); | |
51 | function_requires<ForwardIterator<const_local_iterator> >(); | |
52 | ||
53 | size_type n = 1; | |
54 | const hasher& hf = static_object<hasher>::get(); | |
55 | const key_equal& eq = static_object<key_equal>::get(); | |
56 | value_type const& t = static_object<value_type>::get(); | |
57 | key_type const& k = static_object<key_type>::get(); | |
58 | Unordered x1(n, hf, eq); | |
59 | Unordered x2(n, hf); | |
60 | Unordered x3(n); | |
61 | Unordered x4; | |
62 | ||
63 | typedef input_iterator_archetype<typename Unordered::value_type> input_iterator; | |
64 | input_iterator i = static_object<input_iterator>::get(); | |
65 | input_iterator j = i; | |
66 | x1 = Unordered(i, j, n, hf, eq); | |
67 | x2 = Unordered(i, j, n, hf); | |
68 | x3 = Unordered(i, j, n); | |
69 | x4 = Unordered(i, j); | |
70 | x1 = x2; | |
71 | Unordered x5(x1); | |
72 | iterator q = x1.begin(); | |
73 | const_iterator r = x1.begin(); | |
74 | ||
75 | verify_return_type(x1.hash_function(), hf); | |
76 | verify_return_type(x1.key_eq(), eq); | |
77 | verify_return_type(x1.insert(q, t), q); | |
78 | x1.insert(i, j); | |
79 | verify_return_type(x1.erase(k), n); | |
80 | verify_return_type(x1.erase(q), q); | |
81 | verify_return_type(x1.erase(q, q), q); | |
82 | x1.clear(); | |
83 | ||
84 | const Unordered& b = x1; | |
85 | verify_return_type(x1.find(k), q); | |
86 | verify_return_type(b.find(k), r); | |
87 | verify_return_type(b.count(k), n); | |
88 | verify_return_type(x1.equal_range(k), std::make_pair(q, q)); | |
89 | verify_return_type(b.equal_range(k), std::make_pair(r, r)); | |
90 | verify_return_type(b.bucket_count(), n); | |
91 | verify_return_type(b.max_bucket_count(), n); | |
92 | verify_return_type(b.bucket(k), n); | |
93 | verify_return_type(b.bucket_size(n), n); | |
94 | ||
95 | local_iterator li = x1.begin(n); | |
96 | const_local_iterator cli = b.begin(n); | |
97 | verify_return_type(x1.begin(n), li); | |
98 | verify_return_type(b.begin(n), cli); | |
99 | verify_return_type(x1.end(n), li); | |
100 | verify_return_type(b.end(n), cli); | |
101 | verify_return_type(b.load_factor(), 1.0f); | |
102 | verify_return_type(b.max_load_factor(), 1.0f); | |
103 | x1.max_load_factor(1.0f); | |
104 | x1.rehash(n); | |
105 | } | |
106 | }; | |
107 | ||
108 | template <class Unordered> | |
109 | struct UniqueUnorderedContainer | |
110 | { | |
111 | void constraints() | |
112 | { | |
113 | typedef typename Unordered::key_type key_type; | |
114 | typedef typename Unordered::hasher hasher; | |
115 | typedef typename Unordered::key_equal key_equal; | |
116 | typedef typename Unordered::local_iterator local_iterator; | |
117 | typedef typename Unordered::const_local_iterator const_local_iterator; | |
118 | typedef typename Unordered::value_type value_type; | |
119 | ||
120 | Unordered x; | |
121 | value_type const& t = static_object<value_type>::get(); | |
122 | function_requires<UnorderedContainer<Unordered> >(); | |
123 | verify_return_type(x.insert(t), static_object<std::pair<typename Unordered::iterator, bool> >::get()); | |
124 | } | |
125 | }; | |
126 | ||
127 | template <class Unordered> | |
128 | struct MultiUnorderedContainer | |
129 | { | |
130 | void constraints() | |
131 | { | |
132 | typedef typename Unordered::key_type key_type; | |
133 | typedef typename Unordered::hasher hasher; | |
134 | typedef typename Unordered::key_equal key_equal; | |
135 | typedef typename Unordered::local_iterator local_iterator; | |
136 | typedef typename Unordered::const_local_iterator const_local_iterator; | |
137 | typedef typename Unordered::value_type value_type; | |
138 | ||
139 | Unordered x; | |
140 | value_type const& t = static_object<value_type>::get(); | |
141 | function_requires<UnorderedContainer<Unordered> >(); | |
142 | verify_return_type(x.insert(t), static_object<typename Unordered::iterator>::get()); | |
143 | } | |
144 | }; | |
145 | ||
146 | } | |
147 |