1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="generator" content="Docutils 0.3.9: http://docutils.sourceforge.net/" />
<title>Boost Pointer Container Library</title>
<link rel="stylesheet" href="default.css" type="text/css" />
</head>
<body>
<div class="document" id="boost-pointer-container-library">
<h1 class="title"><img alt="Boost" src="boost.png" /> Pointer Container Library</h1>
<h2 class="subtitle" id="indirected-functions">Indirected functions</h2>
<p>It is quite common that we have two pointers and what to compare the
pointed to objects. Also, we have usually already defined how
to compare the objects. So to avoid some tedious boiler-plate code
this library defines predicates that apply an indirection before comparing.</p>
<p>When the container uses <tt class="docutils literal"><span class="pre">void*</span></tt> internally, we can use the
class <tt class="docutils literal"><span class="pre">void_ptr_indirect_fun</span></tt>; otherwise we use the class
<tt class="docutils literal"><span class="pre">indirect_fun</span></tt>.</p>
<p><strong>Example:</strong></p>
<pre class="literal-block">
std::string* bar = new std::string("bar");
std::string* foo = new std::string("foo");
BOOST_ASSERT( indirect_fun< std::less<std::string> >()( bar, foo ) == true );
BOOST_ASSERT( make_indirect_fun( std::less<std::string>() )( foo, bar ) == false );
void* vptr1 = ptr1;
void* vptr2 = ptr2;
void_ptr_indirect_fun< std::less<std::string>, std::string> cast_fun;
BOOST_CHECK( cast_fun( vptr1, vptr2 ) == true );
</pre>
<p><strong>See also:</strong></p>
<ul class="simple">
<li><a class="reference" href="http://www.boost.org/libs/utility/utility.htm#result_of">result_of</a></li>
<li><a class="reference" href="http://www.boost.org/libs/iterator/doc/pointee.html">pointee</a></li>
<li><a class="reference" href="ptr_set.html">ptr_set</a></li>
<li><a class="reference" href="ptr_multiset.html">ptr_multiset</a></li>
</ul>
<p><strong>Navigate</strong></p>
<ul class="simple">
<li><a class="reference" href="ptr_container.html">home</a></li>
<li><a class="reference" href="reference.html">reference</a></li>
</ul>
<p><strong>Remarks:</strong></p>
<p>The class <tt class="docutils literal"><span class="pre">indirect_fun</span></tt> will work with smart pointers such as <a class="reference" href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm">boost::shared_ptr<T></a>
because of the type traits <tt class="docutils literal"><span class="pre">pointee<T>::type</span></tt> from the header <tt class="docutils literal"><span class="pre"><boost/pointee.hpp></span></tt>.</p>
<p><strong>Synopsis:</strong></p>
<p>Since the definition of the predicates is somewhat trivial, only the
first operation is expanded inline.</p>
<pre class="literal-block">
namespace boost
{
template< class Fun >
struct indirect_fun
{
indirect_fun() : fun(Fun())
{ }
indirect_fun( Fun f ) : fun(f)
{ }
template< class T >
typename result_of< Fun( typename pointee<T>::type ) >::type
operator()( const T& r ) const
{
return fun( *r );
}
template< class T, class U >
typename result_of< Fun( typename pointee<T>::type,
typename pointee<U>::type ) >::type
operator()( const T& r, const U& r2 ) const
{
return fun( *r, *r2 );
}
private:
Fun fun;
};
template< class Fun >
inline indirect_fun<Fun> make_indirect_fun( Fun f )
{
return indirect_fun<Fun>( f );
}
template< class Fun, class Arg1, class Arg2 = Arg1 >
struct void_ptr_indirect_fun
{
void_ptr_indirect_fun() : fun(Fun())
{ }
void_ptr_indirect_fun( Fun f ) : fun(f)
{ }
typename result_of< Fun( Arg1 ) >::type
operator()( const void* r ) const
{
return fun( * static_cast<const Arg1*>( r ) );
}
typename result_of< Fun( Arg1, Arg2 ) >::type
operator()( const void* l, const void* r ) const
{
return fun( * static_cast<const Arg1*>( l ), * static_cast<const Arg2*>( r ) );
}
private:
Fun fun;
};
template< class Fun, class Arg >
inline void_ptr_indirect_fun<Fun,Arg>
make_void_ptr_indirect_fun( Fun f )
{
return void_ptr_indirect_fun<Fun,Arg>( f );
}
} // namespace 'boost'
</pre>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field"><th class="field-name">copyright:</th><td class="field-body">Thorsten Ottosen 2004-2005.</td>
</tr>
</tbody>
</table>
</div>
</body>
</html>
|
