feedc0de/boost_intrusive
1
0
Fork 0
forked from boostorg/intrusive
Code Pull Requests Activity

gcc 4.3 fixes for normal and -std=c++0x modes

Browse Source 
[SVN r46573]
This commit is contained in:
Ion Gaztañaga
2008-06-21 09:06:15 +00:00
parent a60ea9d474
commit e9cdb500d6
16 changed files with 201 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
doc/intrusive.qbk
View File

@@ -127,7 +127,7 @@ way to make user classes compatible with those containers.
[section:properties_of_intrusive Properties of Boost.Intrusive containers] [section:properties_of_intrusive Properties of Boost.Intrusive containers]
Semantically, a [*Boost.Intrusive] container is similar to an STL container Semantically, a [*Boost.Intrusive] container is similar to a STL container
holding pointers to objects. That is, if you have an intrusive list holding holding pointers to objects. That is, if you have an intrusive list holding
objects of type `T`, then `std::list<T*>` would allow you to do quite the objects of type `T`, then `std::list<T*>` would allow you to do quite the
same operations (maintaining and navigating a set of objects of type T and same operations (maintaining and navigating a set of objects of type T and
@@ -584,7 +584,7 @@ Apart from that, [*Boost.Intrusive] offers additional features:
safe state and intrusive containers check that state before inserting a value in the safe state and intrusive containers check that state before inserting a value in the
container. When erasing an element from the container, the container puts the hook container. When erasing an element from the container, the container puts the hook
in the safe state again. This allows a safer use mode and it can be used to detect in the safe state again. This allows a safer use mode and it can be used to detect
programming errors. It implies an slight performance overhead in some operations programming errors. It implies a slight performance overhead in some operations
and can convert some constant time operations to linear time operations. and can convert some constant time operations to linear time operations.
* [*Auto-unlink hooks]: The hook destructor removes the object from the container * [*Auto-unlink hooks]: The hook destructor removes the object from the container
@@ -596,7 +596,7 @@ Apart from that, [*Boost.Intrusive] offers additional features:
be configured to use any type of pointer. This configuration information is also be configured to use any type of pointer. This configuration information is also
transmitted to the containers, so all the internal pointers used by intrusive containers transmitted to the containers, so all the internal pointers used by intrusive containers
configured with these hooks will be smart pointers. As an example, configured with these hooks will be smart pointers. As an example,
[*Boost.Interprocess] defines an smart pointer compatible with shared memory, [*Boost.Interprocess] defines an mart pointer compatible with shared memory,
called `offset_ptr`. [*Boost.Intrusive] can be configured to use this smart pointer called `offset_ptr`. [*Boost.Intrusive] can be configured to use this smart pointer
to allow shared memory intrusive containers. to allow shared memory intrusive containers.
@@ -718,7 +718,7 @@ Let's see an example of an auto-unlink hook:
As explained, [*Boost.Intrusive] auto-unlink hooks are incompatible with containers As explained, [*Boost.Intrusive] auto-unlink hooks are incompatible with containers
that have constant-time `size()`, so if you try to define such container with an that have constant-time `size()`, so if you try to define such container with an
auto-unlink hook's value_traits, you will get an static assertion: auto-unlink hook's value_traits, you will get a static assertion:
[c++] [c++]
@@ -860,7 +860,7 @@ assertion will be raised.
[section:slist_example Example] [section:slist_example Example]
Now let's see an small example using both hooks: Now let's see a small example using both hooks:
[import ../example/doc_slist.cpp] [import ../example/doc_slist.cpp]
[doc_slist_code] [doc_slist_code]
@@ -946,7 +946,7 @@ the section [link intrusive.usage How to use Boost.Intrusive]:
[section:list_example Example] [section:list_example Example]
Now let's see an small example using both hooks: Now let's see a small example using both hooks:
[import ../example/doc_list.cpp] [import ../example/doc_list.cpp]
[doc_list_code] [doc_list_code]
@@ -1075,7 +1075,7 @@ And they also can receive an additional option:
[section:set_multiset_example Example] [section:set_multiset_example Example]
Now let's see an small example using both hooks and both containers: Now let's see a small example using both hooks and both containers:
[import ../example/doc_set.cpp] [import ../example/doc_set.cpp]
[doc_set_code] [doc_set_code]
@@ -1277,11 +1277,22 @@ And they also can receive additional options:
of the first element. This imposes the overhead of one pointer to the size of the first element. This imposes the overhead of one pointer to the size
of the container. Default: `cache_begin<false>`. of the container. Default: `cache_begin<false>`.
* [*`compare_hash<bool Enabled>`]:
[*Note: this option requires `store_hash<true>` option in the hook].
When the comparison function is expensive,
(e.g. strings with a long common predicate) sometimes (specially when the
load factor is high or we have many equivalent elements in an
[classref boost::intrusive::unordered_multiset unordered_multiset] and
no `optimize_multikey<>` is activatedin the hook)
the equality function is a performance problem. Two equal values must have
equal hashes, so comparing the hash values of two elements before using the
comparison functor can speed up some implementations.
[endsect] [endsect]
[section:unordered_set_unordered_multiset_example Example] [section:unordered_set_unordered_multiset_example Example]
Now let's see an small example using both hooks and both containers: Now let's see a small example using both hooks and both containers:
[import ../example/doc_unordered_set.cpp] [import ../example/doc_unordered_set.cpp]
[doc_unordered_set_code] [doc_unordered_set_code]
@@ -1450,9 +1461,9 @@ intrusive scapegoat containers
[classref boost::intrusive::sg_set sg_set] and [classref boost::intrusive::sg_set sg_set] and
[classref boost::intrusive::sg_multiset sg_multiset]. A programmer [classref boost::intrusive::sg_multiset sg_multiset]. A programmer
might prefer using a binary search tree hook so that the same type might prefer using a binary search tree hook so that the same type
can be inserted in some situations in an splay container but can be inserted in some situations in a splay container but
also inserted in other compatible containers when also inserted in other compatible containers when
the hook is not being used in an splay container. the hook is not being used in a splay container.
[classref boost::intrusive::bs_set_base_hook bs_set_base_hook] and [classref boost::intrusive::bs_set_base_hook bs_set_base_hook] and
[classref boost::intrusive::bs_set_base_hook bs_set_member_hook] admit [classref boost::intrusive::bs_set_base_hook bs_set_member_hook] admit
@@ -1462,7 +1473,7 @@ the same options as [classref boost::intrusive::splay_set_base_hook splay_set_ba
[section:splay_set_multiset_example Example] [section:splay_set_multiset_example Example]
Now let's see an small example using both splay hooks, Now let's see a small example using both splay hooks,
binary search tree hooks and binary search tree hooks and
[classref boost::intrusive::splay_set splay_set]/ [classref boost::intrusive::splay_set splay_set]/
[classref boost::intrusive::splay_multiset splay_multiset] [classref boost::intrusive::splay_multiset splay_multiset]
@@ -1590,7 +1601,7 @@ And they also can receive an additional option:
[section:avl_set_multiset_example Example] [section:avl_set_multiset_example Example]
Now let's see an small example using both hooks and Now let's see a small example using both hooks and
[classref boost::intrusive::avl_set avl_set]/ [classref boost::intrusive::avl_set avl_set]/
[classref boost::intrusive::avl_multiset avl_multiset] [classref boost::intrusive::avl_multiset avl_multiset]
containers: containers:
@@ -1745,7 +1756,7 @@ And they also can receive additional options:
[section:sg_set_multiset_example Example] [section:sg_set_multiset_example Example]
Now let's see an small example using both hooks and Now let's see a small example using both hooks and
[classref boost::intrusive::sg_set sg_set]/ [classref boost::intrusive::sg_set sg_set]/
[classref boost::intrusive::sg_multiset sg_multiset] [classref boost::intrusive::sg_multiset sg_multiset]
containers: containers:
@@ -1923,7 +1934,7 @@ more functions taking a disposer function object as argument, like `erase_and_di
Note that the disposing function does not need to just destroy the object. It can Note that the disposing function does not need to just destroy the object. It can
implement any other operation like inserting the remove object in another container. implement any other operation like inserting the remove object in another container.
Let's see an small example: Let's see a small example:
[import ../example/doc_erasing_and_disposing.cpp] [import ../example/doc_erasing_and_disposing.cpp]
[doc_erasing_and_disposing] [doc_erasing_and_disposing]
@@ -1940,11 +1951,11 @@ that erase an element from the container.
As previously mentioned, [*Boost.Intrusive] containers are [*non-copyable and non-assignable], because As previously mentioned, [*Boost.Intrusive] containers are [*non-copyable and non-assignable], because
intrusive containers don't allocate memory at all. To implement a copy-constructor or assignment operator, intrusive containers don't allocate memory at all. To implement a copy-constructor or assignment operator,
the user must clone one by one all the elements of the container and insert them in another intrusive container. the user must clone one by one all the elements of the container and insert them in another intrusive container.
However, cloning by hand is usually more inefficient than a member cloning function and an specialized cloning However, cloning by hand is usually more inefficient than a member cloning function and a specialized cloning
function can offer more guarantees than the manual cloning (better exception safety guarantees, for example). function can offer more guarantees than the manual cloning (better exception safety guarantees, for example).
To ease the implementation of copy constructors and assignment operators of classes containing [*Boost.Intrusive] To ease the implementation of copy constructors and assignment operators of classes containing [*Boost.Intrusive]
containers, all [*Boost.Intrusive] containers offer an special cloning function called `clone_from`. containers, all [*Boost.Intrusive] containers offer a special cloning function called `clone_from`.
Apart from the container to be cloned, `clone_from` takes two function objects as arguments. For example, consider the Apart from the container to be cloned, `clone_from` takes two function objects as arguments. For example, consider the
`clone_from` member function of [classref boost::intrusive::list list]: `clone_from` member function of [classref boost::intrusive::list list]:
@@ -1981,9 +1992,9 @@ Here's an example of `clone_from`:
[section:using_smart_pointers Using smart pointers with Boost.Intrusive containers] [section:using_smart_pointers Using smart pointers with Boost.Intrusive containers]
[*Boost.Intrusive] hooks can be configured to use other pointers than raw pointers. [*Boost.Intrusive] hooks can be configured to use other pointers than raw pointers.
When a [*Boost.Intrusive] hook is configured with an smart pointer as an argument, When a [*Boost.Intrusive] hook is configured with a smart pointer as an argument,
this pointer configuration is passed to the containers. For example, if the following this pointer configuration is passed to the containers. For example, if the following
hook is configured with an smart pointer (for example, an offset pointer from hook is configured with a smart pointer (for example, an offset pointer from
[*Boost.Interprocess]): [*Boost.Interprocess]):
[import ../example/doc_offset_ptr.cpp] [import ../example/doc_offset_ptr.cpp]
@@ -2060,7 +2071,7 @@ explained in the [link intrusive.value_traits.stateful_value_traits Stateful val
if the programmer uses hooks provided by [*Boost.Intrusive], those functions if the programmer uses hooks provided by [*Boost.Intrusive], those functions
will be available. will be available.
Let's see an small function that shows the use of `iterator_to` and Let's see a small function that shows the use of `iterator_to` and
`local_iterator_to`: `local_iterator_to`:
[import ../example/doc_iterator_from_value.cpp] [import ../example/doc_iterator_from_value.cpp]
@@ -2068,6 +2079,51 @@ Let's see an small function that shows the use of `iterator_to` and
[endsect] [endsect]
[section:any_hooks Any Hooks: A single hook for any Intrusive container]
Sometimes, a class programmer wants to place a class in several intrusive
containers but no at the same time. In this case, the programmer might
decide to insert two hooks in the same class.
[c++]
class MyClass
: public list_base_hook<>, public slist_base_hook<> //...
{};
However, there is a more size-efficient alternative in [*Boost.Intrusive]: "any" hooks
([classref boost::intrusive::any_base_hook any_base_hook] and
[classref boost::intrusive::any_member_hook any_member_hook].
These hooks can be used to store a type in several containers
offered by [*Boost.Intrusive] minimizing the size of the class.
These hooks support these options:
* [*`tag<class Tag>`] (for base hooks only): This argument serves as a tag,
so you can derive from more than one slist hook.
Default: `tag<default_tag>`.
* [*`link_mode<link_mode_type LinkMode>`]: The linking policy.
`link_mode<auto_unlink>` is [*not] supported and `link_mode<safe_mode>`
might offer weaker error detection in any hooks than in other hooks.
Default: `link_mode<safe_link>`.
* [*`void_pointer<class VoidPointer>`]: The pointer type to be used
internally in the hook and propagated to the container.
Default: `void_pointer<void*>`.
`auto_unlink` can't be supported because the hook does not know in which type of might
be inserted container. Additionally, these hooks don't support `unlink()` and
`swap_nodes()` operations for the same reason.
Here's an example that creates a class with two any hooks, and uses one to insert the
class in a [classref slist] and the other one in a [classref list].
[import ../example/doc_any_hook.cpp]
[doc_any_hook]
[endsect]
[section:concepts Concepts explained] [section:concepts Concepts explained]
This section will expand the explanation of previously presented basic concepts This section will expand the explanation of previously presented basic concepts
@@ -2187,7 +2243,7 @@ before explaining the customization options of [*Boost.Intrusive].
int value_; int value_;
}; };
* [*Intrusive Container]: A container that offers an STL-like interface to store * [*Intrusive Container]: A container that offers a STL-like interface to store
user objects. An intrusive container can be templatized to store different user objects. An intrusive container can be templatized to store different
value types that use different hooks. An intrusive container is also more elaborate value types that use different hooks. An intrusive container is also more elaborate
than a group of nodes: it can store the number of elements to achieve constant-time than a group of nodes: it can store the number of elements to achieve constant-time
@@ -2642,7 +2698,7 @@ used in node algorithms, since these types can be different. Apart from this,
Instead of using [*Boost.Intrusive] predefined hooks Instead of using [*Boost.Intrusive] predefined hooks
a user might want to develop customized containers, for example, using nodes that are a user might want to develop customized containers, for example, using nodes that are
optimized for an specific optimized for a specific
application or that are compatible with a a legacy ABI. A user might want application or that are compatible with a a legacy ABI. A user might want
to have only two additional pointers in his class and insert the class in a doubly to have only two additional pointers in his class and insert the class in a doubly
linked list sometimes and in a singly linked list in other situations. You can't linked list sometimes and in a singly linked list in other situations. You can't
@@ -2804,7 +2860,7 @@ In the previous example, `legacy_node_traits::node` type and
to have several `ValueTraits` defining the same `node_traits` type (and thus, the same `node_traits::node`). to have several `ValueTraits` defining the same `node_traits` type (and thus, the same `node_traits::node`).
This reduces the number of node algorithm instantiations, but This reduces the number of node algorithm instantiations, but
now `ValueTraits::to_node_ptr` and `ValueTraits::to_value_ptr` functions need to offer now `ValueTraits::to_node_ptr` and `ValueTraits::to_value_ptr` functions need to offer
conversions between both types. Let's see an small example: conversions between both types. Let's see a small example:
First, we'll define the node to be used in the algorithms. For a linked list, First, we'll define the node to be used in the algorithms. For a linked list,
we just need a node that stores two pointers: we just need a node that stores two pointers:

8
proj/vc7ide/Intrusive.sln
View File

@@ -79,6 +79,10 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sg_set", "sg_set\sg_set.vcp
ProjectSection(ProjectDependencies) = postProject ProjectSection(ProjectDependencies) = postProject
EndProjectSection EndProjectSection
EndProject EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "any_hook", "any_test\any_test.vcproj", "{97B61B24-4C97-9681-50BF-243175A813B6}"
ProjectSection(ProjectDependencies) = postProject
EndProjectSection
EndProject
Global Global
GlobalSection(SolutionConfiguration) = preSolution GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug Debug = Debug
@@ -167,6 +171,10 @@ Global
{1690A9E7-DB57-971C-F24A-09B752A942F7}.Debug.Build.0 = Debug|Win32 {1690A9E7-DB57-971C-F24A-09B752A942F7}.Debug.Build.0 = Debug|Win32
{1690A9E7-DB57-971C-F24A-09B752A942F7}.Release.ActiveCfg = Release|Win32 {1690A9E7-DB57-971C-F24A-09B752A942F7}.Release.ActiveCfg = Release|Win32
{1690A9E7-DB57-971C-F24A-09B752A942F7}.Release.Build.0 = Release|Win32 {1690A9E7-DB57-971C-F24A-09B752A942F7}.Release.Build.0 = Release|Win32
{97B61B24-4C97-9681-50BF-243175A813B6}.Debug.ActiveCfg = Debug|Win32
{97B61B24-4C97-9681-50BF-243175A813B6}.Debug.Build.0 = Debug|Win32
{97B61B24-4C97-9681-50BF-243175A813B6}.Release.ActiveCfg = Release|Win32
{97B61B24-4C97-9681-50BF-243175A813B6}.Release.Build.0 = Release|Win32
EndGlobalSection EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution GlobalSection(ExtensibilityGlobals) = postSolution
EndGlobalSection EndGlobalSection

9
proj/vc7ide/_intrusivelib/_intrusivelib.vcproj
View File

@@ -105,6 +105,9 @@
Name="Header Files" Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd" Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
<File
RelativePath="..\..\..\..\..\boost\intrusive\any_hook.hpp">
</File>
<File <File
RelativePath="..\..\..\..\..\boost\intrusive\avl_set.hpp"> RelativePath="..\..\..\..\..\boost\intrusive\avl_set.hpp">
</File> </File>
@@ -207,6 +210,9 @@
<Filter <Filter
Name="detail" Name="detail"
Filter=""> Filter="">
<File
RelativePath="..\..\..\..\..\boost\intrusive\detail\any_node_and_algorithms.hpp">
</File>
<File <File
RelativePath="..\..\..\..\..\boost\intrusive\detail\assert.hpp"> RelativePath="..\..\..\..\..\boost\intrusive\detail\assert.hpp">
</File> </File>
@@ -316,6 +322,9 @@
<File <File
RelativePath="..\..\..\example\doc_advanced_value_traits2.cpp"> RelativePath="..\..\..\example\doc_advanced_value_traits2.cpp">
</File> </File>
<File
RelativePath="..\..\..\example\doc_any_hook.cpp">
</File>
<File <File
RelativePath="..\..\..\example\doc_assoc_optimized_code.cpp"> RelativePath="..\..\..\example\doc_assoc_optimized_code.cpp">
</File> </File>

10
proj/vc7ide/list/list.vcproj
View File

@@ -127,16 +127,6 @@
RelativePath="..\..\..\test\list_test.cpp"> RelativePath="..\..\..\test\list_test.cpp">
</File> </File>
</Filter> </Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
</Filter>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>

10
proj/vc7ide/multiset/multiset.vcproj
View File

@@ -121,16 +121,6 @@
RelativePath="..\..\..\test\multiset_test.cpp"> RelativePath="..\..\..\test\multiset_test.cpp">
</File> </File>
</Filter> </Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
</Filter>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>

10
proj/vc7ide/perf_test/perf_test.vcproj
View File

@@ -122,16 +122,6 @@
RelativePath="..\..\..\perf\perf_list.cpp"> RelativePath="..\..\..\perf\perf_list.cpp">
</File> </File>
</Filter> </Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{68B017A6-F80D6A2-084c-06A6-8A323C1ABD01}">
</Filter>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>

10
proj/vc7ide/set/set.vcproj
View File

@@ -121,16 +121,6 @@
RelativePath="..\..\..\test\set_test.cpp"> RelativePath="..\..\..\test\set_test.cpp">
</File> </File>
</Filter> </Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{68007AB6-FDA6800-084c-B78A-8121AA3BBD01}">
</Filter>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>

10
proj/vc7ide/slist/slist.vcproj
View File

@@ -121,16 +121,6 @@
RelativePath="..\..\..\test\slist_test.cpp"> RelativePath="..\..\..\test\slist_test.cpp">
</File> </File>
</Filter> </Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
</Filter>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>

43
proj/vc7ide/to-do.txt
View File

@@ -1,12 +1,37 @@
Add resize() to list Implement incremental hashing:
Implement incremental hashing
Add invariants to slist and test them after every operation
Create a generic hook that will work with all containers
Take advantage of store_hash in lookups: Instead of comparing objects, just
compare hashes. This will improve equality for expensive objects.
Improve the use of cache_begin to unordered containers: bucket_len is power of two
-> Speed up rehash cur_idx is always at least, half of bucket_len
find bucket from value:
size_type bucket_num = hash(val) &(bucket_len - 1);
if (bucket_num >= cur_idx)
bucket_num -= bucket_len/2;
incremental_rehash:
iterator _Plist, _Where;
if (load_factor > LoadFactorLimit)
{ // too dense, need to grow hash table
if (cur_idx >= (bucket_len - 1))
{ // table full, request doubling
return false;
}
else if (cur_idx >= bucket_len)
bucket_len*=2;
size_type bucket_num = cur_idx - bucket_len/2;
// rehash elements from bucket_num
++cur_idx;
}
insert from value:
size_type bucket_num = hash(val) & (bucket_len - 1);
if (bucket_num >= cur_idx)
bucket_num -= bucket_len/2;
insert in bucket
rehash:
Add erase(iterator, iterator, difference_type) to lists to obtain constant-time erase.

10
proj/vc7ide/unordered_multiset/unordered_multiset.vcproj
View File

@@ -122,16 +122,6 @@
RelativePath="..\..\..\test\unordered_multiset_test.cpp"> RelativePath="..\..\..\test\unordered_multiset_test.cpp">
</File> </File>
</Filter> </Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{99954380-9C8D-084c-4b04-62E52E6FBBFB}">
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{6A181B76-FDA6800-8E8B-0A66-813A3BB1AD01}">
</Filter>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>

10
proj/vc7ide/unordered_set/unordered_set.vcproj
View File

@@ -121,16 +121,6 @@
RelativePath="..\..\..\test\unordered_set_test.cpp"> RelativePath="..\..\..\test\unordered_set_test.cpp">
</File> </File>
</Filter> </Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
UniqueIdentifier="{68AB0076-FDA6800-084c-06A6-8121AA3BBD01}">
</Filter>
</Files> </Files>
<Globals> <Globals>
</Globals> </Globals>

8
test/common_functors.hpp
View File

@@ -41,6 +41,14 @@ class new_cloner
{ return new T(t); } { return new T(t); }
}; };
template<class T>
class new_default_factory
{
public:
T *operator()()
{ return new T(); }
};
} //namespace test { } //namespace test {
} //namespace intrusive { } //namespace intrusive {
} //namespace boost { } //namespace boost {

1
test/list_test.cpp
View File

@@ -229,6 +229,7 @@ void test_list<ValueTraits>
TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); } TEST_INTRUSIVE_SEQUENCE( init_values, const_testlist.begin() ); }
} }
template<class ValueTraits> template<class ValueTraits>
void test_list<ValueTraits> void test_list<ValueTraits>
::test_shift(std::vector<typename ValueTraits::value_type>& values) ::test_shift(std::vector<typename ValueTraits::value_type>& values)

2
test/slist_test.cpp
View File

@@ -315,7 +315,7 @@ void test_slist<ValueTraits, Linear, CacheLast>
testlist.erase (++testlist.begin(), testlist.end()); testlist.erase (++testlist.begin(), testlist.end());
BOOST_TEST (testlist.size() == 1); BOOST_TEST (testlist.size() == 1);
BOOST_TEST (testlist.front().value_ == 3); BOOST_TEST (testlist.front().value_ == 3);
} }
template<class ValueTraits, bool Linear, bool CacheLast> template<class ValueTraits, bool Linear, bool CacheLast>
void test_slist<ValueTraits, Linear, CacheLast> void test_slist<ValueTraits, Linear, CacheLast>

48
test/unordered_multiset_test.cpp
View File

@@ -27,7 +27,7 @@ using namespace boost::intrusive;
static const std::size_t BucketSize = 11; static const std::size_t BucketSize = 11;
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
struct test_unordered_multiset struct test_unordered_multiset
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
@@ -41,8 +41,8 @@ struct test_unordered_multiset
static void test_clone(std::vector<value_type>& values); static void test_clone(std::vector<value_type>& values);
}; };
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_multiset<ValueTraits, CacheBegin>::test_all (std::vector<typename ValueTraits::value_type>& values) void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash>::test_all (std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_multiset typedef unordered_multiset
@@ -50,6 +50,7 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_all (std::vector<typ
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_multiset_type; > unordered_multiset_type;
{ {
typedef typename unordered_multiset_type::bucket_traits bucket_traits; typedef typename unordered_multiset_type::bucket_traits bucket_traits;
@@ -77,8 +78,8 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_all (std::vector<typ
} }
//test case due to an error in tree implementation: //test case due to an error in tree implementation:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_multiset<ValueTraits, CacheBegin>::test_impl() void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash>::test_impl()
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_multiset typedef unordered_multiset
@@ -86,6 +87,7 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_impl()
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_multiset_type; > unordered_multiset_type;
typedef typename unordered_multiset_type::bucket_traits bucket_traits; typedef typename unordered_multiset_type::bucket_traits bucket_traits;
@@ -108,8 +110,8 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_impl()
} }
//test: constructor, iterator, clear, reverse_iterator, front, back, size: //test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_multiset<ValueTraits, CacheBegin>::test_sort(std::vector<typename ValueTraits::value_type>& values) void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_multiset typedef unordered_multiset
@@ -117,6 +119,7 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_sort(std::vector<typ
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_multiset_type; > unordered_multiset_type;
typedef typename unordered_multiset_type::bucket_traits bucket_traits; typedef typename unordered_multiset_type::bucket_traits bucket_traits;
@@ -130,8 +133,8 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_sort(std::vector<typ
} }
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to: //test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_multiset<ValueTraits, CacheBegin>::test_insert(std::vector<typename ValueTraits::value_type>& values) void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_multiset typedef unordered_multiset
@@ -139,6 +142,7 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_insert(std::vector<t
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_multiset_type; > unordered_multiset_type;
typedef typename unordered_multiset_type::bucket_traits bucket_traits; typedef typename unordered_multiset_type::bucket_traits bucket_traits;
typedef typename unordered_multiset_type::iterator iterator; typedef typename unordered_multiset_type::iterator iterator;
@@ -269,8 +273,8 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_insert(std::vector<t
} }
//test: insert (seq-version), swap, erase (seq-version), size: //test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_multiset<ValueTraits, CacheBegin>::test_swap(std::vector<typename ValueTraits::value_type>& values) void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_multiset typedef unordered_multiset
@@ -278,6 +282,7 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_swap(std::vector<typ
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_multiset_type; > unordered_multiset_type;
typedef typename unordered_multiset_type::bucket_traits bucket_traits; typedef typename unordered_multiset_type::bucket_traits bucket_traits;
typename unordered_multiset_type::bucket_type buckets [BucketSize]; typename unordered_multiset_type::bucket_type buckets [BucketSize];
@@ -302,8 +307,8 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_swap(std::vector<typ
} }
//test: rehash: //test: rehash:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_multiset<ValueTraits, CacheBegin>::test_rehash(std::vector<typename ValueTraits::value_type>& values) void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash>::test_rehash(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_multiset typedef unordered_multiset
@@ -311,6 +316,7 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_rehash(std::vector<t
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_multiset_type; > unordered_multiset_type;
typedef typename unordered_multiset_type::bucket_traits bucket_traits; typedef typename unordered_multiset_type::bucket_traits bucket_traits;
@@ -347,8 +353,8 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_rehash(std::vector<t
} }
//test: find, equal_range (lower_bound, upper_bound): //test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_multiset<ValueTraits, CacheBegin>::test_find(std::vector<typename ValueTraits::value_type>& values) void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash>::test_find(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_multiset typedef unordered_multiset
@@ -356,6 +362,7 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_find(std::vector<typ
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_multiset_type; > unordered_multiset_type;
typedef typename unordered_multiset_type::bucket_traits bucket_traits; typedef typename unordered_multiset_type::bucket_traits bucket_traits;
@@ -380,8 +387,8 @@ void test_unordered_multiset<ValueTraits, CacheBegin>::test_find(std::vector<typ
} }
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_multiset<ValueTraits, CacheBegin> void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash>
::test_clone(std::vector<typename ValueTraits::value_type>& values) ::test_clone(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
@@ -390,6 +397,7 @@ void test_unordered_multiset<ValueTraits, CacheBegin>
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_multiset_type; > unordered_multiset_type;
typedef typename unordered_multiset_type::bucket_traits bucket_traits; typedef typename unordered_multiset_type::bucket_traits bucket_traits;
{ {
@@ -462,6 +470,7 @@ class test_main_template
, typename value_type::unordered_set_base_hook_t , typename value_type::unordered_set_base_hook_t
>::type >::type
, true , true
, false
>::test_all(data); >::test_all(data);
test_unordered_multiset < typename detail::get_member_value_traits test_unordered_multiset < typename detail::get_member_value_traits
@@ -472,6 +481,7 @@ class test_main_template
> >
>::type >::type
, false , false
, false
>::test_all(data); >::test_all(data);
return 0; return 0;
@@ -495,6 +505,7 @@ class test_main_template<VoidPointer, false>
, typename value_type::unordered_set_base_hook_t , typename value_type::unordered_set_base_hook_t
>::type >::type
, true , true
, false
>::test_all(data); >::test_all(data);
test_unordered_multiset < typename detail::get_member_value_traits test_unordered_multiset < typename detail::get_member_value_traits
@@ -505,6 +516,7 @@ class test_main_template<VoidPointer, false>
> >
>::type >::type
, false , false
, false
>::test_all(data); >::test_all(data);
test_unordered_multiset < typename detail::get_base_value_traits test_unordered_multiset < typename detail::get_base_value_traits
@@ -512,6 +524,7 @@ class test_main_template<VoidPointer, false>
, typename value_type::unordered_set_auto_base_hook_t , typename value_type::unordered_set_auto_base_hook_t
>::type >::type
, true , true
, true
>::test_all(data); >::test_all(data);
test_unordered_multiset < typename detail::get_member_value_traits test_unordered_multiset < typename detail::get_member_value_traits
@@ -522,6 +535,7 @@ class test_main_template<VoidPointer, false>
> >
>::type >::type
, false , false
, true
>::test_all(data); >::test_all(data);
return 0; return 0;
} }

48
test/unordered_set_test.cpp
View File

@@ -26,7 +26,7 @@ using namespace boost::intrusive;
static const std::size_t BucketSize = 11; static const std::size_t BucketSize = 11;
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
struct test_unordered_set struct test_unordered_set
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
@@ -40,8 +40,8 @@ struct test_unordered_set
static void test_clone(std::vector<value_type>& values); static void test_clone(std::vector<value_type>& values);
}; };
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_set<ValueTraits, CacheBegin>::test_all(std::vector<typename ValueTraits::value_type>& values) void test_unordered_set<ValueTraits, CacheBegin, CompareHash>::test_all(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_set typedef unordered_set
@@ -49,6 +49,7 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_all(std::vector<typename
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_set_type; > unordered_set_type;
typedef typename unordered_set_type::bucket_traits bucket_traits; typedef typename unordered_set_type::bucket_traits bucket_traits;
{ {
@@ -76,8 +77,8 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_all(std::vector<typename
} }
//test case due to an error in tree implementation: //test case due to an error in tree implementation:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_set<ValueTraits, CacheBegin>::test_impl() void test_unordered_set<ValueTraits, CacheBegin, CompareHash>::test_impl()
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_set typedef unordered_set
@@ -85,6 +86,7 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_impl()
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_set_type; > unordered_set_type;
typedef typename unordered_set_type::bucket_traits bucket_traits; typedef typename unordered_set_type::bucket_traits bucket_traits;
@@ -105,8 +107,8 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_impl()
} }
//test: constructor, iterator, clear, reverse_iterator, front, back, size: //test: constructor, iterator, clear, reverse_iterator, front, back, size:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_set<ValueTraits, CacheBegin>::test_sort(std::vector<typename ValueTraits::value_type>& values) void test_unordered_set<ValueTraits, CacheBegin, CompareHash>::test_sort(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_set typedef unordered_set
@@ -114,6 +116,7 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_sort(std::vector<typename
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_set_type; > unordered_set_type;
typedef typename unordered_set_type::bucket_traits bucket_traits; typedef typename unordered_set_type::bucket_traits bucket_traits;
@@ -129,8 +132,8 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_sort(std::vector<typename
} }
//test: insert, const_iterator, const_reverse_iterator, erase, iterator_to: //test: insert, const_iterator, const_reverse_iterator, erase, iterator_to:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_set<ValueTraits, CacheBegin>::test_insert(std::vector<typename ValueTraits::value_type>& values) void test_unordered_set<ValueTraits, CacheBegin, CompareHash>::test_insert(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_set typedef unordered_set
@@ -138,6 +141,7 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_insert(std::vector<typena
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_set_type; > unordered_set_type;
typedef typename unordered_set_type::bucket_traits bucket_traits; typedef typename unordered_set_type::bucket_traits bucket_traits;
@@ -165,8 +169,8 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_insert(std::vector<typena
} }
//test: insert (seq-version), swap, erase (seq-version), size: //test: insert (seq-version), swap, erase (seq-version), size:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_set<ValueTraits, CacheBegin>::test_swap(std::vector<typename ValueTraits::value_type>& values) void test_unordered_set<ValueTraits, CacheBegin, CompareHash>::test_swap(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_set typedef unordered_set
@@ -174,6 +178,7 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_swap(std::vector<typename
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_set_type; > unordered_set_type;
typedef typename unordered_set_type::bucket_traits bucket_traits; typedef typename unordered_set_type::bucket_traits bucket_traits;
@@ -197,8 +202,8 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_swap(std::vector<typename
} }
//test: rehash: //test: rehash:
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_set<ValueTraits, CacheBegin>::test_rehash(std::vector<typename ValueTraits::value_type>& values) void test_unordered_set<ValueTraits, CacheBegin, CompareHash>::test_rehash(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_set typedef unordered_set
@@ -206,6 +211,7 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_rehash(std::vector<typena
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_set_type; > unordered_set_type;
typedef typename unordered_set_type::bucket_traits bucket_traits; typedef typename unordered_set_type::bucket_traits bucket_traits;
@@ -243,8 +249,8 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_rehash(std::vector<typena
//test: find, equal_range (lower_bound, upper_bound): //test: find, equal_range (lower_bound, upper_bound):
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_set<ValueTraits, CacheBegin>::test_find(std::vector<typename ValueTraits::value_type>& values) void test_unordered_set<ValueTraits, CacheBegin, CompareHash>::test_find(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
typedef unordered_set typedef unordered_set
@@ -252,6 +258,7 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_find(std::vector<typename
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_set_type; > unordered_set_type;
typedef typename unordered_set_type::bucket_traits bucket_traits; typedef typename unordered_set_type::bucket_traits bucket_traits;
@@ -274,8 +281,8 @@ void test_unordered_set<ValueTraits, CacheBegin>::test_find(std::vector<typename
BOOST_TEST (testset.find (cmp_val) == testset.end()); BOOST_TEST (testset.find (cmp_val) == testset.end());
} }
template<class ValueTraits, bool CacheBegin> template<class ValueTraits, bool CacheBegin, bool CompareHash>
void test_unordered_set<ValueTraits, CacheBegin> void test_unordered_set<ValueTraits, CacheBegin, CompareHash>
::test_clone(std::vector<typename ValueTraits::value_type>& values) ::test_clone(std::vector<typename ValueTraits::value_type>& values)
{ {
typedef typename ValueTraits::value_type value_type; typedef typename ValueTraits::value_type value_type;
@@ -284,6 +291,7 @@ void test_unordered_set<ValueTraits, CacheBegin>
, value_traits<ValueTraits> , value_traits<ValueTraits>
, constant_time_size<value_type::constant_time_size> , constant_time_size<value_type::constant_time_size>
, cache_begin<CacheBegin> , cache_begin<CacheBegin>
, compare_hash<CompareHash>
> unordered_set_type; > unordered_set_type;
typedef typename unordered_set_type::bucket_traits bucket_traits; typedef typename unordered_set_type::bucket_traits bucket_traits;
{ {
@@ -356,6 +364,7 @@ class test_main_template
, typename value_type::unordered_set_base_hook_t , typename value_type::unordered_set_base_hook_t
>::type >::type
, true , true
, false
>::test_all(data); >::test_all(data);
test_unordered_set < typename detail::get_member_value_traits test_unordered_set < typename detail::get_member_value_traits
< value_type < value_type
@@ -365,6 +374,7 @@ class test_main_template
> >
>::type >::type
, false , false
, false
>::test_all(data); >::test_all(data);
return 0; return 0;
@@ -388,6 +398,7 @@ class test_main_template<VoidPointer, false>
, typename value_type::unordered_set_base_hook_t , typename value_type::unordered_set_base_hook_t
>::type >::type
, true , true
, false
>::test_all(data); >::test_all(data);
test_unordered_set < typename detail::get_member_value_traits test_unordered_set < typename detail::get_member_value_traits
@@ -398,6 +409,7 @@ class test_main_template<VoidPointer, false>
> >
>::type >::type
, false , false
, false
>::test_all(data); >::test_all(data);
test_unordered_set < typename detail::get_base_value_traits test_unordered_set < typename detail::get_base_value_traits
@@ -405,6 +417,7 @@ class test_main_template<VoidPointer, false>
, typename value_type::unordered_set_auto_base_hook_t , typename value_type::unordered_set_auto_base_hook_t
>::type >::type
, true , true
, true
>::test_all(data); >::test_all(data);
test_unordered_set < typename detail::get_member_value_traits test_unordered_set < typename detail::get_member_value_traits
@@ -415,6 +428,7 @@ class test_main_template<VoidPointer, false>
> >
>::type >::type
, false , false
, true
>::test_all(data); >::test_all(data);
return 0; return 0;
} }