forked from boostorg/utility
Compare commits
2 Commits
string_vie
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
|
be4b817c83 | ||
|
13f6d43e5e |
109
Assignable.html
109
Assignable.html
@@ -1,109 +0,0 @@
|
|||||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Language" content="en-us">
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
|
|
||||||
|
|
||||||
<title>Assignable</title>
|
|
||||||
</head>
|
|
||||||
|
|
||||||
<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
|
|
||||||
"#FF0000">
|
|
||||||
<img src="../../boost.png" alt="C++ Boost" width="277" height=
|
|
||||||
"86"><br clear="none">
|
|
||||||
|
|
||||||
<h1>Assignable</h1>
|
|
||||||
|
|
||||||
<h3>Description</h3>
|
|
||||||
|
|
||||||
<p>A type is Assignable if it is possible to assign one object of the type
|
|
||||||
to another object of that type.</p>
|
|
||||||
|
|
||||||
<h3>Notation</h3>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>T</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">is type that is a model of Assignable</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>t</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">is an object of type <tt>T</tt></td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>u</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">is an object of type <tt>T</tt> or possibly <tt>const
|
|
||||||
T</tt></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Definitions</h3>
|
|
||||||
|
|
||||||
<h3>Valid expressions</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Return type</th>
|
|
||||||
|
|
||||||
<th>Semantics</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Assignment</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>t = u</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>T&</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>t</tt> is equivalent to <tt>u</tt></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Models</h3>
|
|
||||||
|
|
||||||
<ul>
|
|
||||||
<li><tt>int</tt></li>
|
|
||||||
|
|
||||||
<li><tt>std::pair</tt></li>
|
|
||||||
</ul>
|
|
||||||
|
|
||||||
<h3>See also</h3>
|
|
||||||
|
|
||||||
<p><a href=
|
|
||||||
"http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>
|
|
||||||
and <a href="./CopyConstructible.html">CopyConstructible</a><br></p>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
|
||||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
|
||||||
height="31" width="88"></a></p>
|
|
||||||
|
|
||||||
<p>Revised
|
|
||||||
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr valign="top">
|
|
||||||
<td nowrap><i>Copyright © 2000</i></td>
|
|
||||||
|
|
||||||
<td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
|
|
||||||
Notre Dame (<a href=
|
|
||||||
"mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<p><i>Distributed under the Boost Software License, Version 1.0. (See
|
|
||||||
accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
|
|
||||||
copy at <a href=
|
|
||||||
"http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
534
Collection.html
534
Collection.html
@@ -1,534 +0,0 @@
|
|||||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Language" content="en-us">
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
|
|
||||||
|
|
||||||
<title>Collection</title>
|
|
||||||
</head>
|
|
||||||
|
|
||||||
<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
|
|
||||||
"#FF0000">
|
|
||||||
<h1><img src="../../boost.png" alt="boost logo" width="277" align="middle"
|
|
||||||
height="86"><br>
|
|
||||||
Collection</h1>
|
|
||||||
|
|
||||||
<h3>Description</h3>
|
|
||||||
|
|
||||||
<p>A Collection is a <i>concept</i> similar to the STL <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/Container.html">Container</a> concept. A
|
|
||||||
Collection provides iterators for accessing a range of elements and
|
|
||||||
provides information about the number of elements in the Collection.
|
|
||||||
However, a Collection has fewer requirements than a Container. The
|
|
||||||
motivation for the Collection concept is that there are many useful
|
|
||||||
Container-like types that do not meet the full requirements of Container,
|
|
||||||
and many algorithms that can be written with this reduced set of
|
|
||||||
requirements. To summarize the reduction in requirements:</p>
|
|
||||||
|
|
||||||
<ul>
|
|
||||||
<li>It is not required to "own" its elements: the lifetime of an element
|
|
||||||
in a Collection does not have to match the lifetime of the Collection
|
|
||||||
object, though the lifetime of the element should cover the lifetime of
|
|
||||||
the Collection object.</li>
|
|
||||||
|
|
||||||
<li>The semantics of copying a Collection object is not defined (it could
|
|
||||||
be a deep or shallow copy or not even support copying).</li>
|
|
||||||
|
|
||||||
<li>The associated reference type of a Collection does not have to be a
|
|
||||||
real C++ reference.</li>
|
|
||||||
</ul>Because of the reduced requirements, some care must be taken when
|
|
||||||
writing code that is meant to be generic for all Collection types. In
|
|
||||||
particular, a Collection object should be passed by-reference since
|
|
||||||
assumptions can not be made about the behaviour of the copy constructor.
|
|
||||||
|
|
||||||
<h3>Associated types</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Value type</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>X::value_type</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">The type of the object stored in a Collection. If the
|
|
||||||
Collection is <i>mutable</i> then the value type must be <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>. Otherwise
|
|
||||||
the value type must be <a href=
|
|
||||||
"./CopyConstructible.html">CopyConstructible</a>.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Iterator type</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>X::iterator</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">The type of iterator used to iterate through a
|
|
||||||
Collection's elements. The iterator's value type is expected to be the
|
|
||||||
Collection's value type. A conversion from the iterator type to the
|
|
||||||
const iterator type must exist. The iterator type must be an <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Const iterator type</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>X::const_iterator</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">A type of iterator that may be used to examine, but
|
|
||||||
not to modify, a Collection's elements.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Reference type</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>X::reference</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">A type that behaves like a reference to the
|
|
||||||
Collection's value type. <a href="#n1">[1]</a></td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Const reference type</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>X::const_reference</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">A type that behaves like a const reference to the
|
|
||||||
Collection's value type.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Pointer type</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>X::pointer</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">A type that behaves as a pointer to the Collection's
|
|
||||||
value type.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Distance type</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>X::difference_type</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">A signed integral type used to represent the distance
|
|
||||||
between two of the Collection's iterators. This type must be the same
|
|
||||||
as the iterator's distance type.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Size type</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>X::size_type</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">An unsigned integral type that can represent any
|
|
||||||
nonnegative value of the Collection's distance type.</td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Notation</h3>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>X</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">A type that is a model of Collection.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>a</tt>, <tt>b</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">Object of type <tt>X</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>T</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">The value type of <tt>X</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Valid expressions</h3>
|
|
||||||
|
|
||||||
<p>The following expressions must be valid.</p>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Return type</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Beginning of range</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.begin()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>iterator</tt> if <tt>a</tt> is mutable,
|
|
||||||
<tt>const_iterator</tt> otherwise</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">End of range</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.end()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>iterator</tt> if <tt>a</tt> is mutable,
|
|
||||||
<tt>const_iterator</tt> otherwise</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Size</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.size()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>size_type</tt></td>
|
|
||||||
</tr><!--
|
|
||||||
<TR>
|
|
||||||
<TD VAlign=top>
|
|
||||||
Maximum size
|
|
||||||
</TD>
|
|
||||||
<TD VAlign=top>
|
|
||||||
<tt>a.max_size()</tt>
|
|
||||||
</TD>
|
|
||||||
<TD VAlign=top>
|
|
||||||
<tt>size_type</tt>
|
|
||||||
</TD>
|
|
||||||
</TR>
|
|
||||||
-->
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Empty Collection</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.empty()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">Convertible to <tt>bool</tt></td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Swap</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.swap(b)</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>void</tt></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Expression semantics</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Semantics</th>
|
|
||||||
|
|
||||||
<th>Postcondition</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Beginning of range</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.begin()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">Returns an iterator pointing to the first element in
|
|
||||||
the Collection.</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.begin()</tt> is either dereferenceable or
|
|
||||||
past-the-end. It is past-the-end if and only if <tt>a.size() ==
|
|
||||||
0</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">End of range</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.end()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">Returns an iterator pointing one past the last element
|
|
||||||
in the Collection.</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.end()</tt> is past-the-end.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Size</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.size()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">Returns the size of the Collection, that is, its
|
|
||||||
number of elements.</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.size() >= 0</tt></td>
|
|
||||||
</tr><!--
|
|
||||||
<TR>
|
|
||||||
<TD VAlign=top>
|
|
||||||
Maximum size
|
|
||||||
</TD>
|
|
||||||
<TD VAlign=top>
|
|
||||||
<tt>a.max_size()</tt>
|
|
||||||
</TD>
|
|
||||||
<TD VAlign=top>
|
|
||||||
|
|
||||||
</TD>
|
|
||||||
<TD VAlign=top>
|
|
||||||
Returns the largest size that this Collection can ever have. <A href="#8">[8]</A>
|
|
||||||
</TD>
|
|
||||||
<TD VAlign=top>
|
|
||||||
<tt>a.max_size() >= 0 && a.max_size() >= a.size()</tt>
|
|
||||||
</TD>
|
|
||||||
</TR>
|
|
||||||
-->
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Empty Collection</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.empty()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">Equivalent to <tt>a.size() == 0</tt>. (But possibly
|
|
||||||
faster.)</td>
|
|
||||||
|
|
||||||
<td valign="top"> </td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Swap</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.swap(b)</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">Equivalent to <tt>swap(a,b)</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"> </td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Complexity guarantees</h3>
|
|
||||||
|
|
||||||
<p><tt>begin()</tt> and <tt>end()</tt> are amortized constant time.</p>
|
|
||||||
|
|
||||||
<p><tt>size()</tt> is at most linear in the Collection's size.
|
|
||||||
<tt>empty()</tt> is amortized constant time.</p>
|
|
||||||
|
|
||||||
<p><tt>swap()</tt> is at most linear in the size of the two
|
|
||||||
collections.</p>
|
|
||||||
|
|
||||||
<h3>Invariants</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Valid range</td>
|
|
||||||
|
|
||||||
<td valign="top">For any Collection <tt>a</tt>, <tt>[a.begin(),
|
|
||||||
a.end())</tt> is a valid range.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Range size</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.size()</tt> is equal to the distance from
|
|
||||||
<tt>a.begin()</tt> to <tt>a.end()</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Completeness</td>
|
|
||||||
|
|
||||||
<td valign="top">An algorithm that iterates through the range
|
|
||||||
<tt>[a.begin(), a.end())</tt> will pass through every element of
|
|
||||||
<tt>a</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Models</h3>
|
|
||||||
|
|
||||||
<ul>
|
|
||||||
<li><tt>array</tt></li>
|
|
||||||
|
|
||||||
<li><tt>array_ptr</tt></li>
|
|
||||||
|
|
||||||
<li><tt>vector<bool></tt></li>
|
|
||||||
</ul>
|
|
||||||
|
|
||||||
<h3>Collection Refinements</h3>
|
|
||||||
|
|
||||||
<p>There are quite a few concepts that refine the Collection concept,
|
|
||||||
similar to the concepts that refine the Container concept. Here is a brief
|
|
||||||
overview of the refining concepts.</p>
|
|
||||||
|
|
||||||
<h4>ForwardCollection</h4>
|
|
||||||
|
|
||||||
<p>The elements are arranged in some order that does not change
|
|
||||||
spontaneously from one iteration to the next. As a result, a
|
|
||||||
ForwardCollection is <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>
|
|
||||||
and <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</a>.
|
|
||||||
In addition, the iterator type of a ForwardCollection is a
|
|
||||||
MultiPassInputIterator which is just an InputIterator with the added
|
|
||||||
requirements that the iterator can be used to make multiple passes through
|
|
||||||
a range, and that if <tt>it1 == it2</tt> and <tt>it1</tt> is
|
|
||||||
dereferenceable then <tt>++it1 == ++it2</tt>. The ForwardCollection also
|
|
||||||
has a <tt>front()</tt> method.</p>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Return type</th>
|
|
||||||
|
|
||||||
<th>Semantics</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Front</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.front()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,<br>
|
|
||||||
<tt>const_reference</tt> otherwise.</td>
|
|
||||||
|
|
||||||
<td valign="top">Equivalent to <tt>*(a.begin())</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h4>ReversibleCollection</h4>
|
|
||||||
|
|
||||||
<p>The container provides access to iterators that traverse in both
|
|
||||||
directions (forward and reverse). The iterator type must meet all of the
|
|
||||||
requirements of <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>
|
|
||||||
except that the reference type does not have to be a real C++ reference.
|
|
||||||
The ReversibleCollection adds the following requirements to those of
|
|
||||||
ForwardCollection.</p>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Return type</th>
|
|
||||||
|
|
||||||
<th>Semantics</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Beginning of range</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.rbegin()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>reverse_iterator</tt> if <tt>a</tt> is mutable,
|
|
||||||
<tt>const_reverse_iterator</tt> otherwise.</td>
|
|
||||||
|
|
||||||
<td valign="top">Equivalent to
|
|
||||||
<tt>X::reverse_iterator(a.end())</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">End of range</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.rend()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>reverse_iterator</tt> if <tt>a</tt> is mutable,
|
|
||||||
<tt>const_reverse_iterator</tt> otherwise.</td>
|
|
||||||
|
|
||||||
<td valign="top">Equivalent to
|
|
||||||
<tt>X::reverse_iterator(a.begin())</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Back</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a.back()</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,<br>
|
|
||||||
<tt>const_reference</tt> otherwise.</td>
|
|
||||||
|
|
||||||
<td valign="top">Equivalent to <tt>*(--a.end())</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h4>SequentialCollection</h4>
|
|
||||||
|
|
||||||
<p>The elements are arranged in a strict linear order. No extra methods are
|
|
||||||
required.</p>
|
|
||||||
|
|
||||||
<h4>RandomAccessCollection</h4>
|
|
||||||
|
|
||||||
<p>The iterators of a RandomAccessCollection satisfy all of the
|
|
||||||
requirements of <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>
|
|
||||||
except that the reference type does not have to be a real C++ reference. In
|
|
||||||
addition, a RandomAccessCollection provides an element access operator.</p>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Return type</th>
|
|
||||||
|
|
||||||
<th>Semantics</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Element Access</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>a[n]</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>reference</tt> if <tt>a</tt> is mutable,
|
|
||||||
<tt>const_reference</tt> otherwise.</td>
|
|
||||||
|
|
||||||
<td valign="top">Returns the nth element of the Collection. <tt>n</tt>
|
|
||||||
must be convertible to <tt>size_type</tt>. Precondition: <tt>0 <= n
|
|
||||||
< a.size()</tt>.</td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Notes</h3>
|
|
||||||
|
|
||||||
<p><a name="n1" id="n1">[1]</a> The reference type does not have to be a
|
|
||||||
real C++ reference. The requirements of the reference type depend on the
|
|
||||||
context within which the Collection is being used. Specifically it depends
|
|
||||||
on the requirements the context places on the value type of the Collection.
|
|
||||||
The reference type of the Collection must meet the same requirements as the
|
|
||||||
value type. In addition, the reference objects must be equivalent to the
|
|
||||||
value type objects in the collection (which is trivially true if they are
|
|
||||||
the same object). Also, in a mutable Collection, an assignment to the
|
|
||||||
reference object must result in an assignment to the object in the
|
|
||||||
Collection (again, which is trivially true if they are the same object, but
|
|
||||||
non-trivial if the reference type is a proxy class).</p>
|
|
||||||
|
|
||||||
<h3>See also</h3>
|
|
||||||
|
|
||||||
<p><a href=
|
|
||||||
"http://www.sgi.com/tech/stl/Container.html">Container</a><br></p>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
|
||||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
|
||||||
height="31" width="88"></a></p>
|
|
||||||
|
|
||||||
<p>Revised
|
|
||||||
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
|
|
||||||
December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr valign="top">
|
|
||||||
<td nowrap><i>Copyright © 2000</i></td>
|
|
||||||
|
|
||||||
<td><i><a href="http://www.boost.org/people/jeremy_siek.htm">Jeremy
|
|
||||||
Siek</a>, Univ.of Notre Dame and C++ Library & Compiler Group/SGI
|
|
||||||
(<a href="mailto:jsiek@engr.sgi.com">jsiek@engr.sgi.com</a>)</i></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<p><i>Distributed under the Boost Software License, Version 1.0. (See
|
|
||||||
accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
|
|
||||||
copy at <a href=
|
|
||||||
"http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,185 +0,0 @@
|
|||||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Language" content="en-us">
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
|
|
||||||
|
|
||||||
<title>Copy Constructible</title>
|
|
||||||
</head>
|
|
||||||
|
|
||||||
<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
|
|
||||||
"#FF0000">
|
|
||||||
<img src="../../boost.png" alt="C++ Boost" width="277" height=
|
|
||||||
"86"><br clear="none">
|
|
||||||
|
|
||||||
<h1>Copy Constructible</h1>
|
|
||||||
|
|
||||||
<h3>Description</h3>
|
|
||||||
|
|
||||||
<p>A type is Copy Constructible if it is possible to copy objects of that
|
|
||||||
type.</p>
|
|
||||||
|
|
||||||
<h3>Notation</h3>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>T</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">is type that is a model of Copy Constructible</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>t</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">is an object of type <tt>T</tt></td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>u</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">is an object of type <tt>const T</tt></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Definitions</h3>
|
|
||||||
|
|
||||||
<h3>Valid expressions</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Return type</th>
|
|
||||||
|
|
||||||
<th>Semantics</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Copy constructor</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>T(t)</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>T</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>t</tt> is equivalent to <tt>T(t)</tt></td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Copy constructor</td>
|
|
||||||
|
|
||||||
<td valign="top">
|
|
||||||
<pre>
|
|
||||||
T(u)
|
|
||||||
</pre>
|
|
||||||
</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>T</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>u</tt> is equivalent to <tt>T(u)</tt></td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Destructor</td>
|
|
||||||
|
|
||||||
<td valign="top">
|
|
||||||
<pre>
|
|
||||||
t.~T()
|
|
||||||
</pre>
|
|
||||||
</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>T</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"> </td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Address Operator</td>
|
|
||||||
|
|
||||||
<td valign="top">
|
|
||||||
<pre>
|
|
||||||
&t
|
|
||||||
</pre>
|
|
||||||
</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>T*</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">denotes the address of <tt>t</tt></td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Address Operator</td>
|
|
||||||
|
|
||||||
<td valign="top">
|
|
||||||
<pre>
|
|
||||||
&u
|
|
||||||
</pre>
|
|
||||||
</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>T*</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">denotes the address of <tt>u</tt></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Models</h3>
|
|
||||||
|
|
||||||
<ul>
|
|
||||||
<li><tt>int</tt></li>
|
|
||||||
|
|
||||||
<li><tt>std::pair</tt></li>
|
|
||||||
</ul>
|
|
||||||
|
|
||||||
<h3>Concept Checking Class</h3>
|
|
||||||
<pre>
|
|
||||||
template <class T>
|
|
||||||
struct CopyConstructibleConcept
|
|
||||||
{
|
|
||||||
void constraints() {
|
|
||||||
T a(b); // require copy constructor
|
|
||||||
T* ptr = &a; // require address of operator
|
|
||||||
const_constraints(a);
|
|
||||||
ignore_unused_variable_warning(ptr);
|
|
||||||
}
|
|
||||||
void const_constraints(const T& a) {
|
|
||||||
T c(a); // require const copy constructor
|
|
||||||
const T* ptr = &a; // require const address of operator
|
|
||||||
ignore_unused_variable_warning(c);
|
|
||||||
ignore_unused_variable_warning(ptr);
|
|
||||||
}
|
|
||||||
T b;
|
|
||||||
};
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<h3>See also</h3>
|
|
||||||
|
|
||||||
<p><a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
|
|
||||||
Constructible</a> and <a href="./Assignable.html">Assignable</a><br></p>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
|
||||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
|
||||||
height="31" width="88"></a></p>
|
|
||||||
|
|
||||||
<p>Revised
|
|
||||||
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
|
|
||||||
December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr valign="top">
|
|
||||||
<td nowrap><i>Copyright © 2000</i></td>
|
|
||||||
|
|
||||||
<td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
|
|
||||||
Notre Dame (<a href=
|
|
||||||
"mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<p><i>Distributed under the Boost Software License, Version 1.0. (See
|
|
||||||
accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
|
|
||||||
copy at <a href=
|
|
||||||
"http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,210 +0,0 @@
|
|||||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
|
|
||||||
<html>
|
|
||||||
<!--
|
|
||||||
== Copyright (c) 1996-1999
|
|
||||||
== Silicon Graphics Computer Systems, Inc.
|
|
||||||
==
|
|
||||||
== Permission to use, copy, modify, distribute and sell this software
|
|
||||||
== and its documentation for any purpose is hereby granted without fee,
|
|
||||||
== provided that the above copyright notice appears in all copies and
|
|
||||||
== that both that copyright notice and this permission notice appear
|
|
||||||
== in supporting documentation. Silicon Graphics makes no
|
|
||||||
== representations about the suitability of this software for any
|
|
||||||
== purpose. It is provided "as is" without express or implied warranty.
|
|
||||||
==
|
|
||||||
== Copyright (c) 1994
|
|
||||||
== Hewlett-Packard Company
|
|
||||||
==
|
|
||||||
== Permission to use, copy, modify, distribute and sell this software
|
|
||||||
== and its documentation for any purpose is hereby granted without fee,
|
|
||||||
== provided that the above copyright notice appears in all copies and
|
|
||||||
== that both that copyright notice and this permission notice appear
|
|
||||||
== in supporting documentation. Hewlett-Packard Company makes no
|
|
||||||
== representations about the suitability of this software for any
|
|
||||||
== purpose. It is provided "as is" without express or implied warranty.
|
|
||||||
==
|
|
||||||
-->
|
|
||||||
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Language" content="en-us">
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
|
|
||||||
|
|
||||||
<title>LessThanComparable</title>
|
|
||||||
</head>
|
|
||||||
|
|
||||||
<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
|
|
||||||
"#FF0000">
|
|
||||||
<img src="../../boost.png" alt="C++ Boost" width="277" height=
|
|
||||||
"86"><br clear="none">
|
|
||||||
|
|
||||||
<h1>LessThanComparable</h1>
|
|
||||||
|
|
||||||
<h3>Description</h3>
|
|
||||||
|
|
||||||
<p>A type is LessThanComparable if it is ordered: it must be possible to
|
|
||||||
compare two objects of that type using <tt>operator<</tt>, and
|
|
||||||
<tt>operator<</tt> must be a strict weak ordering relation.</p>
|
|
||||||
|
|
||||||
<h3>Refinement of</h3>
|
|
||||||
|
|
||||||
<h3>Associated types</h3>
|
|
||||||
|
|
||||||
<h3>Notation</h3>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>X</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">A type that is a model of LessThanComparable</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top"><tt>x</tt>, <tt>y</tt>, <tt>z</tt></td>
|
|
||||||
|
|
||||||
<td valign="top">Object of type <tt>X</tt></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Definitions</h3>
|
|
||||||
|
|
||||||
<p>Consider the relation <tt>!(x < y) && !(y < x)</tt>. If
|
|
||||||
this relation is transitive (that is, if <tt>!(x < y) && !(y
|
|
||||||
< x) && !(y < z) && !(z < y)</tt> implies <tt>!(x
|
|
||||||
< z) && !(z < x)</tt>), then it satisfies the mathematical
|
|
||||||
definition of an equivalence relation. In this case, <tt>operator<</tt>
|
|
||||||
is a <i>strict weak ordering</i>.</p>
|
|
||||||
|
|
||||||
<p>If <tt>operator<</tt> is a strict weak ordering, and if each
|
|
||||||
equivalence class has only a single element, then <tt>operator<</tt> is
|
|
||||||
a <i>total ordering</i>.</p>
|
|
||||||
|
|
||||||
<h3>Valid expressions</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Type requirements</th>
|
|
||||||
|
|
||||||
<th>Return type</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Less</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>x < y</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"> </td>
|
|
||||||
|
|
||||||
<td valign="top">Convertible to <tt>bool</tt></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Expression semantics</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Name</th>
|
|
||||||
|
|
||||||
<th>Expression</th>
|
|
||||||
|
|
||||||
<th>Precondition</th>
|
|
||||||
|
|
||||||
<th>Semantics</th>
|
|
||||||
|
|
||||||
<th>Postcondition</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Less</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>x < y</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>x</tt> and <tt>y</tt> are in the domain of
|
|
||||||
<tt><</tt></td>
|
|
||||||
|
|
||||||
<td valign="top"> </td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Complexity guarantees</h3>
|
|
||||||
|
|
||||||
<h3>Invariants</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Irreflexivity</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>x < x</tt> must be false.</td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Antisymmetry</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>x < y</tt> implies !(y < x) <a href=
|
|
||||||
"#n2">[2]</a></td>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td valign="top">Transitivity</td>
|
|
||||||
|
|
||||||
<td valign="top"><tt>x < y</tt> and <tt>y < z</tt> implies <tt>x
|
|
||||||
< z</tt> <a href="#n3">[3]</a></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Models</h3>
|
|
||||||
|
|
||||||
<ul>
|
|
||||||
<li>int</li>
|
|
||||||
</ul>
|
|
||||||
|
|
||||||
<h3>Notes</h3>
|
|
||||||
|
|
||||||
<p><a name="n1" id="n1">[1]</a> Only <tt>operator<</tt> is fundamental;
|
|
||||||
the other inequality operators are essentially syntactic sugar.</p>
|
|
||||||
|
|
||||||
<p><a name="n2" id="n2">[2]</a> Antisymmetry is a theorem, not an axiom: it
|
|
||||||
follows from irreflexivity and transitivity.</p>
|
|
||||||
|
|
||||||
<p><a name="n3" id="n3">[3]</a> Because of irreflexivity and transitivity,
|
|
||||||
<tt>operator<</tt> always satisfies the definition of a <i>partial
|
|
||||||
ordering</i>. The definition of a <i>strict weak ordering</i> is stricter,
|
|
||||||
and the definition of a <i>total ordering</i> is stricter still.</p>
|
|
||||||
|
|
||||||
<h3>See also</h3>
|
|
||||||
|
|
||||||
<p><a href=
|
|
||||||
"http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>,
|
|
||||||
<a href=
|
|
||||||
"http://www.sgi.com/tech/stl/StrictWeakOrdering.html">StrictWeakOrdering</a><br>
|
|
||||||
</p>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
|
||||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
|
||||||
height="31" width="88"></a></p>
|
|
||||||
|
|
||||||
<p>Revised
|
|
||||||
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
|
|
||||||
December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr valign="top">
|
|
||||||
<td nowrap><i>Copyright © 2000</i></td>
|
|
||||||
|
|
||||||
<td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
|
|
||||||
Notre Dame (<a href=
|
|
||||||
"mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<p><i>Distributed under the Boost Software License, Version 1.0. (See
|
|
||||||
accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
|
|
||||||
copy at <a href=
|
|
||||||
"http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,95 +0,0 @@
|
|||||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Language" content="en-us">
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
|
|
||||||
|
|
||||||
<title>MultiPassInputIterator</title>
|
|
||||||
</head>
|
|
||||||
|
|
||||||
<body bgcolor="#FFFFFF" link="#0000EE" text="#000000" vlink="#551A8B" alink=
|
|
||||||
"#FF0000">
|
|
||||||
<img src="../../boost.png" alt="C++ Boost" width="277" height=
|
|
||||||
"86"><br clear="none">
|
|
||||||
|
|
||||||
<h2><a name="concept:MultiPassInputIterator" id=
|
|
||||||
"concept:MultiPassInputIterator"></a> Multi-Pass Input Iterator</h2>
|
|
||||||
|
|
||||||
<p>This concept is a refinement of <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>, adding
|
|
||||||
the requirements that the iterator can be used to make multiple passes
|
|
||||||
through a range, and that if <tt>it1 == it2</tt> and <tt>it1</tt> is
|
|
||||||
dereferenceable then <tt>++it1 == ++it2</tt>. The Multi-Pass Input Iterator
|
|
||||||
is very similar to the <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>.
|
|
||||||
The only difference is that a <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/ForwardIterator.html">Forward Iterator</a>
|
|
||||||
requires the <tt>reference</tt> type to be <tt>value_type&</tt>,
|
|
||||||
whereas MultiPassInputIterator is like <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a> in that
|
|
||||||
the <tt>reference</tt> type merely has to be convertible to
|
|
||||||
<tt>value_type</tt>.</p>
|
|
||||||
|
|
||||||
<h3>Design Notes</h3>
|
|
||||||
|
|
||||||
<p>comments by Valentin Bonnard:</p>
|
|
||||||
|
|
||||||
<p>I think that introducing Multi-Pass Input Iterator isn't the right
|
|
||||||
solution. Do you also want to define Multi-Pass Bidirectionnal Iterator and
|
|
||||||
Multi-Pass Random Access Iterator ? I don't, definitly. It only confuses
|
|
||||||
the issue. The problem lies into the existing hierarchy of iterators, which
|
|
||||||
mixes movabillity, modifiabillity and lvalue-ness, and these are clearly
|
|
||||||
independant.</p>
|
|
||||||
|
|
||||||
<p>The terms Forward, Bidirectionnal and Random Access are about
|
|
||||||
movabillity and shouldn't be used to mean anything else. In a completly
|
|
||||||
orthogonal way, iterators can be immutable, mutable, or neither. Lvalueness
|
|
||||||
of iterators is also orthogonal with immutabillity. With these clean
|
|
||||||
concepts, your Multi-Pass Input Iterator is just called a Forward
|
|
||||||
Iterator.</p>
|
|
||||||
|
|
||||||
<p>Other translations are:<br>
|
|
||||||
std::Forward Iterator -> ForwardIterator & Lvalue Iterator<br>
|
|
||||||
std::Bidirectionnal Iterator -> Bidirectionnal Iterator & Lvalue
|
|
||||||
Iterator<br>
|
|
||||||
std::Random Access Iterator -> Random Access Iterator & Lvalue
|
|
||||||
Iterator<br></p>
|
|
||||||
|
|
||||||
<p>Note that in practice the only operation not allowed on my Forward
|
|
||||||
Iterator which is allowed on std::Forward Iterator is <tt>&*it</tt>. I
|
|
||||||
think that <tt>&*</tt> is rarely needed in generic code.</p>
|
|
||||||
|
|
||||||
<p>reply by Jeremy Siek:</p>
|
|
||||||
|
|
||||||
<p>The above analysis by Valentin is right on. Of course, there is the
|
|
||||||
problem with backward compatibility. The current STL implementations are
|
|
||||||
based on the old definition of Forward Iterator. The right course of action
|
|
||||||
is to get Forward Iterator, etc. changed in the C++ standard. Once that is
|
|
||||||
done we can drop Multi-Pass Input Iterator.<br></p>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
|
||||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
|
||||||
height="31" width="88"></a></p>
|
|
||||||
|
|
||||||
<p>Revised
|
|
||||||
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05
|
|
||||||
December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
|
|
||||||
|
|
||||||
<table summary="">
|
|
||||||
<tr valign="top">
|
|
||||||
<td nowrap><i>Copyright © 2000</i></td>
|
|
||||||
|
|
||||||
<td><i><a href="http://www.lsc.nd.edu/~jsiek">Jeremy Siek</a>, Univ.of
|
|
||||||
Notre Dame (<a href=
|
|
||||||
"mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</a>)</i></td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<p><i>Distributed under the Boost Software License, Version 1.0. (See
|
|
||||||
accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
|
|
||||||
copy at <a href=
|
|
||||||
"http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,159 +0,0 @@
|
|||||||
<HTML>
|
|
||||||
<Head>
|
|
||||||
<Title>OptionalPointee Concept</Title>
|
|
||||||
</HEAD>
|
|
||||||
<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
|
|
||||||
ALINK="#ff0000">
|
|
||||||
<IMG SRC="../../boost.png"
|
|
||||||
ALT="C++ Boost" width="277" height="86">
|
|
||||||
<!--end header-->
|
|
||||||
<BR Clear>
|
|
||||||
<H1>Concept: OptionalPointee</H1>
|
|
||||||
|
|
||||||
<h3>Description</h3>
|
|
||||||
A type is a model of <i>OptionalPointee</i> if it points to (or refers to) a value
|
|
||||||
that may not exist. That is, if it has a <b>pointee</b> which might be <b>valid</b>
|
|
||||||
(existent) or <b>invalid</b> (inexistent); and it is possible to test whether the
|
|
||||||
pointee is valid or not.
|
|
||||||
This model does <u>not</u> imply pointer semantics: i.e., it does not imply shallow copy nor
|
|
||||||
aliasing.
|
|
||||||
<h3>Notation</h3>
|
|
||||||
<Table>
|
|
||||||
<TR>
|
|
||||||
<TD VAlign=top> <tt>T</tt> </TD>
|
|
||||||
<TD VAlign=top> is a type that is a model of OptionalPointee</TD>
|
|
||||||
</TR>
|
|
||||||
<TR>
|
|
||||||
<TD VAlign=top> <tt>t</tt> </TD>
|
|
||||||
<TD VAlign=top> is an object of type <tt>T</tt> or possibly <tt>const T</tt></TD>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
<h3>Definitions</h3>
|
|
||||||
<h3>Valid expressions</h3>
|
|
||||||
<Table border>
|
|
||||||
<TR>
|
|
||||||
<TH> Name </TH>
|
|
||||||
<TH> Expression </TH>
|
|
||||||
<TH> Return type </TH>
|
|
||||||
<TH> Semantics </TH>
|
|
||||||
</TR>
|
|
||||||
<TR>
|
|
||||||
<TD VAlign=top>Value Access</TD>
|
|
||||||
<TD VAlign=top> <tt>*t</tt></TD>
|
|
||||||
<TD VAlign=top> <tt>T&</tt></TD>
|
|
||||||
<TD VAlign=top>If the pointee is valid returns a reference to
|
|
||||||
the pointee.<br>
|
|
||||||
If the pointee is invalid the result is <i>undefined</i>.</TD>
|
|
||||||
<TD VAlign=top> </TD>
|
|
||||||
</TR>
|
|
||||||
<TR>
|
|
||||||
<TD VAlign=top>Value Access</TD>
|
|
||||||
<TD VAlign=top> <tt>t-><i>xyz</i></tt></TD>
|
|
||||||
<TD VAlign=top> <tt>T*</tt></TD>
|
|
||||||
<TD VAlign=top>If the pointee is valid returns a builtin pointer to the pointee.<br>
|
|
||||||
If the pointee is invalid the result is <i>undefined</i> (It might not even return NULL).<br>
|
|
||||||
</TD>
|
|
||||||
<TD VAlign=top> </TD>
|
|
||||||
</TR>
|
|
||||||
<TR>
|
|
||||||
<TD VAlign=top>Validity Test</TD>
|
|
||||||
<TD VAlign=top> <tt>bool(t)</tt></TD>
|
|
||||||
<TD VAlign=top> bool </TD>
|
|
||||||
<TD VAlign=top>If the pointee is valid returns true.<br>
|
|
||||||
If the pointee is invalid returns false.</TD>
|
|
||||||
<TD VAlign=top></TD>
|
|
||||||
</TR>
|
|
||||||
<TR>
|
|
||||||
<TD VAlign=top>Invalidity Test</TD>
|
|
||||||
<TD VAlign=top> <tt>!t</tt></TD>
|
|
||||||
<TD VAlign=top> bool </TD>
|
|
||||||
<TD VAlign=top>If the pointee is valid returns false.<br>
|
|
||||||
If the pointee is invalid returns true.</TD>
|
|
||||||
<TD VAlign=top></TD>
|
|
||||||
</TR>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
|
|
||||||
<h3>Models</h3>
|
|
||||||
|
|
||||||
<UL>
|
|
||||||
<LI><tt>pointers, both builtin and smart.</tt>
|
|
||||||
<LI><tt>boost::optional<></tt>
|
|
||||||
</UL>
|
|
||||||
|
|
||||||
<HR>
|
|
||||||
<h3>OptionalPointee and relational operations</h3>
|
|
||||||
<p>This concept does not define any particular semantic for relational operations, therefore,
|
|
||||||
a type which models this concept might have either shallow or deep relational semantics.<br>
|
|
||||||
For instance, pointers, which are models of OptionalPointee, have shallow relational operators:
|
|
||||||
comparisons of pointers do not involve comparisons of pointees.
|
|
||||||
This makes sense for pointers because they have shallow copy semantics.<br>
|
|
||||||
But boost::optional<T>, on the other hand, which is also a model of OptionalPointee, has
|
|
||||||
deep-copy and deep-relational semantics.<br>
|
|
||||||
If generic code is written for this concept, it is important not to use relational
|
|
||||||
operators directly because the semantics might be different depending on the actual type.<br>
|
|
||||||
Still, the concept itsef can be used to define <i>deep</i> relational tests that can
|
|
||||||
be used in generic code with any type which models OptionalPointee:</p>
|
|
||||||
<a name="equal"></a>
|
|
||||||
<p><u>Equivalence relation:</u></p>
|
|
||||||
<pre>template<class OptionalPointee>
|
|
||||||
inline
|
|
||||||
bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
|
|
||||||
{
|
|
||||||
return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
|
|
||||||
}
|
|
||||||
template<class OptionalPointee>
|
|
||||||
struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
|
|
||||||
{
|
|
||||||
bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
|
|
||||||
{ return equal_pointees(x,y) ; }
|
|
||||||
} ;
|
|
||||||
</pre>
|
|
||||||
<p>The preceding generic function and function object have the following semantics:<br>
|
|
||||||
If both <b>x</b> and <b>y</b> have valid pointees, it compares values via <code>(*x == *y)</code>.<br>
|
|
||||||
If only one has a valid pointee, returns <code>false</code>.<br>
|
|
||||||
If both have invalid pointees, returns <code>true</code>.</p>
|
|
||||||
<a name="less"></a>
|
|
||||||
<p><u>Less-than relation:</u></p>
|
|
||||||
<pre>template<class OptionalPointee>
|
|
||||||
inline
|
|
||||||
bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
|
|
||||||
{
|
|
||||||
return !y ? false : ( !x ? true : (*x) < (*y) ) ;
|
|
||||||
}
|
|
||||||
template<class OptionalPointee>
|
|
||||||
struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
|
|
||||||
{
|
|
||||||
bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
|
|
||||||
{ return less_pointees(x,y) ; }
|
|
||||||
} ;
|
|
||||||
</pre>
|
|
||||||
<p>The preceding generic function and function object have the following semantics:<br>
|
|
||||||
If <b>y</b> has an invalid pointee, returns <code>false</code>.<br>
|
|
||||||
Else, if <b>x</b> has an invalid pointee, returns <code>true</code>.<br>
|
|
||||||
Else, ( <b>x</b> and <b>y</b> have valid pointees), compares values via <code>(*x <
|
|
||||||
*y).</code></p>
|
|
||||||
<p><br>
|
|
||||||
All these functions and function
|
|
||||||
objects are is implemented in <a href="../../boost/utility/compare_pointees.hpp">compare_pointees.hpp</a></p>
|
|
||||||
<p>Notice that OptionalPointee does not imply aliasing (and optional<> for instance does not alias);
|
|
||||||
so direct usage of relational operators with the implied aliasing of shallow semantics
|
|
||||||
-as with pointers- should not be used with generic code written for this concept.</p>
|
|
||||||
|
|
||||||
<h3>Acknowledgements</h3>
|
|
||||||
<p>Based on the original concept developed by Augustus Saunders.
|
|
||||||
|
|
||||||
<br>
|
|
||||||
</p>
|
|
||||||
<HR>
|
|
||||||
<TABLE>
|
|
||||||
<TR valign=top>
|
|
||||||
<TD nowrap>Copyright © 2003</TD><TD>
|
|
||||||
<A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>
|
|
||||||
</TD></TR></TABLE>
|
|
||||||
|
|
||||||
<p>Distributed under the Boost Software License, Version 1.0. See
|
|
||||||
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
|
|
||||||
|
|
||||||
</BODY>
|
|
||||||
</HTML>
|
|
||||||
423
algo_opt_examples.cpp
Normal file
423
algo_opt_examples.cpp
Normal file
@@ -0,0 +1,423 @@
|
|||||||
|
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Copyright (c) 1999
|
||||||
|
* Dr John Maddock
|
||||||
|
*
|
||||||
|
* Permission to use, copy, modify, distribute and sell this software
|
||||||
|
* and its documentation for any purpose is hereby granted without fee,
|
||||||
|
* provided that the above copyright notice appear in all copies and
|
||||||
|
* that both that copyright notice and this permission notice appear
|
||||||
|
* in supporting documentation. Dr John Maddock makes no representations
|
||||||
|
* about the suitability of this software for any purpose.
|
||||||
|
* It is provided "as is" without express or implied warranty.
|
||||||
|
*
|
||||||
|
* This file provides some example of type_traits usage -
|
||||||
|
* by "optimising" various algorithms:
|
||||||
|
*
|
||||||
|
* opt::copy - optimised for trivial copy (cf std::copy)
|
||||||
|
* opt::fill - optimised for trivial copy/small types (cf std::fill)
|
||||||
|
* opt::destroy_array - an example of optimisation based upon omitted destructor calls
|
||||||
|
* opt::iter_swap - uses type_traits to determine whether the iterator is a proxy
|
||||||
|
* in which case it uses a "safe" approach, otherwise calls swap
|
||||||
|
* on the assumption that swap may be specialised for the pointed-to type.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Release notes:
|
||||||
|
23rd July 2000:
|
||||||
|
Added explicit failure for broken compilers that don't support these examples.
|
||||||
|
Fixed broken gcc support (broken using directive).
|
||||||
|
Reordered tests slightly.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <typeinfo>
|
||||||
|
#include <algorithm>
|
||||||
|
#include <iterator>
|
||||||
|
#include <vector>
|
||||||
|
#include <memory>
|
||||||
|
|
||||||
|
#include <boost/timer.hpp>
|
||||||
|
#include <boost/type_traits.hpp>
|
||||||
|
#include <boost/call_traits.hpp>
|
||||||
|
|
||||||
|
using std::cout;
|
||||||
|
using std::endl;
|
||||||
|
using std::cin;
|
||||||
|
|
||||||
|
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
|
#error "Sorry, without template partial specialisation support there isn't anything to test here..."
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace opt{
|
||||||
|
|
||||||
|
//
|
||||||
|
// algorithm destroy_array:
|
||||||
|
// The reverse of std::unitialized_copy, takes a block of
|
||||||
|
// unitialized memory and calls destructors on all objects therein.
|
||||||
|
//
|
||||||
|
|
||||||
|
namespace detail{
|
||||||
|
|
||||||
|
template <bool>
|
||||||
|
struct array_destroyer
|
||||||
|
{
|
||||||
|
template <class T>
|
||||||
|
static void destroy_array(T* i, T* j){ do_destroy_array(i, j); }
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct array_destroyer<true>
|
||||||
|
{
|
||||||
|
template <class T>
|
||||||
|
static void destroy_array(T*, T*){}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
void do_destroy_array(T* first, T* last)
|
||||||
|
{
|
||||||
|
while(first != last)
|
||||||
|
{
|
||||||
|
first->~T();
|
||||||
|
++first;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}; // namespace detail
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
inline void destroy_array(T* p1, T* p2)
|
||||||
|
{
|
||||||
|
detail::array_destroyer<boost::has_trivial_destructor<T>::value>::destroy_array(p1, p2);
|
||||||
|
}
|
||||||
|
|
||||||
|
//
|
||||||
|
// unoptimised versions of destroy_array:
|
||||||
|
//
|
||||||
|
template <class T>
|
||||||
|
void destroy_array1(T* first, T* last)
|
||||||
|
{
|
||||||
|
while(first != last)
|
||||||
|
{
|
||||||
|
first->~T();
|
||||||
|
++first;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
template <class T>
|
||||||
|
void destroy_array2(T* first, T* last)
|
||||||
|
{
|
||||||
|
for(; first != last; ++first) first->~T();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//
|
||||||
|
// opt::copy
|
||||||
|
// same semantics as std::copy
|
||||||
|
// calls memcpy where appropiate.
|
||||||
|
//
|
||||||
|
|
||||||
|
namespace detail{
|
||||||
|
|
||||||
|
template <bool b>
|
||||||
|
struct copier
|
||||||
|
{
|
||||||
|
template<typename I1, typename I2>
|
||||||
|
static I2 do_copy(I1 first, I1 last, I2 out);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <bool b>
|
||||||
|
template<typename I1, typename I2>
|
||||||
|
I2 copier<b>::do_copy(I1 first, I1 last, I2 out)
|
||||||
|
{
|
||||||
|
while(first != last)
|
||||||
|
{
|
||||||
|
*out = *first;
|
||||||
|
++out;
|
||||||
|
++first;
|
||||||
|
}
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct copier<true>
|
||||||
|
{
|
||||||
|
template<typename I1, typename I2>
|
||||||
|
static I2* do_copy(I1* first, I1* last, I2* out)
|
||||||
|
{
|
||||||
|
memcpy(out, first, (last-first)*sizeof(I2));
|
||||||
|
return out+(last-first);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename I1, typename I2>
|
||||||
|
inline I2 copy(I1 first, I1 last, I2 out)
|
||||||
|
{
|
||||||
|
typedef typename boost::remove_cv<typename std::iterator_traits<I1>::value_type>::type v1_t;
|
||||||
|
typedef typename boost::remove_cv<typename std::iterator_traits<I2>::value_type>::type v2_t;
|
||||||
|
enum{ can_opt = boost::is_same<v1_t, v2_t>::value
|
||||||
|
&& boost::is_pointer<I1>::value
|
||||||
|
&& boost::is_pointer<I2>::value
|
||||||
|
&& boost::has_trivial_assign<v1_t>::value };
|
||||||
|
return detail::copier<can_opt>::do_copy(first, last, out);
|
||||||
|
}
|
||||||
|
|
||||||
|
//
|
||||||
|
// fill
|
||||||
|
// same as std::fill, uses memset where appropriate, along with call_traits
|
||||||
|
// to "optimise" parameter passing.
|
||||||
|
//
|
||||||
|
namespace detail{
|
||||||
|
|
||||||
|
template <bool opt>
|
||||||
|
struct filler
|
||||||
|
{
|
||||||
|
template <typename I, typename T>
|
||||||
|
static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <bool b>
|
||||||
|
template <typename I, typename T>
|
||||||
|
void filler<b>::do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
|
||||||
|
{
|
||||||
|
while(first != last)
|
||||||
|
{
|
||||||
|
*first = val;
|
||||||
|
++first;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct filler<true>
|
||||||
|
{
|
||||||
|
template <typename I, typename T>
|
||||||
|
static void do_fill(I first, I last, T val)
|
||||||
|
{
|
||||||
|
memset(first, val, last-first);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
template <class I, class T>
|
||||||
|
inline void fill(I first, I last, const T& val)
|
||||||
|
{
|
||||||
|
enum{ can_opt = boost::is_pointer<I>::value
|
||||||
|
&& boost::is_arithmetic<T>::value
|
||||||
|
&& (sizeof(T) == 1) };
|
||||||
|
typedef detail::filler<can_opt> filler_t;
|
||||||
|
filler_t::template do_fill<I,T>(first, last, val);
|
||||||
|
}
|
||||||
|
|
||||||
|
//
|
||||||
|
// iter_swap:
|
||||||
|
// tests whether iterator is a proxying iterator or not, and
|
||||||
|
// uses optimal form accordingly:
|
||||||
|
//
|
||||||
|
namespace detail{
|
||||||
|
|
||||||
|
template <bool b>
|
||||||
|
struct swapper
|
||||||
|
{
|
||||||
|
template <typename I>
|
||||||
|
static void do_swap(I one, I two)
|
||||||
|
{
|
||||||
|
typedef typename std::iterator_traits<I>::value_type v_t;
|
||||||
|
v_t v = *one;
|
||||||
|
*one = *two;
|
||||||
|
*two = v;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#ifdef __GNUC__
|
||||||
|
using std::swap;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct swapper<true>
|
||||||
|
{
|
||||||
|
template <typename I>
|
||||||
|
static void do_swap(I one, I two)
|
||||||
|
{
|
||||||
|
using std::swap;
|
||||||
|
swap(*one, *two);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename I1, typename I2>
|
||||||
|
inline void iter_swap(I1 one, I2 two)
|
||||||
|
{
|
||||||
|
typedef typename std::iterator_traits<I1>::reference r1_t;
|
||||||
|
typedef typename std::iterator_traits<I2>::reference r2_t;
|
||||||
|
enum{ can_opt = boost::is_reference<r1_t>::value && boost::is_reference<r2_t>::value && boost::is_same<r1_t, r2_t>::value };
|
||||||
|
detail::swapper<can_opt>::do_swap(one, two);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}; // namespace opt
|
||||||
|
|
||||||
|
//
|
||||||
|
// define some global data:
|
||||||
|
//
|
||||||
|
const int array_size = 1000;
|
||||||
|
int i_array[array_size] = {0,};
|
||||||
|
const int ci_array[array_size] = {0,};
|
||||||
|
char c_array[array_size] = {0,};
|
||||||
|
const char cc_array[array_size] = { 0,};
|
||||||
|
|
||||||
|
const int iter_count = 1000000;
|
||||||
|
|
||||||
|
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
//
|
||||||
|
// test destroy_array,
|
||||||
|
// compare destruction time of an array of ints
|
||||||
|
// with unoptimised form.
|
||||||
|
//
|
||||||
|
cout << "Measuring times in micro-seconds per 1000 elements processed" << endl << endl;
|
||||||
|
cout << "testing destroy_array...\n"
|
||||||
|
"[Some compilers may be able to optimise the \"unoptimised\"\n versions as well as type_traits does.]" << endl;
|
||||||
|
/*cache load*/ opt::destroy_array(i_array, i_array + array_size);
|
||||||
|
boost::timer t;
|
||||||
|
double result;
|
||||||
|
int i;
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::destroy_array(i_array, i_array + array_size);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "destroy_array<int>: " << result << endl;
|
||||||
|
/*cache load*/ opt::destroy_array1(i_array, i_array + array_size);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::destroy_array1(i_array, i_array + array_size);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "destroy_array<int>(unoptimised#1): " << result << endl;
|
||||||
|
/*cache load*/ opt::destroy_array2(i_array, i_array + array_size);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::destroy_array2(i_array, i_array + array_size);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "destroy_array<int>(unoptimised#2): " << result << endl << endl;
|
||||||
|
|
||||||
|
cout << "testing fill(char)...\n"
|
||||||
|
"[Some standard library versions may already perform this optimisation.]" << endl;
|
||||||
|
/*cache load*/ opt::fill<char*, char>(c_array, c_array + array_size, (char)3);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::fill<char*, char>(c_array, c_array + array_size, (char)3);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "opt::fill<char*, char>: " << result << endl;
|
||||||
|
/*cache load*/ std::fill(c_array, c_array + array_size, (char)3);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
std::fill(c_array, c_array + array_size, (char)3);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "std::fill<char*, char>: " << result << endl << endl;
|
||||||
|
|
||||||
|
cout << "testing fill(int)...\n"
|
||||||
|
"[Tests the effect of call_traits pass-by-value optimisation -\nthe value of this optimisation may depend upon hardware characteristics.]" << endl;
|
||||||
|
/*cache load*/ opt::fill<int*, int>(i_array, i_array + array_size, 3);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::fill<int*, int>(i_array, i_array + array_size, 3);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "opt::fill<int*, int>: " << result << endl;
|
||||||
|
/*cache load*/ std::fill(i_array, i_array + array_size, 3);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
std::fill(i_array, i_array + array_size, 3);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "std::fill<int*, int>: " << result << endl << endl;
|
||||||
|
|
||||||
|
cout << "testing copy...\n"
|
||||||
|
"[Some standard library versions may already perform this optimisation.]" << endl;
|
||||||
|
/*cache load*/ opt::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "opt::copy<const int*, int*>: " << result << endl;
|
||||||
|
/*cache load*/ std::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
std::copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "std::copy<const int*, int*>: " << result << endl;
|
||||||
|
/*cache load*/ opt::detail::copier<false>::template do_copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::detail::copier<false>::template do_copy<const int*, int*>(ci_array, ci_array + array_size, i_array);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "standard \"unoptimised\" copy: " << result << endl << endl;
|
||||||
|
|
||||||
|
/*cache load*/ opt::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "opt::copy<const char*, char*>: " << result << endl;
|
||||||
|
/*cache load*/ std::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
std::copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "std::copy<const char*, char*>: " << result << endl;
|
||||||
|
/*cache load*/ opt::detail::copier<false>::template do_copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
|
||||||
|
t.restart();
|
||||||
|
for(i = 0; i < iter_count; ++i)
|
||||||
|
{
|
||||||
|
opt::detail::copier<false>::template do_copy<const char*, char*>(cc_array, cc_array + array_size, c_array);
|
||||||
|
}
|
||||||
|
result = t.elapsed();
|
||||||
|
cout << "standard \"unoptimised\" copy: " << result << endl << endl;
|
||||||
|
|
||||||
|
|
||||||
|
//
|
||||||
|
// testing iter_swap
|
||||||
|
// really just a check that it does in fact compile...
|
||||||
|
std::vector<int> v1;
|
||||||
|
v1.push_back(0);
|
||||||
|
v1.push_back(1);
|
||||||
|
std::vector<bool> v2;
|
||||||
|
v2.push_back(0);
|
||||||
|
v2.push_back(1);
|
||||||
|
opt::iter_swap(v1.begin(), v1.begin()+1);
|
||||||
|
opt::iter_swap(v2.begin(), v2.begin()+1);
|
||||||
|
|
||||||
|
cout << "Press any key to exit...";
|
||||||
|
cin.get();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@@ -1,29 +0,0 @@
|
|||||||
//
|
|
||||||
// Test that a base_from_member<T&> can be properly constructed
|
|
||||||
//
|
|
||||||
// Copyright 2014 Agustin Berge
|
|
||||||
//
|
|
||||||
// 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/utility/base_from_member.hpp>
|
|
||||||
|
|
||||||
#include <boost/detail/lightweight_test.hpp>
|
|
||||||
|
|
||||||
struct foo : boost::base_from_member<int&>
|
|
||||||
{
|
|
||||||
explicit foo(int& ref) : boost::base_from_member<int&>(ref)
|
|
||||||
{
|
|
||||||
BOOST_TEST(&member == &ref);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
int i = 0;
|
|
||||||
foo f(i);
|
|
||||||
|
|
||||||
return boost::report_errors();
|
|
||||||
}
|
|
||||||
@@ -1,595 +0,0 @@
|
|||||||
// Boost test program for base-from-member class templates -----------------//
|
|
||||||
|
|
||||||
// Copyright 2001, 2003 Daryle Walker. Use, modification, and distribution are
|
|
||||||
// subject to the Boost Software License, Version 1.0. (See accompanying file
|
|
||||||
// LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
|
|
||||||
|
|
||||||
// See <http://www.boost.org/libs/utility/> for the library's home page.
|
|
||||||
|
|
||||||
// Revision History
|
|
||||||
// 14 Jun 2003 Adjusted code for Boost.Test changes (Daryle Walker)
|
|
||||||
// 29 Aug 2001 Initial Version (Daryle Walker)
|
|
||||||
|
|
||||||
#include <boost/test/minimal.hpp> // for BOOST_CHECK, main
|
|
||||||
|
|
||||||
#include <boost/config.hpp> // for BOOST_NO_MEMBER_TEMPLATES
|
|
||||||
#include <boost/cstdlib.hpp> // for boost::exit_success
|
|
||||||
#include <boost/noncopyable.hpp> // for boost::noncopyable
|
|
||||||
|
|
||||||
#include <boost/utility/base_from_member.hpp> // for boost::base_from_member
|
|
||||||
|
|
||||||
#include <functional> // for std::binary_function, std::less
|
|
||||||
#include <iostream> // for std::cout (std::ostream, std::endl indirectly)
|
|
||||||
#include <set> // for std::set
|
|
||||||
#include <typeinfo> // for std::type_info
|
|
||||||
#include <utility> // for std::pair, std::make_pair
|
|
||||||
#include <vector> // for std::vector
|
|
||||||
|
|
||||||
|
|
||||||
// Control if extra information is printed
|
|
||||||
#ifndef CONTROL_EXTRA_PRINTING
|
|
||||||
#define CONTROL_EXTRA_PRINTING 1
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
// A (sub)object can be identified by its memory location and its type.
|
|
||||||
// Both are needed since an object can start at the same place as its
|
|
||||||
// first base class subobject and/or contained subobject.
|
|
||||||
typedef std::pair< void *, std::type_info const * > object_id;
|
|
||||||
|
|
||||||
// Object IDs need to be printed
|
|
||||||
std::ostream & operator <<( std::ostream &os, object_id const &oi );
|
|
||||||
|
|
||||||
// A way to generate an object ID
|
|
||||||
template < typename T >
|
|
||||||
object_id identify( T &obj );
|
|
||||||
|
|
||||||
// A custom comparison type is needed
|
|
||||||
struct object_id_compare
|
|
||||||
: std::binary_function<object_id, object_id, bool>
|
|
||||||
{
|
|
||||||
bool operator ()( object_id const &a, object_id const &b ) const;
|
|
||||||
|
|
||||||
}; // object_id_compare
|
|
||||||
|
|
||||||
// A singleton of this type coordinates the acknowledgements
|
|
||||||
// of objects being created and used.
|
|
||||||
class object_registrar
|
|
||||||
: private boost::noncopyable
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_MEMBER_TEMPLATES
|
|
||||||
template < typename T >
|
|
||||||
void register_object( T &obj )
|
|
||||||
{ this->register_object_imp( identify(obj) ); }
|
|
||||||
template < typename T, typename U >
|
|
||||||
void register_use( T &owner, U &owned )
|
|
||||||
{ this->register_use_imp( identify(owner), identify(owned) ); }
|
|
||||||
template < typename T, typename U >
|
|
||||||
void unregister_use( T &owner, U &owned )
|
|
||||||
{ this->unregister_use_imp( identify(owner), identify(owned) ); }
|
|
||||||
template < typename T >
|
|
||||||
void unregister_object( T &obj )
|
|
||||||
{ this->unregister_object_imp( identify(obj) ); }
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void register_object_imp( object_id obj );
|
|
||||||
void register_use_imp( object_id owner, object_id owned );
|
|
||||||
void unregister_use_imp( object_id owner, object_id owned );
|
|
||||||
void unregister_object_imp( object_id obj );
|
|
||||||
|
|
||||||
typedef std::set<object_id, object_id_compare> set_type;
|
|
||||||
|
|
||||||
typedef std::vector<object_id> error_record_type;
|
|
||||||
typedef std::vector< std::pair<object_id, object_id> > error_pair_type;
|
|
||||||
|
|
||||||
set_type db_;
|
|
||||||
|
|
||||||
error_pair_type defrauders_in_, defrauders_out_;
|
|
||||||
error_record_type overeager_, overkilled_;
|
|
||||||
|
|
||||||
}; // object_registrar
|
|
||||||
|
|
||||||
// A sample type to be used by containing types
|
|
||||||
class base_or_member
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
explicit base_or_member( int x = 1, double y = -0.25 );
|
|
||||||
~base_or_member();
|
|
||||||
|
|
||||||
}; // base_or_member
|
|
||||||
|
|
||||||
// A sample type that uses base_or_member, used
|
|
||||||
// as a base for the main demonstration classes
|
|
||||||
class base_class
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
explicit base_class( base_or_member &x, base_or_member *y = 0,
|
|
||||||
base_or_member *z = 0 );
|
|
||||||
|
|
||||||
~base_class();
|
|
||||||
|
|
||||||
private:
|
|
||||||
base_or_member *x_, *y_, *z_;
|
|
||||||
|
|
||||||
}; // base_class
|
|
||||||
|
|
||||||
// This bad class demonstrates the direct method of a base class needing
|
|
||||||
// to be initialized by a member. This is improper since the member
|
|
||||||
// isn't initialized until after the base class.
|
|
||||||
class bad_class
|
|
||||||
: public base_class
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
bad_class();
|
|
||||||
~bad_class();
|
|
||||||
|
|
||||||
private:
|
|
||||||
base_or_member x_;
|
|
||||||
|
|
||||||
}; // bad_class
|
|
||||||
|
|
||||||
// The first good class demonstrates the correct way to initialize a
|
|
||||||
// base class with a member. The member is changed to another base
|
|
||||||
// class, one that is initialized before the base that needs it.
|
|
||||||
class good_class_1
|
|
||||||
: private boost::base_from_member<base_or_member>
|
|
||||||
, public base_class
|
|
||||||
{
|
|
||||||
typedef boost::base_from_member<base_or_member> pbase_type;
|
|
||||||
typedef base_class base_type;
|
|
||||||
|
|
||||||
public:
|
|
||||||
good_class_1();
|
|
||||||
~good_class_1();
|
|
||||||
|
|
||||||
}; // good_class_1
|
|
||||||
|
|
||||||
// The second good class also demonstrates the correct way to initialize
|
|
||||||
// base classes with other subobjects. This class uses the other helpers
|
|
||||||
// in the library, and shows the technique of using two base subobjects
|
|
||||||
// of the "same" type.
|
|
||||||
class good_class_2
|
|
||||||
: private boost::base_from_member<base_or_member, 0>
|
|
||||||
, private boost::base_from_member<base_or_member, 1>
|
|
||||||
, private boost::base_from_member<base_or_member, 2>
|
|
||||||
, public base_class
|
|
||||||
{
|
|
||||||
typedef boost::base_from_member<base_or_member, 0> pbase_type0;
|
|
||||||
typedef boost::base_from_member<base_or_member, 1> pbase_type1;
|
|
||||||
typedef boost::base_from_member<base_or_member, 2> pbase_type2;
|
|
||||||
typedef base_class base_type;
|
|
||||||
|
|
||||||
public:
|
|
||||||
good_class_2();
|
|
||||||
~good_class_2();
|
|
||||||
|
|
||||||
}; // good_class_2
|
|
||||||
|
|
||||||
// Declare/define the single object registrar
|
|
||||||
object_registrar obj_reg;
|
|
||||||
|
|
||||||
|
|
||||||
// Main functionality
|
|
||||||
int
|
|
||||||
test_main( int , char * [] )
|
|
||||||
{
|
|
||||||
BOOST_CHECK( obj_reg.db_.empty() );
|
|
||||||
BOOST_CHECK( obj_reg.defrauders_in_.empty() );
|
|
||||||
BOOST_CHECK( obj_reg.defrauders_out_.empty() );
|
|
||||||
BOOST_CHECK( obj_reg.overeager_.empty() );
|
|
||||||
BOOST_CHECK( obj_reg.overkilled_.empty() );
|
|
||||||
|
|
||||||
// Make a separate block to examine pre- and post-effects
|
|
||||||
{
|
|
||||||
using std::cout;
|
|
||||||
using std::endl;
|
|
||||||
|
|
||||||
bad_class bc;
|
|
||||||
BOOST_CHECK( obj_reg.db_.size() == 3 );
|
|
||||||
BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
|
|
||||||
|
|
||||||
good_class_1 gc1;
|
|
||||||
BOOST_CHECK( obj_reg.db_.size() == 6 );
|
|
||||||
BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
|
|
||||||
|
|
||||||
good_class_2 gc2;
|
|
||||||
BOOST_CHECK( obj_reg.db_.size() == 11 );
|
|
||||||
BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
|
|
||||||
|
|
||||||
BOOST_CHECK( obj_reg.defrauders_out_.empty() );
|
|
||||||
BOOST_CHECK( obj_reg.overeager_.empty() );
|
|
||||||
BOOST_CHECK( obj_reg.overkilled_.empty() );
|
|
||||||
|
|
||||||
// Getting the addresses of the objects ensure
|
|
||||||
// that they're used, and not optimized away.
|
|
||||||
cout << "Object 'bc' is at " << &bc << '.' << endl;
|
|
||||||
cout << "Object 'gc1' is at " << &gc1 << '.' << endl;
|
|
||||||
cout << "Object 'gc2' is at " << &gc2 << '.' << endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CHECK( obj_reg.db_.empty() );
|
|
||||||
BOOST_CHECK( obj_reg.defrauders_in_.size() == 1 );
|
|
||||||
BOOST_CHECK( obj_reg.defrauders_out_.size() == 1 );
|
|
||||||
BOOST_CHECK( obj_reg.overeager_.empty() );
|
|
||||||
BOOST_CHECK( obj_reg.overkilled_.empty() );
|
|
||||||
|
|
||||||
return boost::exit_success;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Print an object's ID
|
|
||||||
std::ostream &
|
|
||||||
operator <<
|
|
||||||
(
|
|
||||||
std::ostream & os,
|
|
||||||
object_id const & oi
|
|
||||||
)
|
|
||||||
{
|
|
||||||
// I had an std::ostringstream to help, but I did not need it since
|
|
||||||
// the program never screws around with formatting. Worse, using
|
|
||||||
// std::ostringstream is an issue with some compilers.
|
|
||||||
|
|
||||||
return os << '[' << ( oi.second ? oi.second->name() : "NOTHING" )
|
|
||||||
<< " at " << oi.first << ']';
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get an object ID given an object
|
|
||||||
template < typename T >
|
|
||||||
inline
|
|
||||||
object_id
|
|
||||||
identify
|
|
||||||
(
|
|
||||||
T & obj
|
|
||||||
)
|
|
||||||
{
|
|
||||||
return std::make_pair( static_cast<void *>(&obj), &(typeid( obj )) );
|
|
||||||
}
|
|
||||||
|
|
||||||
// Compare two object IDs
|
|
||||||
bool
|
|
||||||
object_id_compare::operator ()
|
|
||||||
(
|
|
||||||
object_id const & a,
|
|
||||||
object_id const & b
|
|
||||||
) const
|
|
||||||
{
|
|
||||||
std::less<void *> vp_cmp;
|
|
||||||
if ( vp_cmp(a.first, b.first) )
|
|
||||||
{
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
else if ( vp_cmp(b.first, a.first) )
|
|
||||||
{
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
// object pointers are equal, compare the types
|
|
||||||
if ( a.second == b.second )
|
|
||||||
{
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
else if ( !a.second )
|
|
||||||
{
|
|
||||||
return true; // NULL preceeds anything else
|
|
||||||
}
|
|
||||||
else if ( !b.second )
|
|
||||||
{
|
|
||||||
return false; // NULL preceeds anything else
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
return a.second->before( *b.second ) != 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Let an object register its existence
|
|
||||||
void
|
|
||||||
object_registrar::register_object_imp
|
|
||||||
(
|
|
||||||
object_id obj
|
|
||||||
)
|
|
||||||
{
|
|
||||||
if ( db_.count(obj) <= 0 )
|
|
||||||
{
|
|
||||||
db_.insert( obj );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "Registered " << obj << '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
overeager_.push_back( obj );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "Attempted to register a non-existant " << obj
|
|
||||||
<< '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Let an object register its use of another object
|
|
||||||
void
|
|
||||||
object_registrar::register_use_imp
|
|
||||||
(
|
|
||||||
object_id owner,
|
|
||||||
object_id owned
|
|
||||||
)
|
|
||||||
{
|
|
||||||
if ( db_.count(owned) > 0 )
|
|
||||||
{
|
|
||||||
// We don't care to record usage registrations
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
defrauders_in_.push_back( std::make_pair(owner, owned) );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "Attempted to own a non-existant " << owned
|
|
||||||
<< " by " << owner << '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Let an object un-register its use of another object
|
|
||||||
void
|
|
||||||
object_registrar::unregister_use_imp
|
|
||||||
(
|
|
||||||
object_id owner,
|
|
||||||
object_id owned
|
|
||||||
)
|
|
||||||
{
|
|
||||||
if ( db_.count(owned) > 0 )
|
|
||||||
{
|
|
||||||
// We don't care to record usage un-registrations
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
defrauders_out_.push_back( std::make_pair(owner, owned) );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "Attempted to disown a non-existant " << owned
|
|
||||||
<< " by " << owner << '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Let an object un-register its existence
|
|
||||||
void
|
|
||||||
object_registrar::unregister_object_imp
|
|
||||||
(
|
|
||||||
object_id obj
|
|
||||||
)
|
|
||||||
{
|
|
||||||
set_type::iterator const i = db_.find( obj );
|
|
||||||
|
|
||||||
if ( i != db_.end() )
|
|
||||||
{
|
|
||||||
db_.erase( i );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "Unregistered " << obj << '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
overkilled_.push_back( obj );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "Attempted to unregister a non-existant " << obj
|
|
||||||
<< '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Macros to abstract the registration of objects
|
|
||||||
#ifndef BOOST_NO_MEMBER_TEMPLATES
|
|
||||||
#define PRIVATE_REGISTER_BIRTH(o) obj_reg.register_object( (o) )
|
|
||||||
#define PRIVATE_REGISTER_DEATH(o) obj_reg.unregister_object( (o) )
|
|
||||||
#define PRIVATE_REGISTER_USE(o, w) obj_reg.register_use( (o), (w) )
|
|
||||||
#define PRIVATE_UNREGISTER_USE(o, w) obj_reg.unregister_use( (o), (w) )
|
|
||||||
#else
|
|
||||||
#define PRIVATE_REGISTER_BIRTH(o) obj_reg.register_object_imp( \
|
|
||||||
identify((o)) )
|
|
||||||
#define PRIVATE_REGISTER_DEATH(o) obj_reg.unregister_object_imp( \
|
|
||||||
identify((o)) )
|
|
||||||
#define PRIVATE_REGISTER_USE(o, w) obj_reg.register_use_imp( identify((o)), \
|
|
||||||
identify((w)) )
|
|
||||||
#define PRIVATE_UNREGISTER_USE(o, w) obj_reg.unregister_use_imp( \
|
|
||||||
identify((o)), identify((w)) )
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// Create a base_or_member, with arguments to simulate member initializations
|
|
||||||
base_or_member::base_or_member
|
|
||||||
(
|
|
||||||
int x, // = 1
|
|
||||||
double y // = -0.25
|
|
||||||
)
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_BIRTH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy x-factor is " << x << " and my y-factor is " << y
|
|
||||||
<< '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
// Destroy a base_or_member
|
|
||||||
inline
|
|
||||||
base_or_member::~base_or_member
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_DEATH( *this );
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a base_class, registering any objects used
|
|
||||||
base_class::base_class
|
|
||||||
(
|
|
||||||
base_or_member & x,
|
|
||||||
base_or_member * y, // = 0
|
|
||||||
base_or_member * z // = 0
|
|
||||||
)
|
|
||||||
: x_( &x ), y_( y ), z_( z )
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_BIRTH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy x-factor is " << x_;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
PRIVATE_REGISTER_USE( *this, *x_ );
|
|
||||||
|
|
||||||
if ( y_ )
|
|
||||||
{
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << ", my y-factor is " << y_;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
PRIVATE_REGISTER_USE( *this, *y_ );
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( z_ )
|
|
||||||
{
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << ", my z-factor is " << z_;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
PRIVATE_REGISTER_USE( *this, *z_ );
|
|
||||||
}
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
// Destroy a base_class, unregistering the objects it uses
|
|
||||||
base_class::~base_class
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_DEATH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy x-factor was " << x_;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
PRIVATE_UNREGISTER_USE( *this, *x_ );
|
|
||||||
|
|
||||||
if ( y_ )
|
|
||||||
{
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << ", my y-factor was " << y_;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
PRIVATE_UNREGISTER_USE( *this, *y_ );
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( z_ )
|
|
||||||
{
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << ", my z-factor was " << z_;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
PRIVATE_UNREGISTER_USE( *this, *z_ );
|
|
||||||
}
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a bad_class, noting the improper construction order
|
|
||||||
bad_class::bad_class
|
|
||||||
(
|
|
||||||
)
|
|
||||||
: x_( -7, 16.75 ), base_class( x_ ) // this order doesn't matter
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_BIRTH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy factor is at " << &x_
|
|
||||||
<< " and my base is at " << static_cast<base_class *>(this) << '.'
|
|
||||||
<< std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
// Destroy a bad_class, noting the improper destruction order
|
|
||||||
bad_class::~bad_class
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_DEATH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy factor was at " << &x_
|
|
||||||
<< " and my base was at " << static_cast<base_class *>(this)
|
|
||||||
<< '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a good_class_1, noting the proper construction order
|
|
||||||
good_class_1::good_class_1
|
|
||||||
(
|
|
||||||
)
|
|
||||||
: pbase_type( 8 ), base_type( member )
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_BIRTH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy factor is at " << &member
|
|
||||||
<< " and my base is at " << static_cast<base_class *>(this) << '.'
|
|
||||||
<< std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
// Destroy a good_class_1, noting the proper destruction order
|
|
||||||
good_class_1::~good_class_1
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_DEATH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy factor was at " << &member
|
|
||||||
<< " and my base was at " << static_cast<base_class *>(this)
|
|
||||||
<< '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a good_class_2, noting the proper construction order
|
|
||||||
good_class_2::good_class_2
|
|
||||||
(
|
|
||||||
)
|
|
||||||
: pbase_type0(), pbase_type1(-16, 0.125), pbase_type2(2, -3)
|
|
||||||
, base_type( pbase_type1::member, &this->pbase_type0::member,
|
|
||||||
&this->pbase_type2::member )
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_BIRTH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy factors are at " << &this->pbase_type0::member
|
|
||||||
<< ", " << &this->pbase_type1::member << ", "
|
|
||||||
<< &this->pbase_type2::member << ", and my base is at "
|
|
||||||
<< static_cast<base_class *>(this) << '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
// Destroy a good_class_2, noting the proper destruction order
|
|
||||||
good_class_2::~good_class_2
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
PRIVATE_REGISTER_DEATH( *this );
|
|
||||||
|
|
||||||
#if CONTROL_EXTRA_PRINTING
|
|
||||||
std::cout << "\tMy factors were at " << &this->pbase_type0::member
|
|
||||||
<< ", " << &this->pbase_type1::member << ", "
|
|
||||||
<< &this->pbase_type2::member << ", and my base was at "
|
|
||||||
<< static_cast<base_class *>(this) << '.' << std::endl;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
647
binary_test.cpp
647
binary_test.cpp
@@ -1,647 +0,0 @@
|
|||||||
/*=============================================================================
|
|
||||||
Copyright (c) 2006, 2007 Matthew Calabrese
|
|
||||||
|
|
||||||
Use, modification and distribution is subject to 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/test/minimal.hpp>
|
|
||||||
#include <boost/utility/binary.hpp>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <cstddef>
|
|
||||||
|
|
||||||
#ifdef BOOST_MSVC
|
|
||||||
#pragma warning(disable:4996) // warning C4996: 'std::equal': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
Note: This file tests every single valid bit-grouping on its own, and some
|
|
||||||
random combinations of bit-groupings.
|
|
||||||
*/
|
|
||||||
|
|
||||||
std::size_t const num_random_test_values = 32;
|
|
||||||
|
|
||||||
// Note: These hex values should all correspond with the binary array below
|
|
||||||
unsigned int const random_unsigned_ints_hex[num_random_test_values]
|
|
||||||
= { 0x0103u, 0x77ebu, 0x5f36u, 0x1f18u, 0xc530u, 0xa73au, 0xd6f8u, 0x0919u
|
|
||||||
, 0xfbb0u, 0x3e7cu, 0xd0e9u, 0x22c8u, 0x724eu, 0x14fau, 0xd98eu, 0x40b5
|
|
||||||
, 0xeba0u, 0xfe50u, 0x688au, 0x1b05u, 0x5f9cu, 0xe4fcu, 0xa7b8u, 0xd3acu
|
|
||||||
, 0x1dddu, 0xbf04u, 0x8352u, 0xe89cu, 0x7506u, 0xe767u, 0xf489u, 0xe167
|
|
||||||
};
|
|
||||||
|
|
||||||
unsigned int const random_unsigned_ints_binary[num_random_test_values]
|
|
||||||
= { BOOST_BINARY( 0 00010000 0011 ), BOOST_BINARY( 0 11101 1111 101011 )
|
|
||||||
, BOOST_BINARY( 010111 1100110 1 1 0 ), BOOST_BINARY( 000 1 11110 00 11000 )
|
|
||||||
, BOOST_BINARY( 110 001010 0110 000 ), BOOST_BINARY( 1010 01110011 1010 )
|
|
||||||
, BOOST_BINARY( 11 010 1 101111 1000 ), BOOST_BINARY( 0000 100100 0110 01 )
|
|
||||||
, BOOST_BINARY( 1111 101110 11 0000 ), BOOST_BINARY( 00111110 01111100 )
|
|
||||||
, BOOST_BINARY( 11 010 000111 01001 ), BOOST_BINARY( 00100 010110 01000 )
|
|
||||||
, BOOST_BINARY( 01 11001001 001110 ), BOOST_BINARY( 0010 1001111 1010 )
|
|
||||||
, BOOST_BINARY( 1101 1 00110 0 01110 ), BOOST_BINARY( 100 000 01011010 1 )
|
|
||||||
, BOOST_BINARY( 11 1010 1110 1000 00 ), BOOST_BINARY( 11111 110010 10000 )
|
|
||||||
, BOOST_BINARY( 01101 00010 001010 ), BOOST_BINARY( 000 11011 000001 01 )
|
|
||||||
, BOOST_BINARY( 01 01111 1100111 00 ), BOOST_BINARY( 1 110010 0111111 00 )
|
|
||||||
, BOOST_BINARY( 101 0011 11 01110 00 ), BOOST_BINARY( 110100 1 110101 100 )
|
|
||||||
, BOOST_BINARY( 00 1110111 011 101 ), BOOST_BINARY( 1011 1111 00000 100 )
|
|
||||||
, BOOST_BINARY( 1000 00110 101 0010 ), BOOST_BINARY( 1110 10001 001110 0 )
|
|
||||||
, BOOST_BINARY( 011 1010100 000 110 ), BOOST_BINARY( 1110 0111 01100 111 )
|
|
||||||
, BOOST_BINARY( 11110 10010 001001 ), BOOST_BINARY( 11 1000010 1100 111 )
|
|
||||||
};
|
|
||||||
|
|
||||||
unsigned int const unsigned_ints_1_bit[2] =
|
|
||||||
{ BOOST_BINARY( 0 )
|
|
||||||
, BOOST_BINARY( 1 )
|
|
||||||
};
|
|
||||||
|
|
||||||
unsigned int const unsigned_ints_2_bits[4] =
|
|
||||||
{ BOOST_BINARY( 00 )
|
|
||||||
, BOOST_BINARY( 01 )
|
|
||||||
, BOOST_BINARY( 10 )
|
|
||||||
, BOOST_BINARY( 11 )
|
|
||||||
};
|
|
||||||
|
|
||||||
unsigned int const unsigned_ints_3_bits[8] =
|
|
||||||
{ BOOST_BINARY( 000 )
|
|
||||||
, BOOST_BINARY( 001 )
|
|
||||||
, BOOST_BINARY( 010 )
|
|
||||||
, BOOST_BINARY( 011 )
|
|
||||||
, BOOST_BINARY( 100 )
|
|
||||||
, BOOST_BINARY( 101 )
|
|
||||||
, BOOST_BINARY( 110 )
|
|
||||||
, BOOST_BINARY( 111 )
|
|
||||||
};
|
|
||||||
|
|
||||||
unsigned int const unsigned_ints_4_bits[16] =
|
|
||||||
{ BOOST_BINARY( 0000 )
|
|
||||||
, BOOST_BINARY( 0001 )
|
|
||||||
, BOOST_BINARY( 0010 )
|
|
||||||
, BOOST_BINARY( 0011 )
|
|
||||||
, BOOST_BINARY( 0100 )
|
|
||||||
, BOOST_BINARY( 0101 )
|
|
||||||
, BOOST_BINARY( 0110 )
|
|
||||||
, BOOST_BINARY( 0111 )
|
|
||||||
, BOOST_BINARY( 1000 )
|
|
||||||
, BOOST_BINARY( 1001 )
|
|
||||||
, BOOST_BINARY( 1010 )
|
|
||||||
, BOOST_BINARY( 1011 )
|
|
||||||
, BOOST_BINARY( 1100 )
|
|
||||||
, BOOST_BINARY( 1101 )
|
|
||||||
, BOOST_BINARY( 1110 )
|
|
||||||
, BOOST_BINARY( 1111 )
|
|
||||||
};
|
|
||||||
|
|
||||||
unsigned int const unsigned_ints_5_bits[32] =
|
|
||||||
{ BOOST_BINARY( 00000 )
|
|
||||||
, BOOST_BINARY( 00001 )
|
|
||||||
, BOOST_BINARY( 00010 )
|
|
||||||
, BOOST_BINARY( 00011 )
|
|
||||||
, BOOST_BINARY( 00100 )
|
|
||||||
, BOOST_BINARY( 00101 )
|
|
||||||
, BOOST_BINARY( 00110 )
|
|
||||||
, BOOST_BINARY( 00111 )
|
|
||||||
, BOOST_BINARY( 01000 )
|
|
||||||
, BOOST_BINARY( 01001 )
|
|
||||||
, BOOST_BINARY( 01010 )
|
|
||||||
, BOOST_BINARY( 01011 )
|
|
||||||
, BOOST_BINARY( 01100 )
|
|
||||||
, BOOST_BINARY( 01101 )
|
|
||||||
, BOOST_BINARY( 01110 )
|
|
||||||
, BOOST_BINARY( 01111 )
|
|
||||||
, BOOST_BINARY( 10000 )
|
|
||||||
, BOOST_BINARY( 10001 )
|
|
||||||
, BOOST_BINARY( 10010 )
|
|
||||||
, BOOST_BINARY( 10011 )
|
|
||||||
, BOOST_BINARY( 10100 )
|
|
||||||
, BOOST_BINARY( 10101 )
|
|
||||||
, BOOST_BINARY( 10110 )
|
|
||||||
, BOOST_BINARY( 10111 )
|
|
||||||
, BOOST_BINARY( 11000 )
|
|
||||||
, BOOST_BINARY( 11001 )
|
|
||||||
, BOOST_BINARY( 11010 )
|
|
||||||
, BOOST_BINARY( 11011 )
|
|
||||||
, BOOST_BINARY( 11100 )
|
|
||||||
, BOOST_BINARY( 11101 )
|
|
||||||
, BOOST_BINARY( 11110 )
|
|
||||||
, BOOST_BINARY( 11111 )
|
|
||||||
};
|
|
||||||
|
|
||||||
unsigned int const unsigned_ints_6_bits[64] =
|
|
||||||
{ BOOST_BINARY( 000000 )
|
|
||||||
, BOOST_BINARY( 000001 )
|
|
||||||
, BOOST_BINARY( 000010 )
|
|
||||||
, BOOST_BINARY( 000011 )
|
|
||||||
, BOOST_BINARY( 000100 )
|
|
||||||
, BOOST_BINARY( 000101 )
|
|
||||||
, BOOST_BINARY( 000110 )
|
|
||||||
, BOOST_BINARY( 000111 )
|
|
||||||
, BOOST_BINARY( 001000 )
|
|
||||||
, BOOST_BINARY( 001001 )
|
|
||||||
, BOOST_BINARY( 001010 )
|
|
||||||
, BOOST_BINARY( 001011 )
|
|
||||||
, BOOST_BINARY( 001100 )
|
|
||||||
, BOOST_BINARY( 001101 )
|
|
||||||
, BOOST_BINARY( 001110 )
|
|
||||||
, BOOST_BINARY( 001111 )
|
|
||||||
, BOOST_BINARY( 010000 )
|
|
||||||
, BOOST_BINARY( 010001 )
|
|
||||||
, BOOST_BINARY( 010010 )
|
|
||||||
, BOOST_BINARY( 010011 )
|
|
||||||
, BOOST_BINARY( 010100 )
|
|
||||||
, BOOST_BINARY( 010101 )
|
|
||||||
, BOOST_BINARY( 010110 )
|
|
||||||
, BOOST_BINARY( 010111 )
|
|
||||||
, BOOST_BINARY( 011000 )
|
|
||||||
, BOOST_BINARY( 011001 )
|
|
||||||
, BOOST_BINARY( 011010 )
|
|
||||||
, BOOST_BINARY( 011011 )
|
|
||||||
, BOOST_BINARY( 011100 )
|
|
||||||
, BOOST_BINARY( 011101 )
|
|
||||||
, BOOST_BINARY( 011110 )
|
|
||||||
, BOOST_BINARY( 011111 )
|
|
||||||
, BOOST_BINARY( 100000 )
|
|
||||||
, BOOST_BINARY( 100001 )
|
|
||||||
, BOOST_BINARY( 100010 )
|
|
||||||
, BOOST_BINARY( 100011 )
|
|
||||||
, BOOST_BINARY( 100100 )
|
|
||||||
, BOOST_BINARY( 100101 )
|
|
||||||
, BOOST_BINARY( 100110 )
|
|
||||||
, BOOST_BINARY( 100111 )
|
|
||||||
, BOOST_BINARY( 101000 )
|
|
||||||
, BOOST_BINARY( 101001 )
|
|
||||||
, BOOST_BINARY( 101010 )
|
|
||||||
, BOOST_BINARY( 101011 )
|
|
||||||
, BOOST_BINARY( 101100 )
|
|
||||||
, BOOST_BINARY( 101101 )
|
|
||||||
, BOOST_BINARY( 101110 )
|
|
||||||
, BOOST_BINARY( 101111 )
|
|
||||||
, BOOST_BINARY( 110000 )
|
|
||||||
, BOOST_BINARY( 110001 )
|
|
||||||
, BOOST_BINARY( 110010 )
|
|
||||||
, BOOST_BINARY( 110011 )
|
|
||||||
, BOOST_BINARY( 110100 )
|
|
||||||
, BOOST_BINARY( 110101 )
|
|
||||||
, BOOST_BINARY( 110110 )
|
|
||||||
, BOOST_BINARY( 110111 )
|
|
||||||
, BOOST_BINARY( 111000 )
|
|
||||||
, BOOST_BINARY( 111001 )
|
|
||||||
, BOOST_BINARY( 111010 )
|
|
||||||
, BOOST_BINARY( 111011 )
|
|
||||||
, BOOST_BINARY( 111100 )
|
|
||||||
, BOOST_BINARY( 111101 )
|
|
||||||
, BOOST_BINARY( 111110 )
|
|
||||||
, BOOST_BINARY( 111111 )
|
|
||||||
};
|
|
||||||
|
|
||||||
unsigned int const unsigned_ints_7_bits[128] =
|
|
||||||
{ BOOST_BINARY( 0000000 )
|
|
||||||
, BOOST_BINARY( 0000001 )
|
|
||||||
, BOOST_BINARY( 0000010 )
|
|
||||||
, BOOST_BINARY( 0000011 )
|
|
||||||
, BOOST_BINARY( 0000100 )
|
|
||||||
, BOOST_BINARY( 0000101 )
|
|
||||||
, BOOST_BINARY( 0000110 )
|
|
||||||
, BOOST_BINARY( 0000111 )
|
|
||||||
, BOOST_BINARY( 0001000 )
|
|
||||||
, BOOST_BINARY( 0001001 )
|
|
||||||
, BOOST_BINARY( 0001010 )
|
|
||||||
, BOOST_BINARY( 0001011 )
|
|
||||||
, BOOST_BINARY( 0001100 )
|
|
||||||
, BOOST_BINARY( 0001101 )
|
|
||||||
, BOOST_BINARY( 0001110 )
|
|
||||||
, BOOST_BINARY( 0001111 )
|
|
||||||
, BOOST_BINARY( 0010000 )
|
|
||||||
, BOOST_BINARY( 0010001 )
|
|
||||||
, BOOST_BINARY( 0010010 )
|
|
||||||
, BOOST_BINARY( 0010011 )
|
|
||||||
, BOOST_BINARY( 0010100 )
|
|
||||||
, BOOST_BINARY( 0010101 )
|
|
||||||
, BOOST_BINARY( 0010110 )
|
|
||||||
, BOOST_BINARY( 0010111 )
|
|
||||||
, BOOST_BINARY( 0011000 )
|
|
||||||
, BOOST_BINARY( 0011001 )
|
|
||||||
, BOOST_BINARY( 0011010 )
|
|
||||||
, BOOST_BINARY( 0011011 )
|
|
||||||
, BOOST_BINARY( 0011100 )
|
|
||||||
, BOOST_BINARY( 0011101 )
|
|
||||||
, BOOST_BINARY( 0011110 )
|
|
||||||
, BOOST_BINARY( 0011111 )
|
|
||||||
, BOOST_BINARY( 0100000 )
|
|
||||||
, BOOST_BINARY( 0100001 )
|
|
||||||
, BOOST_BINARY( 0100010 )
|
|
||||||
, BOOST_BINARY( 0100011 )
|
|
||||||
, BOOST_BINARY( 0100100 )
|
|
||||||
, BOOST_BINARY( 0100101 )
|
|
||||||
, BOOST_BINARY( 0100110 )
|
|
||||||
, BOOST_BINARY( 0100111 )
|
|
||||||
, BOOST_BINARY( 0101000 )
|
|
||||||
, BOOST_BINARY( 0101001 )
|
|
||||||
, BOOST_BINARY( 0101010 )
|
|
||||||
, BOOST_BINARY( 0101011 )
|
|
||||||
, BOOST_BINARY( 0101100 )
|
|
||||||
, BOOST_BINARY( 0101101 )
|
|
||||||
, BOOST_BINARY( 0101110 )
|
|
||||||
, BOOST_BINARY( 0101111 )
|
|
||||||
, BOOST_BINARY( 0110000 )
|
|
||||||
, BOOST_BINARY( 0110001 )
|
|
||||||
, BOOST_BINARY( 0110010 )
|
|
||||||
, BOOST_BINARY( 0110011 )
|
|
||||||
, BOOST_BINARY( 0110100 )
|
|
||||||
, BOOST_BINARY( 0110101 )
|
|
||||||
, BOOST_BINARY( 0110110 )
|
|
||||||
, BOOST_BINARY( 0110111 )
|
|
||||||
, BOOST_BINARY( 0111000 )
|
|
||||||
, BOOST_BINARY( 0111001 )
|
|
||||||
, BOOST_BINARY( 0111010 )
|
|
||||||
, BOOST_BINARY( 0111011 )
|
|
||||||
, BOOST_BINARY( 0111100 )
|
|
||||||
, BOOST_BINARY( 0111101 )
|
|
||||||
, BOOST_BINARY( 0111110 )
|
|
||||||
, BOOST_BINARY( 0111111 )
|
|
||||||
, BOOST_BINARY( 1000000 )
|
|
||||||
, BOOST_BINARY( 1000001 )
|
|
||||||
, BOOST_BINARY( 1000010 )
|
|
||||||
, BOOST_BINARY( 1000011 )
|
|
||||||
, BOOST_BINARY( 1000100 )
|
|
||||||
, BOOST_BINARY( 1000101 )
|
|
||||||
, BOOST_BINARY( 1000110 )
|
|
||||||
, BOOST_BINARY( 1000111 )
|
|
||||||
, BOOST_BINARY( 1001000 )
|
|
||||||
, BOOST_BINARY( 1001001 )
|
|
||||||
, BOOST_BINARY( 1001010 )
|
|
||||||
, BOOST_BINARY( 1001011 )
|
|
||||||
, BOOST_BINARY( 1001100 )
|
|
||||||
, BOOST_BINARY( 1001101 )
|
|
||||||
, BOOST_BINARY( 1001110 )
|
|
||||||
, BOOST_BINARY( 1001111 )
|
|
||||||
, BOOST_BINARY( 1010000 )
|
|
||||||
, BOOST_BINARY( 1010001 )
|
|
||||||
, BOOST_BINARY( 1010010 )
|
|
||||||
, BOOST_BINARY( 1010011 )
|
|
||||||
, BOOST_BINARY( 1010100 )
|
|
||||||
, BOOST_BINARY( 1010101 )
|
|
||||||
, BOOST_BINARY( 1010110 )
|
|
||||||
, BOOST_BINARY( 1010111 )
|
|
||||||
, BOOST_BINARY( 1011000 )
|
|
||||||
, BOOST_BINARY( 1011001 )
|
|
||||||
, BOOST_BINARY( 1011010 )
|
|
||||||
, BOOST_BINARY( 1011011 )
|
|
||||||
, BOOST_BINARY( 1011100 )
|
|
||||||
, BOOST_BINARY( 1011101 )
|
|
||||||
, BOOST_BINARY( 1011110 )
|
|
||||||
, BOOST_BINARY( 1011111 )
|
|
||||||
, BOOST_BINARY( 1100000 )
|
|
||||||
, BOOST_BINARY( 1100001 )
|
|
||||||
, BOOST_BINARY( 1100010 )
|
|
||||||
, BOOST_BINARY( 1100011 )
|
|
||||||
, BOOST_BINARY( 1100100 )
|
|
||||||
, BOOST_BINARY( 1100101 )
|
|
||||||
, BOOST_BINARY( 1100110 )
|
|
||||||
, BOOST_BINARY( 1100111 )
|
|
||||||
, BOOST_BINARY( 1101000 )
|
|
||||||
, BOOST_BINARY( 1101001 )
|
|
||||||
, BOOST_BINARY( 1101010 )
|
|
||||||
, BOOST_BINARY( 1101011 )
|
|
||||||
, BOOST_BINARY( 1101100 )
|
|
||||||
, BOOST_BINARY( 1101101 )
|
|
||||||
, BOOST_BINARY( 1101110 )
|
|
||||||
, BOOST_BINARY( 1101111 )
|
|
||||||
, BOOST_BINARY( 1110000 )
|
|
||||||
, BOOST_BINARY( 1110001 )
|
|
||||||
, BOOST_BINARY( 1110010 )
|
|
||||||
, BOOST_BINARY( 1110011 )
|
|
||||||
, BOOST_BINARY( 1110100 )
|
|
||||||
, BOOST_BINARY( 1110101 )
|
|
||||||
, BOOST_BINARY( 1110110 )
|
|
||||||
, BOOST_BINARY( 1110111 )
|
|
||||||
, BOOST_BINARY( 1111000 )
|
|
||||||
, BOOST_BINARY( 1111001 )
|
|
||||||
, BOOST_BINARY( 1111010 )
|
|
||||||
, BOOST_BINARY( 1111011 )
|
|
||||||
, BOOST_BINARY( 1111100 )
|
|
||||||
, BOOST_BINARY( 1111101 )
|
|
||||||
, BOOST_BINARY( 1111110 )
|
|
||||||
, BOOST_BINARY( 1111111 )
|
|
||||||
};
|
|
||||||
unsigned int const unsigned_ints_8_bits[256] =
|
|
||||||
{ BOOST_BINARY( 00000000 )
|
|
||||||
, BOOST_BINARY( 00000001 )
|
|
||||||
, BOOST_BINARY( 00000010 )
|
|
||||||
, BOOST_BINARY( 00000011 )
|
|
||||||
, BOOST_BINARY( 00000100 )
|
|
||||||
, BOOST_BINARY( 00000101 )
|
|
||||||
, BOOST_BINARY( 00000110 )
|
|
||||||
, BOOST_BINARY( 00000111 )
|
|
||||||
, BOOST_BINARY( 00001000 )
|
|
||||||
, BOOST_BINARY( 00001001 )
|
|
||||||
, BOOST_BINARY( 00001010 )
|
|
||||||
, BOOST_BINARY( 00001011 )
|
|
||||||
, BOOST_BINARY( 00001100 )
|
|
||||||
, BOOST_BINARY( 00001101 )
|
|
||||||
, BOOST_BINARY( 00001110 )
|
|
||||||
, BOOST_BINARY( 00001111 )
|
|
||||||
, BOOST_BINARY( 00010000 )
|
|
||||||
, BOOST_BINARY( 00010001 )
|
|
||||||
, BOOST_BINARY( 00010010 )
|
|
||||||
, BOOST_BINARY( 00010011 )
|
|
||||||
, BOOST_BINARY( 00010100 )
|
|
||||||
, BOOST_BINARY( 00010101 )
|
|
||||||
, BOOST_BINARY( 00010110 )
|
|
||||||
, BOOST_BINARY( 00010111 )
|
|
||||||
, BOOST_BINARY( 00011000 )
|
|
||||||
, BOOST_BINARY( 00011001 )
|
|
||||||
, BOOST_BINARY( 00011010 )
|
|
||||||
, BOOST_BINARY( 00011011 )
|
|
||||||
, BOOST_BINARY( 00011100 )
|
|
||||||
, BOOST_BINARY( 00011101 )
|
|
||||||
, BOOST_BINARY( 00011110 )
|
|
||||||
, BOOST_BINARY( 00011111 )
|
|
||||||
, BOOST_BINARY( 00100000 )
|
|
||||||
, BOOST_BINARY( 00100001 )
|
|
||||||
, BOOST_BINARY( 00100010 )
|
|
||||||
, BOOST_BINARY( 00100011 )
|
|
||||||
, BOOST_BINARY( 00100100 )
|
|
||||||
, BOOST_BINARY( 00100101 )
|
|
||||||
, BOOST_BINARY( 00100110 )
|
|
||||||
, BOOST_BINARY( 00100111 )
|
|
||||||
, BOOST_BINARY( 00101000 )
|
|
||||||
, BOOST_BINARY( 00101001 )
|
|
||||||
, BOOST_BINARY( 00101010 )
|
|
||||||
, BOOST_BINARY( 00101011 )
|
|
||||||
, BOOST_BINARY( 00101100 )
|
|
||||||
, BOOST_BINARY( 00101101 )
|
|
||||||
, BOOST_BINARY( 00101110 )
|
|
||||||
, BOOST_BINARY( 00101111 )
|
|
||||||
, BOOST_BINARY( 00110000 )
|
|
||||||
, BOOST_BINARY( 00110001 )
|
|
||||||
, BOOST_BINARY( 00110010 )
|
|
||||||
, BOOST_BINARY( 00110011 )
|
|
||||||
, BOOST_BINARY( 00110100 )
|
|
||||||
, BOOST_BINARY( 00110101 )
|
|
||||||
, BOOST_BINARY( 00110110 )
|
|
||||||
, BOOST_BINARY( 00110111 )
|
|
||||||
, BOOST_BINARY( 00111000 )
|
|
||||||
, BOOST_BINARY( 00111001 )
|
|
||||||
, BOOST_BINARY( 00111010 )
|
|
||||||
, BOOST_BINARY( 00111011 )
|
|
||||||
, BOOST_BINARY( 00111100 )
|
|
||||||
, BOOST_BINARY( 00111101 )
|
|
||||||
, BOOST_BINARY( 00111110 )
|
|
||||||
, BOOST_BINARY( 00111111 )
|
|
||||||
, BOOST_BINARY( 01000000 )
|
|
||||||
, BOOST_BINARY( 01000001 )
|
|
||||||
, BOOST_BINARY( 01000010 )
|
|
||||||
, BOOST_BINARY( 01000011 )
|
|
||||||
, BOOST_BINARY( 01000100 )
|
|
||||||
, BOOST_BINARY( 01000101 )
|
|
||||||
, BOOST_BINARY( 01000110 )
|
|
||||||
, BOOST_BINARY( 01000111 )
|
|
||||||
, BOOST_BINARY( 01001000 )
|
|
||||||
, BOOST_BINARY( 01001001 )
|
|
||||||
, BOOST_BINARY( 01001010 )
|
|
||||||
, BOOST_BINARY( 01001011 )
|
|
||||||
, BOOST_BINARY( 01001100 )
|
|
||||||
, BOOST_BINARY( 01001101 )
|
|
||||||
, BOOST_BINARY( 01001110 )
|
|
||||||
, BOOST_BINARY( 01001111 )
|
|
||||||
, BOOST_BINARY( 01010000 )
|
|
||||||
, BOOST_BINARY( 01010001 )
|
|
||||||
, BOOST_BINARY( 01010010 )
|
|
||||||
, BOOST_BINARY( 01010011 )
|
|
||||||
, BOOST_BINARY( 01010100 )
|
|
||||||
, BOOST_BINARY( 01010101 )
|
|
||||||
, BOOST_BINARY( 01010110 )
|
|
||||||
, BOOST_BINARY( 01010111 )
|
|
||||||
, BOOST_BINARY( 01011000 )
|
|
||||||
, BOOST_BINARY( 01011001 )
|
|
||||||
, BOOST_BINARY( 01011010 )
|
|
||||||
, BOOST_BINARY( 01011011 )
|
|
||||||
, BOOST_BINARY( 01011100 )
|
|
||||||
, BOOST_BINARY( 01011101 )
|
|
||||||
, BOOST_BINARY( 01011110 )
|
|
||||||
, BOOST_BINARY( 01011111 )
|
|
||||||
, BOOST_BINARY( 01100000 )
|
|
||||||
, BOOST_BINARY( 01100001 )
|
|
||||||
, BOOST_BINARY( 01100010 )
|
|
||||||
, BOOST_BINARY( 01100011 )
|
|
||||||
, BOOST_BINARY( 01100100 )
|
|
||||||
, BOOST_BINARY( 01100101 )
|
|
||||||
, BOOST_BINARY( 01100110 )
|
|
||||||
, BOOST_BINARY( 01100111 )
|
|
||||||
, BOOST_BINARY( 01101000 )
|
|
||||||
, BOOST_BINARY( 01101001 )
|
|
||||||
, BOOST_BINARY( 01101010 )
|
|
||||||
, BOOST_BINARY( 01101011 )
|
|
||||||
, BOOST_BINARY( 01101100 )
|
|
||||||
, BOOST_BINARY( 01101101 )
|
|
||||||
, BOOST_BINARY( 01101110 )
|
|
||||||
, BOOST_BINARY( 01101111 )
|
|
||||||
, BOOST_BINARY( 01110000 )
|
|
||||||
, BOOST_BINARY( 01110001 )
|
|
||||||
, BOOST_BINARY( 01110010 )
|
|
||||||
, BOOST_BINARY( 01110011 )
|
|
||||||
, BOOST_BINARY( 01110100 )
|
|
||||||
, BOOST_BINARY( 01110101 )
|
|
||||||
, BOOST_BINARY( 01110110 )
|
|
||||||
, BOOST_BINARY( 01110111 )
|
|
||||||
, BOOST_BINARY( 01111000 )
|
|
||||||
, BOOST_BINARY( 01111001 )
|
|
||||||
, BOOST_BINARY( 01111010 )
|
|
||||||
, BOOST_BINARY( 01111011 )
|
|
||||||
, BOOST_BINARY( 01111100 )
|
|
||||||
, BOOST_BINARY( 01111101 )
|
|
||||||
, BOOST_BINARY( 01111110 )
|
|
||||||
, BOOST_BINARY( 01111111 )
|
|
||||||
, BOOST_BINARY( 10000000 )
|
|
||||||
, BOOST_BINARY( 10000001 )
|
|
||||||
, BOOST_BINARY( 10000010 )
|
|
||||||
, BOOST_BINARY( 10000011 )
|
|
||||||
, BOOST_BINARY( 10000100 )
|
|
||||||
, BOOST_BINARY( 10000101 )
|
|
||||||
, BOOST_BINARY( 10000110 )
|
|
||||||
, BOOST_BINARY( 10000111 )
|
|
||||||
, BOOST_BINARY( 10001000 )
|
|
||||||
, BOOST_BINARY( 10001001 )
|
|
||||||
, BOOST_BINARY( 10001010 )
|
|
||||||
, BOOST_BINARY( 10001011 )
|
|
||||||
, BOOST_BINARY( 10001100 )
|
|
||||||
, BOOST_BINARY( 10001101 )
|
|
||||||
, BOOST_BINARY( 10001110 )
|
|
||||||
, BOOST_BINARY( 10001111 )
|
|
||||||
, BOOST_BINARY( 10010000 )
|
|
||||||
, BOOST_BINARY( 10010001 )
|
|
||||||
, BOOST_BINARY( 10010010 )
|
|
||||||
, BOOST_BINARY( 10010011 )
|
|
||||||
, BOOST_BINARY( 10010100 )
|
|
||||||
, BOOST_BINARY( 10010101 )
|
|
||||||
, BOOST_BINARY( 10010110 )
|
|
||||||
, BOOST_BINARY( 10010111 )
|
|
||||||
, BOOST_BINARY( 10011000 )
|
|
||||||
, BOOST_BINARY( 10011001 )
|
|
||||||
, BOOST_BINARY( 10011010 )
|
|
||||||
, BOOST_BINARY( 10011011 )
|
|
||||||
, BOOST_BINARY( 10011100 )
|
|
||||||
, BOOST_BINARY( 10011101 )
|
|
||||||
, BOOST_BINARY( 10011110 )
|
|
||||||
, BOOST_BINARY( 10011111 )
|
|
||||||
, BOOST_BINARY( 10100000 )
|
|
||||||
, BOOST_BINARY( 10100001 )
|
|
||||||
, BOOST_BINARY( 10100010 )
|
|
||||||
, BOOST_BINARY( 10100011 )
|
|
||||||
, BOOST_BINARY( 10100100 )
|
|
||||||
, BOOST_BINARY( 10100101 )
|
|
||||||
, BOOST_BINARY( 10100110 )
|
|
||||||
, BOOST_BINARY( 10100111 )
|
|
||||||
, BOOST_BINARY( 10101000 )
|
|
||||||
, BOOST_BINARY( 10101001 )
|
|
||||||
, BOOST_BINARY( 10101010 )
|
|
||||||
, BOOST_BINARY( 10101011 )
|
|
||||||
, BOOST_BINARY( 10101100 )
|
|
||||||
, BOOST_BINARY( 10101101 )
|
|
||||||
, BOOST_BINARY( 10101110 )
|
|
||||||
, BOOST_BINARY( 10101111 )
|
|
||||||
, BOOST_BINARY( 10110000 )
|
|
||||||
, BOOST_BINARY( 10110001 )
|
|
||||||
, BOOST_BINARY( 10110010 )
|
|
||||||
, BOOST_BINARY( 10110011 )
|
|
||||||
, BOOST_BINARY( 10110100 )
|
|
||||||
, BOOST_BINARY( 10110101 )
|
|
||||||
, BOOST_BINARY( 10110110 )
|
|
||||||
, BOOST_BINARY( 10110111 )
|
|
||||||
, BOOST_BINARY( 10111000 )
|
|
||||||
, BOOST_BINARY( 10111001 )
|
|
||||||
, BOOST_BINARY( 10111010 )
|
|
||||||
, BOOST_BINARY( 10111011 )
|
|
||||||
, BOOST_BINARY( 10111100 )
|
|
||||||
, BOOST_BINARY( 10111101 )
|
|
||||||
, BOOST_BINARY( 10111110 )
|
|
||||||
, BOOST_BINARY( 10111111 )
|
|
||||||
, BOOST_BINARY( 11000000 )
|
|
||||||
, BOOST_BINARY( 11000001 )
|
|
||||||
, BOOST_BINARY( 11000010 )
|
|
||||||
, BOOST_BINARY( 11000011 )
|
|
||||||
, BOOST_BINARY( 11000100 )
|
|
||||||
, BOOST_BINARY( 11000101 )
|
|
||||||
, BOOST_BINARY( 11000110 )
|
|
||||||
, BOOST_BINARY( 11000111 )
|
|
||||||
, BOOST_BINARY( 11001000 )
|
|
||||||
, BOOST_BINARY( 11001001 )
|
|
||||||
, BOOST_BINARY( 11001010 )
|
|
||||||
, BOOST_BINARY( 11001011 )
|
|
||||||
, BOOST_BINARY( 11001100 )
|
|
||||||
, BOOST_BINARY( 11001101 )
|
|
||||||
, BOOST_BINARY( 11001110 )
|
|
||||||
, BOOST_BINARY( 11001111 )
|
|
||||||
, BOOST_BINARY( 11010000 )
|
|
||||||
, BOOST_BINARY( 11010001 )
|
|
||||||
, BOOST_BINARY( 11010010 )
|
|
||||||
, BOOST_BINARY( 11010011 )
|
|
||||||
, BOOST_BINARY( 11010100 )
|
|
||||||
, BOOST_BINARY( 11010101 )
|
|
||||||
, BOOST_BINARY( 11010110 )
|
|
||||||
, BOOST_BINARY( 11010111 )
|
|
||||||
, BOOST_BINARY( 11011000 )
|
|
||||||
, BOOST_BINARY( 11011001 )
|
|
||||||
, BOOST_BINARY( 11011010 )
|
|
||||||
, BOOST_BINARY( 11011011 )
|
|
||||||
, BOOST_BINARY( 11011100 )
|
|
||||||
, BOOST_BINARY( 11011101 )
|
|
||||||
, BOOST_BINARY( 11011110 )
|
|
||||||
, BOOST_BINARY( 11011111 )
|
|
||||||
, BOOST_BINARY( 11100000 )
|
|
||||||
, BOOST_BINARY( 11100001 )
|
|
||||||
, BOOST_BINARY( 11100010 )
|
|
||||||
, BOOST_BINARY( 11100011 )
|
|
||||||
, BOOST_BINARY( 11100100 )
|
|
||||||
, BOOST_BINARY( 11100101 )
|
|
||||||
, BOOST_BINARY( 11100110 )
|
|
||||||
, BOOST_BINARY( 11100111 )
|
|
||||||
, BOOST_BINARY( 11101000 )
|
|
||||||
, BOOST_BINARY( 11101001 )
|
|
||||||
, BOOST_BINARY( 11101010 )
|
|
||||||
, BOOST_BINARY( 11101011 )
|
|
||||||
, BOOST_BINARY( 11101100 )
|
|
||||||
, BOOST_BINARY( 11101101 )
|
|
||||||
, BOOST_BINARY( 11101110 )
|
|
||||||
, BOOST_BINARY( 11101111 )
|
|
||||||
, BOOST_BINARY( 11110000 )
|
|
||||||
, BOOST_BINARY( 11110001 )
|
|
||||||
, BOOST_BINARY( 11110010 )
|
|
||||||
, BOOST_BINARY( 11110011 )
|
|
||||||
, BOOST_BINARY( 11110100 )
|
|
||||||
, BOOST_BINARY( 11110101 )
|
|
||||||
, BOOST_BINARY( 11110110 )
|
|
||||||
, BOOST_BINARY( 11110111 )
|
|
||||||
, BOOST_BINARY( 11111000 )
|
|
||||||
, BOOST_BINARY( 11111001 )
|
|
||||||
, BOOST_BINARY( 11111010 )
|
|
||||||
, BOOST_BINARY( 11111011 )
|
|
||||||
, BOOST_BINARY( 11111100 )
|
|
||||||
, BOOST_BINARY( 11111101 )
|
|
||||||
, BOOST_BINARY( 11111110 )
|
|
||||||
, BOOST_BINARY( 11111111 )
|
|
||||||
};
|
|
||||||
|
|
||||||
struct left_is_not_one_less_than_right
|
|
||||||
{
|
|
||||||
bool operator ()( unsigned int left, unsigned int right ) const
|
|
||||||
{
|
|
||||||
return right != left + 1;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template< std::size_t Size >
|
|
||||||
bool is_ascending_from_0_array( unsigned int const (&array)[Size] )
|
|
||||||
{
|
|
||||||
unsigned int const* const curr = array,
|
|
||||||
* const end = array + Size;
|
|
||||||
|
|
||||||
return ( *curr == 0 )
|
|
||||||
&& ( std::adjacent_find( curr, end
|
|
||||||
, left_is_not_one_less_than_right()
|
|
||||||
)
|
|
||||||
== end
|
|
||||||
);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t const unsigned_int_id = 1,
|
|
||||||
unsigned_long_int_id = 2;
|
|
||||||
|
|
||||||
typedef char (&unsigned_int_id_type)[unsigned_int_id];
|
|
||||||
typedef char (&unsigned_long_int_id_type)[unsigned_long_int_id];
|
|
||||||
|
|
||||||
// Note: Functions only used for type checking
|
|
||||||
unsigned_int_id_type binary_type_checker( unsigned int );
|
|
||||||
unsigned_long_int_id_type binary_type_checker( unsigned long int );
|
|
||||||
|
|
||||||
int test_main( int, char *[] )
|
|
||||||
{
|
|
||||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_1_bit ) );
|
|
||||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_2_bits ) );
|
|
||||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_3_bits ) );
|
|
||||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_4_bits ) );
|
|
||||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_5_bits ) );
|
|
||||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_6_bits ) );
|
|
||||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_7_bits ) );
|
|
||||||
BOOST_CHECK( is_ascending_from_0_array( unsigned_ints_8_bits ) );
|
|
||||||
|
|
||||||
BOOST_CHECK( std::equal( &random_unsigned_ints_hex[0]
|
|
||||||
, random_unsigned_ints_hex + num_random_test_values
|
|
||||||
, &random_unsigned_ints_binary[0]
|
|
||||||
)
|
|
||||||
);
|
|
||||||
|
|
||||||
BOOST_CHECK( sizeof( binary_type_checker( BOOST_BINARY_U( 110100 1010 ) ) )
|
|
||||||
== unsigned_int_id
|
|
||||||
);
|
|
||||||
|
|
||||||
BOOST_CHECK( sizeof( binary_type_checker( BOOST_BINARY_UL( 11110 ) ) )
|
|
||||||
== unsigned_long_int_id
|
|
||||||
);
|
|
||||||
|
|
||||||
BOOST_CHECK( sizeof( binary_type_checker( BOOST_BINARY_LU( 10 0001 ) ) )
|
|
||||||
== unsigned_long_int_id
|
|
||||||
);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
489
c++_type_traits.htm
Normal file
489
c++_type_traits.htm
Normal file
@@ -0,0 +1,489 @@
|
|||||||
|
<html>
|
||||||
|
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||||
|
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||||
|
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||||
|
<title>C++ Type traits</title>
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||||
|
|
||||||
|
<h2 align="center">C++ Type traits</h2>
|
||||||
|
<p align="center"><em>by John Maddock and Steve Cleary</em></p>
|
||||||
|
<p align="center"><em>This is a draft of an article that will appear in a future
|
||||||
|
issue of </em><a href="http://www.ddj.com"><em>Dr Dobb's Journal</em></a></p>
|
||||||
|
<p>Generic programming (writing code which works with any data type meeting a
|
||||||
|
set of requirements) has become the method of choice for providing reusable
|
||||||
|
code. However, there are times in generic programming when "generic"
|
||||||
|
just isn't good enough - sometimes the differences between types are too large
|
||||||
|
for an efficient generic implementation. This is when the traits technique
|
||||||
|
becomes important - by encapsulating those properties that need to be considered
|
||||||
|
on a type by type basis inside a traits class, we can minimise the amount of
|
||||||
|
code that has to differ from one type to another, and maximise the amount of
|
||||||
|
generic code.</p>
|
||||||
|
<p>Consider an example: when working with character strings, one common
|
||||||
|
operation is to determine the length of a null terminated string. Clearly it's
|
||||||
|
possible to write generic code that can do this, but it turns out that there are
|
||||||
|
much more efficient methods available: for example, the C library functions <font size="2" face="Courier New">strlen</font>
|
||||||
|
and <font size="2" face="Courier New">wcslen</font> are usually written in
|
||||||
|
assembler, and with suitable hardware support can be considerably faster than a
|
||||||
|
generic version written in C++. The authors of the C++ standard library realised
|
||||||
|
this, and abstracted the properties of <font size="2" face="Courier New">char</font>
|
||||||
|
and <font size="2" face="Courier New">wchar_t</font> into the class <font size="2" face="Courier New">char_traits</font>.
|
||||||
|
Generic code that works with character strings can simply use <font size="2" face="Courier New">char_traits<>::length</font>
|
||||||
|
to determine the length of a null terminated string, safe in the knowledge that
|
||||||
|
specialisations of <font size="2" face="Courier New">char_traits</font> will use
|
||||||
|
the most appropriate method available to them.</p>
|
||||||
|
<h4>Type traits</h4>
|
||||||
|
<p>Class <font size="2" face="Courier New">char_traits</font> is a classic
|
||||||
|
example of a collection of type specific properties wrapped up in a single class
|
||||||
|
- what Nathan Myers termed a <i>baggage class</i>[1]. In the Boost type-traits
|
||||||
|
library, we[2] have written a set of very specific traits classes, each of which
|
||||||
|
encapsulate a single trait from the C++ type system; for example, is a type a
|
||||||
|
pointer or a reference type? Or does a type have a trivial constructor, or a
|
||||||
|
const-qualifier? The type-traits classes share a unified design: each class has
|
||||||
|
a single member <i>value</i>, a compile-time constant that is true if the type
|
||||||
|
has the specified property, and false otherwise. As we will show, these classes
|
||||||
|
can be used in generic programming to determine the properties of a given type
|
||||||
|
and introduce optimisations that are appropriate for that case.</p>
|
||||||
|
<p>The type-traits library also contains a set of classes that perform a
|
||||||
|
specific transformation on a type; for example, they can remove a top-level
|
||||||
|
const or volatile qualifier from a type. Each class that performs a
|
||||||
|
transformation defines a single typedef-member <i>type</i> that is the result of
|
||||||
|
the transformation. All of the type-traits classes are defined inside namespace <font size="2" face="Courier New">boost</font>;
|
||||||
|
for brevity, namespace-qualification is omitted in most of the code samples
|
||||||
|
given.</p>
|
||||||
|
<h4>Implementation</h4>
|
||||||
|
<p>There are far too many separate classes contained in the type-traits library
|
||||||
|
to give a full implementation here - see the source code in the Boost library
|
||||||
|
for the full details - however, most of the implementation is fairly repetitive
|
||||||
|
anyway, so here we will just give you a flavour for how some of the classes are
|
||||||
|
implemented. Beginning with possibly the simplest class in the library, is_void<T>
|
||||||
|
has a member <i>value</i> that is true only if T is void.</p>
|
||||||
|
<pre>template <typename T>
|
||||||
|
struct is_void
|
||||||
|
{ static const bool value = false; };
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct is_void<void>
|
||||||
|
{ static const bool value = true; };</pre>
|
||||||
|
<p>Here we define a primary version of the template class <font size="2" face="Courier New">is_void</font>,
|
||||||
|
and provide a full-specialisation when T is void. While full specialisation of a
|
||||||
|
template class is an important technique, sometimes we need a solution that is
|
||||||
|
halfway between a fully generic solution, and a full specialisation. This is
|
||||||
|
exactly the situation for which the standards committee defined partial
|
||||||
|
template-class specialisation. As an example, consider the class
|
||||||
|
boost::is_pointer<T>: here we needed a primary version that handles all
|
||||||
|
the cases where T is not a pointer, and a partial specialisation to handle all
|
||||||
|
the cases where T is a pointer:</p>
|
||||||
|
<pre>template <typename T>
|
||||||
|
struct is_pointer
|
||||||
|
{ static const bool value = false; };
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct is_pointer<T*>
|
||||||
|
{ static const bool value = true; };</pre>
|
||||||
|
<p>The syntax for partial specialisation is somewhat arcane and could easily
|
||||||
|
occupy an article in its own right; like full specialisation, in order to write
|
||||||
|
a partial specialisation for a class, you must first declare the primary
|
||||||
|
template. The partial specialisation contains an extra <<EFBFBD>> after the
|
||||||
|
class name that contains the partial specialisation parameters; these define the
|
||||||
|
types that will bind to that partial specialisation rather than the default
|
||||||
|
template. The rules for what can appear in a partial specialisation are somewhat
|
||||||
|
convoluted, but as a rule of thumb if you can legally write two function
|
||||||
|
overloads of the form:</p>
|
||||||
|
<pre>void foo(T);
|
||||||
|
void foo(U);</pre>
|
||||||
|
<p>Then you can also write a partial specialisation of the form:</p>
|
||||||
|
<pre>template <typename T>
|
||||||
|
class c{ /*details*/ };
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
|
||||||
|
class c<U>{ /*details*/ };</pre>
|
||||||
|
<p>This rule is by no means foolproof, but it is reasonably simple to remember
|
||||||
|
and close enough to the actual rule to be useful for everyday use.</p>
|
||||||
|
<p>As a more complex example of partial specialisation consider the class
|
||||||
|
remove_bounds<T>. This class defines a single typedef-member <i>type</i>
|
||||||
|
that is the same type as T but with any top-level array bounds removed; this is
|
||||||
|
an example of a traits class that performs a transformation on a type:</p>
|
||||||
|
<pre>template <typename T>
|
||||||
|
struct remove_bounds
|
||||||
|
{ typedef T type; };
|
||||||
|
|
||||||
|
template <typename T, std::size_t N>
|
||||||
|
struct remove_bounds<T[N]>
|
||||||
|
{ typedef T type; };</pre>
|
||||||
|
<p>The aim of remove_bounds is this: imagine a generic algorithm that is passed
|
||||||
|
an array type as a template parameter, <font size="2" face="Courier New">remove_bounds</font>
|
||||||
|
provides a means of determining the underlying type of the array. For example <code>remove_bounds<int[4][5]>::type</code>
|
||||||
|
would evaluate to the type <code>int[5]</code>. This example also shows that the
|
||||||
|
number of template parameters in a partial specialisation does not have to match
|
||||||
|
the number in the default template. However, the number of parameters that
|
||||||
|
appear after the class name do have to match the number and type of the
|
||||||
|
parameters in the default template.</p>
|
||||||
|
<h4>Optimised copy</h4>
|
||||||
|
<p>As an example of how the type traits classes can be used, consider the
|
||||||
|
standard library algorithm copy:</p>
|
||||||
|
<pre>template<typename Iter1, typename Iter2>
|
||||||
|
Iter2 copy(Iter1 first, Iter1 last, Iter2 out);</pre>
|
||||||
|
<p>Obviously, there's no problem writing a generic version of copy that works
|
||||||
|
for all iterator types Iter1 and Iter2; however, there are some circumstances
|
||||||
|
when the copy operation can best be performed by a call to <font size="2" face="Courier New">memcpy</font>.
|
||||||
|
In order to implement copy in terms of <font size="2" face="Courier New">memcpy</font>
|
||||||
|
all of the following conditions need to be met:</p>
|
||||||
|
<ul>
|
||||||
|
<li>Both of the iterator types Iter1 and Iter2 must be pointers.</li>
|
||||||
|
<li>Both Iter1 and Iter2 must point to the same type - excluding <font size="2" face="Courier New">const</font>
|
||||||
|
and <font size="2" face="Courier New">volatile</font>-qualifiers.</li>
|
||||||
|
<li>The type pointed to by Iter1 must have a trivial assignment operator.</li>
|
||||||
|
</ul>
|
||||||
|
<p>By trivial assignment operator we mean that the type is either a scalar
|
||||||
|
type[3] or:</p>
|
||||||
|
<ul>
|
||||||
|
<li>The type has no user defined assignment operator.</li>
|
||||||
|
<li>The type does not have any data members that are references.</li>
|
||||||
|
<li>All base classes, and all data member objects must have trivial assignment
|
||||||
|
operators.</li>
|
||||||
|
</ul>
|
||||||
|
<p>If all these conditions are met then a type can be copied using <font size="2" face="Courier New">memcpy</font>
|
||||||
|
rather than using a compiler generated assignment operator. The type-traits
|
||||||
|
library provides a class <i>has_trivial_assign</i>, such that <code>has_trivial_assign<T>::value</code>
|
||||||
|
is true only if T has a trivial assignment operator. This class "just
|
||||||
|
works" for scalar types, but has to be explicitly specialised for
|
||||||
|
class/struct types that also happen to have a trivial assignment operator. In
|
||||||
|
other words if <i>has_trivial_assign</i> gives the wrong answer, it will give
|
||||||
|
the "safe" wrong answer - that trivial assignment is not allowable.</p>
|
||||||
|
<p>The code for an optimised version of copy that uses <font size="2" face="Courier New">memcpy</font>
|
||||||
|
where appropriate is given in listing 1. The code begins by defining a template
|
||||||
|
class <i>copier</i>, that takes a single Boolean template parameter, and has a
|
||||||
|
static template member function <font size="2" face="Courier New">do_copy</font>
|
||||||
|
which performs the generic version of <font size="2">copy</font> (in other words
|
||||||
|
the "slow but safe version"). Following that there is a specialisation
|
||||||
|
for <i>copier<true></i>: again this defines a static template member
|
||||||
|
function <font size="2" face="Courier New">do_copy</font>, but this version uses
|
||||||
|
memcpy to perform an "optimised" copy.</p>
|
||||||
|
<p>In order to complete the implementation, what we need now is a version of
|
||||||
|
copy, that calls <code>copier<true>::do_copy</code> if it is safe to use <font size="2" face="Courier New">memcpy</font>,
|
||||||
|
and otherwise calls <code>copier<false>::do_copy</code> to do a
|
||||||
|
"generic" copy. This is what the version in listing 1 does. To
|
||||||
|
understand how the code works look at the code for <font size="2" face="Courier New">copy</font>
|
||||||
|
and consider first the two typedefs <i>v1_t</i> and <i>v2_t</i>. These use <code>std::iterator_traits<Iter1>::value_type</code>
|
||||||
|
to determine what type the two iterators point to, and then feed the result into
|
||||||
|
another type-traits class <i>remove_cv</i> that removes the top-level
|
||||||
|
const-volatile-qualifiers: this will allow copy to compare the two types without
|
||||||
|
regard to const- or volatile-qualifiers. Next, <font size="2" face="Courier New">copy</font>
|
||||||
|
declares an enumerated value <i>can_opt</i> that will become the template
|
||||||
|
parameter to copier - declaring this here as a constant is really just a
|
||||||
|
convenience - the value could be passed directly to class <font size="2" face="Courier New">copier</font>.
|
||||||
|
The value of <i>can_opt</i> is computed by verifying that all of the following
|
||||||
|
are true:</p>
|
||||||
|
<ul>
|
||||||
|
<li>first that the two iterators point to the same type by using a type-traits
|
||||||
|
class <i>is_same</i>.</li>
|
||||||
|
<li>Then that both iterators are real pointers - using the class <i>is_pointer</i>
|
||||||
|
described above.</li>
|
||||||
|
<li>Finally that the pointed-to types have a trivial assignment operator using
|
||||||
|
<i>has_trivial_assign</i>.</li>
|
||||||
|
</ul>
|
||||||
|
<p>Finally we can use the value of <i>can_opt</i> as the template argument to
|
||||||
|
copier - this version of copy will now adapt to whatever parameters are passed
|
||||||
|
to it, if its possible to use <font size="2" face="Courier New">memcpy</font>,
|
||||||
|
then it will do so, otherwise it will use a generic copy.</p>
|
||||||
|
<h4>Was it worth it?</h4>
|
||||||
|
<p>It has often been repeated in these columns that "premature optimisation
|
||||||
|
is the root of all evil" [4]. So the question must be asked: was our
|
||||||
|
optimisation premature? To put this in perspective the timings for our version
|
||||||
|
of copy compared a conventional generic copy[5] are shown in table 1.</p>
|
||||||
|
<p>Clearly the optimisation makes a difference in this case; but, to be fair,
|
||||||
|
the timings are loaded to exclude cache miss effects - without this accurate
|
||||||
|
comparison between algorithms becomes difficult. However, perhaps we can add a
|
||||||
|
couple of caveats to the premature optimisation rule:</p>
|
||||||
|
<ul>
|
||||||
|
<li>If you use the right algorithm for the job in the first place then
|
||||||
|
optimisation will not be required; in some cases, <font size="2" face="Courier New">memcpy</font>
|
||||||
|
is the right algorithm.</li>
|
||||||
|
<li>If a component is going to be reused in many places by many people then
|
||||||
|
optimisations may well be worthwhile where they would not be so for a single
|
||||||
|
case - in other words, the likelihood that the optimisation will be
|
||||||
|
absolutely necessary somewhere, sometime is that much higher. Just as
|
||||||
|
importantly the perceived value of the stock implementation will be higher:
|
||||||
|
there is no point standardising an algorithm if users reject it on the
|
||||||
|
grounds that there are better, more heavily optimised versions available.</li>
|
||||||
|
</ul>
|
||||||
|
<h4>Table 1: Time taken to copy 1000 elements using copy<const T*, T*>
|
||||||
|
(times in micro-seconds)</h4>
|
||||||
|
<table border="1" cellpadding="7" cellspacing="1" width="529">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="33%">
|
||||||
|
<p align="center">Version</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="33%">
|
||||||
|
<p align="center">T</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="33%">
|
||||||
|
<p align="center">Time</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="33%">"Optimised" copy</td>
|
||||||
|
<td valign="top" width="33%">char</td>
|
||||||
|
<td valign="top" width="33%">0.99</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="33%">Conventional copy</td>
|
||||||
|
<td valign="top" width="33%">char</td>
|
||||||
|
<td valign="top" width="33%">8.07</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="33%">"Optimised" copy</td>
|
||||||
|
<td valign="top" width="33%">int</td>
|
||||||
|
<td valign="top" width="33%">2.52</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="33%">Conventional copy</td>
|
||||||
|
<td valign="top" width="33%">int</td>
|
||||||
|
<td valign="top" width="33%">8.02</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
<p> </p>
|
||||||
|
<h4>Pair of References</h4>
|
||||||
|
<p>The optimised copy example shows how type traits may be used to perform
|
||||||
|
optimisation decisions at compile-time. Another important usage of type traits
|
||||||
|
is to allow code to compile that otherwise would not do so unless excessive
|
||||||
|
partial specialization is used. This is possible by delegating partial
|
||||||
|
specialization to the type traits classes. Our example for this form of usage is
|
||||||
|
a pair that can hold references [6].</p>
|
||||||
|
<p>First, let us examine the definition of "std::pair", omitting the
|
||||||
|
comparision operators, default constructor, and template copy constructor for
|
||||||
|
simplicity:</p>
|
||||||
|
<pre>template <typename T1, typename T2>
|
||||||
|
struct pair
|
||||||
|
{
|
||||||
|
typedef T1 first_type;
|
||||||
|
typedef T2 second_type;
|
||||||
|
|
||||||
|
T1 first;
|
||||||
|
T2 second;
|
||||||
|
|
||||||
|
pair(const T1 & nfirst, const T2 & nsecond)
|
||||||
|
:first(nfirst), second(nsecond) { }
|
||||||
|
};</pre>
|
||||||
|
<p>Now, this "pair" cannot hold references as it currently stands,
|
||||||
|
because the constructor would require taking a reference to a reference, which
|
||||||
|
is currently illegal [7]. Let us consider what the constructor's parameters
|
||||||
|
would have to be in order to allow "pair" to hold non-reference types,
|
||||||
|
references, and constant references:</p>
|
||||||
|
<table border="1" cellpadding="7" cellspacing="1" width="638">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%">Type of "T1"</td>
|
||||||
|
<td valign="top" width="50%">Type of parameter to initializing constructor</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%">
|
||||||
|
<pre>T</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="50%">
|
||||||
|
<pre>const T &</pre>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%">
|
||||||
|
<pre>T &</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="50%">
|
||||||
|
<pre>T &</pre>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%">
|
||||||
|
<pre>const T &</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="50%">
|
||||||
|
<pre>const T &</pre>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
<p>A little familiarity with the type traits classes allows us to construct a
|
||||||
|
single mapping that allows us to determine the type of parameter from the type
|
||||||
|
of the contained class. The type traits classes provide a transformation "add_reference",
|
||||||
|
which adds a reference to its type, unless it is already a reference.</p>
|
||||||
|
<table border="1" cellpadding="7" cellspacing="1" width="580">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="21%">Type of "T1"</td>
|
||||||
|
<td valign="top" width="27%">Type of "const T1"</td>
|
||||||
|
<td valign="top" width="53%">Type of "add_reference<const
|
||||||
|
T1>::type"</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="21%">
|
||||||
|
<pre>T</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="27%">
|
||||||
|
<pre>const T</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="53%">
|
||||||
|
<pre>const T &</pre>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="21%">
|
||||||
|
<pre>T &</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="27%">
|
||||||
|
<pre>T & [8]</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="53%">
|
||||||
|
<pre>T &</pre>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="21%">
|
||||||
|
<pre>const T &</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="27%">
|
||||||
|
<pre>const T &</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="53%">
|
||||||
|
<pre>const T &</pre>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
<p>This allows us to build a primary template definition for "pair"
|
||||||
|
that can contain non-reference types, reference types, and constant reference
|
||||||
|
types:</p>
|
||||||
|
<pre>template <typename T1, typename T2>
|
||||||
|
struct pair
|
||||||
|
{
|
||||||
|
typedef T1 first_type;
|
||||||
|
typedef T2 second_type;
|
||||||
|
|
||||||
|
T1 first;
|
||||||
|
T2 second;
|
||||||
|
|
||||||
|
pair(boost::add_reference<const T1>::type nfirst,
|
||||||
|
boost::add_reference<const T2>::type nsecond)
|
||||||
|
:first(nfirst), second(nsecond) { }
|
||||||
|
};</pre>
|
||||||
|
<p>Add back in the standard comparision operators, default constructor, and
|
||||||
|
template copy constructor (which are all the same), and you have a std::pair
|
||||||
|
that can hold reference types!</p>
|
||||||
|
<p>This same extension <i>could</i> have been done using partial template
|
||||||
|
specialization of "pair", but to specialize "pair" in this
|
||||||
|
way would require three partial specializations, plus the primary template. Type
|
||||||
|
traits allows us to define a single primary template that adjusts itself
|
||||||
|
auto-magically to any of these partial specializations, instead of a brute-force
|
||||||
|
partial specialization approach. Using type traits in this fashion allows
|
||||||
|
programmers to delegate partial specialization to the type traits classes,
|
||||||
|
resulting in code that is easier to maintain and easier to understand.</p>
|
||||||
|
<h4>Conclusion</h4>
|
||||||
|
<p>We hope that in this article we have been able to give you some idea of what
|
||||||
|
type-traits are all about. A more complete listing of the available classes are
|
||||||
|
in the boost documentation, along with further examples using type traits.
|
||||||
|
Templates have enabled C++ uses to take the advantage of the code reuse that
|
||||||
|
generic programming brings; hopefully this article has shown that generic
|
||||||
|
programming does not have to sink to the lowest common denominator, and that
|
||||||
|
templates can be optimal as well as generic.</p>
|
||||||
|
<h4>Acknowledgements</h4>
|
||||||
|
<p>The authors would like to thank Beman Dawes and Howard Hinnant for their
|
||||||
|
helpful comments when preparing this article.</p>
|
||||||
|
<h4>References</h4>
|
||||||
|
<ol>
|
||||||
|
<li>Nathan C. Myers, C++ Report, June 1995.</li>
|
||||||
|
<li>The type traits library is based upon contributions by Steve Cleary, Beman
|
||||||
|
Dawes, Howard Hinnant and John Maddock: it can be found at www.boost.org.</li>
|
||||||
|
<li>A scalar type is an arithmetic type (i.e. a built-in integer or floating
|
||||||
|
point type), an enumeration type, a pointer, a pointer to member, or a
|
||||||
|
const- or volatile-qualified version of one of these types.</li>
|
||||||
|
<li>This quote is from Donald Knuth, ACM Computing Surveys, December 1974, pg
|
||||||
|
268.</li>
|
||||||
|
<li>The test code is available as part of the boost utility library (see
|
||||||
|
algo_opt_examples.cpp), the code was compiled with gcc 2.95 with all
|
||||||
|
optimisations turned on, tests were conducted on a 400MHz Pentium II machine
|
||||||
|
running Microsoft Windows 98.</li>
|
||||||
|
<li>John Maddock and Howard Hinnant have submitted a "compressed_pair"
|
||||||
|
library to Boost, which uses a technique similar to the one described here
|
||||||
|
to hold references. Their pair also uses type traits to determine if any of
|
||||||
|
the types are empty, and will derive instead of contain to conserve space --
|
||||||
|
hence the name "compressed".</li>
|
||||||
|
<li>This is actually an issue with the C++ Core Language Working Group (issue
|
||||||
|
#106), submitted by Bjarne Stroustrup. The tentative resolution is to allow
|
||||||
|
a "reference to a reference to T" to mean the same thing as a
|
||||||
|
"reference to T", but only in template instantiation, in a method
|
||||||
|
similar to multiple cv-qualifiers.</li>
|
||||||
|
<li>For those of you who are wondering why this shouldn't be const-qualified,
|
||||||
|
remember that references are always implicitly constant (for example, you
|
||||||
|
can't re-assign a reference). Remember also that "const T &"
|
||||||
|
is something completely different. For this reason, cv-qualifiers on
|
||||||
|
template type arguments that are references are ignored.</li>
|
||||||
|
</ol>
|
||||||
|
<h2>Listing 1</h2>
|
||||||
|
<pre>namespace detail{
|
||||||
|
|
||||||
|
template <bool b>
|
||||||
|
struct copier
|
||||||
|
{
|
||||||
|
template<typename I1, typename I2>
|
||||||
|
static I2 do_copy(I1 first,
|
||||||
|
I1 last, I2 out);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <bool b>
|
||||||
|
template<typename I1, typename I2>
|
||||||
|
I2 copier<b>::do_copy(I1 first,
|
||||||
|
I1 last,
|
||||||
|
I2 out)
|
||||||
|
{
|
||||||
|
while(first != last)
|
||||||
|
{
|
||||||
|
*out = *first;
|
||||||
|
++out;
|
||||||
|
++first;
|
||||||
|
}
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct copier<true>
|
||||||
|
{
|
||||||
|
template<typename I1, typename I2>
|
||||||
|
static I2* do_copy(I1* first, I1* last, I2* out)
|
||||||
|
{
|
||||||
|
memcpy(out, first, (last-first)*sizeof(I2));
|
||||||
|
return out+(last-first);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename I1, typename I2>
|
||||||
|
inline I2 copy(I1 first, I1 last, I2 out)
|
||||||
|
{
|
||||||
|
typedef typename
|
||||||
|
boost::remove_cv<
|
||||||
|
typename std::iterator_traits<I1>
|
||||||
|
::value_type>::type v1_t;
|
||||||
|
|
||||||
|
typedef typename
|
||||||
|
boost::remove_cv<
|
||||||
|
typename std::iterator_traits<I2>
|
||||||
|
::value_type>::type v2_t;
|
||||||
|
|
||||||
|
enum{ can_opt =
|
||||||
|
boost::is_same<v1_t, v2_t>::value
|
||||||
|
&& boost::is_pointer<I1>::value
|
||||||
|
&& boost::is_pointer<I2>::value
|
||||||
|
&& boost::
|
||||||
|
has_trivial_assign<v1_t>::value
|
||||||
|
};
|
||||||
|
|
||||||
|
return detail::copier<can_opt>::
|
||||||
|
do_copy(first, last, out);
|
||||||
|
}</pre>
|
||||||
|
<hr>
|
||||||
|
<p><EFBFBD> Copyright John Maddock and Steve Cleary, 2000</p>
|
||||||
|
|
||||||
|
</body>
|
||||||
|
|
||||||
|
</html>
|
||||||
131
call_traits.htm
131
call_traits.htm
@@ -12,7 +12,7 @@ content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
|
|||||||
<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
|
<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
|
||||||
vlink="#800080">
|
vlink="#800080">
|
||||||
|
|
||||||
<h1><img src="../../boost.png" width="276" height="86">Header
|
<h1><img src="../../c++boost.gif" width="276" height="86">Header
|
||||||
<<a href="../../boost/detail/call_traits.hpp">boost/call_traits.hpp</a>></h1>
|
<<a href="../../boost/detail/call_traits.hpp">boost/call_traits.hpp</a>></h1>
|
||||||
|
|
||||||
<p>All of the contents of <boost/call_traits.hpp> are
|
<p>All of the contents of <boost/call_traits.hpp> are
|
||||||
@@ -27,16 +27,10 @@ never occur, and that parameters are passed in the most efficient
|
|||||||
manner possible (see <a href="#examples">examples</a>). In each
|
manner possible (see <a href="#examples">examples</a>). In each
|
||||||
case if your existing practice is to use the type defined on the
|
case if your existing practice is to use the type defined on the
|
||||||
left, then replace it with the call_traits defined type on the
|
left, then replace it with the call_traits defined type on the
|
||||||
right. </p>
|
right. Note that for compilers that do not support partial
|
||||||
|
specialization, no benefit will occur from using call_traits: the
|
||||||
<p>Note that for compilers that do not support either partial
|
call_traits defined types will always be the same as the existing
|
||||||
specialization or member templates, no benefit will occur from
|
practice in this case.</p>
|
||||||
using call_traits: the call_traits defined types will always be
|
|
||||||
the same as the existing practice in this case. In addition if
|
|
||||||
only member templates and not partial template specialisation is
|
|
||||||
support by the compiler (for example Visual C++ 6) then
|
|
||||||
call_traits can not be used with array types (although it can be
|
|
||||||
used to solve the reference to reference problem).</p>
|
|
||||||
|
|
||||||
<table border="0" cellpadding="7" cellspacing="1" width="797">
|
<table border="0" cellpadding="7" cellspacing="1" width="797">
|
||||||
<tr>
|
<tr>
|
||||||
@@ -79,8 +73,7 @@ used to solve the reference to reference problem).</p>
|
|||||||
</td>
|
</td>
|
||||||
</tr>
|
</tr>
|
||||||
<tr>
|
<tr>
|
||||||
<td valign="top" width="17%"><p align="center">const
|
<td valign="top" width="17%"><p align="center">const T&<br>
|
||||||
T&<br>
|
|
||||||
(return value)</p>
|
(return value)</p>
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="35%"><p align="center"><code>call_traits<T>::const_reference</code></p>
|
<td valign="top" width="35%"><p align="center"><code>call_traits<T>::const_reference</code></p>
|
||||||
@@ -92,8 +85,7 @@ used to solve the reference to reference problem).</p>
|
|||||||
</td>
|
</td>
|
||||||
</tr>
|
</tr>
|
||||||
<tr>
|
<tr>
|
||||||
<td valign="top" width="17%"><p align="center">const
|
<td valign="top" width="17%"><p align="center">const T&<br>
|
||||||
T&<br>
|
|
||||||
(function parameter)</p>
|
(function parameter)</p>
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="35%"><p align="center"><code>call_traits<T>::param_type</code></p>
|
<td valign="top" width="35%"><p align="center"><code>call_traits<T>::param_type</code></p>
|
||||||
@@ -334,8 +326,8 @@ possible:</p>
|
|||||||
<p>The following table shows the effect that call_traits has on
|
<p>The following table shows the effect that call_traits has on
|
||||||
various types, the table assumes that the compiler supports
|
various types, the table assumes that the compiler supports
|
||||||
partial specialization: if it doesn't then all types behave in
|
partial specialization: if it doesn't then all types behave in
|
||||||
the same way as the entry for "myclass", and
|
the same way as the entry for "myclass", and call_traits
|
||||||
call_traits can not be used with reference or array types.</p>
|
can not be used with reference or array types.</p>
|
||||||
|
|
||||||
<table border="0" cellpadding="7" cellspacing="1" width="766">
|
<table border="0" cellpadding="7" cellspacing="1" width="766">
|
||||||
<tr>
|
<tr>
|
||||||
@@ -390,8 +382,7 @@ call_traits can not be used with reference or array types.</p>
|
|||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">int&</p>
|
<td valign="top" width="17%"><p align="center">int&</p>
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">const
|
<td valign="top" width="17%"><p align="center">const int&</p>
|
||||||
int&</p>
|
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">int const</p>
|
<td valign="top" width="17%"><p align="center">int const</p>
|
||||||
</td>
|
</td>
|
||||||
@@ -423,8 +414,7 @@ call_traits can not be used with reference or array types.</p>
|
|||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">int&</p>
|
<td valign="top" width="17%"><p align="center">int&</p>
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">const
|
<td valign="top" width="17%"><p align="center">const int&</p>
|
||||||
int&</p>
|
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">int&</p>
|
<td valign="top" width="17%"><p align="center">int&</p>
|
||||||
</td>
|
</td>
|
||||||
@@ -436,17 +426,13 @@ call_traits can not be used with reference or array types.</p>
|
|||||||
<td valign="top" width="17%" bgcolor="#C0C0C0"><p
|
<td valign="top" width="17%" bgcolor="#C0C0C0"><p
|
||||||
align="center">const int&</p>
|
align="center">const int&</p>
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">const
|
<td valign="top" width="17%"><p align="center">const int&</p>
|
||||||
int&</p>
|
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">const
|
<td valign="top" width="17%"><p align="center">const int&</p>
|
||||||
int&</p>
|
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">const
|
<td valign="top" width="17%"><p align="center">const int&</p>
|
||||||
int&</p>
|
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">const
|
<td valign="top" width="17%"><p align="center">const int&</p>
|
||||||
int&</p>
|
|
||||||
</td>
|
</td>
|
||||||
<td valign="top" width="17%"><p align="center">All
|
<td valign="top" width="17%"><p align="center">All
|
||||||
constant-references.</p>
|
constant-references.</p>
|
||||||
@@ -494,8 +480,8 @@ call_traits can not be used with reference or array types.</p>
|
|||||||
|
|
||||||
<p>The following class is a trivial class that stores some type T
|
<p>The following class is a trivial class that stores some type T
|
||||||
by value (see the <a href="call_traits_test.cpp">call_traits_test.cpp</a>
|
by value (see the <a href="call_traits_test.cpp">call_traits_test.cpp</a>
|
||||||
file), the aim is to illustrate how each of the available
|
file), the aim is to illustrate how each of the available call_traits
|
||||||
call_traits typedefs may be used:</p>
|
typedefs may be used:</p>
|
||||||
|
|
||||||
<pre>template <class T>
|
<pre>template <class T>
|
||||||
struct contained
|
struct contained
|
||||||
@@ -531,14 +517,14 @@ problem):</h4>
|
|||||||
|
|
||||||
<pre>template <class Operation>
|
<pre>template <class Operation>
|
||||||
class binder1st :
|
class binder1st :
|
||||||
public unary_function<typename Operation::second_argument_type, typename Operation::result_type>
|
public unary_function<Operation::second_argument_type, Operation::result_type>
|
||||||
{
|
{
|
||||||
protected:
|
protected:
|
||||||
Operation op;
|
Operation op;
|
||||||
typename Operation::first_argument_type value;
|
Operation::first_argument_type value;
|
||||||
public:
|
public:
|
||||||
binder1st(const Operation& x, const typename Operation::first_argument_type& y);
|
binder1st(const Operation& x, const Operation::first_argument_type& y);
|
||||||
typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
|
Operation::result_type operator()(const Operation::second_argument_type& x) const;
|
||||||
}; </pre>
|
}; </pre>
|
||||||
|
|
||||||
<p>Now consider what happens in the relatively common case that
|
<p>Now consider what happens in the relatively common case that
|
||||||
@@ -549,7 +535,7 @@ reference to a reference as an argument, and that is not
|
|||||||
currently legal. The solution here is to modify <code>operator()</code>
|
currently legal. The solution here is to modify <code>operator()</code>
|
||||||
to use call_traits:</p>
|
to use call_traits:</p>
|
||||||
|
|
||||||
<pre>typename Operation::result_type operator()(typename call_traits<typename Operation::second_argument_type>::param_type x) const;</pre>
|
<pre>Operation::result_type operator()(call_traits<Operation::second_argument_type>::param_type x) const;</pre>
|
||||||
|
|
||||||
<p>Now in the case that <code>Operation::second_argument_type</code>
|
<p>Now in the case that <code>Operation::second_argument_type</code>
|
||||||
is a reference type, the argument is passed as a reference, and
|
is a reference type, the argument is passed as a reference, and
|
||||||
@@ -583,17 +569,14 @@ std::pair<
|
|||||||
degraded to pointers if the deduced types are arrays, similar
|
degraded to pointers if the deduced types are arrays, similar
|
||||||
situations occur in the standard binders and adapters: in
|
situations occur in the standard binders and adapters: in
|
||||||
principle in any function that "wraps" a temporary
|
principle in any function that "wraps" a temporary
|
||||||
whose type is deduced. Note that the function arguments to
|
whose type is deduced.</p>
|
||||||
make_pair are not expressed in terms of call_traits: doing so
|
|
||||||
would prevent template argument deduction from functioning.</p>
|
|
||||||
|
|
||||||
<h4><a name="ex4"></a>Example 4 (optimising fill):</h4>
|
<h4><a name="ex4"></a>Example 4 (optimising fill):</h4>
|
||||||
|
|
||||||
<p>The call_traits template will "optimize" the passing
|
<p>The call_traits template will "optimize" the passing
|
||||||
of a small built-in type as a function parameter, this mainly has
|
of a small built-in type as a function parameter, this mainly has
|
||||||
an effect when the parameter is used within a loop body. In the
|
an effect when the parameter is used within a loop body. In the
|
||||||
following example (see <a
|
following example (see <a href="algo_opt_examples.cpp">algo_opt_examples.cpp</a>),
|
||||||
href="../type_traits/examples/fill_example.cpp">fill_example.cpp</a>),
|
|
||||||
a version of std::fill is optimized in two ways: if the type
|
a version of std::fill is optimized in two ways: if the type
|
||||||
passed is a single byte built-in type then std::memset is used to
|
passed is a single byte built-in type then std::memset is used to
|
||||||
effect the fill, otherwise a conventional C++ implemention is
|
effect the fill, otherwise a conventional C++ implemention is
|
||||||
@@ -606,7 +589,7 @@ template <bool opt>
|
|||||||
struct filler
|
struct filler
|
||||||
{
|
{
|
||||||
template <typename I, typename T>
|
template <typename I, typename T>
|
||||||
static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val)
|
static void do_fill(I first, I last, typename boost::call_traits<T>::param_type val);
|
||||||
{
|
{
|
||||||
while(first != last)
|
while(first != last)
|
||||||
{
|
{
|
||||||
@@ -649,14 +632,6 @@ Exactly how much mileage you will get from this depends upon your
|
|||||||
compiler - we could really use some accurate benchmarking
|
compiler - we could really use some accurate benchmarking
|
||||||
software as part of boost for cases like this.</p>
|
software as part of boost for cases like this.</p>
|
||||||
|
|
||||||
<p>Note that the function arguments to fill are not expressed in
|
|
||||||
terms of call_traits: doing so would prevent template argument
|
|
||||||
deduction from functioning. Instead fill acts as a "thin
|
|
||||||
wrapper" that is there to perform template argument
|
|
||||||
deduction, the compiler will optimise away the call to fill all
|
|
||||||
together, replacing it with the call to filler<>::do_fill,
|
|
||||||
which does use call_traits.</p>
|
|
||||||
|
|
||||||
<h3>Rationale</h3>
|
<h3>Rationale</h3>
|
||||||
|
|
||||||
<p>The following notes are intended to briefly describe the
|
<p>The following notes are intended to briefly describe the
|
||||||
@@ -675,10 +650,10 @@ be any worse than existing practice.</p>
|
|||||||
<p>Pointers follow the same rational as small built-in types.</p>
|
<p>Pointers follow the same rational as small built-in types.</p>
|
||||||
|
|
||||||
<p>For reference types the rational follows <a href="#refs">Example
|
<p>For reference types the rational follows <a href="#refs">Example
|
||||||
2</a> - references to references are not allowed, so the
|
2</a> - references to references are not allowed, so the call_traits
|
||||||
call_traits members must be defined such that these problems do
|
members must be defined such that these problems do not occur.
|
||||||
not occur. There is a proposal to modify the language such that
|
There is a proposal to modify the language such that "a
|
||||||
"a reference to a reference is a reference" (issue #106,
|
reference to a reference is a reference" (issue #106,
|
||||||
submitted by Bjarne Stroustrup), call_traits<T>::value_type
|
submitted by Bjarne Stroustrup), call_traits<T>::value_type
|
||||||
and call_traits<T>::param_type both provide the same effect
|
and call_traits<T>::param_type both provide the same effect
|
||||||
as that proposal, without the need for a language change (in
|
as that proposal, without the need for a language change (in
|
||||||
@@ -696,11 +671,11 @@ struct A
|
|||||||
void foo(T t);
|
void foo(T t);
|
||||||
};</pre>
|
};</pre>
|
||||||
|
|
||||||
<p><font face="Times New Roman">In this case if we instantiate
|
<p><font face="Times New Roman">In this case if we instantiate A<int[2]>
|
||||||
A<int[2]> then the declared type of the parameter passed to
|
then the declared type of the parameter passed to member function
|
||||||
member function foo is int[2], but it's actual type is const int*,
|
foo is int[2], but it's actual type is const int*, if we try to
|
||||||
if we try to use the type T within the function body, then there
|
use the type T within the function body, then there is a strong
|
||||||
is a strong likelyhood that our code will not compile:</font></p>
|
likelyhood that our code will not compile:</font></p>
|
||||||
|
|
||||||
<pre>template <class T>
|
<pre>template <class T>
|
||||||
void A<T>::foo(T t)
|
void A<T>::foo(T t)
|
||||||
@@ -715,13 +690,13 @@ declared type:</p>
|
|||||||
<pre>template <class T>
|
<pre>template <class T>
|
||||||
struct A
|
struct A
|
||||||
{
|
{
|
||||||
void foo(typename call_traits<T>::value_type t);
|
void foo(call_traits<T>::value_type t);
|
||||||
};
|
};
|
||||||
|
|
||||||
template <class T>
|
template <class T>
|
||||||
void A<T>::foo(typename call_traits<T>::value_type t)
|
void A<T>::foo(call_traits<T>::value_type t)
|
||||||
{
|
{
|
||||||
typename call_traits<T>::value_type dup(t); // OK even if T is an array type.
|
call_traits<T>::value_type dup(t); // OK even if T is an array type.
|
||||||
}</pre>
|
}</pre>
|
||||||
|
|
||||||
<p>For value_type (return by value), again only a pointer may be
|
<p>For value_type (return by value), again only a pointer may be
|
||||||
@@ -738,18 +713,26 @@ specialisation).</p>
|
|||||||
|
|
||||||
<hr>
|
<hr>
|
||||||
|
|
||||||
<p>Revised 01 September 2000</p>
|
<p>Revised 18 June 2000</p>
|
||||||
|
|
||||||
<p>
|
<p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
|
||||||
Copyright 2000 Steve Cleary, Beman Dawes, Howard
|
sell and distribute this document is granted provided this
|
||||||
Hinnant and John Maddock. <br/>
|
copyright notice appears in all copies. This document is provided
|
||||||
Use, modification and distribution are subject to the
|
"as is" without express or implied warranty, and with
|
||||||
Boost Software License, Version 1.0.
|
no claim as to its suitability for any purpose.</p>
|
||||||
(See accompanying file LICENSE_1_0.txt
|
|
||||||
or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
|
<p>Based on contributions by Steve Cleary, Beman Dawes, Howard
|
||||||
http://www.boost.org/LICENSE_1_0.txt
|
Hinnant and John Maddock.</p>
|
||||||
</a>).
|
|
||||||
</p>
|
<p>Maintained by <a href="mailto:John_Maddock@compuserve.com">John
|
||||||
|
Maddock</a>, the latest version of this file can be found at <a
|
||||||
|
href="http://www.boost.org/">www.boost.org</a>, and the boost
|
||||||
|
discussion list at <a href="http://www.egroups.com/list/boost">www.egroups.com/list/boost</a>.</p>
|
||||||
|
|
||||||
|
<p>.</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
</body>
|
</body>
|
||||||
</html>
|
</html>
|
||||||
|
|
||||||
|
|||||||
@@ -1,33 +1,20 @@
|
|||||||
// boost::compressed_pair test program
|
// boost::compressed_pair test program
|
||||||
|
|
||||||
// (C) Copyright John Maddock 2000.
|
// (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and
|
||||||
// Use, modification and distribution are subject to the Boost Software License,
|
// distribute this software is granted provided this copyright notice appears
|
||||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
// http://www.boost.org/LICENSE_1_0.txt).
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
|
|
||||||
|
|
||||||
// standalone test program for <boost/call_traits.hpp>
|
// standalone test program for <boost/call_traits.hpp>
|
||||||
// 18 Mar 2002:
|
|
||||||
// Changed some names to prevent conflicts with some new type_traits additions.
|
|
||||||
// 03 Oct 2000:
|
|
||||||
// Enabled extra tests for VC6.
|
|
||||||
|
|
||||||
|
#include <cassert>
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
#include <iomanip>
|
#include <iomanip>
|
||||||
#include <algorithm>
|
#include <algorithm>
|
||||||
#include <typeinfo>
|
#include <typeinfo>
|
||||||
#include <boost/call_traits.hpp>
|
#include <boost/call_traits.hpp>
|
||||||
|
|
||||||
#include <libs/type_traits/test/test.hpp>
|
#include "type_traits_test.hpp"
|
||||||
#include <libs/type_traits/test/check_type.hpp>
|
|
||||||
|
|
||||||
#ifdef BOOST_MSVC
|
|
||||||
#pragma warning(disable:4181) // : warning C4181: qualifier applied to reference type; ignored
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// a way prevent warnings for unused variables
|
|
||||||
template<class T> inline void unused_variable(const T&) {}
|
|
||||||
|
|
||||||
//
|
//
|
||||||
// struct contained models a type that contains a type (for example std::pair)
|
// struct contained models a type that contains a type (for example std::pair)
|
||||||
// arrays are contained by value, and have to be treated as a special case:
|
// arrays are contained by value, and have to be treated as a special case:
|
||||||
@@ -55,9 +42,8 @@ struct contained
|
|||||||
reference get() { return v_; }
|
reference get() { return v_; }
|
||||||
const_reference const_get()const { return v_; }
|
const_reference const_get()const { return v_; }
|
||||||
// pass value:
|
// pass value:
|
||||||
void call(param_type){}
|
void call(param_type p){}
|
||||||
private:
|
|
||||||
contained& operator=(const contained&);
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
@@ -81,14 +67,12 @@ struct contained<T[N]>
|
|||||||
// return by_ref:
|
// return by_ref:
|
||||||
reference get() { return v_; }
|
reference get() { return v_; }
|
||||||
const_reference const_get()const { return v_; }
|
const_reference const_get()const { return v_; }
|
||||||
void call(param_type){}
|
void call(param_type p){}
|
||||||
private:
|
|
||||||
contained& operator=(const contained&);
|
|
||||||
};
|
};
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
template <class T>
|
template <class T>
|
||||||
contained<typename boost::call_traits<T>::value_type> test_wrap_type(const T& t)
|
contained<typename boost::call_traits<T>::value_type> wrap(const T& t)
|
||||||
{
|
{
|
||||||
typedef typename boost::call_traits<T>::value_type ct;
|
typedef typename boost::call_traits<T>::value_type ct;
|
||||||
return contained<ct>(t);
|
return contained<ct>(t);
|
||||||
@@ -112,38 +96,37 @@ std::pair<
|
|||||||
using namespace std;
|
using namespace std;
|
||||||
|
|
||||||
//
|
//
|
||||||
// struct call_traits_checker:
|
// struct checker:
|
||||||
// verifies behaviour of contained example:
|
// verifies behaviour of contained example:
|
||||||
//
|
//
|
||||||
template <class T>
|
template <class T>
|
||||||
struct call_traits_checker
|
struct checker
|
||||||
{
|
{
|
||||||
typedef typename boost::call_traits<T>::param_type param_type;
|
typedef typename boost::call_traits<T>::param_type param_type;
|
||||||
void operator()(param_type);
|
void operator()(param_type);
|
||||||
};
|
};
|
||||||
|
|
||||||
template <class T>
|
template <class T>
|
||||||
void call_traits_checker<T>::operator()(param_type p)
|
void checker<T>::operator()(param_type p)
|
||||||
{
|
{
|
||||||
T t(p);
|
T t(p);
|
||||||
contained<T> c(t);
|
contained<T> c(t);
|
||||||
cout << "checking contained<" << typeid(T).name() << ">..." << endl;
|
cout << "checking contained<" << typeid(T).name() << ">..." << endl;
|
||||||
BOOST_CHECK(t == c.value());
|
assert(t == c.value());
|
||||||
BOOST_CHECK(t == c.get());
|
assert(t == c.get());
|
||||||
BOOST_CHECK(t == c.const_get());
|
assert(t == c.const_get());
|
||||||
#ifndef __ICL
|
|
||||||
//cout << "typeof contained<" << typeid(T).name() << ">::v_ is: " << typeid(&contained<T>::v_).name() << endl;
|
cout << "typeof contained<" << typeid(T).name() << ">::v_ is: " << typeid(&contained<T>::v_).name() << endl;
|
||||||
cout << "typeof contained<" << typeid(T).name() << ">::value() is: " << typeid(&contained<T>::value).name() << endl;
|
cout << "typeof contained<" << typeid(T).name() << ">::value() is: " << typeid(&contained<T>::value).name() << endl;
|
||||||
cout << "typeof contained<" << typeid(T).name() << ">::get() is: " << typeid(&contained<T>::get).name() << endl;
|
cout << "typeof contained<" << typeid(T).name() << ">::get() is: " << typeid(&contained<T>::get).name() << endl;
|
||||||
cout << "typeof contained<" << typeid(T).name() << ">::const_get() is: " << typeid(&contained<T>::const_get).name() << endl;
|
cout << "typeof contained<" << typeid(T).name() << ">::const_get() is: " << typeid(&contained<T>::const_get).name() << endl;
|
||||||
cout << "typeof contained<" << typeid(T).name() << ">::call() is: " << typeid(&contained<T>::call).name() << endl;
|
cout << "typeof contained<" << typeid(T).name() << ">::call() is: " << typeid(&contained<T>::call).name() << endl;
|
||||||
cout << endl;
|
cout << endl;
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
template <class T, std::size_t N>
|
template <class T, std::size_t N>
|
||||||
struct call_traits_checker<T[N]>
|
struct checker<T[N]>
|
||||||
{
|
{
|
||||||
typedef typename boost::call_traits<T[N]>::param_type param_type;
|
typedef typename boost::call_traits<T[N]>::param_type param_type;
|
||||||
void operator()(param_type t)
|
void operator()(param_type t)
|
||||||
@@ -152,11 +135,11 @@ struct call_traits_checker<T[N]>
|
|||||||
cout << "checking contained<" << typeid(T[N]).name() << ">..." << endl;
|
cout << "checking contained<" << typeid(T[N]).name() << ">..." << endl;
|
||||||
unsigned int i = 0;
|
unsigned int i = 0;
|
||||||
for(i = 0; i < N; ++i)
|
for(i = 0; i < N; ++i)
|
||||||
BOOST_CHECK(t[i] == c.value()[i]);
|
assert(t[i] == c.value()[i]);
|
||||||
for(i = 0; i < N; ++i)
|
for(i = 0; i < N; ++i)
|
||||||
BOOST_CHECK(t[i] == c.get()[i]);
|
assert(t[i] == c.get()[i]);
|
||||||
for(i = 0; i < N; ++i)
|
for(i = 0; i < N; ++i)
|
||||||
BOOST_CHECK(t[i] == c.const_get()[i]);
|
assert(t[i] == c.const_get()[i]);
|
||||||
|
|
||||||
cout << "typeof contained<" << typeid(T[N]).name() << ">::v_ is: " << typeid(&contained<T[N]>::v_).name() << endl;
|
cout << "typeof contained<" << typeid(T[N]).name() << ">::v_ is: " << typeid(&contained<T[N]>::v_).name() << endl;
|
||||||
cout << "typeof contained<" << typeid(T[N]).name() << ">::value is: " << typeid(&contained<T[N]>::value).name() << endl;
|
cout << "typeof contained<" << typeid(T[N]).name() << ">::value is: " << typeid(&contained<T[N]>::value).name() << endl;
|
||||||
@@ -170,11 +153,11 @@ struct call_traits_checker<T[N]>
|
|||||||
|
|
||||||
//
|
//
|
||||||
// check_wrap:
|
// check_wrap:
|
||||||
template <class W, class U>
|
template <class T, class U>
|
||||||
void check_wrap(const W& w, const U& u)
|
void check_wrap(const contained<T>& w, const U& u)
|
||||||
{
|
{
|
||||||
cout << "checking " << typeid(W).name() << "..." << endl;
|
cout << "checking contained<" << typeid(T).name() << ">..." << endl;
|
||||||
BOOST_CHECK(w.value() == u);
|
assert(w.value() == u);
|
||||||
}
|
}
|
||||||
|
|
||||||
//
|
//
|
||||||
@@ -185,53 +168,47 @@ template <class T, class U, class V>
|
|||||||
void check_make_pair(T c, U u, V v)
|
void check_make_pair(T c, U u, V v)
|
||||||
{
|
{
|
||||||
cout << "checking std::pair<" << typeid(c.first).name() << ", " << typeid(c.second).name() << ">..." << endl;
|
cout << "checking std::pair<" << typeid(c.first).name() << ", " << typeid(c.second).name() << ">..." << endl;
|
||||||
BOOST_CHECK(c.first == u);
|
assert(c.first == u);
|
||||||
BOOST_CHECK(c.second == v);
|
assert(c.second == v);
|
||||||
cout << endl;
|
cout << endl;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
struct comparible_UDT
|
struct UDT
|
||||||
{
|
{
|
||||||
int i_;
|
int i_;
|
||||||
comparible_UDT() : i_(2){}
|
UDT() : i_(2){}
|
||||||
comparible_UDT(const comparible_UDT& other) : i_(other.i_){}
|
bool operator == (const UDT& v){ return v.i_ == i_; }
|
||||||
comparible_UDT& operator=(const comparible_UDT& other)
|
|
||||||
{
|
|
||||||
i_ = other.i_;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
bool operator == (const comparible_UDT& v){ return v.i_ == i_; }
|
|
||||||
};
|
};
|
||||||
|
|
||||||
int main()
|
int main()
|
||||||
{
|
{
|
||||||
call_traits_checker<comparible_UDT> c1;
|
checker<UDT> c1;
|
||||||
comparible_UDT u;
|
UDT u;
|
||||||
c1(u);
|
c1(u);
|
||||||
call_traits_checker<int> c2;
|
checker<int> c2;
|
||||||
call_traits_checker<enum_UDT> c2b;
|
|
||||||
int i = 2;
|
int i = 2;
|
||||||
c2(i);
|
c2(i);
|
||||||
c2b(one);
|
|
||||||
int* pi = &i;
|
int* pi = &i;
|
||||||
int a[2] = {1,2};
|
checker<int*> c3;
|
||||||
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) && !defined(__ICL)
|
|
||||||
call_traits_checker<int*> c3;
|
|
||||||
c3(pi);
|
c3(pi);
|
||||||
call_traits_checker<int&> c4;
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
|
checker<int&> c4;
|
||||||
c4(i);
|
c4(i);
|
||||||
call_traits_checker<const int&> c5;
|
checker<const int&> c5;
|
||||||
c5(i);
|
c5(i);
|
||||||
#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__MWERKS__) && !defined(__SUNPRO_CC)
|
|
||||||
call_traits_checker<int[2]> c6;
|
int a[2] = {1,2};
|
||||||
|
checker<int[2]> c6;
|
||||||
c6(a);
|
c6(a);
|
||||||
#endif
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
check_wrap(test_wrap_type(2), 2);
|
check_wrap(wrap(2), 2);
|
||||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
|
const char ca[4] = "abc";
|
||||||
check_wrap(test_wrap_type(a), a);
|
// compiler can't deduce this for some reason:
|
||||||
|
//check_wrap(wrap(ca), ca);
|
||||||
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
|
check_wrap(wrap(a), a);
|
||||||
check_make_pair(test::make_pair(a, a), a, a);
|
check_make_pair(test::make_pair(a, a), a, a);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
@@ -240,71 +217,59 @@ int main()
|
|||||||
typedef int& r_type;
|
typedef int& r_type;
|
||||||
typedef const r_type cr_type;
|
typedef const r_type cr_type;
|
||||||
|
|
||||||
BOOST_CHECK_TYPE(comparible_UDT, boost::call_traits<comparible_UDT>::value_type);
|
type_test(UDT, boost::call_traits<UDT>::value_type)
|
||||||
BOOST_CHECK_TYPE(comparible_UDT&, boost::call_traits<comparible_UDT>::reference);
|
type_test(UDT&, boost::call_traits<UDT>::reference)
|
||||||
BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::const_reference);
|
type_test(const UDT&, boost::call_traits<UDT>::const_reference)
|
||||||
BOOST_CHECK_TYPE(const comparible_UDT&, boost::call_traits<comparible_UDT>::param_type);
|
type_test(const UDT&, boost::call_traits<UDT>::param_type)
|
||||||
BOOST_CHECK_TYPE(int, boost::call_traits<int>::value_type);
|
type_test(int, boost::call_traits<int>::value_type)
|
||||||
BOOST_CHECK_TYPE(int&, boost::call_traits<int>::reference);
|
type_test(int&, boost::call_traits<int>::reference)
|
||||||
BOOST_CHECK_TYPE(const int&, boost::call_traits<int>::const_reference);
|
type_test(const int&, boost::call_traits<int>::const_reference)
|
||||||
BOOST_CHECK_TYPE(const int, boost::call_traits<int>::param_type);
|
type_test(const int, boost::call_traits<int>::param_type)
|
||||||
BOOST_CHECK_TYPE(int*, boost::call_traits<int*>::value_type);
|
type_test(int*, boost::call_traits<int*>::value_type)
|
||||||
BOOST_CHECK_TYPE(int*&, boost::call_traits<int*>::reference);
|
type_test(int*&, boost::call_traits<int*>::reference)
|
||||||
BOOST_CHECK_TYPE(int*const&, boost::call_traits<int*>::const_reference);
|
type_test(int*const&, boost::call_traits<int*>::const_reference)
|
||||||
BOOST_CHECK_TYPE(int*const, boost::call_traits<int*>::param_type);
|
type_test(int*const, boost::call_traits<int*>::param_type)
|
||||||
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES)
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::value_type);
|
type_test(int&, boost::call_traits<int&>::value_type)
|
||||||
BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::reference);
|
type_test(int&, boost::call_traits<int&>::reference)
|
||||||
BOOST_CHECK_TYPE(const int&, boost::call_traits<int&>::const_reference);
|
type_test(const int&, boost::call_traits<int&>::const_reference)
|
||||||
BOOST_CHECK_TYPE(int&, boost::call_traits<int&>::param_type);
|
type_test(int&, boost::call_traits<int&>::param_type)
|
||||||
#if !(defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ < 1)))
|
#if !(defined(__GNUC__) && (__GNUC__ < 3))
|
||||||
BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::value_type);
|
type_test(int&, boost::call_traits<cr_type>::value_type)
|
||||||
BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::reference);
|
type_test(int&, boost::call_traits<cr_type>::reference)
|
||||||
BOOST_CHECK_TYPE(const int&, boost::call_traits<cr_type>::const_reference);
|
type_test(const int&, boost::call_traits<cr_type>::const_reference)
|
||||||
BOOST_CHECK_TYPE(int&, boost::call_traits<cr_type>::param_type);
|
type_test(int&, boost::call_traits<cr_type>::param_type)
|
||||||
#else
|
#else
|
||||||
std::cout << "Your compiler cannot instantiate call_traits<int&const>, skipping four tests (4 errors)" << std::endl;
|
std::cout << "Your compiler cannot instantiate call_traits<int&const>, skipping four tests (4 errors)" << std::endl;
|
||||||
|
failures += 4;
|
||||||
|
test_count += 4;
|
||||||
#endif
|
#endif
|
||||||
BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::value_type);
|
type_test(const int&, boost::call_traits<const int&>::value_type)
|
||||||
BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::reference);
|
type_test(const int&, boost::call_traits<const int&>::reference)
|
||||||
BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::const_reference);
|
type_test(const int&, boost::call_traits<const int&>::const_reference)
|
||||||
BOOST_CHECK_TYPE(const int&, boost::call_traits<const int&>::param_type);
|
type_test(const int&, boost::call_traits<const int&>::param_type)
|
||||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
type_test(const int*, boost::call_traits<int[3]>::value_type)
|
||||||
BOOST_CHECK_TYPE(const int*, boost::call_traits<int[3]>::value_type);
|
type_test(int(&)[3], boost::call_traits<int[3]>::reference)
|
||||||
BOOST_CHECK_TYPE(int(&)[3], boost::call_traits<int[3]>::reference);
|
type_test(const int(&)[3], boost::call_traits<int[3]>::const_reference)
|
||||||
BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<int[3]>::const_reference);
|
type_test(const int*const, boost::call_traits<int[3]>::param_type)
|
||||||
BOOST_CHECK_TYPE(const int*const, boost::call_traits<int[3]>::param_type);
|
type_test(const int*, boost::call_traits<const int[3]>::value_type)
|
||||||
BOOST_CHECK_TYPE(const int*, boost::call_traits<const int[3]>::value_type);
|
type_test(const int(&)[3], boost::call_traits<const int[3]>::reference)
|
||||||
BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::reference);
|
type_test(const int(&)[3], boost::call_traits<const int[3]>::const_reference)
|
||||||
BOOST_CHECK_TYPE(const int(&)[3], boost::call_traits<const int[3]>::const_reference);
|
type_test(const int*const, boost::call_traits<const int[3]>::param_type)
|
||||||
BOOST_CHECK_TYPE(const int*const, boost::call_traits<const int[3]>::param_type);
|
|
||||||
// test with abstract base class:
|
|
||||||
BOOST_CHECK_TYPE(test_abc1, boost::call_traits<test_abc1>::value_type);
|
|
||||||
BOOST_CHECK_TYPE(test_abc1&, boost::call_traits<test_abc1>::reference);
|
|
||||||
BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::const_reference);
|
|
||||||
BOOST_CHECK_TYPE(const test_abc1&, boost::call_traits<test_abc1>::param_type);
|
|
||||||
#else
|
#else
|
||||||
std::cout << "You're compiler does not support partial template specialiation, skipping 8 tests (8 errors)" << std::endl;
|
std::cout << "You're compiler does not support partial template instantiation, skipping 20 tests (20 errors)" << std::endl;
|
||||||
|
failures += 20;
|
||||||
|
test_count += 20;
|
||||||
#endif
|
#endif
|
||||||
#else
|
|
||||||
std::cout << "You're compiler does not support partial template specialiation, skipping 20 tests (20 errors)" << std::endl;
|
std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
|
||||||
#endif
|
std::cin.get();
|
||||||
// test with an incomplete type:
|
return failures;
|
||||||
BOOST_CHECK_TYPE(incomplete_type, boost::call_traits<incomplete_type>::value_type);
|
|
||||||
BOOST_CHECK_TYPE(incomplete_type&, boost::call_traits<incomplete_type>::reference);
|
|
||||||
BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::const_reference);
|
|
||||||
BOOST_CHECK_TYPE(const incomplete_type&, boost::call_traits<incomplete_type>::param_type);
|
|
||||||
// test enum:
|
|
||||||
BOOST_CHECK_TYPE(enum_UDT, boost::call_traits<enum_UDT>::value_type);
|
|
||||||
BOOST_CHECK_TYPE(enum_UDT&, boost::call_traits<enum_UDT>::reference);
|
|
||||||
BOOST_CHECK_TYPE(const enum_UDT&, boost::call_traits<enum_UDT>::const_reference);
|
|
||||||
BOOST_CHECK_TYPE(const enum_UDT, boost::call_traits<enum_UDT>::param_type);
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
//
|
//
|
||||||
// define call_traits tests to check that the assertions in the docs do actually work
|
// define call_traits tests to check that the assertions in the docs do actually work
|
||||||
// this is an compile-time only set of tests:
|
// this is an instantiate only set of tests:
|
||||||
//
|
//
|
||||||
template <typename T, bool isarray = false>
|
template <typename T, bool isarray = false>
|
||||||
struct call_traits_test
|
struct call_traits_test
|
||||||
@@ -339,19 +304,6 @@ void call_traits_test<T, isarray>::assert_construct(typename call_traits_test<T,
|
|||||||
param_type p2(v);
|
param_type p2(v);
|
||||||
param_type p3(r);
|
param_type p3(r);
|
||||||
param_type p4(p);
|
param_type p4(p);
|
||||||
|
|
||||||
unused_variable(v2);
|
|
||||||
unused_variable(v3);
|
|
||||||
unused_variable(v4);
|
|
||||||
unused_variable(r2);
|
|
||||||
unused_variable(r3);
|
|
||||||
unused_variable(cr2);
|
|
||||||
unused_variable(cr3);
|
|
||||||
unused_variable(cr4);
|
|
||||||
unused_variable(cr5);
|
|
||||||
unused_variable(p2);
|
|
||||||
unused_variable(p3);
|
|
||||||
unused_variable(p4);
|
|
||||||
}
|
}
|
||||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
template <typename T>
|
template <typename T>
|
||||||
@@ -366,7 +318,7 @@ struct call_traits_test<T, true>
|
|||||||
};
|
};
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>::param_type val)
|
void call_traits_test<T, true>::assert_construct(boost::call_traits<T>::param_type val)
|
||||||
{
|
{
|
||||||
//
|
//
|
||||||
// this is to check that the call_traits assertions are valid:
|
// this is to check that the call_traits assertions are valid:
|
||||||
@@ -388,19 +340,6 @@ void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>:
|
|||||||
param_type p2(v);
|
param_type p2(v);
|
||||||
param_type p3(r);
|
param_type p3(r);
|
||||||
param_type p4(p);
|
param_type p4(p);
|
||||||
|
|
||||||
unused_variable(v2);
|
|
||||||
unused_variable(v3);
|
|
||||||
unused_variable(v4);
|
|
||||||
unused_variable(v5);
|
|
||||||
#ifndef __BORLANDC__
|
|
||||||
unused_variable(r2);
|
|
||||||
unused_variable(cr2);
|
|
||||||
#endif
|
|
||||||
unused_variable(cr3);
|
|
||||||
unused_variable(p2);
|
|
||||||
unused_variable(p3);
|
|
||||||
unused_variable(p4);
|
|
||||||
}
|
}
|
||||||
#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
//
|
//
|
||||||
@@ -408,11 +347,9 @@ void call_traits_test<T, true>::assert_construct(typename boost::call_traits<T>:
|
|||||||
template struct call_traits_test<int>;
|
template struct call_traits_test<int>;
|
||||||
template struct call_traits_test<const int>;
|
template struct call_traits_test<const int>;
|
||||||
template struct call_traits_test<int*>;
|
template struct call_traits_test<int*>;
|
||||||
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES)
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
template struct call_traits_test<int&>;
|
template struct call_traits_test<int&>;
|
||||||
template struct call_traits_test<const int&>;
|
template struct call_traits_test<const int&>;
|
||||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__SUNPRO_CC)
|
|
||||||
template struct call_traits_test<int[2], true>;
|
template struct call_traits_test<int[2], true>;
|
||||||
#endif
|
#endif
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|||||||
148
cast.htm
Normal file
148
cast.htm
Normal file
@@ -0,0 +1,148 @@
|
|||||||
|
<html>
|
||||||
|
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
||||||
|
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||||
|
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||||
|
<title>Header boost/cast.hpp Documentation</title>
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<body bgcolor="#FFFFFF" text="#000000">
|
||||||
|
|
||||||
|
<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" width="277" height="86">Header
|
||||||
|
<a href="../../boost/cast.hpp">boost/cast.hpp</a></h1>
|
||||||
|
<h2><a name="Cast Functions">Cast Functions</a></h2>
|
||||||
|
<p>The <code>header <a href="../../boost/cast.hpp">boost/cast.hpp</a></code>
|
||||||
|
provides <a href="#Polymorphic_cast"><b>polymorphic_cast</b></a>, <a href="#Polymorphic_cast"><b>polymorphic_downcast</b></a>,
|
||||||
|
and <a href="#numeric_cast"><b>numeric_cast</b></a> template functions designed
|
||||||
|
to complement the C++ Standard's built-in casts.</p>
|
||||||
|
<p>The program <a href="cast_test.cpp">cast_test.cpp</a> can be used to
|
||||||
|
verify these function templates work as expected.</p>
|
||||||
|
<p><b>polymorphic_cast</b> was suggested by Bjarne Stroustrup in "The C++
|
||||||
|
Programming Language".<br>
|
||||||
|
<b>polymorphic_downcast</b> was contributed by <a href="../../people/dave_abrahams.htm">Dave
|
||||||
|
Abrahams</a>.<b><br>
|
||||||
|
numeric_cast</b> was contributed by <a href="../../people/kevlin_henney.htm">Kevlin
|
||||||
|
Henney</a>.</p>
|
||||||
|
<h3>Namespace synopsis</h3>
|
||||||
|
<blockquote>
|
||||||
|
<pre>namespace boost {
|
||||||
|
namespace cast {
|
||||||
|
// all synopsis below included here
|
||||||
|
}
|
||||||
|
using ::boost::cast::polymorphic_cast;
|
||||||
|
using ::boost::cast::polymorphic_downcast;
|
||||||
|
using ::boost::cast::bad_numeric_cast;
|
||||||
|
using ::boost::cast::numeric_cast;
|
||||||
|
}</pre>
|
||||||
|
</blockquote>
|
||||||
|
<h3><a name="Polymorphic_cast">Polymorphic casts</a></h3>
|
||||||
|
<p>Pointers to polymorphic objects (objects of classes which define at least one
|
||||||
|
virtual function) are sometimes downcast or crosscast. Downcasting means
|
||||||
|
casting from a base class to a derived class. Crosscasting means casting
|
||||||
|
across an inheritance hierarchy diagram, such as from one base to the other in a
|
||||||
|
<b>Y</b> diagram hierarchy.</p>
|
||||||
|
<p>Such casts can be done with old-style casts, but this approach is never to be
|
||||||
|
recommended. Old-style casts are sorely lacking in type safety, suffer
|
||||||
|
poor readability, and are difficult to locate with search tools.</p>
|
||||||
|
<p>The C++ built-in <b>static_cast</b> can be used for efficiently downcasting
|
||||||
|
pointers to polymorphic objects, but provides no error detection for the case
|
||||||
|
where the pointer being cast actually points to the wrong derived class. The <b>polymorphic_downcast</b>
|
||||||
|
template retains the efficiency of <b>static_cast</b> for non-debug
|
||||||
|
compilations, but for debug compilations adds safety via an assert() that a <b>dynamic_cast</b>
|
||||||
|
succeeds. <b> </b></p>
|
||||||
|
<p>The C++ built-in <b>dynamic_cast</b> can be used for downcasts and crosscasts
|
||||||
|
of pointers to polymorphic objects, but error notification in the form of a
|
||||||
|
returned value of 0 is inconvenient to test, or worse yet, easy to forget to
|
||||||
|
test. The <b>polymorphic_cast</b> template performs a <b>dynamic_cast</b>,
|
||||||
|
and throws an exception if the <b>dynamic_cast</b> returns 0.</p>
|
||||||
|
<p>A <b>polymorphic_downcast</b> is preferred when debug-mode tests will cover
|
||||||
|
100% of the object types possibly cast and when non-debug-mode efficiency is an
|
||||||
|
issue. If these two conditions are not present, <b>polymorphic_cast</b> is
|
||||||
|
preferred. It must also be used for crosscasts. It does an assert(
|
||||||
|
dynamic_cast<Derived>(x) == x ) where x is the base pointer, ensuring that
|
||||||
|
not only is a non-zero pointer returned, but also that it correct in the
|
||||||
|
presence of multiple inheritance. .<b> Warning:</b>: Because <b>polymorphic_downcast</b>
|
||||||
|
uses assert(), it violates the One Definition Rule if NDEBUG is inconsistently
|
||||||
|
defined across translation units.</p>
|
||||||
|
<p>The C++ built-in <b>dynamic_cast</b> must be used to cast references rather
|
||||||
|
than pointers. It is also the only cast that can be used to check whether
|
||||||
|
a given interface is supported; in that case a return of 0 isn't an error
|
||||||
|
condition.</p>
|
||||||
|
<h3>polymorphic_cast and polymorphic_downcast synopsis</h3>
|
||||||
|
<blockquote>
|
||||||
|
<pre>template <class Derived, class Base>
|
||||||
|
inline Derived polymorphic_cast(Base* x);
|
||||||
|
// Throws: std::bad_cast if ( dynamic_cast<Derived>(x) == 0 )
|
||||||
|
// Returns: dynamic_cast<Derived>(x)
|
||||||
|
|
||||||
|
template <class Derived, class Base>
|
||||||
|
inline Derived polymorphic_downcast(Base* x);
|
||||||
|
// Effects: assert( dynamic_cast<Derived>(x) == x );
|
||||||
|
// Returns: static_cast<Derived>(x)</pre>
|
||||||
|
</blockquote>
|
||||||
|
<h3>polymorphic_downcast example</h3>
|
||||||
|
<blockquote>
|
||||||
|
<pre>#include <boost/cast.hpp>
|
||||||
|
...
|
||||||
|
class Fruit { public: virtual ~Fruit(){}; ... };
|
||||||
|
class Banana : public Fruit { ... };
|
||||||
|
...
|
||||||
|
void f( Fruit * fruit ) {
|
||||||
|
// ... logic which leads us to believe it is a Banana
|
||||||
|
Banana * banana = boost::polymorphic_downcast<Banana*>(fruit);
|
||||||
|
...</pre>
|
||||||
|
</blockquote>
|
||||||
|
<h3><a name="numeric_cast">numeric_cast</a></h3>
|
||||||
|
<p>A <b>static_cast</b>, <b>implicit_cast</b> or implicit conversion will not
|
||||||
|
detect failure to preserve range for numeric casts. The <b>numeric_cast</b>
|
||||||
|
template function are similar to <b>static_cast</b> and certain (dubious)
|
||||||
|
implicit conversions in this respect, except that they detect loss of numeric
|
||||||
|
range. An exception is thrown when a runtime value preservation check fails.</p>
|
||||||
|
<p>The requirements on the argument and result types are:</p>
|
||||||
|
<blockquote>
|
||||||
|
<ul>
|
||||||
|
<li>Both argument and result types are CopyConstructible [20.1.3].</li>
|
||||||
|
<li>Both argument and result types are Numeric, defined by <code>std::numeric_limits<>::is_specialized</code>
|
||||||
|
being true.</li>
|
||||||
|
<li>The argument can be converted to the result type using <b>static_cast</b>.</li>
|
||||||
|
</ul>
|
||||||
|
</blockquote>
|
||||||
|
<h3>numeric_cast synopsis</h3>
|
||||||
|
<blockquote>
|
||||||
|
<pre>class bad_numeric_cast : public std::bad_cast {...};
|
||||||
|
|
||||||
|
template<typename Target, typename Source>
|
||||||
|
inline Target numeric_cast(Source arg);
|
||||||
|
// Throws: bad_numeric_cast unless, in converting arg from Source to Target,
|
||||||
|
// there is no loss of negative range, and no underflow, and no
|
||||||
|
// overflow, as determined by std::numeric_limits
|
||||||
|
// Returns: static_cast<Target>(arg)</pre>
|
||||||
|
</blockquote>
|
||||||
|
<h3>numeric_cast example</h3>
|
||||||
|
<blockquote>
|
||||||
|
<pre>#include <boost/cast.hpp>
|
||||||
|
using namespace boost::cast;
|
||||||
|
|
||||||
|
void ariane(double vx)
|
||||||
|
{
|
||||||
|
...
|
||||||
|
unsigned short dx = numeric_cast<unsigned short>(vx);
|
||||||
|
...
|
||||||
|
}</pre>
|
||||||
|
</blockquote>
|
||||||
|
<h3>numeric_cast rationale</h3>
|
||||||
|
<p>The form of the throws condition is specified so that != is not a required
|
||||||
|
operation.</p>
|
||||||
|
<hr>
|
||||||
|
<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan
|
||||||
|
-->28 June, 2000<!--webbot bot="Timestamp" endspan i-checksum="19846"
|
||||||
|
--></p>
|
||||||
|
<p><EFBFBD> Copyright boost.org 1999. Permission to copy, use, modify, sell and
|
||||||
|
distribute this document is granted provided this copyright notice appears in
|
||||||
|
all copies. This document is provided "as is" without express or
|
||||||
|
implied warranty, and with no claim as to its suitability for any purpose.</p>
|
||||||
|
|
||||||
|
</body>
|
||||||
|
|
||||||
|
</html>
|
||||||
149
cast_test.cpp
Normal file
149
cast_test.cpp
Normal file
@@ -0,0 +1,149 @@
|
|||||||
|
// boost utility cast test program -----------------------------------------//
|
||||||
|
|
||||||
|
// (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
|
||||||
|
// and distribute this software is granted provided this copyright
|
||||||
|
// notice appears in all copies. This software is provided "as is" without
|
||||||
|
// express or implied warranty, and with no claim as to its suitability for
|
||||||
|
// any purpose.
|
||||||
|
|
||||||
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
|
||||||
|
// Revision History
|
||||||
|
// 28 Jun 00 implicit_cast removed (Beman Dawes)
|
||||||
|
// 30 Aug 99 value_cast replaced by numeric_cast
|
||||||
|
// 3 Aug 99 Initial Version
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <climits>
|
||||||
|
#include <limits>
|
||||||
|
#include <boost/cast.hpp>
|
||||||
|
|
||||||
|
# if SCHAR_MAX == LONG_MAX
|
||||||
|
# error "This test program doesn't work if SCHAR_MAX == LONG_MAX"
|
||||||
|
# endif
|
||||||
|
|
||||||
|
using namespace boost;
|
||||||
|
using std::cout;
|
||||||
|
|
||||||
|
namespace
|
||||||
|
{
|
||||||
|
struct Base
|
||||||
|
{
|
||||||
|
virtual char kind() { return 'B'; }
|
||||||
|
};
|
||||||
|
|
||||||
|
struct Base2
|
||||||
|
{
|
||||||
|
virtual char kind2() { return '2'; }
|
||||||
|
};
|
||||||
|
|
||||||
|
struct Derived : public Base, Base2
|
||||||
|
{
|
||||||
|
virtual char kind() { return 'D'; }
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
int main( int argc, char * argv[] )
|
||||||
|
{
|
||||||
|
cout << "Usage: test_casts [n], where n omitted or is:\n"
|
||||||
|
" 1 = execute #1 assert failure (#ifndef NDEBUG)\n"
|
||||||
|
" 2 = execute #2 assert failure (#ifndef NDEBUG)\n"
|
||||||
|
"Example: test_casts 2\n\n";
|
||||||
|
|
||||||
|
# ifdef NDEBUG
|
||||||
|
cout << "NDEBUG is defined\n";
|
||||||
|
# else
|
||||||
|
cout << "NDEBUG is not defined\n";
|
||||||
|
# endif
|
||||||
|
|
||||||
|
cout << "\nBeginning tests...\n";
|
||||||
|
|
||||||
|
// test polymorphic_cast ---------------------------------------------------//
|
||||||
|
|
||||||
|
// tests which should succeed
|
||||||
|
Base * base = new Derived;
|
||||||
|
Base2 * base2 = 0;
|
||||||
|
Derived * derived = 0;
|
||||||
|
derived = polymorphic_downcast<Derived*>( base ); // downcast
|
||||||
|
assert( derived->kind() == 'D' );
|
||||||
|
|
||||||
|
derived = 0;
|
||||||
|
derived = polymorphic_cast<Derived*>( base ); // downcast, throw on error
|
||||||
|
assert( derived->kind() == 'D' );
|
||||||
|
|
||||||
|
base2 = polymorphic_cast<Base2*>( base ); // crosscast
|
||||||
|
assert( base2->kind2() == '2' );
|
||||||
|
|
||||||
|
// tests which should result in errors being detected
|
||||||
|
int err_count = 0;
|
||||||
|
base = new Base;
|
||||||
|
|
||||||
|
if ( argc > 1 && *argv[1] == '1' )
|
||||||
|
{ derived = polymorphic_downcast<Derived*>( base ); } // #1 assert failure
|
||||||
|
|
||||||
|
bool caught_exception = false;
|
||||||
|
try { derived = polymorphic_cast<Derived*>( base ); }
|
||||||
|
catch (std::bad_cast)
|
||||||
|
{ cout<<"caught bad_cast\n"; caught_exception = true; }
|
||||||
|
if ( !caught_exception ) ++err_count;
|
||||||
|
// the following is just so generated code can be inspected
|
||||||
|
if ( derived->kind() == 'B' ) ++err_count;
|
||||||
|
|
||||||
|
// test implicit_cast and numeric_cast -------------------------------------//
|
||||||
|
|
||||||
|
// tests which should succeed
|
||||||
|
long small_value = 1;
|
||||||
|
long small_negative_value = -1;
|
||||||
|
long large_value = std::numeric_limits<long>::max();
|
||||||
|
long large_negative_value = std::numeric_limits<long>::min();
|
||||||
|
signed char c = 0;
|
||||||
|
|
||||||
|
c = large_value; // see if compiler generates warning
|
||||||
|
|
||||||
|
c = numeric_cast<signed char>( small_value );
|
||||||
|
assert( c == 1 );
|
||||||
|
c = 0;
|
||||||
|
c = numeric_cast<signed char>( small_value );
|
||||||
|
assert( c == 1 );
|
||||||
|
c = 0;
|
||||||
|
c = numeric_cast<signed char>( small_negative_value );
|
||||||
|
assert( c == -1 );
|
||||||
|
|
||||||
|
// tests which should result in errors being detected
|
||||||
|
|
||||||
|
caught_exception = false;
|
||||||
|
try { c = numeric_cast<signed char>( large_value ); }
|
||||||
|
catch (bad_numeric_cast)
|
||||||
|
{ cout<<"caught bad_numeric_cast #1\n"; caught_exception = true; }
|
||||||
|
if ( !caught_exception ) ++err_count;
|
||||||
|
|
||||||
|
caught_exception = false;
|
||||||
|
try { c = numeric_cast<signed char>( large_negative_value ); }
|
||||||
|
catch (bad_numeric_cast)
|
||||||
|
{ cout<<"caught bad_numeric_cast #2\n"; caught_exception = true; }
|
||||||
|
if ( !caught_exception ) ++err_count;
|
||||||
|
|
||||||
|
unsigned long ul;
|
||||||
|
caught_exception = false;
|
||||||
|
try { ul = numeric_cast<unsigned long>( large_negative_value ); }
|
||||||
|
catch (bad_numeric_cast)
|
||||||
|
{ cout<<"caught bad_numeric_cast #3\n"; caught_exception = true; }
|
||||||
|
if ( !caught_exception ) ++err_count;
|
||||||
|
|
||||||
|
caught_exception = false;
|
||||||
|
try { ul = numeric_cast<unsigned long>( small_negative_value ); }
|
||||||
|
catch (bad_numeric_cast)
|
||||||
|
{ cout<<"caught bad_numeric_cast #4\n"; caught_exception = true; }
|
||||||
|
if ( !caught_exception ) ++err_count;
|
||||||
|
|
||||||
|
caught_exception = false;
|
||||||
|
try { numeric_cast<int>( std::numeric_limits<double>::max() ); }
|
||||||
|
catch (bad_numeric_cast)
|
||||||
|
{ cout<<"caught bad_numeric_cast #5\n"; caught_exception = true; }
|
||||||
|
if ( !caught_exception ) ++err_count;
|
||||||
|
|
||||||
|
cout << err_count << " errors detected\nTest "
|
||||||
|
<< (err_count==0 ? "passed\n" : "failed\n");
|
||||||
|
return err_count;
|
||||||
|
} // main
|
||||||
@@ -1,15 +0,0 @@
|
|||||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv=refresh content="0; URL=../core/doc/html/core/checked_delete.html">
|
|
||||||
<title>Automatic redirection</title>
|
|
||||||
</head>
|
|
||||||
<body>
|
|
||||||
Automatic redirection failed, please go to
|
|
||||||
<a href="../core/doc/html/core/checked_delete.html">checked_delete.html</a>. <hr>
|
|
||||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
|
||||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
|
||||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,16 +1,92 @@
|
|||||||
|
|
||||||
<!--
|
|
||||||
Copyright 2014 Daniel James.
|
|
||||||
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)
|
|
||||||
-->
|
|
||||||
|
|
||||||
<html>
|
<html>
|
||||||
|
|
||||||
<head>
|
<head>
|
||||||
<meta http-equiv="refresh" content="0; URL=doc/html/compressed_pair.html">
|
<meta http-equiv="Content-Type"
|
||||||
|
content="text/html; charset=iso-8859-1">
|
||||||
|
<meta name="Template"
|
||||||
|
content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
|
||||||
|
<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
|
||||||
|
<title>Header <boost/compressed_pair.hpp></title>
|
||||||
</head>
|
</head>
|
||||||
<body>
|
|
||||||
Automatic redirection failed, please go to
|
<body bgcolor="#FFFFFF" text="#000000" link="#0000FF"
|
||||||
<a href="doc/html/compressed_pair.html">doc/html/compressed_pair.html</a>
|
vlink="#800080">
|
||||||
|
|
||||||
|
<h2><img src="../../c++boost.gif" width="276" height="86">Header
|
||||||
|
<<a href="../../boost/detail/call_traits.hpp">boost/compressed_pair.hpp</a>></h2>
|
||||||
|
|
||||||
|
<p>All of the contents of <boost/compressed_pair.hpp> are
|
||||||
|
defined inside namespace boost.</p>
|
||||||
|
|
||||||
|
<p>The class compressed pair is very similar to std::pair, but if
|
||||||
|
either of the template arguments are empty classes, then the
|
||||||
|
"empty member optimisation" is applied to compress the
|
||||||
|
size of the pair.</p>
|
||||||
|
|
||||||
|
<pre>template <class T1, class T2>
|
||||||
|
class compressed_pair
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef T1 first_type;
|
||||||
|
typedef T2 second_type;
|
||||||
|
typedef typename call_traits<first_type>::param_type first_param_type;
|
||||||
|
typedef typename call_traits<second_type>::param_type second_param_type;
|
||||||
|
typedef typename call_traits<first_type>::reference first_reference;
|
||||||
|
typedef typename call_traits<second_type>::reference second_reference;
|
||||||
|
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
||||||
|
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
||||||
|
|
||||||
|
compressed_pair() : base() {}
|
||||||
|
compressed_pair(first_param_type x, second_param_type y);
|
||||||
|
explicit compressed_pair(first_param_type x);
|
||||||
|
explicit compressed_pair(second_param_type y);
|
||||||
|
|
||||||
|
first_reference first();
|
||||||
|
first_const_reference first() const;
|
||||||
|
|
||||||
|
second_reference second();
|
||||||
|
second_const_reference second() const;
|
||||||
|
|
||||||
|
void swap(compressed_pair& y);
|
||||||
|
};</pre>
|
||||||
|
|
||||||
|
<p>The two members of the pair can be accessed using the member
|
||||||
|
functions first() and second(). Note that not all member
|
||||||
|
functions can be instantiated for all template parameter types.
|
||||||
|
In particular compressed_pair can be instantiated for reference
|
||||||
|
and array types, however in these cases the range of constructors
|
||||||
|
that can be used are limited. If types T1 and T2 are the same
|
||||||
|
type, then there is only one version of the single-argument
|
||||||
|
constructor, and this constructor initialises both values in the
|
||||||
|
pair to the passed value.</p>
|
||||||
|
|
||||||
|
<p>Note that compressed_pair can not be instantiated if either of
|
||||||
|
the template arguments is an enumerator type, unless there is
|
||||||
|
compiler support for boost::is_enum, or if boost::is_enum is
|
||||||
|
specialised for the enumerator type.</p>
|
||||||
|
|
||||||
|
<p>Finally, compressed_pair requires compiler support for partial
|
||||||
|
specialisation of class templates - without that support
|
||||||
|
compressed_pair behaves just like std::pair.</p>
|
||||||
|
|
||||||
|
<hr>
|
||||||
|
|
||||||
|
<p>Revised 08 March 2000</p>
|
||||||
|
|
||||||
|
<p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
|
||||||
|
sell and distribute this document is granted provided this
|
||||||
|
copyright notice appears in all copies. This document is provided
|
||||||
|
"as is" without express or implied warranty, and with
|
||||||
|
no claim as to its suitability for any purpose.</p>
|
||||||
|
|
||||||
|
<p>Based on contributions by Steve Cleary, Beman Dawes, Howard
|
||||||
|
Hinnant and John Maddock.</p>
|
||||||
|
|
||||||
|
<p>Maintained by <a href="mailto:John_Maddock@compuserve.com">John
|
||||||
|
Maddock</a>, the latest version of this file can be found at <a
|
||||||
|
href="http://www.boost.org">www.boost.org</a>, and the boost
|
||||||
|
discussion list at <a href="http://www.egroups.com/list/boost">www.egroups.com/list/boost</a>.</p>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
</body>
|
</body>
|
||||||
</html>
|
</html>
|
||||||
|
|||||||
@@ -1,393 +1,125 @@
|
|||||||
// boost::compressed_pair test program
|
// boost::compressed_pair test program
|
||||||
|
|
||||||
// (C) Copyright John Maddock 2000.
|
// (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and
|
||||||
// Use, modification and distribution are subject to the Boost Software License,
|
// distribute this software is granted provided this copyright notice appears
|
||||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
// http://www.boost.org/LICENSE_1_0.txt).
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
|
|
||||||
// standalone test program for <boost/compressed_pair.hpp>
|
// standalone test program for <boost/compressed_pair.hpp>
|
||||||
// Revised 03 Oct 2000:
|
|
||||||
// Enabled tests for VC6.
|
|
||||||
|
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
#include <typeinfo>
|
#include <typeinfo>
|
||||||
#include <cassert>
|
#include <cassert>
|
||||||
|
|
||||||
#include <boost/compressed_pair.hpp>
|
#include <boost/compressed_pair.hpp>
|
||||||
#include <boost/test/test_tools.hpp>
|
#include "type_traits_test.hpp"
|
||||||
|
|
||||||
using namespace boost;
|
using namespace boost;
|
||||||
|
|
||||||
|
struct empty_POD_UDT{};
|
||||||
struct empty_UDT
|
struct empty_UDT
|
||||||
{
|
{
|
||||||
~empty_UDT(){};
|
~empty_UDT(){};
|
||||||
empty_UDT& operator=(const empty_UDT&){ return *this; }
|
|
||||||
bool operator==(const empty_UDT&)const
|
|
||||||
{ return true; }
|
|
||||||
};
|
};
|
||||||
struct empty_POD_UDT
|
namespace boost {
|
||||||
{
|
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||||
empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; }
|
template <> struct is_empty<empty_UDT>
|
||||||
bool operator==(const empty_POD_UDT&)const
|
{ static const bool value = true; };
|
||||||
{ return true; }
|
template <> struct is_empty<empty_POD_UDT>
|
||||||
};
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_POD<empty_POD_UDT>
|
||||||
struct non_empty1
|
{ static const bool value = true; };
|
||||||
{
|
#else
|
||||||
int i;
|
template <> struct is_empty<empty_UDT>
|
||||||
non_empty1() : i(1){}
|
{ enum{ value = true }; };
|
||||||
non_empty1(int v) : i(v){}
|
template <> struct is_empty<empty_POD_UDT>
|
||||||
friend bool operator==(const non_empty1& a, const non_empty1& b)
|
{ enum{ value = true }; };
|
||||||
{ return a.i == b.i; }
|
template <> struct is_POD<empty_POD_UDT>
|
||||||
};
|
{ enum{ value = true }; };
|
||||||
|
|
||||||
struct non_empty2
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
non_empty2() : i(3){}
|
|
||||||
non_empty2(int v) : i(v){}
|
|
||||||
friend bool operator==(const non_empty2& a, const non_empty2& b)
|
|
||||||
{ return a.i == b.i; }
|
|
||||||
};
|
|
||||||
|
|
||||||
#ifdef __GNUC__
|
|
||||||
using std::swap;
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct compressed_pair_tester
|
|
||||||
{
|
|
||||||
// define the types we need:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
// define our test proc:
|
|
||||||
static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
void compressed_pair_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
|
|
||||||
{
|
|
||||||
#ifndef __GNUC__
|
|
||||||
// gcc 2.90 can't cope with function scope using
|
|
||||||
// declarations, and generates an internal compiler error...
|
|
||||||
using std::swap;
|
|
||||||
#endif
|
|
||||||
// default construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp1;
|
|
||||||
// first param construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp2(p1);
|
|
||||||
cp2.second() = p2;
|
|
||||||
BOOST_CHECK(cp2.first() == p1);
|
|
||||||
BOOST_CHECK(cp2.second() == p2);
|
|
||||||
// second param construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp3(p2);
|
|
||||||
cp3.first() = p1;
|
|
||||||
BOOST_CHECK(cp3.second() == p2);
|
|
||||||
BOOST_CHECK(cp3.first() == p1);
|
|
||||||
// both param construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp4(p1, p2);
|
|
||||||
BOOST_CHECK(cp4.first() == p1);
|
|
||||||
BOOST_CHECK(cp4.second() == p2);
|
|
||||||
boost::compressed_pair<T1,T2> cp5(p3, p4);
|
|
||||||
BOOST_CHECK(cp5.first() == p3);
|
|
||||||
BOOST_CHECK(cp5.second() == p4);
|
|
||||||
// check const members:
|
|
||||||
const boost::compressed_pair<T1,T2>& cpr1 = cp4;
|
|
||||||
BOOST_CHECK(cpr1.first() == p1);
|
|
||||||
BOOST_CHECK(cpr1.second() == p2);
|
|
||||||
|
|
||||||
// copy construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp6(cp4);
|
|
||||||
BOOST_CHECK(cp6.first() == p1);
|
|
||||||
BOOST_CHECK(cp6.second() == p2);
|
|
||||||
// assignment:
|
|
||||||
cp1 = cp4;
|
|
||||||
BOOST_CHECK(cp1.first() == p1);
|
|
||||||
BOOST_CHECK(cp1.second() == p2);
|
|
||||||
cp1 = cp5;
|
|
||||||
BOOST_CHECK(cp1.first() == p3);
|
|
||||||
BOOST_CHECK(cp1.second() == p4);
|
|
||||||
// swap:
|
|
||||||
cp4.swap(cp5);
|
|
||||||
BOOST_CHECK(cp4.first() == p3);
|
|
||||||
BOOST_CHECK(cp4.second() == p4);
|
|
||||||
BOOST_CHECK(cp5.first() == p1);
|
|
||||||
BOOST_CHECK(cp5.second() == p2);
|
|
||||||
swap(cp4,cp5);
|
|
||||||
BOOST_CHECK(cp4.first() == p1);
|
|
||||||
BOOST_CHECK(cp4.second() == p2);
|
|
||||||
BOOST_CHECK(cp5.first() == p3);
|
|
||||||
BOOST_CHECK(cp5.second() == p4);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
//
|
|
||||||
// tests for case where one or both
|
|
||||||
// parameters are reference types:
|
|
||||||
//
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct compressed_pair_reference_tester
|
|
||||||
{
|
|
||||||
// define the types we need:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
// define our test proc:
|
|
||||||
static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
int main()
|
||||||
void compressed_pair_reference_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4)
|
|
||||||
{
|
|
||||||
#ifndef __GNUC__
|
|
||||||
// gcc 2.90 can't cope with function scope using
|
|
||||||
// declarations, and generates an internal compiler error...
|
|
||||||
using std::swap;
|
|
||||||
#endif
|
|
||||||
// both param construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp4(p1, p2);
|
|
||||||
BOOST_CHECK(cp4.first() == p1);
|
|
||||||
BOOST_CHECK(cp4.second() == p2);
|
|
||||||
boost::compressed_pair<T1,T2> cp5(p3, p4);
|
|
||||||
BOOST_CHECK(cp5.first() == p3);
|
|
||||||
BOOST_CHECK(cp5.second() == p4);
|
|
||||||
// check const members:
|
|
||||||
const boost::compressed_pair<T1,T2>& cpr1 = cp4;
|
|
||||||
BOOST_CHECK(cpr1.first() == p1);
|
|
||||||
BOOST_CHECK(cpr1.second() == p2);
|
|
||||||
|
|
||||||
// copy construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp6(cp4);
|
|
||||||
BOOST_CHECK(cp6.first() == p1);
|
|
||||||
BOOST_CHECK(cp6.second() == p2);
|
|
||||||
// assignment:
|
|
||||||
// VC6 bug:
|
|
||||||
// When second() is an empty class, VC6 performs the
|
|
||||||
// assignment by doing a memcpy - even though the empty
|
|
||||||
// class is really a zero sized base class, the result
|
|
||||||
// is that the memory of first() gets trampled over.
|
|
||||||
// Similar arguments apply to the case that first() is
|
|
||||||
// an empty base class.
|
|
||||||
// Strangely the problem is dependent upon the compiler
|
|
||||||
// settings - some generate the problem others do not.
|
|
||||||
cp4.first() = p3;
|
|
||||||
cp4.second() = p4;
|
|
||||||
BOOST_CHECK(cp4.first() == p3);
|
|
||||||
BOOST_CHECK(cp4.second() == p4);
|
|
||||||
}
|
|
||||||
//
|
|
||||||
// supplimentary tests for case where first arg only is a reference type:
|
|
||||||
//
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct compressed_pair_reference1_tester
|
|
||||||
{
|
|
||||||
// define the types we need:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
// define our test proc:
|
|
||||||
static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
void compressed_pair_reference1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
|
|
||||||
{
|
{
|
||||||
|
compressed_pair<int, double> cp1(1, 1.3);
|
||||||
|
assert(cp1.first() == 1);
|
||||||
|
assert(cp1.second() == 1.3);
|
||||||
|
compressed_pair<int, double> cp1b(2, 2.3);
|
||||||
|
assert(cp1b.first() == 2);
|
||||||
|
assert(cp1b.second() == 2.3);
|
||||||
|
swap(cp1, cp1b);
|
||||||
|
assert(cp1b.first() == 1);
|
||||||
|
assert(cp1b.second() == 1.3);
|
||||||
|
assert(cp1.first() == 2);
|
||||||
|
assert(cp1.second() == 2.3);
|
||||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
// first param construct:
|
compressed_pair<empty_UDT, int> cp2(2);
|
||||||
boost::compressed_pair<T1,T2> cp2(p1);
|
assert(cp2.second() == 2);
|
||||||
cp2.second() = p2;
|
|
||||||
BOOST_CHECK(cp2.first() == p1);
|
|
||||||
BOOST_CHECK(cp2.second() == p2);
|
|
||||||
#endif
|
#endif
|
||||||
}
|
compressed_pair<int, empty_UDT> cp3(1);
|
||||||
//
|
assert(cp3.first() ==1);
|
||||||
// supplimentary tests for case where second arg only is a reference type:
|
compressed_pair<empty_UDT, empty_UDT> cp4;
|
||||||
//
|
compressed_pair<empty_UDT, empty_POD_UDT> cp5;
|
||||||
template <class T1, class T2>
|
|
||||||
struct compressed_pair_reference2_tester
|
|
||||||
{
|
|
||||||
// define the types we need:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
// define our test proc:
|
|
||||||
static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
void compressed_pair_reference2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
|
|
||||||
{
|
|
||||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
// second param construct:
|
int i = 0;
|
||||||
boost::compressed_pair<T1,T2> cp3(p2);
|
compressed_pair<int&, int&> cp6(i,i);
|
||||||
cp3.first() = p1;
|
assert(cp6.first() == i);
|
||||||
BOOST_CHECK(cp3.second() == p2);
|
assert(cp6.second() == i);
|
||||||
BOOST_CHECK(cp3.first() == p1);
|
assert(&cp6.first() == &i);
|
||||||
|
assert(&cp6.second() == &i);
|
||||||
|
compressed_pair<int, double[2]> cp7;
|
||||||
|
cp7.first();
|
||||||
|
double* pd = cp7.second();
|
||||||
#endif
|
#endif
|
||||||
|
value_test(true, (sizeof(compressed_pair<empty_UDT, int>) < sizeof(std::pair<empty_UDT, int>)))
|
||||||
|
value_test(true, (sizeof(compressed_pair<int, empty_UDT>) < sizeof(std::pair<int, empty_UDT>)))
|
||||||
|
value_test(true, (sizeof(compressed_pair<empty_UDT, empty_UDT>) < sizeof(std::pair<empty_UDT, empty_UDT>)))
|
||||||
|
value_test(true, (sizeof(compressed_pair<empty_UDT, empty_POD_UDT>) < sizeof(std::pair<empty_UDT, empty_POD_UDT>)))
|
||||||
|
value_test(true, (sizeof(compressed_pair<empty_UDT, compressed_pair<empty_POD_UDT, int> >) < sizeof(std::pair<empty_UDT, std::pair<empty_POD_UDT, int> >)))
|
||||||
|
|
||||||
|
std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
|
||||||
|
std::cin.get();
|
||||||
|
return failures;
|
||||||
}
|
}
|
||||||
|
|
||||||
//
|
//
|
||||||
// tests for where one or the other parameter is an array:
|
// instanciate some compressed pairs:
|
||||||
|
#ifdef __MWERKS__
|
||||||
|
template class compressed_pair<int, double>;
|
||||||
|
template class compressed_pair<int, int>;
|
||||||
|
template class compressed_pair<empty_UDT, int>;
|
||||||
|
template class compressed_pair<int, empty_UDT>;
|
||||||
|
template class compressed_pair<empty_UDT, empty_UDT>;
|
||||||
|
template class compressed_pair<empty_UDT, empty_POD_UDT>;
|
||||||
|
#else
|
||||||
|
template class boost::compressed_pair<int, double>;
|
||||||
|
template class boost::compressed_pair<int, int>;
|
||||||
|
template class boost::compressed_pair<empty_UDT, int>;
|
||||||
|
template class boost::compressed_pair<int, empty_UDT>;
|
||||||
|
template class boost::compressed_pair<empty_UDT, empty_UDT>;
|
||||||
|
template class boost::compressed_pair<empty_UDT, empty_POD_UDT>;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
//
|
//
|
||||||
template <class T1, class T2>
|
// now some for which only a few specific members can be instantiated,
|
||||||
struct compressed_pair_array1_tester
|
// first references:
|
||||||
{
|
template double& compressed_pair<double, int&>::first();
|
||||||
// define the types we need:
|
template int& compressed_pair<double, int&>::second();
|
||||||
typedef T1 first_type;
|
template compressed_pair<double, int&>::compressed_pair(int&);
|
||||||
typedef T2 second_type;
|
template compressed_pair<double, int&>::compressed_pair(call_traits<double>::param_type,int&);
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
//
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
// and then arrays:
|
||||||
// define our test proc:
|
#ifndef __MWERKS__
|
||||||
static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
|
#ifndef __BORLANDC__
|
||||||
};
|
template call_traits<int[2]>::reference compressed_pair<double, int[2]>::second();
|
||||||
|
#endif
|
||||||
template <class T1, class T2>
|
template call_traits<double>::reference compressed_pair<double, int[2]>::first();
|
||||||
void compressed_pair_array1_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
|
template compressed_pair<double, int[2]>::compressed_pair(const double&);
|
||||||
{
|
template compressed_pair<double, int[2]>::compressed_pair();
|
||||||
// default construct:
|
#endif // __MWERKS__
|
||||||
boost::compressed_pair<T1,T2> cp1;
|
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
// second param construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp3(p2);
|
|
||||||
cp3.first()[0] = p1[0];
|
|
||||||
BOOST_CHECK(cp3.second() == p2);
|
|
||||||
BOOST_CHECK(cp3.first()[0] == p1[0]);
|
|
||||||
// check const members:
|
|
||||||
const boost::compressed_pair<T1,T2>& cpr1 = cp3;
|
|
||||||
BOOST_CHECK(cpr1.first()[0] == p1[0]);
|
|
||||||
BOOST_CHECK(cpr1.second() == p2);
|
|
||||||
|
|
||||||
BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct compressed_pair_array2_tester
|
|
||||||
{
|
|
||||||
// define the types we need:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
// define our test proc:
|
|
||||||
static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
void compressed_pair_array2_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
|
|
||||||
{
|
|
||||||
// default construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp1;
|
|
||||||
// first param construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp2(p1);
|
|
||||||
cp2.second()[0] = p2[0];
|
|
||||||
BOOST_CHECK(cp2.first() == p1);
|
|
||||||
BOOST_CHECK(cp2.second()[0] == p2[0]);
|
|
||||||
// check const members:
|
|
||||||
const boost::compressed_pair<T1,T2>& cpr1 = cp2;
|
|
||||||
BOOST_CHECK(cpr1.first() == p1);
|
|
||||||
BOOST_CHECK(cpr1.second()[0] == p2[0]);
|
|
||||||
|
|
||||||
BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct compressed_pair_array_tester
|
|
||||||
{
|
|
||||||
// define the types we need:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
// define our test proc:
|
|
||||||
static void test(first_param_type p1, second_param_type p2, first_param_type p3, second_param_type p4);
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
void compressed_pair_array_tester<T1, T2>::test(first_param_type p1, second_param_type p2, first_param_type, second_param_type)
|
|
||||||
{
|
|
||||||
// default construct:
|
|
||||||
boost::compressed_pair<T1,T2> cp1;
|
|
||||||
cp1.first()[0] = p1[0];
|
|
||||||
cp1.second()[0] = p2[0];
|
|
||||||
BOOST_CHECK(cp1.first()[0] == p1[0]);
|
|
||||||
BOOST_CHECK(cp1.second()[0] == p2[0]);
|
|
||||||
// check const members:
|
|
||||||
const boost::compressed_pair<T1,T2>& cpr1 = cp1;
|
|
||||||
BOOST_CHECK(cpr1.first()[0] == p1[0]);
|
|
||||||
BOOST_CHECK(cpr1.second()[0] == p2[0]);
|
|
||||||
|
|
||||||
BOOST_CHECK(sizeof(T1) == sizeof(cp1.first()));
|
|
||||||
BOOST_CHECK(sizeof(T2) == sizeof(cp1.second()));
|
|
||||||
}
|
|
||||||
|
|
||||||
int test_main(int, char *[])
|
|
||||||
{
|
|
||||||
// declare some variables to pass to the tester:
|
|
||||||
non_empty1 ne1(2);
|
|
||||||
non_empty1 ne2(3);
|
|
||||||
non_empty2 ne3(4);
|
|
||||||
non_empty2 ne4(5);
|
|
||||||
empty_POD_UDT e1;
|
|
||||||
empty_UDT e2;
|
|
||||||
|
|
||||||
// T1 != T2, both non-empty
|
|
||||||
compressed_pair_tester<non_empty1,non_empty2>::test(ne1, ne3, ne2, ne4);
|
|
||||||
// T1 != T2, T2 empty
|
|
||||||
compressed_pair_tester<non_empty1,empty_POD_UDT>::test(ne1, e1, ne2, e1);
|
|
||||||
// T1 != T2, T1 empty
|
|
||||||
compressed_pair_tester<empty_POD_UDT,non_empty2>::test(e1, ne3, e1, ne4);
|
|
||||||
// T1 != T2, both empty
|
|
||||||
compressed_pair_tester<empty_POD_UDT,empty_UDT>::test(e1, e2, e1, e2);
|
|
||||||
// T1 == T2, both non-empty
|
|
||||||
compressed_pair_tester<non_empty1,non_empty1>::test(ne1, ne1, ne2, ne2);
|
|
||||||
// T1 == T2, both empty
|
|
||||||
compressed_pair_tester<empty_UDT,empty_UDT>::test(e2, e2, e2, e2);
|
|
||||||
|
|
||||||
|
|
||||||
// test references:
|
|
||||||
|
|
||||||
// T1 != T2, both non-empty
|
|
||||||
compressed_pair_reference_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
|
|
||||||
compressed_pair_reference_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
|
|
||||||
compressed_pair_reference1_tester<non_empty1&,non_empty2>::test(ne1, ne3, ne2, ne4);
|
|
||||||
compressed_pair_reference2_tester<non_empty1,non_empty2&>::test(ne1, ne3, ne2, ne4);
|
|
||||||
// T1 != T2, T2 empty
|
|
||||||
compressed_pair_reference_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
|
|
||||||
compressed_pair_reference1_tester<non_empty1&,empty_POD_UDT>::test(ne1, e1, ne2, e1);
|
|
||||||
// T1 != T2, T1 empty
|
|
||||||
compressed_pair_reference_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
|
|
||||||
compressed_pair_reference2_tester<empty_POD_UDT,non_empty2&>::test(e1, ne3, e1, ne4);
|
|
||||||
// T1 == T2, both non-empty
|
|
||||||
compressed_pair_reference_tester<non_empty1&,non_empty1&>::test(ne1, ne1, ne2, ne2);
|
|
||||||
|
|
||||||
// tests arrays:
|
|
||||||
non_empty1 nea1[2];
|
|
||||||
non_empty1 nea2[2];
|
|
||||||
non_empty2 nea3[2];
|
|
||||||
non_empty2 nea4[2];
|
|
||||||
nea1[0] = non_empty1(5);
|
|
||||||
nea2[0] = non_empty1(6);
|
|
||||||
nea3[0] = non_empty2(7);
|
|
||||||
nea4[0] = non_empty2(8);
|
|
||||||
|
|
||||||
// T1 != T2, both non-empty
|
|
||||||
compressed_pair_array1_tester<non_empty1[2],non_empty2>::test(nea1, ne3, nea2, ne4);
|
|
||||||
compressed_pair_array2_tester<non_empty1,non_empty2[2]>::test(ne1, nea3, ne2, nea4);
|
|
||||||
compressed_pair_array_tester<non_empty1[2],non_empty2[2]>::test(nea1, nea3, nea2, nea4);
|
|
||||||
// T1 != T2, T2 empty
|
|
||||||
compressed_pair_array1_tester<non_empty1[2],empty_POD_UDT>::test(nea1, e1, nea2, e1);
|
|
||||||
// T1 != T2, T1 empty
|
|
||||||
compressed_pair_array2_tester<empty_POD_UDT,non_empty2[2]>::test(e1, nea3, e1, nea4);
|
|
||||||
// T1 == T2, both non-empty
|
|
||||||
compressed_pair_array_tester<non_empty1[2],non_empty1[2]>::test(nea1, nea1, nea2, nea2);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
unsigned int expected_failures = 0;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
138
doc/Jamfile.v2
138
doc/Jamfile.v2
@@ -1,138 +0,0 @@
|
|||||||
|
|
||||||
# Copyright John Maddock 2005. Use, modification, and distribution are
|
|
||||||
# subject to 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)
|
|
||||||
|
|
||||||
project : requirements
|
|
||||||
# Path for links to Boost:
|
|
||||||
<xsl:param>boost.root=../../../..
|
|
||||||
|
|
||||||
# Some general style settings:
|
|
||||||
<xsl:param>table.footnote.number.format=1
|
|
||||||
<xsl:param>footnote.number.format=1
|
|
||||||
|
|
||||||
# HTML options first:
|
|
||||||
# Use graphics not text for navigation:
|
|
||||||
<xsl:param>navig.graphics=1
|
|
||||||
# PDF Options:
|
|
||||||
# TOC Generation: this is needed for FOP-0.9 and later:
|
|
||||||
<xsl:param>fop1.extensions=0
|
|
||||||
<xsl:param>xep.extensions=1
|
|
||||||
# TOC generation: this is needed for FOP 0.2, but must not be set to zero for FOP-0.9!
|
|
||||||
<xsl:param>fop.extensions=0
|
|
||||||
# No indent on body text:
|
|
||||||
<xsl:param>body.start.indent=0pt
|
|
||||||
# Margin size:
|
|
||||||
<xsl:param>page.margin.inner=0.5in
|
|
||||||
# Margin size:
|
|
||||||
<xsl:param>page.margin.outer=0.5in
|
|
||||||
# Paper type = A4
|
|
||||||
<xsl:param>paper.type=A4
|
|
||||||
# Yes, we want graphics for admonishments:
|
|
||||||
<xsl:param>admon.graphics=1
|
|
||||||
# Set this one for PDF generation *only*:
|
|
||||||
# default pnd graphics are awful in PDF form,
|
|
||||||
# better use SVG's instead:
|
|
||||||
<format>pdf:<xsl:param>admon.graphics.extension=".svg"
|
|
||||||
<format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
|
|
||||||
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/utility/doc/html
|
|
||||||
;
|
|
||||||
|
|
||||||
using quickbook ;
|
|
||||||
|
|
||||||
path-constant boost-images : ../../../doc/src/images ;
|
|
||||||
|
|
||||||
xml base_from_member : base_from_member.qbk ;
|
|
||||||
boostbook standalone_base_from_member
|
|
||||||
:
|
|
||||||
base_from_member
|
|
||||||
:
|
|
||||||
# File name of HTML output:
|
|
||||||
<xsl:param>root.filename=base_from_member
|
|
||||||
# How far down we chunk nested sections, basically all of them:
|
|
||||||
<xsl:param>chunk.section.depth=0
|
|
||||||
# Don't put the first section on the same page as the TOC:
|
|
||||||
<xsl:param>chunk.first.sections=0
|
|
||||||
# How far down sections get TOC's
|
|
||||||
<xsl:param>toc.section.depth=1
|
|
||||||
# Max depth in each TOC:
|
|
||||||
<xsl:param>toc.max.depth=1
|
|
||||||
# How far down we go with TOC's
|
|
||||||
<xsl:param>generate.section.toc.level=1
|
|
||||||
;
|
|
||||||
|
|
||||||
xml compressed_pair : compressed_pair.qbk ;
|
|
||||||
boostbook standalone_compressed_pair
|
|
||||||
:
|
|
||||||
compressed_pair
|
|
||||||
:
|
|
||||||
# File name of HTML output:
|
|
||||||
<xsl:param>root.filename=compressed_pair
|
|
||||||
# How far down we chunk nested sections, basically all of them:
|
|
||||||
<xsl:param>chunk.section.depth=0
|
|
||||||
# Don't put the first section on the same page as the TOC:
|
|
||||||
<xsl:param>chunk.first.sections=0
|
|
||||||
# How far down sections get TOC's
|
|
||||||
<xsl:param>toc.section.depth=1
|
|
||||||
# Max depth in each TOC:
|
|
||||||
<xsl:param>toc.max.depth=1
|
|
||||||
# How far down we go with TOC's
|
|
||||||
<xsl:param>generate.section.toc.level=1
|
|
||||||
;
|
|
||||||
|
|
||||||
xml declval : declval.qbk ;
|
|
||||||
boostbook standalone_declval
|
|
||||||
:
|
|
||||||
declval
|
|
||||||
:
|
|
||||||
# File name of HTML output:
|
|
||||||
<xsl:param>root.filename=declval
|
|
||||||
# How far down we chunk nested sections, basically all of them:
|
|
||||||
<xsl:param>chunk.section.depth=0
|
|
||||||
# Don't put the first section on the same page as the TOC:
|
|
||||||
<xsl:param>chunk.first.sections=0
|
|
||||||
# How far down sections get TOC's
|
|
||||||
<xsl:param>toc.section.depth=1
|
|
||||||
# Max depth in each TOC:
|
|
||||||
<xsl:param>toc.max.depth=1
|
|
||||||
# How far down we go with TOC's
|
|
||||||
<xsl:param>generate.section.toc.level=1
|
|
||||||
;
|
|
||||||
|
|
||||||
xml string_ref : string_ref.qbk ;
|
|
||||||
boostbook standalone_string_ref
|
|
||||||
:
|
|
||||||
string_ref
|
|
||||||
:
|
|
||||||
# File name of HTML output:
|
|
||||||
<xsl:param>root.filename=string_ref
|
|
||||||
# How far down we chunk nested sections, basically all of them:
|
|
||||||
<xsl:param>chunk.section.depth=0
|
|
||||||
# Don't put the first section on the same page as the TOC:
|
|
||||||
<xsl:param>chunk.first.sections=0
|
|
||||||
# How far down sections get TOC's
|
|
||||||
<xsl:param>toc.section.depth=1
|
|
||||||
# Max depth in each TOC:
|
|
||||||
<xsl:param>toc.max.depth=1
|
|
||||||
# How far down we go with TOC's
|
|
||||||
<xsl:param>generate.section.toc.level=1
|
|
||||||
;
|
|
||||||
|
|
||||||
xml string_view : string_view.qbk ;
|
|
||||||
boostbook standalone_string_view
|
|
||||||
:
|
|
||||||
string_view
|
|
||||||
:
|
|
||||||
# File name of HTML output:
|
|
||||||
<xsl:param>root.filename=string_view
|
|
||||||
# How far down we chunk nested sections, basically all of them:
|
|
||||||
<xsl:param>chunk.section.depth=0
|
|
||||||
# Don't put the first section on the same page as the TOC:
|
|
||||||
<xsl:param>chunk.first.sections=0
|
|
||||||
# How far down sections get TOC's
|
|
||||||
<xsl:param>toc.section.depth=1
|
|
||||||
# Max depth in each TOC:
|
|
||||||
<xsl:param>toc.max.depth=1
|
|
||||||
# How far down we go with TOC's
|
|
||||||
<xsl:param>generate.section.toc.level=1
|
|
||||||
;
|
|
||||||
@@ -1,363 +0,0 @@
|
|||||||
[/
|
|
||||||
Copyright 2001, 2003, 2004, 2012 Daryle Walker.
|
|
||||||
|
|
||||||
Distributed under the Boost Software License, Version 1.0.
|
|
||||||
|
|
||||||
See accompanying file LICENSE_1_0.txt
|
|
||||||
or copy at http://boost.org/LICENSE_1_0.txt
|
|
||||||
]
|
|
||||||
|
|
||||||
[article Base_From_Member
|
|
||||||
[quickbook 1.5]
|
|
||||||
[authors [Walker, Daryle]]
|
|
||||||
[copyright 2001, 2003, 2004, 2012 Daryle Walker]
|
|
||||||
[license
|
|
||||||
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])
|
|
||||||
]
|
|
||||||
]
|
|
||||||
|
|
||||||
[section Rationale]
|
|
||||||
|
|
||||||
When developing a class, sometimes a base class needs to be initialized
|
|
||||||
with a member of the current class. As a na\u00EFve example:
|
|
||||||
|
|
||||||
#include <streambuf> /* for std::streambuf */
|
|
||||||
#include <ostream> /* for std::ostream */
|
|
||||||
|
|
||||||
class fdoutbuf
|
|
||||||
: public std::streambuf
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
explicit fdoutbuf( int fd );
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
class fdostream
|
|
||||||
: public std::ostream
|
|
||||||
{
|
|
||||||
protected:
|
|
||||||
fdoutbuf buf;
|
|
||||||
public:
|
|
||||||
explicit fdostream( int fd )
|
|
||||||
: buf( fd ), std::ostream( &buf ) {}
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
This is undefined because C++'s initialization order mandates that the base
|
|
||||||
class is initialized before the member it uses. [@http://www.moocat.org R.
|
|
||||||
Samuel Klatchko] developed a way around this by using the initialization
|
|
||||||
order in his favor. Base classes are intialized in order of declaration, so
|
|
||||||
moving the desired member to another base class, that is initialized before
|
|
||||||
the desired base class, can ensure proper initialization.
|
|
||||||
|
|
||||||
A custom base class can be made for this idiom:
|
|
||||||
|
|
||||||
#include <streambuf> /* for std::streambuf */
|
|
||||||
#include <ostream> /* for std::ostream */
|
|
||||||
|
|
||||||
class fdoutbuf
|
|
||||||
: public std::streambuf
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
explicit fdoutbuf( int fd );
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
struct fdostream_pbase
|
|
||||||
{
|
|
||||||
fdoutbuf sbuffer;
|
|
||||||
|
|
||||||
explicit fdostream_pbase( int fd )
|
|
||||||
: sbuffer( fd ) {}
|
|
||||||
};
|
|
||||||
|
|
||||||
class fdostream
|
|
||||||
: private fdostream_pbase
|
|
||||||
, public std::ostream
|
|
||||||
{
|
|
||||||
typedef fdostream_pbase pbase_type;
|
|
||||||
typedef std::ostream base_type;
|
|
||||||
|
|
||||||
public:
|
|
||||||
explicit fdostream( int fd )
|
|
||||||
: pbase_type( fd ), base_type( &sbuffer ) {}
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
Other projects can use similar custom base classes. The technique is basic
|
|
||||||
enough to make a template, with a sample template class in this library.
|
|
||||||
The main template parameter is the type of the enclosed member. The
|
|
||||||
template class has several (explicit) constructor member templates, which
|
|
||||||
implicitly type the constructor arguments and pass them to the member. The
|
|
||||||
template class uses implicit copy construction and assignment, cancelling
|
|
||||||
them if the enclosed member is non-copyable.
|
|
||||||
|
|
||||||
Manually coding a base class may be better if the construction and/or
|
|
||||||
copying needs are too complex for the supplied template class, or if the
|
|
||||||
compiler is not advanced enough to use it.
|
|
||||||
|
|
||||||
Since base classes are unnamed, a class cannot have multiple (direct) base
|
|
||||||
classes of the same type. The supplied template class has an extra template
|
|
||||||
parameter, an integer, that exists solely to provide type differentiation.
|
|
||||||
This parameter has a default value so a single use of a particular member
|
|
||||||
type does not need to concern itself with the integer.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Synopsis]
|
|
||||||
|
|
||||||
#include <type_traits> /* exposition only */
|
|
||||||
|
|
||||||
#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
|
|
||||||
#define BOOST_BASE_FROM_MEMBER_MAX_ARITY 10
|
|
||||||
#endif
|
|
||||||
|
|
||||||
template < typename MemberType, int UniqueID = 0 >
|
|
||||||
class boost::base_from_member
|
|
||||||
{
|
|
||||||
protected:
|
|
||||||
MemberType member;
|
|
||||||
|
|
||||||
#if ``['C++11 is in use]``
|
|
||||||
template< typename ...T >
|
|
||||||
explicit constexpr base_from_member( T&& ...x )
|
|
||||||
noexcept( std::is_nothrow_constructible<MemberType, T...>::value );
|
|
||||||
#else
|
|
||||||
base_from_member();
|
|
||||||
|
|
||||||
template< typename T1 >
|
|
||||||
explicit base_from_member( T1 x1 );
|
|
||||||
|
|
||||||
template< typename T1, typename T2 >
|
|
||||||
base_from_member( T1 x1, T2 x2 );
|
|
||||||
|
|
||||||
//...
|
|
||||||
|
|
||||||
template< typename T1, typename T2, typename T3, typename T4,
|
|
||||||
typename T5, typename T6, typename T7, typename T8, typename T9,
|
|
||||||
typename T10 >
|
|
||||||
base_from_member( T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6, T7 x7,
|
|
||||||
T8 x8, T9 x9, T10 x10 );
|
|
||||||
#endif
|
|
||||||
};
|
|
||||||
|
|
||||||
template < typename MemberType, int UniqueID >
|
|
||||||
class base_from_member<MemberType&, UniqueID>
|
|
||||||
{
|
|
||||||
protected:
|
|
||||||
MemberType& member;
|
|
||||||
|
|
||||||
explicit constexpr base_from_member( MemberType& x )
|
|
||||||
noexcept;
|
|
||||||
};
|
|
||||||
|
|
||||||
The class template has a first template parameter `MemberType` representing
|
|
||||||
the type of the based-member. It has a last template parameter `UniqueID`,
|
|
||||||
that is an `int`, to differentiate between multiple base classes that use
|
|
||||||
the same based-member type. The last template parameter has a default value
|
|
||||||
of zero if it is omitted. The class template has a protected data member
|
|
||||||
called `member` that the derived class can use for later base classes (or
|
|
||||||
itself).
|
|
||||||
|
|
||||||
If the appropriate features of C++11 are present, there will be a single
|
|
||||||
constructor template. It implements ['perfect forwarding] to the best
|
|
||||||
constructor call of `member` (if any). The constructor template is marked
|
|
||||||
both `constexpr` and `explicit`. The former will be ignored if the
|
|
||||||
corresponding inner constructor call (of `member`) does not have the marker.
|
|
||||||
The latter binds the other way; always taking effect, even when the inner
|
|
||||||
constructor call does not have the marker. The constructor template
|
|
||||||
propagates the `noexcept` status of the inner constructor call. (The
|
|
||||||
constructor template has a trailing parameter with a default value that
|
|
||||||
disables the template when its signature is too close to the signatures of
|
|
||||||
the automatically-defined non-template copy- and/or move-constructors of
|
|
||||||
`base_from_member`.)
|
|
||||||
|
|
||||||
On earlier-standard compilers, there is a default constructor and several
|
|
||||||
constructor member templates. These constructor templates can take as many
|
|
||||||
arguments (currently up to ten) as possible and pass them to a constructor
|
|
||||||
of the data member.
|
|
||||||
|
|
||||||
A specialization for member references offers a single constructor taking
|
|
||||||
a `MemberType&`, which is the only way to initialize a reference.
|
|
||||||
|
|
||||||
Since C++ does not allow any way to explicitly state the template parameters
|
|
||||||
of a templated constructor, make sure that the arguments are already close
|
|
||||||
as possible to the actual type used in the data member's desired constructor.
|
|
||||||
Explicit conversions may be necessary.
|
|
||||||
|
|
||||||
The `BOOST_BASE_FROM_MEMBER_MAX_ARITY` macro constant specifies the maximum
|
|
||||||
argument length for the constructor templates. The constant may be overridden
|
|
||||||
if more (or less) argument configurations are needed. The constant may be
|
|
||||||
read for code that is expandable like the class template and needs to
|
|
||||||
maintain the same maximum size. (Example code would be a class that uses
|
|
||||||
this class template as a base class for a member with a flexible set of
|
|
||||||
constructors.) This constant is ignored when C++11 features are present.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Usage]
|
|
||||||
|
|
||||||
With the starting example, the `fdoutbuf` sub-object needs to be
|
|
||||||
encapsulated in a base class that is inheirited before `std::ostream`.
|
|
||||||
|
|
||||||
#include <boost/utility/base_from_member.hpp>
|
|
||||||
|
|
||||||
#include <streambuf> // for std::streambuf
|
|
||||||
#include <ostream> // for std::ostream
|
|
||||||
|
|
||||||
class fdoutbuf
|
|
||||||
: public std::streambuf
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
explicit fdoutbuf( int fd );
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
class fdostream
|
|
||||||
: private boost::base_from_member<fdoutbuf>
|
|
||||||
, public std::ostream
|
|
||||||
{
|
|
||||||
// Helper typedef's
|
|
||||||
typedef boost::base_from_member<fdoutbuf> pbase_type;
|
|
||||||
typedef std::ostream base_type;
|
|
||||||
|
|
||||||
public:
|
|
||||||
explicit fdostream( int fd )
|
|
||||||
: pbase_type( fd ), base_type( &member ){}
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
The base-from-member idiom is an implementation detail, so it should not
|
|
||||||
be visible to the clients (or any derived classes) of `fdostream`. Due to
|
|
||||||
the initialization order, the `fdoutbuf` sub-object will get initialized
|
|
||||||
before the `std::ostream` sub-object does, making the former sub-object
|
|
||||||
safe to use in the latter sub-object's construction. Since the `fdoutbuf`
|
|
||||||
sub-object of the final type is the only sub-object with the name `member`
|
|
||||||
that name can be used unqualified within the final class.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Example]
|
|
||||||
|
|
||||||
The base-from-member class templates should commonly involve only one
|
|
||||||
base-from-member sub-object, usually for attaching a stream-buffer to an
|
|
||||||
I/O stream. The next example demonstrates how to use multiple
|
|
||||||
base-from-member sub-objects and the resulting qualification issues.
|
|
||||||
|
|
||||||
#include <boost/utility/base_from_member.hpp>
|
|
||||||
|
|
||||||
#include <cstddef> /* for NULL */
|
|
||||||
|
|
||||||
struct an_int
|
|
||||||
{
|
|
||||||
int y;
|
|
||||||
|
|
||||||
an_int( float yf );
|
|
||||||
};
|
|
||||||
|
|
||||||
class switcher
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
switcher();
|
|
||||||
switcher( double, int * );
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
class flow_regulator
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
flow_regulator( switcher &, switcher & );
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
template < unsigned Size >
|
|
||||||
class fan
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
explicit fan( switcher );
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
class system
|
|
||||||
: private boost::base_from_member<an_int>
|
|
||||||
, private boost::base_from_member<switcher>
|
|
||||||
, private boost::base_from_member<switcher, 1>
|
|
||||||
, private boost::base_from_member<switcher, 2>
|
|
||||||
, protected flow_regulator
|
|
||||||
, public fan<6>
|
|
||||||
{
|
|
||||||
// Helper typedef's
|
|
||||||
typedef boost::base_from_member<an_int> pbase0_type;
|
|
||||||
typedef boost::base_from_member<switcher> pbase1_type;
|
|
||||||
typedef boost::base_from_member<switcher, 1> pbase2_type;
|
|
||||||
typedef boost::base_from_member<switcher, 2> pbase3_type;
|
|
||||||
|
|
||||||
typedef flow_regulator base1_type;
|
|
||||||
typedef fan<6> base2_type;
|
|
||||||
|
|
||||||
public:
|
|
||||||
system( double x );
|
|
||||||
//...
|
|
||||||
};
|
|
||||||
|
|
||||||
system::system( double x )
|
|
||||||
: pbase0_type( 0.2 )
|
|
||||||
, pbase1_type()
|
|
||||||
, pbase2_type( -16, &this->pbase0_type::member.y )
|
|
||||||
, pbase3_type( x, static_cast<int *>(NULL) )
|
|
||||||
, base1_type( pbase3_type::member, pbase1_type::member )
|
|
||||||
, base2_type( pbase2_type::member )
|
|
||||||
{
|
|
||||||
//...
|
|
||||||
}
|
|
||||||
|
|
||||||
The final class has multiple sub-objects with the name `member`, so any
|
|
||||||
use of that name needs qualification by a name of the appropriate base
|
|
||||||
type. (Using `typedef`s ease mentioning the base types.) However, the fix
|
|
||||||
introduces a new problem when a pointer is needed. Using the address
|
|
||||||
operator with a sub-object qualified with its class's name results in a
|
|
||||||
pointer-to-member (here, having a type of `an_int boost::base_from_member<
|
|
||||||
an_int, 0> :: *`) instead of a pointer to the member (having a type of
|
|
||||||
`an_int *`). The new problem is fixed by qualifying the sub-object with
|
|
||||||
`this->` and is needed just for pointers, and not for references or values.
|
|
||||||
|
|
||||||
There are some argument conversions in the initialization. The constructor
|
|
||||||
argument for `pbase0_type` is converted from `double` to `float`. The first
|
|
||||||
constructor argument for `pbase2_type` is converted from `int` to `double`.
|
|
||||||
The second constructor argument for `pbase3_type` is a special case of
|
|
||||||
necessary conversion; all forms of the null-pointer literal in C++ (except
|
|
||||||
`nullptr` from C++11) also look like compile-time integral expressions, so
|
|
||||||
C++ always interprets such code as an integer when it has overloads that can
|
|
||||||
take either an integer or a pointer. The last conversion is necessary for the
|
|
||||||
compiler to call a constructor form with the exact pointer type used in
|
|
||||||
`switcher`'s constructor. (If C++11's `nullptr` is used, it still needs a
|
|
||||||
conversion if multiple pointer types can be accepted in a constructor call
|
|
||||||
but `std::nullptr_t` cannot.)
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Acknowledgments]
|
|
||||||
|
|
||||||
* [@http://www.boost.org/people/ed_brey.htm Ed Brey] suggested some interface
|
|
||||||
changes.
|
|
||||||
|
|
||||||
* [@http://www.moocat.org R. Samuel Klatchko] ([@mailto:rsk@moocat.org
|
|
||||||
rsk@moocat.org], [@mailto:rsk@brightmail.com rsk@brightmail.com]) invented
|
|
||||||
the idiom of how to use a class member for initializing a base class.
|
|
||||||
|
|
||||||
* [@http://www.boost.org/people/dietmar_kuehl.htm Dietmar Kuehl] popularized the
|
|
||||||
base-from-member idiom in his [@http://www.informatik.uni-konstanz.de/~kuehl/c++/iostream/
|
|
||||||
IOStream example classes].
|
|
||||||
|
|
||||||
* Jonathan Turkanis supplied an implementation of generating the constructor
|
|
||||||
templates that can be controlled and automated with macros. The
|
|
||||||
implementation uses the [@../../../preprocessor/index.html Preprocessor library].
|
|
||||||
|
|
||||||
* [@http://www.boost.org/people/daryle_walker.html">Daryle Walker] started the
|
|
||||||
library. Contributed the test file [@../../base_from_member_test.cpp
|
|
||||||
base_from_member_test.cpp].
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
@@ -1,99 +0,0 @@
|
|||||||
[/
|
|
||||||
Copyright 2000 Beman Dawes & John Maddock.
|
|
||||||
|
|
||||||
Distributed under the Boost Software License, Version 1.0.
|
|
||||||
|
|
||||||
See accompanying file LICENSE_1_0.txt
|
|
||||||
or copy at http://boost.org/LICENSE_1_0.txt
|
|
||||||
]
|
|
||||||
|
|
||||||
[article Compressed_Pair
|
|
||||||
[quickbook 1.5]
|
|
||||||
[authors [Cleary, Steve]]
|
|
||||||
[authors [Dawes, Beman]]
|
|
||||||
[authors [Hinnant, Howard]]
|
|
||||||
[authors [Maddock, John]]
|
|
||||||
[copyright 2000 Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock]
|
|
||||||
[license
|
|
||||||
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])
|
|
||||||
]
|
|
||||||
]
|
|
||||||
|
|
||||||
[section Overview]
|
|
||||||
|
|
||||||
All of the contents of `<boost/compressed_pair.hpp>` are defined inside
|
|
||||||
`namespace boost`.
|
|
||||||
|
|
||||||
The class `compressed_pair` is very similar to `std::pair`, but if either of
|
|
||||||
the template arguments are empty classes, then the ['empty base-class
|
|
||||||
optimisation] is applied to compress the size of the pair.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Synopsis]
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
typedef typename call_traits<first_type>::reference first_reference;
|
|
||||||
typedef typename call_traits<second_type>::reference second_reference;
|
|
||||||
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
|
||||||
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
|
||||||
|
|
||||||
compressed_pair() : base() {}
|
|
||||||
compressed_pair(first_param_type x, second_param_type y);
|
|
||||||
explicit compressed_pair(first_param_type x);
|
|
||||||
explicit compressed_pair(second_param_type y);
|
|
||||||
|
|
||||||
compressed_pair& operator=(const compressed_pair&);
|
|
||||||
|
|
||||||
first_reference first();
|
|
||||||
first_const_reference first() const;
|
|
||||||
|
|
||||||
second_reference second();
|
|
||||||
second_const_reference second() const;
|
|
||||||
|
|
||||||
void swap(compressed_pair& y);
|
|
||||||
};
|
|
||||||
|
|
||||||
The two members of the pair can be accessed using the member functions
|
|
||||||
`first()` and `second()`. Note that not all member functions can be
|
|
||||||
instantiated for all template parameter types. In particular
|
|
||||||
`compressed_pair` can be instantiated for reference and array types,
|
|
||||||
however in these cases the range of constructors that can be used are
|
|
||||||
limited. If types `T1` and `T2` are the same type, then there is only
|
|
||||||
one version of the single-argument constructor, and this constructor
|
|
||||||
initialises both values in the pair to the passed value.
|
|
||||||
|
|
||||||
Note that if either member is a POD type, then that member is not
|
|
||||||
zero-initialized by the `compressed_pair` default constructor: it's up
|
|
||||||
to you to supply an initial value for these types if you want them to have
|
|
||||||
a default value.
|
|
||||||
|
|
||||||
Note that `compressed_pair` can not be instantiated if either of the
|
|
||||||
template arguments is a union type, unless there is compiler support for
|
|
||||||
`boost::is_union`, or if `boost::is_union` is specialised for the union
|
|
||||||
type.
|
|
||||||
|
|
||||||
Finally, a word of caution for Visual C++ 6 users: if either argument is an
|
|
||||||
empty type, then assigning to that member will produce memory corruption,
|
|
||||||
unless the empty type has a "do nothing" assignment operator defined. This
|
|
||||||
is due to a bug in the way VC6 generates implicit assignment operators.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Acknowledgments]
|
|
||||||
|
|
||||||
Based on contributions by Steve Cleary, Beman Dawes, Howard Hinnant and
|
|
||||||
John Maddock.
|
|
||||||
|
|
||||||
Maintained by [@mailto:john@johnmaddock.co.uk John Maddock].
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
114
doc/declval.qbk
114
doc/declval.qbk
@@ -1,114 +0,0 @@
|
|||||||
[/
|
|
||||||
/ Copyright (c) 2008 Howard Hinnant
|
|
||||||
/ Copyright (c) 2009-20012 Vicente J. Botet Escriba
|
|
||||||
/
|
|
||||||
/ 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)
|
|
||||||
/]
|
|
||||||
|
|
||||||
[article Declval
|
|
||||||
[quickbook 1.5]
|
|
||||||
[authors [Hinnant, Howard]]
|
|
||||||
[authors [Botet Escriba, Vicente J.]]
|
|
||||||
[copyright 2008 Howard Hinnant]
|
|
||||||
[copyright 2009-2012 Vicente J. Botet Escriba]
|
|
||||||
[license
|
|
||||||
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])
|
|
||||||
]
|
|
||||||
]
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section Overview]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
The motivation for `declval` was introduced in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2958.html#Value N2958:
|
|
||||||
Moving Swap Forward]. Here follows a rewording of this chapter.
|
|
||||||
|
|
||||||
With the provision of decltype, late-specified return types, and default template-arguments for function templates a
|
|
||||||
new generation of SFINAE patterns will emerge to at least partially compensate the lack of concepts on the C++0x timescale.
|
|
||||||
Using this technique, it is sometimes necessary to obtain an object of a known type in a non-using context, e.g. given the declaration
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T&& declval(); // not used
|
|
||||||
|
|
||||||
as part of the function template declaration
|
|
||||||
|
|
||||||
template<class To, class From>
|
|
||||||
decltype(static_cast<To>(declval<From>())) convert(From&&);
|
|
||||||
|
|
||||||
or as part of a class template definition
|
|
||||||
|
|
||||||
template<class> class result_of;
|
|
||||||
|
|
||||||
template<class Fn, class... ArgTypes>
|
|
||||||
struct result_of<Fn(ArgTypes...)>
|
|
||||||
{
|
|
||||||
typedef decltype(declval<Fn>()(declval<ArgTypes>()...)) type;
|
|
||||||
};
|
|
||||||
|
|
||||||
The role of the function template declval() is a transformation of a type T into a value without using or evaluating this function.
|
|
||||||
The name is supposed to direct the reader's attention to the fact that the expression `declval<T>()` is an lvalue if and only if
|
|
||||||
T is an lvalue-reference, otherwise an rvalue. To extend the domain of this function we can do a bit better by changing its declaration to
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
typename std::add_rvalue_reference<T>::type declval(); // not used
|
|
||||||
|
|
||||||
which ensures that we can also use cv void as template parameter. The careful reader might have noticed that `declval()`
|
|
||||||
already exists under the name create() as part of the definition of the semantics of the type trait is_convertible in the C++0x standard.
|
|
||||||
|
|
||||||
The provision of a new library component that allows the production of values in unevaluated expressions is considered
|
|
||||||
important to realize constrained templates in C++0x where concepts are not available.
|
|
||||||
This extremely light-weight function is expected to be part of the daily tool-box of the C++0x programmer.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
|
|
||||||
[/=================]
|
|
||||||
[section:reference Reference ]
|
|
||||||
[/=================]
|
|
||||||
|
|
||||||
`#include <boost/utility/declval.hpp>`
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
typename add_rvalue_reference<T>::type declval() noexcept; // as unevaluated operand
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
|
|
||||||
The library provides the function template declval to simplify the definition of expressions which occur as unevaluated operands.
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
typename add_rvalue_reference<T>::type declval();
|
|
||||||
|
|
||||||
[*Remarks:] If this function is used, the program is ill-formed.
|
|
||||||
|
|
||||||
[*Remarks:] The template parameter T of declval may be an incomplete type.
|
|
||||||
|
|
||||||
[*Example:]
|
|
||||||
|
|
||||||
template <class To, class From>
|
|
||||||
decltype(static_cast<To>(declval<From>())) convert(From&&);
|
|
||||||
|
|
||||||
Declares a function template convert which only participates in overloading if the type From can be explicitly converted to type To.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section History]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
[heading boost 1.50]
|
|
||||||
|
|
||||||
Fixes:
|
|
||||||
|
|
||||||
* [@http://svn.boost.org/trac/boost/ticket/6570 #6570] Adding noexcept to boost::declval.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@@ -1,381 +0,0 @@
|
|||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
|
|
||||||
<title>String_View</title>
|
|
||||||
<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
|
|
||||||
<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
|
|
||||||
<link rel="home" href="string_view.html" title="String_View">
|
|
||||||
</head>
|
|
||||||
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
|
|
||||||
<table cellpadding="2" width="100%"><tr>
|
|
||||||
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
|
|
||||||
<td align="center"><a href="../../../../index.html">Home</a></td>
|
|
||||||
<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
|
|
||||||
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
|
|
||||||
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
|
|
||||||
<td align="center"><a href="../../../../more/index.htm">More</a></td>
|
|
||||||
</tr></table>
|
|
||||||
<hr>
|
|
||||||
<div class="spirit-nav"></div>
|
|
||||||
<div class="article">
|
|
||||||
<div class="titlepage">
|
|
||||||
<div>
|
|
||||||
<div><h2 class="title">
|
|
||||||
<a name="string_view"></a>String_View</h2></div>
|
|
||||||
<div><div class="authorgroup">
|
|
||||||
<div class="author"><h3 class="author">
|
|
||||||
<span class="firstname">Marshall</span> <span class="surname">Clow</span>
|
|
||||||
</h3></div>
|
|
||||||
<div class="author"><h3 class="author">
|
|
||||||
<span class="firstname">Beman</span> <span class="surname">Dawes</span>
|
|
||||||
</h3></div>
|
|
||||||
</div></div>
|
|
||||||
<div><p class="copyright">Copyright © 2012 Marshall Clow</p></div>
|
|
||||||
<div><p class="copyright">Copyright © 2015 Beman Dawes</p></div>
|
|
||||||
<div><div class="legalnotice">
|
|
||||||
<a name="string_view.legal"></a><p>
|
|
||||||
Distributed under the Boost Software License, Version 1.0. <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>
|
|
||||||
</p>
|
|
||||||
</div></div>
|
|
||||||
</div>
|
|
||||||
<hr>
|
|
||||||
</div>
|
|
||||||
<div class="toc">
|
|
||||||
<p><b>Table of Contents</b></p>
|
|
||||||
<dl>
|
|
||||||
<dt><span class="section"><a href="string_view.html#string_view.overview">Overview</a></span></dt>
|
|
||||||
<dt><span class="section"><a href="string_view.html#string_view.examples">Examples</a></span></dt>
|
|
||||||
<dt><span class="section"><a href="string_view.html#string_view.reference">Reference </a></span></dt>
|
|
||||||
<dt><span class="section"><a href="string_view.html#string_view.compiler_support">Compiler Support</a></span></dt>
|
|
||||||
<dt><span class="section"><a href="string_view.html#string_view.history">History</a></span></dt>
|
|
||||||
</dl>
|
|
||||||
</div>
|
|
||||||
<div class="section">
|
|
||||||
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
|
|
||||||
<a name="string_view.overview"></a><a class="link" href="string_view.html#string_view.overview" title="Overview">Overview</a>
|
|
||||||
</h2></div></div></div>
|
|
||||||
<p>
|
|
||||||
Boost.StringView is an implementation of <code class="computeroutput"><span class="identifier">string_view</span></code>
|
|
||||||
as specified in <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html#string.view" target="_top">N4480:
|
|
||||||
ISO/IEC DTS 19568, Technical Specification - C++ Extensions for Library Fundamentals</a>.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
When you are parsing/processing strings from some external source, frequently
|
|
||||||
you want to pass a piece of text to a procedure for specialized processing.
|
|
||||||
The canonical way to do this is as a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>,
|
|
||||||
but that has certain drawbacks:
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
1) If you are processing a buffer of text (say a HTTP response or the contents
|
|
||||||
of a file), then you have to create the string from the text you want to pass,
|
|
||||||
which involves memory allocation and copying of data.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
2) if a routine receives a constant <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
|
|
||||||
and wants to pass a portion of that string to another routine, then it must
|
|
||||||
create a new string of that substring.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
3) A routine receives a constant <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
|
|
||||||
and wants to return a portion of the string, then it must create a new string
|
|
||||||
to return.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
<code class="computeroutput"><span class="identifier">string_view</span></code> is designed to
|
|
||||||
solve these efficiency problems. A <code class="computeroutput"><span class="identifier">string_view</span></code>
|
|
||||||
is a read-only reference to a contiguous sequence of characters, and provides
|
|
||||||
much of the functionality of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>.
|
|
||||||
A <code class="computeroutput"><span class="identifier">string_view</span></code> is cheap to create,
|
|
||||||
copy and pass by value, because it does not actually own the storage that it
|
|
||||||
points to.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
A <code class="computeroutput"><span class="identifier">string_view</span></code> is implemented
|
|
||||||
as a small struct that contains a pointer to the start of the character data
|
|
||||||
and a count. A <code class="computeroutput"><span class="identifier">string_view</span></code>
|
|
||||||
is cheap to create and cheap to copy.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
<code class="computeroutput"><span class="identifier">string_view</span></code> acts as a container;
|
|
||||||
it includes all the methods that you would expect in a container, including
|
|
||||||
iteration support, <code class="computeroutput"><span class="keyword">operator</span> <span class="special">[]</span></code>,
|
|
||||||
<code class="computeroutput"><span class="identifier">at</span></code> and <code class="computeroutput"><span class="identifier">size</span></code>.
|
|
||||||
It can be used with any of the iterator-based algorithms in the STL - as long
|
|
||||||
as you don't need to change the underlying data (<code class="computeroutput"><span class="identifier">sort</span></code>
|
|
||||||
and <code class="computeroutput"><span class="identifier">remove</span></code>, for example, will
|
|
||||||
not work)
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
Besides generic container functionality, <code class="computeroutput"><span class="identifier">string_view</span></code>
|
|
||||||
provides a subset of the interface of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>.
|
|
||||||
This makes it easy to replace parameters of type <code class="computeroutput"><span class="keyword">const</span>
|
|
||||||
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">&</span></code>
|
|
||||||
with <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">string_view</span></code>. Like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>,
|
|
||||||
<code class="computeroutput"><span class="identifier">string_view</span></code> has a static member
|
|
||||||
variable named <code class="computeroutput"><span class="identifier">npos</span></code> to denote
|
|
||||||
the result of failed searches, and to mean "the end".
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
Because a <code class="computeroutput"><span class="identifier">string_view</span></code> does
|
|
||||||
not own the data that it "points to", it introduces lifetime issues
|
|
||||||
into code that uses it. The programmer must ensure that the data that a <code class="computeroutput"><span class="identifier">string_view</span></code> refers to exists as long as the
|
|
||||||
<code class="computeroutput"><span class="identifier">string_view</span></code> does.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
Note: The header actually contains a class template, <code class="computeroutput"><span class="identifier">basic_string_view</span></code>
|
|
||||||
and four typedefs:
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span> <span class="special">=</span> <span class="identifier">char_traits</span><span class="special"><</span><span class="identifier">charT</span><span class="special">>></span>
|
|
||||||
<span class="keyword">class</span> <span class="identifier">basic_string_view</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">basic_string_view</span><span class="special"><</span><span class="keyword">char</span><span class="special">></span> <span class="identifier">string_view</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">basic_string_view</span><span class="special"><</span><span class="keyword">char16_t</span><span class="special">></span> <span class="identifier">u16string_view</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">basic_string_view</span><span class="special"><</span><span class="keyword">char32_t</span><span class="special">></span> <span class="identifier">u32string_view</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">basic_string_view</span><span class="special"><</span><span class="keyword">wchar_t</span><span class="special">></span> <span class="identifier">wstring_view</span><span class="special">;</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
So you can have views of strings of any of the four built-in character types
|
|
||||||
as well as strings of user-defined character-like type strings. For the sake
|
|
||||||
of simple exposition, we concentrate on <code class="computeroutput"><span class="identifier">string_view</span></code>
|
|
||||||
(i.e. <code class="computeroutput"><span class="keyword">char</span></code> strings) in this documentation.
|
|
||||||
</p>
|
|
||||||
</div>
|
|
||||||
<div class="section">
|
|
||||||
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
|
|
||||||
<a name="string_view.examples"></a><a class="link" href="string_view.html#string_view.examples" title="Examples">Examples</a>
|
|
||||||
</h2></div></div></div>
|
|
||||||
<p>
|
|
||||||
Integrating <code class="computeroutput"><span class="identifier">string_view</span></code> into
|
|
||||||
your code is fairly simple. Wherever you pass a <code class="computeroutput"><span class="keyword">const</span>
|
|
||||||
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">&</span></code>
|
|
||||||
or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code> as a parameter, that's a candidate
|
|
||||||
for passing a <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">string_view</span></code>.
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">extract_part</span> <span class="special">(</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">&</span><span class="identifier">bar</span> <span class="special">)</span> <span class="special">{</span>
|
|
||||||
<span class="keyword">return</span> <span class="identifier">bar</span><span class="special">.</span><span class="identifier">substr</span> <span class="special">(</span> <span class="number">2</span><span class="special">,</span> <span class="number">3</span> <span class="special">);</span>
|
|
||||||
<span class="special">}</span>
|
|
||||||
|
|
||||||
<span class="keyword">if</span> <span class="special">(</span> <span class="identifier">extract_part</span> <span class="special">(</span> <span class="string">"ABCDEFG"</span> <span class="special">).</span><span class="identifier">front</span><span class="special">()</span> <span class="special">==</span> <span class="char">'C'</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">/* do something */</span> <span class="special">}</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
Let's figure out what happens in this (contrived) example.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
First, a temporary string is created from the string literal <code class="computeroutput"><span class="string">"ABCDEFG"</span></code>, and it is passed (by reference)
|
|
||||||
to the routine <code class="computeroutput"><span class="identifier">extract_part</span></code>.
|
|
||||||
Then a second string is created in the call <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">::</span><span class="identifier">substr</span></code>
|
|
||||||
and returned to <code class="computeroutput"><span class="identifier">extract_part</span></code>
|
|
||||||
(this copy may be elided by RVO). Then <code class="computeroutput"><span class="identifier">extract_part</span></code>
|
|
||||||
returns that string back to the caller (again this copy may be elided). The
|
|
||||||
first temporary string is deallocated, and <code class="computeroutput"><span class="identifier">front</span></code>
|
|
||||||
is called on the second string, and then it is deallocated as well.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
Two <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>s are created, and two copy operations.
|
|
||||||
That's (potentially) four memory allocations and deallocations, and the associated
|
|
||||||
copying of data.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
Now let's look at the same code with <code class="computeroutput"><span class="identifier">string_view</span></code>:
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">string_view</span> <span class="identifier">extract_part</span> <span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">string_view</span> <span class="identifier">bar</span> <span class="special">)</span> <span class="special">{</span>
|
|
||||||
<span class="keyword">return</span> <span class="identifier">bar</span><span class="special">.</span><span class="identifier">substr</span> <span class="special">(</span> <span class="number">2</span><span class="special">,</span> <span class="number">3</span> <span class="special">);</span>
|
|
||||||
<span class="special">}</span>
|
|
||||||
|
|
||||||
<span class="keyword">if</span> <span class="special">(</span> <span class="identifier">extract_part</span> <span class="special">(</span> <span class="string">"ABCDEFG"</span> <span class="special">).</span><span class="identifier">front</span><span class="special">()</span> <span class="special">==</span> <span class="string">"C"</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">/* do something */</span> <span class="special">}</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
No memory allocations. No copying of character data. No changes to the code
|
|
||||||
other than the types. There are two <code class="computeroutput"><span class="identifier">string_view</span></code>s
|
|
||||||
created, and two <code class="computeroutput"><span class="identifier">string_view</span></code>s
|
|
||||||
copied, but those are cheap operations.
|
|
||||||
</p>
|
|
||||||
</div>
|
|
||||||
<div class="section">
|
|
||||||
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
|
|
||||||
<a name="string_view.reference"></a><a class="link" href="string_view.html#string_view.reference" title="Reference">Reference </a>
|
|
||||||
</h2></div></div></div>
|
|
||||||
<p>
|
|
||||||
The header file "string_view.hpp" defines a class template <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">basic_string_view</span></code>,
|
|
||||||
and four specializations - for <code class="computeroutput"><span class="keyword">char</span></code>
|
|
||||||
/ <code class="computeroutput"><span class="keyword">wchar_t</span></code> / <code class="computeroutput"><span class="keyword">char16_t</span></code>
|
|
||||||
/ <code class="computeroutput"><span class="keyword">char32_t</span></code> .
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">string_view</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
Types:
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">traits</span> <span class="identifier">traits_type</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">charT</span> <span class="identifier">value_type</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">pointer</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">const_pointer</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">charT</span><span class="special">&</span> <span class="identifier">reference</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&</span> <span class="identifier">const_reference</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">const_pointer</span> <span class="identifier">const_iterator</span><span class="special">;</span> <span class="comment">// implementation defined</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">const_iterator</span> <span class="identifier">iterator</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">reverse_iterator</span><span class="special"><</span><span class="identifier">const_iterator</span><span class="special">></span> <span class="identifier">const_reverse_iterator</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">const_reverse_iterator</span> <span class="identifier">reverse_iterator</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">size_type</span><span class="special">;</span>
|
|
||||||
<span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="identifier">difference_type</span><span class="special">;</span>
|
|
||||||
<span class="keyword">static</span> <span class="identifier">BOOST_CONSTEXPR_OR_CONST</span> <span class="identifier">size_type</span> <span class="identifier">npos</span> <span class="special">=</span> <span class="identifier">size_type</span><span class="special">(-</span><span class="number">1</span><span class="special">);</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
Construction and copying:
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">basic_string_view</span> <span class="special">()</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span> <span class="comment">// Constructs empty string_view</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">basic_string_view</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">basic_string_view</span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">basic_string_view</span><span class="special">&</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">basic_string_view</span> <span class="special">&</span><span class="identifier">rhs</span><span class="special">)</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Allocator</span><span class="special">></span>
|
|
||||||
<span class="identifier">basic_string_view</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span><span class="special"><</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">>&</span> <span class="identifier">str</span><span class="special">)</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span> <span class="comment">// Ctor from std::string</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">basic_string_view</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">str</span><span class="special">);</span> <span class="comment">// Ctor from NULL-terminated string</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">basic_string_view</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">str</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">len</span><span class="special">);</span> <span class="comment">// Ctor from pointer, length pair</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
<code class="computeroutput"><span class="identifier">string_view</span></code> does not define
|
|
||||||
a move constructor or a move-assignment operator because copying a <code class="computeroutput"><span class="identifier">string_view</span></code> is just as cheap as moving one
|
|
||||||
would be.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
Basic container-like functions:
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">length</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">bool</span> <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="comment">// All iterators are const_iterators</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">const_iterator</span> <span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">const_iterator</span> <span class="identifier">cbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">const_iterator</span> <span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="identifier">const_iterator</span> <span class="identifier">cend</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">const_reverse_iterator</span> <span class="identifier">rbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">const_reverse_iterator</span> <span class="identifier">crbegin</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">const_reverse_iterator</span> <span class="identifier">rend</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">const_reverse_iterator</span> <span class="identifier">crend</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
Access to the individual elements (all of which are const):
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&</span> <span class="keyword">operator</span><span class="special">[](</span><span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&</span> <span class="identifier">at</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">pos</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&</span> <span class="identifier">front</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">&</span> <span class="identifier">back</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span> <span class="special">;</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
Modifying the <code class="computeroutput"><span class="identifier">string_view</span></code> (but
|
|
||||||
not the underlying data):
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">clear</span><span class="special">();</span> <span class="comment">// boost extension</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="keyword">void</span> <span class="identifier">remove_prefix</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="keyword">void</span> <span class="identifier">remove_suffix</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="keyword">void</span> <span class="identifier">swap</span><span class="special">(</span><span class="identifier">basic_string_view</span><span class="special">&</span> <span class="identifier">s</span><span class="special">)</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
Searching:
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find</span><span class="special">(</span><span class="identifier">basic_string_view</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">rfind</span><span class="special">(</span><span class="identifier">basic_string_view</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">rfind</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">rfind</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">rfind</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_first_of</span><span class="special">(</span><span class="identifier">basic_string_view</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_first_of</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_first_of</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_first_of</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_last_of</span><span class="special">(</span><span class="identifier">basic_string_view</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_last_of</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_last_of</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_last_of</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_first_not_of</span><span class="special">(</span><span class="identifier">basic_string_view</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_first_not_of</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_first_not_of</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_first_not_of</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_last_not_of</span><span class="special">(</span><span class="identifier">basic_string_view</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_last_not_of</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span> <span class="identifier">BOOST_NOEXCEPT</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_last_not_of</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">size_type</span> <span class="identifier">find_last_not_of</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">bool</span> <span class="identifier">starts_with</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <span class="comment">// boost extension</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">bool</span> <span class="identifier">starts_with</span><span class="special">(</span><span class="identifier">basic_string_view</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <span class="comment">// boost extension</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">bool</span> <span class="identifier">ends_with</span><span class="special">(</span><span class="identifier">charT</span> <span class="identifier">c</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <span class="comment">// boost extension</span>
|
|
||||||
<span class="identifier">BOOST_CONSTEXPR</span> <span class="keyword">bool</span> <span class="identifier">ends_with</span><span class="special">(</span><span class="identifier">basic_string_view</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <span class="comment">// boost extension</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
String-like operations:
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">Allocator</span><span class="special">></span> <span class="comment">// Only present if compiler supports C++11 explicit conversion</span>
|
|
||||||
<span class="keyword">explicit</span> <span class="keyword">operator</span> <span class="identifier">basic_string</span><span class="special"><</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">>()</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">allocator</span><span class="special"><</span><span class="identifier">charT</span><span class="special">></span> <span class="special">></span> <span class="comment">// Default only present if compiler supports</span>
|
|
||||||
<span class="identifier">basic_string</span><span class="special"><</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">,</span> <span class="identifier">Allocator</span><span class="special">></span> <span class="comment">// C++11 default template parameters</span>
|
|
||||||
<span class="identifier">to_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Allocator</span><span class="special">&</span> <span class="identifier">a</span> <span class="special">=</span> <span class="identifier">Allocator</span><span class="special">())</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">size_type</span> <span class="identifier">copy</span><span class="special">(</span><span class="identifier">charT</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">size_type</span> <span class="identifier">pos</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">BOOST_CXX14_CONSTEXPR</span> <span class="identifier">basic_string_view</span> <span class="identifier">substr</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">pos</span><span class="special">,</span>
|
|
||||||
<span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">=</span><span class="identifier">npos</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">;</span> <span class="comment">// Create new string_view</span>
|
|
||||||
</pre>
|
|
||||||
<p>
|
|
||||||
Comparison:
|
|
||||||
</p>
|
|
||||||
<pre class="programlisting"><span class="identifier">To</span> <span class="identifier">be</span> <span class="identifier">supplied</span>
|
|
||||||
</pre>
|
|
||||||
</div>
|
|
||||||
<div class="section">
|
|
||||||
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
|
|
||||||
<a name="string_view.compiler_support"></a><a class="link" href="string_view.html#string_view.compiler_support" title="Compiler Support">Compiler Support</a>
|
|
||||||
</h2></div></div></div>
|
|
||||||
<p>
|
|
||||||
This Boost implementation only requires a C++03 compliant compiler.
|
|
||||||
</p>
|
|
||||||
<p>
|
|
||||||
The actual Library Fundamentals specification assumes a C++14 compliant compiler,
|
|
||||||
so a few features are only present if actually supported by the compiler. Boost
|
|
||||||
macros such as BOOST_CONSTEXPR, BOOST_CXX14_CONSTEXPR, and BOOST_NOEXCEPT supply
|
|
||||||
certain features if supported by the compiler.
|
|
||||||
</p>
|
|
||||||
</div>
|
|
||||||
<div class="section">
|
|
||||||
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
|
|
||||||
<a name="string_view.history"></a><a class="link" href="string_view.html#string_view.history" title="History">History</a>
|
|
||||||
</h2></div></div></div>
|
|
||||||
<h4>
|
|
||||||
<a name="string_view.history.h0"></a>
|
|
||||||
<span class="phrase"><a name="string_view.history.boost_1_53"></a></span><a class="link" href="string_view.html#string_view.history.boost_1_53">boost
|
|
||||||
1.53</a>
|
|
||||||
</h4>
|
|
||||||
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
|
|
||||||
Introduced, based on Jeffrey Yaskin's <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html" target="_top">N3442:
|
|
||||||
string_ref: a non-owning reference to a string</a>
|
|
||||||
</li></ul></div>
|
|
||||||
<h4>
|
|
||||||
<a name="string_view.history.h1"></a>
|
|
||||||
<span class="phrase"><a name="string_view.history.boost_1_60"></a></span><a class="link" href="string_view.html#string_view.history.boost_1_60">boost
|
|
||||||
1.60</a>
|
|
||||||
</h4>
|
|
||||||
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
|
|
||||||
Updated to reflect <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html#string.view" target="_top">N4480:
|
|
||||||
ISO/IEC DTS 19568, Technical Specification - C++ Extensions for Library
|
|
||||||
Fundamentals</a>
|
|
||||||
</li></ul></div>
|
|
||||||
</div>
|
|
||||||
</div>
|
|
||||||
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
|
|
||||||
<td align="left"><p><small>Last revised: July 17, 2015 at 19:19:23 GMT</small></p></td>
|
|
||||||
<td align="right"><div class="copyright-footer"></div></td>
|
|
||||||
</tr></table>
|
|
||||||
<hr>
|
|
||||||
<div class="spirit-nav"></div>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,167 +0,0 @@
|
|||||||
[/
|
|
||||||
/ Copyright (c) 2012 Marshall Clow
|
|
||||||
/
|
|
||||||
/ 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)
|
|
||||||
/]
|
|
||||||
|
|
||||||
[article String_Ref
|
|
||||||
[quickbook 1.5]
|
|
||||||
[authors [Clow, Marshall]]
|
|
||||||
[copyright 2012 Marshall Clow]
|
|
||||||
[license
|
|
||||||
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])
|
|
||||||
]
|
|
||||||
]
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section Overview]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
Boost.StringRef is an implementation of Jeffrey Yaskin's [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html N3442:
|
|
||||||
string_ref: a non-owning reference to a string].
|
|
||||||
|
|
||||||
When you are parsing/processing strings from some external source, frequently you want to pass a piece of text to a procedure for specialized processing. The canonical way to do this is as a `std::string`, but that has certain drawbacks:
|
|
||||||
|
|
||||||
1) If you are processing a buffer of text (say a HTTP response or the contents of a file), then you have to create the string from the text you want to pass, which involves memory allocation and copying of data.
|
|
||||||
|
|
||||||
2) if a routine receives a constant `std::string` and wants to pass a portion of that string to another routine, then it must create a new string of that substring.
|
|
||||||
|
|
||||||
3) A routine receives a constant `std::string` and wants to return a portion of the string, then it must create a new string to return.
|
|
||||||
|
|
||||||
`string_ref` is designed to solve these efficiency problems. A `string_ref` is a read-only reference to a contiguous sequence of characters, and provides much of the functionality of `std::string`. A `string_ref` is cheap to create, copy and pass by value, because it does not actually own the storage that it points to.
|
|
||||||
|
|
||||||
A `string_ref` is implemented as a small struct that contains a pointer to the start of the character data and a count. A `string_ref` is cheap to create and cheap to copy.
|
|
||||||
|
|
||||||
`string_ref` acts as a container; it includes all the methods that you would expect in a container, including iteration support, `operator []`, `at` and `size`. It can be used with any of the iterator-based algorithms in the STL - as long as you don't need to change the underlying data (`sort` and `remove`, for example, will not work)
|
|
||||||
|
|
||||||
Besides generic container functionality, `string_ref` provides a subset of the interface of `std::string`. This makes it easy to replace parameters of type `const std::string &` with `boost::string_ref`. Like `std::string`, `string_ref` has a static member variable named `npos` to denote the result of failed searches, and to mean "the end".
|
|
||||||
|
|
||||||
Because a `string_ref` does not own the data that it "points to", it introduces lifetime issues into code that uses it. The programmer must ensure that the data that a `string_ref` refers to exists as long as the `string_ref` does.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section Examples]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
Integrating `string_ref` into your code is fairly simple. Wherever you pass a `const std::string &` or `std::string` as a parameter, that's a candidate for passing a `boost::string_ref`.
|
|
||||||
|
|
||||||
std::string extract_part ( const std::string &bar ) {
|
|
||||||
return bar.substr ( 2, 3 );
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( extract_part ( "ABCDEFG" ).front() == 'C' ) { /* do something */ }
|
|
||||||
|
|
||||||
Let's figure out what happens in this (contrived) example.
|
|
||||||
|
|
||||||
First, a temporary string is created from the string literal `"ABCDEFG"`, and it is passed (by reference) to the routine `extract_part`. Then a second string is created in the call `std::string::substr` and returned to `extract_part` (this copy may be elided by RVO). Then `extract_part` returns that string back to the caller (again this copy may be elided). The first temporary string is deallocated, and `front` is called on the second string, and then it is deallocated as well.
|
|
||||||
|
|
||||||
Two `std::string`s are created, and two copy operations. That's (potentially) four memory allocations and deallocations, and the associated copying of data.
|
|
||||||
|
|
||||||
Now let's look at the same code with `string_ref`:
|
|
||||||
|
|
||||||
boost::string_ref extract_part ( boost::string_ref bar ) {
|
|
||||||
return bar.substr ( 2, 3 );
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( extract_part ( "ABCDEFG" ).front() == "C" ) { /* do something */ }
|
|
||||||
|
|
||||||
No memory allocations. No copying of character data. No changes to the code other than the types. There are two `string_ref`s created, and two `string_ref`s copied, but those are cheap operations.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
|
|
||||||
[/=================]
|
|
||||||
[section:reference Reference ]
|
|
||||||
[/=================]
|
|
||||||
|
|
||||||
The header file "string_ref.hpp" defines a template `boost::basic_string_ref`, and four specializations - for `char` / `wchar_t` / `char16_t` / `char32_t` .
|
|
||||||
|
|
||||||
`#include <boost/utility/string_ref.hpp>`
|
|
||||||
|
|
||||||
Construction and copying:
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR basic_string_ref (); // Constructs an empty string_ref
|
|
||||||
BOOST_CONSTEXPR basic_string_ref(const charT* str); // Constructs from a NULL-terminated string
|
|
||||||
BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len); // Constructs from a pointer, length pair
|
|
||||||
template<typename Allocator>
|
|
||||||
basic_string_ref(const std::basic_string<charT, traits, Allocator>& str); // Constructs from a std::string
|
|
||||||
basic_string_ref (const basic_string_ref &rhs);
|
|
||||||
basic_string_ref& operator=(const basic_string_ref &rhs);
|
|
||||||
|
|
||||||
`string_ref` does not define a move constructor nor a move-assignment operator because copying a `string_ref` is just a cheap as moving one.
|
|
||||||
|
|
||||||
Basic container-like functions:
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR size_type size() const ;
|
|
||||||
BOOST_CONSTEXPR size_type length() const ;
|
|
||||||
BOOST_CONSTEXPR size_type max_size() const ;
|
|
||||||
BOOST_CONSTEXPR bool empty() const ;
|
|
||||||
|
|
||||||
// All iterators are const_iterators
|
|
||||||
BOOST_CONSTEXPR const_iterator begin() const ;
|
|
||||||
BOOST_CONSTEXPR const_iterator cbegin() const ;
|
|
||||||
BOOST_CONSTEXPR const_iterator end() const ;
|
|
||||||
BOOST_CONSTEXPR const_iterator cend() const ;
|
|
||||||
const_reverse_iterator rbegin() const ;
|
|
||||||
const_reverse_iterator crbegin() const ;
|
|
||||||
const_reverse_iterator rend() const ;
|
|
||||||
const_reverse_iterator crend() const ;
|
|
||||||
|
|
||||||
Access to the individual elements (all of which are const):
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR const charT& operator[](size_type pos) const ;
|
|
||||||
const charT& at(size_t pos) const ;
|
|
||||||
BOOST_CONSTEXPR const charT& front() const ;
|
|
||||||
BOOST_CONSTEXPR const charT& back() const ;
|
|
||||||
BOOST_CONSTEXPR const charT* data() const ;
|
|
||||||
|
|
||||||
Modifying the `string_ref` (but not the underlying data):
|
|
||||||
|
|
||||||
void clear();
|
|
||||||
void remove_prefix(size_type n);
|
|
||||||
void remove_suffix(size_type n);
|
|
||||||
|
|
||||||
Searching:
|
|
||||||
|
|
||||||
size_type find(basic_string_ref s) const ;
|
|
||||||
size_type find(charT c) const ;
|
|
||||||
size_type rfind(basic_string_ref s) const ;
|
|
||||||
size_type rfind(charT c) const ;
|
|
||||||
size_type find_first_of(charT c) const ;
|
|
||||||
size_type find_last_of (charT c) const ;
|
|
||||||
|
|
||||||
size_type find_first_of(basic_string_ref s) const ;
|
|
||||||
size_type find_last_of(basic_string_ref s) const ;
|
|
||||||
size_type find_first_not_of(basic_string_ref s) const ;
|
|
||||||
size_type find_first_not_of(charT c) const ;
|
|
||||||
size_type find_last_not_of(basic_string_ref s) const ;
|
|
||||||
size_type find_last_not_of(charT c) const ;
|
|
||||||
|
|
||||||
String-like operations:
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR basic_string_ref substr(size_type pos, size_type n=npos) const ; // Creates a new string_ref
|
|
||||||
bool starts_with(charT c) const ;
|
|
||||||
bool starts_with(basic_string_ref x) const ;
|
|
||||||
bool ends_with(charT c) const ;
|
|
||||||
bool ends_with(basic_string_ref x) const ;
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section History]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
[heading boost 1.53]
|
|
||||||
* Introduced
|
|
||||||
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@@ -1,243 +0,0 @@
|
|||||||
[/
|
|
||||||
/ Copyright (c) 2012 Marshall Clow
|
|
||||||
/ Copyright (c) 2015 Beman Dawes
|
|
||||||
/
|
|
||||||
/ 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)
|
|
||||||
/]
|
|
||||||
|
|
||||||
[article String_View
|
|
||||||
[quickbook 1.5]
|
|
||||||
[authors [Clow, Marshall] [Dawes, Beman]]
|
|
||||||
[copyright 2012 Marshall Clow, 2015 Beman Dawes]
|
|
||||||
[license
|
|
||||||
Distributed under the Boost Software License, Version 1.0.
|
|
||||||
[@http://www.boost.org/LICENSE_1_0.txt]
|
|
||||||
]
|
|
||||||
]
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section Overview]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
Boost.StringView is an implementation of `string_view` as specified in [@
|
|
||||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html#string.view N4480:
|
|
||||||
ISO/IEC DTS 19568, Technical Specification - C++ Extensions for Library Fundamentals].
|
|
||||||
|
|
||||||
When you are parsing/processing strings from some external source, frequently you want to pass a piece of text to a procedure for specialized processing. The canonical way to do this is as a `std::string`, but that has certain drawbacks:
|
|
||||||
|
|
||||||
1) If you are processing a buffer of text (say a HTTP response or the contents of a file), then you have to create the string from the text you want to pass, which involves memory allocation and copying of data.
|
|
||||||
|
|
||||||
2) if a routine receives a constant `std::string` and wants to pass a portion of that string to another routine, then it must create a new string of that substring.
|
|
||||||
|
|
||||||
3) A routine receives a constant `std::string` and wants to return a portion of the string, then it must create a new string to return.
|
|
||||||
|
|
||||||
`string_view` is designed to solve these efficiency problems. A `string_view` is a read-only reference to a contiguous sequence of characters, and provides much of the functionality of `std::string`. A `string_view` is cheap to create, copy and pass by value, because it does not actually own the storage that it points to.
|
|
||||||
|
|
||||||
A `string_view` is implemented as a small struct that contains a pointer to the start of the character data and a count. A `string_view` is cheap to create and cheap to copy.
|
|
||||||
|
|
||||||
`string_view` acts as a container; it includes all the methods that you would expect in a container, including iteration support, `operator []`, `at` and `size`. It can be used with any of the iterator-based algorithms in the STL - as long as you don't need to change the underlying data (`sort` and `remove`, for example, will not work)
|
|
||||||
|
|
||||||
Besides generic container functionality, `string_view` provides a subset of the interface of `std::string`. This makes it easy to replace parameters of type `const std::string &` with `boost::string_view`. Like `std::string`, `string_view` has a static member variable named `npos` to denote the result of failed searches, and to mean "the end".
|
|
||||||
|
|
||||||
Because a `string_view` does not own the data that it "points to", it introduces lifetime issues into code that uses it. The programmer must ensure that the data that a `string_view` refers to exists as long as the `string_view` does.
|
|
||||||
|
|
||||||
Note: The header actually contains a class template, `basic_string_view` and four typedefs:
|
|
||||||
|
|
||||||
template<class charT, class traits = char_traits<charT>>
|
|
||||||
class basic_string_view;
|
|
||||||
|
|
||||||
typedef basic_string_view<char> string_view;
|
|
||||||
typedef basic_string_view<char16_t> u16string_view;
|
|
||||||
typedef basic_string_view<char32_t> u32string_view;
|
|
||||||
typedef basic_string_view<wchar_t> wstring_view;
|
|
||||||
|
|
||||||
So you can have views of strings of any of the four built-in character types as well as strings of user-defined character-like type strings. For the sake of simple exposition, we concentrate on `string_view` (i.e. `char` strings) in this documentation.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section Examples]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
Integrating `string_view` into your code is fairly simple. Wherever you pass a `const std::string &` or `std::string` as a parameter, that's a candidate for passing a `boost::string_view`.
|
|
||||||
|
|
||||||
std::string extract_part ( const std::string &bar ) {
|
|
||||||
return bar.substr ( 2, 3 );
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( extract_part ( "ABCDEFG" ).front() == 'C' ) { /* do something */ }
|
|
||||||
|
|
||||||
Let's figure out what happens in this (contrived) example.
|
|
||||||
|
|
||||||
First, a temporary string is created from the string literal `"ABCDEFG"`, and it is passed (by reference) to the routine `extract_part`. Then a second string is created in the call `std::string::substr` and returned to `extract_part` (this copy may be elided by RVO). Then `extract_part` returns that string back to the caller (again this copy may be elided). The first temporary string is deallocated, and `front` is called on the second string, and then it is deallocated as well.
|
|
||||||
|
|
||||||
Two `std::string`s are created, and two copy operations. That's (potentially) four memory allocations and deallocations, and the associated copying of data.
|
|
||||||
|
|
||||||
Now let's look at the same code with `string_view`:
|
|
||||||
|
|
||||||
boost::string_view extract_part ( boost::string_view bar ) {
|
|
||||||
return bar.substr ( 2, 3 );
|
|
||||||
}
|
|
||||||
|
|
||||||
if ( extract_part ( "ABCDEFG" ).front() == "C" ) { /* do something */ }
|
|
||||||
|
|
||||||
No memory allocations. No copying of character data. No changes to the code other than the types. There are two `string_view`s created, and two `string_view`s copied, but those are cheap operations.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
|
|
||||||
[/=================]
|
|
||||||
[section:reference Reference ]
|
|
||||||
[/=================]
|
|
||||||
|
|
||||||
The header file "string_view.hpp" defines a class template `boost::basic_string_view`, and four specializations - for `char` / `wchar_t` / `char16_t` / `char32_t` .
|
|
||||||
|
|
||||||
`#include <boost/utility/string_view.hpp>`
|
|
||||||
|
|
||||||
Types:
|
|
||||||
|
|
||||||
typedef traits traits_type;
|
|
||||||
typedef charT value_type;
|
|
||||||
typedef charT* pointer;
|
|
||||||
typedef const charT* const_pointer;
|
|
||||||
typedef charT& reference;
|
|
||||||
typedef const charT& const_reference;
|
|
||||||
typedef const_pointer const_iterator; // implementation defined
|
|
||||||
typedef const_iterator iterator;
|
|
||||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
||||||
typedef const_reverse_iterator reverse_iterator;
|
|
||||||
typedef std::size_t size_type;
|
|
||||||
typedef std::ptrdiff_t difference_type;
|
|
||||||
static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);
|
|
||||||
|
|
||||||
Construction and copying:
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR basic_string_view () BOOST_NOEXCEPT; // Constructs empty string_view
|
|
||||||
BOOST_CONSTEXPR basic_string_view (const basic_string_view &rhs) BOOST_NOEXCEPT;
|
|
||||||
basic_string_view& operator=(const basic_string_view &rhs) BOOST_NOEXCEPT;
|
|
||||||
template<typename Allocator>
|
|
||||||
basic_string_view(const std::basic_string<charT, traits, Allocator>& str) BOOST_NOEXCEPT; // Ctor from std::string
|
|
||||||
BOOST_CONSTEXPR basic_string_view(const charT* str); // Ctor from NULL-terminated string
|
|
||||||
BOOST_CONSTEXPR basic_string_view(const charT* str, size_type len); // Ctor from pointer, length pair
|
|
||||||
|
|
||||||
`string_view` does not define a move constructor or a move-assignment operator because copying a `string_view` is just as cheap as moving one would be.
|
|
||||||
|
|
||||||
Basic container-like functions:
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR size_type size() const BOOST_NOEXCEPT ;
|
|
||||||
BOOST_CONSTEXPR size_type length() const BOOST_NOEXCEPT ;
|
|
||||||
BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT ;
|
|
||||||
BOOST_CONSTEXPR bool empty() const BOOST_NOEXCEPT ;
|
|
||||||
|
|
||||||
// All iterators are const_iterators
|
|
||||||
BOOST_CONSTEXPR const_iterator begin() const BOOST_NOEXCEPT ;
|
|
||||||
BOOST_CONSTEXPR const_iterator cbegin() const BOOST_NOEXCEPT ;
|
|
||||||
BOOST_CONSTEXPR const_iterator end() const BOOST_NOEXCEPT ;
|
|
||||||
BOOST_CONSTEXPR const_iterator cend() const BOOST_NOEXCEPT ;
|
|
||||||
const_reverse_iterator rbegin() const BOOST_NOEXCEPT ;
|
|
||||||
const_reverse_iterator crbegin() const BOOST_NOEXCEPT ;
|
|
||||||
const_reverse_iterator rend() const BOOST_NOEXCEPT ;
|
|
||||||
const_reverse_iterator crend() const BOOST_NOEXCEPT ;
|
|
||||||
|
|
||||||
Access to the individual elements (all of which are const):
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR const charT& operator[](size_type pos) const ;
|
|
||||||
BOOST_CONSTEXPR const charT& at(size_t pos) const ;
|
|
||||||
BOOST_CONSTEXPR const charT& front() const ;
|
|
||||||
BOOST_CONSTEXPR const charT& back() const ;
|
|
||||||
BOOST_CONSTEXPR const charT* data() const BOOST_NOEXCEPT ;
|
|
||||||
|
|
||||||
Modifying the `string_view` (but not the underlying data):
|
|
||||||
|
|
||||||
void clear(); // boost extension
|
|
||||||
BOOST_CXX14_CONSTEXPR void remove_prefix(size_type n);
|
|
||||||
BOOST_CXX14_CONSTEXPR void remove_suffix(size_type n);
|
|
||||||
BOOST_CXX14_CONSTEXPR void swap(basic_string_view& s) BOOST_NOEXCEPT;
|
|
||||||
|
|
||||||
Searching:
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find(charT c, size_type pos = 0) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find(const charT* s, size_type pos, size_type n) const;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find(const charT* s, size_type pos = 0) const;
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type rfind(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type rfind(charT c, size_type pos = npos) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type rfind(const charT* s, size_type pos, size_type n) const;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type rfind(const charT* s, size_type pos = npos) const;
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_of(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_of(charT c, size_type pos = 0) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_of(const charT* s, size_type pos, size_type n) const;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_of(const charT* s, size_type pos = 0) const;
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_of(charT c, size_type pos = npos) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_of(const charT* s, size_type pos, size_type n) const;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_of(const charT* s, size_type pos = npos) const;
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_not_of(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_not_of(charT c, size_type pos = 0) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_not_of(const charT* s, size_type pos = 0) const;
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_not_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_not_of(charT c, size_type pos = npos) const BOOST_NOEXCEPT;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_not_of(const charT* s, size_type pos = npos) const;
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR bool starts_with(charT c) const ; // boost extension
|
|
||||||
BOOST_CONSTEXPR bool starts_with(basic_string_view x) const ; // boost extension
|
|
||||||
BOOST_CONSTEXPR bool ends_with(charT c) const ; // boost extension
|
|
||||||
BOOST_CONSTEXPR bool ends_with(basic_string_view x) const ; // boost extension
|
|
||||||
|
|
||||||
String-like operations:
|
|
||||||
|
|
||||||
template<class Allocator> // Only present if compiler supports C++11 explicit conversion
|
|
||||||
explicit operator basic_string<charT, traits, Allocator>() const;
|
|
||||||
|
|
||||||
template<class Allocator = allocator<charT> > // Default only present if compiler supports
|
|
||||||
basic_string<charT, traits, Allocator> // C++11 default template parameters
|
|
||||||
to_string(const Allocator& a = Allocator()) const;
|
|
||||||
|
|
||||||
size_type copy(charT* s, size_type n, size_type pos = 0) const;
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR basic_string_view substr(size_type pos,
|
|
||||||
size_type n=npos) const ; // Create new string_view
|
|
||||||
|
|
||||||
Comparison:
|
|
||||||
|
|
||||||
To be supplied
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section Compiler Support]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
This Boost implementation only requires a C++03 compliant compiler.
|
|
||||||
|
|
||||||
The actual Library Fundamentals specification assumes a C++14 compliant compiler, so a few features are only present if actually supported by the compiler. Boost macros such as BOOST_CONSTEXPR, BOOST_CXX14_CONSTEXPR, and BOOST_NOEXCEPT supply certain features if supported by the compiler.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[/===============]
|
|
||||||
[section History]
|
|
||||||
[/===============]
|
|
||||||
|
|
||||||
[heading boost 1.53]
|
|
||||||
* Introduced, based on Jeffrey Yaskin's [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html N3442:
|
|
||||||
string_ref: a non-owning reference to a string]
|
|
||||||
|
|
||||||
[heading boost 1.60]
|
|
||||||
* Updated to reflect [@
|
|
||||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html#string.view N4480:
|
|
||||||
ISO/IEC DTS 19568, Technical Specification - C++ Extensions for Library Fundamentals]
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@@ -1,15 +0,0 @@
|
|||||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv=refresh content="0; URL=../core/doc/html/core/enable_if.html">
|
|
||||||
<title>Automatic redirection</title>
|
|
||||||
</head>
|
|
||||||
<body>
|
|
||||||
Automatic redirection failed, please go to
|
|
||||||
<a href="../core/doc/html/core/enable_if.html">enable_if.html</a>. <hr>
|
|
||||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
|
||||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
|
||||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,163 +0,0 @@
|
|||||||
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Language" content="en-us">
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
|
|
||||||
|
|
||||||
<title>Generator Iterator Adaptor Documentation</title>
|
|
||||||
</head>
|
|
||||||
|
|
||||||
<body bgcolor="#FFFFFF" text="#000000">
|
|
||||||
<img src="../../boost.png" alt="boost.png (6897 bytes)" align="middle"
|
|
||||||
width="277" height="86">
|
|
||||||
|
|
||||||
<h1>Generator Iterator Adaptor</h1>
|
|
||||||
|
|
||||||
<p>Defined in header <a href=
|
|
||||||
"../../boost/generator_iterator.hpp">boost/generator_iterator.hpp</a></p>
|
|
||||||
|
|
||||||
<p>The generator iterator adaptor makes it easier to create custom input
|
|
||||||
iterators from 0-ary functions and function objects. The adaptor takes a
|
|
||||||
<a href="http://www.sgi.com/tech/stl/Generator.html">Generator</a> and
|
|
||||||
creates a model of <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>. Each
|
|
||||||
increment retrieves an item from the generator and makes it available to be
|
|
||||||
retrieved by dereferencing. The motivation for this iterator is that some
|
|
||||||
concepts can be more naturally expressed as a generator, while most STL
|
|
||||||
algorithms expect an iterator. An example is the <a href=
|
|
||||||
"../random/index.html">Random Number</a> library.</p>
|
|
||||||
|
|
||||||
<h2>Synopsis</h2>
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>
|
|
||||||
namespace boost {
|
|
||||||
template <class Generator>
|
|
||||||
class generator_iterator_policies;
|
|
||||||
|
|
||||||
template <class Generator>
|
|
||||||
class generator_iterator_generator;
|
|
||||||
|
|
||||||
template <class Generator>
|
|
||||||
typename generator_iterator_generator<Generator>::type
|
|
||||||
make_generator_iterator(Generator & gen);
|
|
||||||
}
|
|
||||||
</pre>
|
|
||||||
</blockquote>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<h2>The Generator Iterator Generator Class</h2>
|
|
||||||
|
|
||||||
<p>The class generator_iterator_generator is a helper class whose purpose
|
|
||||||
is to construct a generator iterator type. The template parameter for this
|
|
||||||
class is the Generator function object type that is being wrapped. The
|
|
||||||
generator iterator adaptor only holds a reference (or pointer) to the
|
|
||||||
function object, therefore the function object must outlive the generator
|
|
||||||
iterator adaptor constructed from it.</p>
|
|
||||||
<pre>
|
|
||||||
template <class Generator>
|
|
||||||
class generator_iterator_generator
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef <i>unspecified</i> type; // the resulting generator iterator type
|
|
||||||
}
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<h3>Template Parameters</h3>
|
|
||||||
|
|
||||||
<table border summary="">
|
|
||||||
<tr>
|
|
||||||
<th>Parameter</th>
|
|
||||||
|
|
||||||
<th>Description</th>
|
|
||||||
</tr>
|
|
||||||
|
|
||||||
<tr>
|
|
||||||
<td><tt><a href=
|
|
||||||
"http://www.sgi.com/tech/stl/Generator.html">Generator</a></tt></td>
|
|
||||||
|
|
||||||
<td>The generator (0-ary function object) type being wrapped. The
|
|
||||||
return type of the function must be defined as
|
|
||||||
<tt>Generator::result_type</tt>. The function object must be a model of
|
|
||||||
<a href=
|
|
||||||
"http://www.sgi.com/tech/stl/Generator.html">Generator</a>.</td>
|
|
||||||
</tr>
|
|
||||||
</table>
|
|
||||||
|
|
||||||
<h3>Concept Model</h3>
|
|
||||||
|
|
||||||
<p>The generator iterator class is a model of <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>.</p>
|
|
||||||
|
|
||||||
<h3>Members</h3>
|
|
||||||
|
|
||||||
<p>The generator iterator implements the member functions and operators
|
|
||||||
required of the <a href=
|
|
||||||
"http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
|
|
||||||
concept.<br></p>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<h2><a name="make_generator_iterator" id="make_generator_iterator">The
|
|
||||||
Generator Iterator Object Generator</a></h2>
|
|
||||||
|
|
||||||
<p>The <tt>make_generator_iterator()</tt> function provides a convenient
|
|
||||||
way to create generator iterator objects. The function saves the user the
|
|
||||||
trouble of explicitly writing out the iterator types.</p>
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>
|
|
||||||
template <class Generator>
|
|
||||||
typename generator_iterator_generator<Generator>::type
|
|
||||||
make_generator_iterator(Generator & gen);
|
|
||||||
</pre>
|
|
||||||
</blockquote>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<h3>Example</h3>
|
|
||||||
|
|
||||||
<p>The following program shows how <code>generator_iterator</code>
|
|
||||||
transforms a generator into an input iterator.</p>
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>
|
|
||||||
#include <iostream>
|
|
||||||
#include <boost/generator_iterator.hpp>
|
|
||||||
|
|
||||||
class my_generator
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef int result_type;
|
|
||||||
my_generator() : state(0) { }
|
|
||||||
int operator()() { return ++state; }
|
|
||||||
private:
|
|
||||||
int state;
|
|
||||||
};
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
my_generator gen;
|
|
||||||
boost::generator_iterator_generator<my_generator>::type it = boost::make_generator_iterator(gen);
|
|
||||||
for(int i = 0; i < 10; ++i, ++it)
|
|
||||||
std::cout << *it << std::endl;
|
|
||||||
}
|
|
||||||
</pre>
|
|
||||||
</blockquote>
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<p><a href="http://validator.w3.org/check?uri=referer"><img border="0" src=
|
|
||||||
"../../doc/images/valid-html401.png" alt="Valid HTML 4.01 Transitional"
|
|
||||||
height="31" width="88"></a></p>
|
|
||||||
|
|
||||||
<p>Revised
|
|
||||||
<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->05 December, 2006<!--webbot bot="Timestamp" endspan i-checksum="38516" --></p>
|
|
||||||
|
|
||||||
<p><i>Copyright © 2001 <a href=
|
|
||||||
"http://www.boost.org/people/jens_maurer.htm">Jens Maurer</a></i></p>
|
|
||||||
|
|
||||||
<p><i>Distributed under the Boost Software License, Version 1.0. (See
|
|
||||||
accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
|
|
||||||
copy at <a href=
|
|
||||||
"http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,63 +0,0 @@
|
|||||||
//
|
|
||||||
// Copyright 2014 Peter Dimov
|
|
||||||
//
|
|
||||||
// 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/generator_iterator.hpp>
|
|
||||||
#include <boost/detail/lightweight_test.hpp>
|
|
||||||
#include <algorithm>
|
|
||||||
|
|
||||||
class X
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
|
|
||||||
int v;
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
typedef int result_type;
|
|
||||||
|
|
||||||
X(): v( 0 )
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
int operator()()
|
|
||||||
{
|
|
||||||
return ++v;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class InputIterator, class Size, class OutputIterator> OutputIterator copy_n( InputIterator first, Size n, OutputIterator result )
|
|
||||||
{
|
|
||||||
while( n-- > 0 )
|
|
||||||
{
|
|
||||||
*result++ = *first++;
|
|
||||||
}
|
|
||||||
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
void copy_test()
|
|
||||||
{
|
|
||||||
X x;
|
|
||||||
boost::generator_iterator<X> in( &x );
|
|
||||||
|
|
||||||
int const N = 4;
|
|
||||||
int v[ N ] = { 0 };
|
|
||||||
|
|
||||||
::copy_n( in, 4, v );
|
|
||||||
|
|
||||||
BOOST_TEST_EQ( v[0], 1 );
|
|
||||||
BOOST_TEST_EQ( v[1], 2 );
|
|
||||||
BOOST_TEST_EQ( v[2], 3 );
|
|
||||||
BOOST_TEST_EQ( v[3], 4 );
|
|
||||||
}
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
copy_test();
|
|
||||||
return boost::report_errors();
|
|
||||||
}
|
|
||||||
@@ -1,44 +0,0 @@
|
|||||||
|
|
||||||
# Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
# Distributed under the Boost Software License, Version 1.0
|
|
||||||
# (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
# http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
# Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
import quickbook ;
|
|
||||||
using boostbook ;
|
|
||||||
|
|
||||||
doxygen reference : ../../../../boost/utility/identity_type.hpp
|
|
||||||
: <reftitle>"Reference"
|
|
||||||
<doxygen:param>PREDEFINED="DOXYGEN"
|
|
||||||
<doxygen:param>QUIET=YES
|
|
||||||
<doxygen:param>WARN_IF_UNDOCUMENTED=NO
|
|
||||||
<doxygen:param>HIDE_UNDOC_MEMBERS=YES
|
|
||||||
<doxygen:param>HIDE_UNDOC_CLASSES=YES
|
|
||||||
<doxygen:param>ALIASES=" Params=\"<b>Parameters:</b> <table border="0">\" Param{2}=\"<tr><td><b><tt>\\1</tt></b></td><td>\\2</td></tr>\" EndParams=\"</table>\" Returns=\"<b>Returns:</b>\" Note=\"<b>Note:</b>\" Warning=\"<b>Warning:</b>\" See=\"<b>See:</b>\" RefSect{2}=\"\\xmlonly<link linkend='boost_utility_identitytype.\\1'>\\2</link>\\endxmlonly\" RefClass{1}=\"\\xmlonly<computeroutput><classname alt='\\1'>\\1</classname></computeroutput>\\endxmlonly\" RefFunc{1}=\"\\xmlonly<computeroutput><functionname alt='\\1'>\\1</functionname></computeroutput>\\endxmlonly\" RefMacro{1}=\"\\xmlonly<computeroutput><macroname alt='\\1'>\\1</macroname></computeroutput>\\endxmlonly\" "
|
|
||||||
;
|
|
||||||
|
|
||||||
# This target must be called "index" so to generate "index.html" file.
|
|
||||||
xml index : identity_type.qbk : <dependency>reference ;
|
|
||||||
|
|
||||||
boostbook doc : index
|
|
||||||
: <location>html
|
|
||||||
<format>onehtml
|
|
||||||
<xsl:param>toc.section.depth=0
|
|
||||||
<xsl:param>html.stylesheet=../../../../../doc/src/boostbook.css
|
|
||||||
<xsl:param>boost.root=../../../../..
|
|
||||||
;
|
|
||||||
|
|
||||||
#
|
|
||||||
# This is very imperfect - it results in both html and pdf docs being built,
|
|
||||||
# for some reason I can't get the "onehtml" format specified above to play nice
|
|
||||||
# with the usual incantations for mixed pdf/html builds. JM 06/2012.
|
|
||||||
#
|
|
||||||
boostbook pdf_doc : index
|
|
||||||
:
|
|
||||||
<format>pdf
|
|
||||||
<format>html:<build>no
|
|
||||||
;
|
|
||||||
|
|
||||||
install pdf_doc_install : pdf_doc : <location>. <name>identity_type.pdf <install-type>PDF ;
|
|
||||||
explicit pdf_doc_install ;
|
|
||||||
@@ -1,252 +0,0 @@
|
|||||||
<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Boost.Utility/IdentityType 1.0.0</title><link rel="stylesheet" type="text/css" href="../../../../../doc/src/boostbook.css"><meta name="generator" content="DocBook XSL Stylesheets V1.76.1"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="chapter" title="Boost.Utility/IdentityType 1.0.0"><div class="titlepage"><div><div><h2 class="title"><a name="boost_utility_identitytype"></a>Boost.Utility/IdentityType 1.0.0</h2></div><div><div class="author"><h3 class="author"><span class="firstname">Lorenzo</span> <span class="surname">Caminiti <code class="email"><<a class="email" href="mailto:lorcaminiti@gmail.com">lorcaminiti@gmail.com</a>></code></span></h3></div></div><div><p class="copyright">Copyright © 2009-2012 Lorenzo
|
|
||||||
Caminiti</p></div><div><div class="legalnotice" title="Legal Notice"><a name="boost_utility_identitytype.legal"></a><p>
|
|
||||||
Distributed under the Boost Software License, Version 1.0 (see accompanying
|
|
||||||
file LICENSE_1_0.txt or a copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
|
|
||||||
</p></div></div></div></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="section"><a href="#boost_utility_identitytype.motivation">Motivation</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.solution">Solution</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.templates">Templates</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.abstract_types">Abstract Types</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.annex__usage">Annex: Usage</a></span></dt><dt><span class="section"><a href="#boost_utility_identitytype.annex__implementation">Annex:
|
|
||||||
Implementation</a></span></dt><dt><span class="section"><a href="#reference">Reference</a></span></dt></dl></div><p>
|
|
||||||
This library allows to wrap types within round parenthesis so they can always
|
|
||||||
be passed as macro parameters.
|
|
||||||
</p><div class="section boost_utility_identitytype_motivation" title="Motivation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.motivation"></a><a class="link" href="#boost_utility_identitytype.motivation" title="Motivation">Motivation</a></h2></div></div></div><p>
|
|
||||||
Consider the following macro which declares a variable named <code class="computeroutput"><span class="identifier">var</span></code><code class="literal"><span class="emphasis"><em>n</em></span></code>
|
|
||||||
with the specified <code class="literal"><span class="emphasis"><em>type</em></span></code> (see also
|
|
||||||
<a href="../../test/var_error.cpp" target="_top"><code class="literal">var_error.cpp</code></a>):
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">VAR</span><span class="special">(</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span> <span class="identifier">type</span> <span class="identifier">var</span> <span class="error">#</span><span class="preprocessor"># n</span>
|
|
||||||
|
|
||||||
<span class="identifier">VAR</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="number">1</span><span class="special">);</span> <span class="comment">// OK.</span>
|
|
||||||
<span class="identifier">VAR</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">>,</span> <span class="number">2</span><span class="special">);</span> <span class="comment">// Error.</span>
|
|
||||||
</pre><p>
|
|
||||||
</p><p>
|
|
||||||
The first macro invocation works correctly declaring a variable named <code class="computeroutput"><span class="identifier">var1</span></code> of type <code class="computeroutput"><span class="keyword">int</span></code>.
|
|
||||||
However, the second macro invocation fails generating a preprocessor error
|
|
||||||
similar to the following:
|
|
||||||
</p><pre class="programlisting">error: macro "VAR" passed 3 arguments, but takes just 2
|
|
||||||
</pre><p>
|
|
||||||
That is because the <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span></code> type passed as the first macro parameter
|
|
||||||
contains a comma <code class="computeroutput"><span class="special">,</span></code> not wrapped
|
|
||||||
by round parenthesis <code class="computeroutput"><span class="special">()</span></code>. The preprocessor
|
|
||||||
interprets that unwrapped comma as a separation between macro parameters concluding
|
|
||||||
that a total of three (and not two) parameters are passed to the macro in the
|
|
||||||
following order:
|
|
||||||
</p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
|
|
||||||
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span></code>
|
|
||||||
</li><li class="listitem">
|
|
||||||
<code class="computeroutput"><span class="keyword">char</span><span class="special">></span></code>
|
|
||||||
</li><li class="listitem">
|
|
||||||
<code class="computeroutput"><span class="number">2</span></code>
|
|
||||||
</li></ol></div><p>
|
|
||||||
Note that, differently from the compiler, the preprocessor only recognizes
|
|
||||||
round parenthesis <code class="computeroutput"><span class="special">()</span></code>. Angular
|
|
||||||
<code class="computeroutput"><span class="special"><></span></code> and squared <code class="computeroutput"><span class="special">[]</span></code> parenthesis are not recognized by the preprocessor
|
|
||||||
when parsing macro parameters.
|
|
||||||
</p></div><div class="section boost_utility_identitytype_solution" title="Solution"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.solution"></a><a class="link" href="#boost_utility_identitytype.solution" title="Solution">Solution</a></h2></div></div></div><p>
|
|
||||||
In some cases, it might be possible to workaround this issue by avoiding to
|
|
||||||
pass the type expression to the macro all together. For example, in the case
|
|
||||||
above a <code class="computeroutput"><span class="keyword">typedef</span></code> could have been
|
|
||||||
used to specify the type expression with the commas outside the macro (see
|
|
||||||
also <a href="../../test/var.cpp" target="_top"><code class="literal">var.cpp</code></a>):
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">></span> <span class="identifier">map_type</span><span class="special">;</span>
|
|
||||||
<span class="identifier">VAR</span><span class="special">(</span><span class="identifier">map_type</span><span class="special">,</span> <span class="number">3</span><span class="special">);</span> <span class="comment">// OK.</span>
|
|
||||||
</pre><p>
|
|
||||||
</p><p>
|
|
||||||
When this is neither possible nor desired (e.g., see the function template
|
|
||||||
<code class="computeroutput"><span class="identifier">f</span></code> in the section below), this
|
|
||||||
library header <code class="computeroutput"><a class="link" href="#header.boost.utility.identity_type_hpp" title="Header <boost/utility/identity_type.hpp>">boost/utility/identity_type.hpp</a></code>
|
|
||||||
defines a macro <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
|
|
||||||
which can be used to workaround the issue while keeping the type expression
|
|
||||||
as one of the macro parameters (see also <a href="../../test/var.cpp" target="_top"><code class="literal">var.cpp</code></a>).
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">identity_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
|
|
||||||
|
|
||||||
<span class="identifier">VAR</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">>)),</span> <span class="number">4</span><span class="special">);</span> <span class="comment">// OK.</span>
|
|
||||||
</pre><p>
|
|
||||||
</p><p>
|
|
||||||
The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro
|
|
||||||
expands to an expression that evaluates (at compile-time) to the specified
|
|
||||||
type. The specified type is never split into multiple macro parameters because
|
|
||||||
it is always wrapped by a set of extra round parenthesis <code class="computeroutput"><span class="special">()</span></code>.
|
|
||||||
In fact, a total of two sets of round parenthesis must be used: The parenthesis
|
|
||||||
to invoke the macro <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(...)</span></code> plus the inner parenthesis to wrap the
|
|
||||||
type passed to the macro <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((...))</span></code>.
|
|
||||||
</p><p>
|
|
||||||
This macro works on any <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/standards" target="_top">C++03</a>
|
|
||||||
compiler (and it does not use <a href="http://en.wikipedia.org/wiki/Variadic_macro" target="_top">variadic
|
|
||||||
macros</a>). <sup>[<a name="boost_utility_identitytype.solution.f0" href="#ftn.boost_utility_identitytype.solution.f0" class="footnote">1</a>]</sup> The authors originally developed and tested this library using
|
|
||||||
GNU Compiler Collection (GCC) C++ 4.5.3 (with and without C++11 features enabled
|
|
||||||
<code class="computeroutput"><span class="special">-</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">c</span><span class="special">++</span><span class="number">0</span><span class="identifier">x</span></code>) on Cygwin
|
|
||||||
and Miscrosoft Visual C++ (MSVC) 8.0 on Windows 7. See the library <a href="http://www.boost.org/development/tests/release/developer/utility-identity_type.html" target="_top">regressions
|
|
||||||
test results</a> for more information on supported compilers and platforms.
|
|
||||||
</p></div><div class="section boost_utility_identitytype_templates" title="Templates"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.templates"></a><a class="link" href="#boost_utility_identitytype.templates" title="Templates">Templates</a></h2></div></div></div><p>
|
|
||||||
This macro must be prefixed by <code class="computeroutput"><span class="keyword">typename</span></code>
|
|
||||||
when used within templates. For example, let's program a macro that declares
|
|
||||||
a function parameter named <code class="computeroutput"><span class="identifier">arg</span></code><code class="literal"><span class="emphasis"><em>n</em></span></code>
|
|
||||||
with the specified <code class="literal"><span class="emphasis"><em>type</em></span></code> (see also
|
|
||||||
<a href="../../test/template.cpp" target="_top"><code class="literal">template.cpp</code></a>):
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">ARG</span><span class="special">(</span><span class="identifier">type</span><span class="special">,</span> <span class="identifier">n</span><span class="special">)</span> <span class="identifier">type</span> <span class="identifier">arg</span> <span class="error">#</span><span class="preprocessor"># n</span>
|
|
||||||
|
|
||||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
|
|
||||||
<span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span> <span class="comment">// Prefix macro with `typename` in templates.</span>
|
|
||||||
<span class="identifier">ARG</span><span class="special">(</span><span class="keyword">typename</span> <span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">T</span><span class="special">>)),</span> <span class="number">1</span><span class="special">)</span>
|
|
||||||
<span class="special">)</span> <span class="special">{</span>
|
|
||||||
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special"><<</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
|
|
||||||
<span class="special">}</span>
|
|
||||||
</pre><p>
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">></span> <span class="identifier">a</span><span class="special">;</span>
|
|
||||||
<span class="identifier">a</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special">=</span> <span class="char">'a'</span><span class="special">;</span>
|
|
||||||
|
|
||||||
<span class="identifier">f</span><span class="special"><</span><span class="keyword">char</span><span class="special">>(</span><span class="identifier">a</span><span class="special">);</span> <span class="comment">// OK...</span>
|
|
||||||
<span class="comment">// f(a); // ... but error.</span>
|
|
||||||
</pre><p>
|
|
||||||
</p><p>
|
|
||||||
However, note that the template parameter <code class="computeroutput"><span class="keyword">char</span></code>
|
|
||||||
must be manually specified when invoking the function as in <code class="computeroutput"><span class="identifier">f</span><span class="special"><</span><span class="keyword">char</span><span class="special">>(</span><span class="identifier">a</span><span class="special">)</span></code>. In fact,
|
|
||||||
when the <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
|
|
||||||
macro is used to wrap a function template parameter, the template parameter
|
|
||||||
can no longer be automatically deduced by the compiler form the function call
|
|
||||||
as <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> would
|
|
||||||
have done. <sup>[<a name="boost_utility_identitytype.templates.f0" href="#ftn.boost_utility_identitytype.templates.f0" class="footnote">2</a>]</sup> (This limitation does not apply to class templates because class
|
|
||||||
template parameters must always be explicitly specified.) In other words, without
|
|
||||||
using the <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
|
|
||||||
macro, C++ would normally be able to automatically deduce the function template
|
|
||||||
parameter as shown below:
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
|
|
||||||
<span class="keyword">void</span> <span class="identifier">g</span><span class="special">(</span>
|
|
||||||
<span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">T</span><span class="special">></span> <span class="identifier">arg1</span>
|
|
||||||
<span class="special">)</span> <span class="special">{</span>
|
|
||||||
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span><span class="special">[</span><span class="number">0</span><span class="special">]</span> <span class="special"><<</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
|
|
||||||
<span class="special">}</span>
|
|
||||||
</pre><p>
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="identifier">g</span><span class="special"><</span><span class="keyword">char</span><span class="special">>(</span><span class="identifier">a</span><span class="special">);</span> <span class="comment">// OK...</span>
|
|
||||||
<span class="identifier">g</span><span class="special">(</span><span class="identifier">a</span><span class="special">);</span> <span class="comment">// ... and also OK.</span>
|
|
||||||
</pre><p>
|
|
||||||
</p></div><div class="section boost_utility_identitytype_abstract_types" title="Abstract Types"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.abstract_types"></a><a class="link" href="#boost_utility_identitytype.abstract_types" title="Abstract Types">Abstract Types</a></h2></div></div></div><p>
|
|
||||||
On some compilers (e.g., GCC), using this macro on abstract types (i.e., classes
|
|
||||||
with one or more pure virtual functions) generates a compiler error. This can
|
|
||||||
be avoided by manipulating the type adding and removing a reference to it.
|
|
||||||
</p><p>
|
|
||||||
Let's program a macro that performs a static assertion on a <a href="http://en.wikipedia.org/wiki/Template_metaprogramming" target="_top">Template
|
|
||||||
Meta-Programming</a> (TMP) meta-function (similarly to Boost.MPL <a href="http://www.boost.org/doc/libs/1_36_0/libs/mpl/doc/refmanual/assert.html" target="_top"><code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT</span></code></a>). The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro can be used
|
|
||||||
to pass a meta-function with multiple template parameters to the assert macro
|
|
||||||
(so to handle the commas separating the template parameters). In this case,
|
|
||||||
if the meta-function is an abstract type, it needs to be manipulated adding
|
|
||||||
and removing a reference to it (see also <a href="../../test/abstract.cpp" target="_top"><code class="literal">abstract.cpp</code></a>):
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">)</span> <span class="special">\</span>
|
|
||||||
<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span>
|
|
||||||
|
|
||||||
<span class="keyword">template</span><span class="special"><</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">b</span><span class="special">></span>
|
|
||||||
<span class="keyword">struct</span> <span class="identifier">abstract</span> <span class="special">{</span>
|
|
||||||
<span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">value</span> <span class="special">=</span> <span class="identifier">b</span><span class="special">;</span>
|
|
||||||
<span class="keyword">virtual</span> <span class="keyword">void</span> <span class="identifier">f</span><span class="special">(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="comment">// Pure virtual function.</span>
|
|
||||||
<span class="special">};</span>
|
|
||||||
|
|
||||||
<span class="identifier">TMP_ASSERT</span><span class="special">(</span>
|
|
||||||
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">remove_reference</span><span class="special"><</span> <span class="comment">// Add and remove</span>
|
|
||||||
<span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span> <span class="comment">// reference for</span>
|
|
||||||
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">add_reference</span><span class="special"><</span> <span class="comment">// abstract type.</span>
|
|
||||||
<span class="identifier">abstract</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">true</span><span class="special">></span>
|
|
||||||
<span class="special">>::</span><span class="identifier">type</span>
|
|
||||||
<span class="special">))</span>
|
|
||||||
<span class="special">>::</span><span class="identifier">type</span>
|
|
||||||
<span class="special">);</span>
|
|
||||||
</pre><p>
|
|
||||||
</p></div><div class="section boost_utility_identitytype_annex__usage" title="Annex: Usage"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.annex__usage"></a><a class="link" href="#boost_utility_identitytype.annex__usage" title="Annex: Usage">Annex: Usage</a></h2></div></div></div><p>
|
|
||||||
The <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> macro
|
|
||||||
can be used either when calling a user-defined macro (as shown by the examples
|
|
||||||
so far), or internally when implementing a user-defined macro (as shown below).
|
|
||||||
When <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code> is
|
|
||||||
used in the implementation of the user-defined macro, the caller of the user
|
|
||||||
macro will have to specify the extra parenthesis (see also <a href="../../test/paren.cpp" target="_top"><code class="literal">paren.cpp</code></a>):
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT_PAREN</span><span class="special">(</span><span class="identifier">parenthesized_metafunction</span><span class="special">)</span> <span class="special">\</span>
|
|
||||||
<span class="comment">/* use `BOOST_IDENTITY_TYPE` in macro definition instead of invocation */</span> <span class="special">\</span>
|
|
||||||
<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(</span><span class="identifier">parenthesized_metafunction</span><span class="special">)::</span><span class="identifier">value</span><span class="special">)</span>
|
|
||||||
|
|
||||||
<span class="preprocessor">#define</span> <span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">)</span> <span class="special">\</span>
|
|
||||||
<span class="identifier">BOOST_STATIC_ASSERT</span><span class="special">(</span><span class="identifier">metafunction</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span>
|
|
||||||
|
|
||||||
<span class="comment">// Specify only extra parenthesis `((...))`.</span>
|
|
||||||
<span class="identifier">TMP_ASSERT_PAREN</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">></span> <span class="keyword">const</span><span class="special">>));</span>
|
|
||||||
|
|
||||||
<span class="comment">// Specify both the extra parenthesis `((...))` and `BOOST_IDENTITY_TYPE` macro.</span>
|
|
||||||
<span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">></span> <span class="keyword">const</span><span class="special">>)));</span>
|
|
||||||
</pre><p>
|
|
||||||
</p><p>
|
|
||||||
However, note that the caller will <span class="emphasis"><em>always</em></span> have to specify
|
|
||||||
the extra parenthesis even when the macro parameters contain no comma:
|
|
||||||
</p><p>
|
|
||||||
</p><pre class="programlisting"><span class="identifier">TMP_ASSERT_PAREN</span><span class="special">((</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">>));</span> <span class="comment">// Always extra `((...))`.</span>
|
|
||||||
|
|
||||||
<span class="identifier">TMP_ASSERT</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special"><</span><span class="keyword">int</span> <span class="keyword">const</span><span class="special">>);</span> <span class="comment">// No extra `((...))` and no macro.</span>
|
|
||||||
</pre><p>
|
|
||||||
</p><p>
|
|
||||||
In some cases, using <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
|
|
||||||
in the implementation of the user-defined macro might provide the best syntax
|
|
||||||
for the caller. For example, this is the case for <code class="computeroutput"><span class="identifier">BOOST_MPL_ASSERT</span></code>
|
|
||||||
because the majority of template meta-programming expressions contain unwrapped
|
|
||||||
commas so it is less confusing for the user to always specify the extra parenthesis
|
|
||||||
<code class="computeroutput"><span class="special">((...))</span></code> instead of using <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>:
|
|
||||||
</p><pre class="programlisting"><span class="identifier">BOOST_MPL_ASSERT</span><span class="special">((</span> <span class="comment">// Natural syntax.</span>
|
|
||||||
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">mpl</span><span class="special">::</span><span class="identifier">and_</span><span class="special"><</span>
|
|
||||||
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_const</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span>
|
|
||||||
<span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_reference</span><span class="special"><</span><span class="identifier">T</span><span class="special">></span>
|
|
||||||
<span class="special">></span>
|
|
||||||
<span class="special">));</span>
|
|
||||||
</pre><p>
|
|
||||||
However, in other situations it might be preferable to not require the extra
|
|
||||||
parenthesis in the common cases and handle commas as special cases using <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>. For example, this
|
|
||||||
is the case for <a href="http://www.boost.org/libs/local_function" target="_top"><code class="computeroutput"><span class="identifier">BOOST_LOCAL_FUNCTION</span></code></a> for which always
|
|
||||||
requiring the extra parenthesis <code class="computeroutput"><span class="special">((...))</span></code>
|
|
||||||
around the types would lead to an unnatural syntax for the local function signature:
|
|
||||||
</p><pre class="programlisting"><span class="keyword">int</span> <span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span> <span class="special">((</span><span class="keyword">int</span><span class="special">&))</span> <span class="identifier">x</span><span class="special">,</span> <span class="special">((</span><span class="keyword">int</span><span class="special">&))</span> <span class="identifier">y</span> <span class="special">)</span> <span class="special">{</span> <span class="comment">// Unnatural syntax.</span>
|
|
||||||
<span class="keyword">return</span> <span class="identifier">x</span> <span class="special">+</span> <span class="identifier">y</span><span class="special">;</span>
|
|
||||||
<span class="special">}</span> <span class="identifier">BOOST_LOCAL_FUNCTION_NAME</span><span class="special">(</span><span class="identifier">add</span><span class="special">)</span>
|
|
||||||
</pre><p>
|
|
||||||
Instead requiring the user to specify <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
|
|
||||||
only when needed allows for the more natural syntax <code class="computeroutput"><span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span><span class="keyword">int</span><span class="special">&</span>
|
|
||||||
<span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&</span> <span class="identifier">y</span><span class="special">)</span></code> in the common cases when the parameter types
|
|
||||||
contain no comma (while still allowing to specify parameter types with commas
|
|
||||||
as special cases using <code class="computeroutput"><span class="identifier">BOOST_LOCAL_FUNCTION</span><span class="special">(</span><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">>))&</span>
|
|
||||||
<span class="identifier">x</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&</span> <span class="identifier">y</span><span class="special">)</span></code>).
|
|
||||||
</p></div><div class="section boost_utility_identitytype_annex__implementation" title="Annex: Implementation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="boost_utility_identitytype.annex__implementation"></a><a class="link" href="#boost_utility_identitytype.annex__implementation" title="Annex: Implementation">Annex:
|
|
||||||
Implementation</a></h2></div></div></div><p>
|
|
||||||
The implementation of this library macro is equivalent to the following: <sup>[<a name="boost_utility_identitytype.annex__implementation.f0" href="#ftn.boost_utility_identitytype.annex__implementation.f0" class="footnote">3</a>]</sup>
|
|
||||||
</p><pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">function_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
|
|
||||||
|
|
||||||
<span class="preprocessor">#define</span> <span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(</span><span class="identifier">parenthesized_type</span><span class="special">)</span> <span class="special">\</span>
|
|
||||||
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">function_traits</span><span class="special"><</span><span class="keyword">void</span> <span class="identifier">parenthesized_type</span><span class="special">>::</span><span class="identifier">arg1_type</span>
|
|
||||||
</pre><p>
|
|
||||||
Essentially, the type is wrapped between round parenthesis <code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span>
|
|
||||||
<span class="keyword">char</span><span class="special">>)</span></code>
|
|
||||||
so it can be passed as a single macro parameter even if it contains commas.
|
|
||||||
Then the parenthesized type is transformed into the type of a function returning
|
|
||||||
<code class="computeroutput"><span class="keyword">void</span></code> and with the specified type
|
|
||||||
as the type of the first and only argument <code class="computeroutput"><span class="keyword">void</span>
|
|
||||||
<span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special"><</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">>)</span></code>. Finally, the type of the first argument
|
|
||||||
<code class="computeroutput"><span class="identifier">arg1_type</span></code> is extracted at compile-time
|
|
||||||
using the <code class="computeroutput"><span class="identifier">function_traits</span></code> meta-function
|
|
||||||
therefore obtaining the original type from the parenthesized type (effectively
|
|
||||||
stripping the extra parenthesis from around the specified type).
|
|
||||||
</p></div><div class="section reference" title="Reference"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="reference"></a>Reference</h2></div></div></div><div class="section header_boost_utility_identity_type_hpp" title="Header <boost/utility/identity_type.hpp>"><div class="titlepage"><div><div><h3 class="title"><a name="header.boost.utility.identity_type_hpp"></a>Header <<a href="../../../../../boost/utility/identity_type.hpp" target="_top">boost/utility/identity_type.hpp</a>></h3></div></div></div><p>Wrap type expressions with round parenthesis so they can be passed to macros even if they contain commas. </p><pre class="synopsis">
|
|
||||||
|
|
||||||
<a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a>(parenthesized_type)</pre><div class="refentry" title="Macro BOOST_IDENTITY_TYPE"><a name="BOOST_IDENTITY_TYPE"></a><div class="titlepage"></div><div class="refnamediv"><h2><span class="refentrytitle">Macro BOOST_IDENTITY_TYPE</span></h2><p>BOOST_IDENTITY_TYPE — This macro allows to wrap the specified type expression within extra round parenthesis so the type can be passed as a single macro parameter even if it contains commas (not already wrapped within round parenthesis). </p></div><h2 class="refsynopsisdiv-title">Synopsis</h2><div class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: <<a class="link" href="#header.boost.utility.identity_type_hpp" title="Header <boost/utility/identity_type.hpp>">boost/utility/identity_type.hpp</a>>
|
|
||||||
|
|
||||||
</span>BOOST_IDENTITY_TYPE(parenthesized_type)</pre></div><div class="refsect1" title="Description"><a name="id554262"></a><h2>Description</h2><p><span class="bold"><strong>Parameters:</strong></span> </p><div class="informaltable"><table class="table"><colgroup><col><col></colgroup><tbody><tr><td><span class="bold"><strong><code class="computeroutput">parenthesized_type</code></strong></span></td><td>The type expression to be passed as macro parameter wrapped by a single set of round parenthesis <code class="computeroutput">(...)</code>. This type expression can contain an arbitrary number of commas. </td></tr></tbody></table></div><p>
|
|
||||||
</p><p>This macro works on any C++03 compiler (it does not use variadic macros).</p><p>This macro must be prefixed by <code class="computeroutput">typename</code> when used within templates. Note that the compiler will not be able to automatically determine function template parameters when they are wrapped with this macro (these parameters need to be explicitly specified when calling the function template).</p><p>On some compilers (like GCC), using this macro on abstract types requires to add and remove a reference to the specified type. </p></div></div></div></div><div class="footnotes"><br><hr width="100" align="left"><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.solution.f0" href="#boost_utility_identitytype.solution.f0" class="para">1</a>] </sup>
|
|
||||||
Using variadic macros, it would be possible to require a single set of extra
|
|
||||||
parenthesis <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">(</span></code><code class="literal"><span class="emphasis"><em>type</em></span></code><code class="computeroutput"><span class="special">)</span></code> instead of two <code class="computeroutput"><span class="identifier">BOOST_IDENTITY_TYPE</span><span class="special">((</span></code><code class="literal"><span class="emphasis"><em>type</em></span></code><code class="computeroutput"><span class="special">))</span></code> but variadic macros are not part of C++03
|
|
||||||
(even if nowadays they are supported by most modern compilers and they are
|
|
||||||
also part of C++11).
|
|
||||||
</p></div><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.templates.f0" href="#boost_utility_identitytype.templates.f0" class="para">2</a>] </sup>
|
|
||||||
This is because the implementation of <code class="computeroutput"><a class="link" href="#BOOST_IDENTITY_TYPE" title="Macro BOOST_IDENTITY_TYPE">BOOST_IDENTITY_TYPE</a></code>
|
|
||||||
wraps the specified type within a meta-function.
|
|
||||||
</p></div><div class="footnote"><p><sup>[<a id="ftn.boost_utility_identitytype.annex__implementation.f0" href="#boost_utility_identitytype.annex__implementation.f0" class="para">3</a>] </sup>
|
|
||||||
There is absolutely no guarantee that the macro is actually implemented using
|
|
||||||
the code listed in this documentation. The listed code is for explanatory
|
|
||||||
purposes only.
|
|
||||||
</p></div></div></div></body></html>
|
|
||||||
@@ -1,165 +0,0 @@
|
|||||||
|
|
||||||
[/ Copyright (C) 2009-2012 Lorenzo Caminiti ]
|
|
||||||
[/ Distributed under the Boost Software License, Version 1.0 ]
|
|
||||||
[/ (see accompanying file LICENSE_1_0.txt or a copy at ]
|
|
||||||
[/ http://www.boost.org/LICENSE_1_0.txt) ]
|
|
||||||
[/ Home at http://www.boost.org/libs/utility/identity_type ]
|
|
||||||
|
|
||||||
[library Boost.Utility/IdentityType
|
|
||||||
[quickbook 1.5]
|
|
||||||
[version 1.0.0]
|
|
||||||
[copyright 2009-2012 Lorenzo Caminiti]
|
|
||||||
[purpose wraps types with round parenthesis]
|
|
||||||
[license
|
|
||||||
Distributed under the Boost Software License, Version 1.0
|
|
||||||
(see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
[@http://www.boost.org/LICENSE_1_0.txt])
|
|
||||||
]
|
|
||||||
[authors [Caminiti <email>lorcaminiti@gmail.com</email>, Lorenzo]]
|
|
||||||
[category Utilities]
|
|
||||||
]
|
|
||||||
|
|
||||||
This library allows to wrap types within round parenthesis so they can always be passed as macro parameters.
|
|
||||||
|
|
||||||
[import ../test/var_error.cpp]
|
|
||||||
[import ../test/var.cpp]
|
|
||||||
[import ../test/template.cpp]
|
|
||||||
[import ../test/abstract.cpp]
|
|
||||||
[import ../test/paren.cpp]
|
|
||||||
|
|
||||||
[section Motivation]
|
|
||||||
|
|
||||||
Consider the following macro which declares a variable named `var`[^['n]] with the specified [^['type]] (see also [@../../test/var_error.cpp =var_error.cpp=]):
|
|
||||||
|
|
||||||
[var_error]
|
|
||||||
|
|
||||||
The first macro invocation works correctly declaring a variable named `var1` of type `int`.
|
|
||||||
However, the second macro invocation fails generating a preprocessor error similar to the following:
|
|
||||||
|
|
||||||
[pre
|
|
||||||
error: macro "VAR" passed 3 arguments, but takes just 2
|
|
||||||
]
|
|
||||||
|
|
||||||
That is because the `std::map` type passed as the first macro parameter contains a comma `,` not wrapped by round parenthesis `()`.
|
|
||||||
The preprocessor interprets that unwrapped comma as a separation between macro parameters concluding that a total of three (and not two) parameters are passed to the macro in the following order:
|
|
||||||
|
|
||||||
# `std::map<int`
|
|
||||||
# `char>`
|
|
||||||
# `2`
|
|
||||||
|
|
||||||
Note that, differently from the compiler, the preprocessor only recognizes round parenthesis `()`.
|
|
||||||
Angular `<>` and squared `[]` parenthesis are not recognized by the preprocessor when parsing macro parameters.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Solution]
|
|
||||||
|
|
||||||
In some cases, it might be possible to workaround this issue by avoiding to pass the type expression to the macro all together.
|
|
||||||
For example, in the case above a `typedef` could have been used to specify the type expression with the commas outside the macro (see also [@../../test/var.cpp =var.cpp=]):
|
|
||||||
|
|
||||||
[var_typedef]
|
|
||||||
|
|
||||||
When this is neither possible nor desired (e.g., see the function template `f` in the section below), this library header [headerref boost/utility/identity_type.hpp] defines a macro [macroref BOOST_IDENTITY_TYPE] which can be used to workaround the issue while keeping the type expression as one of the macro parameters (see also [@../../test/var.cpp =var.cpp=]).
|
|
||||||
|
|
||||||
[var_ok]
|
|
||||||
|
|
||||||
The [macroref BOOST_IDENTITY_TYPE] macro expands to an expression that evaluates (at compile-time) to the specified type.
|
|
||||||
The specified type is never split into multiple macro parameters because it is always wrapped by a set of extra round parenthesis `()`.
|
|
||||||
In fact, a total of two sets of round parenthesis must be used: The parenthesis to invoke the macro `BOOST_IDENTITY_TYPE(...)` plus the inner parenthesis to wrap the type passed to the macro `BOOST_IDENTITY_TYPE((...))`.
|
|
||||||
|
|
||||||
This macro works on any [@http://www.open-std.org/JTC1/SC22/WG21/docs/standards C++03] compiler (and it does not use [@http://en.wikipedia.org/wiki/Variadic_macro variadic macros]).
|
|
||||||
[footnote
|
|
||||||
Using variadic macros, it would be possible to require a single set of extra parenthesis `BOOST_IDENTITY_TYPE(`[^['type]]`)` instead of two `BOOST_IDENTITY_TYPE((`[^['type]]`))` but variadic macros are not part of C++03 (even if nowadays they are supported by most modern compilers and they are also part of C++11).
|
|
||||||
]
|
|
||||||
The authors originally developed and tested this library using GNU Compiler Collection (GCC) C++ 4.5.3 (with and without C++11 features enabled `-std=c++0x`) on Cygwin and Miscrosoft Visual C++ (MSVC) 8.0 on Windows 7.
|
|
||||||
See the library [@http://www.boost.org/development/tests/release/developer/utility-identity_type.html regressions test results] for more information on supported compilers and platforms.
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Templates]
|
|
||||||
|
|
||||||
This macro must be prefixed by `typename` when used within templates.
|
|
||||||
For example, let's program a macro that declares a function parameter named `arg`[^['n]] with the specified [^['type]] (see also [@../../test/template.cpp =template.cpp=]):
|
|
||||||
|
|
||||||
[template_f_decl]
|
|
||||||
[template_f_call]
|
|
||||||
|
|
||||||
However, note that the template parameter `char` must be manually specified when invoking the function as in `f<char>(a)`.
|
|
||||||
In fact, when the [macroref BOOST_IDENTITY_TYPE] macro is used to wrap a function template parameter, the template parameter can no longer be automatically deduced by the compiler form the function call as `f(a)` would have done.
|
|
||||||
[footnote
|
|
||||||
This is because the implementation of [macroref BOOST_IDENTITY_TYPE] wraps the specified type within a meta-function.
|
|
||||||
]
|
|
||||||
(This limitation does not apply to class templates because class template parameters must always be explicitly specified.)
|
|
||||||
In other words, without using the [macroref BOOST_IDENTITY_TYPE] macro, C++ would normally be able to automatically deduce the function template parameter as shown below:
|
|
||||||
|
|
||||||
[template_g_decl]
|
|
||||||
[template_g_call]
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Abstract Types]
|
|
||||||
|
|
||||||
On some compilers (e.g., GCC), using this macro on abstract types (i.e., classes with one or more pure virtual functions) generates a compiler error.
|
|
||||||
This can be avoided by manipulating the type adding and removing a reference to it.
|
|
||||||
|
|
||||||
Let's program a macro that performs a static assertion on a [@http://en.wikipedia.org/wiki/Template_metaprogramming Template Meta-Programming] (TMP) meta-function (similarly to Boost.MPL [@http://www.boost.org/doc/libs/1_36_0/libs/mpl/doc/refmanual/assert.html `BOOST_MPL_ASSERT`]).
|
|
||||||
The [macroref BOOST_IDENTITY_TYPE] macro can be used to pass a meta-function with multiple template parameters to the assert macro (so to handle the commas separating the template parameters).
|
|
||||||
In this case, if the meta-function is an abstract type, it needs to be manipulated adding and removing a reference to it (see also [@../../test/abstract.cpp =abstract.cpp=]):
|
|
||||||
|
|
||||||
[abstract]
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Annex: Usage]
|
|
||||||
|
|
||||||
The [macroref BOOST_IDENTITY_TYPE] macro can be used either when calling a user-defined macro (as shown by the examples so far), or internally when implementing a user-defined macro (as shown below).
|
|
||||||
When [macroref BOOST_IDENTITY_TYPE] is used in the implementation of the user-defined macro, the caller of the user macro will have to specify the extra parenthesis (see also [@../../test/paren.cpp =paren.cpp=]):
|
|
||||||
|
|
||||||
[paren]
|
|
||||||
|
|
||||||
However, note that the caller will /always/ have to specify the extra parenthesis even when the macro parameters contain no comma:
|
|
||||||
|
|
||||||
[paren_always]
|
|
||||||
|
|
||||||
In some cases, using [macroref BOOST_IDENTITY_TYPE] in the implementation of the user-defined macro might provide the best syntax for the caller.
|
|
||||||
For example, this is the case for `BOOST_MPL_ASSERT` because the majority of template meta-programming expressions contain unwrapped commas so it is less confusing for the user to always specify the extra parenthesis `((...))` instead of using [macroref BOOST_IDENTITY_TYPE]:
|
|
||||||
|
|
||||||
BOOST_MPL_ASSERT(( // Natural syntax.
|
|
||||||
boost::mpl::and_<
|
|
||||||
boost::is_const<T>
|
|
||||||
, boost::is_reference<T>
|
|
||||||
>
|
|
||||||
));
|
|
||||||
|
|
||||||
However, in other situations it might be preferable to not require the extra parenthesis in the common cases and handle commas as special cases using [macroref BOOST_IDENTITY_TYPE].
|
|
||||||
For example, this is the case for [@http://www.boost.org/libs/local_function `BOOST_LOCAL_FUNCTION`] for which always requiring the extra parenthesis `((...))` around the types would lead to an unnatural syntax for the local function signature:
|
|
||||||
|
|
||||||
int BOOST_LOCAL_FUNCTION( ((int&)) x, ((int&)) y ) { // Unnatural syntax.
|
|
||||||
return x + y;
|
|
||||||
} BOOST_LOCAL_FUNCTION_NAME(add)
|
|
||||||
|
|
||||||
Instead requiring the user to specify [macroref BOOST_IDENTITY_TYPE] only when needed allows for the more natural syntax `BOOST_LOCAL_FUNCTION(int& x, int& y)` in the common cases when the parameter types contain no comma (while still allowing to specify parameter types with commas as special cases using `BOOST_LOCAL_FUNCTION(BOOST_IDENTITY_TYPE((std::map<int, char>))& x, int& y)`).
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[section Annex: Implementation]
|
|
||||||
|
|
||||||
The implementation of this library macro is equivalent to the following:
|
|
||||||
[footnote
|
|
||||||
There is absolutely no guarantee that the macro is actually implemented using the code listed in this documentation.
|
|
||||||
The listed code is for explanatory purposes only.
|
|
||||||
]
|
|
||||||
|
|
||||||
#include <boost/type_traits/function_traits.hpp>
|
|
||||||
|
|
||||||
#define BOOST_IDENTITY_TYPE(parenthesized_type) \
|
|
||||||
boost::function_traits<void parenthesized_type>::arg1_type
|
|
||||||
|
|
||||||
Essentially, the type is wrapped between round parenthesis `(std::map<int, char>)` so it can be passed as a single macro parameter even if it contains commas.
|
|
||||||
Then the parenthesized type is transformed into the type of a function returning `void` and with the specified type as the type of the first and only argument `void (std::map<int, char>)`.
|
|
||||||
Finally, the type of the first argument `arg1_type` is extracted at compile-time using the `function_traits` meta-function therefore obtaining the original type from the parenthesized type (effectively stripping the extra parenthesis from around the specified type).
|
|
||||||
|
|
||||||
[endsect]
|
|
||||||
|
|
||||||
[xinclude reference.xml]
|
|
||||||
|
|
||||||
@@ -1,15 +0,0 @@
|
|||||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="refresh" content="0; URL=doc/html/index.html">
|
|
||||||
</head>
|
|
||||||
<body>
|
|
||||||
Automatic redirection failed, click this
|
|
||||||
<a href="doc/html/index.html">link</a> <hr>
|
|
||||||
<p><EFBFBD> Copyright Lorenzo Caminiti, 2009-2012</p>
|
|
||||||
<p>Distributed under the Boost Software License, Version 1.0 (see
|
|
||||||
accompanying file <a href="../../../LICENSE_1_0.txt">
|
|
||||||
LICENSE_1_0.txt</a> or a copy at
|
|
||||||
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,16 +0,0 @@
|
|||||||
|
|
||||||
# Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
# Distributed under the Boost Software License, Version 1.0
|
|
||||||
# (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
# http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
# Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
import testing ;
|
|
||||||
|
|
||||||
compile-fail var_error.cpp ;
|
|
||||||
run var.cpp ;
|
|
||||||
run template.cpp ;
|
|
||||||
run abstract.cpp ;
|
|
||||||
run noncopyable.cpp ;
|
|
||||||
run paren.cpp ;
|
|
||||||
|
|
||||||
@@ -1,35 +0,0 @@
|
|||||||
|
|
||||||
// Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
// Distributed under the Boost Software License, Version 1.0
|
|
||||||
// (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
// Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
#include <boost/utility/identity_type.hpp>
|
|
||||||
#include <boost/static_assert.hpp>
|
|
||||||
#include <boost/type_traits/add_reference.hpp>
|
|
||||||
#include <boost/type_traits/remove_reference.hpp>
|
|
||||||
|
|
||||||
//[abstract
|
|
||||||
#define TMP_ASSERT(metafunction) \
|
|
||||||
BOOST_STATIC_ASSERT(metafunction::value)
|
|
||||||
|
|
||||||
template<typename T, bool b>
|
|
||||||
struct abstract {
|
|
||||||
static const bool value = b;
|
|
||||||
virtual void f(T const& x) = 0; // Pure virtual function.
|
|
||||||
};
|
|
||||||
|
|
||||||
TMP_ASSERT(
|
|
||||||
boost::remove_reference< // Add and remove
|
|
||||||
BOOST_IDENTITY_TYPE(( // reference for
|
|
||||||
boost::add_reference< // abstract type.
|
|
||||||
abstract<int, true>
|
|
||||||
>::type
|
|
||||||
))
|
|
||||||
>::type
|
|
||||||
);
|
|
||||||
//]
|
|
||||||
|
|
||||||
int main() { return 0; }
|
|
||||||
|
|
||||||
@@ -1,25 +0,0 @@
|
|||||||
|
|
||||||
// Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
// Distributed under the Boost Software License, Version 1.0
|
|
||||||
// (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
// Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
#include <boost/utility/identity_type.hpp>
|
|
||||||
#include <boost/static_assert.hpp>
|
|
||||||
#include <boost/noncopyable.hpp>
|
|
||||||
|
|
||||||
//[noncopyable
|
|
||||||
#define TMP_ASSERT(metafunction) \
|
|
||||||
BOOST_STATIC_ASSERT(metafunction::value)
|
|
||||||
|
|
||||||
template<typename T, T init>
|
|
||||||
struct noncopyable : boost::noncopyable {
|
|
||||||
static const T value = init;
|
|
||||||
};
|
|
||||||
|
|
||||||
TMP_ASSERT(BOOST_IDENTITY_TYPE((noncopyable<bool, true>)));
|
|
||||||
//]
|
|
||||||
|
|
||||||
int main() { return 0; }
|
|
||||||
|
|
||||||
@@ -1,35 +0,0 @@
|
|||||||
|
|
||||||
// Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
// Distributed under the Boost Software License, Version 1.0
|
|
||||||
// (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
// Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
#include <boost/utility/identity_type.hpp>
|
|
||||||
#include <boost/static_assert.hpp>
|
|
||||||
#include <boost/type_traits/is_const.hpp>
|
|
||||||
#include <map>
|
|
||||||
|
|
||||||
//[paren
|
|
||||||
#define TMP_ASSERT_PAREN(parenthesized_metafunction) \
|
|
||||||
/* use `BOOST_IDENTITY_TYPE` in macro definition instead of invocation */ \
|
|
||||||
BOOST_STATIC_ASSERT(BOOST_IDENTITY_TYPE(parenthesized_metafunction)::value)
|
|
||||||
|
|
||||||
#define TMP_ASSERT(metafunction) \
|
|
||||||
BOOST_STATIC_ASSERT(metafunction::value)
|
|
||||||
|
|
||||||
// Specify only extra parenthesis `((...))`.
|
|
||||||
TMP_ASSERT_PAREN((boost::is_const<std::map<int, char> const>));
|
|
||||||
|
|
||||||
// Specify both the extra parenthesis `((...))` and `BOOST_IDENTITY_TYPE` macro.
|
|
||||||
TMP_ASSERT(BOOST_IDENTITY_TYPE((boost::is_const<std::map<int, char> const>)));
|
|
||||||
//]
|
|
||||||
|
|
||||||
//[paren_always
|
|
||||||
TMP_ASSERT_PAREN((boost::is_const<int const>)); // Always extra `((...))`.
|
|
||||||
|
|
||||||
TMP_ASSERT(boost::is_const<int const>); // No extra `((...))` and no macro.
|
|
||||||
//]
|
|
||||||
|
|
||||||
int main() { return 0; }
|
|
||||||
|
|
||||||
@@ -1,48 +0,0 @@
|
|||||||
|
|
||||||
// Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
// Distributed under the Boost Software License, Version 1.0
|
|
||||||
// (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
// Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
#include <boost/utility/identity_type.hpp>
|
|
||||||
#include <map>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
//[template_f_decl
|
|
||||||
#define ARG(type, n) type arg ## n
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
void f( // Prefix macro with `typename` in templates.
|
|
||||||
ARG(typename BOOST_IDENTITY_TYPE((std::map<int, T>)), 1)
|
|
||||||
) {
|
|
||||||
std::cout << arg1[0] << std::endl;
|
|
||||||
}
|
|
||||||
//]
|
|
||||||
|
|
||||||
//[template_g_decl
|
|
||||||
template<typename T>
|
|
||||||
void g(
|
|
||||||
std::map<int, T> arg1
|
|
||||||
) {
|
|
||||||
std::cout << arg1[0] << std::endl;
|
|
||||||
}
|
|
||||||
//]
|
|
||||||
|
|
||||||
int main() {
|
|
||||||
//[template_f_call
|
|
||||||
std::map<int, char> a;
|
|
||||||
a[0] = 'a';
|
|
||||||
|
|
||||||
f<char>(a); // OK...
|
|
||||||
// f(a); // ... but error.
|
|
||||||
//]
|
|
||||||
|
|
||||||
//[template_g_call
|
|
||||||
g<char>(a); // OK...
|
|
||||||
g(a); // ... and also OK.
|
|
||||||
//]
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
@@ -1,26 +0,0 @@
|
|||||||
|
|
||||||
// Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
// Distributed under the Boost Software License, Version 1.0
|
|
||||||
// (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
// Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
#include <map>
|
|
||||||
|
|
||||||
#define VAR(type, n) type var ## n
|
|
||||||
|
|
||||||
VAR(int, 1); // OK.
|
|
||||||
|
|
||||||
//[var_typedef
|
|
||||||
typedef std::map<int, char> map_type;
|
|
||||||
VAR(map_type, 3); // OK.
|
|
||||||
//]
|
|
||||||
|
|
||||||
//[var_ok
|
|
||||||
#include <boost/utility/identity_type.hpp>
|
|
||||||
|
|
||||||
VAR(BOOST_IDENTITY_TYPE((std::map<int, char>)), 4); // OK.
|
|
||||||
//]
|
|
||||||
|
|
||||||
int main() { return 0; }
|
|
||||||
|
|
||||||
@@ -1,18 +0,0 @@
|
|||||||
|
|
||||||
// Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
// Distributed under the Boost Software License, Version 1.0
|
|
||||||
// (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
// Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
#include <map>
|
|
||||||
|
|
||||||
//[var_error
|
|
||||||
#define VAR(type, n) type var ## n
|
|
||||||
|
|
||||||
VAR(int, 1); // OK.
|
|
||||||
VAR(std::map<int, char>, 2); // Error.
|
|
||||||
//]
|
|
||||||
|
|
||||||
int main() { return 0; }
|
|
||||||
|
|
||||||
@@ -1,296 +0,0 @@
|
|||||||
<!DOCTYPE HTML PUBLIC "-//SoftQuad Software//DTD HoTMetaL PRO 5.0::19981217::extensions to HTML 4.0//EN" "hmpro5.dtd">
|
|
||||||
|
|
||||||
<HTML>
|
|
||||||
|
|
||||||
<HEAD>
|
|
||||||
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252">
|
|
||||||
<TITLE>In_place_factory Documentation</TITLE>
|
|
||||||
</HEAD>
|
|
||||||
|
|
||||||
<BODY BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080">
|
|
||||||
<H2 align="left"><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86"></H2>
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<blockquote>
|
|
||||||
<blockquote>
|
|
||||||
<blockquote>
|
|
||||||
<blockquote>
|
|
||||||
<blockquote>
|
|
||||||
<H2 align="left">Header <<A
|
|
||||||
HREF="../../boost/utility/in_place_factory.hpp">boost/utility/in_place_factory.hpp</A>> </H2>
|
|
||||||
|
|
||||||
<H2 align="left">Header <<A
|
|
||||||
HREF="../../boost/utility/typed_in_place_factory.hpp">boost/utility/typed_in_place_factory.hpp</A>> </H2>
|
|
||||||
|
|
||||||
</blockquote>
|
|
||||||
</blockquote>
|
|
||||||
</blockquote>
|
|
||||||
</blockquote>
|
|
||||||
</blockquote>
|
|
||||||
</blockquote>
|
|
||||||
<p> </p>
|
|
||||||
|
|
||||||
<H2>Contents</H2>
|
|
||||||
<DL CLASS="page-index">
|
|
||||||
<DT><A HREF="#mot">Motivation</A></DT>
|
|
||||||
<DT><A HREF="#framework">Framework</A></DT>
|
|
||||||
<DT><A HREF="#specification">Specification</A></DT>
|
|
||||||
<DT><A HREF="#container-usage">Container-side Usage</A></DT>
|
|
||||||
<DT><A HREF="#user-usage">User-side Usage</A></DT>
|
|
||||||
</DL>
|
|
||||||
|
|
||||||
<HR>
|
|
||||||
|
|
||||||
<H2><A NAME="mot"></A>Motivation</H2>
|
|
||||||
|
|
||||||
<p>Suppose we have a class</p>
|
|
||||||
<pre>struct X
|
|
||||||
{
|
|
||||||
X ( int, std::string ) ;
|
|
||||||
} ;</pre>
|
|
||||||
<p>And a container for it which supports an empty state (that is, which can contain zero objects):</p>
|
|
||||||
<pre>struct C
|
|
||||||
{
|
|
||||||
C() : contained_(0) {}
|
|
||||||
~C() { delete contained_ ; }
|
|
||||||
X* contained_ ;
|
|
||||||
} ;</pre>
|
|
||||||
<p>A container designed to support an empty state typically doesn't require the contained type to be DefaultConstructible,
|
|
||||||
but it typically requires it to be CopyConstructible as a mechanism to
|
|
||||||
initialize the object to store:</p>
|
|
||||||
<pre>struct C
|
|
||||||
{
|
|
||||||
C() : contained_(0) {}
|
|
||||||
C ( X const& v ) : contained_ ( new X(v) ) {}
|
|
||||||
~C() { delete contained_ ; }
|
|
||||||
X* contained_ ;
|
|
||||||
} ;</pre>
|
|
||||||
<p>There is a subtle problem with this: since the mechanism used to initialize the stored object is copy construction,
|
|
||||||
there must exist a previously constructed source object to copy from. This
|
|
||||||
object is likely to be temporary and serve no purpose besides being the source</p>
|
|
||||||
<pre>void foo()
|
|
||||||
{
|
|
||||||
// Temporary object created.
|
|
||||||
C c( X(123,"hello") ) ;
|
|
||||||
}
|
|
||||||
</pre>
|
|
||||||
<p>A solution to this problem is to support direct construction of the contained
|
|
||||||
object right in the container's storage.<br>
|
|
||||||
In this scheme, the user supplies the arguments for the X constructor
|
|
||||||
directly to the container:</p>
|
|
||||||
<pre>struct C
|
|
||||||
{
|
|
||||||
C() : contained_(0) {}
|
|
||||||
C ( X const& v ) : contained_ ( new X(v) ) {}
|
|
||||||
C ( int a0, std::string a1 ) : contained_ ( new X(a0,a1) ) {}
|
|
||||||
~C() { delete contained_ ; }
|
|
||||||
X* contained_ ;
|
|
||||||
} ;</pre>
|
|
||||||
<pre>void foo()
|
|
||||||
{
|
|
||||||
// Wrapped object constructed in-place
|
|
||||||
// No temporary created.
|
|
||||||
C c(123,"hello") ;
|
|
||||||
}
|
|
||||||
</pre>
|
|
||||||
<p>Clearly, this solution doesn't scale well since the container must duplicate all the constructor overloads from the contained type
|
|
||||||
(at least all those which are to be supported directly in the container).</p>
|
|
||||||
|
|
||||||
<H2><A NAME="framework"></A>Framework</H2>
|
|
||||||
<p>
|
|
||||||
This library proposes a framework to allow some containers to directly contruct contained objects in-place without requiring
|
|
||||||
the entire set of constructor overloads from the contained type. It also allows the container to remove the CopyConstuctible
|
|
||||||
requirement from the contained type since objects can be directly constructed in-place without need of a copy.<br>
|
|
||||||
The only requirement on the container is that it must provide proper storage (that is, correctly aligned and sized).
|
|
||||||
Naturally, the container will typically support uninitialized storage to avoid the in-place construction to override
|
|
||||||
a fully-constructed object (as this would defeat the purpose of in-place construction)
|
|
||||||
</p>
|
|
||||||
<p>For this purpose, the framework provides two families of classes collectively called: InPlaceFactories and TypedInPlaceFactories.<br>
|
|
||||||
Essentially, these classes hold a sequence of actual parameters and a method to contruct an object in place using these parameters.
|
|
||||||
Each member of the family differs only in the number (and type) of the parameter list. The first family
|
|
||||||
takes the type of the object to construct directly in method provided for that
|
|
||||||
purpose, whereas the second family incorporates that type in the factory class
|
|
||||||
itself..</p>
|
|
||||||
<p>From the container POV, using the framework amounts to calling the factory's method to contruct the object in place.
|
|
||||||
From the user POV, it amounts to creating the right factory object to hold the parameters and pass it to the container.<br>
|
|
||||||
The following simplified example shows the basic idea. A complete example follows the formal specification of the framework:</p>
|
|
||||||
<pre>struct C
|
|
||||||
{
|
|
||||||
template<class InPlaceFactory>
|
|
||||||
C ( InPlaceFactory const& aFactory )
|
|
||||||
:
|
|
||||||
contained_ ( uninitialized_storage() )
|
|
||||||
{
|
|
||||||
aFactory.template apply<X>(contained_);
|
|
||||||
}
|
|
||||||
|
|
||||||
~C()
|
|
||||||
{
|
|
||||||
contained_ -> X::~X();
|
|
||||||
delete[] contained_ ;
|
|
||||||
}
|
|
||||||
|
|
||||||
char* uninitialized_storage() { return new char[sizeof(X)] ; }
|
|
||||||
|
|
||||||
char* contained_ ;
|
|
||||||
} ;
|
|
||||||
|
|
||||||
void foo()
|
|
||||||
{
|
|
||||||
C c( in_place(123,"hello") ) ;
|
|
||||||
}
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<HR>
|
|
||||||
|
|
||||||
<H2><A NAME="specification">Specification</A></H2>
|
|
||||||
|
|
||||||
<p>The following is the first member of the family of 'in_place_factory' classes, along with its corresponding helper template function.
|
|
||||||
The rest of the family varies only in the number and type of template (and constructor) parameters.</p>
|
|
||||||
<PRE>namespace boost {
|
|
||||||
|
|
||||||
struct in_place_factory_base {} ;
|
|
||||||
|
|
||||||
template<class A0>
|
|
||||||
class in_place_factory : public in_place_factory_base
|
|
||||||
{
|
|
||||||
public:</PRE>
|
|
||||||
|
|
||||||
<PRE> in_place_factory ( A0 const& a0 ) : m_a0(a0) {}
|
|
||||||
|
|
||||||
template< class T >
|
|
||||||
void apply ( void* address ) const
|
|
||||||
{
|
|
||||||
new (address) T(m_a0);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:</PRE>
|
|
||||||
|
|
||||||
<PRE> A0 const& m_a0 ;
|
|
||||||
} ;
|
|
||||||
|
|
||||||
template<class A0>
|
|
||||||
in_place_factory<A0> in_place ( A0 const& a0 )
|
|
||||||
{
|
|
||||||
return in_place_factory<A0>(a0);
|
|
||||||
}
|
|
||||||
</PRE>
|
|
||||||
|
|
||||||
<p>Similarly, the following is the first member of the family of 'typed_in_place_factory' classes, along with its corresponding
|
|
||||||
helper template function. The rest of the family varies only in the number and type of template (and constructor) parameters.</p>
|
|
||||||
<PRE>namespace boost {
|
|
||||||
|
|
||||||
struct typed_in_place_factory_base {} ;
|
|
||||||
|
|
||||||
template<class T, class A0>
|
|
||||||
class typed_in_place_factory : public typed_in_place_factory_base
|
|
||||||
{
|
|
||||||
public:</PRE>
|
|
||||||
|
|
||||||
<PRE> typed_in_place_factory ( A0 const& a0 ) : m_a0(a0) {}
|
|
||||||
|
|
||||||
void apply ( void* address ) const
|
|
||||||
{
|
|
||||||
new (address) T(m_a0);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:</PRE>
|
|
||||||
|
|
||||||
<PRE> A0 const& m_a0 ;
|
|
||||||
} ;
|
|
||||||
|
|
||||||
template<class T, class A0>
|
|
||||||
typed_in_place_factory<A0> in_place ( A0 const& a0 )
|
|
||||||
{
|
|
||||||
return typed_in_place_factory<T,A0>(a0);
|
|
||||||
}</PRE>
|
|
||||||
|
|
||||||
<PRE>}
|
|
||||||
</PRE>
|
|
||||||
|
|
||||||
<p>As you can see, the 'in_place_factory' and 'typed_in_place_factory' template classes varies only in the way they specify
|
|
||||||
the target type: in the first family, the type is given as a template argument to the apply member function while in the
|
|
||||||
second it is given directly as part of the factory class.<br>
|
|
||||||
When the container holds a unique non-polymorphic type (such as the case of Boost.Optional), it knows the exact dynamic-type
|
|
||||||
of the contained object and can pass it to the apply() method of a (non-typed) factory.
|
|
||||||
In this case, end users can use an 'in_place_factory' instance which can be constructed without the type of the object to construct.<br>
|
|
||||||
However, if the container holds heterogeneous or polymorphic objects (such as the case of Boost.Variant), the dynamic-type
|
|
||||||
of the object to be constructed must be known by the factory itslef. In this case, end users must use a 'typed_in_place_factory'
|
|
||||||
instead.</p>
|
|
||||||
|
|
||||||
<HR>
|
|
||||||
|
|
||||||
<h2><A NAME="container-usage">Container-side Usage</a></h2>
|
|
||||||
|
|
||||||
<p>As shown in the introductory simplified example, the container class must
|
|
||||||
contain methods that accept an instance of
|
|
||||||
these factories and pass the object's storage to the factory's apply method.<br>
|
|
||||||
However, the type of the factory class cannot be completly specified in the container class because that would
|
|
||||||
defeat the whole purpose of the factories which is to allow the container to accept a variadic argument list
|
|
||||||
for the constructor of its contained object.<br>
|
|
||||||
The correct function overload must be based on the only distinctive and common
|
|
||||||
characteristic of all the classes in each family, the base class.<br>
|
|
||||||
Depending on the container class, you can use 'enable_if' to generate the right overload, or use the following
|
|
||||||
dispatch technique (used in the Boost.Optional class):
|
|
||||||
</p>
|
|
||||||
<pre>struct C
|
|
||||||
{
|
|
||||||
C() : contained_(0) {}
|
|
||||||
C ( X const& v ) : contained_ ( new X(v) ) {}
|
|
||||||
|
|
||||||
template<class Expr>
|
|
||||||
C ( Expr const& expr )
|
|
||||||
:
|
|
||||||
contained_ ( uninitialized_storage() )
|
|
||||||
{
|
|
||||||
construct(expr,&expr)
|
|
||||||
}
|
|
||||||
|
|
||||||
~C() { delete contained_ ; }
|
|
||||||
|
|
||||||
template<class InPlaceFactory>
|
|
||||||
void construct ( InPlaceFactory const& aFactory, boost::in_place_factory_base* )
|
|
||||||
{
|
|
||||||
aFactory.template apply<X>(contained_);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class TypedInPlaceFactory>
|
|
||||||
void construct ( TypedInPlaceFactory const& aFactory, boost::typed_in_place_factory_base* )
|
|
||||||
{
|
|
||||||
aFactory.apply(contained_);
|
|
||||||
}
|
|
||||||
|
|
||||||
X* uninitialized_storage() { return static_cast<X*>(new char[sizeof(X)]) ; }
|
|
||||||
|
|
||||||
X* contained_ ;
|
|
||||||
} ;
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<h2><A NAME="user-usage">User-side Usage</a></h2>
|
|
||||||
|
|
||||||
<p>End users pass to the container an instance of a factory object holding the actual parameters needed to construct the
|
|
||||||
contained object directly within the container. For this, the helper template function 'in_place' is used.<br>
|
|
||||||
The call 'in_place(a0,a1,a2,...,an)' constructs a (non-typed) 'in_place_factory' instance with the given argument list.<br>
|
|
||||||
The call 'in_place<T>(a0,a1,a2,...,an)' constructs a 'typed_in_place_factory' instance with the given argument list for the
|
|
||||||
type 'T'.</p>
|
|
||||||
<pre>void foo()
|
|
||||||
{
|
|
||||||
C a( in_place(123,"hello") ) ; // in_place_factory passed
|
|
||||||
C b( in_place<X>(456,"world") ) ; // typed_in_place_factory passed
|
|
||||||
}
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<P>Revised September 17, 2004</P>
|
|
||||||
<p><EFBFBD> Copyright Fernando Luis Cacciola Carballal, 2004</p>
|
|
||||||
<p> Use, modification, and distribution are subject to the Boost Software
|
|
||||||
License, Version 1.0. (See accompanying file <a href="../../LICENSE_1_0.txt">
|
|
||||||
LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
|
|
||||||
www.boost.org/LICENSE_1_0.txt</a>)</p>
|
|
||||||
<P>Developed by <A HREF="mailto:fernando_cacciola@hotmail.com">Fernando Cacciola</A>,
|
|
||||||
the latest version of this file can be found at <A
|
|
||||||
HREF="http://www.boost.org">www.boost.org</A>, and the boost
|
|
||||||
<A HREF="http://www.boost.org/more/mailing_lists.htm#main">discussion lists</A></P>
|
|
||||||
</BODY>
|
|
||||||
</HTML>
|
|
||||||
@@ -1,11 +1,10 @@
|
|||||||
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
// (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
|
||||||
// Use, modification and distribution are subject to the Boost Software License,
|
// distribute this software is granted provided this copyright notice appears
|
||||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
// http://www.boost.org/LICENSE_1_0.txt).
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
//
|
|
||||||
// See http://www.boost.org/libs/utility for most recent version including documentation.
|
|
||||||
|
|
||||||
// See boost/detail/call_traits.hpp
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
// See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
|
||||||
// for full copyright notices.
|
// for full copyright notices.
|
||||||
|
|
||||||
#ifndef BOOST_CALL_TRAITS_HPP
|
#ifndef BOOST_CALL_TRAITS_HPP
|
||||||
@@ -15,6 +14,10 @@
|
|||||||
#include <boost/config.hpp>
|
#include <boost/config.hpp>
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
|
#include <boost/detail/ob_call_traits.hpp>
|
||||||
|
#else
|
||||||
#include <boost/detail/call_traits.hpp>
|
#include <boost/detail/call_traits.hpp>
|
||||||
|
#endif
|
||||||
|
|
||||||
#endif // BOOST_CALL_TRAITS_HPP
|
#endif // BOOST_CALL_TRAITS_HPP
|
||||||
|
|||||||
@@ -1,11 +1,10 @@
|
|||||||
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
// (C) Copyright Boost.org 2000. Permission to copy, use, modify, sell and
|
||||||
// Use, modification and distribution are subject to the Boost Software License,
|
// distribute this software is granted provided this copyright notice appears
|
||||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
// http://www.boost.org/LICENSE_1_0.txt).
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
//
|
|
||||||
// See http://www.boost.org/libs/utility for most recent version including documentation.
|
|
||||||
|
|
||||||
// See boost/detail/compressed_pair.hpp
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
// See boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp
|
||||||
// for full copyright notices.
|
// for full copyright notices.
|
||||||
|
|
||||||
#ifndef BOOST_COMPRESSED_PAIR_HPP
|
#ifndef BOOST_COMPRESSED_PAIR_HPP
|
||||||
@@ -15,6 +14,10 @@
|
|||||||
#include <boost/config.hpp>
|
#include <boost/config.hpp>
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
|
#include <boost/detail/ob_compressed_pair.hpp>
|
||||||
|
#else
|
||||||
#include <boost/detail/compressed_pair.hpp>
|
#include <boost/detail/compressed_pair.hpp>
|
||||||
|
#endif
|
||||||
|
|
||||||
#endif // BOOST_COMPRESSED_PAIR_HPP
|
#endif // BOOST_COMPRESSED_PAIR_HPP
|
||||||
|
|||||||
@@ -1,9 +1,10 @@
|
|||||||
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
||||||
// Use, modification and distribution are subject to the Boost Software License,
|
// Permission to copy, use, modify, sell and
|
||||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// distribute this software is granted provided this copyright notice appears
|
||||||
// http://www.boost.org/LICENSE_1_0.txt).
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
//
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
// See http://www.boost.org/libs/utility for most recent version including documentation.
|
|
||||||
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
|
||||||
// call_traits: defines typedefs for function usage
|
// call_traits: defines typedefs for function usage
|
||||||
// (see libs/utility/call_traits.htm)
|
// (see libs/utility/call_traits.htm)
|
||||||
@@ -21,51 +22,31 @@
|
|||||||
#ifndef BOOST_CONFIG_HPP
|
#ifndef BOOST_CONFIG_HPP
|
||||||
#include <boost/config.hpp>
|
#include <boost/config.hpp>
|
||||||
#endif
|
#endif
|
||||||
#include <cstddef>
|
|
||||||
|
|
||||||
#include <boost/type_traits/is_arithmetic.hpp>
|
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||||
#include <boost/type_traits/is_enum.hpp>
|
#include <boost/type_traits.hpp>
|
||||||
#include <boost/type_traits/is_pointer.hpp>
|
#endif
|
||||||
#include <boost/detail/workaround.hpp>
|
|
||||||
|
|
||||||
namespace boost{
|
namespace boost{
|
||||||
|
|
||||||
namespace detail{
|
namespace detail{
|
||||||
|
|
||||||
template <typename T, bool small_>
|
|
||||||
struct ct_imp2
|
|
||||||
{
|
|
||||||
typedef const T& param_type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct ct_imp2<T, true>
|
|
||||||
{
|
|
||||||
typedef const T param_type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename T, bool isp, bool b1, bool b2>
|
template <typename T, bool isp, bool b1, bool b2>
|
||||||
struct ct_imp
|
struct ct_imp
|
||||||
{
|
{
|
||||||
typedef const T& param_type;
|
typedef const T& param_type;
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T, bool isp, bool b2>
|
template <typename T, bool isp>
|
||||||
struct ct_imp<T, isp, true, b2>
|
struct ct_imp<T, isp, true, true>
|
||||||
{
|
{
|
||||||
typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
|
typedef T const param_type;
|
||||||
};
|
|
||||||
|
|
||||||
template <typename T, bool isp, bool b1>
|
|
||||||
struct ct_imp<T, isp, b1, true>
|
|
||||||
{
|
|
||||||
typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T, bool b1, bool b2>
|
template <typename T, bool b1, bool b2>
|
||||||
struct ct_imp<T, true, b1, b2>
|
struct ct_imp<T, true, b1, b2>
|
||||||
{
|
{
|
||||||
typedef const T param_type;
|
typedef T const param_type;
|
||||||
};
|
};
|
||||||
|
|
||||||
}
|
}
|
||||||
@@ -83,12 +64,7 @@ public:
|
|||||||
// however compiler bugs prevent this - instead pass three bool's to
|
// however compiler bugs prevent this - instead pass three bool's to
|
||||||
// ct_imp<T,bool,bool,bool> and add an extra partial specialisation
|
// ct_imp<T,bool,bool,bool> and add an extra partial specialisation
|
||||||
// of ct_imp to handle the logic. (JM)
|
// of ct_imp to handle the logic. (JM)
|
||||||
typedef typename boost::detail::ct_imp<
|
typedef typename detail::ct_imp<T, ::boost::is_pointer<typename remove_const<T>::type>::value, ::boost::is_arithmetic<typename remove_const<T>::type>::value, sizeof(T) <= sizeof(void*)>::param_type param_type;
|
||||||
T,
|
|
||||||
::boost::is_pointer<T>::value,
|
|
||||||
::boost::is_arithmetic<T>::value,
|
|
||||||
::boost::is_enum<T>::value
|
|
||||||
>::param_type param_type;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
@@ -100,7 +76,7 @@ struct call_traits<T&>
|
|||||||
typedef T& param_type; // hh removed const
|
typedef T& param_type; // hh removed const
|
||||||
};
|
};
|
||||||
|
|
||||||
#if BOOST_WORKAROUND( __BORLANDC__, < 0x5A0 )
|
#if defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
|
||||||
// these are illegal specialisations; cv-qualifies applied to
|
// these are illegal specialisations; cv-qualifies applied to
|
||||||
// references have no effect according to [8.3.2p1],
|
// references have no effect according to [8.3.2p1],
|
||||||
// C++ Builder requires them though as it treats cv-qualified
|
// C++ Builder requires them though as it treats cv-qualified
|
||||||
@@ -129,17 +105,8 @@ struct call_traits<T&const volatile>
|
|||||||
typedef const T& const_reference;
|
typedef const T& const_reference;
|
||||||
typedef T& param_type; // hh removed const
|
typedef T& param_type; // hh removed const
|
||||||
};
|
};
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct call_traits< T * >
|
|
||||||
{
|
|
||||||
typedef T * value_type;
|
|
||||||
typedef T * & reference;
|
|
||||||
typedef T * const & const_reference;
|
|
||||||
typedef T * const param_type; // hh removed const
|
|
||||||
};
|
|
||||||
#endif
|
#endif
|
||||||
#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
|
|
||||||
template <typename T, std::size_t N>
|
template <typename T, std::size_t N>
|
||||||
struct call_traits<T [N]>
|
struct call_traits<T [N]>
|
||||||
{
|
{
|
||||||
@@ -165,7 +132,6 @@ public:
|
|||||||
typedef const array_type& const_reference;
|
typedef const array_type& const_reference;
|
||||||
typedef const T* const param_type;
|
typedef const T* const param_type;
|
||||||
};
|
};
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -1,16 +1,14 @@
|
|||||||
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
||||||
// Use, modification and distribution are subject to the Boost Software License,
|
// Permission to copy, use, modify, sell and
|
||||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// distribute this software is granted provided this copyright notice appears
|
||||||
// http://www.boost.org/LICENSE_1_0.txt).
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
//
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
// See http://www.boost.org/libs/utility for most recent version including documentation.
|
|
||||||
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
|
||||||
// compressed_pair: pair that "compresses" empty members
|
// compressed_pair: pair that "compresses" empty members
|
||||||
// (see libs/utility/doc/html/compressed_pair.html)
|
// (see libs/utility/compressed_pair.htm)
|
||||||
//
|
//
|
||||||
// JM changes 25 Jan 2004:
|
|
||||||
// For the case where T1 == T2 and both are empty, then first() and second()
|
|
||||||
// should return different objects.
|
|
||||||
// JM changes 25 Jan 2000:
|
// JM changes 25 Jan 2000:
|
||||||
// Removed default arguments from compressed_pair_switch to get
|
// Removed default arguments from compressed_pair_switch to get
|
||||||
// C++ Builder 4 to accept them
|
// C++ Builder 4 to accept them
|
||||||
@@ -21,23 +19,16 @@
|
|||||||
#define BOOST_DETAIL_COMPRESSED_PAIR_HPP
|
#define BOOST_DETAIL_COMPRESSED_PAIR_HPP
|
||||||
|
|
||||||
#include <algorithm>
|
#include <algorithm>
|
||||||
|
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||||
#include <boost/type_traits/remove_cv.hpp>
|
#include <boost/type_traits.hpp>
|
||||||
#include <boost/type_traits/is_empty.hpp>
|
#endif
|
||||||
#include <boost/type_traits/is_same.hpp>
|
#ifndef BOOST_CALL_TRAITS_HPP
|
||||||
#include <boost/call_traits.hpp>
|
#include <boost/call_traits.hpp>
|
||||||
|
#endif
|
||||||
|
|
||||||
#ifdef BOOST_MSVC
|
|
||||||
# pragma warning(push)
|
|
||||||
# pragma warning(disable:4512)
|
|
||||||
#endif
|
|
||||||
namespace boost
|
namespace boost
|
||||||
{
|
{
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair;
|
|
||||||
|
|
||||||
|
|
||||||
// compressed_pair
|
// compressed_pair
|
||||||
|
|
||||||
namespace details
|
namespace details
|
||||||
@@ -84,9 +75,7 @@ namespace details
|
|||||||
template <typename T>
|
template <typename T>
|
||||||
inline void cp_swap(T& t1, T& t2)
|
inline void cp_swap(T& t1, T& t2)
|
||||||
{
|
{
|
||||||
#ifndef __GNUC__
|
|
||||||
using std::swap;
|
using std::swap;
|
||||||
#endif
|
|
||||||
swap(t1, t2);
|
swap(t1, t2);
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -110,10 +99,10 @@ namespace details
|
|||||||
compressed_pair_imp(first_param_type x, second_param_type y)
|
compressed_pair_imp(first_param_type x, second_param_type y)
|
||||||
: first_(x), second_(y) {}
|
: first_(x), second_(y) {}
|
||||||
|
|
||||||
compressed_pair_imp(first_param_type x)
|
explicit compressed_pair_imp(first_param_type x)
|
||||||
: first_(x) {}
|
: first_(x) {}
|
||||||
|
|
||||||
compressed_pair_imp(second_param_type y)
|
explicit compressed_pair_imp(second_param_type y)
|
||||||
: second_(y) {}
|
: second_(y) {}
|
||||||
|
|
||||||
first_reference first() {return first_;}
|
first_reference first() {return first_;}
|
||||||
@@ -122,10 +111,10 @@ namespace details
|
|||||||
second_reference second() {return second_;}
|
second_reference second() {return second_;}
|
||||||
second_const_reference second() const {return second_;}
|
second_const_reference second() const {return second_;}
|
||||||
|
|
||||||
void swap(::boost::compressed_pair<T1, T2>& y)
|
void swap(compressed_pair_imp& y)
|
||||||
{
|
{
|
||||||
cp_swap(first_, y.first());
|
cp_swap(first_, y.first_);
|
||||||
cp_swap(second_, y.second());
|
cp_swap(second_, y.second_);
|
||||||
}
|
}
|
||||||
private:
|
private:
|
||||||
first_type first_;
|
first_type first_;
|
||||||
@@ -136,7 +125,7 @@ namespace details
|
|||||||
|
|
||||||
template <class T1, class T2>
|
template <class T1, class T2>
|
||||||
class compressed_pair_imp<T1, T2, 1>
|
class compressed_pair_imp<T1, T2, 1>
|
||||||
: protected ::boost::remove_cv<T1>::type
|
: private T1
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
typedef T1 first_type;
|
typedef T1 first_type;
|
||||||
@@ -153,10 +142,10 @@ namespace details
|
|||||||
compressed_pair_imp(first_param_type x, second_param_type y)
|
compressed_pair_imp(first_param_type x, second_param_type y)
|
||||||
: first_type(x), second_(y) {}
|
: first_type(x), second_(y) {}
|
||||||
|
|
||||||
compressed_pair_imp(first_param_type x)
|
explicit compressed_pair_imp(first_param_type x)
|
||||||
: first_type(x) {}
|
: first_type(x) {}
|
||||||
|
|
||||||
compressed_pair_imp(second_param_type y)
|
explicit compressed_pair_imp(second_param_type y)
|
||||||
: second_(y) {}
|
: second_(y) {}
|
||||||
|
|
||||||
first_reference first() {return *this;}
|
first_reference first() {return *this;}
|
||||||
@@ -165,10 +154,10 @@ namespace details
|
|||||||
second_reference second() {return second_;}
|
second_reference second() {return second_;}
|
||||||
second_const_reference second() const {return second_;}
|
second_const_reference second() const {return second_;}
|
||||||
|
|
||||||
void swap(::boost::compressed_pair<T1,T2>& y)
|
void swap(compressed_pair_imp& y)
|
||||||
{
|
{
|
||||||
// no need to swap empty base class:
|
// no need to swap empty base class:
|
||||||
cp_swap(second_, y.second());
|
cp_swap(second_, y.second_);
|
||||||
}
|
}
|
||||||
private:
|
private:
|
||||||
second_type second_;
|
second_type second_;
|
||||||
@@ -178,7 +167,7 @@ namespace details
|
|||||||
|
|
||||||
template <class T1, class T2>
|
template <class T1, class T2>
|
||||||
class compressed_pair_imp<T1, T2, 2>
|
class compressed_pair_imp<T1, T2, 2>
|
||||||
: protected ::boost::remove_cv<T2>::type
|
: private T2
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
typedef T1 first_type;
|
typedef T1 first_type;
|
||||||
@@ -195,10 +184,10 @@ namespace details
|
|||||||
compressed_pair_imp(first_param_type x, second_param_type y)
|
compressed_pair_imp(first_param_type x, second_param_type y)
|
||||||
: second_type(y), first_(x) {}
|
: second_type(y), first_(x) {}
|
||||||
|
|
||||||
compressed_pair_imp(first_param_type x)
|
explicit compressed_pair_imp(first_param_type x)
|
||||||
: first_(x) {}
|
: first_(x) {}
|
||||||
|
|
||||||
compressed_pair_imp(second_param_type y)
|
explicit compressed_pair_imp(second_param_type y)
|
||||||
: second_type(y) {}
|
: second_type(y) {}
|
||||||
|
|
||||||
first_reference first() {return first_;}
|
first_reference first() {return first_;}
|
||||||
@@ -207,10 +196,10 @@ namespace details
|
|||||||
second_reference second() {return *this;}
|
second_reference second() {return *this;}
|
||||||
second_const_reference second() const {return *this;}
|
second_const_reference second() const {return *this;}
|
||||||
|
|
||||||
void swap(::boost::compressed_pair<T1,T2>& y)
|
void swap(compressed_pair_imp& y)
|
||||||
{
|
{
|
||||||
// no need to swap empty base class:
|
// no need to swap empty base class:
|
||||||
cp_swap(first_, y.first());
|
cp_swap(first_, y.first_);
|
||||||
}
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
@@ -221,8 +210,8 @@ namespace details
|
|||||||
|
|
||||||
template <class T1, class T2>
|
template <class T1, class T2>
|
||||||
class compressed_pair_imp<T1, T2, 3>
|
class compressed_pair_imp<T1, T2, 3>
|
||||||
: protected ::boost::remove_cv<T1>::type,
|
: private T1,
|
||||||
protected ::boost::remove_cv<T2>::type
|
private T2
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
typedef T1 first_type;
|
typedef T1 first_type;
|
||||||
@@ -239,10 +228,10 @@ namespace details
|
|||||||
compressed_pair_imp(first_param_type x, second_param_type y)
|
compressed_pair_imp(first_param_type x, second_param_type y)
|
||||||
: first_type(x), second_type(y) {}
|
: first_type(x), second_type(y) {}
|
||||||
|
|
||||||
compressed_pair_imp(first_param_type x)
|
explicit compressed_pair_imp(first_param_type x)
|
||||||
: first_type(x) {}
|
: first_type(x) {}
|
||||||
|
|
||||||
compressed_pair_imp(second_param_type y)
|
explicit compressed_pair_imp(second_param_type y)
|
||||||
: second_type(y) {}
|
: second_type(y) {}
|
||||||
|
|
||||||
first_reference first() {return *this;}
|
first_reference first() {return *this;}
|
||||||
@@ -252,19 +241,16 @@ namespace details
|
|||||||
second_const_reference second() const {return *this;}
|
second_const_reference second() const {return *this;}
|
||||||
//
|
//
|
||||||
// no need to swap empty bases:
|
// no need to swap empty bases:
|
||||||
void swap(::boost::compressed_pair<T1,T2>&) {}
|
void swap(compressed_pair_imp&) {}
|
||||||
};
|
};
|
||||||
|
|
||||||
// JM
|
// JM
|
||||||
// 4 T1 == T2, T1 and T2 both empty
|
// 4 T1 == T2, T1 and T2 both empty
|
||||||
// Originally this did not store an instance of T2 at all
|
// Note does not actually store an instance of T2 at all -
|
||||||
// but that led to problems beause it meant &x.first() == &x.second()
|
// but reuses T1 base class for both first() and second().
|
||||||
// which is not true for any other kind of pair, so now we store an instance
|
|
||||||
// of T2 just in case the user is relying on first() and second() returning
|
|
||||||
// different objects (albeit both empty).
|
|
||||||
template <class T1, class T2>
|
template <class T1, class T2>
|
||||||
class compressed_pair_imp<T1, T2, 4>
|
class compressed_pair_imp<T1, T2, 4>
|
||||||
: protected ::boost::remove_cv<T1>::type
|
: private T1
|
||||||
{
|
{
|
||||||
public:
|
public:
|
||||||
typedef T1 first_type;
|
typedef T1 first_type;
|
||||||
@@ -278,21 +264,20 @@ namespace details
|
|||||||
|
|
||||||
compressed_pair_imp() {}
|
compressed_pair_imp() {}
|
||||||
|
|
||||||
compressed_pair_imp(first_param_type x, second_param_type y)
|
compressed_pair_imp(first_param_type x, second_param_type)
|
||||||
: first_type(x), m_second(y) {}
|
: first_type(x) {}
|
||||||
|
|
||||||
compressed_pair_imp(first_param_type x)
|
explicit compressed_pair_imp(first_param_type x)
|
||||||
: first_type(x), m_second(x) {}
|
: first_type(x) {}
|
||||||
|
|
||||||
first_reference first() {return *this;}
|
first_reference first() {return *this;}
|
||||||
first_const_reference first() const {return *this;}
|
first_const_reference first() const {return *this;}
|
||||||
|
|
||||||
second_reference second() {return m_second;}
|
second_reference second() {return *this;}
|
||||||
second_const_reference second() const {return m_second;}
|
second_const_reference second() const {return *this;}
|
||||||
|
|
||||||
void swap(::boost::compressed_pair<T1,T2>&) {}
|
void swap(compressed_pair_imp&) {}
|
||||||
private:
|
private:
|
||||||
T2 m_second;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
// 5 T1 == T2 and are not empty: //JM
|
// 5 T1 == T2 and are not empty: //JM
|
||||||
@@ -315,7 +300,7 @@ namespace details
|
|||||||
compressed_pair_imp(first_param_type x, second_param_type y)
|
compressed_pair_imp(first_param_type x, second_param_type y)
|
||||||
: first_(x), second_(y) {}
|
: first_(x), second_(y) {}
|
||||||
|
|
||||||
compressed_pair_imp(first_param_type x)
|
explicit compressed_pair_imp(first_param_type x)
|
||||||
: first_(x), second_(x) {}
|
: first_(x), second_(x) {}
|
||||||
|
|
||||||
first_reference first() {return first_;}
|
first_reference first() {return first_;}
|
||||||
@@ -324,10 +309,10 @@ namespace details
|
|||||||
second_reference second() {return second_;}
|
second_reference second() {return second_;}
|
||||||
second_const_reference second() const {return second_;}
|
second_const_reference second() const {return second_;}
|
||||||
|
|
||||||
void swap(::boost::compressed_pair<T1, T2>& y)
|
void swap(compressed_pair_imp<T1, T2, 5>& y)
|
||||||
{
|
{
|
||||||
cp_swap(first_, y.first());
|
cp_swap(first_, y.first_);
|
||||||
cp_swap(second_, y.second());
|
cp_swap(second_, y.second_);
|
||||||
}
|
}
|
||||||
private:
|
private:
|
||||||
first_type first_;
|
first_type first_;
|
||||||
@@ -411,10 +396,7 @@ public:
|
|||||||
|
|
||||||
compressed_pair() : base() {}
|
compressed_pair() : base() {}
|
||||||
compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
|
compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
|
||||||
#if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530))
|
explicit compressed_pair(first_param_type x) : base(x) {}
|
||||||
explicit
|
|
||||||
#endif
|
|
||||||
compressed_pair(first_param_type x) : base(x) {}
|
|
||||||
|
|
||||||
first_reference first() {return base::first();}
|
first_reference first() {return base::first();}
|
||||||
first_const_reference first() const {return base::first();}
|
first_const_reference first() const {return base::first();}
|
||||||
@@ -422,7 +404,7 @@ public:
|
|||||||
second_reference second() {return base::second();}
|
second_reference second() {return base::second();}
|
||||||
second_const_reference second() const {return base::second();}
|
second_const_reference second() const {return base::second();}
|
||||||
|
|
||||||
void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
|
void swap(compressed_pair& y) { base::swap(y); }
|
||||||
};
|
};
|
||||||
|
|
||||||
template <class T1, class T2>
|
template <class T1, class T2>
|
||||||
@@ -435,9 +417,6 @@ swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
|
|||||||
|
|
||||||
} // boost
|
} // boost
|
||||||
|
|
||||||
#ifdef BOOST_MSVC
|
|
||||||
# pragma warning(pop)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
|
#endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
36
include/boost/detail/ob_call_traits.hpp
Normal file
36
include/boost/detail/ob_call_traits.hpp
Normal file
@@ -0,0 +1,36 @@
|
|||||||
|
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
||||||
|
// Permission to copy, use, modify, sell and
|
||||||
|
// distribute this software is granted provided this copyright notice appears
|
||||||
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
|
|
||||||
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
//
|
||||||
|
// Crippled version for crippled compilers:
|
||||||
|
// see libs/utility/call_traits.htm
|
||||||
|
//
|
||||||
|
#ifndef BOOST_OB_CALL_TRAITS_HPP
|
||||||
|
#define BOOST_OB_CALL_TRAITS_HPP
|
||||||
|
|
||||||
|
#ifndef BOOST_CONFIG_HPP
|
||||||
|
#include <boost/config.hpp>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||||
|
#include <boost/type_traits.hpp>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace boost{
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct call_traits
|
||||||
|
{
|
||||||
|
typedef T value_type;
|
||||||
|
typedef T& reference;
|
||||||
|
typedef const T& const_reference;
|
||||||
|
typedef const T& param_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // BOOST_OB_CALL_TRAITS_HPP
|
||||||
@@ -1,18 +1,13 @@
|
|||||||
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
||||||
// Use, modification and distribution are subject to the Boost Software License,
|
// Permission to copy, use, modify, sell and
|
||||||
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
// distribute this software is granted provided this copyright notice appears
|
||||||
// http://www.boost.org/LICENSE_1_0.txt).
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
//
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
// See http://www.boost.org/libs/utility for most recent version including documentation.
|
|
||||||
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
// see libs/utility/compressed_pair.hpp
|
// see libs/utility/compressed_pair.hpp
|
||||||
//
|
//
|
||||||
/* Release notes:
|
/* Release notes:
|
||||||
20 Jan 2001:
|
|
||||||
Fixed obvious bugs (David Abrahams)
|
|
||||||
07 Oct 2000:
|
|
||||||
Added better single argument constructor support.
|
|
||||||
03 Oct 2000:
|
|
||||||
Added VC6 support (JM).
|
|
||||||
23rd July 2000:
|
23rd July 2000:
|
||||||
Additional comments added. (JM)
|
Additional comments added. (JM)
|
||||||
Jan 2000:
|
Jan 2000:
|
||||||
@@ -25,11 +20,8 @@
|
|||||||
#define BOOST_OB_COMPRESSED_PAIR_HPP
|
#define BOOST_OB_COMPRESSED_PAIR_HPP
|
||||||
|
|
||||||
#include <algorithm>
|
#include <algorithm>
|
||||||
#ifndef BOOST_OBJECT_TYPE_TRAITS_HPP
|
#ifndef BOOST_TYPE_TRAITS_HPP
|
||||||
#include <boost/type_traits/object_traits.hpp>
|
#include <boost/type_traits.hpp>
|
||||||
#endif
|
|
||||||
#ifndef BOOST_SAME_TRAITS_HPP
|
|
||||||
#include <boost/type_traits/same_traits.hpp>
|
|
||||||
#endif
|
#endif
|
||||||
#ifndef BOOST_CALL_TRAITS_HPP
|
#ifndef BOOST_CALL_TRAITS_HPP
|
||||||
#include <boost/call_traits.hpp>
|
#include <boost/call_traits.hpp>
|
||||||
@@ -37,415 +29,6 @@
|
|||||||
|
|
||||||
namespace boost
|
namespace boost
|
||||||
{
|
{
|
||||||
#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
|
|
||||||
//
|
|
||||||
// use member templates to emulate
|
|
||||||
// partial specialisation. Note that due to
|
|
||||||
// problems with overload resolution with VC6
|
|
||||||
// each of the compressed_pair versions that follow
|
|
||||||
// have one template single-argument constructor
|
|
||||||
// in place of two specific constructors:
|
|
||||||
//
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair;
|
|
||||||
|
|
||||||
namespace detail{
|
|
||||||
|
|
||||||
template <class A, class T1, class T2>
|
|
||||||
struct best_conversion_traits
|
|
||||||
{
|
|
||||||
typedef char one;
|
|
||||||
typedef char (&two)[2];
|
|
||||||
static A a;
|
|
||||||
static one test(T1);
|
|
||||||
static two test(T2);
|
|
||||||
|
|
||||||
enum { value = sizeof(test(a)) };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <int>
|
|
||||||
struct init_one;
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct init_one<1>
|
|
||||||
{
|
|
||||||
template <class A, class T1, class T2>
|
|
||||||
static void init(const A& a, T1* p1, T2*)
|
|
||||||
{
|
|
||||||
*p1 = a;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct init_one<2>
|
|
||||||
{
|
|
||||||
template <class A, class T1, class T2>
|
|
||||||
static void init(const A& a, T1*, T2* p2)
|
|
||||||
{
|
|
||||||
*p2 = a;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
// T1 != T2, both non-empty
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair_0
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
T1 _first;
|
|
||||||
T2 _second;
|
|
||||||
public:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
typedef typename call_traits<first_type>::reference first_reference;
|
|
||||||
typedef typename call_traits<second_type>::reference second_reference;
|
|
||||||
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
|
||||||
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
|
||||||
|
|
||||||
compressed_pair_0() : _first(), _second() {}
|
|
||||||
compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {}
|
|
||||||
template <class A>
|
|
||||||
explicit compressed_pair_0(const A& val)
|
|
||||||
{
|
|
||||||
init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second);
|
|
||||||
}
|
|
||||||
compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x)
|
|
||||||
: _first(x.first()), _second(x.second()) {}
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
compressed_pair_0& operator=(const compressed_pair_0& x) {
|
|
||||||
cout << "assigning compressed pair 0" << endl;
|
|
||||||
_first = x._first;
|
|
||||||
_second = x._second;
|
|
||||||
cout << "finished assigning compressed pair 0" << endl;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
first_reference first() { return _first; }
|
|
||||||
first_const_reference first() const { return _first; }
|
|
||||||
|
|
||||||
second_reference second() { return _second; }
|
|
||||||
second_const_reference second() const { return _second; }
|
|
||||||
|
|
||||||
void swap(compressed_pair_0& y)
|
|
||||||
{
|
|
||||||
using std::swap;
|
|
||||||
swap(_first, y._first);
|
|
||||||
swap(_second, y._second);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// T1 != T2, T2 empty
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair_1 : T2
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
T1 _first;
|
|
||||||
public:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
typedef typename call_traits<first_type>::reference first_reference;
|
|
||||||
typedef typename call_traits<second_type>::reference second_reference;
|
|
||||||
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
|
||||||
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
|
||||||
|
|
||||||
compressed_pair_1() : T2(), _first() {}
|
|
||||||
compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {}
|
|
||||||
|
|
||||||
template <class A>
|
|
||||||
explicit compressed_pair_1(const A& val)
|
|
||||||
{
|
|
||||||
init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2*>(this));
|
|
||||||
}
|
|
||||||
|
|
||||||
compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x)
|
|
||||||
: T2(x.second()), _first(x.first()) {}
|
|
||||||
|
|
||||||
first_reference first() { return _first; }
|
|
||||||
first_const_reference first() const { return _first; }
|
|
||||||
|
|
||||||
second_reference second() { return *this; }
|
|
||||||
second_const_reference second() const { return *this; }
|
|
||||||
|
|
||||||
void swap(compressed_pair_1& y)
|
|
||||||
{
|
|
||||||
// no need to swap empty base class:
|
|
||||||
using std::swap;
|
|
||||||
swap(_first, y._first);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// T1 != T2, T1 empty
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair_2 : T1
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
T2 _second;
|
|
||||||
public:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
typedef typename call_traits<first_type>::reference first_reference;
|
|
||||||
typedef typename call_traits<second_type>::reference second_reference;
|
|
||||||
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
|
||||||
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
|
||||||
|
|
||||||
compressed_pair_2() : T1(), _second() {}
|
|
||||||
compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {}
|
|
||||||
template <class A>
|
|
||||||
explicit compressed_pair_2(const A& val)
|
|
||||||
{
|
|
||||||
init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), &_second);
|
|
||||||
}
|
|
||||||
compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x)
|
|
||||||
: T1(x.first()), _second(x.second()) {}
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
compressed_pair_2& operator=(const compressed_pair_2& x) {
|
|
||||||
cout << "assigning compressed pair 2" << endl;
|
|
||||||
T1::operator=(x);
|
|
||||||
_second = x._second;
|
|
||||||
cout << "finished assigning compressed pair 2" << endl;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
first_reference first() { return *this; }
|
|
||||||
first_const_reference first() const { return *this; }
|
|
||||||
|
|
||||||
second_reference second() { return _second; }
|
|
||||||
second_const_reference second() const { return _second; }
|
|
||||||
|
|
||||||
void swap(compressed_pair_2& y)
|
|
||||||
{
|
|
||||||
// no need to swap empty base class:
|
|
||||||
using std::swap;
|
|
||||||
swap(_second, y._second);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// T1 != T2, both empty
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair_3 : T1, T2
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
typedef typename call_traits<first_type>::reference first_reference;
|
|
||||||
typedef typename call_traits<second_type>::reference second_reference;
|
|
||||||
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
|
||||||
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
|
||||||
|
|
||||||
compressed_pair_3() : T1(), T2() {}
|
|
||||||
compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {}
|
|
||||||
template <class A>
|
|
||||||
explicit compressed_pair_3(const A& val)
|
|
||||||
{
|
|
||||||
init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1*>(this), static_cast<T2*>(this));
|
|
||||||
}
|
|
||||||
compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x)
|
|
||||||
: T1(x.first()), T2(x.second()) {}
|
|
||||||
|
|
||||||
first_reference first() { return *this; }
|
|
||||||
first_const_reference first() const { return *this; }
|
|
||||||
|
|
||||||
second_reference second() { return *this; }
|
|
||||||
second_const_reference second() const { return *this; }
|
|
||||||
|
|
||||||
void swap(compressed_pair_3& y)
|
|
||||||
{
|
|
||||||
// no need to swap empty base classes:
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// T1 == T2, and empty
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair_4 : T1
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
typedef typename call_traits<first_type>::reference first_reference;
|
|
||||||
typedef typename call_traits<second_type>::reference second_reference;
|
|
||||||
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
|
||||||
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
|
||||||
|
|
||||||
compressed_pair_4() : T1() {}
|
|
||||||
compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {}
|
|
||||||
// only one single argument constructor since T1 == T2
|
|
||||||
explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {}
|
|
||||||
compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x)
|
|
||||||
: T1(x.first()), m_second(x.second()) {}
|
|
||||||
|
|
||||||
first_reference first() { return *this; }
|
|
||||||
first_const_reference first() const { return *this; }
|
|
||||||
|
|
||||||
second_reference second() { return m_second; }
|
|
||||||
second_const_reference second() const { return m_second; }
|
|
||||||
|
|
||||||
void swap(compressed_pair_4& y)
|
|
||||||
{
|
|
||||||
// no need to swap empty base classes:
|
|
||||||
}
|
|
||||||
private:
|
|
||||||
T2 m_second;
|
|
||||||
};
|
|
||||||
|
|
||||||
// T1 == T2, not empty
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair_5
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
T1 _first;
|
|
||||||
T2 _second;
|
|
||||||
public:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
typedef typename call_traits<first_type>::reference first_reference;
|
|
||||||
typedef typename call_traits<second_type>::reference second_reference;
|
|
||||||
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
|
||||||
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
|
||||||
|
|
||||||
compressed_pair_5() : _first(), _second() {}
|
|
||||||
compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {}
|
|
||||||
// only one single argument constructor since T1 == T2
|
|
||||||
explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {}
|
|
||||||
compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c)
|
|
||||||
: _first(c.first()), _second(c.second()) {}
|
|
||||||
|
|
||||||
first_reference first() { return _first; }
|
|
||||||
first_const_reference first() const { return _first; }
|
|
||||||
|
|
||||||
second_reference second() { return _second; }
|
|
||||||
second_const_reference second() const { return _second; }
|
|
||||||
|
|
||||||
void swap(compressed_pair_5& y)
|
|
||||||
{
|
|
||||||
using std::swap;
|
|
||||||
swap(_first, y._first);
|
|
||||||
swap(_second, y._second);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <bool e1, bool e2, bool same>
|
|
||||||
struct compressed_pair_chooser
|
|
||||||
{
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct rebind
|
|
||||||
{
|
|
||||||
typedef compressed_pair_0<T1, T2> type;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct compressed_pair_chooser<false, true, false>
|
|
||||||
{
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct rebind
|
|
||||||
{
|
|
||||||
typedef compressed_pair_1<T1, T2> type;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct compressed_pair_chooser<true, false, false>
|
|
||||||
{
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct rebind
|
|
||||||
{
|
|
||||||
typedef compressed_pair_2<T1, T2> type;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct compressed_pair_chooser<true, true, false>
|
|
||||||
{
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct rebind
|
|
||||||
{
|
|
||||||
typedef compressed_pair_3<T1, T2> type;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct compressed_pair_chooser<true, true, true>
|
|
||||||
{
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct rebind
|
|
||||||
{
|
|
||||||
typedef compressed_pair_4<T1, T2> type;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct compressed_pair_chooser<false, false, true>
|
|
||||||
{
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct rebind
|
|
||||||
{
|
|
||||||
typedef compressed_pair_5<T1, T2> type;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
struct compressed_pair_traits
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser;
|
|
||||||
typedef typename chooser::template rebind<T1, T2> bound_type;
|
|
||||||
public:
|
|
||||||
typedef typename bound_type::type type;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace detail
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
typedef typename detail::compressed_pair_traits<T1, T2>::type base_type;
|
|
||||||
public:
|
|
||||||
typedef T1 first_type;
|
|
||||||
typedef T2 second_type;
|
|
||||||
typedef typename call_traits<first_type>::param_type first_param_type;
|
|
||||||
typedef typename call_traits<second_type>::param_type second_param_type;
|
|
||||||
typedef typename call_traits<first_type>::reference first_reference;
|
|
||||||
typedef typename call_traits<second_type>::reference second_reference;
|
|
||||||
typedef typename call_traits<first_type>::const_reference first_const_reference;
|
|
||||||
typedef typename call_traits<second_type>::const_reference second_const_reference;
|
|
||||||
|
|
||||||
compressed_pair() : base_type() {}
|
|
||||||
compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {}
|
|
||||||
template <class A>
|
|
||||||
explicit compressed_pair(const A& x) : base_type(x){}
|
|
||||||
|
|
||||||
first_reference first() { return base_type::first(); }
|
|
||||||
first_const_reference first() const { return base_type::first(); }
|
|
||||||
|
|
||||||
second_reference second() { return base_type::second(); }
|
|
||||||
second_const_reference second() const { return base_type::second(); }
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
|
||||||
inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
|
|
||||||
{
|
|
||||||
x.swap(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
#else
|
|
||||||
// no partial specialisation, no member templates:
|
|
||||||
|
|
||||||
template <class T1, class T2>
|
template <class T1, class T2>
|
||||||
class compressed_pair
|
class compressed_pair
|
||||||
@@ -489,11 +72,7 @@ inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
|
|||||||
x.swap(y);
|
x.swap(y);
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
} // boost
|
} // boost
|
||||||
|
|
||||||
#endif // BOOST_OB_COMPRESSED_PAIR_HPP
|
#endif // BOOST_OB_COMPRESSED_PAIR_HPP
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -1,165 +0,0 @@
|
|||||||
// Boost next_prior.hpp header file ---------------------------------------//
|
|
||||||
|
|
||||||
// (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. 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)
|
|
||||||
|
|
||||||
// See http://www.boost.org/libs/utility for documentation.
|
|
||||||
|
|
||||||
// Revision History
|
|
||||||
// 13 Dec 2003 Added next(x, n) and prior(x, n) (Daniel Walker)
|
|
||||||
|
|
||||||
#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
|
|
||||||
#define BOOST_NEXT_PRIOR_HPP_INCLUDED
|
|
||||||
|
|
||||||
#include <iterator>
|
|
||||||
#if defined(_MSC_VER) && _MSC_VER <= 1310
|
|
||||||
#include <boost/mpl/and.hpp>
|
|
||||||
#include <boost/type_traits/is_integral.hpp>
|
|
||||||
#endif
|
|
||||||
#include <boost/type_traits/is_unsigned.hpp>
|
|
||||||
#include <boost/type_traits/integral_promotion.hpp>
|
|
||||||
#include <boost/type_traits/make_signed.hpp>
|
|
||||||
#include <boost/type_traits/has_plus.hpp>
|
|
||||||
#include <boost/type_traits/has_plus_assign.hpp>
|
|
||||||
#include <boost/type_traits/has_minus.hpp>
|
|
||||||
#include <boost/type_traits/has_minus_assign.hpp>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
// Helper functions for classes like bidirectional iterators not supporting
|
|
||||||
// operator+ and operator-
|
|
||||||
//
|
|
||||||
// Usage:
|
|
||||||
// const std::list<T>::iterator p = get_some_iterator();
|
|
||||||
// const std::list<T>::iterator prev = boost::prior(p);
|
|
||||||
// const std::list<T>::iterator next = boost::next(prev, 2);
|
|
||||||
|
|
||||||
// Contributed by Dave Abrahams
|
|
||||||
|
|
||||||
namespace next_prior_detail {
|
|
||||||
|
|
||||||
template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
|
|
||||||
struct next_impl2
|
|
||||||
{
|
|
||||||
static T call(T x, Distance n)
|
|
||||||
{
|
|
||||||
std::advance(x, n);
|
|
||||||
return x;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template< typename T, typename Distance >
|
|
||||||
struct next_impl2< T, Distance, true >
|
|
||||||
{
|
|
||||||
static T call(T x, Distance n)
|
|
||||||
{
|
|
||||||
return x + n;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
|
|
||||||
struct next_impl1 :
|
|
||||||
public next_impl2< T, Distance >
|
|
||||||
{
|
|
||||||
};
|
|
||||||
|
|
||||||
template< typename T, typename Distance >
|
|
||||||
struct next_impl1< T, Distance, true >
|
|
||||||
{
|
|
||||||
static T call(T x, Distance n)
|
|
||||||
{
|
|
||||||
x += n;
|
|
||||||
return x;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
template<
|
|
||||||
typename T,
|
|
||||||
typename Distance,
|
|
||||||
typename PromotedDistance = typename integral_promotion< Distance >::type,
|
|
||||||
#if !defined(_MSC_VER) || _MSC_VER > 1310
|
|
||||||
bool IsUInt = is_unsigned< PromotedDistance >::value
|
|
||||||
#else
|
|
||||||
// MSVC 7.1 has problems with applying is_unsigned to non-integral types
|
|
||||||
bool IsUInt = mpl::and_< is_integral< PromotedDistance >, is_unsigned< PromotedDistance > >::value
|
|
||||||
#endif
|
|
||||||
>
|
|
||||||
struct prior_impl3
|
|
||||||
{
|
|
||||||
static T call(T x, Distance n)
|
|
||||||
{
|
|
||||||
std::advance(x, -n);
|
|
||||||
return x;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template< typename T, typename Distance, typename PromotedDistance >
|
|
||||||
struct prior_impl3< T, Distance, PromotedDistance, true >
|
|
||||||
{
|
|
||||||
static T call(T x, Distance n)
|
|
||||||
{
|
|
||||||
typedef typename make_signed< PromotedDistance >::type signed_distance;
|
|
||||||
std::advance(x, -static_cast< signed_distance >(static_cast< PromotedDistance >(n)));
|
|
||||||
return x;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
|
|
||||||
struct prior_impl2 :
|
|
||||||
public prior_impl3< T, Distance >
|
|
||||||
{
|
|
||||||
};
|
|
||||||
|
|
||||||
template< typename T, typename Distance >
|
|
||||||
struct prior_impl2< T, Distance, true >
|
|
||||||
{
|
|
||||||
static T call(T x, Distance n)
|
|
||||||
{
|
|
||||||
return x - n;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
|
|
||||||
struct prior_impl1 :
|
|
||||||
public prior_impl2< T, Distance >
|
|
||||||
{
|
|
||||||
};
|
|
||||||
|
|
||||||
template< typename T, typename Distance >
|
|
||||||
struct prior_impl1< T, Distance, true >
|
|
||||||
{
|
|
||||||
static T call(T x, Distance n)
|
|
||||||
{
|
|
||||||
x -= n;
|
|
||||||
return x;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace next_prior_detail
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
inline T next(T x) { return ++x; }
|
|
||||||
|
|
||||||
template <class T, class Distance>
|
|
||||||
inline T next(T x, Distance n)
|
|
||||||
{
|
|
||||||
return next_prior_detail::next_impl1< T, Distance >::call(x, n);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
inline T prior(T x) { return --x; }
|
|
||||||
|
|
||||||
template <class T, class Distance>
|
|
||||||
inline T prior(T x, Distance n)
|
|
||||||
{
|
|
||||||
return next_prior_detail::prior_impl1< T, Distance >::call(x, n);
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#endif // BOOST_NEXT_PRIOR_HPP_INCLUDED
|
|
||||||
File diff suppressed because it is too large
Load Diff
@@ -1,21 +1,69 @@
|
|||||||
// Boost utility.hpp header file -------------------------------------------//
|
// boost utility.hpp header file -------------------------------------------//
|
||||||
|
|
||||||
// Copyright 1999-2003 Aleksey Gurtovoy. Use, modification, and distribution are
|
// (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
|
||||||
// subject to the Boost Software License, Version 1.0. (See accompanying file
|
// and distribute this software is granted provided this copyright
|
||||||
// LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
|
// notice appears in all copies. This software is provided "as is" without
|
||||||
|
// express or implied warranty, and with no claim as to its suitability for
|
||||||
|
// any purpose.
|
||||||
|
|
||||||
// See <http://www.boost.org/libs/utility/> for the library's home page.
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
|
||||||
|
// Classes appear in alphabetical order
|
||||||
|
|
||||||
|
// Revision History
|
||||||
|
// 26 Jan 00 protected noncopyable destructor added (Miki Jovanovic)
|
||||||
|
// 10 Dec 99 next() and prior() templates added (Dave Abrahams)
|
||||||
|
// 30 Aug 99 moved cast templates to cast.hpp (Beman Dawes)
|
||||||
|
// 3 Aug 99 cast templates added
|
||||||
|
// 20 Jul 99 name changed to utility.hpp
|
||||||
|
// 9 Jun 99 protected noncopyable default ctor
|
||||||
|
// 2 Jun 99 Initial Version. Class noncopyable only contents (Dave Abrahams)
|
||||||
|
|
||||||
#ifndef BOOST_UTILITY_HPP
|
#ifndef BOOST_UTILITY_HPP
|
||||||
#define BOOST_UTILITY_HPP
|
#define BOOST_UTILITY_HPP
|
||||||
|
|
||||||
#include <boost/utility/addressof.hpp>
|
#include <boost/config.hpp>
|
||||||
#include <boost/utility/base_from_member.hpp>
|
#include <cstddef> // for size_t
|
||||||
#include <boost/utility/binary.hpp>
|
|
||||||
#include <boost/utility/enable_if.hpp>
|
namespace boost
|
||||||
#include <boost/utility/identity_type.hpp>
|
{
|
||||||
#include <boost/checked_delete.hpp>
|
|
||||||
#include <boost/next_prior.hpp>
|
// next() and prior() template functions -----------------------------------//
|
||||||
#include <boost/noncopyable.hpp>
|
|
||||||
|
// Helper functions for classes like bidirectional iterators not supporting
|
||||||
|
// operator+ and operator-.
|
||||||
|
//
|
||||||
|
// Usage:
|
||||||
|
// const std::list<T>::iterator p = get_some_iterator();
|
||||||
|
// const std::list<T>::iterator prev = boost::prior(p);
|
||||||
|
|
||||||
|
// Contributed by Dave Abrahams
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
T next(T x) { return ++x; }
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
T prior(T x) { return --x; }
|
||||||
|
|
||||||
|
|
||||||
|
// class noncopyable -------------------------------------------------------//
|
||||||
|
|
||||||
|
// Private copy constructor and copy assignment ensure classes derived from
|
||||||
|
// class noncopyable cannot be copied.
|
||||||
|
|
||||||
|
// Contributed by Dave Abrahams
|
||||||
|
|
||||||
|
class noncopyable
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
noncopyable(){}
|
||||||
|
~noncopyable(){}
|
||||||
|
private: // emphasize the following members are private
|
||||||
|
noncopyable( const noncopyable& );
|
||||||
|
const noncopyable& operator=( const noncopyable& );
|
||||||
|
}; // noncopyable
|
||||||
|
|
||||||
|
} // namespace boost
|
||||||
|
|
||||||
#endif // BOOST_UTILITY_HPP
|
#endif // BOOST_UTILITY_HPP
|
||||||
|
|
||||||
|
|||||||
@@ -1,171 +0,0 @@
|
|||||||
// boost utility/base_from_member.hpp header file --------------------------//
|
|
||||||
|
|
||||||
// Copyright 2001, 2003, 2004, 2012 Daryle Walker. Use, modification, and
|
|
||||||
// distribution are subject to the Boost Software License, Version 1.0. (See
|
|
||||||
// accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// <http://www.boost.org/LICENSE_1_0.txt>.)
|
|
||||||
|
|
||||||
// See <http://www.boost.org/libs/utility/> for the library's home page.
|
|
||||||
|
|
||||||
#ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP
|
|
||||||
#define BOOST_UTILITY_BASE_FROM_MEMBER_HPP
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
|
||||||
#include <boost/type_traits/is_same.hpp>
|
|
||||||
#include <boost/type_traits/remove_cv.hpp>
|
|
||||||
#include <boost/type_traits/remove_reference.hpp>
|
|
||||||
#include <boost/utility/enable_if.hpp>
|
|
||||||
|
|
||||||
|
|
||||||
// Base-from-member arity configuration macro ------------------------------//
|
|
||||||
|
|
||||||
// The following macro determines how many arguments will be in the largest
|
|
||||||
// constructor template of base_from_member. Constructor templates will be
|
|
||||||
// generated from one argument to this maximum. Code from other files can read
|
|
||||||
// this number if they need to always match the exact maximum base_from_member
|
|
||||||
// uses. The maximum constructor length can be changed by overriding the
|
|
||||||
// #defined constant. Make sure to apply the override, if any, for all source
|
|
||||||
// files during project compiling for consistency.
|
|
||||||
|
|
||||||
// Contributed by Jonathan Turkanis
|
|
||||||
|
|
||||||
#ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY
|
|
||||||
#define BOOST_BASE_FROM_MEMBER_MAX_ARITY 10
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
// An iteration of a constructor template for base_from_member -------------//
|
|
||||||
|
|
||||||
// A macro that should expand to:
|
|
||||||
// template < typename T1, ..., typename Tn >
|
|
||||||
// base_from_member( T1 x1, ..., Tn xn )
|
|
||||||
// : member( x1, ..., xn )
|
|
||||||
// {}
|
|
||||||
// This macro should only persist within this file.
|
|
||||||
|
|
||||||
#define BOOST_PRIVATE_CTR_DEF( z, n, data ) \
|
|
||||||
template < BOOST_PP_ENUM_PARAMS(n, typename T) > \
|
|
||||||
explicit base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \
|
|
||||||
: member( BOOST_PP_ENUM_PARAMS(n, x) ) \
|
|
||||||
{} \
|
|
||||||
/**/
|
|
||||||
|
|
||||||
|
|
||||||
namespace boost
|
|
||||||
{
|
|
||||||
|
|
||||||
namespace detail
|
|
||||||
{
|
|
||||||
|
|
||||||
// Type-unmarking class template -------------------------------------------//
|
|
||||||
|
|
||||||
// Type-trait to get the raw type, i.e. the type without top-level reference nor
|
|
||||||
// cv-qualification, from a type expression. Mainly for function arguments, any
|
|
||||||
// reference part is stripped first.
|
|
||||||
|
|
||||||
// Contributed by Daryle Walker
|
|
||||||
|
|
||||||
template < typename T >
|
|
||||||
struct remove_cv_ref
|
|
||||||
{
|
|
||||||
typedef typename ::boost::remove_cv<typename
|
|
||||||
::boost::remove_reference<T>::type>::type type;
|
|
||||||
|
|
||||||
}; // boost::detail::remove_cv_ref
|
|
||||||
|
|
||||||
// Unmarked-type comparison class template ---------------------------------//
|
|
||||||
|
|
||||||
// Type-trait to check if two type expressions have the same raw type.
|
|
||||||
|
|
||||||
// Contributed by Daryle Walker, based on a work-around by Luc Danton
|
|
||||||
|
|
||||||
template < typename T, typename U >
|
|
||||||
struct is_related
|
|
||||||
: public ::boost::is_same<
|
|
||||||
typename ::boost::detail::remove_cv_ref<T>::type,
|
|
||||||
typename ::boost::detail::remove_cv_ref<U>::type >
|
|
||||||
{};
|
|
||||||
|
|
||||||
// Enable-if-on-unidentical-unmarked-type class template -------------------//
|
|
||||||
|
|
||||||
// Enable-if on the first two type expressions NOT having the same raw type.
|
|
||||||
|
|
||||||
// Contributed by Daryle Walker, based on a work-around by Luc Danton
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
|
|
||||||
template<typename ...T>
|
|
||||||
struct enable_if_unrelated
|
|
||||||
: public ::boost::enable_if_c<true>
|
|
||||||
{};
|
|
||||||
|
|
||||||
template<typename T, typename U, typename ...U2>
|
|
||||||
struct enable_if_unrelated<T, U, U2...>
|
|
||||||
: public ::boost::disable_if< ::boost::detail::is_related<T, U> >
|
|
||||||
{};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
} // namespace boost::detail
|
|
||||||
|
|
||||||
|
|
||||||
// Base-from-member class template -----------------------------------------//
|
|
||||||
|
|
||||||
// Helper to initialize a base object so a derived class can use this
|
|
||||||
// object in the initialization of another base class. Used by
|
|
||||||
// Dietmar Kuehl from ideas by Ron Klatcho to solve the problem of a
|
|
||||||
// base class needing to be initialized by a member.
|
|
||||||
|
|
||||||
// Contributed by Daryle Walker
|
|
||||||
|
|
||||||
template < typename MemberType, int UniqueID = 0 >
|
|
||||||
class base_from_member
|
|
||||||
{
|
|
||||||
protected:
|
|
||||||
MemberType member;
|
|
||||||
|
|
||||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
|
|
||||||
!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
|
|
||||||
!defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && \
|
|
||||||
!(defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 4))
|
|
||||||
template <typename ...T, typename EnableIf = typename
|
|
||||||
::boost::detail::enable_if_unrelated<base_from_member, T...>::type>
|
|
||||||
explicit BOOST_CONSTEXPR base_from_member( T&& ...x )
|
|
||||||
BOOST_NOEXCEPT_IF( BOOST_NOEXCEPT_EXPR(::new ((void*) 0) MemberType(
|
|
||||||
static_cast<T&&>(x)... )) ) // no std::is_nothrow_constructible...
|
|
||||||
: member( static_cast<T&&>(x)... ) // ...nor std::forward needed
|
|
||||||
{}
|
|
||||||
#else
|
|
||||||
base_from_member()
|
|
||||||
: member()
|
|
||||||
{}
|
|
||||||
|
|
||||||
BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY),
|
|
||||||
BOOST_PRIVATE_CTR_DEF, _ )
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}; // boost::base_from_member
|
|
||||||
|
|
||||||
template < typename MemberType, int UniqueID >
|
|
||||||
class base_from_member<MemberType&, UniqueID>
|
|
||||||
{
|
|
||||||
protected:
|
|
||||||
MemberType& member;
|
|
||||||
|
|
||||||
explicit BOOST_CONSTEXPR base_from_member( MemberType& x )
|
|
||||||
BOOST_NOEXCEPT
|
|
||||||
: member( x )
|
|
||||||
{}
|
|
||||||
|
|
||||||
}; // boost::base_from_member
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
|
|
||||||
// Undo any private macros
|
|
||||||
#undef BOOST_PRIVATE_CTR_DEF
|
|
||||||
|
|
||||||
|
|
||||||
#endif // BOOST_UTILITY_BASE_FROM_MEMBER_HPP
|
|
||||||
@@ -1,708 +0,0 @@
|
|||||||
/*=============================================================================
|
|
||||||
Copyright (c) 2005 Matthew Calabrese
|
|
||||||
|
|
||||||
Use, modification and distribution is subject to 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_UTILITY_BINARY_HPP
|
|
||||||
#define BOOST_UTILITY_BINARY_HPP
|
|
||||||
|
|
||||||
/*=============================================================================
|
|
||||||
|
|
||||||
Binary Literal Utility
|
|
||||||
______________________
|
|
||||||
|
|
||||||
|
|
||||||
The following code works by converting the input bit pattern into a
|
|
||||||
Boost.Preprocessor sequence, then converting groupings of 3 bits each into
|
|
||||||
the corresponding octal digit, and finally concatenating all of the digits
|
|
||||||
together along with a leading zero. This yields a standard octal literal
|
|
||||||
with the desired value as specified in bits.
|
|
||||||
|
|
||||||
==============================================================================*/
|
|
||||||
|
|
||||||
#include <boost/preprocessor/control/deduce_d.hpp>
|
|
||||||
#include <boost/preprocessor/facilities/identity.hpp>
|
|
||||||
#include <boost/preprocessor/cat.hpp>
|
|
||||||
#include <boost/preprocessor/seq/cat.hpp>
|
|
||||||
#include <boost/preprocessor/seq/transform.hpp>
|
|
||||||
#include <boost/preprocessor/arithmetic/mod.hpp>
|
|
||||||
#include <boost/preprocessor/seq/size.hpp>
|
|
||||||
#include <boost/preprocessor/facilities/empty.hpp>
|
|
||||||
#include <boost/preprocessor/control/while.hpp>
|
|
||||||
|
|
||||||
#define BOOST_BINARY( bit_groupings ) \
|
|
||||||
BOOST_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings )
|
|
||||||
|
|
||||||
#define BOOST_BINARY_U( bit_groupings ) \
|
|
||||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, U )
|
|
||||||
|
|
||||||
#define BOOST_BINARY_L( bit_groupings ) \
|
|
||||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, L )
|
|
||||||
|
|
||||||
#define BOOST_BINARY_UL( bit_groupings ) \
|
|
||||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, UL )
|
|
||||||
|
|
||||||
#define BOOST_BINARY_LU( bit_groupings ) \
|
|
||||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LU )
|
|
||||||
|
|
||||||
#define BOOST_BINARY_LL( bit_groupings ) \
|
|
||||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LL )
|
|
||||||
|
|
||||||
#define BOOST_BINARY_ULL( bit_groupings ) \
|
|
||||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, ULL )
|
|
||||||
|
|
||||||
#define BOOST_BINARY_LLU( bit_groupings ) \
|
|
||||||
BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, LLU )
|
|
||||||
|
|
||||||
#define BOOST_SUFFIXED_BINARY_LITERAL( bit_groupings, suffix ) \
|
|
||||||
BOOST_SUFFIXED_BINARY_LITERAL_D( BOOST_PP_DEDUCE_D(), bit_groupings, suffix )
|
|
||||||
|
|
||||||
#define BOOST_SUFFIXED_BINARY_LITERAL_D( d, bit_groupings, suffix ) \
|
|
||||||
BOOST_PP_CAT( BOOST_BINARY_LITERAL_D( d, bit_groupings ), suffix )
|
|
||||||
|
|
||||||
#define BOOST_BINARY_LITERAL_D( d, bit_groupings ) \
|
|
||||||
BOOST_PP_SEQ_CAT \
|
|
||||||
( (0) BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings ) \
|
|
||||||
)
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_CREATE_BINARY_LITERAL_OCTAL_SEQUENCE( d, bit_groupings ) \
|
|
||||||
BOOST_PP_SEQ_TRANSFORM \
|
|
||||||
( BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION \
|
|
||||||
, BOOST_PP_NIL \
|
|
||||||
, BOOST_PP_IDENTITY( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE )()\
|
|
||||||
( BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE \
|
|
||||||
( \
|
|
||||||
d \
|
|
||||||
, BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings ) \
|
|
||||||
) \
|
|
||||||
) \
|
|
||||||
)
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_TRIPLE_SEQUENCE( bit_sequence ) \
|
|
||||||
BOOST_PP_CAT \
|
|
||||||
( BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1 bit_sequence \
|
|
||||||
, END_BIT \
|
|
||||||
)
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BITS_PER_OCTIT 3
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_COMPLETE_TRIPLE_SEQUENCE( d, incomplete_nibble_sequence ) \
|
|
||||||
BOOST_PP_CAT \
|
|
||||||
( BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_ \
|
|
||||||
, BOOST_PP_MOD_D( d \
|
|
||||||
, BOOST_PP_SEQ_SIZE( incomplete_nibble_sequence ) \
|
|
||||||
, BOOST_DETAIL_BITS_PER_OCTIT \
|
|
||||||
) \
|
|
||||||
) \
|
|
||||||
incomplete_nibble_sequence
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_FIXED_COMPL( bit ) \
|
|
||||||
BOOST_PP_CAT( BOOST_DETAIL_FIXED_COMPL_, bit )
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_FIXED_COMPL_0 1
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_FIXED_COMPL_1 0
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_CREATE_BINARY_LITERAL_BIT_SEQUENCE( d, bit_groupings ) \
|
|
||||||
BOOST_PP_EMPTY \
|
|
||||||
BOOST_PP_CAT( BOOST_PP_WHILE_, d ) \
|
|
||||||
( BOOST_DETAIL_BINARY_LITERAL_PREDICATE \
|
|
||||||
, BOOST_DETAIL_BINARY_LITERAL_OPERATION \
|
|
||||||
, bit_groupings () \
|
|
||||||
)
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_PREDICATE( d, state ) \
|
|
||||||
BOOST_DETAIL_FIXED_COMPL( BOOST_DETAIL_IS_NULLARY_ARGS( state ) )
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_OPERATION( d, state ) \
|
|
||||||
BOOST_DETAIL_SPLIT_AND_SWAP \
|
|
||||||
( BOOST_PP_CAT( BOOST_DETAIL_BINARY_LITERAL_ELEMENT_, state ) )
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_OPERATION( s, dummy_param, tuple ) \
|
|
||||||
BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL tuple
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_TERNARY_TRIPLE_TO_OCTAL( bit2, bit1, bit0 ) \
|
|
||||||
BOOST_DETAIL_TRIPLE_TO_OCTAL_ ## bit2 ## bit1 ## bit0
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_1 (0)(0)
|
|
||||||
#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_2 (0)
|
|
||||||
#define BOOST_DETAIL_CREATE_TRIPLE_COMPLETION_SEQUENCE_0
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1END_BIT
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1( bit ) \
|
|
||||||
( ( bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_2( bit ) \
|
|
||||||
bit, BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_3( bit ) \
|
|
||||||
bit ) ) BOOST_DETAIL_CONVERT_BIT_SEQUENCE_TO_PARENTHETIC_TUPLE_1
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_SPLIT_AND_SWAP( params ) \
|
|
||||||
BOOST_PP_IDENTITY( BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS )()( params )
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_SPLIT_AND_SWAP_PARAMS( first_param, second_param ) \
|
|
||||||
second_param first_param
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_LEFT_OF_COMMA( params ) \
|
|
||||||
BOOST_PP_IDENTITY( BOOST_DETAIL_FIRST_MACRO_PARAM )()( params )
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_FIRST_MACRO_PARAM( first_param, second_param ) \
|
|
||||||
first_param
|
|
||||||
|
|
||||||
/* Begin derived concepts from Chaos by Paul Mensonides */
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_IS_NULLARY_ARGS( param ) \
|
|
||||||
BOOST_DETAIL_LEFT_OF_COMMA \
|
|
||||||
( BOOST_PP_CAT( BOOST_DETAIL_IS_NULLARY_ARGS_R_ \
|
|
||||||
, BOOST_DETAIL_IS_NULLARY_ARGS_C param \
|
|
||||||
) \
|
|
||||||
)
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_IS_NULLARY_ARGS_C() \
|
|
||||||
1
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_IS_NULLARY_ARGS_R_1 \
|
|
||||||
1, BOOST_PP_NIL
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_IS_NULLARY_ARGS_R_BOOST_DETAIL_IS_NULLARY_ARGS_C \
|
|
||||||
0, BOOST_PP_NIL
|
|
||||||
|
|
||||||
/* End derived concepts from Chaos by Paul Mensonides */
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_000 0
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_001 1
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_010 2
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_011 3
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_100 4
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_101 5
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_110 6
|
|
||||||
#define BOOST_DETAIL_TRIPLE_TO_OCTAL_111 7
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0 (0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1 (1),
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00 (0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01 (0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10 (1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11 (1)(1),
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000 (0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001 (0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010 (0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011 (0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100 (1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101 (1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110 (1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111 (1)(1)(1),
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000 (0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001 (0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010 (0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011 (0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100 (0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101 (0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110 (0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111 (0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000 (1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001 (1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010 (1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011 (1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100 (1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101 (1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110 (1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111 (1)(1)(1)(1),
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000 (0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001 (0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010 (0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011 (0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100 (0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101 (0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110 (0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111 (0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000 (0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001 (0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010 (0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011 (0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100 (0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101 (0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110 (0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111 (0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000 (1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001 (1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010 (1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011 (1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100 (1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101 (1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110 (1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111 (1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000 (1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001 (1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010 (1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011 (1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100 (1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101 (1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110 (1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111 (1)(1)(1)(1)(1),
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000000 (0)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000001 (0)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000010 (0)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000011 (0)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000100 (0)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000101 (0)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000110 (0)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_000111 (0)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001000 (0)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001001 (0)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001010 (0)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001011 (0)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001100 (0)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001101 (0)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001110 (0)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_001111 (0)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010000 (0)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010001 (0)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010010 (0)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010011 (0)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010100 (0)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010101 (0)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010110 (0)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_010111 (0)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011000 (0)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011001 (0)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011010 (0)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011011 (0)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011100 (0)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011101 (0)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011110 (0)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_011111 (0)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100000 (1)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100001 (1)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100010 (1)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100011 (1)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100100 (1)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100101 (1)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100110 (1)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_100111 (1)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101000 (1)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101001 (1)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101010 (1)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101011 (1)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101100 (1)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101101 (1)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101110 (1)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_101111 (1)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110000 (1)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110001 (1)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110010 (1)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110011 (1)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110100 (1)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110101 (1)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110110 (1)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_110111 (1)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111000 (1)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111001 (1)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111010 (1)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111011 (1)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111100 (1)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111101 (1)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111110 (1)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_111111 (1)(1)(1)(1)(1)(1),
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000000 (0)(0)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000001 (0)(0)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000010 (0)(0)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000011 (0)(0)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000100 (0)(0)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000101 (0)(0)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000110 (0)(0)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0000111 (0)(0)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001000 (0)(0)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001001 (0)(0)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001010 (0)(0)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001011 (0)(0)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001100 (0)(0)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001101 (0)(0)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001110 (0)(0)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0001111 (0)(0)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010000 (0)(0)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010001 (0)(0)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010010 (0)(0)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010011 (0)(0)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010100 (0)(0)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010101 (0)(0)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010110 (0)(0)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0010111 (0)(0)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011000 (0)(0)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011001 (0)(0)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011010 (0)(0)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011011 (0)(0)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011100 (0)(0)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011101 (0)(0)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011110 (0)(0)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0011111 (0)(0)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100000 (0)(1)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100001 (0)(1)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100010 (0)(1)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100011 (0)(1)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100100 (0)(1)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100101 (0)(1)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100110 (0)(1)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0100111 (0)(1)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101000 (0)(1)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101001 (0)(1)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101010 (0)(1)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101011 (0)(1)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101100 (0)(1)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101101 (0)(1)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101110 (0)(1)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0101111 (0)(1)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110000 (0)(1)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110001 (0)(1)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110010 (0)(1)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110011 (0)(1)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110100 (0)(1)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110101 (0)(1)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110110 (0)(1)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0110111 (0)(1)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111000 (0)(1)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111001 (0)(1)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111010 (0)(1)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111011 (0)(1)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111100 (0)(1)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111101 (0)(1)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111110 (0)(1)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_0111111 (0)(1)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000000 (1)(0)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000001 (1)(0)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000010 (1)(0)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000011 (1)(0)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000100 (1)(0)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000101 (1)(0)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000110 (1)(0)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1000111 (1)(0)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001000 (1)(0)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001001 (1)(0)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001010 (1)(0)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001011 (1)(0)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001100 (1)(0)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001101 (1)(0)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001110 (1)(0)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1001111 (1)(0)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010000 (1)(0)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010001 (1)(0)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010010 (1)(0)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010011 (1)(0)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010100 (1)(0)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010101 (1)(0)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010110 (1)(0)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1010111 (1)(0)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011000 (1)(0)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011001 (1)(0)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011010 (1)(0)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011011 (1)(0)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011100 (1)(0)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011101 (1)(0)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011110 (1)(0)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1011111 (1)(0)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100000 (1)(1)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100001 (1)(1)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100010 (1)(1)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100011 (1)(1)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100100 (1)(1)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100101 (1)(1)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100110 (1)(1)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1100111 (1)(1)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101000 (1)(1)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101001 (1)(1)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101010 (1)(1)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101011 (1)(1)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101100 (1)(1)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101101 (1)(1)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101110 (1)(1)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1101111 (1)(1)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110000 (1)(1)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110001 (1)(1)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110010 (1)(1)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110011 (1)(1)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110100 (1)(1)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110101 (1)(1)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110110 (1)(1)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1110111 (1)(1)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111000 (1)(1)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111001 (1)(1)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111010 (1)(1)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111011 (1)(1)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111100 (1)(1)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111101 (1)(1)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111110 (1)(1)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_1111111 (1)(1)(1)(1)(1)(1)(1),
|
|
||||||
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000000 (0)(0)(0)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000001 (0)(0)(0)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000010 (0)(0)(0)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000011 (0)(0)(0)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000100 (0)(0)(0)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000101 (0)(0)(0)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000110 (0)(0)(0)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00000111 (0)(0)(0)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001000 (0)(0)(0)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001001 (0)(0)(0)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001010 (0)(0)(0)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001011 (0)(0)(0)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001100 (0)(0)(0)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001101 (0)(0)(0)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001110 (0)(0)(0)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00001111 (0)(0)(0)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010000 (0)(0)(0)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010001 (0)(0)(0)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010010 (0)(0)(0)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010011 (0)(0)(0)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010100 (0)(0)(0)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010101 (0)(0)(0)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010110 (0)(0)(0)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00010111 (0)(0)(0)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011000 (0)(0)(0)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011001 (0)(0)(0)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011010 (0)(0)(0)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011011 (0)(0)(0)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011100 (0)(0)(0)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011101 (0)(0)(0)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011110 (0)(0)(0)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00011111 (0)(0)(0)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100000 (0)(0)(1)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100001 (0)(0)(1)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100010 (0)(0)(1)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100011 (0)(0)(1)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100100 (0)(0)(1)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100101 (0)(0)(1)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100110 (0)(0)(1)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00100111 (0)(0)(1)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101000 (0)(0)(1)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101001 (0)(0)(1)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101010 (0)(0)(1)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101011 (0)(0)(1)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101100 (0)(0)(1)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101101 (0)(0)(1)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101110 (0)(0)(1)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00101111 (0)(0)(1)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110000 (0)(0)(1)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110001 (0)(0)(1)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110010 (0)(0)(1)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110011 (0)(0)(1)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110100 (0)(0)(1)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110101 (0)(0)(1)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110110 (0)(0)(1)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00110111 (0)(0)(1)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111000 (0)(0)(1)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111001 (0)(0)(1)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111010 (0)(0)(1)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111011 (0)(0)(1)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111100 (0)(0)(1)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111101 (0)(0)(1)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111110 (0)(0)(1)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_00111111 (0)(0)(1)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000000 (0)(1)(0)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000001 (0)(1)(0)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000010 (0)(1)(0)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000011 (0)(1)(0)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000100 (0)(1)(0)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000101 (0)(1)(0)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000110 (0)(1)(0)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01000111 (0)(1)(0)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001000 (0)(1)(0)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001001 (0)(1)(0)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001010 (0)(1)(0)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001011 (0)(1)(0)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001100 (0)(1)(0)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001101 (0)(1)(0)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001110 (0)(1)(0)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01001111 (0)(1)(0)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010000 (0)(1)(0)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010001 (0)(1)(0)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010010 (0)(1)(0)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010011 (0)(1)(0)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010100 (0)(1)(0)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010101 (0)(1)(0)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010110 (0)(1)(0)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01010111 (0)(1)(0)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011000 (0)(1)(0)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011001 (0)(1)(0)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011010 (0)(1)(0)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011011 (0)(1)(0)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011100 (0)(1)(0)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011101 (0)(1)(0)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011110 (0)(1)(0)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01011111 (0)(1)(0)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100000 (0)(1)(1)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100001 (0)(1)(1)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100010 (0)(1)(1)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100011 (0)(1)(1)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100100 (0)(1)(1)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100101 (0)(1)(1)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100110 (0)(1)(1)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01100111 (0)(1)(1)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101000 (0)(1)(1)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101001 (0)(1)(1)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101010 (0)(1)(1)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101011 (0)(1)(1)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101100 (0)(1)(1)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101101 (0)(1)(1)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101110 (0)(1)(1)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01101111 (0)(1)(1)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110000 (0)(1)(1)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110001 (0)(1)(1)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110010 (0)(1)(1)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110011 (0)(1)(1)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110100 (0)(1)(1)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110101 (0)(1)(1)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110110 (0)(1)(1)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01110111 (0)(1)(1)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111000 (0)(1)(1)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111001 (0)(1)(1)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111010 (0)(1)(1)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111011 (0)(1)(1)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111100 (0)(1)(1)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111101 (0)(1)(1)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111110 (0)(1)(1)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_01111111 (0)(1)(1)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000000 (1)(0)(0)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000001 (1)(0)(0)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000010 (1)(0)(0)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000011 (1)(0)(0)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000100 (1)(0)(0)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000101 (1)(0)(0)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000110 (1)(0)(0)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10000111 (1)(0)(0)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001000 (1)(0)(0)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001001 (1)(0)(0)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001010 (1)(0)(0)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001011 (1)(0)(0)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001100 (1)(0)(0)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001101 (1)(0)(0)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001110 (1)(0)(0)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10001111 (1)(0)(0)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010000 (1)(0)(0)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010001 (1)(0)(0)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010010 (1)(0)(0)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010011 (1)(0)(0)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010100 (1)(0)(0)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010101 (1)(0)(0)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010110 (1)(0)(0)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10010111 (1)(0)(0)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011000 (1)(0)(0)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011001 (1)(0)(0)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011010 (1)(0)(0)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011011 (1)(0)(0)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011100 (1)(0)(0)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011101 (1)(0)(0)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011110 (1)(0)(0)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10011111 (1)(0)(0)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100000 (1)(0)(1)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100001 (1)(0)(1)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100010 (1)(0)(1)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100011 (1)(0)(1)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100100 (1)(0)(1)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100101 (1)(0)(1)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100110 (1)(0)(1)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10100111 (1)(0)(1)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101000 (1)(0)(1)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101001 (1)(0)(1)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101010 (1)(0)(1)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101011 (1)(0)(1)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101100 (1)(0)(1)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101101 (1)(0)(1)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101110 (1)(0)(1)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10101111 (1)(0)(1)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110000 (1)(0)(1)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110001 (1)(0)(1)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110010 (1)(0)(1)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110011 (1)(0)(1)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110100 (1)(0)(1)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110101 (1)(0)(1)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110110 (1)(0)(1)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10110111 (1)(0)(1)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111000 (1)(0)(1)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111001 (1)(0)(1)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111010 (1)(0)(1)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111011 (1)(0)(1)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111100 (1)(0)(1)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111101 (1)(0)(1)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111110 (1)(0)(1)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_10111111 (1)(0)(1)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000000 (1)(1)(0)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000001 (1)(1)(0)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000010 (1)(1)(0)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000011 (1)(1)(0)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000100 (1)(1)(0)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000101 (1)(1)(0)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000110 (1)(1)(0)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11000111 (1)(1)(0)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001000 (1)(1)(0)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001001 (1)(1)(0)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001010 (1)(1)(0)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001011 (1)(1)(0)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001100 (1)(1)(0)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001101 (1)(1)(0)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001110 (1)(1)(0)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11001111 (1)(1)(0)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010000 (1)(1)(0)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010001 (1)(1)(0)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010010 (1)(1)(0)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010011 (1)(1)(0)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010100 (1)(1)(0)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010101 (1)(1)(0)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010110 (1)(1)(0)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11010111 (1)(1)(0)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011000 (1)(1)(0)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011001 (1)(1)(0)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011010 (1)(1)(0)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011011 (1)(1)(0)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011100 (1)(1)(0)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011101 (1)(1)(0)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011110 (1)(1)(0)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11011111 (1)(1)(0)(1)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100000 (1)(1)(1)(0)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100001 (1)(1)(1)(0)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100010 (1)(1)(1)(0)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100011 (1)(1)(1)(0)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100100 (1)(1)(1)(0)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100101 (1)(1)(1)(0)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100110 (1)(1)(1)(0)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11100111 (1)(1)(1)(0)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101000 (1)(1)(1)(0)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101001 (1)(1)(1)(0)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101010 (1)(1)(1)(0)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101011 (1)(1)(1)(0)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101100 (1)(1)(1)(0)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101101 (1)(1)(1)(0)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101110 (1)(1)(1)(0)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11101111 (1)(1)(1)(0)(1)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110000 (1)(1)(1)(1)(0)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110001 (1)(1)(1)(1)(0)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110010 (1)(1)(1)(1)(0)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110011 (1)(1)(1)(1)(0)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110100 (1)(1)(1)(1)(0)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110101 (1)(1)(1)(1)(0)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110110 (1)(1)(1)(1)(0)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11110111 (1)(1)(1)(1)(0)(1)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111000 (1)(1)(1)(1)(1)(0)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111001 (1)(1)(1)(1)(1)(0)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111010 (1)(1)(1)(1)(1)(0)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111011 (1)(1)(1)(1)(1)(0)(1)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111100 (1)(1)(1)(1)(1)(1)(0)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111101 (1)(1)(1)(1)(1)(1)(0)(1),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111110 (1)(1)(1)(1)(1)(1)(1)(0),
|
|
||||||
#define BOOST_DETAIL_BINARY_LITERAL_ELEMENT_11111111 (1)(1)(1)(1)(1)(1)(1)(1),
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,68 +0,0 @@
|
|||||||
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
|
|
||||||
//
|
|
||||||
// Use, modification, and distribution is subject to 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)
|
|
||||||
//
|
|
||||||
// See http://www.boost.org/libs/optional for documentation.
|
|
||||||
//
|
|
||||||
// You are welcome to contact the author at:
|
|
||||||
// fernando_cacciola@hotmail.com
|
|
||||||
//
|
|
||||||
#ifndef BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
|
|
||||||
#define BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP
|
|
||||||
|
|
||||||
#include<functional>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
// template<class OP> bool equal_pointees(OP const& x, OP const& y);
|
|
||||||
// template<class OP> struct equal_pointees_t;
|
|
||||||
//
|
|
||||||
// Being OP a model of OptionalPointee (either a pointer or an optional):
|
|
||||||
//
|
|
||||||
// If both x and y have valid pointees, returns the result of (*x == *y)
|
|
||||||
// If only one has a valid pointee, returns false.
|
|
||||||
// If none have valid pointees, returns true.
|
|
||||||
// No-throw
|
|
||||||
template<class OptionalPointee>
|
|
||||||
inline
|
|
||||||
bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
|
|
||||||
{
|
|
||||||
return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class OptionalPointee>
|
|
||||||
struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
|
|
||||||
{
|
|
||||||
bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
|
|
||||||
{ return equal_pointees(x,y) ; }
|
|
||||||
} ;
|
|
||||||
|
|
||||||
// template<class OP> bool less_pointees(OP const& x, OP const& y);
|
|
||||||
// template<class OP> struct less_pointees_t;
|
|
||||||
//
|
|
||||||
// Being OP a model of OptionalPointee (either a pointer or an optional):
|
|
||||||
//
|
|
||||||
// If y has not a valid pointee, returns false.
|
|
||||||
// ElseIf x has not a valid pointee, returns true.
|
|
||||||
// ElseIf both x and y have valid pointees, returns the result of (*x < *y)
|
|
||||||
// No-throw
|
|
||||||
template<class OptionalPointee>
|
|
||||||
inline
|
|
||||||
bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
|
|
||||||
{
|
|
||||||
return !y ? false : ( !x ? true : (*x) < (*y) ) ;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class OptionalPointee>
|
|
||||||
struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
|
|
||||||
{
|
|
||||||
bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
|
|
||||||
{ return less_pointees(x,y) ; }
|
|
||||||
} ;
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@@ -1,36 +0,0 @@
|
|||||||
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
|
|
||||||
// Copyright (C) 2007, Tobias Schwinger.
|
|
||||||
//
|
|
||||||
// Use, modification, and distribution is subject to 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)
|
|
||||||
//
|
|
||||||
// See http://www.boost.org/libs/optional for documentation.
|
|
||||||
//
|
|
||||||
// You are welcome to contact the author at:
|
|
||||||
// fernando_cacciola@hotmail.com
|
|
||||||
//
|
|
||||||
#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
|
|
||||||
#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
|
|
||||||
|
|
||||||
#include <new>
|
|
||||||
#include <cstddef>
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <boost/preprocessor/cat.hpp>
|
|
||||||
#include <boost/preprocessor/punctuation/paren.hpp>
|
|
||||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/repeat.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
|
||||||
|
|
||||||
#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN()
|
|
||||||
#define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n);
|
|
||||||
|
|
||||||
#define BOOST_MAX_INPLACE_FACTORY_ARITY 10
|
|
||||||
|
|
||||||
#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@@ -1,23 +0,0 @@
|
|||||||
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
|
|
||||||
// Copyright (C) 2007, Tobias Schwinger.
|
|
||||||
//
|
|
||||||
// Use, modification, and distribution is subject to 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)
|
|
||||||
//
|
|
||||||
// See http://www.boost.org/libs/optional for documentation.
|
|
||||||
//
|
|
||||||
// You are welcome to contact the author at:
|
|
||||||
// fernando_cacciola@hotmail.com
|
|
||||||
//
|
|
||||||
#ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
|
|
||||||
#define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_04APR2007_HPP
|
|
||||||
|
|
||||||
#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT
|
|
||||||
#undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL
|
|
||||||
#undef BOOST_MAX_INPLACE_FACTORY_ARITY
|
|
||||||
|
|
||||||
#undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_04APR2007_HPP
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@@ -1,221 +0,0 @@
|
|||||||
// Boost result_of library
|
|
||||||
|
|
||||||
// Copyright Douglas Gregor 2004. Use, modification and
|
|
||||||
// distribution is subject to 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)
|
|
||||||
|
|
||||||
// Copyright Daniel Walker, Eric Niebler, Michel Morin 2008-2012.
|
|
||||||
// Use, modification and distribution is subject to 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)
|
|
||||||
|
|
||||||
// For more information, see http://www.boost.org/libs/utility
|
|
||||||
#if !defined(BOOST_PP_IS_ITERATING)
|
|
||||||
# error Boost result_of - do not include this file!
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// CWPro8 requires an argument in a function type specialization
|
|
||||||
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3002)) && BOOST_PP_ITERATION() == 0
|
|
||||||
# define BOOST_RESULT_OF_ARGS void
|
|
||||||
#else
|
|
||||||
# define BOOST_RESULT_OF_ARGS BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct tr1_result_of<F(BOOST_RESULT_OF_ARGS)>
|
|
||||||
: mpl::if_<
|
|
||||||
mpl::or_< is_pointer<F>, is_member_function_pointer<F> >
|
|
||||||
, boost::detail::tr1_result_of_impl<
|
|
||||||
typename remove_cv<F>::type,
|
|
||||||
typename remove_cv<F>::type(BOOST_RESULT_OF_ARGS),
|
|
||||||
(boost::detail::has_result_type<F>::value)>
|
|
||||||
, boost::detail::tr1_result_of_impl<
|
|
||||||
F,
|
|
||||||
F(BOOST_RESULT_OF_ARGS),
|
|
||||||
(boost::detail::has_result_type<F>::value)> >::type { };
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef BOOST_RESULT_OF_USE_DECLTYPE
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct result_of<F(BOOST_RESULT_OF_ARGS)>
|
|
||||||
: detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> { };
|
|
||||||
#endif // BOOST_RESULT_OF_USE_DECLTYPE
|
|
||||||
|
|
||||||
#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct result_of<F(BOOST_RESULT_OF_ARGS)>
|
|
||||||
: mpl::if_<mpl::or_<detail::has_result_type<F>, detail::has_result<F> >,
|
|
||||||
tr1_result_of<F(BOOST_RESULT_OF_ARGS)>,
|
|
||||||
detail::cpp0x_result_of<F(BOOST_RESULT_OF_ARGS)> >::type { };
|
|
||||||
#endif // BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
|
|
||||||
|
|
||||||
#if defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
|
|
||||||
|
|
||||||
namespace detail {
|
|
||||||
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct cpp0x_result_of<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))>
|
|
||||||
: mpl::if_<
|
|
||||||
is_member_function_pointer<F>
|
|
||||||
, detail::tr1_result_of_impl<
|
|
||||||
typename remove_cv<F>::type,
|
|
||||||
typename remove_cv<F>::type(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false
|
|
||||||
>
|
|
||||||
, detail::cpp0x_result_of_impl<
|
|
||||||
F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T))
|
|
||||||
>
|
|
||||||
>::type
|
|
||||||
{};
|
|
||||||
|
|
||||||
#ifdef BOOST_NO_SFINAE_EXPR
|
|
||||||
|
|
||||||
template<typename F>
|
|
||||||
struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION());
|
|
||||||
|
|
||||||
template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
|
|
||||||
struct BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<R(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), T))> {
|
|
||||||
R operator()(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), T)) const;
|
|
||||||
typedef result_of_private_type const &(*pfn_t)(...);
|
|
||||||
operator pfn_t() const volatile;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename F>
|
|
||||||
struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION());
|
|
||||||
|
|
||||||
template<typename F>
|
|
||||||
struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F *>
|
|
||||||
: BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
|
|
||||||
{};
|
|
||||||
|
|
||||||
template<typename F>
|
|
||||||
struct BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<F &>
|
|
||||||
: BOOST_PP_CAT(result_of_callable_fun_2_, BOOST_PP_ITERATION())<F>
|
|
||||||
{};
|
|
||||||
|
|
||||||
template<typename F>
|
|
||||||
struct BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())
|
|
||||||
: mpl::eval_if<
|
|
||||||
is_class<typename remove_reference<F>::type>,
|
|
||||||
result_of_wrap_callable_class<F>,
|
|
||||||
mpl::identity<BOOST_PP_CAT(result_of_callable_fun_, BOOST_PP_ITERATION())<typename remove_cv<F>::type> >
|
|
||||||
>
|
|
||||||
{};
|
|
||||||
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename T)>
|
|
||||||
struct BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION()) {
|
|
||||||
typedef typename BOOST_PP_CAT(result_of_select_call_wrapper_type_, BOOST_PP_ITERATION())<F>::type wrapper_t;
|
|
||||||
static const bool value = (
|
|
||||||
sizeof(result_of_no_type) == sizeof(detail::result_of_is_private_type(
|
|
||||||
(boost::declval<wrapper_t>()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)), result_of_weird_type())
|
|
||||||
))
|
|
||||||
);
|
|
||||||
typedef mpl::bool_<value> type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), true>
|
|
||||||
: lazy_enable_if<
|
|
||||||
BOOST_PP_CAT(result_of_is_callable_, BOOST_PP_ITERATION())<F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), T)>
|
|
||||||
, cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false>
|
|
||||||
>
|
|
||||||
{};
|
|
||||||
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), false>
|
|
||||||
{
|
|
||||||
typedef decltype(
|
|
||||||
boost::declval<F>()(
|
|
||||||
BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
|
|
||||||
)
|
|
||||||
) type;
|
|
||||||
};
|
|
||||||
|
|
||||||
#else // BOOST_NO_SFINAE_EXPR
|
|
||||||
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct cpp0x_result_of_impl<F(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)),
|
|
||||||
typename result_of_always_void<decltype(
|
|
||||||
boost::declval<F>()(
|
|
||||||
BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
|
|
||||||
)
|
|
||||||
)>::type> {
|
|
||||||
typedef decltype(
|
|
||||||
boost::declval<F>()(
|
|
||||||
BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(), boost::declval<T, >() BOOST_PP_INTERCEPT)
|
|
||||||
)
|
|
||||||
) type;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif // BOOST_NO_SFINAE_EXPR
|
|
||||||
|
|
||||||
} // namespace detail
|
|
||||||
|
|
||||||
#else // defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
|
|
||||||
|
|
||||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
|
||||||
template<typename F BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct result_of<F(BOOST_RESULT_OF_ARGS)>
|
|
||||||
: tr1_result_of<F(BOOST_RESULT_OF_ARGS)> { };
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE)
|
|
||||||
|
|
||||||
#undef BOOST_RESULT_OF_ARGS
|
|
||||||
|
|
||||||
#if BOOST_PP_ITERATION() >= 1
|
|
||||||
|
|
||||||
namespace detail {
|
|
||||||
|
|
||||||
template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct tr1_result_of_impl<R (*)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
|
|
||||||
{
|
|
||||||
typedef R type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct tr1_result_of_impl<R (&)(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T)), FArgs, false>
|
|
||||||
{
|
|
||||||
typedef R type;
|
|
||||||
};
|
|
||||||
|
|
||||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
|
|
||||||
template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct tr1_result_of_impl<R (T0::*)
|
|
||||||
(BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T)),
|
|
||||||
FArgs, false>
|
|
||||||
{
|
|
||||||
typedef R type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct tr1_result_of_impl<R (T0::*)
|
|
||||||
(BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
|
|
||||||
const,
|
|
||||||
FArgs, false>
|
|
||||||
{
|
|
||||||
typedef R type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct tr1_result_of_impl<R (T0::*)
|
|
||||||
(BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
|
|
||||||
volatile,
|
|
||||||
FArgs, false>
|
|
||||||
{
|
|
||||||
typedef R type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename R, typename FArgs BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(),typename T)>
|
|
||||||
struct tr1_result_of_impl<R (T0::*)
|
|
||||||
(BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_ITERATION(),T))
|
|
||||||
const volatile,
|
|
||||||
FArgs, false>
|
|
||||||
{
|
|
||||||
typedef R type;
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
@@ -1,46 +0,0 @@
|
|||||||
|
|
||||||
// Copyright (C) 2009-2012 Lorenzo Caminiti
|
|
||||||
// Distributed under the Boost Software License, Version 1.0
|
|
||||||
// (see accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// http://www.boost.org/LICENSE_1_0.txt)
|
|
||||||
// Home at http://www.boost.org/libs/utility/identity_type
|
|
||||||
|
|
||||||
/** @file
|
|
||||||
Wrap type expressions with round parenthesis so they can be passed to macros
|
|
||||||
even if they contain commas.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef BOOST_IDENTITY_TYPE_HPP_
|
|
||||||
#define BOOST_IDENTITY_TYPE_HPP_
|
|
||||||
|
|
||||||
#include <boost/type_traits/function_traits.hpp>
|
|
||||||
|
|
||||||
/**
|
|
||||||
@brief This macro allows to wrap the specified type expression within extra
|
|
||||||
round parenthesis so the type can be passed as a single macro parameter even if
|
|
||||||
it contains commas (not already wrapped within round parenthesis).
|
|
||||||
|
|
||||||
@Params
|
|
||||||
@Param{parenthesized_type,
|
|
||||||
The type expression to be passed as macro parameter wrapped by a single set
|
|
||||||
of round parenthesis <c>(...)</c>.
|
|
||||||
This type expression can contain an arbitrary number of commas.
|
|
||||||
}
|
|
||||||
@EndParams
|
|
||||||
|
|
||||||
This macro works on any C++03 compiler (it does not use variadic macros).
|
|
||||||
|
|
||||||
This macro must be prefixed by <c>typename</c> when used within templates.
|
|
||||||
Note that the compiler will not be able to automatically determine function
|
|
||||||
template parameters when they are wrapped with this macro (these parameters
|
|
||||||
need to be explicitly specified when calling the function template).
|
|
||||||
|
|
||||||
On some compilers (like GCC), using this macro on abstract types requires to
|
|
||||||
add and remove a reference to the specified type.
|
|
||||||
*/
|
|
||||||
#define BOOST_IDENTITY_TYPE(parenthesized_type) \
|
|
||||||
/* must NOT prefix this with `::` to work with parenthesized syntax */ \
|
|
||||||
boost::function_traits< void parenthesized_type >::arg1_type
|
|
||||||
|
|
||||||
#endif // #include guard
|
|
||||||
|
|
||||||
@@ -1,86 +0,0 @@
|
|||||||
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
|
|
||||||
// Copyright (C) 2007, Tobias Schwinger.
|
|
||||||
//
|
|
||||||
// Use, modification, and distribution is subject to 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)
|
|
||||||
//
|
|
||||||
// See http://www.boost.org/libs/optional for documentation.
|
|
||||||
//
|
|
||||||
// You are welcome to contact the author at:
|
|
||||||
// fernando_cacciola@hotmail.com
|
|
||||||
//
|
|
||||||
#ifndef BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
|
|
||||||
#ifndef BOOST_PP_IS_ITERATING
|
|
||||||
|
|
||||||
#include <boost/utility/detail/in_place_factory_prefix.hpp>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
class in_place_factory_base {} ;
|
|
||||||
|
|
||||||
#define BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
|
|
||||||
#define BOOST_PP_FILENAME_1 <boost/utility/in_place_factory.hpp>
|
|
||||||
#include BOOST_PP_ITERATE()
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#include <boost/utility/detail/in_place_factory_suffix.hpp>
|
|
||||||
|
|
||||||
#define BOOST_UTILITY_INPLACE_FACTORY_04APR2007_HPP
|
|
||||||
#else
|
|
||||||
#define N BOOST_PP_ITERATION()
|
|
||||||
|
|
||||||
#if N
|
|
||||||
template< BOOST_PP_ENUM_PARAMS(N, class A) >
|
|
||||||
#endif
|
|
||||||
class BOOST_PP_CAT(in_place_factory,N)
|
|
||||||
:
|
|
||||||
public in_place_factory_base
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
explicit BOOST_PP_CAT(in_place_factory,N)
|
|
||||||
( BOOST_PP_ENUM_BINARY_PARAMS(N,A,const& a) )
|
|
||||||
#if N > 0
|
|
||||||
: BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
|
|
||||||
#endif
|
|
||||||
{}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
void* apply(void* address) const
|
|
||||||
{
|
|
||||||
return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
void* apply(void* address, std::size_t n) const
|
|
||||||
{
|
|
||||||
for(char* next = address = this->BOOST_NESTED_TEMPLATE apply<T>(address);
|
|
||||||
!! --n;)
|
|
||||||
this->BOOST_NESTED_TEMPLATE apply<T>(next = next+sizeof(T));
|
|
||||||
return address;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
|
|
||||||
};
|
|
||||||
|
|
||||||
#if N > 0
|
|
||||||
template< BOOST_PP_ENUM_PARAMS(N, class A) >
|
|
||||||
inline BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
|
|
||||||
in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
|
|
||||||
{
|
|
||||||
return BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
|
|
||||||
( BOOST_PP_ENUM_PARAMS(N, a) );
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
inline in_place_factory0 in_place()
|
|
||||||
{
|
|
||||||
return in_place_factory0();
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#undef N
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@@ -1,210 +0,0 @@
|
|||||||
// Boost result_of library
|
|
||||||
|
|
||||||
// Copyright Douglas Gregor 2004. Use, modification and
|
|
||||||
// distribution is subject to 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)
|
|
||||||
|
|
||||||
// For more information, see http://www.boost.org/libs/utility
|
|
||||||
#ifndef BOOST_RESULT_OF_HPP
|
|
||||||
#define BOOST_RESULT_OF_HPP
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <boost/preprocessor/cat.hpp>
|
|
||||||
#include <boost/preprocessor/iteration/iterate.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
|
||||||
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
|
|
||||||
#include <boost/preprocessor/facilities/intercept.hpp>
|
|
||||||
#include <boost/detail/workaround.hpp>
|
|
||||||
#include <boost/mpl/has_xxx.hpp>
|
|
||||||
#include <boost/mpl/if.hpp>
|
|
||||||
#include <boost/mpl/eval_if.hpp>
|
|
||||||
#include <boost/mpl/bool.hpp>
|
|
||||||
#include <boost/mpl/identity.hpp>
|
|
||||||
#include <boost/mpl/or.hpp>
|
|
||||||
#include <boost/type_traits/is_class.hpp>
|
|
||||||
#include <boost/type_traits/is_pointer.hpp>
|
|
||||||
#include <boost/type_traits/is_member_function_pointer.hpp>
|
|
||||||
#include <boost/type_traits/remove_cv.hpp>
|
|
||||||
#include <boost/type_traits/remove_reference.hpp>
|
|
||||||
#include <boost/utility/declval.hpp>
|
|
||||||
#include <boost/utility/enable_if.hpp>
|
|
||||||
|
|
||||||
#ifndef BOOST_RESULT_OF_NUM_ARGS
|
|
||||||
# define BOOST_RESULT_OF_NUM_ARGS 16
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// Use the decltype-based version of result_of by default if the compiler
|
|
||||||
// supports N3276 <http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf>.
|
|
||||||
// The user can force the choice by defining BOOST_RESULT_OF_USE_DECLTYPE,
|
|
||||||
// BOOST_RESULT_OF_USE_TR1, or BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK but not more than one!
|
|
||||||
#if (defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1)) || \
|
|
||||||
(defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)) || \
|
|
||||||
(defined(BOOST_RESULT_OF_USE_TR1) && defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK))
|
|
||||||
# error More than one of BOOST_RESULT_OF_USE_DECLTYPE, BOOST_RESULT_OF_USE_TR1 and \
|
|
||||||
BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK cannot be defined at the same time.
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK) && defined(BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE)
|
|
||||||
# error Cannot fallback to decltype if BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE is not defined.
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef BOOST_RESULT_OF_USE_TR1
|
|
||||||
# ifndef BOOST_RESULT_OF_USE_DECLTYPE
|
|
||||||
# ifndef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
|
|
||||||
# ifndef BOOST_NO_CXX11_DECLTYPE_N3276 // this implies !defined(BOOST_NO_CXX11_DECLTYPE)
|
|
||||||
# define BOOST_RESULT_OF_USE_DECLTYPE
|
|
||||||
# else
|
|
||||||
# define BOOST_RESULT_OF_USE_TR1
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
# endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
template<typename F> struct result_of;
|
|
||||||
template<typename F> struct tr1_result_of; // a TR1-style implementation of result_of
|
|
||||||
|
|
||||||
#if !defined(BOOST_NO_SFINAE)
|
|
||||||
namespace detail {
|
|
||||||
|
|
||||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type)
|
|
||||||
|
|
||||||
// Work around a nvcc bug by only defining has_result when it's needed.
|
|
||||||
#ifdef BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK
|
|
||||||
BOOST_MPL_HAS_XXX_TEMPLATE_DEF(result)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;
|
|
||||||
|
|
||||||
template<typename F> struct cpp0x_result_of;
|
|
||||||
|
|
||||||
#ifdef BOOST_NO_SFINAE_EXPR
|
|
||||||
|
|
||||||
// There doesn't seem to be any other way to turn this off such that the presence of
|
|
||||||
// the user-defined operator,() below doesn't cause spurious warning all over the place,
|
|
||||||
// so unconditionally turn it off.
|
|
||||||
#if BOOST_MSVC
|
|
||||||
# pragma warning(disable: 4913) // user defined binary operator ',' exists but no overload could convert all operands, default built-in binary operator ',' used
|
|
||||||
#endif
|
|
||||||
|
|
||||||
struct result_of_private_type {};
|
|
||||||
|
|
||||||
struct result_of_weird_type {
|
|
||||||
friend result_of_private_type operator,(result_of_private_type, result_of_weird_type);
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef char result_of_yes_type; // sizeof(result_of_yes_type) == 1
|
|
||||||
typedef char (&result_of_no_type)[2]; // sizeof(result_of_no_type) == 2
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
result_of_no_type result_of_is_private_type(T const &);
|
|
||||||
result_of_yes_type result_of_is_private_type(result_of_private_type);
|
|
||||||
|
|
||||||
template<typename C>
|
|
||||||
struct result_of_callable_class : C {
|
|
||||||
result_of_callable_class();
|
|
||||||
typedef result_of_private_type const &(*pfn_t)(...);
|
|
||||||
operator pfn_t() const volatile;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename C>
|
|
||||||
struct result_of_wrap_callable_class {
|
|
||||||
typedef result_of_callable_class<C> type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename C>
|
|
||||||
struct result_of_wrap_callable_class<C const> {
|
|
||||||
typedef result_of_callable_class<C> const type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename C>
|
|
||||||
struct result_of_wrap_callable_class<C volatile> {
|
|
||||||
typedef result_of_callable_class<C> volatile type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename C>
|
|
||||||
struct result_of_wrap_callable_class<C const volatile> {
|
|
||||||
typedef result_of_callable_class<C> const volatile type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename C>
|
|
||||||
struct result_of_wrap_callable_class<C &> {
|
|
||||||
typedef typename result_of_wrap_callable_class<C>::type &type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename F, bool TestCallability = true> struct cpp0x_result_of_impl;
|
|
||||||
|
|
||||||
#else // BOOST_NO_SFINAE_EXPR
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
struct result_of_always_void
|
|
||||||
{
|
|
||||||
typedef void type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};
|
|
||||||
|
|
||||||
#endif // BOOST_NO_SFINAE_EXPR
|
|
||||||
|
|
||||||
template<typename F>
|
|
||||||
struct result_of_void_impl
|
|
||||||
{
|
|
||||||
typedef void type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename R>
|
|
||||||
struct result_of_void_impl<R (*)(void)>
|
|
||||||
{
|
|
||||||
typedef R type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename R>
|
|
||||||
struct result_of_void_impl<R (&)(void)>
|
|
||||||
{
|
|
||||||
typedef R type;
|
|
||||||
};
|
|
||||||
|
|
||||||
// Determine the return type of a function pointer or pointer to member.
|
|
||||||
template<typename F, typename FArgs>
|
|
||||||
struct result_of_pointer
|
|
||||||
: tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };
|
|
||||||
|
|
||||||
template<typename F, typename FArgs>
|
|
||||||
struct tr1_result_of_impl<F, FArgs, true>
|
|
||||||
{
|
|
||||||
typedef typename F::result_type type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename FArgs>
|
|
||||||
struct is_function_with_no_args : mpl::false_ {};
|
|
||||||
|
|
||||||
template<typename F>
|
|
||||||
struct is_function_with_no_args<F(void)> : mpl::true_ {};
|
|
||||||
|
|
||||||
template<typename F, typename FArgs>
|
|
||||||
struct result_of_nested_result : F::template result<FArgs>
|
|
||||||
{};
|
|
||||||
|
|
||||||
template<typename F, typename FArgs>
|
|
||||||
struct tr1_result_of_impl<F, FArgs, false>
|
|
||||||
: mpl::if_<is_function_with_no_args<FArgs>,
|
|
||||||
result_of_void_impl<F>,
|
|
||||||
result_of_nested_result<F, FArgs> >::type
|
|
||||||
{};
|
|
||||||
|
|
||||||
} // end namespace detail
|
|
||||||
|
|
||||||
#define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
|
|
||||||
#include BOOST_PP_ITERATE()
|
|
||||||
|
|
||||||
#else
|
|
||||||
# define BOOST_NO_RESULT_OF 1
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // BOOST_RESULT_OF_HPP
|
|
||||||
@@ -1,536 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright (c) Marshall Clow 2012-2015.
|
|
||||||
|
|
||||||
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)
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
|
|
||||||
Based on the StringRef implementation in LLVM (http://llvm.org) and
|
|
||||||
N3422 by Jeffrey Yasskin
|
|
||||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef BOOST_STRING_REF_HPP
|
|
||||||
#define BOOST_STRING_REF_HPP
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <boost/detail/workaround.hpp>
|
|
||||||
#include <boost/utility/string_ref_fwd.hpp>
|
|
||||||
#include <boost/throw_exception.hpp>
|
|
||||||
|
|
||||||
#include <cstddef>
|
|
||||||
#include <stdexcept>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <iterator>
|
|
||||||
#include <string>
|
|
||||||
#include <iosfwd>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
namespace detail {
|
|
||||||
// A helper functor because sometimes we don't have lambdas
|
|
||||||
template <typename charT, typename traits>
|
|
||||||
class string_ref_traits_eq {
|
|
||||||
public:
|
|
||||||
string_ref_traits_eq ( charT ch ) : ch_(ch) {}
|
|
||||||
bool operator () ( charT val ) const { return traits::eq ( ch_, val ); }
|
|
||||||
charT ch_;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
class basic_string_ref {
|
|
||||||
public:
|
|
||||||
// types
|
|
||||||
typedef charT value_type;
|
|
||||||
typedef const charT* pointer;
|
|
||||||
typedef const charT& reference;
|
|
||||||
typedef const charT& const_reference;
|
|
||||||
typedef pointer const_iterator; // impl-defined
|
|
||||||
typedef const_iterator iterator;
|
|
||||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
||||||
typedef const_reverse_iterator reverse_iterator;
|
|
||||||
typedef std::size_t size_type;
|
|
||||||
typedef std::ptrdiff_t difference_type;
|
|
||||||
static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);
|
|
||||||
|
|
||||||
// construct/copy
|
|
||||||
BOOST_CONSTEXPR basic_string_ref ()
|
|
||||||
: ptr_(NULL), len_(0) {}
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR basic_string_ref (const basic_string_ref &rhs)
|
|
||||||
: ptr_(rhs.ptr_), len_(rhs.len_) {}
|
|
||||||
|
|
||||||
basic_string_ref& operator=(const basic_string_ref &rhs) {
|
|
||||||
ptr_ = rhs.ptr_;
|
|
||||||
len_ = rhs.len_;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
basic_string_ref(const charT* str)
|
|
||||||
: ptr_(str), len_(traits::length(str)) {}
|
|
||||||
|
|
||||||
template<typename Allocator>
|
|
||||||
basic_string_ref(const std::basic_string<charT, traits, Allocator>& str)
|
|
||||||
: ptr_(str.data()), len_(str.length()) {}
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len)
|
|
||||||
: ptr_(str), len_(len) {}
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
|
|
||||||
template<typename Allocator>
|
|
||||||
explicit operator std::basic_string<charT, traits, Allocator>() const {
|
|
||||||
return std::basic_string<charT, traits, Allocator> ( begin(), end());
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
std::basic_string<charT, traits> to_string () const {
|
|
||||||
return std::basic_string<charT, traits> ( begin(), end());
|
|
||||||
}
|
|
||||||
|
|
||||||
// iterators
|
|
||||||
BOOST_CONSTEXPR const_iterator begin() const { return ptr_; }
|
|
||||||
BOOST_CONSTEXPR const_iterator cbegin() const { return ptr_; }
|
|
||||||
BOOST_CONSTEXPR const_iterator end() const { return ptr_ + len_; }
|
|
||||||
BOOST_CONSTEXPR const_iterator cend() const { return ptr_ + len_; }
|
|
||||||
const_reverse_iterator rbegin() const { return const_reverse_iterator (end()); }
|
|
||||||
const_reverse_iterator crbegin() const { return const_reverse_iterator (end()); }
|
|
||||||
const_reverse_iterator rend() const { return const_reverse_iterator (begin()); }
|
|
||||||
const_reverse_iterator crend() const { return const_reverse_iterator (begin()); }
|
|
||||||
|
|
||||||
// capacity
|
|
||||||
BOOST_CONSTEXPR size_type size() const { return len_; }
|
|
||||||
BOOST_CONSTEXPR size_type length() const { return len_; }
|
|
||||||
BOOST_CONSTEXPR size_type max_size() const { return len_; }
|
|
||||||
BOOST_CONSTEXPR bool empty() const { return len_ == 0; }
|
|
||||||
|
|
||||||
// element access
|
|
||||||
BOOST_CONSTEXPR const charT& operator[](size_type pos) const { return ptr_[pos]; }
|
|
||||||
|
|
||||||
const charT& at(size_t pos) const {
|
|
||||||
if ( pos >= len_ )
|
|
||||||
BOOST_THROW_EXCEPTION( std::out_of_range ( "boost::string_ref::at" ) );
|
|
||||||
return ptr_[pos];
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR const charT& front() const { return ptr_[0]; }
|
|
||||||
BOOST_CONSTEXPR const charT& back() const { return ptr_[len_-1]; }
|
|
||||||
BOOST_CONSTEXPR const charT* data() const { return ptr_; }
|
|
||||||
|
|
||||||
// modifiers
|
|
||||||
void clear() { len_ = 0; }
|
|
||||||
void remove_prefix(size_type n) {
|
|
||||||
if ( n > len_ )
|
|
||||||
n = len_;
|
|
||||||
ptr_ += n;
|
|
||||||
len_ -= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
void remove_suffix(size_type n) {
|
|
||||||
if ( n > len_ )
|
|
||||||
n = len_;
|
|
||||||
len_ -= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// basic_string_ref string operations
|
|
||||||
basic_string_ref substr(size_type pos, size_type n=npos) const {
|
|
||||||
if ( pos > size())
|
|
||||||
BOOST_THROW_EXCEPTION( std::out_of_range ( "string_ref::substr" ) );
|
|
||||||
if ( n == npos || pos + n > size())
|
|
||||||
n = size () - pos;
|
|
||||||
return basic_string_ref ( data() + pos, n );
|
|
||||||
}
|
|
||||||
|
|
||||||
int compare(basic_string_ref x) const {
|
|
||||||
const int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
|
|
||||||
return cmp != 0 ? cmp : ( len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1 );
|
|
||||||
}
|
|
||||||
|
|
||||||
bool starts_with(charT c) const { return !empty() && traits::eq ( c, front()); }
|
|
||||||
bool starts_with(basic_string_ref x) const {
|
|
||||||
return len_ >= x.len_ && traits::compare ( ptr_, x.ptr_, x.len_ ) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ends_with(charT c) const { return !empty() && traits::eq ( c, back()); }
|
|
||||||
bool ends_with(basic_string_ref x) const {
|
|
||||||
return len_ >= x.len_ && traits::compare ( ptr_ + len_ - x.len_, x.ptr_, x.len_ ) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type find(basic_string_ref s) const {
|
|
||||||
const_iterator iter = std::search ( this->cbegin (), this->cend (),
|
|
||||||
s.cbegin (), s.cend (), traits::eq );
|
|
||||||
return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type find(charT c) const {
|
|
||||||
const_iterator iter = std::find_if ( this->cbegin (), this->cend (),
|
|
||||||
detail::string_ref_traits_eq<charT, traits> ( c ));
|
|
||||||
return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type rfind(basic_string_ref s) const {
|
|
||||||
const_reverse_iterator iter = std::search ( this->crbegin (), this->crend (),
|
|
||||||
s.crbegin (), s.crend (), traits::eq );
|
|
||||||
return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type rfind(charT c) const {
|
|
||||||
const_reverse_iterator iter = std::find_if ( this->crbegin (), this->crend (),
|
|
||||||
detail::string_ref_traits_eq<charT, traits> ( c ));
|
|
||||||
return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type find_first_of(charT c) const { return find (c); }
|
|
||||||
size_type find_last_of (charT c) const { return rfind (c); }
|
|
||||||
|
|
||||||
size_type find_first_of(basic_string_ref s) const {
|
|
||||||
const_iterator iter = std::find_first_of
|
|
||||||
( this->cbegin (), this->cend (), s.cbegin (), s.cend (), traits::eq );
|
|
||||||
return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type find_last_of(basic_string_ref s) const {
|
|
||||||
const_reverse_iterator iter = std::find_first_of
|
|
||||||
( this->crbegin (), this->crend (), s.cbegin (), s.cend (), traits::eq );
|
|
||||||
return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type find_first_not_of(basic_string_ref s) const {
|
|
||||||
const_iterator iter = find_not_of ( this->cbegin (), this->cend (), s );
|
|
||||||
return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type find_first_not_of(charT c) const {
|
|
||||||
for ( const_iterator iter = this->cbegin (); iter != this->cend (); ++iter )
|
|
||||||
if ( !traits::eq ( c, *iter ))
|
|
||||||
return std::distance ( this->cbegin (), iter );
|
|
||||||
return npos;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type find_last_not_of(basic_string_ref s) const {
|
|
||||||
const_reverse_iterator iter = find_not_of ( this->crbegin (), this->crend (), s );
|
|
||||||
return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type find_last_not_of(charT c) const {
|
|
||||||
for ( const_reverse_iterator iter = this->crbegin (); iter != this->crend (); ++iter )
|
|
||||||
if ( !traits::eq ( c, *iter ))
|
|
||||||
return reverse_distance ( this->crbegin (), iter );
|
|
||||||
return npos;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
template <typename r_iter>
|
|
||||||
size_type reverse_distance ( r_iter first, r_iter last ) const {
|
|
||||||
return len_ - 1 - std::distance ( first, last );
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename Iterator>
|
|
||||||
Iterator find_not_of ( Iterator first, Iterator last, basic_string_ref s ) const {
|
|
||||||
for ( ; first != last ; ++first )
|
|
||||||
if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
|
|
||||||
return first;
|
|
||||||
return last;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
const charT *ptr_;
|
|
||||||
std::size_t len_;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
// Comparison operators
|
|
||||||
// Equality
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator==(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
|
|
||||||
if ( x.size () != y.size ()) return false;
|
|
||||||
return x.compare(y) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator==(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
|
|
||||||
return x == basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator==(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) == y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator==(basic_string_ref<charT, traits> x, const charT * y) {
|
|
||||||
return x == basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator==(const charT * x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) == y;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Inequality
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator!=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
|
|
||||||
if ( x.size () != y.size ()) return true;
|
|
||||||
return x.compare(y) != 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator!=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
|
|
||||||
return x != basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) != y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator!=(basic_string_ref<charT, traits> x, const charT * y) {
|
|
||||||
return x != basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator!=(const charT * x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) != y;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Less than
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
|
|
||||||
return x.compare(y) < 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator<(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
|
|
||||||
return x < basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator<(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) < y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<(basic_string_ref<charT, traits> x, const charT * y) {
|
|
||||||
return x < basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<(const charT * x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) < y;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Greater than
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
|
|
||||||
return x.compare(y) > 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator>(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
|
|
||||||
return x > basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator>(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) > y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>(basic_string_ref<charT, traits> x, const charT * y) {
|
|
||||||
return x > basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>(const charT * x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) > y;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Less than or equal to
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
|
|
||||||
return x.compare(y) <= 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator<=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
|
|
||||||
return x <= basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) <= y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<=(basic_string_ref<charT, traits> x, const charT * y) {
|
|
||||||
return x <= basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<=(const charT * x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) <= y;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Greater than or equal to
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>=(basic_string_ref<charT, traits> x, basic_string_ref<charT, traits> y) {
|
|
||||||
return x.compare(y) >= 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator>=(basic_string_ref<charT, traits> x, const std::basic_string<charT, traits, Allocator> & y) {
|
|
||||||
return x >= basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) >= y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>=(basic_string_ref<charT, traits> x, const charT * y) {
|
|
||||||
return x >= basic_string_ref<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>=(const charT * x, basic_string_ref<charT, traits> y) {
|
|
||||||
return basic_string_ref<charT, traits>(x) >= y;
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace detail {
|
|
||||||
|
|
||||||
template<class charT, class traits>
|
|
||||||
inline void insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
|
|
||||||
enum { chunk_size = 8 };
|
|
||||||
charT fill_chars[chunk_size];
|
|
||||||
std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
|
|
||||||
for (; n >= chunk_size && os.good(); n -= chunk_size)
|
|
||||||
os.write(fill_chars, static_cast< std::size_t >(chunk_size));
|
|
||||||
if (n > 0 && os.good())
|
|
||||||
os.write(fill_chars, n);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class charT, class traits>
|
|
||||||
void insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
|
|
||||||
const std::size_t size = str.size();
|
|
||||||
const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
|
|
||||||
const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
|
|
||||||
if (!align_left) {
|
|
||||||
detail::insert_fill_chars(os, alignment_size);
|
|
||||||
if (os.good())
|
|
||||||
os.write(str.data(), size);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
os.write(str.data(), size);
|
|
||||||
if (os.good())
|
|
||||||
detail::insert_fill_chars(os, alignment_size);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace detail
|
|
||||||
|
|
||||||
// Inserter
|
|
||||||
template<class charT, class traits>
|
|
||||||
inline std::basic_ostream<charT, traits>&
|
|
||||||
operator<<(std::basic_ostream<charT, traits>& os, const basic_string_ref<charT,traits>& str) {
|
|
||||||
if (os.good()) {
|
|
||||||
const std::size_t size = str.size();
|
|
||||||
const std::size_t w = static_cast< std::size_t >(os.width());
|
|
||||||
if (w <= size)
|
|
||||||
os.write(str.data(), size);
|
|
||||||
else
|
|
||||||
detail::insert_aligned(os, str);
|
|
||||||
os.width(0);
|
|
||||||
}
|
|
||||||
return os;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
// numeric conversions
|
|
||||||
//
|
|
||||||
// These are short-term implementations.
|
|
||||||
// In a production environment, I would rather avoid the copying.
|
|
||||||
//
|
|
||||||
inline int stoi (string_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoi ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long stol (string_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stol ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline unsigned long stoul (string_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoul ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long long stoll (string_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoll ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline unsigned long long stoull (string_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoull ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline float stof (string_ref str, size_t* idx=0) {
|
|
||||||
return std::stof ( std::string(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline double stod (string_ref str, size_t* idx=0) {
|
|
||||||
return std::stod ( std::string(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long double stold (string_ref str, size_t* idx=0) {
|
|
||||||
return std::stold ( std::string(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline int stoi (wstring_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoi ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long stol (wstring_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stol ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline unsigned long stoul (wstring_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoul ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long long stoll (wstring_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoll ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline unsigned long long stoull (wstring_ref str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoull ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline float stof (wstring_ref str, size_t* idx=0) {
|
|
||||||
return std::stof ( std::wstring(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline double stod (wstring_ref str, size_t* idx=0) {
|
|
||||||
return std::stod ( std::wstring(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long double stold (wstring_ref str, size_t* idx=0) {
|
|
||||||
return std::stold ( std::wstring(str), idx );
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
namespace std {
|
|
||||||
// Hashing
|
|
||||||
template<> struct hash<boost::string_ref>;
|
|
||||||
template<> struct hash<boost::u16string_ref>;
|
|
||||||
template<> struct hash<boost::u32string_ref>;
|
|
||||||
template<> struct hash<boost::wstring_ref>;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,37 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright (c) Marshall Clow 2012-2012.
|
|
||||||
|
|
||||||
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)
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
|
|
||||||
Based on the StringRef implementation in LLVM (http://llvm.org) and
|
|
||||||
N3422 by Jeffrey Yasskin
|
|
||||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef BOOST_STRING_REF_FWD_HPP
|
|
||||||
#define BOOST_STRING_REF_FWD_HPP
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
template<typename charT, typename traits = std::char_traits<charT> > class basic_string_ref;
|
|
||||||
typedef basic_string_ref<char, std::char_traits<char> > string_ref;
|
|
||||||
typedef basic_string_ref<wchar_t, std::char_traits<wchar_t> > wstring_ref;
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_CHAR16_T
|
|
||||||
typedef basic_string_ref<char16_t, std::char_traits<char16_t> > u16string_ref;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_CHAR32_T
|
|
||||||
typedef basic_string_ref<char32_t, std::char_traits<char32_t> > u32string_ref;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,666 +0,0 @@
|
|||||||
/*
|
|
||||||
<20> Copyright (c) Marshall Clow 2012-2015.
|
|
||||||
<20> Copyright Beman Dawes 2015
|
|
||||||
|
|
||||||
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)
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
|
|
||||||
Based on the StringRef implementation in LLVM (http://llvm.org) and
|
|
||||||
N3422 by Jeffrey Yasskin
|
|
||||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
|
|
||||||
Updated July 2015 to reflect the Library Fundamentals TS
|
|
||||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef BOOST_STRING_VIEW_HPP
|
|
||||||
#define BOOST_STRING_VIEW_HPP
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <boost/detail/workaround.hpp>
|
|
||||||
#include <boost/utility/string_view_fwd.hpp>
|
|
||||||
#include <boost/throw_exception.hpp>
|
|
||||||
|
|
||||||
#include <cstddef>
|
|
||||||
#include <stdexcept>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <iterator>
|
|
||||||
#include <string>
|
|
||||||
#include <cstring>
|
|
||||||
#include <iosfwd>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
namespace detail {
|
|
||||||
// A helper functor because sometimes we don't have lambdas
|
|
||||||
template <typename charT, typename traits>
|
|
||||||
class string_view_traits_eq {
|
|
||||||
public:
|
|
||||||
string_view_traits_eq ( charT ch ) : ch_(ch) {}
|
|
||||||
bool operator () ( charT val ) const { return traits::eq ( ch_, val ); }
|
|
||||||
charT ch_;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits> // traits defaulted in string_view_fwd.hpp
|
|
||||||
class basic_string_view {
|
|
||||||
public:
|
|
||||||
// types
|
|
||||||
typedef traits traits_type;
|
|
||||||
typedef charT value_type;
|
|
||||||
typedef charT* pointer;
|
|
||||||
typedef const charT* const_pointer;
|
|
||||||
typedef charT& reference;
|
|
||||||
typedef const charT& const_reference;
|
|
||||||
typedef const_pointer const_iterator; // impl-defined
|
|
||||||
typedef const_iterator iterator;
|
|
||||||
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
|
|
||||||
typedef const_reverse_iterator reverse_iterator;
|
|
||||||
typedef std::size_t size_type;
|
|
||||||
typedef std::ptrdiff_t difference_type;
|
|
||||||
static BOOST_CONSTEXPR_OR_CONST size_type npos = size_type(-1);
|
|
||||||
|
|
||||||
// construct/copy
|
|
||||||
BOOST_CONSTEXPR basic_string_view() BOOST_NOEXCEPT
|
|
||||||
: ptr_(NULL), len_(0) {}
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR basic_string_view(const basic_string_view &rhs) BOOST_NOEXCEPT
|
|
||||||
: ptr_(rhs.ptr_), len_(rhs.len_) {}
|
|
||||||
|
|
||||||
basic_string_view& operator=(const basic_string_view &rhs) BOOST_NOEXCEPT {
|
|
||||||
ptr_ = rhs.ptr_;
|
|
||||||
len_ = rhs.len_;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename Allocator>
|
|
||||||
basic_string_view(const std::basic_string<charT, traits,
|
|
||||||
Allocator>& str) BOOST_NOEXCEPT
|
|
||||||
: ptr_(str.data()), len_(str.length()) {}
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR basic_string_view(const charT* str)
|
|
||||||
: ptr_(str), len_(traits::length(str)) {}
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR basic_string_view(const charT* str, size_type len)
|
|
||||||
: ptr_(str), len_(len) {}
|
|
||||||
|
|
||||||
// iterators
|
|
||||||
BOOST_CONSTEXPR const_iterator begin() const BOOST_NOEXCEPT { return ptr_; }
|
|
||||||
BOOST_CONSTEXPR const_iterator cbegin() const BOOST_NOEXCEPT { return ptr_; }
|
|
||||||
BOOST_CONSTEXPR const_iterator end() const BOOST_NOEXCEPT { return ptr_ + len_; }
|
|
||||||
BOOST_CONSTEXPR const_iterator cend() const BOOST_NOEXCEPT { return ptr_ + len_; }
|
|
||||||
const_reverse_iterator rbegin() const BOOST_NOEXCEPT { return const_reverse_iterator (end()); }
|
|
||||||
const_reverse_iterator crbegin() const BOOST_NOEXCEPT { return const_reverse_iterator (end()); }
|
|
||||||
const_reverse_iterator rend() const BOOST_NOEXCEPT { return const_reverse_iterator (begin()); }
|
|
||||||
const_reverse_iterator crend() const BOOST_NOEXCEPT { return const_reverse_iterator (begin()); }
|
|
||||||
|
|
||||||
// capacity
|
|
||||||
BOOST_CONSTEXPR size_type size() const BOOST_NOEXCEPT { return len_; }
|
|
||||||
BOOST_CONSTEXPR size_type length() const BOOST_NOEXCEPT { return len_; }
|
|
||||||
BOOST_CONSTEXPR size_type max_size() const BOOST_NOEXCEPT { return len_; }
|
|
||||||
BOOST_CONSTEXPR bool empty() const BOOST_NOEXCEPT { return len_ == 0; }
|
|
||||||
|
|
||||||
// element access
|
|
||||||
BOOST_CONSTEXPR const_reference operator[](size_type pos) const { return ptr_[pos]; }
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR const_reference at(size_t pos) const {
|
|
||||||
if ( pos >= len_ )
|
|
||||||
BOOST_THROW_EXCEPTION( std::out_of_range ( "boost::string_view::at" ) );
|
|
||||||
return ptr_[pos];
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR const_reference front() const { return ptr_[0]; }
|
|
||||||
BOOST_CONSTEXPR const_reference back() const { return ptr_[len_-1]; }
|
|
||||||
BOOST_CONSTEXPR const_pointer data() const BOOST_NOEXCEPT { return ptr_; }
|
|
||||||
|
|
||||||
// modifiers
|
|
||||||
void clear() BOOST_NOEXCEPT { len_ = 0; } // Boost extension
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR void remove_prefix(size_type n) {
|
|
||||||
if ( n > len_ )
|
|
||||||
n = len_;
|
|
||||||
ptr_ += n;
|
|
||||||
len_ -= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR void remove_suffix(size_type n) {
|
|
||||||
if ( n > len_ )
|
|
||||||
n = len_;
|
|
||||||
len_ -= n;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR void swap(basic_string_view& s) BOOST_NOEXCEPT {
|
|
||||||
std::swap(ptr_, s.ptr_);
|
|
||||||
std::swap(len_, s.len_);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// basic_string_view string operations
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
|
|
||||||
template<typename Allocator>
|
|
||||||
explicit operator std::basic_string<charT, traits, Allocator>() const {
|
|
||||||
return std::basic_string<charT, traits, Allocator>(begin(), end());
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
|
|
||||||
template<typename Allocator = std::allocator<charT> >
|
|
||||||
std::basic_string<charT, traits> to_string(const Allocator& a = Allocator()) const {
|
|
||||||
return std::basic_string<charT, traits, Allocator>(begin(), end(), a);
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
std::basic_string<charT, traits> to_string() const {
|
|
||||||
return std::basic_string<charT, traits>(begin(), end());
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
size_type copy( charT* s, size_type n, size_type pos = 0 ) const {
|
|
||||||
if ( pos > size())
|
|
||||||
BOOST_THROW_EXCEPTION( std::out_of_range ( "string_view::copy" ) );
|
|
||||||
size_type rlen = (std::min)(n, len_ - pos);
|
|
||||||
// use std::copy(begin() + pos, begin() + pos + rlen, s) rather than
|
|
||||||
// std::copy_n(begin() + pos, rlen, s) to support pre-C++11 standard libraries
|
|
||||||
std::copy(begin() + pos, begin() + pos + rlen, s);
|
|
||||||
return rlen;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR basic_string_view substr(size_type pos, size_type n=npos) const {
|
|
||||||
if ( pos > size())
|
|
||||||
BOOST_THROW_EXCEPTION( std::out_of_range ( "string_view::substr" ) );
|
|
||||||
if ( n == npos || pos + n > size())
|
|
||||||
n = size () - pos;
|
|
||||||
return basic_string_view ( data() + pos, n );
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CXX14_CONSTEXPR int compare(basic_string_view x) const BOOST_NOEXCEPT {
|
|
||||||
const int cmp = traits::compare ( ptr_, x.ptr_, (std::min)(len_, x.len_));
|
|
||||||
return cmp != 0 ? cmp : ( len_ == x.len_ ? 0 : len_ < x.len_ ? -1 : 1 );
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1, basic_string_view x)
|
|
||||||
const BOOST_NOEXCEPT {
|
|
||||||
return substr(pos1, n1).compare(x);
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1,
|
|
||||||
basic_string_view x, size_type pos2, size_type n2) const {
|
|
||||||
return substr(pos1, n1).compare(x.substr(pos2, n2));
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR int compare(const charT* x) const {
|
|
||||||
return compare(basic_string_view(x));
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1, const charT* x) const {
|
|
||||||
return substr(pos1, n1).compare(basic_string_view(x));
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR int compare(size_type pos1, size_type n1,
|
|
||||||
const charT* x, size_type n2) const {
|
|
||||||
return substr(pos1, n1).compare(basic_string_view(x, n2));
|
|
||||||
}
|
|
||||||
|
|
||||||
// Searches
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR bool starts_with(charT c) const { // Boost extension
|
|
||||||
return !empty() && traits::eq ( c, front());
|
|
||||||
}
|
|
||||||
BOOST_CONSTEXPR bool starts_with(basic_string_view x) const { // Boost extension
|
|
||||||
return len_ >= x.len_ && traits::compare ( ptr_, x.ptr_, x.len_ ) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CONSTEXPR bool ends_with(charT c) const {
|
|
||||||
return !empty() && traits::eq ( c, back()); // Boost extension
|
|
||||||
}
|
|
||||||
BOOST_CONSTEXPR bool ends_with(basic_string_view x) const { // Boost extension
|
|
||||||
return len_ >= x.len_ && traits::compare ( ptr_ + len_ - x.len_,
|
|
||||||
x.ptr_, x.len_ ) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// find
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
|
|
||||||
if (pos > size())
|
|
||||||
return npos;
|
|
||||||
if (s.empty())
|
|
||||||
return pos;
|
|
||||||
const_iterator iter = std::search(this->cbegin() + pos, this->cend(),
|
|
||||||
s.cbegin (), s.cend (), traits::eq );
|
|
||||||
return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find(charT c, size_type pos = 0) const BOOST_NOEXCEPT
|
|
||||||
{ return find(basic_string_view(&c, 1), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find(const charT* s, size_type pos, size_type n) const
|
|
||||||
{ return find(basic_string_view(s, n), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find(const charT* s, size_type pos = 0) const
|
|
||||||
{ return find(basic_string_view(s), pos); }
|
|
||||||
|
|
||||||
// rfind
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type rfind(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
|
|
||||||
if (len_ < s.len_)
|
|
||||||
return npos;
|
|
||||||
if (pos > len_ - s.len_)
|
|
||||||
pos = len_ - s.len_;
|
|
||||||
if (s.len_ == 0u) // an empty string is always found
|
|
||||||
return pos;
|
|
||||||
for (const charT* cur = ptr_ + pos;; --cur) {
|
|
||||||
if (traits::compare(cur, s.ptr_, s.len_) == 0)
|
|
||||||
return cur - ptr_;
|
|
||||||
if (cur == ptr_)
|
|
||||||
return npos;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type rfind(charT c, size_type pos = npos) const BOOST_NOEXCEPT
|
|
||||||
{ return rfind(basic_string_view(&c, 1), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type rfind(const charT* s, size_type pos, size_type n) const
|
|
||||||
{ return rfind(basic_string_view(s, n), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type rfind(const charT* s, size_type pos = npos) const
|
|
||||||
{ return rfind(basic_string_view(s), pos); }
|
|
||||||
|
|
||||||
// find_first_of
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_of(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
|
|
||||||
if (pos >= len_ || s.len_ == 0)
|
|
||||||
return npos;
|
|
||||||
const_iterator iter = std::find_first_of
|
|
||||||
(this->cbegin () + pos, this->cend (), s.cbegin (), s.cend (), traits::eq);
|
|
||||||
return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_of(charT c, size_type pos = 0) const BOOST_NOEXCEPT
|
|
||||||
{ return find_first_of(basic_string_view(&c, 1), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_of(const charT* s, size_type pos, size_type n) const
|
|
||||||
{ return find_first_of(basic_string_view(s, n), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_of(const charT* s, size_type pos = 0) const
|
|
||||||
{ return find_first_of(basic_string_view(s), pos); }
|
|
||||||
|
|
||||||
// find_last_of
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
|
|
||||||
if (s.len_ == 0u)
|
|
||||||
return npos;
|
|
||||||
if (pos >= len_)
|
|
||||||
pos = 0;
|
|
||||||
else
|
|
||||||
pos = len_ - (pos+1);
|
|
||||||
const_reverse_iterator iter = std::find_first_of
|
|
||||||
( this->crbegin () + pos, this->crend (), s.cbegin (), s.cend (), traits::eq );
|
|
||||||
return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter);
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_of(charT c, size_type pos = npos) const BOOST_NOEXCEPT
|
|
||||||
{ return find_last_of(basic_string_view(&c, 1), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_of(const charT* s, size_type pos, size_type n) const
|
|
||||||
{ return find_last_of(basic_string_view(s, n), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_of(const charT* s, size_type pos = npos) const
|
|
||||||
{ return find_last_of(basic_string_view(s), pos); }
|
|
||||||
|
|
||||||
// find_first_not_of
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_not_of(basic_string_view s, size_type pos = 0) const BOOST_NOEXCEPT {
|
|
||||||
if (pos >= len_)
|
|
||||||
return npos;
|
|
||||||
if (s.len_ == 0)
|
|
||||||
return pos;
|
|
||||||
const_iterator iter = find_not_of ( this->cbegin () + pos, this->cend (), s );
|
|
||||||
return iter == this->cend () ? npos : std::distance ( this->cbegin (), iter );
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_not_of(charT c, size_type pos = 0) const BOOST_NOEXCEPT
|
|
||||||
{ return find_first_not_of(basic_string_view(&c, 1), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_not_of(const charT* s, size_type pos, size_type n) const
|
|
||||||
{ return find_first_not_of(basic_string_view(s, n), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_first_not_of(const charT* s, size_type pos = 0) const
|
|
||||||
{ return find_first_not_of(basic_string_view(s), pos); }
|
|
||||||
|
|
||||||
// find_last_not_of
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_not_of(basic_string_view s, size_type pos = npos) const BOOST_NOEXCEPT {
|
|
||||||
if (pos >= len_)
|
|
||||||
pos = len_ - 1;;
|
|
||||||
if (s.len_ == 0u)
|
|
||||||
return pos;
|
|
||||||
pos = len_ - (pos+1);
|
|
||||||
const_reverse_iterator iter = find_not_of ( this->crbegin () + pos, this->crend (), s );
|
|
||||||
return iter == this->crend () ? npos : reverse_distance ( this->crbegin (), iter );
|
|
||||||
}
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_not_of(charT c, size_type pos = npos) const BOOST_NOEXCEPT
|
|
||||||
{ return find_last_not_of(basic_string_view(&c, 1), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_not_of(const charT* s, size_type pos, size_type n) const
|
|
||||||
{ return find_last_not_of(basic_string_view(s, n), pos); }
|
|
||||||
BOOST_CXX14_CONSTEXPR size_type find_last_not_of(const charT* s, size_type pos = npos) const
|
|
||||||
{ return find_last_not_of(basic_string_view(s), pos); }
|
|
||||||
|
|
||||||
private:
|
|
||||||
template <typename r_iter>
|
|
||||||
size_type reverse_distance ( r_iter first, r_iter last ) const {
|
|
||||||
return len_ - 1 - std::distance ( first, last );
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename Iterator>
|
|
||||||
Iterator find_not_of ( Iterator first, Iterator last, basic_string_view s ) const {
|
|
||||||
for ( ; first != last ; ++first )
|
|
||||||
if ( 0 == traits::find ( s.ptr_, s.len_, *first ))
|
|
||||||
return first;
|
|
||||||
return last;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
const charT *ptr_;
|
|
||||||
std::size_t len_;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
// Comparison operators
|
|
||||||
// Equality
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator==(basic_string_view<charT, traits> x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
if ( x.size () != y.size ()) return false;
|
|
||||||
return x.compare(y) == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Inequality
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator!=(basic_string_view<charT, traits> x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
if ( x.size () != y.size ()) return true;
|
|
||||||
return x.compare(y) != 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Less than
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<(basic_string_view<charT, traits> x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return x.compare(y) < 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Greater than
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>(basic_string_view<charT, traits> x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return x.compare(y) > 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Less than or equal to
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<=(basic_string_view<charT, traits> x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return x.compare(y) <= 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Greater than or equal to
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>=(basic_string_view<charT, traits> x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return x.compare(y) >= 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
// "sufficient additional overloads of comparison functions"
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator==(basic_string_view<charT, traits> x,
|
|
||||||
const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
|
|
||||||
return x == basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator==(const std::basic_string<charT, traits, Allocator> & x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) == y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator==(basic_string_view<charT, traits> x,
|
|
||||||
const charT * y) BOOST_NOEXCEPT {
|
|
||||||
return x == basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator==(const charT * x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) == y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator!=(basic_string_view<charT, traits> x,
|
|
||||||
const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
|
|
||||||
return x != basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) != y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator!=(basic_string_view<charT, traits> x,
|
|
||||||
const charT * y) BOOST_NOEXCEPT {
|
|
||||||
return x != basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator!=(const charT * x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) != y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator<(basic_string_view<charT, traits> x,
|
|
||||||
const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
|
|
||||||
return x < basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator<(const std::basic_string<charT, traits, Allocator> & x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) < y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<(basic_string_view<charT, traits> x,
|
|
||||||
const charT * y) BOOST_NOEXCEPT {
|
|
||||||
return x < basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<(const charT * x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) < y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator>(basic_string_view<charT, traits> x,
|
|
||||||
const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
|
|
||||||
return x > basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator>(const std::basic_string<charT, traits, Allocator> & x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) > y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>(basic_string_view<charT, traits> x,
|
|
||||||
const charT * y) BOOST_NOEXCEPT {
|
|
||||||
return x > basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>(const charT * x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) > y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator<=(basic_string_view<charT, traits> x,
|
|
||||||
const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
|
|
||||||
return x <= basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) <= y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<=(basic_string_view<charT, traits> x,
|
|
||||||
const charT * y) BOOST_NOEXCEPT {
|
|
||||||
return x <= basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator<=(const charT * x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) <= y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator>=(basic_string_view<charT, traits> x,
|
|
||||||
const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
|
|
||||||
return x >= basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits, typename Allocator>
|
|
||||||
inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) >= y;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>=(basic_string_view<charT, traits> x,
|
|
||||||
const charT * y) BOOST_NOEXCEPT {
|
|
||||||
return x >= basic_string_view<charT, traits>(y);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename charT, typename traits>
|
|
||||||
inline bool operator>=(const charT * x,
|
|
||||||
basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
|
|
||||||
return basic_string_view<charT, traits>(x) >= y;
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace detail {
|
|
||||||
|
|
||||||
template<class charT, class traits>
|
|
||||||
inline void insert_fill_chars(std::basic_ostream<charT, traits>& os, std::size_t n) {
|
|
||||||
enum { chunk_size = 8 };
|
|
||||||
charT fill_chars[chunk_size];
|
|
||||||
std::fill_n(fill_chars, static_cast< std::size_t >(chunk_size), os.fill());
|
|
||||||
for (; n >= chunk_size && os.good(); n -= chunk_size)
|
|
||||||
os.write(fill_chars, static_cast< std::size_t >(chunk_size));
|
|
||||||
if (n > 0 && os.good())
|
|
||||||
os.write(fill_chars, n);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class charT, class traits>
|
|
||||||
void insert_aligned(std::basic_ostream<charT, traits>& os, const basic_string_view<charT,traits>& str) {
|
|
||||||
const std::size_t size = str.size();
|
|
||||||
const std::size_t alignment_size = static_cast< std::size_t >(os.width()) - size;
|
|
||||||
const bool align_left = (os.flags() & std::basic_ostream<charT, traits>::adjustfield) == std::basic_ostream<charT, traits>::left;
|
|
||||||
if (!align_left) {
|
|
||||||
detail::insert_fill_chars(os, alignment_size);
|
|
||||||
if (os.good())
|
|
||||||
os.write(str.data(), size);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
os.write(str.data(), size);
|
|
||||||
if (os.good())
|
|
||||||
detail::insert_fill_chars(os, alignment_size);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace detail
|
|
||||||
|
|
||||||
// Inserter
|
|
||||||
template<class charT, class traits>
|
|
||||||
inline std::basic_ostream<charT, traits>&
|
|
||||||
operator<<(std::basic_ostream<charT, traits>& os,
|
|
||||||
const basic_string_view<charT,traits>& str) {
|
|
||||||
if (os.good()) {
|
|
||||||
const std::size_t size = str.size();
|
|
||||||
const std::size_t w = static_cast< std::size_t >(os.width());
|
|
||||||
if (w <= size)
|
|
||||||
os.write(str.data(), size);
|
|
||||||
else
|
|
||||||
detail::insert_aligned(os, str);
|
|
||||||
os.width(0);
|
|
||||||
}
|
|
||||||
return os;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
// numeric conversions
|
|
||||||
//
|
|
||||||
// These are short-term implementations.
|
|
||||||
// In a production environment, I would rather avoid the copying.
|
|
||||||
//
|
|
||||||
inline int stoi (string_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoi ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long stol (string_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stol ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline unsigned long stoul (string_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoul ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long long stoll (string_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoll ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline unsigned long long stoull (string_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoull ( std::string(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline float stof (string_view str, size_t* idx=0) {
|
|
||||||
return std::stof ( std::string(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline double stod (string_view str, size_t* idx=0) {
|
|
||||||
return std::stod ( std::string(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long double stold (string_view str, size_t* idx=0) {
|
|
||||||
return std::stold ( std::string(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline int stoi (wstring_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoi ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long stol (wstring_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stol ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline unsigned long stoul (wstring_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoul ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long long stoll (wstring_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoll ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline unsigned long long stoull (wstring_view str, size_t* idx=0, int base=10) {
|
|
||||||
return std::stoull ( std::wstring(str), idx, base );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline float stof (wstring_view str, size_t* idx=0) {
|
|
||||||
return std::stof ( std::wstring(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline double stod (wstring_view str, size_t* idx=0) {
|
|
||||||
return std::stod ( std::wstring(str), idx );
|
|
||||||
}
|
|
||||||
|
|
||||||
inline long double stold (wstring_view str, size_t* idx=0) {
|
|
||||||
return std::stold ( std::wstring(str), idx );
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
namespace std {
|
|
||||||
// Hashing
|
|
||||||
template<> struct hash<boost::string_view>;
|
|
||||||
template<> struct hash<boost::u16string_view>;
|
|
||||||
template<> struct hash<boost::u32string_view>;
|
|
||||||
template<> struct hash<boost::wstring_view>;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,39 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright (c) Marshall Clow 2012-2012.
|
|
||||||
|
|
||||||
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)
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
|
|
||||||
Based on the StringRef implementation in LLVM (http://llvm.org) and
|
|
||||||
N3422 by Jeffrey Yasskin
|
|
||||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3442.html
|
|
||||||
Updated July 2015 to reflect the Library Fundamentals TS
|
|
||||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4480.html
|
|
||||||
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef BOOST_STRING_VIEW_FWD_HPP
|
|
||||||
#define BOOST_STRING_VIEW_FWD_HPP
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
template<typename charT, typename traits = std::char_traits<charT> > class basic_string_view;
|
|
||||||
typedef basic_string_view<char, std::char_traits<char> > string_view;
|
|
||||||
typedef basic_string_view<wchar_t, std::char_traits<wchar_t> > wstring_view;
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_CHAR16_T
|
|
||||||
typedef basic_string_view<char16_t, std::char_traits<char16_t> > u16string_view;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_CHAR32_T
|
|
||||||
typedef basic_string_view<char32_t, std::char_traits<char32_t> > u32string_view;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@@ -1,77 +0,0 @@
|
|||||||
// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
|
|
||||||
// Copyright (C) 2007, Tobias Schwinger.
|
|
||||||
//
|
|
||||||
// Use, modification, and distribution is subject to 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)
|
|
||||||
//
|
|
||||||
// See http://www.boost.org/libs/optional for documentation.
|
|
||||||
//
|
|
||||||
// You are welcome to contact the author at:
|
|
||||||
// fernando_cacciola@hotmail.com
|
|
||||||
//
|
|
||||||
#ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
|
|
||||||
#ifndef BOOST_PP_IS_ITERATING
|
|
||||||
|
|
||||||
#include <boost/utility/detail/in_place_factory_prefix.hpp>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
class typed_in_place_factory_base {} ;
|
|
||||||
|
|
||||||
#define BOOST_PP_ITERATION_LIMITS (0, BOOST_MAX_INPLACE_FACTORY_ARITY)
|
|
||||||
#define BOOST_PP_FILENAME_1 <boost/utility/typed_in_place_factory.hpp>
|
|
||||||
#include BOOST_PP_ITERATE()
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#include <boost/utility/detail/in_place_factory_suffix.hpp>
|
|
||||||
|
|
||||||
#define BOOST_UTILITY_TYPED_INPLACE_FACTORY_04APR2007_HPP
|
|
||||||
#else
|
|
||||||
#define N BOOST_PP_ITERATION()
|
|
||||||
|
|
||||||
template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N,class A) >
|
|
||||||
class BOOST_PP_CAT(typed_in_place_factory,N)
|
|
||||||
:
|
|
||||||
public typed_in_place_factory_base
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
|
|
||||||
typedef T value_type;
|
|
||||||
|
|
||||||
explicit BOOST_PP_CAT(typed_in_place_factory,N)
|
|
||||||
( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
|
|
||||||
#if N > 0
|
|
||||||
: BOOST_PP_ENUM(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _)
|
|
||||||
#endif
|
|
||||||
{}
|
|
||||||
|
|
||||||
void* apply (void* address) const
|
|
||||||
{
|
|
||||||
return new(address) T( BOOST_PP_ENUM_PARAMS(N, m_a) );
|
|
||||||
}
|
|
||||||
|
|
||||||
void* apply (void* address, std::size_t n) const
|
|
||||||
{
|
|
||||||
for(void* next = address = this->apply(address); !! --n;)
|
|
||||||
this->apply(next = static_cast<char *>(next) + sizeof(T));
|
|
||||||
return address;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_PP_REPEAT(N, BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _)
|
|
||||||
};
|
|
||||||
|
|
||||||
template< class T BOOST_PP_ENUM_TRAILING_PARAMS(N, class A) >
|
|
||||||
inline BOOST_PP_CAT(typed_in_place_factory,N)<
|
|
||||||
T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >
|
|
||||||
in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
|
|
||||||
{
|
|
||||||
return BOOST_PP_CAT(typed_in_place_factory,N)<
|
|
||||||
T BOOST_PP_ENUM_TRAILING_PARAMS(N, A) >( BOOST_PP_ENUM_PARAMS(N, a) );
|
|
||||||
}
|
|
||||||
|
|
||||||
#undef N
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@@ -1,281 +0,0 @@
|
|||||||
// (C) Copyright 2002-2008, Fernando Luis Cacciola Carballal.
|
|
||||||
//
|
|
||||||
// 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)
|
|
||||||
//
|
|
||||||
// 21 Ago 2002 (Created) Fernando Cacciola
|
|
||||||
// 24 Dec 2007 (Refactored and worked around various compiler bugs) Fernando Cacciola, Niels Dekker
|
|
||||||
// 23 May 2008 (Fixed operator= const issue, added initialized_value) Niels Dekker, Fernando Cacciola
|
|
||||||
// 21 Ago 2008 (Added swap) Niels Dekker, Fernando Cacciola
|
|
||||||
// 20 Feb 2009 (Fixed logical const-ness issues) Niels Dekker, Fernando Cacciola
|
|
||||||
// 03 Apr 2010 (Added initialized<T>, suggested by Jeffrey Hellrung, fixing #3472) Niels Dekker
|
|
||||||
// 30 May 2010 (Made memset call conditional, fixing #3869) Niels Dekker
|
|
||||||
//
|
|
||||||
#ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
|
|
||||||
#define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP
|
|
||||||
|
|
||||||
// Note: The implementation of boost::value_initialized had to deal with the
|
|
||||||
// fact that various compilers haven't fully implemented value-initialization.
|
|
||||||
// The constructor of boost::value_initialized<T> works around these compiler
|
|
||||||
// issues, by clearing the bytes of T, before constructing the T object it
|
|
||||||
// contains. More details on these issues are at libs/utility/value_init.htm
|
|
||||||
|
|
||||||
#include <boost/aligned_storage.hpp>
|
|
||||||
#include <boost/config.hpp> // For BOOST_NO_COMPLETE_VALUE_INITIALIZATION.
|
|
||||||
#include <boost/detail/workaround.hpp>
|
|
||||||
#include <boost/static_assert.hpp>
|
|
||||||
#include <boost/type_traits/cv_traits.hpp>
|
|
||||||
#include <boost/type_traits/alignment_of.hpp>
|
|
||||||
#include <boost/swap.hpp>
|
|
||||||
#include <cstring>
|
|
||||||
#include <new>
|
|
||||||
|
|
||||||
#ifdef BOOST_MSVC
|
|
||||||
#pragma warning(push)
|
|
||||||
// It is safe to ignore the following warning from MSVC 7.1 or higher:
|
|
||||||
// "warning C4351: new behavior: elements of array will be default initialized"
|
|
||||||
#pragma warning(disable: 4351)
|
|
||||||
// It is safe to ignore the following MSVC warning, which may pop up when T is
|
|
||||||
// a const type: "warning C4512: assignment operator could not be generated".
|
|
||||||
#pragma warning(disable: 4512)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
|
|
||||||
// Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
|
|
||||||
// suggests that a workaround should be applied, because of compiler issues
|
|
||||||
// regarding value-initialization.
|
|
||||||
#define BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// Implementation detail: The macro BOOST_DETAIL_VALUE_INIT_WORKAROUND
|
|
||||||
// switches the value-initialization workaround either on or off.
|
|
||||||
#ifndef BOOST_DETAIL_VALUE_INIT_WORKAROUND
|
|
||||||
#ifdef BOOST_DETAIL_VALUE_INIT_WORKAROUND_SUGGESTED
|
|
||||||
#define BOOST_DETAIL_VALUE_INIT_WORKAROUND 1
|
|
||||||
#else
|
|
||||||
#define BOOST_DETAIL_VALUE_INIT_WORKAROUND 0
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
class initialized
|
|
||||||
{
|
|
||||||
private :
|
|
||||||
struct wrapper
|
|
||||||
{
|
|
||||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
|
|
||||||
typename
|
|
||||||
#endif
|
|
||||||
remove_const<T>::type data;
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
wrapper()
|
|
||||||
:
|
|
||||||
data()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
wrapper(T const & arg)
|
|
||||||
:
|
|
||||||
data(arg)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
mutable
|
|
||||||
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592))
|
|
||||||
typename
|
|
||||||
#endif
|
|
||||||
aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
wrapper * wrapper_address() const
|
|
||||||
{
|
|
||||||
return static_cast<wrapper *>( static_cast<void*>(&x));
|
|
||||||
}
|
|
||||||
|
|
||||||
public :
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
initialized()
|
|
||||||
{
|
|
||||||
#if BOOST_DETAIL_VALUE_INIT_WORKAROUND
|
|
||||||
std::memset(&x, 0, sizeof(x));
|
|
||||||
#endif
|
|
||||||
new (wrapper_address()) wrapper();
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
initialized(initialized const & arg)
|
|
||||||
{
|
|
||||||
new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
explicit initialized(T const & arg)
|
|
||||||
{
|
|
||||||
new (wrapper_address()) wrapper(arg);
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
initialized & operator=(initialized const & arg)
|
|
||||||
{
|
|
||||||
// Assignment is only allowed when T is non-const.
|
|
||||||
BOOST_STATIC_ASSERT( ! is_const<T>::value );
|
|
||||||
*wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
~initialized()
|
|
||||||
{
|
|
||||||
wrapper_address()->wrapper::~wrapper();
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
T const & data() const
|
|
||||||
{
|
|
||||||
return wrapper_address()->data;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
T& data()
|
|
||||||
{
|
|
||||||
return wrapper_address()->data;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
void swap(initialized & arg)
|
|
||||||
{
|
|
||||||
::boost::swap( this->data(), arg.data() );
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
operator T const &() const
|
|
||||||
{
|
|
||||||
return wrapper_address()->data;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
operator T&()
|
|
||||||
{
|
|
||||||
return wrapper_address()->data;
|
|
||||||
}
|
|
||||||
|
|
||||||
} ;
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
T const& get ( initialized<T> const& x )
|
|
||||||
{
|
|
||||||
return x.data() ;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
T& get ( initialized<T>& x )
|
|
||||||
{
|
|
||||||
return x.data() ;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
void swap ( initialized<T> & lhs, initialized<T> & rhs )
|
|
||||||
{
|
|
||||||
lhs.swap(rhs) ;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
class value_initialized
|
|
||||||
{
|
|
||||||
private :
|
|
||||||
|
|
||||||
// initialized<T> does value-initialization by default.
|
|
||||||
initialized<T> m_data;
|
|
||||||
|
|
||||||
public :
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
value_initialized()
|
|
||||||
:
|
|
||||||
m_data()
|
|
||||||
{ }
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
T const & data() const
|
|
||||||
{
|
|
||||||
return m_data.data();
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
T& data()
|
|
||||||
{
|
|
||||||
return m_data.data();
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
void swap(value_initialized & arg)
|
|
||||||
{
|
|
||||||
m_data.swap(arg.m_data);
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
operator T const &() const
|
|
||||||
{
|
|
||||||
return m_data;
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
operator T&()
|
|
||||||
{
|
|
||||||
return m_data;
|
|
||||||
}
|
|
||||||
} ;
|
|
||||||
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
T const& get ( value_initialized<T> const& x )
|
|
||||||
{
|
|
||||||
return x.data() ;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
T& get ( value_initialized<T>& x )
|
|
||||||
{
|
|
||||||
return x.data() ;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
BOOST_GPU_ENABLED
|
|
||||||
void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
|
|
||||||
{
|
|
||||||
lhs.swap(rhs) ;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
class initialized_value_t
|
|
||||||
{
|
|
||||||
public :
|
|
||||||
|
|
||||||
template <class T> BOOST_GPU_ENABLED operator T() const
|
|
||||||
{
|
|
||||||
return initialized<T>().data();
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
initialized_value_t const initialized_value = {} ;
|
|
||||||
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#ifdef BOOST_MSVC
|
|
||||||
#pragma warning(pop)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
72
index.htm
Normal file
72
index.htm
Normal file
@@ -0,0 +1,72 @@
|
|||||||
|
<html>
|
||||||
|
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||||
|
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
||||||
|
<meta name="ProgId" content="FrontPage.Editor.Document">
|
||||||
|
<title>Boost Utility Library</title>
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<body bgcolor="#FFFFFF" text="#000000">
|
||||||
|
|
||||||
|
<table border="1" cellpadding="2" bgcolor="#007F7F">
|
||||||
|
<tr>
|
||||||
|
<td bgcolor="#FFFFFF"><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86"></td>
|
||||||
|
<td><a href="../../index.htm"><font color="#FFFFFF" size="4" face="Arial">Home</font></a></td>
|
||||||
|
<td><a href="../../libraries.htm"><font color="#FFFFFF" size="4" face="Arial">Libraries</font></a></td>
|
||||||
|
<td><a href="../../people.htm"><font color="#FFFFFF" size="4" face="Arial">People</font></a></td>
|
||||||
|
<td><a href="../../more/faq.htm"><font color="#FFFFFF" size="4" face="Arial">FAQ</font></a></td>
|
||||||
|
<td><a href="../../more/index.htm"><font color="#FFFFFF" size="4" face="Arial">More</font></a></td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
<h1>Boost Utility Library</h1>
|
||||||
|
<table border="1" cellpadding="5">
|
||||||
|
<tr>
|
||||||
|
<td><b><i>Header</i></b></td>
|
||||||
|
<td><b><i>Contents</i></b></td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td><a href="../../boost/utility.hpp"><code>boost/utility.hpp<br>
|
||||||
|
</code></a><a href="utility.htm">[Documentation]</a></td>
|
||||||
|
<td>Class <b>noncopyable</b> plus <b>next()</b> and <b>prior()</b> template
|
||||||
|
functions.</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td><a href="../../boost/cast.hpp"><code>boost/cast.hpp</code></a><br>
|
||||||
|
<a href="cast.htm">[Documentation]</a></td>
|
||||||
|
<td><b>polymorphic_cast</b>, <b>implicit_cast</b>, and <b>numeric_cast</b>
|
||||||
|
function templates.
|
||||||
|
<p><i>[Beta.]</i></p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td><a href="../../boost/operators.hpp">boost/operators.hpp</a><br>
|
||||||
|
<a href="operators.htm">[Documentation]</a></td>
|
||||||
|
<td>Templates <b>equality_comparable</b>, <b>less_than_comparable</b>, <b>addable</b>,
|
||||||
|
and the like ease the task of defining comparison and arithmetic
|
||||||
|
operators, and iterators.</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td><a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a><br>
|
||||||
|
[<a href="type_traits.htm">Documentation</a>]</td>
|
||||||
|
<td>Template classes that describe the fundamental properties of a type. [<a href="c++_type_traits.htm">DDJ
|
||||||
|
Article "C++ type traits"</a>]</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td><a href="../../boost/detail/call_traits.hpp">boost/call_traits.hpp</a><br>
|
||||||
|
[<a href="call_traits.htm">Documentation</a>]</td>
|
||||||
|
<td>Template class call_traits<T>, that defines types used for passing
|
||||||
|
parameters to and from a proceedure.</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td><a href="../../boost/detail/compressed_pair.hpp">boost/compressed_pair.hpp</a><br>
|
||||||
|
[<a href="compressed_pair.htm">Documentation</a>]</td>
|
||||||
|
<td>Template class compressed_pait<T1, T2> which pairs two values
|
||||||
|
using the empty member optimisation where appropriate.</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->27 July 2000<!--webbot bot="Timestamp" endspan i-checksum="18770" --></p>
|
||||||
|
|
||||||
|
</body>
|
||||||
|
|
||||||
|
</html>
|
||||||
48
index.html
48
index.html
@@ -1,48 +0,0 @@
|
|||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Language" content="en-us">
|
|
||||||
<meta name="GENERATOR" content="Microsoft FrontPage 5.0">
|
|
||||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
|
||||||
<title>Boost Utility Library</title>
|
|
||||||
</head>
|
|
||||||
<body bgcolor="#FFFFFF">
|
|
||||||
<h1><IMG SRC="../../boost.png" WIDTH="276" HEIGHT="86" align="center">Boost
|
|
||||||
Utility Library</h1>
|
|
||||||
<p>The Boost Utility Library isn't really a single library at all. It is just a
|
|
||||||
collection for components too small to be called libraries in their own right.</p>
|
|
||||||
<p>But that doesn't mean there isn't useful stuff here. Take a look:</p>
|
|
||||||
<blockquote>
|
|
||||||
<p>
|
|
||||||
<a href="../core/doc/html/core/addressof.html">addressof</a> (moved to the Boost.Core library)<br>
|
|
||||||
<a href="doc/html/base_from_member.html">base_from_member</a><br>
|
|
||||||
<a href="utility.htm#BOOST_BINARY">BOOST_BINARY</a><br>
|
|
||||||
<a href="call_traits.htm">call_traits</a><br>
|
|
||||||
<a href="../core/doc/html/core/checked_delete.html">checked_delete</a> (moved to the Boost.Core library)<br>
|
|
||||||
<a href="doc/html/compressed_pair.html">compressed_pair</a><br>
|
|
||||||
<a href="doc/html/declval.html">declval</a><br>
|
|
||||||
<a href="../core/doc/html/core/enable_if.html">enable_if</a> (moved to the Boost.Core library)<br>
|
|
||||||
<a href="in_place_factories.html">in_place_factory</a><br>
|
|
||||||
<a href="iterator_adaptors.htm">iterator_adaptors</a><br>
|
|
||||||
<a href="generator_iterator.htm">generator iterator adaptors</a><br>
|
|
||||||
<a href="utility.htm#functions_next_prior">next/prior</a><br>
|
|
||||||
<a href="../core/doc/html/core/noncopyable.html">noncopyable</a> (moved to the Boost.Core library)<br>
|
|
||||||
<a href="operators.htm">operators</a><br>
|
|
||||||
<a href="utility.htm#result_of">result_of</a><br>
|
|
||||||
<a href="throw_exception.html">throw_exception</a><br>
|
|
||||||
<a href="utility.htm">utility</a><br>
|
|
||||||
<a href="doc/html/string_ref.html">string_ref</a><br>
|
|
||||||
<a href="value_init.htm">value_init</a><br>
|
|
||||||
</p>
|
|
||||||
</blockquote>
|
|
||||||
<hr>
|
|
||||||
<p>© Copyright Beman Dawes, 2001</p>
|
|
||||||
<p>Distributed under the Boost Software License, Version 1.0. (See
|
|
||||||
accompanying file <a href="../../LICENSE_1_0.txt">
|
|
||||||
LICENSE_1_0.txt</a> or copy at
|
|
||||||
<a href="http://www.boost.org/LICENSE_1_0.txt">
|
|
||||||
www.boost.org/LICENSE_1_0.txt</a>)</p>
|
|
||||||
<p>Revised
|
|
||||||
<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->07 November, 2006<!--webbot bot="Timestamp" endspan i-checksum="39368" --></p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,116 +0,0 @@
|
|||||||
// Copyright 2010, Niels Dekker.
|
|
||||||
//
|
|
||||||
// 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)
|
|
||||||
//
|
|
||||||
// Test program for boost::initialized<T>.
|
|
||||||
//
|
|
||||||
// 2 May 2010 (Created) Niels Dekker
|
|
||||||
|
|
||||||
#include <boost/utility/value_init.hpp>
|
|
||||||
#include <boost/detail/lightweight_test.hpp>
|
|
||||||
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
namespace
|
|
||||||
{
|
|
||||||
// Typical use case for boost::initialized<T>: A generic class that
|
|
||||||
// holds a value of type T, which must be initialized by either
|
|
||||||
// value-initialization or direct-initialization.
|
|
||||||
template <class T> class key_value_pair
|
|
||||||
{
|
|
||||||
std::string m_key;
|
|
||||||
boost::initialized<T> m_value;
|
|
||||||
public:
|
|
||||||
|
|
||||||
// Value-initializes the object held by m_value.
|
|
||||||
key_value_pair() { }
|
|
||||||
|
|
||||||
// Value-initializes the object held by m_value.
|
|
||||||
explicit key_value_pair(const std::string& key)
|
|
||||||
:
|
|
||||||
m_key(key)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
// Direct-initializes the object held by m_value.
|
|
||||||
key_value_pair(const std::string& key, const T& value)
|
|
||||||
:
|
|
||||||
m_key(key), m_value(value)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
const T& get_value() const
|
|
||||||
{
|
|
||||||
return m_value;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
// Tells whether the argument is value-initialized.
|
|
||||||
bool is_value_initialized(const int& arg)
|
|
||||||
{
|
|
||||||
return arg == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Tells whether the argument is value-initialized.
|
|
||||||
bool is_value_initialized(const std::string& arg)
|
|
||||||
{
|
|
||||||
return arg.empty();
|
|
||||||
}
|
|
||||||
|
|
||||||
struct foo
|
|
||||||
{
|
|
||||||
int data;
|
|
||||||
};
|
|
||||||
|
|
||||||
bool operator==(const foo& lhs, const foo& rhs)
|
|
||||||
{
|
|
||||||
return lhs.data == rhs.data;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Tells whether the argument is value-initialized.
|
|
||||||
bool is_value_initialized(const foo& arg)
|
|
||||||
{
|
|
||||||
return arg.data == 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
void test_key_value_pair(const T& magic_value)
|
|
||||||
{
|
|
||||||
// The value component of a default key_value_pair must be value-initialized.
|
|
||||||
key_value_pair<T> default_key_value_pair;
|
|
||||||
BOOST_TEST( is_value_initialized(default_key_value_pair.get_value() ) );
|
|
||||||
|
|
||||||
// The value component of a key_value_pair that only has its key explicitly specified
|
|
||||||
// must also be value-initialized.
|
|
||||||
BOOST_TEST( is_value_initialized(key_value_pair<T>("key").get_value()) );
|
|
||||||
|
|
||||||
// However, the value component of the following key_value_pair must be
|
|
||||||
// "magic_value", as it must be direct-initialized.
|
|
||||||
BOOST_TEST( key_value_pair<T>("key", magic_value).get_value() == magic_value );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Tests boost::initialize for a fundamental type, a type with a
|
|
||||||
// user-defined constructor, and a user-defined type without
|
|
||||||
// a user-defined constructor.
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
|
|
||||||
const int magic_number = 42;
|
|
||||||
test_key_value_pair(magic_number);
|
|
||||||
|
|
||||||
const std::string magic_string = "magic value";
|
|
||||||
test_key_value_pair(magic_string);
|
|
||||||
|
|
||||||
const foo magic_foo = { 42 };
|
|
||||||
test_key_value_pair(magic_foo);
|
|
||||||
|
|
||||||
return boost::report_errors();
|
|
||||||
}
|
|
||||||
@@ -1,33 +0,0 @@
|
|||||||
// Copyright 2010, Niels Dekker.
|
|
||||||
//
|
|
||||||
// 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)
|
|
||||||
//
|
|
||||||
// Test program for boost::initialized<T>. Must fail to compile.
|
|
||||||
//
|
|
||||||
// Initial: 2 May 2010
|
|
||||||
|
|
||||||
#include <boost/utility/value_init.hpp>
|
|
||||||
|
|
||||||
namespace
|
|
||||||
{
|
|
||||||
void direct_initialize_from_int()
|
|
||||||
{
|
|
||||||
// Okay: initialized<T> supports direct-initialization from T.
|
|
||||||
boost::initialized<int> direct_initialized_int(1);
|
|
||||||
}
|
|
||||||
|
|
||||||
void copy_initialize_from_int()
|
|
||||||
{
|
|
||||||
// The following line should not compile, because initialized<T>
|
|
||||||
// was not intended to supports copy-initialization from T.
|
|
||||||
boost::initialized<int> copy_initialized_int = 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
// This should fail to compile, so there is no need to call any function.
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,37 +0,0 @@
|
|||||||
// Copyright 2010, Niels Dekker.
|
|
||||||
//
|
|
||||||
// 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)
|
|
||||||
//
|
|
||||||
// Test program for boost::initialized<T>. Must fail to compile.
|
|
||||||
//
|
|
||||||
// Initial: 2 May 2010
|
|
||||||
|
|
||||||
#include <boost/utility/value_init.hpp>
|
|
||||||
|
|
||||||
namespace
|
|
||||||
{
|
|
||||||
void from_value_initialized_to_initialized()
|
|
||||||
{
|
|
||||||
boost::value_initialized<int> value_initialized_int;
|
|
||||||
|
|
||||||
// Okay: initialized<T> can be initialized by value_initialized<T>.
|
|
||||||
boost::initialized<int> initialized_int(value_initialized_int);
|
|
||||||
}
|
|
||||||
|
|
||||||
void from_initialized_to_value_initialized()
|
|
||||||
{
|
|
||||||
boost::initialized<int> initialized_int(13);
|
|
||||||
|
|
||||||
// The following line should not compile, because initialized<T>
|
|
||||||
// should not be convertible to value_initialized<T>.
|
|
||||||
boost::value_initialized<int> value_initialized_int(initialized_int);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
// This should fail to compile, so there is no need to call any function.
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,11 +0,0 @@
|
|||||||
<!-- Copyright David Abrahams 2004. 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) -->
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="refresh" content="0; URL=../iterator/doc/index.html">
|
|
||||||
</head>
|
|
||||||
<body>
|
|
||||||
This documentation moved to <a href="../iterator/doc/index.html">../iterator/doc/index.html</a>.
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
@@ -1,36 +1,24 @@
|
|||||||
// Demonstrate and test boost/operators.hpp on std::iterators --------------//
|
// Demonstrate and test boost/operators.hpp on std::iterators --------------//
|
||||||
|
|
||||||
// (C) Copyright Jeremy Siek 1999.
|
// (C) Copyright Jeremy Siek 1999. Permission to copy, use, modify,
|
||||||
// Distributed under the Boost Software License, Version 1.0. (See
|
// sell and distribute this software is granted provided this
|
||||||
// accompanying file LICENSE_1_0.txt or copy at
|
// copyright notice appears in all copies. This software is provided
|
||||||
// http://www.boost.org/LICENSE_1_0.txt)
|
// "as is" without express or implied warranty, and with no claim as
|
||||||
|
// to its suitability for any purpose.
|
||||||
|
|
||||||
// See http://www.boost.org for most recent version including documentation.
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
|
||||||
// Revision History
|
// Revision History
|
||||||
// 29 May 01 Factored implementation, added comparison tests, use Test Tools
|
|
||||||
// library (Daryle Walker)
|
|
||||||
// 12 Dec 99 Initial version with iterator operators (Jeremy Siek)
|
// 12 Dec 99 Initial version with iterator operators (Jeremy Siek)
|
||||||
|
|
||||||
#define BOOST_INCLUDE_MAIN
|
#include <string>
|
||||||
#include <boost/test/test_tools.hpp> // for main
|
#include <iostream>
|
||||||
|
using namespace std;
|
||||||
|
|
||||||
#include <boost/config.hpp> // for BOOST_STATIC_CONSTANT
|
#include <boost/operators.hpp>
|
||||||
#include <boost/cstdlib.hpp> // for boost::exit_success
|
using namespace boost;
|
||||||
#include <boost/operators.hpp> // for boost::random_access_iterator_helper
|
|
||||||
|
|
||||||
#include <cstddef> // for std::ptrdiff_t, std::size_t
|
|
||||||
#include <cstring> // for std::strcmp
|
|
||||||
#include <iostream> // for std::cout (std::endl, ends, and flush indirectly)
|
|
||||||
#include <string> // for std::string
|
|
||||||
#include <sstream> // for std::stringstream
|
|
||||||
|
|
||||||
# ifdef BOOST_NO_STDC_NAMESPACE
|
|
||||||
namespace std { using ::strcmp; }
|
|
||||||
# endif
|
|
||||||
|
|
||||||
|
|
||||||
// Iterator test class
|
|
||||||
template <class T, class R, class P>
|
template <class T, class R, class P>
|
||||||
struct test_iter
|
struct test_iter
|
||||||
: public boost::random_access_iterator_helper<
|
: public boost::random_access_iterator_helper<
|
||||||
@@ -41,7 +29,7 @@ struct test_iter
|
|||||||
typedef std::ptrdiff_t Distance;
|
typedef std::ptrdiff_t Distance;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
explicit test_iter(T* i =0) : _i(i) { }
|
test_iter(T* i) : _i(i) { }
|
||||||
test_iter(const self& x) : _i(x._i) { }
|
test_iter(const self& x) : _i(x._i) { }
|
||||||
self& operator=(const self& x) { _i = x._i; return *this; }
|
self& operator=(const self& x) { _i = x._i; return *this; }
|
||||||
Reference operator*() const { return *_i; }
|
Reference operator*() const { return *_i; }
|
||||||
@@ -55,270 +43,127 @@ public:
|
|||||||
return x._i - y._i;
|
return x._i - y._i;
|
||||||
}
|
}
|
||||||
protected:
|
protected:
|
||||||
P _i;
|
T* _i;
|
||||||
};
|
};
|
||||||
|
|
||||||
// Iterator operator testing classes
|
|
||||||
class test_opr_base
|
|
||||||
{
|
|
||||||
protected:
|
|
||||||
// Test data and types
|
|
||||||
BOOST_STATIC_CONSTANT( std::size_t, fruit_length = 6u );
|
|
||||||
|
|
||||||
typedef std::string fruit_array_type[ fruit_length ];
|
|
||||||
|
|
||||||
static fruit_array_type fruit;
|
|
||||||
|
|
||||||
}; // test_opr_base
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
|
||||||
// A definition is required even for integral static constants
|
|
||||||
const std::size_t test_opr_base::fruit_length;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
template <typename T, typename R = T&, typename P = T*>
|
|
||||||
class test_opr
|
|
||||||
: public test_opr_base
|
|
||||||
{
|
|
||||||
typedef test_opr<T, R, P> self_type;
|
|
||||||
|
|
||||||
public:
|
|
||||||
// Types
|
|
||||||
typedef T value_type;
|
|
||||||
typedef R reference;
|
|
||||||
typedef P pointer;
|
|
||||||
|
|
||||||
typedef test_iter<T, R, P> iter_type;
|
|
||||||
|
|
||||||
// Test controller
|
|
||||||
static void master_test( char const name[] );
|
|
||||||
|
|
||||||
private:
|
|
||||||
// Test data
|
|
||||||
static iter_type const fruit_begin;
|
|
||||||
static iter_type const fruit_end;
|
|
||||||
|
|
||||||
// Test parts
|
|
||||||
static void post_increment_test();
|
|
||||||
static void post_decrement_test();
|
|
||||||
static void indirect_referral_test();
|
|
||||||
static void offset_addition_test();
|
|
||||||
static void reverse_offset_addition_test();
|
|
||||||
static void offset_subtraction_test();
|
|
||||||
static void comparison_test();
|
|
||||||
static void indexing_test();
|
|
||||||
|
|
||||||
}; // test_opr
|
|
||||||
|
|
||||||
|
|
||||||
// Class-static data definitions
|
|
||||||
test_opr_base::fruit_array_type
|
|
||||||
test_opr_base::fruit = { "apple", "orange", "pear", "peach", "grape", "plum" };
|
|
||||||
|
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
typename test_opr<T, R, P>::iter_type const
|
|
||||||
test_opr<T, R, P>::fruit_begin = test_iter<T,R,P>( fruit );
|
|
||||||
|
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
typename test_opr<T, R, P>::iter_type const
|
|
||||||
test_opr<T, R, P>::fruit_end = test_iter<T,R,P>( fruit + fruit_length );
|
|
||||||
|
|
||||||
|
|
||||||
// Main testing function
|
|
||||||
int
|
int
|
||||||
test_main( int , char * [] )
|
main()
|
||||||
{
|
{
|
||||||
using std::string;
|
string array[] = { "apple", "orange", "pear", "peach", "grape", "plum" };
|
||||||
|
{
|
||||||
|
test_iter<string,string&,string*> i = array,
|
||||||
|
ie = array + sizeof(array)/sizeof(string);
|
||||||
|
|
||||||
typedef test_opr<string, string &, string *> test1_type;
|
// Tests for all of the operators added by random_access_iterator_helper
|
||||||
typedef test_opr<string, string const &, string const *> test2_type;
|
|
||||||
|
|
||||||
test1_type::master_test( "non-const string" );
|
// test i++
|
||||||
test2_type::master_test( "const string" );
|
while (i != ie)
|
||||||
|
cout << *i++ << " ";
|
||||||
|
cout << endl;
|
||||||
|
i = array;
|
||||||
|
|
||||||
return boost::exit_success;
|
// test i--
|
||||||
}
|
while (ie != i) {
|
||||||
|
ie--;
|
||||||
// Tests for all of the operators added by random_access_iterator_helper
|
cout << *ie << " ";
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
void
|
|
||||||
test_opr<T, R, P>::master_test
|
|
||||||
(
|
|
||||||
char const name[]
|
|
||||||
)
|
|
||||||
{
|
|
||||||
std::cout << "Doing test run for " << name << '.' << std::endl;
|
|
||||||
|
|
||||||
post_increment_test();
|
|
||||||
post_decrement_test();
|
|
||||||
indirect_referral_test();
|
|
||||||
offset_addition_test();
|
|
||||||
reverse_offset_addition_test();
|
|
||||||
offset_subtraction_test();
|
|
||||||
comparison_test();
|
|
||||||
indexing_test();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test post-increment
|
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
void
|
|
||||||
test_opr<T, R, P>::post_increment_test
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
std::cout << "\tDoing post-increment test." << std::endl;
|
|
||||||
|
|
||||||
std::stringstream oss;
|
|
||||||
for ( iter_type i = fruit_begin ; i != fruit_end ; )
|
|
||||||
{
|
|
||||||
oss << *i++ << ' ';
|
|
||||||
}
|
}
|
||||||
|
cout << endl;
|
||||||
|
ie = array + sizeof(array)/sizeof(string);
|
||||||
|
|
||||||
BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
|
// test i->m
|
||||||
}
|
while (i != ie) {
|
||||||
|
cout << i->size() << " ";
|
||||||
// Test post-decrement
|
++i;
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
void
|
|
||||||
test_opr<T, R, P>::post_decrement_test
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
std::cout << "\tDoing post-decrement test." << std::endl;
|
|
||||||
|
|
||||||
std::stringstream oss;
|
|
||||||
for ( iter_type i = fruit_end ; i != fruit_begin ; )
|
|
||||||
{
|
|
||||||
i--;
|
|
||||||
oss << *i << ' ';
|
|
||||||
}
|
}
|
||||||
|
cout << endl;
|
||||||
|
i = array;
|
||||||
|
|
||||||
BOOST_CHECK( oss.str() == "plum grape peach pear orange apple ");
|
// test i + n
|
||||||
}
|
while (i < ie) {
|
||||||
|
cout << *i << " ";
|
||||||
// Test indirect structure referral
|
i = i + 2;
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
void
|
|
||||||
test_opr<T, R, P>::indirect_referral_test
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
std::cout << "\tDoing indirect reference test." << std::endl;
|
|
||||||
|
|
||||||
std::stringstream oss;
|
|
||||||
for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
|
|
||||||
{
|
|
||||||
oss << i->size() << ' ';
|
|
||||||
}
|
}
|
||||||
|
cout << endl;
|
||||||
|
i = array;
|
||||||
|
|
||||||
BOOST_CHECK( oss.str() == "5 6 4 5 5 4 ");
|
// test n + i
|
||||||
}
|
while (i < ie) {
|
||||||
|
cout << *i << " ";
|
||||||
// Test offset addition
|
i = ptrdiff_t(2) + i;
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
void
|
|
||||||
test_opr<T, R, P>::offset_addition_test
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
std::cout << "\tDoing offset addition test." << std::endl;
|
|
||||||
|
|
||||||
std::ptrdiff_t const two = 2;
|
|
||||||
std::stringstream oss;
|
|
||||||
for ( iter_type i = fruit_begin ; i != fruit_end ; i = i + two )
|
|
||||||
{
|
|
||||||
oss << *i << ' ';
|
|
||||||
}
|
}
|
||||||
|
cout << endl;
|
||||||
|
i = array;
|
||||||
|
|
||||||
BOOST_CHECK( oss.str() == "apple pear grape ");
|
// test i - n
|
||||||
}
|
while (ie > i) {
|
||||||
|
ie = ie - 2;
|
||||||
// Test offset addition, in reverse order
|
cout << *ie << " ";
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
void
|
|
||||||
test_opr<T, R, P>::reverse_offset_addition_test
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
std::cout << "\tDoing reverse offset addition test." << std::endl;
|
|
||||||
|
|
||||||
std::ptrdiff_t const two = 2;
|
|
||||||
std::stringstream oss;
|
|
||||||
for ( iter_type i = fruit_begin ; i != fruit_end ; i = two + i )
|
|
||||||
{
|
|
||||||
oss << *i << ' ';
|
|
||||||
}
|
}
|
||||||
|
cout << endl;
|
||||||
|
ie = array + sizeof(array)/sizeof(string);
|
||||||
|
|
||||||
BOOST_CHECK( oss.str() == "apple pear grape ");
|
// test i[n]
|
||||||
}
|
for (std::size_t j = 0; j < sizeof(array)/sizeof(string); ++j)
|
||||||
|
cout << i[j] << " ";
|
||||||
|
cout << endl;
|
||||||
|
}
|
||||||
|
{
|
||||||
|
test_iter<string, const string&, const string*> i = array,
|
||||||
|
ie = array + sizeof(array)/sizeof(string);
|
||||||
|
|
||||||
// Test offset subtraction
|
// Tests for all of the operators added by random_access_iterator_helper
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
void
|
|
||||||
test_opr<T, R, P>::offset_subtraction_test
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
std::cout << "\tDoing offset subtraction test." << std::endl;
|
|
||||||
|
|
||||||
std::ptrdiff_t const two = 2;
|
// test i++
|
||||||
std::stringstream oss;
|
while (i != ie)
|
||||||
for ( iter_type i = fruit_end ; fruit_begin < i ; )
|
cout << *i++ << " ";
|
||||||
{
|
cout << endl;
|
||||||
i = i - two;
|
i = array;
|
||||||
if ( (fruit_begin < i) || (fruit_begin == i) )
|
|
||||||
{
|
// test i--
|
||||||
oss << *i << ' ';
|
while (ie != i) {
|
||||||
}
|
ie--;
|
||||||
|
cout << *ie << " ";
|
||||||
}
|
}
|
||||||
|
cout << endl;
|
||||||
|
ie = array + sizeof(array)/sizeof(string);
|
||||||
|
|
||||||
BOOST_CHECK( oss.str() == "grape pear apple ");
|
// test i->m
|
||||||
}
|
while (i != ie) {
|
||||||
|
cout << i->size() << " ";
|
||||||
// Test comparisons
|
++i;
|
||||||
template <typename T, typename R, typename P>
|
|
||||||
void
|
|
||||||
test_opr<T, R, P>::comparison_test
|
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
using std::cout;
|
|
||||||
using std::ptrdiff_t;
|
|
||||||
|
|
||||||
cout << "\tDoing comparison tests.\n\t\tPass:";
|
|
||||||
|
|
||||||
for ( iter_type i = fruit_begin ; i != fruit_end ; ++i )
|
|
||||||
{
|
|
||||||
ptrdiff_t const i_offset = i - fruit_begin;
|
|
||||||
|
|
||||||
cout << ' ' << *i << std::flush;
|
|
||||||
for ( iter_type j = fruit_begin ; j != fruit_end ; ++j )
|
|
||||||
{
|
|
||||||
ptrdiff_t const j_offset = j - fruit_begin;
|
|
||||||
|
|
||||||
BOOST_CHECK( (i != j) == (i_offset != j_offset) );
|
|
||||||
BOOST_CHECK( (i > j) == (i_offset > j_offset) );
|
|
||||||
BOOST_CHECK( (i <= j) == (i_offset <= j_offset) );
|
|
||||||
BOOST_CHECK( (i >= j) == (i_offset >= j_offset) );
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
cout << std::endl;
|
cout << endl;
|
||||||
}
|
i = array;
|
||||||
|
|
||||||
// Test indexing
|
// test i + n
|
||||||
template <typename T, typename R, typename P>
|
while (i < ie) {
|
||||||
void
|
cout << *i << " ";
|
||||||
test_opr<T, R, P>::indexing_test
|
i = i + 2;
|
||||||
(
|
|
||||||
)
|
|
||||||
{
|
|
||||||
std::cout << "\tDoing indexing test." << std::endl;
|
|
||||||
|
|
||||||
std::stringstream oss;
|
|
||||||
for ( std::size_t k = 0u ; k < fruit_length ; ++k )
|
|
||||||
{
|
|
||||||
oss << fruit_begin[ k ] << ' ';
|
|
||||||
}
|
}
|
||||||
|
cout << endl;
|
||||||
|
i = array;
|
||||||
|
|
||||||
BOOST_CHECK( oss.str() == "apple orange pear peach grape plum ");
|
// test n + i
|
||||||
|
while (i < ie) {
|
||||||
|
cout << *i << " ";
|
||||||
|
i = ptrdiff_t(2) + i;
|
||||||
|
}
|
||||||
|
cout << endl;
|
||||||
|
i = array;
|
||||||
|
|
||||||
|
// test i - n
|
||||||
|
while (ie > i) {
|
||||||
|
ie = ie - 2;
|
||||||
|
cout << *ie << " ";
|
||||||
|
}
|
||||||
|
cout << endl;
|
||||||
|
ie = array + sizeof(array)/sizeof(string);
|
||||||
|
|
||||||
|
// test i[n]
|
||||||
|
for (std::size_t j = 0; j < sizeof(array)/sizeof(string); ++j)
|
||||||
|
cout << i[j] << " ";
|
||||||
|
cout << endl;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,113 +0,0 @@
|
|||||||
[
|
|
||||||
{
|
|
||||||
"key": "utility",
|
|
||||||
"name": "Utility",
|
|
||||||
"authors": [
|
|
||||||
"Dave Abrahams and others"
|
|
||||||
],
|
|
||||||
"description": "Class noncopyable plus checked_delete(), checked_array_delete(), next(), prior() function templates, plus base-from-member idiom.",
|
|
||||||
"documentation": "utility.htm",
|
|
||||||
"category": [
|
|
||||||
"Algorithms",
|
|
||||||
"Function-objects",
|
|
||||||
"Memory",
|
|
||||||
"Miscellaneous",
|
|
||||||
"Patterns"
|
|
||||||
]
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"key": "utility/call_traits",
|
|
||||||
"name": "Call Traits",
|
|
||||||
"authors": [
|
|
||||||
"John Maddock, Howard Hinnant, et al"
|
|
||||||
],
|
|
||||||
"description": "Defines types for passing parameters.",
|
|
||||||
"documentation": "call_traits.htm",
|
|
||||||
"category": [
|
|
||||||
"Generic"
|
|
||||||
]
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"key": "utility/compressed_pair",
|
|
||||||
"name": "Compressed Pair",
|
|
||||||
"authors": [
|
|
||||||
"John Maddock, Howard Hinnant, et al"
|
|
||||||
],
|
|
||||||
"description": "Empty member optimization.",
|
|
||||||
"documentation": "compressed_pair.htm",
|
|
||||||
"category": [
|
|
||||||
"Data",
|
|
||||||
"Patterns"
|
|
||||||
]
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"key": "utility/identity_type",
|
|
||||||
"name": "Identity Type",
|
|
||||||
"authors": [
|
|
||||||
"Lorenzo Caminiti"
|
|
||||||
],
|
|
||||||
"description": "Wrap types within round parenthesis so they can always be passed as macro parameters.",
|
|
||||||
"documentation": "identity_type/",
|
|
||||||
"category": [
|
|
||||||
"Preprocessor"
|
|
||||||
],
|
|
||||||
"maintainers": [
|
|
||||||
"Lorenzo Caminiti <lorcaminiti -at- gmail.com>"
|
|
||||||
]
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"key": "utility/in_place_factories",
|
|
||||||
"name": "In Place Factory, Typed In Place Factory",
|
|
||||||
"authors": [
|
|
||||||
"Fernando Cacciola"
|
|
||||||
],
|
|
||||||
"description": "Generic in-place construction of contained objects with a variadic argument-list.",
|
|
||||||
"documentation": "in_place_factories.html",
|
|
||||||
"category": [
|
|
||||||
"Generic"
|
|
||||||
]
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"key": "utility/operators",
|
|
||||||
"name": "Operators",
|
|
||||||
"authors": [
|
|
||||||
"Dave Abrahams",
|
|
||||||
"Jeremy Siek"
|
|
||||||
],
|
|
||||||
"description": "Templates ease arithmetic classes and iterators.",
|
|
||||||
"documentation": "operators.htm",
|
|
||||||
"category": [
|
|
||||||
"Generic",
|
|
||||||
"Iterators",
|
|
||||||
"Math"
|
|
||||||
],
|
|
||||||
"maintainers": [
|
|
||||||
"Daniel Frey <d.frey -at- gmx.de>"
|
|
||||||
]
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"key": "utility/result_of",
|
|
||||||
"name": "Result Of",
|
|
||||||
"description": "Determines the type of a function call expression.",
|
|
||||||
"documentation": "utility.htm#result_of",
|
|
||||||
"category": [
|
|
||||||
"Function-objects"
|
|
||||||
],
|
|
||||||
"authors": "",
|
|
||||||
"maintainers": [
|
|
||||||
"Daniel Walker <daniel.j.walker -at- gmail.com>"
|
|
||||||
]
|
|
||||||
},
|
|
||||||
{
|
|
||||||
"key": "utility/value_initialized",
|
|
||||||
"name": "Value Initialized",
|
|
||||||
"authors": [
|
|
||||||
"Fernando Cacciola"
|
|
||||||
],
|
|
||||||
"description": "Wrapper for uniform-syntax value initialization, based on the original idea of David Abrahams.",
|
|
||||||
"documentation": "value_init.htm",
|
|
||||||
"category": [
|
|
||||||
"Miscellaneous"
|
|
||||||
]
|
|
||||||
}
|
|
||||||
]
|
|
||||||
38
noncopyable_test.cpp
Normal file
38
noncopyable_test.cpp
Normal file
@@ -0,0 +1,38 @@
|
|||||||
|
// boost class noncopyable test program ------------------------------------//
|
||||||
|
|
||||||
|
// (C) Copyright boost.org 1999. Permission to copy, use, modify, sell
|
||||||
|
// and distribute this software is granted provided this copyright
|
||||||
|
// notice appears in all copies. This software is provided "as is" without
|
||||||
|
// express or implied warranty, and with no claim as to its suitability for
|
||||||
|
// any purpose.
|
||||||
|
|
||||||
|
// See http://www.boost.org for most recent version including documentation.
|
||||||
|
|
||||||
|
// Revision History
|
||||||
|
// 9 Jun 99 Add unnamed namespace
|
||||||
|
// 2 Jun 99 Initial Version
|
||||||
|
|
||||||
|
#include <boost/utility.hpp>
|
||||||
|
#include <iostream>
|
||||||
|
|
||||||
|
// This program demonstrates compiler errors resulting from trying to copy
|
||||||
|
// construct or copy assign a class object derived from class noncopyable.
|
||||||
|
|
||||||
|
namespace
|
||||||
|
{
|
||||||
|
class DontTreadOnMe : boost::noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
DontTreadOnMe() { std::cout << "defanged!" << std::endl; }
|
||||||
|
}; // DontTreadOnMe
|
||||||
|
|
||||||
|
} // unnamed namespace
|
||||||
|
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
DontTreadOnMe object1;
|
||||||
|
DontTreadOnMe object2(object1);
|
||||||
|
object1 = object2;
|
||||||
|
return 0;
|
||||||
|
} // main
|
||||||
|
|
||||||
@@ -1,406 +0,0 @@
|
|||||||
// (C) Copyright David Abrahams 2001.
|
|
||||||
// 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)
|
|
||||||
|
|
||||||
// See http://www.boost.org for most recent version including documentation.
|
|
||||||
|
|
||||||
// Revision History
|
|
||||||
// 1 Apr 2001 Fixes for ICL; use BOOST_STATIC_CONSTANT
|
|
||||||
// 11 Feb 2001 Fixes for Borland (David Abrahams)
|
|
||||||
// 23 Jan 2001 Added test for wchar_t (David Abrahams)
|
|
||||||
// 23 Jan 2001 Now statically selecting a test for signed numbers to avoid
|
|
||||||
// warnings with fancy compilers. Added commentary and
|
|
||||||
// additional dumping of traits data for tested types (David
|
|
||||||
// Abrahams).
|
|
||||||
// 21 Jan 2001 Initial version (David Abrahams)
|
|
||||||
|
|
||||||
#include <boost/detail/numeric_traits.hpp>
|
|
||||||
#include <cassert>
|
|
||||||
#include <boost/type_traits.hpp>
|
|
||||||
#include <boost/static_assert.hpp>
|
|
||||||
#include <boost/cstdint.hpp>
|
|
||||||
#include <boost/utility.hpp>
|
|
||||||
#include <boost/lexical_cast.hpp>
|
|
||||||
#include <climits>
|
|
||||||
#include <typeinfo>
|
|
||||||
#include <iostream>
|
|
||||||
#include <string>
|
|
||||||
#ifndef BOOST_NO_LIMITS
|
|
||||||
# include <limits>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// =================================================================================
|
|
||||||
// template class complement_traits<Number> --
|
|
||||||
//
|
|
||||||
// statically computes the max and min for 1s and 2s-complement binary
|
|
||||||
// numbers. This helps on platforms without <limits> support. It also shows
|
|
||||||
// an example of a recursive template that works with MSVC!
|
|
||||||
//
|
|
||||||
|
|
||||||
template <unsigned size> struct complement; // forward
|
|
||||||
|
|
||||||
// The template complement, below, does all the real work, using "poor man's
|
|
||||||
// partial specialization". We need complement_traits_aux<> so that MSVC doesn't
|
|
||||||
// complain about undefined min/max as we're trying to recursively define them.
|
|
||||||
template <class Number, unsigned size>
|
|
||||||
struct complement_traits_aux
|
|
||||||
{
|
|
||||||
BOOST_STATIC_CONSTANT(Number, max = complement<size>::template traits<Number>::max);
|
|
||||||
BOOST_STATIC_CONSTANT(Number, min = complement<size>::template traits<Number>::min);
|
|
||||||
};
|
|
||||||
|
|
||||||
template <unsigned size>
|
|
||||||
struct complement
|
|
||||||
{
|
|
||||||
template <class Number>
|
|
||||||
struct traits
|
|
||||||
{
|
|
||||||
private:
|
|
||||||
// indirection through complement_traits_aux necessary to keep MSVC happy
|
|
||||||
typedef complement_traits_aux<Number, size - 1> prev;
|
|
||||||
public:
|
|
||||||
#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
|
|
||||||
// GCC 4.0.2 ICEs on these C-style casts
|
|
||||||
BOOST_STATIC_CONSTANT(Number, max =
|
|
||||||
Number((prev::max) << CHAR_BIT)
|
|
||||||
+ Number(UCHAR_MAX));
|
|
||||||
BOOST_STATIC_CONSTANT(Number, min = Number((prev::min) << CHAR_BIT));
|
|
||||||
#else
|
|
||||||
// Avoid left shifting negative integers, use multiplication instead
|
|
||||||
BOOST_STATIC_CONSTANT(Number, shift = 1u << CHAR_BIT);
|
|
||||||
BOOST_STATIC_CONSTANT(Number, max =
|
|
||||||
Number(Number(prev::max) * shift)
|
|
||||||
+ Number(UCHAR_MAX));
|
|
||||||
BOOST_STATIC_CONSTANT(Number, min = Number(Number(prev::min) * shift));
|
|
||||||
#endif
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
// Template class complement_base<> -- defines values for min and max for
|
|
||||||
// complement<1>, at the deepest level of recursion. Uses "poor man's partial
|
|
||||||
// specialization" again.
|
|
||||||
template <bool is_signed> struct complement_base;
|
|
||||||
|
|
||||||
template <> struct complement_base<false>
|
|
||||||
{
|
|
||||||
template <class Number>
|
|
||||||
struct values
|
|
||||||
{
|
|
||||||
BOOST_STATIC_CONSTANT(Number, min = 0);
|
|
||||||
BOOST_STATIC_CONSTANT(Number, max = UCHAR_MAX);
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template <> struct complement_base<true>
|
|
||||||
{
|
|
||||||
template <class Number>
|
|
||||||
struct values
|
|
||||||
{
|
|
||||||
BOOST_STATIC_CONSTANT(Number, min = SCHAR_MIN);
|
|
||||||
BOOST_STATIC_CONSTANT(Number, max = SCHAR_MAX);
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
// Base specialization of complement, puts an end to the recursion.
|
|
||||||
template <>
|
|
||||||
struct complement<1>
|
|
||||||
{
|
|
||||||
template <class Number>
|
|
||||||
struct traits
|
|
||||||
{
|
|
||||||
BOOST_STATIC_CONSTANT(bool, is_signed = boost::detail::is_signed<Number>::value);
|
|
||||||
BOOST_STATIC_CONSTANT(Number, min =
|
|
||||||
complement_base<is_signed>::template values<Number>::min);
|
|
||||||
BOOST_STATIC_CONSTANT(Number, max =
|
|
||||||
complement_base<is_signed>::template values<Number>::max);
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
// Now here's the "pretty" template you're intended to actually use.
|
|
||||||
// complement_traits<Number>::min, complement_traits<Number>::max are the
|
|
||||||
// minimum and maximum values of Number if Number is a built-in integer type.
|
|
||||||
template <class Number>
|
|
||||||
struct complement_traits
|
|
||||||
{
|
|
||||||
BOOST_STATIC_CONSTANT(Number, max = (complement_traits_aux<Number, sizeof(Number)>::max));
|
|
||||||
BOOST_STATIC_CONSTANT(Number, min = (complement_traits_aux<Number, sizeof(Number)>::min));
|
|
||||||
};
|
|
||||||
|
|
||||||
// =================================================================================
|
|
||||||
|
|
||||||
// Support for streaming various numeric types in exactly the format I want. I
|
|
||||||
// needed this in addition to all the assertions so that I could see exactly
|
|
||||||
// what was going on.
|
|
||||||
//
|
|
||||||
// Numbers go through a 2-stage conversion process (by default, though, no real
|
|
||||||
// conversion).
|
|
||||||
//
|
|
||||||
template <class T> struct stream_as {
|
|
||||||
typedef T t1;
|
|
||||||
typedef T t2;
|
|
||||||
};
|
|
||||||
|
|
||||||
// char types first get converted to unsigned char, then to unsigned.
|
|
||||||
template <> struct stream_as<char> {
|
|
||||||
typedef unsigned char t1;
|
|
||||||
typedef unsigned t2;
|
|
||||||
};
|
|
||||||
template <> struct stream_as<unsigned char> {
|
|
||||||
typedef unsigned char t1; typedef unsigned t2;
|
|
||||||
};
|
|
||||||
template <> struct stream_as<signed char> {
|
|
||||||
typedef unsigned char t1; typedef unsigned t2;
|
|
||||||
};
|
|
||||||
|
|
||||||
#if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
|
|
||||||
|
|
||||||
// With this library implementation, __int64 and __uint64 get streamed as strings
|
|
||||||
template <> struct stream_as<boost::uintmax_t> {
|
|
||||||
typedef std::string t1;
|
|
||||||
typedef std::string t2;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <> struct stream_as<boost::intmax_t> {
|
|
||||||
typedef std::string t1;
|
|
||||||
typedef std::string t2;
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// Standard promotion process for streaming
|
|
||||||
template <class T> struct promote
|
|
||||||
{
|
|
||||||
static typename stream_as<T>::t1 from(T x) {
|
|
||||||
typedef typename stream_as<T>::t1 t1;
|
|
||||||
return t1(x);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
#if defined(BOOST_MSVC_STD_ITERATOR) // No intmax streaming built-in
|
|
||||||
|
|
||||||
// On this platform, stream them as long/unsigned long if they fit.
|
|
||||||
// Otherwise, write a string.
|
|
||||||
template <> struct promote<boost::uintmax_t> {
|
|
||||||
std::string static from(const boost::uintmax_t x) {
|
|
||||||
if (x > ULONG_MAX)
|
|
||||||
return std::string("large unsigned value");
|
|
||||||
else
|
|
||||||
return boost::lexical_cast<std::string>((unsigned long)x);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
template <> struct promote<boost::intmax_t> {
|
|
||||||
std::string static from(const boost::intmax_t x) {
|
|
||||||
if (x > boost::intmax_t(ULONG_MAX))
|
|
||||||
return std::string("large positive signed value");
|
|
||||||
else if (x >= 0)
|
|
||||||
return boost::lexical_cast<std::string>((unsigned long)x);
|
|
||||||
|
|
||||||
if (x < boost::intmax_t(LONG_MIN))
|
|
||||||
return std::string("large negative signed value");
|
|
||||||
else
|
|
||||||
return boost::lexical_cast<std::string>((long)x);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// This is the function which converts types to the form I want to stream them in.
|
|
||||||
template <class T>
|
|
||||||
typename stream_as<T>::t2 stream_number(T x)
|
|
||||||
{
|
|
||||||
return promote<T>::from(x);
|
|
||||||
}
|
|
||||||
// =================================================================================
|
|
||||||
|
|
||||||
//
|
|
||||||
// Tests for built-in signed and unsigned types
|
|
||||||
//
|
|
||||||
|
|
||||||
// Tag types for selecting tests
|
|
||||||
struct unsigned_tag {};
|
|
||||||
struct signed_tag {};
|
|
||||||
|
|
||||||
// Tests for unsigned numbers. The extra default Number parameter works around
|
|
||||||
// an MSVC bug.
|
|
||||||
template <class Number>
|
|
||||||
void test_aux(unsigned_tag, Number*)
|
|
||||||
{
|
|
||||||
typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
|
|
||||||
BOOST_STATIC_ASSERT(!boost::detail::is_signed<Number>::value);
|
|
||||||
BOOST_STATIC_ASSERT(
|
|
||||||
(sizeof(Number) < sizeof(boost::intmax_t))
|
|
||||||
| (boost::is_same<difference_type, boost::intmax_t>::value));
|
|
||||||
|
|
||||||
#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
|
|
||||||
// GCC 4.0.2 ICEs on this C-style cases
|
|
||||||
BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
|
|
||||||
BOOST_STATIC_ASSERT((complement_traits<Number>::min) == Number(0));
|
|
||||||
#else
|
|
||||||
// Force casting to Number here to work around the fact that it's an enum on MSVC
|
|
||||||
BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
|
|
||||||
BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) == Number(0));
|
|
||||||
#endif
|
|
||||||
|
|
||||||
const Number max = complement_traits<Number>::max;
|
|
||||||
const Number min = complement_traits<Number>::min;
|
|
||||||
|
|
||||||
const Number test_max = (sizeof(Number) < sizeof(boost::intmax_t))
|
|
||||||
? max
|
|
||||||
: max / 2 - 1;
|
|
||||||
|
|
||||||
std::cout << std::hex << "(unsigned) min = " << stream_number(min) << ", max = "
|
|
||||||
<< stream_number(max) << "..." << std::flush;
|
|
||||||
std::cout << "difference_type = " << typeid(difference_type).name() << "..."
|
|
||||||
<< std::flush;
|
|
||||||
|
|
||||||
difference_type d1 = boost::detail::numeric_distance(Number(0), test_max);
|
|
||||||
difference_type d2 = boost::detail::numeric_distance(test_max, Number(0));
|
|
||||||
|
|
||||||
std::cout << "0->" << stream_number(test_max) << "==" << std::dec << stream_number(d1) << "; "
|
|
||||||
<< std::hex << stream_number(test_max) << "->0==" << std::dec << stream_number(d2) << "..." << std::flush;
|
|
||||||
|
|
||||||
assert(d1 == difference_type(test_max));
|
|
||||||
assert(d2 == -difference_type(test_max));
|
|
||||||
}
|
|
||||||
|
|
||||||
// Tests for signed numbers. The extra default Number parameter works around an
|
|
||||||
// MSVC bug.
|
|
||||||
struct out_of_range_tag {};
|
|
||||||
struct in_range_tag {};
|
|
||||||
|
|
||||||
// This test morsel gets executed for numbers whose difference will always be
|
|
||||||
// representable in intmax_t
|
|
||||||
template <class Number>
|
|
||||||
void signed_test(in_range_tag, Number*)
|
|
||||||
{
|
|
||||||
BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
|
|
||||||
typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
|
|
||||||
const Number max = complement_traits<Number>::max;
|
|
||||||
const Number min = complement_traits<Number>::min;
|
|
||||||
|
|
||||||
difference_type d1 = boost::detail::numeric_distance(min, max);
|
|
||||||
difference_type d2 = boost::detail::numeric_distance(max, min);
|
|
||||||
|
|
||||||
std::cout << stream_number(min) << "->" << stream_number(max) << "==";
|
|
||||||
std::cout << std::dec << stream_number(d1) << "; ";
|
|
||||||
std::cout << std::hex << stream_number(max) << "->" << stream_number(min)
|
|
||||||
<< "==" << std::dec << stream_number(d2) << "..." << std::flush;
|
|
||||||
assert(d1 == difference_type(max) - difference_type(min));
|
|
||||||
assert(d2 == difference_type(min) - difference_type(max));
|
|
||||||
}
|
|
||||||
|
|
||||||
// This test morsel gets executed for numbers whose difference may exceed the
|
|
||||||
// capacity of intmax_t.
|
|
||||||
template <class Number>
|
|
||||||
void signed_test(out_of_range_tag, Number*)
|
|
||||||
{
|
|
||||||
BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
|
|
||||||
typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
|
|
||||||
const Number max = complement_traits<Number>::max;
|
|
||||||
const Number min = complement_traits<Number>::min;
|
|
||||||
|
|
||||||
difference_type min_distance = complement_traits<difference_type>::min;
|
|
||||||
difference_type max_distance = complement_traits<difference_type>::max;
|
|
||||||
|
|
||||||
const Number n1 = Number(min + max_distance);
|
|
||||||
const Number n2 = Number(max + min_distance);
|
|
||||||
difference_type d1 = boost::detail::numeric_distance(min, n1);
|
|
||||||
difference_type d2 = boost::detail::numeric_distance(max, n2);
|
|
||||||
|
|
||||||
std::cout << stream_number(min) << "->" << stream_number(n1) << "==";
|
|
||||||
std::cout << std::dec << stream_number(d1) << "; ";
|
|
||||||
std::cout << std::hex << stream_number(max) << "->" << stream_number(n2)
|
|
||||||
<< "==" << std::dec << stream_number(d2) << "..." << std::flush;
|
|
||||||
assert(d1 == max_distance);
|
|
||||||
assert(d2 == min_distance);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class Number>
|
|
||||||
void test_aux(signed_tag, Number*)
|
|
||||||
{
|
|
||||||
typedef typename boost::detail::numeric_traits<Number>::difference_type difference_type;
|
|
||||||
BOOST_STATIC_ASSERT(boost::detail::is_signed<Number>::value);
|
|
||||||
BOOST_STATIC_ASSERT(
|
|
||||||
(sizeof(Number) < sizeof(boost::intmax_t))
|
|
||||||
| (boost::is_same<difference_type, Number>::value));
|
|
||||||
|
|
||||||
#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2
|
|
||||||
// GCC 4.0.2 ICEs on this cast
|
|
||||||
BOOST_STATIC_ASSERT((complement_traits<Number>::max) > Number(0));
|
|
||||||
BOOST_STATIC_ASSERT((complement_traits<Number>::min) < Number(0));
|
|
||||||
#else
|
|
||||||
// Force casting to Number here to work around the fact that it's an enum on MSVC
|
|
||||||
BOOST_STATIC_ASSERT(Number(complement_traits<Number>::max) > Number(0));
|
|
||||||
BOOST_STATIC_ASSERT(Number(complement_traits<Number>::min) < Number(0));
|
|
||||||
#endif
|
|
||||||
const Number max = complement_traits<Number>::max;
|
|
||||||
const Number min = complement_traits<Number>::min;
|
|
||||||
|
|
||||||
std::cout << std::hex << "min = " << stream_number(min) << ", max = "
|
|
||||||
<< stream_number(max) << "..." << std::flush;
|
|
||||||
std::cout << "difference_type = " << typeid(difference_type).name() << "..."
|
|
||||||
<< std::flush;
|
|
||||||
|
|
||||||
typedef typename boost::detail::if_true<
|
|
||||||
(sizeof(Number) < sizeof(boost::intmax_t))>
|
|
||||||
::template then<
|
|
||||||
in_range_tag,
|
|
||||||
out_of_range_tag
|
|
||||||
>::type
|
|
||||||
range_tag;
|
|
||||||
signed_test<Number>(range_tag(), 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Test for all numbers. The extra default Number parameter works around an MSVC
|
|
||||||
// bug.
|
|
||||||
template <class Number>
|
|
||||||
void test(Number* = 0)
|
|
||||||
{
|
|
||||||
std::cout << "testing " << typeid(Number).name() << ":\n"
|
|
||||||
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
|
|
||||||
<< "is_signed: " << (std::numeric_limits<Number>::is_signed ? "true\n" : "false\n")
|
|
||||||
<< "is_bounded: " << (std::numeric_limits<Number>::is_bounded ? "true\n" : "false\n")
|
|
||||||
<< "digits: " << std::numeric_limits<Number>::digits << "\n"
|
|
||||||
#endif
|
|
||||||
<< "..." << std::flush;
|
|
||||||
|
|
||||||
// factoring out difference_type for the assert below confused Borland :(
|
|
||||||
typedef boost::detail::is_signed<
|
|
||||||
#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
|
|
||||||
typename
|
|
||||||
#endif
|
|
||||||
boost::detail::numeric_traits<Number>::difference_type
|
|
||||||
> is_signed;
|
|
||||||
BOOST_STATIC_ASSERT(is_signed::value);
|
|
||||||
|
|
||||||
typedef typename boost::detail::if_true<
|
|
||||||
boost::detail::is_signed<Number>::value
|
|
||||||
>::template then<signed_tag, unsigned_tag>::type signedness;
|
|
||||||
|
|
||||||
test_aux<Number>(signedness(), 0);
|
|
||||||
std::cout << "passed" << std::endl;
|
|
||||||
}
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
test<char>();
|
|
||||||
test<unsigned char>();
|
|
||||||
test<signed char>();
|
|
||||||
test<wchar_t>();
|
|
||||||
test<short>();
|
|
||||||
test<unsigned short>();
|
|
||||||
test<int>();
|
|
||||||
test<unsigned int>();
|
|
||||||
test<long>();
|
|
||||||
test<unsigned long>();
|
|
||||||
#if defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T)
|
|
||||||
test< ::boost::long_long_type>();
|
|
||||||
test< ::boost::ulong_long_type>();
|
|
||||||
#elif defined(BOOST_MSVC)
|
|
||||||
// The problem of not having compile-time static class constants other than
|
|
||||||
// enums prevents this from working, since values get truncated.
|
|
||||||
// test<boost::uintmax_t>();
|
|
||||||
// test<boost::intmax_t>();
|
|
||||||
#endif
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
2604
operators.htm
2604
operators.htm
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,322 +0,0 @@
|
|||||||
<html>
|
|
||||||
|
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
|
|
||||||
<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
|
|
||||||
<meta name="ProgId" content="FrontPage.Editor.Document">
|
|
||||||
<title>Shared Container Iterator Documentation</title>
|
|
||||||
</head>
|
|
||||||
|
|
||||||
<body bgcolor="#FFFFFF" text="#000000">
|
|
||||||
|
|
||||||
<img src="../../boost.png" alt="boost.png (6897 bytes)"
|
|
||||||
align="center" width="277" height="86">
|
|
||||||
|
|
||||||
<h1>Shared Container Iterator</h1>
|
|
||||||
|
|
||||||
Defined in header
|
|
||||||
<a href="../../boost/shared_container_iterator.hpp">boost/shared_container_iterator.hpp</a>
|
|
||||||
|
|
||||||
<p>
|
|
||||||
The purpose of the shared container iterator is to attach the lifetime
|
|
||||||
of a container to the lifetime of its iterators. In other words, the
|
|
||||||
container will not be deleted until after all its iterators are
|
|
||||||
destroyed. The shared container iterator is typically used to
|
|
||||||
implement functions that return iterators over a range of objects that
|
|
||||||
only need to exist for the lifetime of the iterators. By returning a
|
|
||||||
pair of shared iterators from a function, the callee can return a
|
|
||||||
heap-allocated range of objects whose lifetime is automatically managed.
|
|
||||||
<p>
|
|
||||||
The shared container iterator augments an iterator over a shared
|
|
||||||
container. It maintains a reference count on the shared
|
|
||||||
container. If only shared container iterators hold references to
|
|
||||||
the container, the container's lifetime will end when the last shared
|
|
||||||
container iterator over it is destroyed. In any case, the shared
|
|
||||||
container is guaranteed to persist beyond the lifetime of all
|
|
||||||
the iterators. In all other ways, the
|
|
||||||
shared container iterator behaves the same as its base iterator.
|
|
||||||
|
|
||||||
|
|
||||||
<h2>Synopsis</h2>
|
|
||||||
|
|
||||||
<pre>
|
|
||||||
namespace boost {
|
|
||||||
template <typename <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>>
|
|
||||||
class shared_container_iterator;
|
|
||||||
|
|
||||||
template <typename <a href="http://www.sgi.com/tech/stl/Container.html">Container</a>>
|
|
||||||
shared_container_iterator<Container>
|
|
||||||
make_shared_container_iterator(typename Container::iterator base,
|
|
||||||
boost::shared_ptr<Container> const& container);
|
|
||||||
|
|
||||||
std::pair<
|
|
||||||
typename shared_container_iterator<Container>,
|
|
||||||
typename shared_container_iterator<Container>
|
|
||||||
>
|
|
||||||
make_shared_container_range(boost::shared_ptr<Container> const& container);
|
|
||||||
}
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<hr>
|
|
||||||
|
|
||||||
<h2><a name="generator">The Shared Container Iterator Type</a></h2>
|
|
||||||
|
|
||||||
<pre>
|
|
||||||
template <typename Container> class shared_container_iterator;
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
The class template <tt>shared_container_iterator</tt>
|
|
||||||
is the shared container iterator type. The <tt>Container</tt> template
|
|
||||||
type argument must model the
|
|
||||||
<a href="http://www.sgi.com/tech/stl/Container.html">Container</a>
|
|
||||||
concept.
|
|
||||||
|
|
||||||
<h3>Example</h3>
|
|
||||||
|
|
||||||
<p>
|
|
||||||
The following example illustrates how to create an iterator that
|
|
||||||
regulates the lifetime of a reference counted <tt>std::vector</tt>.
|
|
||||||
Though the original shared pointer <tt>ints</tt> ceases to exist
|
|
||||||
after <tt>set_range()</tt> returns, the
|
|
||||||
<tt>shared_counter_iterator</tt> objects maintain references to the
|
|
||||||
underlying vector and thereby extend the container's lifetime.
|
|
||||||
<p>
|
|
||||||
<a href="./shared_iterator_example1.cpp">shared_iterator_example1.cpp</a>:
|
|
||||||
<PRE>
|
|
||||||
<font color="#008040">#include "shared_container_iterator.hpp"</font>
|
|
||||||
<font color="#008040">#include "boost/shared_ptr.hpp"</font>
|
|
||||||
<font color="#008040">#include <algorithm></font>
|
|
||||||
<font color="#008040">#include <iostream></font>
|
|
||||||
<font color="#008040">#include <vector></font>
|
|
||||||
|
|
||||||
<B>typedef</B> boost::shared_container_iterator< std::vector<<B>int</B>> > iterator;
|
|
||||||
|
|
||||||
|
|
||||||
<B>void</B> set_range(iterator& i, iterator& end) {
|
|
||||||
|
|
||||||
boost::shared_ptr< std::vector<<B>int</B>> > ints(<B>new</B> std::vector<<B>int</B>>());
|
|
||||||
|
|
||||||
ints->push_back(<font color="#0000A0">0</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">1</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">2</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">3</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">4</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">5</font>);
|
|
||||||
|
|
||||||
i = iterator(ints->begin(),ints);
|
|
||||||
end = iterator(ints->end(),ints);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
<B>int</B> main() {
|
|
||||||
|
|
||||||
iterator i,end;
|
|
||||||
|
|
||||||
set_range(i,end);
|
|
||||||
|
|
||||||
std::copy(i,end,std::ostream_iterator<<B>int</B>>(std::cout,<font color="#0000FF">","</font>));
|
|
||||||
std::cout.put(<font color="#0000FF">'\n'</font>);
|
|
||||||
|
|
||||||
<B>return</B> <font color="#0000A0">0</font>;
|
|
||||||
}
|
|
||||||
</PRE>
|
|
||||||
|
|
||||||
The output from this part is:
|
|
||||||
<pre>
|
|
||||||
0,1,2,3,4,5,
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<h3>Template Parameters</h3>
|
|
||||||
|
|
||||||
<Table border>
|
|
||||||
<TR>
|
|
||||||
<TH>Parameter</TH><TH>Description</TH>
|
|
||||||
</TR>
|
|
||||||
|
|
||||||
<TR>
|
|
||||||
<TD><a
|
|
||||||
href="http://www.sgi.com/tech/stl/Container.html"><tt>Container</tt></a></TD>
|
|
||||||
<TD>The type of the container that we wish to iterate over. It must be
|
|
||||||
a model of the
|
|
||||||
<a href="http://www.sgi.com/tech/stl/Container.html"><tt>Container</tt></a>
|
|
||||||
concept.
|
|
||||||
</TD>
|
|
||||||
</TR>
|
|
||||||
</Table>
|
|
||||||
|
|
||||||
<h3>Model of</h3>
|
|
||||||
|
|
||||||
The <tt>shared_container_iterator<Container></tt> type models the
|
|
||||||
same iterator concept as the base iterator
|
|
||||||
(<tt>Container::iterator</tt>).
|
|
||||||
|
|
||||||
<h3>Members</h3>
|
|
||||||
|
|
||||||
The shared container iterator type implements the member functions and
|
|
||||||
operators required of the <a
|
|
||||||
href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
|
|
||||||
concept, though only operations defined for the base iterator will be valid.
|
|
||||||
In addition it has the following constructor:
|
|
||||||
|
|
||||||
<pre>
|
|
||||||
shared_container_iterator(Container::iterator const& it,
|
|
||||||
boost::shared_ptr<Container> const& container)
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<p>
|
|
||||||
<hr>
|
|
||||||
<p>
|
|
||||||
|
|
||||||
|
|
||||||
<h2><a name="make_iterator">The Shared Container Iterator Object Generator</a></h2>
|
|
||||||
|
|
||||||
<pre>
|
|
||||||
template <typename Container>
|
|
||||||
shared_container_iterator<Container>
|
|
||||||
make_shared_container_iterator(Container::iterator base,
|
|
||||||
boost::shared_ptr<Container> const& container)
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
This function provides an alternative to directly constructing a
|
|
||||||
shared container iterator. Using the object generator, a shared
|
|
||||||
container iterator can be created and passed to a function without
|
|
||||||
explicitly specifying its type.
|
|
||||||
|
|
||||||
<h3>Example</h3>
|
|
||||||
|
|
||||||
This example, similar to the previous, uses
|
|
||||||
<tt>make_shared_container_iterator()</tt> to create the iterators.
|
|
||||||
|
|
||||||
<p>
|
|
||||||
<a href="./shared_iterator_example2.cpp">shared_iterator_example2.cpp</a>:
|
|
||||||
|
|
||||||
<PRE>
|
|
||||||
<font color="#008040">#include "shared_container_iterator.hpp"</font>
|
|
||||||
<font color="#008040">#include "boost/shared_ptr.hpp"</font>
|
|
||||||
<font color="#008040">#include <algorithm></font>
|
|
||||||
<font color="#008040">#include <iterator></font>
|
|
||||||
<font color="#008040">#include <iostream></font>
|
|
||||||
<font color="#008040">#include <vector></font>
|
|
||||||
|
|
||||||
|
|
||||||
<B>template</B> <<B>typename</B> Iterator>
|
|
||||||
<B>void</B> print_range_nl (Iterator begin, Iterator end) {
|
|
||||||
<B>typedef</B> <B>typename</B> std::iterator_traits<Iterator>::value_type val;
|
|
||||||
std::copy(begin,end,std::ostream_iterator<val>(std::cout,<font color="#0000FF">","</font>));
|
|
||||||
std::cout.put(<font color="#0000FF">'\n'</font>);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
<B>int</B> main() {
|
|
||||||
|
|
||||||
<B>typedef</B> boost::shared_ptr< std::vector<<B>int</B>> > ints_t;
|
|
||||||
{
|
|
||||||
ints_t ints(<B>new</B> std::vector<<B>int</B>>());
|
|
||||||
|
|
||||||
ints->push_back(<font color="#0000A0">0</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">1</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">2</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">3</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">4</font>);
|
|
||||||
ints->push_back(<font color="#0000A0">5</font>);
|
|
||||||
|
|
||||||
print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
|
|
||||||
boost::make_shared_container_iterator(ints->end(),ints));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
<B>return</B> <font color="#0000A0">0</font>;
|
|
||||||
}
|
|
||||||
</PRE>
|
|
||||||
|
|
||||||
Observe that the <tt>shared_container_iterator</tt> type is never
|
|
||||||
explicitly named. The output from this example is the same as the previous.
|
|
||||||
|
|
||||||
<h2><a name="make_range">The Shared Container Iterator Range Generator</a></h2>
|
|
||||||
|
|
||||||
<pre>
|
|
||||||
template <typename Container>
|
|
||||||
std::pair<
|
|
||||||
shared_container_iterator<Container>,
|
|
||||||
shared_container_iterator<Container>
|
|
||||||
>
|
|
||||||
make_shared_container_range(boost::shared_ptr<Container> const& container);
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
Class <tt>shared_container_iterator</tt> is meant primarily to return,
|
|
||||||
using iterators, a range of values that we can guarantee will be alive as
|
|
||||||
long as the iterators are. This is a convenience
|
|
||||||
function to do just that. It is equivalent to
|
|
||||||
|
|
||||||
<pre>
|
|
||||||
std::make_pair(make_shared_container_iterator(container->begin(),container),
|
|
||||||
make_shared_container_iterator(container->end(),container));
|
|
||||||
</pre>
|
|
||||||
|
|
||||||
<h3>Example</h3>
|
|
||||||
|
|
||||||
In the following example, a range of values is returned as a pair of
|
|
||||||
<tt>shared_container_iterator</tt> objects.
|
|
||||||
|
|
||||||
|
|
||||||
<p>
|
|
||||||
<a href="./shared_iterator_example3.cpp">shared_iterator_example3.cpp</a>:
|
|
||||||
|
|
||||||
<PRE>
|
|
||||||
<font color="#008040">#include "shared_container_iterator.hpp"</font>
|
|
||||||
<font color="#008040">#include "boost/shared_ptr.hpp"</font>
|
|
||||||
<font color="#008040">#include "boost/tuple/tuple.hpp" // for boost::tie</font>
|
|
||||||
<font color="#008040">#include <algorithm> // for std::copy</font>
|
|
||||||
<font color="#008040">#include <iostream> </font>
|
|
||||||
<font color="#008040">#include <vector></font>
|
|
||||||
|
|
||||||
|
|
||||||
<B>typedef</B> boost::shared_container_iterator< std::vector<<B>int</B>> > iterator;
|
|
||||||
|
|
||||||
std::pair<iterator,iterator>
|
|
||||||
return_range() {
|
|
||||||
boost::shared_ptr< std::vector<<B>int</B>> > range(<B>new</B> std::vector<<B>int</B>>());
|
|
||||||
range->push_back(<font color="#0000A0">0</font>);
|
|
||||||
range->push_back(<font color="#0000A0">1</font>);
|
|
||||||
range->push_back(<font color="#0000A0">2</font>);
|
|
||||||
range->push_back(<font color="#0000A0">3</font>);
|
|
||||||
range->push_back(<font color="#0000A0">4</font>);
|
|
||||||
range->push_back(<font color="#0000A0">5</font>);
|
|
||||||
<B>return</B> boost::make_shared_container_range(range);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
<B>int</B> main() {
|
|
||||||
|
|
||||||
|
|
||||||
iterator i,end;
|
|
||||||
|
|
||||||
boost::tie(i,end) = return_range();
|
|
||||||
|
|
||||||
std::copy(i,end,std::ostream_iterator<<B>int</B>>(std::cout,<font color="#0000FF">","</font>));
|
|
||||||
std::cout.put(<font color="#0000FF">'\n'</font>);
|
|
||||||
|
|
||||||
<B>return</B> <font color="#0000A0">0</font>;
|
|
||||||
}
|
|
||||||
</PRE>
|
|
||||||
|
|
||||||
Though the <tt>range</tt> object only lives for the duration of the
|
|
||||||
<tt>return_range</tt> call, the reference counted
|
|
||||||
<tt>std::vector</tt> will live until <tt>i</tt> and <tt>end</tt>
|
|
||||||
are both destroyed. The output from this example is the same as
|
|
||||||
the previous two.
|
|
||||||
|
|
||||||
|
|
||||||
<hr>
|
|
||||||
<!-- hhmts start -->
|
|
||||||
Last modified: Mon Aug 11 11:27:03 EST 2003
|
|
||||||
<!-- hhmts end -->
|
|
||||||
<p><EFBFBD> Copyright 2003 The Trustees of Indiana University.
|
|
||||||
Use, modification and distribution is subject to 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)</p>
|
|
||||||
|
|
||||||
</body>
|
|
||||||
|
|
||||||
</html>
|
|
||||||
@@ -1,42 +0,0 @@
|
|||||||
// Copyright 2003 The Trustees of Indiana University.
|
|
||||||
|
|
||||||
// Use, modification and distribution is subject to 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/shared_container_iterator.hpp"
|
|
||||||
#include "boost/shared_ptr.hpp"
|
|
||||||
#include <algorithm>
|
|
||||||
#include <iostream>
|
|
||||||
#include <vector>
|
|
||||||
|
|
||||||
typedef boost::shared_container_iterator< std::vector<int> > iterator;
|
|
||||||
|
|
||||||
|
|
||||||
void set_range(iterator& i, iterator& end) {
|
|
||||||
|
|
||||||
boost::shared_ptr< std::vector<int> > ints(new std::vector<int>());
|
|
||||||
|
|
||||||
ints->push_back(0);
|
|
||||||
ints->push_back(1);
|
|
||||||
ints->push_back(2);
|
|
||||||
ints->push_back(3);
|
|
||||||
ints->push_back(4);
|
|
||||||
ints->push_back(5);
|
|
||||||
|
|
||||||
i = iterator(ints->begin(),ints);
|
|
||||||
end = iterator(ints->end(),ints);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int main() {
|
|
||||||
|
|
||||||
iterator i,end;
|
|
||||||
|
|
||||||
set_range(i,end);
|
|
||||||
|
|
||||||
std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
|
|
||||||
std::cout.put('\n');
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,43 +0,0 @@
|
|||||||
// Copyright 2003 The Trustees of Indiana University.
|
|
||||||
|
|
||||||
// Use, modification and distribution is subject to 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/shared_container_iterator.hpp"
|
|
||||||
#include "boost/shared_ptr.hpp"
|
|
||||||
#include <algorithm>
|
|
||||||
#include <iterator>
|
|
||||||
#include <iostream>
|
|
||||||
#include <vector>
|
|
||||||
|
|
||||||
|
|
||||||
template <typename Iterator>
|
|
||||||
void print_range_nl (Iterator begin, Iterator end) {
|
|
||||||
typedef typename std::iterator_traits<Iterator>::value_type val;
|
|
||||||
std::copy(begin,end,std::ostream_iterator<val>(std::cout,","));
|
|
||||||
std::cout.put('\n');
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int main() {
|
|
||||||
|
|
||||||
typedef boost::shared_ptr< std::vector<int> > ints_t;
|
|
||||||
{
|
|
||||||
ints_t ints(new std::vector<int>());
|
|
||||||
|
|
||||||
ints->push_back(0);
|
|
||||||
ints->push_back(1);
|
|
||||||
ints->push_back(2);
|
|
||||||
ints->push_back(3);
|
|
||||||
ints->push_back(4);
|
|
||||||
ints->push_back(5);
|
|
||||||
|
|
||||||
print_range_nl(boost::make_shared_container_iterator(ints->begin(),ints),
|
|
||||||
boost::make_shared_container_iterator(ints->end(),ints));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,41 +0,0 @@
|
|||||||
// Copyright 2003 The Trustees of Indiana University.
|
|
||||||
|
|
||||||
// Use, modification and distribution is subject to 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/shared_container_iterator.hpp"
|
|
||||||
#include "boost/shared_ptr.hpp"
|
|
||||||
#include "boost/tuple/tuple.hpp" // for boost::tie
|
|
||||||
#include <algorithm> // for std::copy
|
|
||||||
#include <iostream>
|
|
||||||
#include <vector>
|
|
||||||
|
|
||||||
|
|
||||||
typedef boost::shared_container_iterator< std::vector<int> > iterator;
|
|
||||||
|
|
||||||
std::pair<iterator,iterator>
|
|
||||||
return_range() {
|
|
||||||
boost::shared_ptr< std::vector<int> > range(new std::vector<int>());
|
|
||||||
range->push_back(0);
|
|
||||||
range->push_back(1);
|
|
||||||
range->push_back(2);
|
|
||||||
range->push_back(3);
|
|
||||||
range->push_back(4);
|
|
||||||
range->push_back(5);
|
|
||||||
return boost::make_shared_container_range(range);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int main() {
|
|
||||||
|
|
||||||
|
|
||||||
iterator i,end;
|
|
||||||
|
|
||||||
boost::tie(i,end) = return_range();
|
|
||||||
|
|
||||||
std::copy(i,end,std::ostream_iterator<int>(std::cout,","));
|
|
||||||
std::cout.put('\n');
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,64 +0,0 @@
|
|||||||
// Copyright 2003 The Trustees of Indiana University.
|
|
||||||
|
|
||||||
// Use, modification and distribution is subject to 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)
|
|
||||||
|
|
||||||
// Shared container iterator adaptor
|
|
||||||
// Author: Ronald Garcia
|
|
||||||
// See http://boost.org/libs/utility/shared_container_iterator.html
|
|
||||||
// for documentation.
|
|
||||||
|
|
||||||
//
|
|
||||||
// shared_iterator_test.cpp - Regression tests for shared_container_iterator.
|
|
||||||
//
|
|
||||||
|
|
||||||
|
|
||||||
#include "boost/shared_container_iterator.hpp"
|
|
||||||
#include "boost/shared_ptr.hpp"
|
|
||||||
#include <vector>
|
|
||||||
#include <cassert>
|
|
||||||
|
|
||||||
struct resource {
|
|
||||||
static int count;
|
|
||||||
resource() { ++count; }
|
|
||||||
resource(resource const&) { ++count; }
|
|
||||||
~resource() { --count; }
|
|
||||||
};
|
|
||||||
int resource::count = 0;
|
|
||||||
|
|
||||||
typedef std::vector<resource> resources_t;
|
|
||||||
|
|
||||||
typedef boost::shared_container_iterator< resources_t > iterator;
|
|
||||||
|
|
||||||
|
|
||||||
void set_range(iterator& i, iterator& end) {
|
|
||||||
|
|
||||||
boost::shared_ptr< resources_t > objs(new resources_t());
|
|
||||||
|
|
||||||
for (int j = 0; j != 6; ++j)
|
|
||||||
objs->push_back(resource());
|
|
||||||
|
|
||||||
i = iterator(objs->begin(),objs);
|
|
||||||
end = iterator(objs->end(),objs);
|
|
||||||
assert(resource::count == 6);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int main() {
|
|
||||||
|
|
||||||
assert(resource::count == 0);
|
|
||||||
|
|
||||||
{
|
|
||||||
iterator i;
|
|
||||||
{
|
|
||||||
iterator end;
|
|
||||||
set_range(i,end);
|
|
||||||
assert(resource::count == 6);
|
|
||||||
}
|
|
||||||
assert(resource::count == 6);
|
|
||||||
}
|
|
||||||
assert(resource::count == 0);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
1
sublibs
1
sublibs
@@ -1 +0,0 @@
|
|||||||
The existance of this file tells the regression reporting programs that the directory contains sub-directories which are libraries.
|
|
||||||
@@ -1,48 +0,0 @@
|
|||||||
# Copyright David Abrahams 2003.
|
|
||||||
|
|
||||||
# Distributed under the Boost Software License, Version 1.0.
|
|
||||||
# See http://www.boost.org/LICENSE_1_0.txt
|
|
||||||
|
|
||||||
# For more information, see http://www.boost.org/
|
|
||||||
|
|
||||||
# bring in rules for testing
|
|
||||||
import testing ;
|
|
||||||
|
|
||||||
alias unit_test_framework
|
|
||||||
: # sources
|
|
||||||
/boost//unit_test_framework
|
|
||||||
;
|
|
||||||
|
|
||||||
# Please keep the tests ordered by filename
|
|
||||||
test-suite utility
|
|
||||||
:
|
|
||||||
[ run ../base_from_member_test.cpp ]
|
|
||||||
[ run ../base_from_member_ref_test.cpp ]
|
|
||||||
[ run ../binary_test.cpp ]
|
|
||||||
[ run ../call_traits_test.cpp : -u ]
|
|
||||||
[ run ../compressed_pair_test.cpp ../../test/build//boost_test_exec_monitor/<link>static : -u ]
|
|
||||||
[ run ../iterators_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
|
|
||||||
[ run next_prior_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
|
|
||||||
[ run ../numeric_traits_test.cpp ]
|
|
||||||
[ run ../operators_test.cpp ../../test/build//boost_test_exec_monitor/<link>static ]
|
|
||||||
[ compile result_of_test.cpp ]
|
|
||||||
[ run ../shared_iterator_test.cpp ]
|
|
||||||
[ run string_ref_test1.cpp unit_test_framework ]
|
|
||||||
[ run string_ref_test2.cpp unit_test_framework ]
|
|
||||||
[ run string_ref_test_io.cpp unit_test_framework ]
|
|
||||||
[ run string_view_test1.cpp unit_test_framework ]
|
|
||||||
[ run string_view_test2.cpp unit_test_framework ]
|
|
||||||
[ run string_view_test3.cpp ]
|
|
||||||
[ run string_view_test_io.cpp unit_test_framework ]
|
|
||||||
[ run ../value_init_test.cpp ]
|
|
||||||
[ run ../value_init_workaround_test.cpp ]
|
|
||||||
[ run ../initialized_test.cpp ]
|
|
||||||
[ compile-fail ../value_init_test_fail1.cpp ]
|
|
||||||
[ compile-fail ../value_init_test_fail2.cpp ]
|
|
||||||
[ compile-fail ../value_init_test_fail3.cpp ]
|
|
||||||
[ compile-fail ../initialized_test_fail1.cpp ]
|
|
||||||
[ compile-fail ../initialized_test_fail2.cpp ]
|
|
||||||
|
|
||||||
[ run ../generator_iterator_test.cpp ]
|
|
||||||
;
|
|
||||||
|
|
||||||
@@ -1,15 +0,0 @@
|
|||||||
<?xml version="1.0" encoding="utf-8"?>
|
|
||||||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
|
||||||
<ImportGroup Label="PropertySheets" />
|
|
||||||
<PropertyGroup Label="UserMacros" />
|
|
||||||
<PropertyGroup />
|
|
||||||
<ItemDefinitionGroup>
|
|
||||||
<ClCompile>
|
|
||||||
<AdditionalIncludeDirectories>../../../../..</AdditionalIncludeDirectories>
|
|
||||||
</ClCompile>
|
|
||||||
<PostBuildEvent>
|
|
||||||
<Command>"$(TargetDir)\$(TargetName).exe"</Command>
|
|
||||||
</PostBuildEvent>
|
|
||||||
</ItemDefinitionGroup>
|
|
||||||
<ItemGroup />
|
|
||||||
</Project>
|
|
||||||
@@ -1,22 +0,0 @@
|
|||||||
|
|
||||||
Microsoft Visual Studio Solution File, Format Version 12.00
|
|
||||||
# Visual Studio 14
|
|
||||||
VisualStudioVersion = 14.0.22823.1
|
|
||||||
MinimumVisualStudioVersion = 10.0.40219.1
|
|
||||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "string_view_test3", "string_view_test3\string_view_test3.vcxproj", "{4921E3AB-4466-4592-BA7A-3460AD616956}"
|
|
||||||
EndProject
|
|
||||||
Global
|
|
||||||
GlobalSection(SolutionConfigurationPlatforms) = preSolution
|
|
||||||
Debug|x86 = Debug|x86
|
|
||||||
Release|x86 = Release|x86
|
|
||||||
EndGlobalSection
|
|
||||||
GlobalSection(ProjectConfigurationPlatforms) = postSolution
|
|
||||||
{4921E3AB-4466-4592-BA7A-3460AD616956}.Debug|x86.ActiveCfg = Debug|Win32
|
|
||||||
{4921E3AB-4466-4592-BA7A-3460AD616956}.Debug|x86.Build.0 = Debug|Win32
|
|
||||||
{4921E3AB-4466-4592-BA7A-3460AD616956}.Release|x86.ActiveCfg = Release|Win32
|
|
||||||
{4921E3AB-4466-4592-BA7A-3460AD616956}.Release|x86.Build.0 = Release|Win32
|
|
||||||
EndGlobalSection
|
|
||||||
GlobalSection(SolutionProperties) = preSolution
|
|
||||||
HideSolutionNode = FALSE
|
|
||||||
EndGlobalSection
|
|
||||||
EndGlobal
|
|
||||||
@@ -1,90 +0,0 @@
|
|||||||
<?xml version="1.0" encoding="utf-8"?>
|
|
||||||
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
|
||||||
<ItemGroup Label="ProjectConfigurations">
|
|
||||||
<ProjectConfiguration Include="Debug|Win32">
|
|
||||||
<Configuration>Debug</Configuration>
|
|
||||||
<Platform>Win32</Platform>
|
|
||||||
</ProjectConfiguration>
|
|
||||||
<ProjectConfiguration Include="Release|Win32">
|
|
||||||
<Configuration>Release</Configuration>
|
|
||||||
<Platform>Win32</Platform>
|
|
||||||
</ProjectConfiguration>
|
|
||||||
</ItemGroup>
|
|
||||||
<PropertyGroup Label="Globals">
|
|
||||||
<ProjectGuid>{4921E3AB-4466-4592-BA7A-3460AD616956}</ProjectGuid>
|
|
||||||
<Keyword>Win32Proj</Keyword>
|
|
||||||
<RootNamespace>string_view_test3</RootNamespace>
|
|
||||||
</PropertyGroup>
|
|
||||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
|
||||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
|
|
||||||
<ConfigurationType>Application</ConfigurationType>
|
|
||||||
<UseDebugLibraries>true</UseDebugLibraries>
|
|
||||||
<PlatformToolset>v140</PlatformToolset>
|
|
||||||
<CharacterSet>Unicode</CharacterSet>
|
|
||||||
</PropertyGroup>
|
|
||||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
|
||||||
<ConfigurationType>Application</ConfigurationType>
|
|
||||||
<UseDebugLibraries>false</UseDebugLibraries>
|
|
||||||
<PlatformToolset>v140</PlatformToolset>
|
|
||||||
<WholeProgramOptimization>true</WholeProgramOptimization>
|
|
||||||
<CharacterSet>Unicode</CharacterSet>
|
|
||||||
</PropertyGroup>
|
|
||||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
|
|
||||||
<ImportGroup Label="ExtensionSettings">
|
|
||||||
</ImportGroup>
|
|
||||||
<ImportGroup Label="Shared">
|
|
||||||
</ImportGroup>
|
|
||||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
|
||||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
|
||||||
<Import Project="..\common.props" />
|
|
||||||
</ImportGroup>
|
|
||||||
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
|
||||||
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
|
|
||||||
<Import Project="..\common.props" />
|
|
||||||
</ImportGroup>
|
|
||||||
<PropertyGroup Label="UserMacros" />
|
|
||||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
|
||||||
<LinkIncremental>true</LinkIncremental>
|
|
||||||
</PropertyGroup>
|
|
||||||
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
|
||||||
<LinkIncremental>false</LinkIncremental>
|
|
||||||
</PropertyGroup>
|
|
||||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
|
|
||||||
<ClCompile>
|
|
||||||
<PrecompiledHeader>
|
|
||||||
</PrecompiledHeader>
|
|
||||||
<WarningLevel>Level3</WarningLevel>
|
|
||||||
<Optimization>Disabled</Optimization>
|
|
||||||
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
|
||||||
<SDLCheck>true</SDLCheck>
|
|
||||||
</ClCompile>
|
|
||||||
<Link>
|
|
||||||
<SubSystem>Console</SubSystem>
|
|
||||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
|
||||||
</Link>
|
|
||||||
</ItemDefinitionGroup>
|
|
||||||
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
|
||||||
<ClCompile>
|
|
||||||
<WarningLevel>Level3</WarningLevel>
|
|
||||||
<PrecompiledHeader>
|
|
||||||
</PrecompiledHeader>
|
|
||||||
<Optimization>MaxSpeed</Optimization>
|
|
||||||
<FunctionLevelLinking>true</FunctionLevelLinking>
|
|
||||||
<IntrinsicFunctions>true</IntrinsicFunctions>
|
|
||||||
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
|
|
||||||
<SDLCheck>true</SDLCheck>
|
|
||||||
</ClCompile>
|
|
||||||
<Link>
|
|
||||||
<SubSystem>Console</SubSystem>
|
|
||||||
<GenerateDebugInformation>true</GenerateDebugInformation>
|
|
||||||
<EnableCOMDATFolding>true</EnableCOMDATFolding>
|
|
||||||
<OptimizeReferences>true</OptimizeReferences>
|
|
||||||
</Link>
|
|
||||||
</ItemDefinitionGroup>
|
|
||||||
<ItemGroup>
|
|
||||||
<ClCompile Include="..\..\string_view_test3.cpp" />
|
|
||||||
</ItemGroup>
|
|
||||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
|
|
||||||
<ImportGroup Label="ExtensionTargets">
|
|
||||||
</ImportGroup>
|
|
||||||
</Project>
|
|
||||||
@@ -1,97 +0,0 @@
|
|||||||
// Boost test program for next() and prior() utilities.
|
|
||||||
|
|
||||||
// Copyright 2003 Daniel Walker. Use, modification, and distribution
|
|
||||||
// are subject to the Boost Software License, Version 1.0. (See
|
|
||||||
// accompanying file LICENSE_1_0.txt or a copy at
|
|
||||||
// http://www.boost.org/LICENSE_1_0.txt.)
|
|
||||||
|
|
||||||
// See http://www.boost.org/libs/utility for documentation.
|
|
||||||
|
|
||||||
// Revision History 13 Dec 2003 Initial Version (Daniel Walker)
|
|
||||||
|
|
||||||
// next() and prior() are replacements for operator+ and operator- for
|
|
||||||
// non-random-access iterators. The semantics of these operators are
|
|
||||||
// such that after executing j = i + n, std::distance(i, j) equals
|
|
||||||
// n. Tests are provided to ensure next() has the same
|
|
||||||
// result. Parallel tests are provided for prior(). The tests call
|
|
||||||
// next() and prior() several times. next() and prior() are very
|
|
||||||
// simple functions, though, and it would be very strange if these
|
|
||||||
// tests were to fail.
|
|
||||||
|
|
||||||
#define BOOST_INCLUDE_MAIN
|
|
||||||
#include <boost/test/test_tools.hpp>
|
|
||||||
|
|
||||||
#include <list>
|
|
||||||
#include <vector>
|
|
||||||
|
|
||||||
#include <boost/next_prior.hpp>
|
|
||||||
|
|
||||||
template<class RandomAccessIterator, class ForwardIterator>
|
|
||||||
bool plus_one_test(RandomAccessIterator first, RandomAccessIterator last, ForwardIterator first2)
|
|
||||||
{
|
|
||||||
RandomAccessIterator i = first;
|
|
||||||
ForwardIterator j = first2;
|
|
||||||
while(i != last)
|
|
||||||
i = i + 1, j = boost::next(j);
|
|
||||||
return std::distance(first, i) == std::distance(first2, j);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class RandomAccessIterator, class ForwardIterator>
|
|
||||||
bool plus_n_test(RandomAccessIterator first, RandomAccessIterator last, ForwardIterator first2)
|
|
||||||
{
|
|
||||||
RandomAccessIterator i = first;
|
|
||||||
ForwardIterator j = first2;
|
|
||||||
for(int n = 0; i != last; ++n)
|
|
||||||
i = first + n, j = boost::next(first2, n);
|
|
||||||
return std::distance(first, i) == std::distance(first2, j);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class RandomAccessIterator, class BidirectionalIterator>
|
|
||||||
bool minus_one_test(RandomAccessIterator first, RandomAccessIterator last, BidirectionalIterator last2)
|
|
||||||
{
|
|
||||||
RandomAccessIterator i = last;
|
|
||||||
BidirectionalIterator j = last2;
|
|
||||||
while(i != first)
|
|
||||||
i = i - 1, j = boost::prior(j);
|
|
||||||
return std::distance(i, last) == std::distance(j, last2);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class RandomAccessIterator, class BidirectionalIterator>
|
|
||||||
bool minus_n_test(RandomAccessIterator first, RandomAccessIterator last, BidirectionalIterator last2)
|
|
||||||
{
|
|
||||||
RandomAccessIterator i = last;
|
|
||||||
BidirectionalIterator j = last2;
|
|
||||||
for(int n = 0; i != first; ++n)
|
|
||||||
i = last - n, j = boost::prior(last2, n);
|
|
||||||
return std::distance(i, last) == std::distance(j, last2);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class Iterator, class Distance>
|
|
||||||
bool minus_n_unsigned_test(Iterator first, Iterator last, Distance size)
|
|
||||||
{
|
|
||||||
Iterator i = boost::prior(last, size);
|
|
||||||
return i == first;
|
|
||||||
}
|
|
||||||
|
|
||||||
int test_main(int, char*[])
|
|
||||||
{
|
|
||||||
std::vector<int> x(8);
|
|
||||||
std::list<int> y(x.begin(), x.end());
|
|
||||||
|
|
||||||
// Tests with iterators
|
|
||||||
BOOST_REQUIRE(plus_one_test(x.begin(), x.end(), y.begin()));
|
|
||||||
BOOST_REQUIRE(plus_n_test(x.begin(), x.end(), y.begin()));
|
|
||||||
BOOST_REQUIRE(minus_one_test(x.begin(), x.end(), y.end()));
|
|
||||||
BOOST_REQUIRE(minus_n_test(x.begin(), x.end(), y.end()));
|
|
||||||
BOOST_REQUIRE(minus_n_unsigned_test(x.begin(), x.end(), x.size()));
|
|
||||||
BOOST_REQUIRE(minus_n_unsigned_test(y.begin(), y.end(), y.size()));
|
|
||||||
|
|
||||||
// Tests with integers
|
|
||||||
BOOST_REQUIRE(boost::next(5) == 6);
|
|
||||||
BOOST_REQUIRE(boost::next(5, 7) == 12);
|
|
||||||
BOOST_REQUIRE(boost::prior(5) == 4);
|
|
||||||
BOOST_REQUIRE(boost::prior(5, 7) == -2);
|
|
||||||
BOOST_REQUIRE(boost::prior(5, 7u) == -2);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,316 +0,0 @@
|
|||||||
// Boost result_of library
|
|
||||||
|
|
||||||
// Copyright Douglas Gregor 2003-2004. Use, modification and
|
|
||||||
// distribution is subject to 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)
|
|
||||||
|
|
||||||
// Examples:
|
|
||||||
// To run the default test:
|
|
||||||
// $ cd libs/utility/test && bjam
|
|
||||||
// To test decltype on g++ 2.7:
|
|
||||||
// $ cd libs/utility/test && bjam cxxflags="-std=c++11 -D BOOST_RESULT_OF_USE_DECLTYPE"
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
|
|
||||||
// For more information, see http://www.boost.org/libs/utility
|
|
||||||
#include <boost/utility/result_of.hpp>
|
|
||||||
#include <utility>
|
|
||||||
#include <boost/static_assert.hpp>
|
|
||||||
#include <boost/type_traits/is_same.hpp>
|
|
||||||
|
|
||||||
struct int_result_type
|
|
||||||
{
|
|
||||||
typedef int result_type;
|
|
||||||
result_type operator()(float);
|
|
||||||
};
|
|
||||||
|
|
||||||
struct int_result_of
|
|
||||||
{
|
|
||||||
template<typename F> struct result { typedef int type; };
|
|
||||||
result<int_result_of(double)>::type operator()(double);
|
|
||||||
result<const int_result_of(double)>::type operator()(double) const;
|
|
||||||
result<int_result_of()>::type operator()();
|
|
||||||
result<volatile int_result_of()>::type operator()() volatile;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct int_result_type_and_float_result_of_and_char_return
|
|
||||||
{
|
|
||||||
typedef int result_type;
|
|
||||||
template<typename F> struct result { typedef float type; };
|
|
||||||
char operator()(char);
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
struct int_result_type_template
|
|
||||||
{
|
|
||||||
typedef int result_type;
|
|
||||||
result_type operator()(float);
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
struct int_result_of_template
|
|
||||||
{
|
|
||||||
template<typename F> struct result;
|
|
||||||
template<typename This, typename That> struct result<This(That)> { typedef int type; };
|
|
||||||
typename result<int_result_of_template<T>(double)>::type operator()(double);
|
|
||||||
typename result<const int_result_of_template<T>(double)>::type operator()(double) const;
|
|
||||||
typename result<int_result_of_template<T>(double)>::type operator()();
|
|
||||||
typename result<volatile int_result_of_template<T>(double)>::type operator()() volatile;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
struct int_result_type_and_float_result_of_and_char_return_template
|
|
||||||
{
|
|
||||||
typedef int result_type;
|
|
||||||
template<typename F> struct result;
|
|
||||||
template<typename This, typename That> struct result<This(That)> { typedef float type; };
|
|
||||||
char operator()(char);
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
struct cv_overload_check {};
|
|
||||||
|
|
||||||
struct result_of_member_function_template
|
|
||||||
{
|
|
||||||
template<typename F> struct result;
|
|
||||||
|
|
||||||
template<typename This, typename That> struct result<This(That)> { typedef That type; };
|
|
||||||
template<class T> typename result<result_of_member_function_template(T)>::type operator()(T);
|
|
||||||
|
|
||||||
template<typename This, typename That> struct result<const This(That)> { typedef cv_overload_check<const That> type; };
|
|
||||||
template<class T> typename result<const result_of_member_function_template(T)>::type operator()(T) const;
|
|
||||||
|
|
||||||
template<typename This, typename That> struct result<volatile This(That)> { typedef cv_overload_check<volatile That> type; };
|
|
||||||
template<class T> typename result<volatile result_of_member_function_template(T)>::type operator()(T) volatile;
|
|
||||||
|
|
||||||
template<typename This, typename That> struct result<const volatile This(That)> { typedef cv_overload_check<const volatile That> type; };
|
|
||||||
template<class T> typename result<const volatile result_of_member_function_template(T)>::type operator()(T) const volatile;
|
|
||||||
|
|
||||||
template<typename This, typename That> struct result<This(That &, That)> { typedef That & type; };
|
|
||||||
template<class T> typename result<result_of_member_function_template(T &, T)>::type operator()(T &, T);
|
|
||||||
|
|
||||||
template<typename This, typename That> struct result<This(That const &, That)> { typedef That const & type; };
|
|
||||||
template<class T> typename result<result_of_member_function_template(T const &, T)>::type operator()(T const &, T);
|
|
||||||
|
|
||||||
template<typename This, typename That> struct result<This(That volatile &, That)> { typedef That volatile & type; };
|
|
||||||
template<class T> typename result<result_of_member_function_template(T volatile &, T)>::type operator()(T volatile &, T);
|
|
||||||
|
|
||||||
template<typename This, typename That> struct result<This(That const volatile &, That)> { typedef That const volatile & type; };
|
|
||||||
template<class T> typename result<result_of_member_function_template(T const volatile &, T)>::type operator()(T const volatile &, T);
|
|
||||||
};
|
|
||||||
|
|
||||||
struct no_result_type_or_result
|
|
||||||
{
|
|
||||||
short operator()(double);
|
|
||||||
cv_overload_check<const short> operator()(double) const;
|
|
||||||
cv_overload_check<volatile short> operator()(double) volatile;
|
|
||||||
cv_overload_check<const volatile short> operator()(double) const volatile;
|
|
||||||
int operator()();
|
|
||||||
cv_overload_check<const int> operator()() const;
|
|
||||||
cv_overload_check<volatile int> operator()() volatile;
|
|
||||||
cv_overload_check<const volatile int> operator()() const volatile;
|
|
||||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
|
||||||
short operator()(int&&);
|
|
||||||
int operator()(int&);
|
|
||||||
long operator()(int const&);
|
|
||||||
#endif
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
struct no_result_type_or_result_template
|
|
||||||
{
|
|
||||||
short operator()(double);
|
|
||||||
cv_overload_check<const short> operator()(double) const;
|
|
||||||
cv_overload_check<volatile short> operator()(double) volatile;
|
|
||||||
cv_overload_check<const volatile short> operator()(double) const volatile;
|
|
||||||
int operator()();
|
|
||||||
cv_overload_check<const int> operator()() const;
|
|
||||||
cv_overload_check<volatile int> operator()() volatile;
|
|
||||||
cv_overload_check<const volatile int> operator()() const volatile;
|
|
||||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
|
||||||
short operator()(int&&);
|
|
||||||
int operator()(int&);
|
|
||||||
long operator()(int const&);
|
|
||||||
#endif
|
|
||||||
};
|
|
||||||
|
|
||||||
// sfinae_tests are derived from example code from Joel de Guzman,
|
|
||||||
// which demonstrated the interaction between result_of and SFINAE.
|
|
||||||
template <typename F, typename Arg>
|
|
||||||
typename boost::result_of<F(Arg const&)>::type
|
|
||||||
sfinae_test(F f, Arg const& arg)
|
|
||||||
{
|
|
||||||
return f(arg);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename F, typename Arg>
|
|
||||||
typename boost::result_of<F(Arg&)>::type
|
|
||||||
sfinae_test(F f, Arg& arg)
|
|
||||||
{
|
|
||||||
return f(arg);
|
|
||||||
}
|
|
||||||
|
|
||||||
int sfinae_test_f(int& i)
|
|
||||||
{
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
struct X {};
|
|
||||||
|
|
||||||
int main()
|
|
||||||
{
|
|
||||||
using namespace boost;
|
|
||||||
|
|
||||||
typedef int (*func_ptr)(float, double);
|
|
||||||
typedef int (&func_ref)(float, double);
|
|
||||||
typedef int (*func_ptr_0)();
|
|
||||||
typedef int (&func_ref_0)();
|
|
||||||
typedef void (*func_ptr_void)(float, double);
|
|
||||||
typedef void (&func_ref_void)(float, double);
|
|
||||||
typedef void (*func_ptr_void_0)();
|
|
||||||
typedef void (&func_ref_void_0)();
|
|
||||||
typedef int (X::*mem_func_ptr)(float);
|
|
||||||
typedef int (X::*mem_func_ptr_c)(float) const;
|
|
||||||
typedef int (X::*mem_func_ptr_v)(float) volatile;
|
|
||||||
typedef int (X::*mem_func_ptr_cv)(float) const volatile;
|
|
||||||
typedef int (X::*mem_func_ptr_0)();
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type(float)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(double)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of(double)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_template<void>(float)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(double)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of_template<void>(double)>::type, int>::value));
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type(float)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_of(double)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<const int_result_of(double)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_template<void>(float)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_of_template<void>(double)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<const int_result_of_template<void>(double)>::type, int>::value));
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_of(void)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile int_result_of(void)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_of_template<void>(void)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
|
|
||||||
|
|
||||||
// Prior to decltype, result_of could not deduce the return type
|
|
||||||
// of nullary function objects unless they exposed a result_type.
|
|
||||||
#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, int>::value));
|
|
||||||
#else
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_of_template<void>(void)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of_template<void>(void)>::type, void>::value));
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// Prior to decltype, result_of ignored a nested result<> if
|
|
||||||
// result_type was defined. After decltype, result_of deduces the
|
|
||||||
// actual return type of the function object, ignoring both
|
|
||||||
// result<> and result_type.
|
|
||||||
#if defined(BOOST_RESULT_OF_USE_DECLTYPE)
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, char>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, char>::value));
|
|
||||||
#else
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
|
|
||||||
#endif
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return(char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<int_result_type_and_float_result_of_and_char_return_template<void>(char)>::type, int>::value));
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_0()>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ref_0()>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_void(char, float)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ref_void(char, float)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ptr_void_0()>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<func_ref_void_0()>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr(X,char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_c(X,char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_v(X,char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_0(X)>::type, int>::value));
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr(char, float)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref(char, float)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_0()>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_0()>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_void(char, float)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_void(char, float)>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr_void_0()>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref_void_0()>::type, void>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr(X,char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_c(X,char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_v(X,char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<mem_func_ptr_0(X)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ptr(void)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<func_ref(void)>::type, int>::value));
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(double)>::type, double>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const result_of_member_function_template(double)>::type, cv_overload_check<const double> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile result_of_member_function_template(double)>::type, cv_overload_check<volatile double> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const volatile result_of_member_function_template(double)>::type, cv_overload_check<const volatile double> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<result_of_member_function_template(int const volatile &, int)>::type, int const volatile &>::value));
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(double)>::type, double>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<const result_of_member_function_template(double)>::type, cv_overload_check<const double> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<volatile result_of_member_function_template(double)>::type, cv_overload_check<volatile double> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<const volatile result_of_member_function_template(double)>::type, cv_overload_check<const volatile double> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int &, int)>::type, int &>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int const &, int)>::type, int const &>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int volatile &, int)>::type, int volatile &>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<result_of_member_function_template(int const volatile &, int)>::type, int const volatile &>::value));
|
|
||||||
|
|
||||||
typedef int (*pf_t)(int);
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<pf_t(int)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<pf_t const(int)>::type,int>::value));
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<pf_t(int)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<tr1_result_of<pf_t const(int)>::type,int>::value));
|
|
||||||
|
|
||||||
#if defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(double)>::type, short>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result(double)>::type, cv_overload_check<const short> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result(double)>::type, cv_overload_check<volatile short> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result(double)>::type, cv_overload_check<const volatile short> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(void)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result(void)>::type, cv_overload_check<const int> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result(void)>::type, cv_overload_check<volatile int> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result(void)>::type, cv_overload_check<const volatile int> >::value));
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(double)>::type, short>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_template<void>(double)>::type, cv_overload_check<const short> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_template<void>(double)>::type, cv_overload_check<volatile short> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_template<void>(double)>::type, cv_overload_check<const volatile short> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(void)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const no_result_type_or_result_template<void>(void)>::type, cv_overload_check<const int> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<volatile no_result_type_or_result_template<void>(void)>::type, cv_overload_check<volatile int> >::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<const volatile no_result_type_or_result_template<void>(void)>::type, cv_overload_check<const volatile int> >::value));
|
|
||||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int&&)>::type, short>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int&)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result(int const&)>::type, long>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int&&)>::type, short>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int&)>::type, int>::value));
|
|
||||||
BOOST_STATIC_ASSERT((is_same<result_of<no_result_type_or_result_template<void>(int const&)>::type, long>::value));
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
|
|
||||||
int i = 123;
|
|
||||||
sfinae_test(sfinae_test_f, i);
|
|
||||||
#endif // defined(BOOST_RESULT_OF_USE_DECLTYPE) || defined(BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK)
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
@@ -1,109 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright (c) Marshall Clow 2012-2012.
|
|
||||||
|
|
||||||
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)
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
#include <boost/utility/string_ref.hpp>
|
|
||||||
|
|
||||||
#define BOOST_TEST_MAIN
|
|
||||||
#include <boost/test/unit_test.hpp>
|
|
||||||
|
|
||||||
typedef boost::string_ref string_ref;
|
|
||||||
|
|
||||||
// Should be equal
|
|
||||||
void interop ( const std::string &str, string_ref ref ) {
|
|
||||||
// BOOST_CHECK ( str == ref );
|
|
||||||
BOOST_CHECK ( str.size () == ref.size ());
|
|
||||||
BOOST_CHECK ( std::equal ( str.begin (), str.end (), ref.begin ()));
|
|
||||||
BOOST_CHECK ( std::equal ( str.rbegin (), str.rend (), ref.rbegin ()));
|
|
||||||
}
|
|
||||||
|
|
||||||
void null_tests ( const char *p ) {
|
|
||||||
// All zero-length string-refs should be equal
|
|
||||||
string_ref sr1; // NULL, 0
|
|
||||||
string_ref sr2 ( NULL, 0 );
|
|
||||||
string_ref sr3 ( p, 0 );
|
|
||||||
string_ref sr4 ( p );
|
|
||||||
sr4.clear ();
|
|
||||||
|
|
||||||
BOOST_CHECK ( sr1 == sr2 );
|
|
||||||
BOOST_CHECK ( sr1 == sr3 );
|
|
||||||
BOOST_CHECK ( sr2 == sr3 );
|
|
||||||
BOOST_CHECK ( sr1 == sr4 );
|
|
||||||
}
|
|
||||||
|
|
||||||
// make sure that substrings work just like strings
|
|
||||||
void test_substr ( const std::string &str ) {
|
|
||||||
const size_t sz = str.size ();
|
|
||||||
string_ref ref ( str );
|
|
||||||
|
|
||||||
// Substrings at the end
|
|
||||||
for ( size_t i = 0; i <= sz; ++ i )
|
|
||||||
interop ( str.substr ( i ), ref.substr ( i ));
|
|
||||||
|
|
||||||
// Substrings at the beginning
|
|
||||||
for ( size_t i = 0; i <= sz; ++ i )
|
|
||||||
interop ( str.substr ( 0, i ), ref.substr ( 0, i ));
|
|
||||||
|
|
||||||
// All possible substrings
|
|
||||||
for ( size_t i = 0; i < sz; ++i )
|
|
||||||
for ( size_t j = i; j < sz; ++j )
|
|
||||||
interop ( str.substr ( i, j ), ref.substr ( i, j ));
|
|
||||||
}
|
|
||||||
|
|
||||||
// make sure that removing prefixes and suffixes work just like strings
|
|
||||||
void test_remove ( const std::string &str ) {
|
|
||||||
const size_t sz = str.size ();
|
|
||||||
std::string work;
|
|
||||||
string_ref ref;
|
|
||||||
|
|
||||||
for ( size_t i = 1; i <= sz; ++i ) {
|
|
||||||
work = str;
|
|
||||||
ref = str;
|
|
||||||
while ( ref.size () >= i ) {
|
|
||||||
interop ( work, ref );
|
|
||||||
work.erase ( 0, i );
|
|
||||||
ref.remove_prefix (i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for ( size_t i = 1; i < sz; ++ i ) {
|
|
||||||
work = str;
|
|
||||||
ref = str;
|
|
||||||
while ( ref.size () >= i ) {
|
|
||||||
interop ( work, ref );
|
|
||||||
work.erase ( work.size () - i, i );
|
|
||||||
ref.remove_suffix (i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const char *test_strings [] = {
|
|
||||||
"",
|
|
||||||
"1",
|
|
||||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ",
|
|
||||||
"0123456789",
|
|
||||||
NULL
|
|
||||||
};
|
|
||||||
|
|
||||||
BOOST_AUTO_TEST_CASE( test_main )
|
|
||||||
{
|
|
||||||
const char **p = &test_strings[0];
|
|
||||||
|
|
||||||
while ( *p != NULL ) {
|
|
||||||
interop ( *p, *p );
|
|
||||||
test_substr ( *p );
|
|
||||||
test_remove ( *p );
|
|
||||||
null_tests ( *p );
|
|
||||||
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,318 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright (c) Marshall Clow 2012-2012.
|
|
||||||
|
|
||||||
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)
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
#include <cstring> // for std::strchr
|
|
||||||
|
|
||||||
#include <boost/utility/string_ref.hpp>
|
|
||||||
|
|
||||||
#define BOOST_TEST_MAIN
|
|
||||||
#include <boost/test/unit_test.hpp>
|
|
||||||
|
|
||||||
typedef boost::string_ref string_ref;
|
|
||||||
|
|
||||||
void ends_with ( const char *arg ) {
|
|
||||||
const size_t sz = std::strlen ( arg );
|
|
||||||
string_ref sr ( arg );
|
|
||||||
string_ref sr2 ( arg );
|
|
||||||
const char *p = arg;
|
|
||||||
|
|
||||||
while ( *p ) {
|
|
||||||
BOOST_CHECK ( sr.ends_with ( p ));
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
while ( !sr2.empty ()) {
|
|
||||||
BOOST_CHECK ( sr.ends_with ( sr2 ));
|
|
||||||
sr2.remove_prefix (1);
|
|
||||||
}
|
|
||||||
|
|
||||||
sr2 = arg;
|
|
||||||
while ( !sr2.empty ()) {
|
|
||||||
BOOST_CHECK ( sr.ends_with ( sr2 ));
|
|
||||||
sr2.remove_prefix (1);
|
|
||||||
}
|
|
||||||
|
|
||||||
char ch = sz == 0 ? '\0' : arg [ sz - 1 ];
|
|
||||||
sr2 = arg;
|
|
||||||
if ( sz > 0 )
|
|
||||||
BOOST_CHECK ( sr2.ends_with ( ch ));
|
|
||||||
BOOST_CHECK ( !sr2.ends_with ( ++ch ));
|
|
||||||
BOOST_CHECK ( sr2.ends_with ( string_ref ()));
|
|
||||||
}
|
|
||||||
|
|
||||||
void starts_with ( const char *arg ) {
|
|
||||||
const size_t sz = std::strlen ( arg );
|
|
||||||
string_ref sr ( arg );
|
|
||||||
string_ref sr2 ( arg );
|
|
||||||
const char *p = arg + std::strlen ( arg ) - 1;
|
|
||||||
while ( p >= arg ) {
|
|
||||||
std::string foo ( arg, p + 1 );
|
|
||||||
BOOST_CHECK ( sr.starts_with ( foo ));
|
|
||||||
--p;
|
|
||||||
}
|
|
||||||
|
|
||||||
while ( !sr2.empty ()) {
|
|
||||||
BOOST_CHECK ( sr.starts_with ( sr2 ));
|
|
||||||
sr2.remove_suffix (1);
|
|
||||||
}
|
|
||||||
|
|
||||||
char ch = *arg;
|
|
||||||
sr2 = arg;
|
|
||||||
if ( sz > 0 )
|
|
||||||
BOOST_CHECK ( sr2.starts_with ( ch ));
|
|
||||||
BOOST_CHECK ( !sr2.starts_with ( ++ch ));
|
|
||||||
BOOST_CHECK ( sr2.starts_with ( string_ref ()));
|
|
||||||
}
|
|
||||||
|
|
||||||
void reverse ( const char *arg ) {
|
|
||||||
// Round trip
|
|
||||||
string_ref sr1 ( arg );
|
|
||||||
std::string string1 ( sr1.rbegin (), sr1.rend ());
|
|
||||||
string_ref sr2 ( string1 );
|
|
||||||
std::string string2 ( sr2.rbegin (), sr2.rend ());
|
|
||||||
|
|
||||||
BOOST_CHECK ( std::equal ( sr2.rbegin (), sr2.rend (), arg ));
|
|
||||||
BOOST_CHECK ( string2 == arg );
|
|
||||||
BOOST_CHECK ( std::equal ( sr1.begin (), sr1.end (), string2.begin ()));
|
|
||||||
}
|
|
||||||
|
|
||||||
// This helper function eliminates signed vs. unsigned warnings
|
|
||||||
string_ref::size_type ptr_diff ( const char *res, const char *base ) {
|
|
||||||
BOOST_CHECK ( res >= base );
|
|
||||||
return static_cast<string_ref::size_type> ( res - base );
|
|
||||||
}
|
|
||||||
|
|
||||||
void find ( const char *arg ) {
|
|
||||||
string_ref sr1;
|
|
||||||
string_ref sr2;
|
|
||||||
const char *p;
|
|
||||||
|
|
||||||
// Look for each character in the string(searching from the start)
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( *p ) {
|
|
||||||
string_ref::size_type pos = sr1.find(*p);
|
|
||||||
BOOST_CHECK ( pos != string_ref::npos && ( pos <= ptr_diff ( p, arg )));
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Look for each character in the string (searching from the end)
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( *p ) {
|
|
||||||
string_ref::size_type pos = sr1.rfind(*p);
|
|
||||||
BOOST_CHECK ( pos != string_ref::npos && pos < sr1.size () && ( pos >= ptr_diff ( p, arg )));
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Look for pairs on characters (searching from the start)
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg;
|
|
||||||
while ( *p && *(p+1)) {
|
|
||||||
string_ref sr3 ( p, 2 );
|
|
||||||
string_ref::size_type pos = sr1.find ( sr3 );
|
|
||||||
BOOST_CHECK ( pos != string_ref::npos && pos <= static_cast<string_ref::size_type>( p - arg ));
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg;
|
|
||||||
// for all possible chars, see if we find them in the right place.
|
|
||||||
// Note that strchr will/might do the _wrong_ thing if we search for NULL
|
|
||||||
for ( int ch = 1; ch < 256; ++ch ) {
|
|
||||||
string_ref::size_type pos = sr1.find(ch);
|
|
||||||
const char *strp = std::strchr ( arg, ch );
|
|
||||||
BOOST_CHECK (( strp == NULL ) == ( pos == string_ref::npos ));
|
|
||||||
if ( strp != NULL )
|
|
||||||
BOOST_CHECK ( ptr_diff ( strp, arg ) == pos );
|
|
||||||
}
|
|
||||||
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg;
|
|
||||||
// for all possible chars, see if we find them in the right place.
|
|
||||||
// Note that strchr will/might do the _wrong_ thing if we search for NULL
|
|
||||||
for ( int ch = 1; ch < 256; ++ch ) {
|
|
||||||
string_ref::size_type pos = sr1.rfind(ch);
|
|
||||||
const char *strp = std::strrchr ( arg, ch );
|
|
||||||
BOOST_CHECK (( strp == NULL ) == ( pos == string_ref::npos ));
|
|
||||||
if ( strp != NULL )
|
|
||||||
BOOST_CHECK ( ptr_diff ( strp, arg ) == pos );
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Find everything at the start
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( !sr1.empty ()) {
|
|
||||||
string_ref::size_type pos = sr1.find(*p);
|
|
||||||
BOOST_CHECK ( pos == 0 );
|
|
||||||
sr1.remove_prefix (1);
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find everything at the end
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg + std::strlen ( arg ) - 1;
|
|
||||||
while ( !sr1.empty ()) {
|
|
||||||
string_ref::size_type pos = sr1.rfind(*p);
|
|
||||||
BOOST_CHECK ( pos == sr1.size () - 1 );
|
|
||||||
sr1.remove_suffix (1);
|
|
||||||
--p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find everything at the start
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg;
|
|
||||||
while ( !sr1.empty ()) {
|
|
||||||
string_ref::size_type pos = sr1.find_first_of(*p);
|
|
||||||
BOOST_CHECK ( pos == 0 );
|
|
||||||
sr1.remove_prefix (1);
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Find everything at the end
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg + std::strlen ( arg ) - 1;
|
|
||||||
while ( !sr1.empty ()) {
|
|
||||||
string_ref::size_type pos = sr1.find_last_of(*p);
|
|
||||||
BOOST_CHECK ( pos == sr1.size () - 1 );
|
|
||||||
sr1.remove_suffix (1);
|
|
||||||
--p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Basic sanity checking for "find_first_of / find_first_not_of"
|
|
||||||
sr1 = arg;
|
|
||||||
sr2 = arg;
|
|
||||||
while ( !sr1.empty() ) {
|
|
||||||
BOOST_CHECK ( sr1.find_first_of ( sr2 ) == 0 );
|
|
||||||
BOOST_CHECK ( sr1.find_first_not_of ( sr2 ) == string_ref::npos );
|
|
||||||
sr1.remove_prefix ( 1 );
|
|
||||||
}
|
|
||||||
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( *p ) {
|
|
||||||
string_ref::size_type pos1 = sr1.find_first_of(*p);
|
|
||||||
string_ref::size_type pos2 = sr1.find_first_not_of(*p);
|
|
||||||
BOOST_CHECK ( pos1 != string_ref::npos && pos1 < sr1.size () && pos1 <= ptr_diff ( p, arg ));
|
|
||||||
if ( pos2 != string_ref::npos ) {
|
|
||||||
for ( size_t i = 0 ; i < pos2; ++i )
|
|
||||||
BOOST_CHECK ( sr1[i] == *p );
|
|
||||||
BOOST_CHECK ( sr1 [ pos2 ] != *p );
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CHECK ( pos2 != pos1 );
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Basic sanity checking for "find_last_of / find_last_not_of"
|
|
||||||
sr1 = arg;
|
|
||||||
sr2 = arg;
|
|
||||||
while ( !sr1.empty() ) {
|
|
||||||
BOOST_CHECK ( sr1.find_last_of ( sr2 ) == ( sr1.size () - 1 ));
|
|
||||||
BOOST_CHECK ( sr1.find_last_not_of ( sr2 ) == string_ref::npos );
|
|
||||||
sr1.remove_suffix ( 1 );
|
|
||||||
}
|
|
||||||
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( *p ) {
|
|
||||||
string_ref::size_type pos1 = sr1.find_last_of(*p);
|
|
||||||
string_ref::size_type pos2 = sr1.find_last_not_of(*p);
|
|
||||||
BOOST_CHECK ( pos1 != string_ref::npos && pos1 < sr1.size () && pos1 >= ptr_diff ( p, arg ));
|
|
||||||
BOOST_CHECK ( pos2 == string_ref::npos || pos1 < sr1.size ());
|
|
||||||
if ( pos2 != string_ref::npos ) {
|
|
||||||
for ( size_t i = sr1.size () -1 ; i > pos2; --i )
|
|
||||||
BOOST_CHECK ( sr1[i] == *p );
|
|
||||||
BOOST_CHECK ( sr1 [ pos2 ] != *p );
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CHECK ( pos2 != pos1 );
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void to_string ( const char *arg ) {
|
|
||||||
string_ref sr1;
|
|
||||||
std::string str1;
|
|
||||||
std::string str2;
|
|
||||||
|
|
||||||
str1.assign ( arg );
|
|
||||||
sr1 = arg;
|
|
||||||
// str2 = sr1.to_string<std::allocator<char> > ();
|
|
||||||
str2 = sr1.to_string ();
|
|
||||||
BOOST_CHECK ( str1 == str2 );
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
|
|
||||||
std::string str3 = static_cast<std::string> ( sr1 );
|
|
||||||
BOOST_CHECK ( str1 == str3 );
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void compare ( const char *arg ) {
|
|
||||||
string_ref sr1;
|
|
||||||
std::string str1;
|
|
||||||
std::string str2 = str1;
|
|
||||||
|
|
||||||
str1.assign ( arg );
|
|
||||||
sr1 = arg;
|
|
||||||
BOOST_CHECK ( sr1 == sr1); // compare string_ref and string_ref
|
|
||||||
BOOST_CHECK ( sr1 == str1); // compare string and string_ref
|
|
||||||
BOOST_CHECK ( str1 == sr1 ); // compare string_ref and string
|
|
||||||
BOOST_CHECK ( sr1 == arg ); // compare string_ref and pointer
|
|
||||||
BOOST_CHECK ( arg == sr1 ); // compare pointer and string_ref
|
|
||||||
|
|
||||||
if ( sr1.size () > 0 ) {
|
|
||||||
(*str1.rbegin())++;
|
|
||||||
BOOST_CHECK ( sr1 != str1 );
|
|
||||||
BOOST_CHECK ( str1 != sr1 );
|
|
||||||
BOOST_CHECK ( sr1 < str1 );
|
|
||||||
BOOST_CHECK ( sr1 <= str1 );
|
|
||||||
BOOST_CHECK ( str1 > sr1 );
|
|
||||||
BOOST_CHECK ( str1 >= sr1 );
|
|
||||||
|
|
||||||
(*str1.rbegin()) -= 2;
|
|
||||||
BOOST_CHECK ( sr1 != str1 );
|
|
||||||
BOOST_CHECK ( str1 != sr1 );
|
|
||||||
BOOST_CHECK ( sr1 > str1 );
|
|
||||||
BOOST_CHECK ( sr1 >= str1 );
|
|
||||||
BOOST_CHECK ( str1 < sr1 );
|
|
||||||
BOOST_CHECK ( str1 <= sr1 );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const char *test_strings [] = {
|
|
||||||
"",
|
|
||||||
"0",
|
|
||||||
"abc",
|
|
||||||
"AAA", // all the same
|
|
||||||
"adsfadadiaef;alkdg;aljt;j agl;sjrl;tjs;lga;lretj;srg[w349u5209dsfadfasdfasdfadsf",
|
|
||||||
"abc\0asdfadsfasf",
|
|
||||||
NULL
|
|
||||||
};
|
|
||||||
|
|
||||||
BOOST_AUTO_TEST_CASE( test_main )
|
|
||||||
{
|
|
||||||
const char **p = &test_strings[0];
|
|
||||||
|
|
||||||
while ( *p != NULL ) {
|
|
||||||
starts_with ( *p );
|
|
||||||
ends_with ( *p );
|
|
||||||
reverse ( *p );
|
|
||||||
find ( *p );
|
|
||||||
to_string ( *p );
|
|
||||||
compare ( *p );
|
|
||||||
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,183 +0,0 @@
|
|||||||
/*
|
|
||||||
* Copyright Andrey Semashev 2013.
|
|
||||||
* 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)
|
|
||||||
*/
|
|
||||||
/*!
|
|
||||||
* \file string_ref_test_io.cpp
|
|
||||||
* \author Andrey Semashev
|
|
||||||
* \date 26.05.2013
|
|
||||||
*
|
|
||||||
* \brief This header contains tests for stream operations of \c basic_string_ref.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define BOOST_TEST_MODULE string_ref_test_io
|
|
||||||
|
|
||||||
#include <boost/utility/string_ref.hpp>
|
|
||||||
|
|
||||||
#include <iomanip>
|
|
||||||
#include <sstream>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <iterator>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <boost/mpl/vector.hpp>
|
|
||||||
#include <boost/test/unit_test.hpp>
|
|
||||||
|
|
||||||
typedef boost::mpl::vector<
|
|
||||||
char
|
|
||||||
#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
|
||||||
, wchar_t
|
|
||||||
#endif
|
|
||||||
/* Current implementations seem to be missing codecvt facets to convert chars to char16_t and char32_t even though the types are available.
|
|
||||||
#if !defined(BOOST_NO_CXX11_CHAR16_T)
|
|
||||||
, char16_t
|
|
||||||
#endif
|
|
||||||
#if !defined(BOOST_NO_CXX11_CHAR32_T)
|
|
||||||
, char32_t
|
|
||||||
#endif
|
|
||||||
*/
|
|
||||||
>::type char_types;
|
|
||||||
|
|
||||||
static const char* test_strings[] =
|
|
||||||
{
|
|
||||||
"begin",
|
|
||||||
"abcd",
|
|
||||||
"end"
|
|
||||||
};
|
|
||||||
|
|
||||||
//! The context with test data for particular character type
|
|
||||||
template< typename CharT >
|
|
||||||
struct context
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
|
|
||||||
string_type begin, abcd, end;
|
|
||||||
|
|
||||||
context()
|
|
||||||
{
|
|
||||||
boost::string_ref str = test_strings[0];
|
|
||||||
std::copy(str.begin(), str.end(), std::back_inserter(begin));
|
|
||||||
|
|
||||||
str = test_strings[1];
|
|
||||||
std::copy(str.begin(), str.end(), std::back_inserter(abcd));
|
|
||||||
|
|
||||||
str = test_strings[2];
|
|
||||||
std::copy(str.begin(), str.end(), std::back_inserter(end));
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// Test regular output
|
|
||||||
BOOST_AUTO_TEST_CASE_TEMPLATE(string_ref_output, CharT, char_types)
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
typedef boost::basic_string_ref< char_type > string_ref_type;
|
|
||||||
|
|
||||||
context< char_type > ctx;
|
|
||||||
|
|
||||||
ostream_type strm;
|
|
||||||
strm << string_ref_type(ctx.abcd);
|
|
||||||
BOOST_CHECK(strm.str() == ctx.abcd);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test support for padding
|
|
||||||
BOOST_AUTO_TEST_CASE_TEMPLATE(padding, CharT, char_types)
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
typedef boost::basic_string_ref< char_type > string_ref_type;
|
|
||||||
|
|
||||||
context< char_type > ctx;
|
|
||||||
|
|
||||||
// Test for padding
|
|
||||||
{
|
|
||||||
ostream_type strm_ref;
|
|
||||||
strm_ref << ctx.begin << std::setw(8) << string_ref_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::setw(8) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_ref.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test for long padding
|
|
||||||
{
|
|
||||||
ostream_type strm_ref;
|
|
||||||
strm_ref << ctx.begin << std::setw(100) << string_ref_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::setw(100) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_ref.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test that short width does not truncate the string
|
|
||||||
{
|
|
||||||
ostream_type strm_ref;
|
|
||||||
strm_ref << ctx.begin << std::setw(1) << string_ref_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::setw(1) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_ref.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test support for padding fill
|
|
||||||
BOOST_AUTO_TEST_CASE_TEMPLATE(padding_fill, CharT, char_types)
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
typedef boost::basic_string_ref< char_type > string_ref_type;
|
|
||||||
|
|
||||||
context< char_type > ctx;
|
|
||||||
|
|
||||||
ostream_type strm_ref;
|
|
||||||
strm_ref << ctx.begin << std::setfill(static_cast< char_type >('x')) << std::setw(8) << string_ref_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::setfill(static_cast< char_type >('x')) << std::setw(8) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_ref.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test support for alignment
|
|
||||||
BOOST_AUTO_TEST_CASE_TEMPLATE(alignment, CharT, char_types)
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
typedef boost::basic_string_ref< char_type > string_ref_type;
|
|
||||||
|
|
||||||
context< char_type > ctx;
|
|
||||||
|
|
||||||
// Left alignment
|
|
||||||
{
|
|
||||||
ostream_type strm_ref;
|
|
||||||
strm_ref << ctx.begin << std::left << std::setw(8) << string_ref_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::left << std::setw(8) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_ref.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Right alignment
|
|
||||||
{
|
|
||||||
ostream_type strm_ref;
|
|
||||||
strm_ref << ctx.begin << std::right << std::setw(8) << string_ref_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::right << std::setw(8) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_ref.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,113 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright (c) Marshall Clow 2012-2012.
|
|
||||||
|
|
||||||
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)
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef _SCL_SECURE_NO_WARNINGS
|
|
||||||
# define _SCL_SECURE_NO_WARNINGS
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
#include <boost/utility/string_view.hpp>
|
|
||||||
|
|
||||||
#define BOOST_TEST_MAIN
|
|
||||||
#include <boost/test/unit_test.hpp>
|
|
||||||
|
|
||||||
typedef boost::string_view string_view;
|
|
||||||
|
|
||||||
// Should be equal
|
|
||||||
void interop ( const std::string &str, string_view ref ) {
|
|
||||||
// BOOST_CHECK ( str == ref );
|
|
||||||
BOOST_CHECK ( str.size () == ref.size ());
|
|
||||||
BOOST_CHECK ( std::equal ( str.begin (), str.end (), ref.begin ()));
|
|
||||||
BOOST_CHECK ( std::equal ( str.rbegin (), str.rend (), ref.rbegin ()));
|
|
||||||
}
|
|
||||||
|
|
||||||
void null_tests ( const char *p ) {
|
|
||||||
// All zero-length string-refs should be equal
|
|
||||||
string_view sr1; // NULL, 0
|
|
||||||
string_view sr2 ( NULL, 0 );
|
|
||||||
string_view sr3 ( p, 0 );
|
|
||||||
string_view sr4 ( p );
|
|
||||||
sr4.clear ();
|
|
||||||
|
|
||||||
BOOST_CHECK ( sr1 == sr2 );
|
|
||||||
BOOST_CHECK ( sr1 == sr3 );
|
|
||||||
BOOST_CHECK ( sr2 == sr3 );
|
|
||||||
BOOST_CHECK ( sr1 == sr4 );
|
|
||||||
}
|
|
||||||
|
|
||||||
// make sure that substrings work just like strings
|
|
||||||
void test_substr ( const std::string &str ) {
|
|
||||||
const size_t sz = str.size ();
|
|
||||||
string_view ref ( str );
|
|
||||||
|
|
||||||
// Substrings at the end
|
|
||||||
for ( size_t i = 0; i <= sz; ++ i )
|
|
||||||
interop ( str.substr ( i ), ref.substr ( i ));
|
|
||||||
|
|
||||||
// Substrings at the beginning
|
|
||||||
for ( size_t i = 0; i <= sz; ++ i )
|
|
||||||
interop ( str.substr ( 0, i ), ref.substr ( 0, i ));
|
|
||||||
|
|
||||||
// All possible substrings
|
|
||||||
for ( size_t i = 0; i < sz; ++i )
|
|
||||||
for ( size_t j = i; j < sz; ++j )
|
|
||||||
interop ( str.substr ( i, j ), ref.substr ( i, j ));
|
|
||||||
}
|
|
||||||
|
|
||||||
// make sure that removing prefixes and suffixes work just like strings
|
|
||||||
void test_remove ( const std::string &str ) {
|
|
||||||
const size_t sz = str.size ();
|
|
||||||
std::string work;
|
|
||||||
string_view ref;
|
|
||||||
|
|
||||||
for ( size_t i = 1; i <= sz; ++i ) {
|
|
||||||
work = str;
|
|
||||||
ref = str;
|
|
||||||
while ( ref.size () >= i ) {
|
|
||||||
interop ( work, ref );
|
|
||||||
work.erase ( 0, i );
|
|
||||||
ref.remove_prefix (i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for ( size_t i = 1; i < sz; ++ i ) {
|
|
||||||
work = str;
|
|
||||||
ref = str;
|
|
||||||
while ( ref.size () >= i ) {
|
|
||||||
interop ( work, ref );
|
|
||||||
work.erase ( work.size () - i, i );
|
|
||||||
ref.remove_suffix (i);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const char *test_strings [] = {
|
|
||||||
"",
|
|
||||||
"1",
|
|
||||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ",
|
|
||||||
"0123456789",
|
|
||||||
NULL
|
|
||||||
};
|
|
||||||
|
|
||||||
BOOST_AUTO_TEST_CASE( test_main )
|
|
||||||
{
|
|
||||||
const char **p = &test_strings[0];
|
|
||||||
|
|
||||||
while ( *p != NULL ) {
|
|
||||||
interop ( *p, *p );
|
|
||||||
test_substr ( *p );
|
|
||||||
test_remove ( *p );
|
|
||||||
null_tests ( *p );
|
|
||||||
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,327 +0,0 @@
|
|||||||
/*
|
|
||||||
Copyright (c) Marshall Clow 2012-2012.
|
|
||||||
|
|
||||||
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)
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef _SCL_SECURE_NO_WARNINGS
|
|
||||||
# define _SCL_SECURE_NO_WARNINGS
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
#include <cstring> // for std::strchr
|
|
||||||
|
|
||||||
#include <boost/utility/string_view.hpp>
|
|
||||||
|
|
||||||
#define BOOST_TEST_MAIN
|
|
||||||
#include <boost/test/unit_test.hpp>
|
|
||||||
|
|
||||||
typedef boost::string_view string_view;
|
|
||||||
|
|
||||||
void ends_with ( const char *arg ) {
|
|
||||||
const size_t sz = std::strlen ( arg );
|
|
||||||
string_view sr ( arg );
|
|
||||||
string_view sr2 ( arg );
|
|
||||||
const char *p = arg;
|
|
||||||
|
|
||||||
while ( *p ) {
|
|
||||||
BOOST_CHECK ( sr.ends_with ( p ));
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
while ( !sr2.empty ()) {
|
|
||||||
BOOST_CHECK ( sr.ends_with ( sr2 ));
|
|
||||||
sr2.remove_prefix (1);
|
|
||||||
}
|
|
||||||
|
|
||||||
sr2 = arg;
|
|
||||||
while ( !sr2.empty ()) {
|
|
||||||
BOOST_CHECK ( sr.ends_with ( sr2 ));
|
|
||||||
sr2.remove_prefix (1);
|
|
||||||
}
|
|
||||||
|
|
||||||
char ch = sz == 0 ? '\0' : arg [ sz - 1 ];
|
|
||||||
sr2 = arg;
|
|
||||||
if ( sz > 0 )
|
|
||||||
BOOST_CHECK ( sr2.ends_with ( ch ));
|
|
||||||
BOOST_CHECK ( !sr2.ends_with ( ++ch ));
|
|
||||||
BOOST_CHECK ( sr2.ends_with ( string_view ()));
|
|
||||||
}
|
|
||||||
|
|
||||||
void starts_with ( const char *arg ) {
|
|
||||||
const size_t sz = std::strlen ( arg );
|
|
||||||
string_view sr ( arg );
|
|
||||||
string_view sr2 ( arg );
|
|
||||||
const char *p = arg + std::strlen ( arg ) - 1;
|
|
||||||
while ( p >= arg ) {
|
|
||||||
std::string foo ( arg, p + 1 );
|
|
||||||
BOOST_CHECK ( sr.starts_with ( foo ));
|
|
||||||
--p;
|
|
||||||
}
|
|
||||||
|
|
||||||
while ( !sr2.empty ()) {
|
|
||||||
BOOST_CHECK ( sr.starts_with ( sr2 ));
|
|
||||||
sr2.remove_suffix (1);
|
|
||||||
}
|
|
||||||
|
|
||||||
char ch = *arg;
|
|
||||||
sr2 = arg;
|
|
||||||
if ( sz > 0 )
|
|
||||||
BOOST_CHECK ( sr2.starts_with ( ch ));
|
|
||||||
BOOST_CHECK ( !sr2.starts_with ( ++ch ));
|
|
||||||
BOOST_CHECK ( sr2.starts_with ( string_view ()));
|
|
||||||
}
|
|
||||||
|
|
||||||
void reverse ( const char *arg ) {
|
|
||||||
// Round trip
|
|
||||||
string_view sr1 ( arg );
|
|
||||||
std::string string1 ( sr1.rbegin (), sr1.rend ());
|
|
||||||
string_view sr2 ( string1 );
|
|
||||||
std::string string2 ( sr2.rbegin (), sr2.rend ());
|
|
||||||
|
|
||||||
BOOST_CHECK ( std::equal ( sr2.rbegin (), sr2.rend (), arg ));
|
|
||||||
BOOST_CHECK ( string2 == arg );
|
|
||||||
BOOST_CHECK ( std::equal ( sr1.begin (), sr1.end (), string2.begin ()));
|
|
||||||
}
|
|
||||||
|
|
||||||
// This helper function eliminates signed vs. unsigned warnings
|
|
||||||
string_view::size_type ptr_diff ( const char *res, const char *base ) {
|
|
||||||
BOOST_CHECK ( res >= base );
|
|
||||||
return static_cast<string_view::size_type> ( res - base );
|
|
||||||
}
|
|
||||||
|
|
||||||
void find ( const char *arg ) {
|
|
||||||
string_view sr1;
|
|
||||||
string_view sr2;
|
|
||||||
const char *p;
|
|
||||||
|
|
||||||
// Look for each character in the string(searching from the start)
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( *p ) {
|
|
||||||
string_view::size_type pos = sr1.find(*p);
|
|
||||||
BOOST_CHECK ( pos != string_view::npos && ( pos <= ptr_diff ( p, arg )));
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Look for each character in the string (searching from the end)
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( *p ) {
|
|
||||||
string_view::size_type pos = sr1.rfind(*p);
|
|
||||||
BOOST_CHECK ( pos != string_view::npos && pos < sr1.size () && ( pos >= ptr_diff ( p, arg )));
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Look for pairs on characters (searching from the start)
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg;
|
|
||||||
while ( *p && *(p+1)) {
|
|
||||||
string_view sr3 ( p, 2 );
|
|
||||||
string_view::size_type pos = sr1.find ( sr3 );
|
|
||||||
BOOST_CHECK ( pos != string_view::npos && pos <= static_cast<string_view::size_type>( p - arg ));
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg;
|
|
||||||
// for all possible chars, see if we find them in the right place.
|
|
||||||
// Note that strchr will/might do the _wrong_ thing if we search for NULL
|
|
||||||
|
|
||||||
for ( unsigned char ch = 1u; ; ++ch ) {
|
|
||||||
string_view::size_type pos = sr1.find(ch);
|
|
||||||
const char *strp = std::strchr ( arg, ch );
|
|
||||||
BOOST_CHECK (( strp == NULL ) == ( pos == string_view::npos ));
|
|
||||||
if ( strp != NULL )
|
|
||||||
BOOST_CHECK ( ptr_diff ( strp, arg ) == pos );
|
|
||||||
if (ch == 255u)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg;
|
|
||||||
// for all possible chars, see if we find them in the right place.
|
|
||||||
// Note that strchr will/might do the _wrong_ thing if we search for NULL
|
|
||||||
for ( unsigned char ch = 1u; ; ++ch ) {
|
|
||||||
string_view::size_type pos = sr1.rfind(ch);
|
|
||||||
const char *strp = std::strrchr ( arg, ch );
|
|
||||||
BOOST_CHECK (( strp == NULL ) == ( pos == string_view::npos ));
|
|
||||||
if ( strp != NULL )
|
|
||||||
BOOST_CHECK ( ptr_diff ( strp, arg ) == pos );
|
|
||||||
if (ch == 255u)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Find everything at the start
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( !sr1.empty ()) {
|
|
||||||
string_view::size_type pos = sr1.find(*p);
|
|
||||||
BOOST_CHECK ( pos == 0 );
|
|
||||||
sr1.remove_prefix (1);
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find everything at the end
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg + std::strlen ( arg ) - 1;
|
|
||||||
while ( !sr1.empty ()) {
|
|
||||||
string_view::size_type pos = sr1.rfind(*p);
|
|
||||||
BOOST_CHECK ( pos == sr1.size () - 1 );
|
|
||||||
sr1.remove_suffix (1);
|
|
||||||
--p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Find everything at the start
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg;
|
|
||||||
while ( !sr1.empty ()) {
|
|
||||||
string_view::size_type pos = sr1.find_first_of(*p);
|
|
||||||
BOOST_CHECK ( pos == 0 );
|
|
||||||
sr1.remove_prefix (1);
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
// Find everything at the end
|
|
||||||
sr1 = arg;
|
|
||||||
p = arg + std::strlen ( arg ) - 1;
|
|
||||||
while ( !sr1.empty ()) {
|
|
||||||
string_view::size_type pos = sr1.find_last_of(*p);
|
|
||||||
BOOST_CHECK ( pos == sr1.size () - 1 );
|
|
||||||
sr1.remove_suffix (1);
|
|
||||||
--p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Basic sanity checking for "find_first_of / find_first_not_of"
|
|
||||||
sr1 = arg;
|
|
||||||
sr2 = arg;
|
|
||||||
while ( !sr1.empty() ) {
|
|
||||||
BOOST_CHECK ( sr1.find_first_of ( sr2 ) == 0 );
|
|
||||||
BOOST_CHECK ( sr1.find_first_not_of ( sr2 ) == string_view::npos );
|
|
||||||
sr1.remove_prefix ( 1 );
|
|
||||||
}
|
|
||||||
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( *p ) {
|
|
||||||
string_view::size_type pos1 = sr1.find_first_of(*p);
|
|
||||||
string_view::size_type pos2 = sr1.find_first_not_of(*p);
|
|
||||||
BOOST_CHECK ( pos1 != string_view::npos && pos1 < sr1.size () && pos1 <= ptr_diff ( p, arg ));
|
|
||||||
if ( pos2 != string_view::npos ) {
|
|
||||||
for ( size_t i = 0 ; i < pos2; ++i )
|
|
||||||
BOOST_CHECK ( sr1[i] == *p );
|
|
||||||
BOOST_CHECK ( sr1 [ pos2 ] != *p );
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CHECK ( pos2 != pos1 );
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Basic sanity checking for "find_last_of / find_last_not_of"
|
|
||||||
sr1 = arg;
|
|
||||||
sr2 = arg;
|
|
||||||
while ( !sr1.empty() ) {
|
|
||||||
BOOST_CHECK ( sr1.find_last_of ( sr2 ) == ( sr1.size () - 1 ));
|
|
||||||
BOOST_CHECK ( sr1.find_last_not_of ( sr2 ) == string_view::npos );
|
|
||||||
sr1.remove_suffix ( 1 );
|
|
||||||
}
|
|
||||||
|
|
||||||
p = arg;
|
|
||||||
sr1 = arg;
|
|
||||||
while ( *p ) {
|
|
||||||
string_view::size_type pos1 = sr1.find_last_of(*p);
|
|
||||||
string_view::size_type pos2 = sr1.find_last_not_of(*p);
|
|
||||||
BOOST_CHECK ( pos1 != string_view::npos && pos1 < sr1.size () && pos1 >= ptr_diff ( p, arg ));
|
|
||||||
BOOST_CHECK ( pos2 == string_view::npos || pos1 < sr1.size ());
|
|
||||||
if ( pos2 != string_view::npos ) {
|
|
||||||
for ( size_t i = sr1.size () -1 ; i > pos2; --i )
|
|
||||||
BOOST_CHECK ( sr1[i] == *p );
|
|
||||||
BOOST_CHECK ( sr1 [ pos2 ] != *p );
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_CHECK ( pos2 != pos1 );
|
|
||||||
++p;
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void to_string ( const char *arg ) {
|
|
||||||
string_view sr1;
|
|
||||||
std::string str1;
|
|
||||||
std::string str2;
|
|
||||||
|
|
||||||
str1.assign ( arg );
|
|
||||||
sr1 = arg;
|
|
||||||
// str2 = sr1.to_string<std::allocator<char> > ();
|
|
||||||
str2 = sr1.to_string ();
|
|
||||||
BOOST_CHECK ( str1 == str2 );
|
|
||||||
|
|
||||||
//#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
|
|
||||||
// std::string str3 = static_cast<std::string> ( sr1 );
|
|
||||||
// BOOST_CHECK ( str1 == str3 );
|
|
||||||
//#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
void compare ( const char *arg ) {
|
|
||||||
string_view sr1;
|
|
||||||
std::string str1;
|
|
||||||
std::string str2 = str1;
|
|
||||||
|
|
||||||
str1.assign ( arg );
|
|
||||||
sr1 = arg;
|
|
||||||
BOOST_CHECK ( sr1 == sr1); // compare string_view and string_view
|
|
||||||
BOOST_CHECK ( sr1 == str1); // compare string and string_view
|
|
||||||
BOOST_CHECK ( str1 == sr1 ); // compare string_view and string
|
|
||||||
BOOST_CHECK ( sr1 == arg ); // compare string_view and pointer
|
|
||||||
BOOST_CHECK ( arg == sr1 ); // compare pointer and string_view
|
|
||||||
|
|
||||||
if ( sr1.size () > 0 ) {
|
|
||||||
(*str1.rbegin())++;
|
|
||||||
BOOST_CHECK ( sr1 != str1 );
|
|
||||||
BOOST_CHECK ( str1 != sr1 );
|
|
||||||
BOOST_CHECK ( sr1 < str1 );
|
|
||||||
BOOST_CHECK ( sr1 <= str1 );
|
|
||||||
BOOST_CHECK ( str1 > sr1 );
|
|
||||||
BOOST_CHECK ( str1 >= sr1 );
|
|
||||||
|
|
||||||
(*str1.rbegin()) -= 2;
|
|
||||||
BOOST_CHECK ( sr1 != str1 );
|
|
||||||
BOOST_CHECK ( str1 != sr1 );
|
|
||||||
BOOST_CHECK ( sr1 > str1 );
|
|
||||||
BOOST_CHECK ( sr1 >= str1 );
|
|
||||||
BOOST_CHECK ( str1 < sr1 );
|
|
||||||
BOOST_CHECK ( str1 <= sr1 );
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const char *test_strings [] = {
|
|
||||||
"",
|
|
||||||
"0",
|
|
||||||
"abc",
|
|
||||||
"AAA", // all the same
|
|
||||||
"adsfadadiaef;alkdg;aljt;j agl;sjrl;tjs;lga;lretj;srg[w349u5209dsfadfasdfasdfadsf",
|
|
||||||
"abc\0asdfadsfasf",
|
|
||||||
NULL
|
|
||||||
};
|
|
||||||
|
|
||||||
BOOST_AUTO_TEST_CASE( test_main )
|
|
||||||
{
|
|
||||||
const char **p = &test_strings[0];
|
|
||||||
|
|
||||||
while ( *p != NULL ) {
|
|
||||||
starts_with ( *p );
|
|
||||||
ends_with ( *p );
|
|
||||||
reverse ( *p );
|
|
||||||
find ( *p );
|
|
||||||
to_string ( *p );
|
|
||||||
compare ( *p );
|
|
||||||
|
|
||||||
p++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,482 +0,0 @@
|
|||||||
/*
|
|
||||||
<20> Copyright Beman Dawes 2015
|
|
||||||
|
|
||||||
Distributed under the Boost Software License, Version 1.0
|
|
||||||
See http://www.boost.org/LICENSE_1_0.txt
|
|
||||||
|
|
||||||
For more information, see http://www.boost.org
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef _SCL_SECURE_NO_WARNINGS
|
|
||||||
# define _SCL_SECURE_NO_WARNINGS
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <boost/utility/string_view.hpp>
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
#define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cout
|
|
||||||
#include <boost/core/lightweight_test.hpp>
|
|
||||||
#include <boost/detail/lightweight_main.hpp>
|
|
||||||
|
|
||||||
namespace
|
|
||||||
{
|
|
||||||
void swap_test()
|
|
||||||
{
|
|
||||||
std::cout << "swap test..." << std::endl;
|
|
||||||
|
|
||||||
std::string s1("abcdefg");
|
|
||||||
boost::string_view sv1(s1);
|
|
||||||
std::string s2("xyz");
|
|
||||||
boost::string_view sv2(s2);
|
|
||||||
std::string s3;
|
|
||||||
boost::string_view sv3(s3);
|
|
||||||
|
|
||||||
boost::string_view sv1_org(sv1);
|
|
||||||
boost::string_view sv2_org(sv2);
|
|
||||||
boost::string_view sv3_org(sv3);
|
|
||||||
|
|
||||||
sv1.swap(sv2);
|
|
||||||
BOOST_TEST_EQ(sv1.data(), sv2_org.data());
|
|
||||||
BOOST_TEST_EQ(sv2.data(), sv1_org.data());
|
|
||||||
BOOST_TEST_EQ(sv1.size(), sv2_org.size());
|
|
||||||
BOOST_TEST_EQ(sv2.size(), sv1_org.size());
|
|
||||||
sv1.swap(sv2);
|
|
||||||
BOOST_TEST_EQ(sv1.data(), sv1_org.data());
|
|
||||||
BOOST_TEST_EQ(sv2.data(), sv2_org.data());
|
|
||||||
BOOST_TEST_EQ(sv1.size(), sv1_org.size());
|
|
||||||
BOOST_TEST_EQ(sv2.size(), sv2_org.size());
|
|
||||||
|
|
||||||
sv3.swap(sv1);
|
|
||||||
BOOST_TEST_EQ(sv3.data(), sv1_org.data());
|
|
||||||
BOOST_TEST_EQ(sv1.data(), sv3_org.data());
|
|
||||||
BOOST_TEST_EQ(sv3.size(), sv1_org.size());
|
|
||||||
BOOST_TEST_EQ(sv1.size(), sv3_org.size());
|
|
||||||
sv3.swap(sv1);
|
|
||||||
BOOST_TEST_EQ(sv1.data(), sv1_org.data());
|
|
||||||
BOOST_TEST_EQ(sv3.data(), sv3_org.data());
|
|
||||||
BOOST_TEST_EQ(sv1.size(), sv1_org.size());
|
|
||||||
BOOST_TEST_EQ(sv3.size(), sv3_org.size());
|
|
||||||
}
|
|
||||||
|
|
||||||
void copy_test()
|
|
||||||
{
|
|
||||||
std::cout << "copy test..." << std::endl;
|
|
||||||
|
|
||||||
std::string s1("abcdefg");
|
|
||||||
boost::string_view sv1(s1);
|
|
||||||
const std::size_t sz = 128u;
|
|
||||||
char a[sz];
|
|
||||||
|
|
||||||
std::fill(a, a + sz, 'x');
|
|
||||||
sv1.copy(a, sv1.size());
|
|
||||||
BOOST_TEST(std::memcmp(sv1.data(), &a, sv1.size()) == 0);
|
|
||||||
const char* p;
|
|
||||||
for (p = a + sv1.size();
|
|
||||||
p != a + sz && *p == 'x'; ++p) {}
|
|
||||||
BOOST_TEST(p == a + sz);
|
|
||||||
|
|
||||||
std::fill(a, a + sz, 'x');
|
|
||||||
sv1.copy(a, sv1.size()-2, 2);
|
|
||||||
BOOST_TEST(std::memcmp(sv1.data()+2, &a, sv1.size()-2) == 0);
|
|
||||||
for (p = a + sv1.size() - 2;
|
|
||||||
p != a + sz && *p == 'x'; ++p) {}
|
|
||||||
BOOST_TEST(p == a + sz);
|
|
||||||
}
|
|
||||||
|
|
||||||
void compare_test()
|
|
||||||
{
|
|
||||||
std::cout << "compare test..." << std::endl;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
void find_test()
|
|
||||||
{
|
|
||||||
std::cout << "find test..." << std::endl;
|
|
||||||
|
|
||||||
// find - test two modified and two new signatures
|
|
||||||
std::string s1("ababcab");
|
|
||||||
boost::string_view sv1(s1);
|
|
||||||
std::string s2("abc");
|
|
||||||
boost::string_view sv2(s2);
|
|
||||||
std::string s3;
|
|
||||||
boost::string_view sv3(s3);
|
|
||||||
|
|
||||||
// first signature
|
|
||||||
BOOST_TEST_EQ(sv3.find(sv3), s3.find(s3)); // both strings empty
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv3), s1.find(s3)); // search string empty
|
|
||||||
BOOST_TEST_EQ(sv3.find(sv2), s3.find(s2)); // searched string empty
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv3, sizeof(s1) + 2), s1.find(s3, sizeof(s1) + 2));
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv3, sizeof(s1) + 1), s1.find(s3, sizeof(s1) + 1));
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv3, sizeof(s1)), s1.find(s3, sizeof(s1)));
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv3, sizeof(s1)- 1), s1.find(s3, sizeof(s1)- 1));
|
|
||||||
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv2), s1.find(s2));
|
|
||||||
for (std::string::size_type i = 0; i <= sizeof(s1) + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv2, i), s1.find(s2, i));
|
|
||||||
}
|
|
||||||
for (std::string::size_type i = 0; i <= sizeof(s1) + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv3, i), s1.find(s3, i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// second signature
|
|
||||||
for (std::string::size_type i = 0; i <= sizeof(s1) + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find('b', i), s1.find('b', i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// third signature
|
|
||||||
for (std::string::size_type i = 0; i <= sizeof(s1) + 1; ++i)
|
|
||||||
for (std::string::size_type j = 0; j <= 4; ++j)
|
|
||||||
{
|
|
||||||
//std::cout << i << " " << j << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find("abc", i, j), s1.find("abc", i, j));
|
|
||||||
}
|
|
||||||
|
|
||||||
// fourth signature
|
|
||||||
BOOST_TEST_EQ(sv1.find("abc"), s1.find("abc"));
|
|
||||||
for (std::string::size_type i = 0; i <= sizeof(s1) + 1; ++i)
|
|
||||||
BOOST_TEST_EQ(sv1.find("abc", i), s1.find("abc", i));
|
|
||||||
}
|
|
||||||
|
|
||||||
void rfind_test()
|
|
||||||
{
|
|
||||||
std::cout << "rfind test..." << std::endl;
|
|
||||||
|
|
||||||
// rfind - test two modified and two new signatures
|
|
||||||
std::string s1("ababcab");
|
|
||||||
boost::string_view sv1(s1);
|
|
||||||
std::string s2("ab");
|
|
||||||
boost::string_view sv2(s2);
|
|
||||||
std::string s3;
|
|
||||||
boost::string_view sv3(s3);
|
|
||||||
|
|
||||||
// first signature
|
|
||||||
BOOST_TEST_EQ(sv3.rfind(sv3), s3.rfind(s3)); // both strings empty
|
|
||||||
BOOST_TEST_EQ(sv1.rfind(sv3), s1.rfind(s3)); // search string empty
|
|
||||||
BOOST_TEST_EQ(sv3.rfind(sv2), s3.rfind(s2)); // searched string empty
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv3, s1.size() + 2), s1.find(s3, s1.size() + 2));
|
|
||||||
BOOST_TEST_EQ(sv1.find(sv3, s1.size() + 1), s1.find(s3, s1.size() + 1));
|
|
||||||
BOOST_TEST_EQ(sv1.rfind(sv3, s1.size()), s1.rfind(s3, s1.size()));
|
|
||||||
BOOST_TEST_EQ(sv1.rfind(sv3, s1.size()- 1), s1.rfind(s3, s1.size()- 1));
|
|
||||||
|
|
||||||
BOOST_TEST_EQ(sv1.rfind(sv2), s1.rfind(s2));
|
|
||||||
for (std::string::size_type i = s1.size(); i <= s1.size(); --i)
|
|
||||||
{
|
|
||||||
// std::cout << i << ": " << sv1.rfind(sv2, i) << " " << s1.rfind(s2, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.rfind(sv2, i), s1.rfind(s2, i));
|
|
||||||
}
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.rfind(sv3, i), s1.rfind(s3, i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// second signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.rfind('b', i), s1.rfind('b', i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// third signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
for (std::string::size_type j = 0; j <= 4; ++j)
|
|
||||||
{
|
|
||||||
//std::cout << i << " " << j << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.rfind("abc", i, j), s1.rfind("abc", i, j));
|
|
||||||
}
|
|
||||||
|
|
||||||
// fourth signature
|
|
||||||
BOOST_TEST_EQ(sv1.rfind("abc"), s1.rfind("abc"));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
BOOST_TEST_EQ(sv1.rfind("abc", i), s1.rfind("abc", i));
|
|
||||||
}
|
|
||||||
|
|
||||||
void find_first_of_test()
|
|
||||||
{
|
|
||||||
std::cout << "find_first_of test..." << std::endl;
|
|
||||||
|
|
||||||
// find_first_of - test two modified and two new signatures
|
|
||||||
std::string s1("Hello World!");
|
|
||||||
boost::string_view sv1(s1);
|
|
||||||
std::string s2("o");
|
|
||||||
boost::string_view sv2(s2);
|
|
||||||
const char* s2c = "Good Bye";
|
|
||||||
boost::string_view sv2c(s2c);
|
|
||||||
std::string s3;
|
|
||||||
boost::string_view sv3(s3);
|
|
||||||
|
|
||||||
// smoke test
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv2), s1.find_first_of(s2));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv2, 5), s1.find_first_of(s2, 5));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(s2c), s1.find_first_of(s2c));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(s2c, 0, 4), s1.find_first_of(s2c, 0, 4));
|
|
||||||
|
|
||||||
// first signature
|
|
||||||
BOOST_TEST_EQ(sv3.find_first_of(sv3), s3.find_first_of(s3)); // both strings empty
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv3), s1.find_first_of(s3)); // search string empty
|
|
||||||
BOOST_TEST_EQ(sv3.find_first_of(sv2), s3.find_first_of(s2)); // searched string empty
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv3, s1.size() + 2), s1.find_first_of(s3, s1.size() + 2));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv3, s1.size() + 1), s1.find_first_of(s3, s1.size() + 1));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv3, s1.size()), s1.find_first_of(s3, s1.size()));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv3, s1.size() - 1), s1.find_first_of(s3, s1.size() - 1));
|
|
||||||
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv2), s1.find_first_of(s2));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_first_of(sv2, i) << " " << s1.find_first_of(s2, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv2, i), s1.find_first_of(s2, i));
|
|
||||||
}
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_first_of(sv3, i) << " " << s1.find_first_of(s3, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(sv3, i), s1.find_first_of(s3, i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// second signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_first_of('o', i) << " " << s1.find_first_of('o', i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of('o', i), s1.find_first_of('o', i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// third signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
for (std::string::size_type j = 0; j <= std::strlen(s2c) + 1; ++j)
|
|
||||||
{
|
|
||||||
//std::cout << i << "," << j << ": " << sv1.find_first_of(s2c, i, j) << " " << s1.find_first_of(s2c, i, j) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(s2c, i, j), s1.find_first_of(s2c, i, j));
|
|
||||||
}
|
|
||||||
|
|
||||||
// fourth signature
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(s2c), s1.find_first_of(s2c));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_first_of(s2c, i) << " " << s1.find_first_of(s2c, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_of(s2c, i), s1.find_first_of(s2c, i));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void find_last_of_test()
|
|
||||||
{
|
|
||||||
std::cout << "find_last_of test..." << std::endl;
|
|
||||||
|
|
||||||
// find_last_of - test two modified and two new signatures
|
|
||||||
std::string s1("Hello World!");
|
|
||||||
boost::string_view sv1(s1);
|
|
||||||
std::string s2("o");
|
|
||||||
boost::string_view sv2(s2);
|
|
||||||
const char* s2c = "Good Bye";
|
|
||||||
boost::string_view sv2c(s2c);
|
|
||||||
std::string s3;
|
|
||||||
boost::string_view sv3(s3);
|
|
||||||
|
|
||||||
// smoke test
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv2), s1.find_last_of(s2));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv2, 5), s1.find_last_of(s2, 5));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(s2c), s1.find_last_of(s2c));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(s2c, 0, 4), s1.find_last_of(s2c, 0, 4));
|
|
||||||
|
|
||||||
// first signature
|
|
||||||
BOOST_TEST_EQ(sv3.find_last_of(sv3), s3.find_last_of(s3)); // both strings empty
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv3), s1.find_last_of(s3)); // search string empty
|
|
||||||
BOOST_TEST_EQ(sv3.find_last_of(sv2), s3.find_last_of(s2)); // searched string empty
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv3, s1.size() + 2), s1.find_last_of(s3, s1.size() + 2));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv3, s1.size() + 1), s1.find_last_of(s3, s1.size() + 1));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv3, s1.size()), s1.find_last_of(s3, s1.size()));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv3, s1.size() - 1), s1.find_last_of(s3, s1.size() - 1));
|
|
||||||
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv2), s1.find_last_of(s2));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_last_of(sv2, i) << " " << s1.find_last_of(s2, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv2, i), s1.find_last_of(s2, i));
|
|
||||||
}
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_last_of(sv3, i) << " " << s1.find_last_of(s3, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(sv3, i), s1.find_last_of(s3, i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// second signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_last_of('o', i) << " " << s1.find_last_of('o', i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of('o', i), s1.find_last_of('o', i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// third signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
for (std::string::size_type j = 0; j <= std::strlen(s2c) + 1; ++j)
|
|
||||||
{
|
|
||||||
//std::cout << i << "," << j << ": " << sv1.find_last_of(s2c, i, j) << " " << s1.find_last_of(s2c, i, j) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(s2c, i, j), s1.find_last_of(s2c, i, j));
|
|
||||||
}
|
|
||||||
|
|
||||||
// fourth signature
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(s2c), s1.find_last_of(s2c));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_last_of(s2c, i) << " " << s1.find_last_of(s2c, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_of(s2c, i), s1.find_last_of(s2c, i));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void find_first_not_of_test()
|
|
||||||
{
|
|
||||||
std::cout << "find_first_not_of test..." << std::endl;
|
|
||||||
|
|
||||||
// find_first_not_of - test two modified and two new signatures
|
|
||||||
std::string s1("Hello World!");
|
|
||||||
boost::string_view sv1(s1);
|
|
||||||
std::string s2("o");
|
|
||||||
boost::string_view sv2(s2);
|
|
||||||
const char* s2c = "Good Bye";
|
|
||||||
boost::string_view sv2c(s2c);
|
|
||||||
std::string s3;
|
|
||||||
boost::string_view sv3(s3);
|
|
||||||
|
|
||||||
// smoke test
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv2), s1.find_first_not_of(s2));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv2, 5), s1.find_first_not_of(s2, 5));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(s2c), s1.find_first_not_of(s2c));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(s2c, 0, 4), s1.find_first_not_of(s2c, 0, 4));
|
|
||||||
|
|
||||||
// first signature
|
|
||||||
BOOST_TEST_EQ(sv3.find_first_not_of(sv3), s3.find_first_not_of(s3)); // both strings empty
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv3), s1.find_first_not_of(s3)); // search string empty
|
|
||||||
BOOST_TEST_EQ(sv3.find_first_not_of(sv2), s3.find_first_not_of(s2)); // searched string empty
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv3, s1.size() + 2), s1.find_first_not_of(s3, s1.size() + 2));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv3, s1.size() + 1), s1.find_first_not_of(s3, s1.size() + 1));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv3, s1.size()), s1.find_first_not_of(s3, s1.size()));
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv3, s1.size() - 1), s1.find_first_not_of(s3, s1.size() - 1));
|
|
||||||
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv2), s1.find_first_not_of(s2));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_first_not_of(sv2, i) << " " << s1.find_first_not_of(s2, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv2, i), s1.find_first_not_of(s2, i));
|
|
||||||
}
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_first_not_of(sv3, i) << " " << s1.find_first_not_of(s3, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(sv3, i), s1.find_first_not_of(s3, i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// second signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_first_not_of('o', i) << " " << s1.find_first_not_of('o', i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of('o', i), s1.find_first_not_of('o', i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// third signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
for (std::string::size_type j = 0; j <= std::strlen(s2c) + 1; ++j)
|
|
||||||
{
|
|
||||||
//std::cout << i << "," << j << ": " << sv1.find_first_not_of(s2c, i, j) << " " << s1.find_first_not_of(s2c, i, j) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(s2c, i, j), s1.find_first_not_of(s2c, i, j));
|
|
||||||
}
|
|
||||||
|
|
||||||
// fourth signature
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(s2c), s1.find_first_not_of(s2c));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_first_not_of(s2c, i) << " " << s1.find_first_not_of(s2c, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_first_not_of(s2c, i), s1.find_first_not_of(s2c, i));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void find_last_not_of_test()
|
|
||||||
{
|
|
||||||
std::cout << "find_last_not_of test..." << std::endl;
|
|
||||||
|
|
||||||
// find_last_not_of - test two modified and two new signatures
|
|
||||||
std::string s1("Hello World!");
|
|
||||||
boost::string_view sv1(s1);
|
|
||||||
std::string s2("o");
|
|
||||||
boost::string_view sv2(s2);
|
|
||||||
const char* s2c = "Good Bye";
|
|
||||||
boost::string_view sv2c(s2c);
|
|
||||||
std::string s3;
|
|
||||||
boost::string_view sv3(s3);
|
|
||||||
|
|
||||||
// smoke test
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv2), s1.find_last_not_of(s2));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv2, 5), s1.find_last_not_of(s2, 5));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(s2c), s1.find_last_not_of(s2c));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(s2c, 0, 4), s1.find_last_not_of(s2c, 0, 4));
|
|
||||||
|
|
||||||
// first signature
|
|
||||||
BOOST_TEST_EQ(sv3.find_last_not_of(sv3), s3.find_last_not_of(s3)); // both strings empty
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv3), s1.find_last_not_of(s3)); // search string empty
|
|
||||||
BOOST_TEST_EQ(sv3.find_last_not_of(sv2), s3.find_last_not_of(s2)); // searched string empty
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv3, s1.size() + 2), s1.find_last_not_of(s3, s1.size() + 2));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv3, s1.size() + 1), s1.find_last_not_of(s3, s1.size() + 1));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv3, s1.size()), s1.find_last_not_of(s3, s1.size()));
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv3, s1.size() - 1), s1.find_last_not_of(s3, s1.size() - 1));
|
|
||||||
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv2), s1.find_last_not_of(s2));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_last_not_of(sv2, i) << " " << s1.find_last_not_of(s2, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv2, i), s1.find_last_not_of(s2, i));
|
|
||||||
}
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_last_not_of(sv3, i) << " " << s1.find_last_not_of(s3, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(sv3, i), s1.find_last_not_of(s3, i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// second signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_last_not_of('o', i) << " " << s1.find_last_not_of('o', i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of('o', i), s1.find_last_not_of('o', i));
|
|
||||||
}
|
|
||||||
|
|
||||||
// third signature
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
for (std::string::size_type j = 0; j <= std::strlen(s2c) + 1; ++j)
|
|
||||||
{
|
|
||||||
//std::cout << i << "," << j << ": " << sv1.find_last_not_of(s2c, i, j) << " " << s1.find_last_not_of(s2c, i, j) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(s2c, i, j), s1.find_last_not_of(s2c, i, j));
|
|
||||||
}
|
|
||||||
|
|
||||||
// fourth signature
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(s2c), s1.find_last_not_of(s2c));
|
|
||||||
for (std::string::size_type i = 0; i <= s1.size() + 1; ++i)
|
|
||||||
{
|
|
||||||
//std::cout << i << ": " << sv1.find_last_not_of(s2c, i) << " " << s1.find_last_not_of(s2c, i) << std::endl;
|
|
||||||
BOOST_TEST_EQ(sv1.find_last_not_of(s2c, i), s1.find_last_not_of(s2c, i));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
} // unnamed namespace
|
|
||||||
|
|
||||||
int cpp_main(int argc, char* argv[])
|
|
||||||
{
|
|
||||||
// verify traits_type and const_pointer typedefs compile OK
|
|
||||||
BOOST_TEST(boost::string_view::traits_type::eq('x', 'x'));
|
|
||||||
BOOST_TEST_EQ(sizeof(boost::string_view::const_pointer), sizeof(&argc));
|
|
||||||
|
|
||||||
swap_test();
|
|
||||||
copy_test();
|
|
||||||
compare_test();
|
|
||||||
find_test();
|
|
||||||
rfind_test();
|
|
||||||
find_first_of_test();
|
|
||||||
find_last_of_test();
|
|
||||||
find_first_not_of_test();
|
|
||||||
find_last_not_of_test();
|
|
||||||
|
|
||||||
return boost::report_errors();
|
|
||||||
}
|
|
||||||
@@ -1,183 +0,0 @@
|
|||||||
/*
|
|
||||||
* Copyright Andrey Semashev 2013.
|
|
||||||
* 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)
|
|
||||||
*/
|
|
||||||
/*!
|
|
||||||
* \file string_view_test_io.cpp
|
|
||||||
* \author Andrey Semashev
|
|
||||||
* \date 26.05.2013
|
|
||||||
*
|
|
||||||
* \brief This header contains tests for stream operations of \c basic_string_view.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define BOOST_TEST_MODULE string_view_test_io
|
|
||||||
|
|
||||||
#include <boost/utility/string_view.hpp>
|
|
||||||
|
|
||||||
#include <iomanip>
|
|
||||||
#include <sstream>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <iterator>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <boost/mpl/vector.hpp>
|
|
||||||
#include <boost/test/unit_test.hpp>
|
|
||||||
|
|
||||||
typedef boost::mpl::vector<
|
|
||||||
char
|
|
||||||
#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
|
|
||||||
, wchar_t
|
|
||||||
#endif
|
|
||||||
/* Current implementations seem to be missing codecvt facets to convert chars to char16_t and char32_t even though the types are available.
|
|
||||||
#if !defined(BOOST_NO_CXX11_CHAR16_T)
|
|
||||||
, char16_t
|
|
||||||
#endif
|
|
||||||
#if !defined(BOOST_NO_CXX11_CHAR32_T)
|
|
||||||
, char32_t
|
|
||||||
#endif
|
|
||||||
*/
|
|
||||||
>::type char_types;
|
|
||||||
|
|
||||||
static const char* test_strings[] =
|
|
||||||
{
|
|
||||||
"begin",
|
|
||||||
"abcd",
|
|
||||||
"end"
|
|
||||||
};
|
|
||||||
|
|
||||||
//! The context with test data for particular character type
|
|
||||||
template< typename CharT >
|
|
||||||
struct context
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
|
|
||||||
string_type begin, abcd, end;
|
|
||||||
|
|
||||||
context()
|
|
||||||
{
|
|
||||||
boost::string_view str = test_strings[0];
|
|
||||||
std::copy(str.begin(), str.end(), std::back_inserter(begin));
|
|
||||||
|
|
||||||
str = test_strings[1];
|
|
||||||
std::copy(str.begin(), str.end(), std::back_inserter(abcd));
|
|
||||||
|
|
||||||
str = test_strings[2];
|
|
||||||
std::copy(str.begin(), str.end(), std::back_inserter(end));
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// Test regular output
|
|
||||||
BOOST_AUTO_TEST_CASE_TEMPLATE(string_view_output, CharT, char_types)
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
//typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
typedef boost::basic_string_view< char_type > string_view_type;
|
|
||||||
|
|
||||||
context< char_type > ctx;
|
|
||||||
|
|
||||||
ostream_type strm;
|
|
||||||
strm << string_view_type(ctx.abcd);
|
|
||||||
BOOST_CHECK(strm.str() == ctx.abcd);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test support for padding
|
|
||||||
BOOST_AUTO_TEST_CASE_TEMPLATE(padding, CharT, char_types)
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
//typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
typedef boost::basic_string_view< char_type > string_view_type;
|
|
||||||
|
|
||||||
context< char_type > ctx;
|
|
||||||
|
|
||||||
// Test for padding
|
|
||||||
{
|
|
||||||
ostream_type strm_view;
|
|
||||||
strm_view << ctx.begin << std::setw(8) << string_view_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::setw(8) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_view.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test for long padding
|
|
||||||
{
|
|
||||||
ostream_type strm_view;
|
|
||||||
strm_view << ctx.begin << std::setw(100) << string_view_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::setw(100) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_view.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test that short width does not truncate the string
|
|
||||||
{
|
|
||||||
ostream_type strm_view;
|
|
||||||
strm_view << ctx.begin << std::setw(1) << string_view_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::setw(1) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_view.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test support for padding fill
|
|
||||||
BOOST_AUTO_TEST_CASE_TEMPLATE(padding_fill, CharT, char_types)
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
//typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
typedef boost::basic_string_view< char_type > string_view_type;
|
|
||||||
|
|
||||||
context< char_type > ctx;
|
|
||||||
|
|
||||||
ostream_type strm_view;
|
|
||||||
strm_view << ctx.begin << std::setfill(static_cast< char_type >('x')) << std::setw(8) << string_view_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::setfill(static_cast< char_type >('x')) << std::setw(8) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_view.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test support for alignment
|
|
||||||
BOOST_AUTO_TEST_CASE_TEMPLATE(alignment, CharT, char_types)
|
|
||||||
{
|
|
||||||
typedef CharT char_type;
|
|
||||||
//typedef std::basic_string< char_type > string_type;
|
|
||||||
typedef std::basic_ostringstream< char_type > ostream_type;
|
|
||||||
typedef boost::basic_string_view< char_type > string_view_type;
|
|
||||||
|
|
||||||
context< char_type > ctx;
|
|
||||||
|
|
||||||
// Left alignment
|
|
||||||
{
|
|
||||||
ostream_type strm_view;
|
|
||||||
strm_view << ctx.begin << std::left << std::setw(8) << string_view_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::left << std::setw(8) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_view.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Right alignment
|
|
||||||
{
|
|
||||||
ostream_type strm_view;
|
|
||||||
strm_view << ctx.begin << std::right << std::setw(8) << string_view_type(ctx.abcd) << ctx.end;
|
|
||||||
|
|
||||||
ostream_type strm_correct;
|
|
||||||
strm_correct << ctx.begin << std::right << std::setw(8) << ctx.abcd << ctx.end;
|
|
||||||
|
|
||||||
BOOST_CHECK(strm_view.str() == strm_correct.str());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,15 +0,0 @@
|
|||||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
|
||||||
<html>
|
|
||||||
<head>
|
|
||||||
<meta http-equiv=refresh content="0; URL=../exception/doc/throw_exception.html">
|
|
||||||
<title>Automatic redirection</title>
|
|
||||||
</head>
|
|
||||||
<body>
|
|
||||||
Automatic redirection failed, please go to
|
|
||||||
<a href="../exception/doc/throw_exception.html">throw_exception.html</a>. <hr>
|
|
||||||
<p><EFBFBD> Copyright Beman Dawes, 2001</p>
|
|
||||||
<p>Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
||||||
file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy
|
|
||||||
at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
|
|
||||||
</body>
|
|
||||||
</html>
|
|
||||||
626
type_traits.htm
Normal file
626
type_traits.htm
Normal file
@@ -0,0 +1,626 @@
|
|||||||
|
<html>
|
||||||
|
|
||||||
|
<head>
|
||||||
|
<meta http-equiv="Content-Type"
|
||||||
|
content="text/html; charset=iso-8859-1">
|
||||||
|
<meta name="Template"
|
||||||
|
content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
|
||||||
|
<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
|
||||||
|
<title>Type Traits</title>
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
|
||||||
|
|
||||||
|
<h1><img src="../../c++boost.gif" width="276" height="86">Header
|
||||||
|
<<a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a>></h1>
|
||||||
|
|
||||||
|
<p>The contents of <boost/type_traits.hpp> are declared in
|
||||||
|
namespace boost.</p>
|
||||||
|
|
||||||
|
<p>The file <<a href="../../boost/detail/type_traits.hpp">boost/type_traits.hpp</a>>
|
||||||
|
contains various template classes that describe the fundamental
|
||||||
|
properties of a type; each class represents a single type
|
||||||
|
property or a single type transformation. This documentation is
|
||||||
|
divided up into the following sections:</p>
|
||||||
|
|
||||||
|
<pre><a href="#fop">Fundamental type operations</a>
|
||||||
|
<a href="#fp">Fundamental type properties</a>
|
||||||
|
<a href="#misc">Miscellaneous</a>
|
||||||
|
<code> </code><a href="#cv">cv-Qualifiers</a>
|
||||||
|
<code> </code><a href="#ft">Fundamental Types</a>
|
||||||
|
<code> </code><a href="#ct">Compound Types</a>
|
||||||
|
<code> </code><a href="#ot">Object/Scalar Types</a>
|
||||||
|
<a href="#cs">Compiler Support Information</a>
|
||||||
|
<a href="#ec">Example Code</a></pre>
|
||||||
|
|
||||||
|
<h2><a name="fop"></a>Fundamental type operations</h2>
|
||||||
|
|
||||||
|
<p>Usage: "class_name<T>::type" performs
|
||||||
|
indicated transformation on type T.</p>
|
||||||
|
|
||||||
|
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><p align="center">Expression.</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="45%"><p align="center">Description.</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">Compiler.</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>remove_volatile<T>::type</code></td>
|
||||||
|
<td valign="top" width="45%">Creates a type the same as T
|
||||||
|
but with any top level volatile qualifier removed. For
|
||||||
|
example "volatile int" would become "int".</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>remove_const<T>::type</code></td>
|
||||||
|
<td valign="top" width="45%">Creates a type the same as T
|
||||||
|
but with any top level const qualifier removed. For
|
||||||
|
example "const int" would become "int".</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>remove_cv<T>::type</code></td>
|
||||||
|
<td valign="top" width="45%">Creates a type the same as T
|
||||||
|
but with any top level cv-qualifiers removed. For example
|
||||||
|
"const int" would become "int", and
|
||||||
|
"volatile double" would become "double".</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>remove_reference<T>::type</code></td>
|
||||||
|
<td valign="top" width="45%">If T is a reference type
|
||||||
|
then removes the reference, otherwise leaves T unchanged.
|
||||||
|
For example "int&" becomes "int"
|
||||||
|
but "int*" remains unchanged.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>add_reference<T>::type</code></td>
|
||||||
|
<td valign="top" width="45%">If T is a reference type
|
||||||
|
then leaves T unchanged, otherwise converts T to a
|
||||||
|
reference type. For example "int&" remains
|
||||||
|
unchanged, but "double" becomes "double&".</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>remove_bounds<T>::type</code></td>
|
||||||
|
<td valign="top" width="45%">If T is an array type then
|
||||||
|
removes the top level array qualifier from T, otherwise
|
||||||
|
leaves T unchanged. For example "int[2][3]"
|
||||||
|
becomes "int[3]".</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<h2><a name="fp"></a>Fundamental type properties</h2>
|
||||||
|
|
||||||
|
<p>Usage: "class_name<T>::value" is true if
|
||||||
|
indicated property is true, false otherwise. (Note that class_name<T>::value
|
||||||
|
is always defined as a compile time constant).</p>
|
||||||
|
|
||||||
|
<h3><a name="misc"></a>Miscellaneous</h3>
|
||||||
|
|
||||||
|
<table border="1" cellspacing="1" width="100%">
|
||||||
|
<tr>
|
||||||
|
<td width="37%"><p align="center">Expression</p>
|
||||||
|
</td>
|
||||||
|
<td width="36%"><p align="center">Description</p>
|
||||||
|
</td>
|
||||||
|
<td width="27%"><p align="center">Compiler</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td width="37%"><div align="center"><center><pre><code>is_same<T,U>::value</code></pre>
|
||||||
|
</center></div></td>
|
||||||
|
<td width="36%"><p align="center">True if T and U are the
|
||||||
|
same type.</p>
|
||||||
|
</td>
|
||||||
|
<td width="27%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td width="37%"><div align="center"><center><pre>is_convertible<T,U>::value</pre>
|
||||||
|
</center></div></td>
|
||||||
|
<td width="36%"><p align="center">True if type T is
|
||||||
|
convertible to type U.</p>
|
||||||
|
</td>
|
||||||
|
<td width="27%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td width="37%"><div align="center"><center><pre>alignment_of<T>::value</pre>
|
||||||
|
</center></div></td>
|
||||||
|
<td width="36%"><p align="center">An integral value
|
||||||
|
representing the minimum alignment requirements of type T
|
||||||
|
(strictly speaking defines a multiple of the type's
|
||||||
|
alignment requirement; for all compilers tested so far
|
||||||
|
however it does return the actual alignment).</p>
|
||||||
|
</td>
|
||||||
|
<td width="27%"> </td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<h3><a name="cv"></a>cv-Qualifiers</h3>
|
||||||
|
|
||||||
|
<p>The following classes determine what cv-qualifiers are present
|
||||||
|
on a type (see 3.93).</p>
|
||||||
|
|
||||||
|
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="37%"><p align="center">Expression.</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="37%"><p align="center">Description.</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="27%"><p align="center">Compiler.</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="37%"><code>is_const<T>::value</code></td>
|
||||||
|
<td valign="top" width="37%">True if type T is top-level
|
||||||
|
const qualified.</td>
|
||||||
|
<td valign="top" width="27%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="37%"><code>is_volatile<T>::value</code></td>
|
||||||
|
<td valign="top" width="37%">True if type T is top-level
|
||||||
|
volatile qualified.</td>
|
||||||
|
<td valign="top" width="27%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<h3><a name="ft"></a>Fundamental Types</h3>
|
||||||
|
|
||||||
|
<p>The following will only ever be true for cv-unqualified types;
|
||||||
|
these are closely based on the section 3.9 of the C++ Standard.</p>
|
||||||
|
|
||||||
|
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><p align="center">Expression.</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="45%"><p align="center">Description.</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">Compiler.</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_void<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True only if T is void.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_standard_unsigned_integral<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True only if T is one of the
|
||||||
|
standard unsigned integral types (3.9.1 p3) - unsigned
|
||||||
|
char, unsigned short, unsigned int, and unsigned long.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_standard_signed_integral<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True only if T is one of the
|
||||||
|
standard signed integral types (3.9.1 p2) - signed char,
|
||||||
|
short, int, and long.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_standard_integral<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a standard
|
||||||
|
integral type(3.9.1 p7) - T is either char, wchar_t, bool
|
||||||
|
or either is_standard_signed_integral<T>::value or
|
||||||
|
is_standard_integral<T>::value is true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_standard_float<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is one of the
|
||||||
|
standard floating point types(3.9.1 p8) - float, double
|
||||||
|
or long double.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_standard_arithmetic<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a standard
|
||||||
|
arithmetic type(3.9.1 p8) - implies is_standard_integral
|
||||||
|
or is_standard_float is true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_standard_fundamental<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a standard
|
||||||
|
arithmetic type or if T is void.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_extension_unsigned_integral<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True for compiler specific
|
||||||
|
unsigned integral types.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_extension_signed_integral<T>>:value</code></td>
|
||||||
|
<td valign="top" width="45%">True for compiler specific
|
||||||
|
signed integral types.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_extension_integral<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_extension_unsigned_integral<T>::value
|
||||||
|
or is_extension_signed_integral<T>::value is true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_extension_float<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True for compiler specific
|
||||||
|
floating point types.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_extension_arithmetic<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_extension_integral<T>::value
|
||||||
|
or is_extension_float<T>::value are true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code> is_extension_fundamental<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_extension_arithmetic<T>::value
|
||||||
|
or is_void<T>::value are true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code> is_unsigned_integral<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_standard_unsigned_integral<T>::value
|
||||||
|
or is_extention_unsigned_integral<T>::value are
|
||||||
|
true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_signed_integral<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_standard_signed_integral<T>::value
|
||||||
|
or is_extention_signed_integral<T>>::value are
|
||||||
|
true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_integral<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_standard_integral<T>::value
|
||||||
|
or is_extention_integral<T>::value are true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_float<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_standard_float<T>::value
|
||||||
|
or is_extention_float<T>::value are true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_arithmetic<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_integral<T>::value
|
||||||
|
or is_float<T>::value are true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_fundamental<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if either is_arithmetic<T>::value
|
||||||
|
or is_void<T>::value are true.</td>
|
||||||
|
<td valign="top" width="33%"> </td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<h3><a name="ct"></a>Compound Types</h3>
|
||||||
|
|
||||||
|
<p>The following will only ever be true for cv-unqualified types,
|
||||||
|
as defined by the Standard. </p>
|
||||||
|
|
||||||
|
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><p align="center">Expression</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="45%"><p align="center">Description</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">Compiler</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_array<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is an array type.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_pointer<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a regular
|
||||||
|
pointer type - including function pointers - but
|
||||||
|
excluding pointers to member functions (3.9.2 p1 and 8.3.1).</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_member_pointer<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a pointer to a
|
||||||
|
non-static class member (3.9.2 p1 and 8.3.1).</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_reference<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a reference
|
||||||
|
type (3.9.2 p1 and 8.3.2).</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_class<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a class or
|
||||||
|
struct type.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PD</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_union<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a union type.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">C</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_enum<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is an enumerator
|
||||||
|
type.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">C</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_compound<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is any of the
|
||||||
|
above compound types.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PD</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<h3><a name="ot"></a>Object/Scalar Types</h3>
|
||||||
|
|
||||||
|
<p>The following ignore any top level cv-qualifiers: if <code>class_name<T>::value</code>
|
||||||
|
is true then <code>class_name<cv-qualified-T>::value</code>
|
||||||
|
will also be true.</p>
|
||||||
|
|
||||||
|
<table border="1" cellpadding="7" cellspacing="1" width="100%">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><p align="center">Expression</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="45%"><p align="center">Description</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">Compiler</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_object<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is not a reference
|
||||||
|
type, or a (possibly cv-qualified) void type.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_standard_scalar<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a standard
|
||||||
|
arithmetic type, an enumerated type, a pointer or a
|
||||||
|
member pointer.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PD</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_extension_scalar<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is an extentions
|
||||||
|
arithmetic type, an enumerated type, a pointer or a
|
||||||
|
member pointer.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PD</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_scalar<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is an arithmetic
|
||||||
|
type, an enumerated type, a pointer or a member pointer.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PD</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_POD<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is a "Plain
|
||||||
|
Old Data" type (see 3.9 p2&p3). Note that
|
||||||
|
although this requires compiler support to be correct in
|
||||||
|
all cases, if T is a scalar or an array of scalars then
|
||||||
|
we can correctly define T as a POD.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PC</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>is_empty<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T is an empty struct
|
||||||
|
or class. If the compiler implements the "zero sized
|
||||||
|
empty base classes" optimisation, then is_empty will
|
||||||
|
correctly guess whether T is empty. Relies upon is_class
|
||||||
|
to determine whether T is a class type. Screens out enum
|
||||||
|
types by using is_convertible<T,int>, this means
|
||||||
|
that empty classes that overload operator int(), will not
|
||||||
|
be classified as empty.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PCD</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>has_trivial_constructor<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T has a trivial
|
||||||
|
default constructor - that is T() is equivalent to memset.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PC</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>has_trivial_copy<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T has a trivial copy
|
||||||
|
constructor - that is T(const T&) is equivalent to
|
||||||
|
memcpy.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PC</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>has_trivial_assign<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T has a trivial
|
||||||
|
assignment operator - that is if T::operator=(const T&)
|
||||||
|
is equivalent to memcpy.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PC</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="45%"><code>has_trivial_destructor<T>::value</code></td>
|
||||||
|
<td valign="top" width="45%">True if T has a trivial
|
||||||
|
destructor - that is if T::~T() has no effect.</td>
|
||||||
|
<td valign="top" width="33%"><p align="center">PC</p>
|
||||||
|
</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<h2><a name="cs"></a>Compiler Support Information</h2>
|
||||||
|
|
||||||
|
<p>The legends used in the tables above have the following
|
||||||
|
meanings:</p>
|
||||||
|
|
||||||
|
<table border="0" cellpadding="7" cellspacing="0" width="480">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%"><p align="center">P</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="90%">Denotes that the class
|
||||||
|
requires support for partial specialisation of class
|
||||||
|
templates to work correctly.</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%"><p align="center">C</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="90%">Denotes that direct compiler
|
||||||
|
support for that traits class is required.</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%"><p align="center">D</p>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="90%">Denotes that the traits
|
||||||
|
class is dependent upon a class that requires direct
|
||||||
|
compiler support.</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<p>For those classes that are marked with a D or C, if compiler
|
||||||
|
support is not provided, this type trait may return "false"
|
||||||
|
when the correct value is actually "true". The single
|
||||||
|
exception to this rule is "is_class", which attempts to
|
||||||
|
guess whether or not T is really a class, and may return "true"
|
||||||
|
when the correct value is actually "false". This can
|
||||||
|
happen if: T is a union, T is an enum, or T is a compiler-supplied
|
||||||
|
scalar type that is not specialised for in these type traits.</p>
|
||||||
|
|
||||||
|
<p><i>If there is no compiler support</i>, to ensure that these
|
||||||
|
traits <i>always</i> return the correct values, specialise 'is_enum'
|
||||||
|
for each user-defined enumeration type, 'is_union' for each user-defined
|
||||||
|
union type, 'is_empty' for each user-defined empty composite type,
|
||||||
|
and 'is_POD' for each user-defined POD type. The 'has_*' traits
|
||||||
|
should also be specialized if the user-defined type has those
|
||||||
|
traits and is <i>not</i> a POD.</p>
|
||||||
|
|
||||||
|
<p>The following rules are automatically enforced:</p>
|
||||||
|
|
||||||
|
<p>is_enum implies is_POD</p>
|
||||||
|
|
||||||
|
<p>is_POD implies has_*</p>
|
||||||
|
|
||||||
|
<p>This means, for example, if you have an empty POD-struct, just
|
||||||
|
specialize is_empty and is_POD, which will cause all the has_* to
|
||||||
|
also return true.</p>
|
||||||
|
|
||||||
|
<h2><a name="ec"></a>Example code</h2>
|
||||||
|
|
||||||
|
<p>Type-traits comes with two sample programs: <a
|
||||||
|
href="type_traits_test.cpp">type_traits_test.cpp</a> tests the
|
||||||
|
type traits classes - mostly this is a test of your compiler's
|
||||||
|
support for the concepts used in the type traits implementation,
|
||||||
|
while <a href="algo_opt_examples.cpp">algo_opt_examples.cpp</a>
|
||||||
|
uses the type traits classes to "optimise" some
|
||||||
|
familiar standard library algorithms.</p>
|
||||||
|
|
||||||
|
<p>There are four algorithm examples in algo_opt_examples.cpp:</p>
|
||||||
|
|
||||||
|
<table border="0" cellpadding="7" cellspacing="0" width="638">
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%"><pre>opt::copy</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="50%">If the copy operation can be
|
||||||
|
performed using memcpy then does so, otherwise uses a
|
||||||
|
regular element by element copy (<i>c.f.</i> std::copy).</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%"><pre>opt::fill</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="50%">If the fill operation can be
|
||||||
|
performed by memset, then does so, otherwise uses a
|
||||||
|
regular element by element assign. Also uses call_traits
|
||||||
|
to optimise how the parameters can be passed (<i>c.f.</i>
|
||||||
|
std::fill).</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%"><pre>opt::destroy_array</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="50%">If the type in the array has
|
||||||
|
a trivial destructor then does nothing, otherwise calls
|
||||||
|
destructors for all elements in the array - this
|
||||||
|
algorithm is the reverse of std::uninitialized_copy / std::uninitialized_fill.</td>
|
||||||
|
</tr>
|
||||||
|
<tr>
|
||||||
|
<td valign="top" width="50%"><pre>opt::iter_swap</pre>
|
||||||
|
</td>
|
||||||
|
<td valign="top" width="50%">Determines whether the
|
||||||
|
iterator is a proxy-iterator: if it is then does a "slow
|
||||||
|
and safe" swap, otherwise calls std::swap on the
|
||||||
|
assumption that std::swap may be specialised for the
|
||||||
|
iterated type.</td>
|
||||||
|
</tr>
|
||||||
|
</table>
|
||||||
|
|
||||||
|
<p> </p>
|
||||||
|
|
||||||
|
<hr>
|
||||||
|
|
||||||
|
<p>Revised 08<sup>th</sup> March 2000</p>
|
||||||
|
|
||||||
|
<p><EFBFBD> Copyright boost.org 2000. Permission to copy, use, modify,
|
||||||
|
sell and distribute this document is granted provided this
|
||||||
|
copyright notice appears in all copies. This document is provided
|
||||||
|
"as is" without express or implied warranty, and with
|
||||||
|
no claim as to its suitability for any purpose.</p>
|
||||||
|
|
||||||
|
<p>Based on contributions by Steve Cleary, Beman Dawes, Howard
|
||||||
|
Hinnant and John Maddock.</p>
|
||||||
|
|
||||||
|
<p>Maintained by <a href="mailto:John_Maddock@compuserve.com">John
|
||||||
|
Maddock</a>, the latest version of this file can be found at <a
|
||||||
|
href="http://www.boost.org/">www.boost.org</a>, and the boost
|
||||||
|
discussion list at <a href="http://www.egroups.com/list/boost">www.egroups.com/list/boost</a>.</p>
|
||||||
|
</body>
|
||||||
|
</html>
|
||||||
595
type_traits_test.cpp
Normal file
595
type_traits_test.cpp
Normal file
@@ -0,0 +1,595 @@
|
|||||||
|
// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
|
||||||
|
// Permission to copy, use, modify, sell and
|
||||||
|
// distribute this software is granted provided this copyright notice appears
|
||||||
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
|
|
||||||
|
// standalone test program for <boost/type_traits.hpp>
|
||||||
|
|
||||||
|
/* Release notes:
|
||||||
|
31st July 2000:
|
||||||
|
Added extra tests for is_empty, is_convertible, alignment_of.
|
||||||
|
23rd July 2000:
|
||||||
|
Removed all call_traits tests to call_traits_test.cpp
|
||||||
|
Removed all compressed_pair tests to compressed_pair_tests.cpp
|
||||||
|
Improved tests macros
|
||||||
|
Tidied up specialistions of type_types classes for test cases.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <iostream>
|
||||||
|
#include <typeinfo>
|
||||||
|
|
||||||
|
#include <boost/type_traits.hpp>
|
||||||
|
#include "type_traits_test.hpp"
|
||||||
|
|
||||||
|
using namespace boost;
|
||||||
|
|
||||||
|
// Since there is no compiler support, we should specialize:
|
||||||
|
// is_enum for all enumerations (is_enum implies is_POD)
|
||||||
|
// is_union for all unions
|
||||||
|
// is_empty for all empty composites
|
||||||
|
// is_POD for all PODs (except enums) (is_POD implies has_*)
|
||||||
|
// has_* for any UDT that has that trait and is not POD
|
||||||
|
|
||||||
|
enum enum_UDT{ one, two, three };
|
||||||
|
struct UDT
|
||||||
|
{
|
||||||
|
UDT();
|
||||||
|
~UDT();
|
||||||
|
UDT(const UDT&);
|
||||||
|
UDT& operator=(const UDT&);
|
||||||
|
int i;
|
||||||
|
|
||||||
|
void f1();
|
||||||
|
int f2();
|
||||||
|
int f3(int);
|
||||||
|
int f4(int, float);
|
||||||
|
};
|
||||||
|
|
||||||
|
struct POD_UDT { int x; };
|
||||||
|
struct empty_UDT{ ~empty_UDT(){}; };
|
||||||
|
struct empty_POD_UDT{};
|
||||||
|
union union_UDT
|
||||||
|
{
|
||||||
|
int x;
|
||||||
|
double y;
|
||||||
|
~union_UDT();
|
||||||
|
};
|
||||||
|
union POD_union_UDT
|
||||||
|
{
|
||||||
|
int x;
|
||||||
|
double y;
|
||||||
|
};
|
||||||
|
union empty_union_UDT
|
||||||
|
{
|
||||||
|
~empty_union_UDT();
|
||||||
|
};
|
||||||
|
union empty_POD_union_UDT{};
|
||||||
|
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||||||
|
namespace boost {
|
||||||
|
template <> struct is_enum<enum_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_POD<POD_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
// this type is not POD, so we have to specialize the has_* individually
|
||||||
|
template <> struct has_trivial_constructor<empty_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct has_trivial_copy<empty_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct has_trivial_assign<empty_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_POD<empty_POD_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_union<union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_union<POD_union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_POD<POD_union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_union<empty_union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
// this type is not POD, so we have to specialize the has_* individually
|
||||||
|
template <> struct has_trivial_constructor<empty_union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct has_trivial_copy<empty_union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct has_trivial_assign<empty_union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_union<empty_POD_union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
template <> struct is_POD<empty_POD_union_UDT>
|
||||||
|
{ static const bool value = true; };
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
namespace boost {
|
||||||
|
template <> struct is_enum<enum_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct is_POD<POD_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
// this type is not POD, so we have to specialize the has_* individually
|
||||||
|
template <> struct has_trivial_constructor<empty_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct has_trivial_copy<empty_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct has_trivial_assign<empty_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct is_POD<empty_POD_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct is_union<union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct is_union<POD_union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct is_POD<POD_union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct is_union<empty_union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
// this type is not POD, so we have to specialize the has_* individually
|
||||||
|
template <> struct has_trivial_constructor<empty_union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct has_trivial_copy<empty_union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct has_trivial_assign<empty_union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct is_union<empty_POD_union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
template <> struct is_POD<empty_POD_union_UDT>
|
||||||
|
{ enum{ value = true }; };
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
class Base { };
|
||||||
|
|
||||||
|
class Deriverd : public Base { };
|
||||||
|
|
||||||
|
class NonDerived { };
|
||||||
|
|
||||||
|
enum enum1
|
||||||
|
{
|
||||||
|
one_,two_
|
||||||
|
};
|
||||||
|
|
||||||
|
enum enum2
|
||||||
|
{
|
||||||
|
three_,four_
|
||||||
|
};
|
||||||
|
|
||||||
|
struct VB
|
||||||
|
{
|
||||||
|
virtual ~VB(){};
|
||||||
|
};
|
||||||
|
|
||||||
|
struct VD : VB
|
||||||
|
{
|
||||||
|
~VD(){};
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
// Steve: All comments that I (Steve Cleary) have added below are prefixed with
|
||||||
|
// "Steve:" The failures that BCB4 has on the tests are due to Borland's
|
||||||
|
// not considering cv-qual's as a part of the type -- they are considered
|
||||||
|
// compiler hints only. These failures should be fixed before long.
|
||||||
|
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
std::cout << "Checking type operations..." << std::endl << std::endl;
|
||||||
|
|
||||||
|
// cv-qualifiers applied to reference types should have no effect
|
||||||
|
// declare these here for later use with is_reference and remove_reference:
|
||||||
|
typedef int& r_type;
|
||||||
|
typedef const r_type cr_type;
|
||||||
|
|
||||||
|
type_test(int, remove_reference<int>::type)
|
||||||
|
type_test(const int, remove_reference<const int>::type)
|
||||||
|
type_test(int, remove_reference<int&>::type)
|
||||||
|
type_test(const int, remove_reference<const int&>::type)
|
||||||
|
type_test(volatile int, remove_reference<volatile int&>::type)
|
||||||
|
type_test(int, remove_reference<cr_type>::type)
|
||||||
|
|
||||||
|
type_test(int, remove_const<const int>::type)
|
||||||
|
// Steve: fails on BCB4
|
||||||
|
type_test(volatile int, remove_const<volatile int>::type)
|
||||||
|
// Steve: fails on BCB4
|
||||||
|
type_test(volatile int, remove_const<const volatile int>::type)
|
||||||
|
type_test(int, remove_const<int>::type)
|
||||||
|
type_test(int*, remove_const<int* const>::type)
|
||||||
|
type_test(int, remove_volatile<volatile int>::type)
|
||||||
|
// Steve: fails on BCB4
|
||||||
|
type_test(const int, remove_volatile<const int>::type)
|
||||||
|
// Steve: fails on BCB4
|
||||||
|
type_test(const int, remove_volatile<const volatile int>::type)
|
||||||
|
type_test(int, remove_volatile<int>::type)
|
||||||
|
type_test(int*, remove_volatile<int* volatile>::type)
|
||||||
|
type_test(int, remove_cv<volatile int>::type)
|
||||||
|
type_test(int, remove_cv<const int>::type)
|
||||||
|
type_test(int, remove_cv<const volatile int>::type)
|
||||||
|
type_test(int, remove_cv<int>::type)
|
||||||
|
type_test(int*, remove_cv<int* volatile>::type)
|
||||||
|
type_test(int*, remove_cv<int* const>::type)
|
||||||
|
type_test(int*, remove_cv<int* const volatile>::type)
|
||||||
|
type_test(const int *, remove_cv<const int * const>::type)
|
||||||
|
type_test(int, remove_bounds<int>::type)
|
||||||
|
type_test(int*, remove_bounds<int*>::type)
|
||||||
|
type_test(int, remove_bounds<int[3]>::type)
|
||||||
|
type_test(int[3], remove_bounds<int[2][3]>::type)
|
||||||
|
|
||||||
|
std::cout << std::endl << "Checking type properties..." << std::endl << std::endl;
|
||||||
|
|
||||||
|
value_test(true, (is_same<int, int>::value))
|
||||||
|
value_test(false, (is_same<int, const int>::value))
|
||||||
|
value_test(false, (is_same<int, int&>::value))
|
||||||
|
value_test(false, (is_same<int*, const int*>::value))
|
||||||
|
value_test(false, (is_same<int*, int*const>::value))
|
||||||
|
value_test(false, (is_same<int, int[2]>::value))
|
||||||
|
|
||||||
|
value_test(false, is_const<int>::value)
|
||||||
|
value_test(true, is_const<const int>::value)
|
||||||
|
value_test(false, is_const<volatile int>::value)
|
||||||
|
value_test(true, is_const<const volatile int>::value)
|
||||||
|
|
||||||
|
value_test(false, is_volatile<int>::value)
|
||||||
|
value_test(false, is_volatile<const int>::value)
|
||||||
|
value_test(true, is_volatile<volatile int>::value)
|
||||||
|
value_test(true, is_volatile<const volatile int>::value)
|
||||||
|
|
||||||
|
value_test(true, is_void<void>::value)
|
||||||
|
// Steve: fails on BCB4
|
||||||
|
// JM: but looks as though it should according to [3.9.3p1]?
|
||||||
|
//value_test(false, is_void<const void>::value)
|
||||||
|
value_test(false, is_void<int>::value)
|
||||||
|
|
||||||
|
value_test(false, is_standard_unsigned_integral<UDT>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<void>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<bool>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<char>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<signed char>::value)
|
||||||
|
value_test(true, is_standard_unsigned_integral<unsigned char>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<wchar_t>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<short>::value)
|
||||||
|
value_test(true, is_standard_unsigned_integral<unsigned short>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<int>::value)
|
||||||
|
value_test(true, is_standard_unsigned_integral<unsigned int>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<long>::value)
|
||||||
|
value_test(true, is_standard_unsigned_integral<unsigned long>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<float>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<double>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<long double>::value)
|
||||||
|
#ifdef ULLONG_MAX
|
||||||
|
value_test(false, is_standard_unsigned_integral<long long>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<unsigned long long>::value)
|
||||||
|
#endif
|
||||||
|
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||||
|
value_test(false, is_standard_unsigned_integral<__int64>::value)
|
||||||
|
value_test(false, is_standard_unsigned_integral<unsigned __int64>::value)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
value_test(false, is_standard_signed_integral<UDT>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<void>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<bool>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<char>::value)
|
||||||
|
value_test(true, is_standard_signed_integral<signed char>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<unsigned char>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<wchar_t>::value)
|
||||||
|
value_test(true, is_standard_signed_integral<short>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<unsigned short>::value)
|
||||||
|
value_test(true, is_standard_signed_integral<int>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<unsigned int>::value)
|
||||||
|
value_test(true, is_standard_signed_integral<long>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<unsigned long>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<float>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<double>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<long double>::value)
|
||||||
|
#ifdef ULLONG_MAX
|
||||||
|
value_test(false, is_standard_signed_integral<long long>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<unsigned long long>::value)
|
||||||
|
#endif
|
||||||
|
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||||
|
value_test(false, is_standard_signed_integral<__int64>::value)
|
||||||
|
value_test(false, is_standard_signed_integral<unsigned __int64>::value)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
value_test(false, is_standard_arithmetic<UDT>::value)
|
||||||
|
value_test(false, is_standard_arithmetic<void>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<bool>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<char>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<signed char>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<unsigned char>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<wchar_t>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<short>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<unsigned short>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<int>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<unsigned int>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<long>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<unsigned long>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<float>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<double>::value)
|
||||||
|
value_test(true, is_standard_arithmetic<long double>::value)
|
||||||
|
#ifdef ULLONG_MAX
|
||||||
|
value_test(false, is_standard_arithmetic<long long>::value)
|
||||||
|
value_test(false, is_standard_arithmetic<unsigned long long>::value)
|
||||||
|
#endif
|
||||||
|
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||||
|
value_test(false, is_standard_arithmetic<__int64>::value)
|
||||||
|
value_test(false, is_standard_arithmetic<unsigned __int64>::value)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
value_test(false, is_standard_fundamental<UDT>::value)
|
||||||
|
value_test(true, is_standard_fundamental<void>::value)
|
||||||
|
value_test(true, is_standard_fundamental<bool>::value)
|
||||||
|
value_test(true, is_standard_fundamental<char>::value)
|
||||||
|
value_test(true, is_standard_fundamental<signed char>::value)
|
||||||
|
value_test(true, is_standard_fundamental<unsigned char>::value)
|
||||||
|
value_test(true, is_standard_fundamental<wchar_t>::value)
|
||||||
|
value_test(true, is_standard_fundamental<short>::value)
|
||||||
|
value_test(true, is_standard_fundamental<unsigned short>::value)
|
||||||
|
value_test(true, is_standard_fundamental<int>::value)
|
||||||
|
value_test(true, is_standard_fundamental<unsigned int>::value)
|
||||||
|
value_test(true, is_standard_fundamental<long>::value)
|
||||||
|
value_test(true, is_standard_fundamental<unsigned long>::value)
|
||||||
|
value_test(true, is_standard_fundamental<float>::value)
|
||||||
|
value_test(true, is_standard_fundamental<double>::value)
|
||||||
|
value_test(true, is_standard_fundamental<long double>::value)
|
||||||
|
#ifdef ULLONG_MAX
|
||||||
|
value_test(false, is_standard_fundamental<long long>::value)
|
||||||
|
value_test(false, is_standard_fundamental<unsigned long long>::value)
|
||||||
|
#endif
|
||||||
|
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||||
|
value_test(false, is_standard_fundamental<__int64>::value)
|
||||||
|
value_test(false, is_standard_fundamental<unsigned __int64>::value)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
value_test(false, is_arithmetic<UDT>::value)
|
||||||
|
value_test(true, is_arithmetic<char>::value)
|
||||||
|
value_test(true, is_arithmetic<signed char>::value)
|
||||||
|
value_test(true, is_arithmetic<unsigned char>::value)
|
||||||
|
value_test(true, is_arithmetic<wchar_t>::value)
|
||||||
|
value_test(true, is_arithmetic<short>::value)
|
||||||
|
value_test(true, is_arithmetic<unsigned short>::value)
|
||||||
|
value_test(true, is_arithmetic<int>::value)
|
||||||
|
value_test(true, is_arithmetic<unsigned int>::value)
|
||||||
|
value_test(true, is_arithmetic<long>::value)
|
||||||
|
value_test(true, is_arithmetic<unsigned long>::value)
|
||||||
|
value_test(true, is_arithmetic<float>::value)
|
||||||
|
value_test(true, is_arithmetic<double>::value)
|
||||||
|
value_test(true, is_arithmetic<long double>::value)
|
||||||
|
value_test(true, is_arithmetic<bool>::value)
|
||||||
|
#ifdef ULLONG_MAX
|
||||||
|
value_test(true, is_arithmetic<long long>::value)
|
||||||
|
value_test(true, is_arithmetic<unsigned long long>::value)
|
||||||
|
#endif
|
||||||
|
#if defined(__BORLANDC__) || defined(_MSC_VER)
|
||||||
|
value_test(true, is_arithmetic<__int64>::value)
|
||||||
|
value_test(true, is_arithmetic<unsigned __int64>::value)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
value_test(false, is_array<int>::value)
|
||||||
|
value_test(false, is_array<int*>::value)
|
||||||
|
value_test(true, is_array<int[2]>::value)
|
||||||
|
value_test(true, is_array<int[2][3]>::value)
|
||||||
|
value_test(true, is_array<UDT[2]>::value)
|
||||||
|
|
||||||
|
typedef void(*f1)();
|
||||||
|
typedef int(*f2)(int);
|
||||||
|
typedef int(*f3)(int, bool);
|
||||||
|
typedef void (UDT::*mf1)();
|
||||||
|
typedef int (UDT::*mf2)();
|
||||||
|
typedef int (UDT::*mf3)(int);
|
||||||
|
typedef int (UDT::*mf4)(int, float);
|
||||||
|
|
||||||
|
value_test(false, is_pointer<int>::value)
|
||||||
|
value_test(false, is_pointer<int&>::value)
|
||||||
|
value_test(true, is_pointer<int*>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
|
||||||
|
value_test(false, is_pointer<int*const>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
|
||||||
|
value_test(false, is_pointer<int*volatile>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9.2p3, 3.9.3p1
|
||||||
|
value_test(false, is_pointer<int*const volatile>::value)
|
||||||
|
value_test(true, is_pointer<f1>::value)
|
||||||
|
value_test(true, is_pointer<f2>::value)
|
||||||
|
value_test(true, is_pointer<f3>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9.2p3
|
||||||
|
value_test(false, is_pointer<mf1>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9.2p3
|
||||||
|
value_test(false, is_pointer<mf2>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9.2p3
|
||||||
|
value_test(false, is_pointer<mf3>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9.2p3
|
||||||
|
value_test(false, is_pointer<mf4>::value)
|
||||||
|
|
||||||
|
value_test(false, is_reference<bool>::value)
|
||||||
|
value_test(true, is_reference<int&>::value)
|
||||||
|
value_test(true, is_reference<const int&>::value)
|
||||||
|
value_test(true, is_reference<volatile int &>::value)
|
||||||
|
value_test(true, is_reference<r_type>::value)
|
||||||
|
value_test(true, is_reference<cr_type>::value)
|
||||||
|
|
||||||
|
value_test(false, is_class<int>::value)
|
||||||
|
value_test(false, is_class<const int>::value)
|
||||||
|
value_test(false, is_class<volatile int>::value)
|
||||||
|
value_test(false, is_class<int*>::value)
|
||||||
|
value_test(false, is_class<int* const>::value)
|
||||||
|
value_test(false, is_class<int[2]>::value)
|
||||||
|
value_test(false, is_class<int&>::value)
|
||||||
|
value_test(false, is_class<mf4>::value)
|
||||||
|
value_test(false, is_class<f1>::value)
|
||||||
|
value_test(false, is_class<enum_UDT>::value)
|
||||||
|
value_test(true, is_class<UDT>::value)
|
||||||
|
value_test(true, is_class<UDT const>::value)
|
||||||
|
value_test(true, is_class<UDT volatile>::value)
|
||||||
|
value_test(true, is_class<empty_UDT>::value)
|
||||||
|
value_test(true, is_class<std::iostream>::value)
|
||||||
|
value_test(false, is_class<UDT*>::value)
|
||||||
|
value_test(false, is_class<UDT[2]>::value)
|
||||||
|
value_test(false, is_class<UDT&>::value)
|
||||||
|
|
||||||
|
value_test(true, is_object<int>::value)
|
||||||
|
value_test(true, is_object<UDT>::value)
|
||||||
|
value_test(false, is_object<int&>::value)
|
||||||
|
value_test(false, is_object<void>::value)
|
||||||
|
value_test(true, is_standard_scalar<int>::value)
|
||||||
|
value_test(true, is_extension_scalar<void*>::value)
|
||||||
|
|
||||||
|
value_test(false, is_enum<int>::value)
|
||||||
|
value_test(true, is_enum<enum_UDT>::value)
|
||||||
|
|
||||||
|
value_test(false, is_member_pointer<f1>::value)
|
||||||
|
value_test(false, is_member_pointer<f2>::value)
|
||||||
|
value_test(false, is_member_pointer<f3>::value)
|
||||||
|
value_test(true, is_member_pointer<mf1>::value)
|
||||||
|
value_test(true, is_member_pointer<mf2>::value)
|
||||||
|
value_test(true, is_member_pointer<mf3>::value)
|
||||||
|
value_test(true, is_member_pointer<mf4>::value)
|
||||||
|
|
||||||
|
value_test(false, is_empty<int>::value)
|
||||||
|
value_test(false, is_empty<int*>::value)
|
||||||
|
value_test(false, is_empty<int&>::value)
|
||||||
|
#ifdef __MWERKS__
|
||||||
|
// apparent compiler bug causes this to fail to compile:
|
||||||
|
value_fail(false, is_empty<int[2]>::value)
|
||||||
|
#else
|
||||||
|
value_test(false, is_empty<int[2]>::value)
|
||||||
|
#endif
|
||||||
|
value_test(false, is_empty<f1>::value)
|
||||||
|
value_test(false, is_empty<mf1>::value)
|
||||||
|
value_test(false, is_empty<UDT>::value)
|
||||||
|
value_test(true, is_empty<empty_UDT>::value)
|
||||||
|
value_test(true, is_empty<empty_POD_UDT>::value)
|
||||||
|
value_test(true, is_empty<empty_union_UDT>::value)
|
||||||
|
value_test(false, is_empty<enum_UDT>::value)
|
||||||
|
|
||||||
|
value_test(true, has_trivial_constructor<int>::value)
|
||||||
|
value_test(true, has_trivial_constructor<int*>::value)
|
||||||
|
value_test(true, has_trivial_constructor<int*const>::value)
|
||||||
|
value_test(true, has_trivial_constructor<const int>::value)
|
||||||
|
value_test(true, has_trivial_constructor<volatile int>::value)
|
||||||
|
value_test(true, has_trivial_constructor<int[2]>::value)
|
||||||
|
value_test(true, has_trivial_constructor<int[3][2]>::value)
|
||||||
|
value_test(true, has_trivial_constructor<int[2][4][5][6][3]>::value)
|
||||||
|
value_test(true, has_trivial_constructor<f1>::value)
|
||||||
|
value_test(true, has_trivial_constructor<mf2>::value)
|
||||||
|
value_test(false, has_trivial_constructor<UDT>::value)
|
||||||
|
value_test(true, has_trivial_constructor<empty_UDT>::value)
|
||||||
|
value_test(true, has_trivial_constructor<enum_UDT>::value)
|
||||||
|
|
||||||
|
value_test(true, has_trivial_copy<int>::value)
|
||||||
|
value_test(true, has_trivial_copy<int*>::value)
|
||||||
|
value_test(true, has_trivial_copy<int*const>::value)
|
||||||
|
value_test(true, has_trivial_copy<const int>::value)
|
||||||
|
// Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
|
||||||
|
value_test(true, has_trivial_copy<volatile int>::value)
|
||||||
|
value_test(true, has_trivial_copy<int[2]>::value)
|
||||||
|
value_test(true, has_trivial_copy<int[3][2]>::value)
|
||||||
|
value_test(true, has_trivial_copy<int[2][4][5][6][3]>::value)
|
||||||
|
value_test(true, has_trivial_copy<f1>::value)
|
||||||
|
value_test(true, has_trivial_copy<mf2>::value)
|
||||||
|
value_test(false, has_trivial_copy<UDT>::value)
|
||||||
|
value_test(true, has_trivial_copy<empty_UDT>::value)
|
||||||
|
value_test(true, has_trivial_copy<enum_UDT>::value)
|
||||||
|
|
||||||
|
value_test(true, has_trivial_assign<int>::value)
|
||||||
|
value_test(true, has_trivial_assign<int*>::value)
|
||||||
|
value_test(true, has_trivial_assign<int*const>::value)
|
||||||
|
value_test(true, has_trivial_assign<const int>::value)
|
||||||
|
// Steve: was 'false' -- should be 'true' via 3.9p3, 3.9p10
|
||||||
|
value_test(true, has_trivial_assign<volatile int>::value)
|
||||||
|
value_test(true, has_trivial_assign<int[2]>::value)
|
||||||
|
value_test(true, has_trivial_assign<int[3][2]>::value)
|
||||||
|
value_test(true, has_trivial_assign<int[2][4][5][6][3]>::value)
|
||||||
|
value_test(true, has_trivial_assign<f1>::value)
|
||||||
|
value_test(true, has_trivial_assign<mf2>::value)
|
||||||
|
value_test(false, has_trivial_assign<UDT>::value)
|
||||||
|
value_test(true, has_trivial_assign<empty_UDT>::value)
|
||||||
|
value_test(true, has_trivial_assign<enum_UDT>::value)
|
||||||
|
|
||||||
|
value_test(true, has_trivial_destructor<int>::value)
|
||||||
|
value_test(true, has_trivial_destructor<int*>::value)
|
||||||
|
value_test(true, has_trivial_destructor<int*const>::value)
|
||||||
|
value_test(true, has_trivial_destructor<const int>::value)
|
||||||
|
value_test(true, has_trivial_destructor<volatile int>::value)
|
||||||
|
value_test(true, has_trivial_destructor<int[2]>::value)
|
||||||
|
value_test(true, has_trivial_destructor<int[3][2]>::value)
|
||||||
|
value_test(true, has_trivial_destructor<int[2][4][5][6][3]>::value)
|
||||||
|
value_test(true, has_trivial_destructor<f1>::value)
|
||||||
|
value_test(true, has_trivial_destructor<mf2>::value)
|
||||||
|
value_test(false, has_trivial_destructor<UDT>::value)
|
||||||
|
value_test(false, has_trivial_destructor<empty_UDT>::value)
|
||||||
|
value_test(true, has_trivial_destructor<enum_UDT>::value)
|
||||||
|
|
||||||
|
value_test(true, is_POD<int>::value)
|
||||||
|
value_test(true, is_POD<int*>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9p10
|
||||||
|
value_test(false, is_POD<int&>::value)
|
||||||
|
value_test(true, is_POD<int*const>::value)
|
||||||
|
value_test(true, is_POD<const int>::value)
|
||||||
|
// Steve: was 'false', should be 'true', via 3.9p10
|
||||||
|
value_test(true, is_POD<volatile int>::value)
|
||||||
|
// Steve: was 'true', should be 'false', via 3.9p10
|
||||||
|
value_test(false, is_POD<const int&>::value)
|
||||||
|
value_test(true, is_POD<int[2]>::value)
|
||||||
|
value_test(true, is_POD<int[3][2]>::value)
|
||||||
|
value_test(true, is_POD<int[2][4][5][6][3]>::value)
|
||||||
|
value_test(true, is_POD<f1>::value)
|
||||||
|
value_test(true, is_POD<mf2>::value)
|
||||||
|
value_test(false, is_POD<UDT>::value)
|
||||||
|
value_test(false, is_POD<empty_UDT>::value)
|
||||||
|
value_test(true, is_POD<enum_UDT>::value)
|
||||||
|
|
||||||
|
value_test(true, (boost::is_convertible<Deriverd,Base>::value));
|
||||||
|
value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
|
||||||
|
value_test(true, (boost::is_convertible<Base,Base>::value));
|
||||||
|
value_test(false, (boost::is_convertible<Base,Deriverd>::value));
|
||||||
|
value_test(true, (boost::is_convertible<Deriverd,Deriverd>::value));
|
||||||
|
value_test(false, (boost::is_convertible<NonDerived,Base>::value));
|
||||||
|
//value_test(false, (boost::is_convertible<boost::noncopyable, boost::noncopyable>::value));
|
||||||
|
value_test(true, (boost::is_convertible<float,int>::value));
|
||||||
|
#if defined(BOOST_MSVC6_MEMBER_TEMPLATES) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
||||||
|
value_test(false, (boost::is_convertible<float,void>::value));
|
||||||
|
value_test(false, (boost::is_convertible<void,float>::value));
|
||||||
|
value_test(true, (boost::is_convertible<void,void>::value));
|
||||||
|
#endif
|
||||||
|
value_test(true, (boost::is_convertible<enum1, int>::value));
|
||||||
|
value_test(true, (boost::is_convertible<Deriverd*, Base*>::value));
|
||||||
|
value_test(false, (boost::is_convertible<Base*, Deriverd*>::value));
|
||||||
|
value_test(true, (boost::is_convertible<Deriverd&, Base&>::value));
|
||||||
|
value_test(false, (boost::is_convertible<Base&, Deriverd&>::value));
|
||||||
|
value_test(true, (boost::is_convertible<const Deriverd*, const Base*>::value));
|
||||||
|
value_test(false, (boost::is_convertible<const Base*, const Deriverd*>::value));
|
||||||
|
value_test(true, (boost::is_convertible<const Deriverd&, const Base&>::value));
|
||||||
|
value_test(false, (boost::is_convertible<const Base&, const Deriverd&>::value));
|
||||||
|
|
||||||
|
value_test(false, (boost::is_convertible<const int *, int*>::value));
|
||||||
|
value_test(false, (boost::is_convertible<const int&, int&>::value));
|
||||||
|
value_test(false, (boost::is_convertible<int*, int[2]>::value));
|
||||||
|
value_test(false, (boost::is_convertible<const int*, int[3]>::value));
|
||||||
|
value_test(true, (boost::is_convertible<const int&, int>::value));
|
||||||
|
value_test(true, (boost::is_convertible<int(&)[4], const int*>::value));
|
||||||
|
value_test(true, (boost::is_convertible<int(&)(int), int(*)(int)>::value));
|
||||||
|
value_test(true, (boost::is_convertible<int *, const int*>::value));
|
||||||
|
value_test(true, (boost::is_convertible<int&, const int&>::value));
|
||||||
|
value_test(true, (boost::is_convertible<int[2], int*>::value));
|
||||||
|
value_test(true, (boost::is_convertible<int[2], const int*>::value));
|
||||||
|
value_test(false, (boost::is_convertible<const int[2], int*>::value));
|
||||||
|
|
||||||
|
align_test(int);
|
||||||
|
align_test(char);
|
||||||
|
align_test(double);
|
||||||
|
align_test(int[4]);
|
||||||
|
align_test(int(*)(int));
|
||||||
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
|
align_test(char&);
|
||||||
|
align_test(char (&)(int));
|
||||||
|
align_test(char(&)[4]);
|
||||||
|
#endif
|
||||||
|
align_test(int*);
|
||||||
|
//align_test(const int);
|
||||||
|
align_test(VB);
|
||||||
|
align_test(VD);
|
||||||
|
|
||||||
|
std::cout << std::endl << test_count << " tests completed (" << failures << " failures)... press any key to exit";
|
||||||
|
std::cin.get();
|
||||||
|
return failures;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
106
type_traits_test.hpp
Normal file
106
type_traits_test.hpp
Normal file
@@ -0,0 +1,106 @@
|
|||||||
|
// boost::compressed_pair test program
|
||||||
|
|
||||||
|
// (C) Copyright John Maddock 2000. Permission to copy, use, modify, sell and
|
||||||
|
// distribute this software is granted provided this copyright notice appears
|
||||||
|
// in all copies. This software is provided "as is" without express or implied
|
||||||
|
// warranty, and with no claim as to its suitability for any purpose.
|
||||||
|
|
||||||
|
// common test code for type_traits_test.cpp/call_traits_test.cpp/compressed_pair_test.cpp
|
||||||
|
|
||||||
|
|
||||||
|
#ifndef BOOST_TYPE_TRAITS_TEST_HPP
|
||||||
|
#define BOOST_TYPE_TRAITS_TEST_HPP
|
||||||
|
|
||||||
|
//
|
||||||
|
// this one is here just to suppress warnings:
|
||||||
|
//
|
||||||
|
template <class T>
|
||||||
|
bool do_compare(T i, T j)
|
||||||
|
{
|
||||||
|
return i == j;
|
||||||
|
}
|
||||||
|
|
||||||
|
//
|
||||||
|
// this one is to verify that a constant is indeed a
|
||||||
|
// constant-integral-expression:
|
||||||
|
//
|
||||||
|
template <int>
|
||||||
|
struct ct_checker
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
|
||||||
|
#define BOOST_DO_JOIN2(X, Y) X ## Y
|
||||||
|
#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
|
||||||
|
|
||||||
|
|
||||||
|
#define value_test(v, x) ++test_count;\
|
||||||
|
typedef ct_checker<(x)> BOOST_JOIN(this_is_a_compile_time_check_, __LINE__);\
|
||||||
|
if(!do_compare((int)v,(int)x)){++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;}
|
||||||
|
#define value_fail(v, x) ++test_count; ++failures; std::cout << "checking value of " << #x << "...failed" << std::endl;
|
||||||
|
|
||||||
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
|
#define type_test(v, x) ++test_count;\
|
||||||
|
if(do_compare(boost::is_same<v, x>::value, false)){\
|
||||||
|
++failures; \
|
||||||
|
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||||
|
std::cout << " expected type was " << #v << std::endl; \
|
||||||
|
std::cout << " " << typeid(boost::is_same<v, x>).name() << "::value is false" << std::endl; }
|
||||||
|
#else
|
||||||
|
#define type_test(v, x) ++test_count;\
|
||||||
|
if(typeid(v) != typeid(x)){\
|
||||||
|
++failures; \
|
||||||
|
std::cout << "checking type of " << #x << "...failed" << std::endl; \
|
||||||
|
std::cout << " expected type was " << #v << std::endl; \
|
||||||
|
std::cout << " " << "typeid(" #v ") != typeid(" #x ")" << std::endl; }
|
||||||
|
#endif
|
||||||
|
|
||||||
|
template <class T>
|
||||||
|
struct test_align
|
||||||
|
{
|
||||||
|
struct padded
|
||||||
|
{
|
||||||
|
char c;
|
||||||
|
T t;
|
||||||
|
};
|
||||||
|
static void do_it()
|
||||||
|
{
|
||||||
|
padded p;
|
||||||
|
unsigned a = reinterpret_cast<char*>(&(p.t)) - reinterpret_cast<char*>(&p);
|
||||||
|
value_test(a, boost::alignment_of<T>::value);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
||||||
|
template <class T>
|
||||||
|
struct test_align<T&>
|
||||||
|
{
|
||||||
|
static void do_it()
|
||||||
|
{
|
||||||
|
//
|
||||||
|
// we can't do the usual test because we can't take the address
|
||||||
|
// of a reference, so check that the result is the same as for a
|
||||||
|
// pointer type instead:
|
||||||
|
value_test(boost::alignment_of<T*>::value, boost::alignment_of<T&>::value);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define align_test(T) test_align<T>::do_it()
|
||||||
|
|
||||||
|
//
|
||||||
|
// define tests here
|
||||||
|
unsigned failures = 0;
|
||||||
|
unsigned test_count = 0;
|
||||||
|
|
||||||
|
//
|
||||||
|
// turn off some warnings:
|
||||||
|
#ifdef __BORLANDC__
|
||||||
|
#pragma option -w-8004
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef BOOST_MSVC
|
||||||
|
#pragma warning (disable: 4018)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
#endif // BOOST_TYPE_TRAITS_TEST_HPP
|
||||||
685
utility.htm
685
utility.htm
@@ -1,622 +1,103 @@
|
|||||||
<html>
|
<html>
|
||||||
<head>
|
|
||||||
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
<head>
|
||||||
<title>Header boost/utility.hpp Documentation</title>
|
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
|
||||||
</head>
|
<title>Header boost/utility.hpp Documentation</title>
|
||||||
<body bgcolor="#FFFFFF" text="#000000">
|
</head>
|
||||||
<h1><img src="../../boost.png" alt="boost.png (6897 bytes)" align="center" WIDTH="277" HEIGHT="86">Header
|
|
||||||
<a href="../../boost/utility.hpp">boost/utility.hpp</a></h1>
|
<body bgcolor="#FFFFFF" text="#000000">
|
||||||
<p>The entire contents of the header <code><a href="../../boost/utility.hpp"><boost/utility.hpp></a></code>
|
|
||||||
are in <code>namespace boost</code>.</p>
|
<h1><img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center" WIDTH="277" HEIGHT="86">Header
|
||||||
<h2>Contents</h2>
|
<a href="../../boost/utility.hpp">boost/utility.hpp</a></h1>
|
||||||
<ul>
|
|
||||||
<li>
|
<p>The entire contents of the header <code><a href="../../boost/utility.hpp"><boost/utility.hpp></a></code>
|
||||||
Class templates supporting the <a href="doc/html/base_from_member.html">
|
are in <code>namespace boost</code>.</p>
|
||||||
base-from-member idiom</a></li>
|
|
||||||
<li>
|
<h2>Contents</h2>
|
||||||
Function templates <a href="../core/doc/html/core/checked_delete.html">checked_delete() and
|
|
||||||
checked_array_delete()</a> (moved to the Boost.Core library)</li>
|
<ul>
|
||||||
<li>
|
<li>Template functions <a href="#functions next">next() and prior()</a></li>
|
||||||
Function templates <a href="#functions_next_prior">next() and prior()</a></li>
|
<li>Class <a href="#Class noncopyable">noncopyable</a></li>
|
||||||
<li>
|
</ul>
|
||||||
Class <a href="../core/doc/html/core/noncopyable.html">noncopyable</a> (moved to the Boost.Core library)</li>
|
<h2>Template <a name="functions next">functions next</a>() and prior()</h2>
|
||||||
<li>
|
|
||||||
Function template <a href="../core/doc/html/core/addressof.html">addressof()</a> (moved to the Boost.Core library)</li>
|
<p>Certain data types, such as the C++ Standard Library's forward and
|
||||||
<li>Class template <a href="#result_of">result_of</a></li>
|
bidirectional iterators, do not provide addition and subtraction via operator+()
|
||||||
<li>
|
or operator-(). This means that non-modifying computation of the next or
|
||||||
Macro <a href="#BOOST_BINARY">BOOST_BINARY</a></li>
|
prior value requires a temporary, even though operator++() or operator--() is
|
||||||
<li><a href="index.html">Other utilities not part of <code>utility.hpp</code></a></li>
|
provided. It also means that writing code like <code>itr+1</code> inside a
|
||||||
</ul>
|
template restricts the iterator category to random access iterators.</p>
|
||||||
<h2>
|
|
||||||
<a name="functions_next_prior">Function</a> templates next() and prior()</h2>
|
<p>The next() and prior() functions provide a simple way around these problems:</p>
|
||||||
<p>Certain data types, such as the C++ Standard Library's forward and bidirectional
|
|
||||||
iterators, do not provide addition and subtraction via operator+() or
|
<blockquote>
|
||||||
operator-(). This means that non-modifying computation of the next or
|
|
||||||
prior value requires a temporary, even though operator++() or operator--() is
|
<pre>template <class T>
|
||||||
provided. It also means that writing code like <code>itr+1</code> inside
|
|
||||||
a template restricts the iterator category to random access iterators.</p>
|
|
||||||
<p>The next() and prior() functions provide a simple way around these problems:</p>
|
|
||||||
<blockquote>
|
|
||||||
<pre>template <class T>
|
|
||||||
T next(T x) { return ++x; }
|
T next(T x) { return ++x; }
|
||||||
|
|
||||||
template <class T, class Distance>
|
template <class X>
|
||||||
T next(T x, Distance n)
|
T prior(T x) { return --x; }</pre>
|
||||||
{
|
|
||||||
std::advance(x, n);
|
|
||||||
return x;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
</blockquote>
|
||||||
T prior(T x) { return --x; }
|
|
||||||
|
|
||||||
template <class T, class Distance>
|
<p>Usage is simple:</p>
|
||||||
T prior(T x, Distance n)
|
|
||||||
{
|
|
||||||
std::advance(x, -n);
|
|
||||||
return x;
|
|
||||||
}</pre>
|
|
||||||
</blockquote>
|
|
||||||
<p>Usage is simple:</p>
|
|
||||||
<blockquote>
|
|
||||||
<pre>const std::list<T>::iterator p = get_some_iterator();
|
|
||||||
const std::list<T>::iterator prev = boost::prior(p);
|
|
||||||
const std::list<T>::iterator next = boost::next(prev, 2);</pre>
|
|
||||||
</blockquote>
|
|
||||||
<p>The distance from the given iterator should be supplied as an absolute value. For
|
|
||||||
example, the iterator four iterators prior to the given iterator <code>p</code>
|
|
||||||
may be obtained by <code>prior(p, 4)</code>.</p>
|
|
||||||
<p>Contributed by <a href="http://www.boost.org/people/dave_abrahams.htm">Dave Abrahams</a>. Two-argument versions by Daniel Walker.</p>
|
|
||||||
|
|
||||||
<h2><a name="result_of">Class template
|
<blockquote>
|
||||||
result_of</a></h2> <p>The class template
|
|
||||||
<code>result_of</code> helps determine the type of a
|
|
||||||
call expression. For example, given an lvalue <code>f</code> of
|
|
||||||
type <code>F</code> and lvalues <code>t1</code>,
|
|
||||||
<code>t2</code>, ..., <code>t<em>N</em></code> of
|
|
||||||
types <code>T1</code>, <code>T2</code>, ...,
|
|
||||||
<code>T<em>N</em></code>, respectively, the type
|
|
||||||
<code>result_of<F(T1, T2, ...,
|
|
||||||
T<em>N</em>)>::type</code> defines the result type
|
|
||||||
of the expression <code>f(t1, t2,
|
|
||||||
...,t<em>N</em>)</code>. This implementation permits
|
|
||||||
the type <code>F</code> to be a function pointer,
|
|
||||||
function reference, member function pointer, or class
|
|
||||||
type. By default, <em>N</em> may be any value between 0 and
|
|
||||||
16. To change the upper limit, define the macro
|
|
||||||
<code>BOOST_RESULT_OF_NUM_ARGS</code> to the maximum
|
|
||||||
value for <em>N</em>. Class template <code>result_of</code>
|
|
||||||
resides in the header <code><<a
|
|
||||||
href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>></code>.</p>
|
|
||||||
|
|
||||||
<p>If your compiler's support for <code>decltype</code> is
|
<pre>const std::list<T>::iterator p = get_some_iterator();
|
||||||
adequate, <code>result_of</code> automatically uses it to
|
const std::list<T>::iterator prev = boost::prior(p);</pre>
|
||||||
deduce the type of the call expression, in which case
|
|
||||||
<code>result_of<F(T1, T2, ...,
|
|
||||||
T<em>N</em>)>::type</code> names the type
|
|
||||||
<code>decltype(boost::declval<F>()(boost::declval<T1>(),
|
|
||||||
boost::declval<T2>(), ...,
|
|
||||||
boost::declval<T<em>N</em>>()))</code>, as in the
|
|
||||||
following example.</p>
|
|
||||||
|
|
||||||
<blockquote>
|
</blockquote>
|
||||||
<pre>struct functor {
|
|
||||||
template<class T>
|
|
||||||
T operator()(T x)
|
|
||||||
{
|
|
||||||
return x;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef boost::result_of<
|
<p>Contributed by <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>.</p>
|
||||||
functor(int)
|
|
||||||
>::type type; // type is int</pre>
|
|
||||||
</blockquote>
|
|
||||||
|
|
||||||
<p>You can test whether <code>result_of</code> is using
|
<h2><a name="Class noncopyable">Class noncopyable</a></h2>
|
||||||
<code>decltype</code> by checking if the macro
|
|
||||||
<code>BOOST_RESULT_OF_USE_DECLTYPE</code> is defined after
|
|
||||||
including <code>result_of.hpp</code>. You can also force
|
|
||||||
<code>result_of</code> to use <code>decltype</code> by
|
|
||||||
defining <code>BOOST_RESULT_OF_USE_DECLTYPE</code> prior
|
|
||||||
to including <code>result_of.hpp</code>.</p>
|
|
||||||
|
|
||||||
<p>If <code>decltype</code> is not used,
|
<p>Class <strong>noncopyable</strong> is a base class. Derive your own class from <strong>noncopyable</strong>
|
||||||
then automatic result type deduction of function
|
when you want to prohibit copy construction and copy assignment.</p>
|
||||||
objects is not possible. Instead, <code>result_of</code>
|
|
||||||
uses the following protocol to allow the programmer to
|
|
||||||
specify a type. When <code>F</code> is a class type with a
|
|
||||||
member type <code>result_type</code>,
|
|
||||||
<code>result_of<F(T1, T2, ...,
|
|
||||||
T<em>N</em>)>::type</code> is
|
|
||||||
<code>F::result_type</code>. When <code>F</code> does
|
|
||||||
not contain <code>result_type</code>,
|
|
||||||
<code>result_of<F(T1, T2, ...,
|
|
||||||
T<em>N</em>)>::type</code> is <code>F::result<F(T1,
|
|
||||||
T2, ..., T<em>N</em>)>::type</code> when
|
|
||||||
<code><em>N</em> > 0</code> or <code>void</code>
|
|
||||||
when <code><em>N</em> = 0</code>. Note that it is the
|
|
||||||
responsibility of the programmer to ensure that
|
|
||||||
function objects accurately advertise their result
|
|
||||||
type via this protocol, as in the following
|
|
||||||
example.</p>
|
|
||||||
|
|
||||||
<blockquote>
|
<p>Some objects, particularly those which hold complex resources like files or
|
||||||
<pre>struct functor {
|
network connections, have no sensible copy semantics. Sometimes there are
|
||||||
template<class> struct result;
|
possible copy semantics, but these would be of very limited usefulness and be
|
||||||
|
very difficult to implement correctly. Sometimes you're implementing a class that doesn't need to be copied
|
||||||
|
just yet and you don't want to take the time to write the appropriate functions.
|
||||||
|
Deriving from <b> noncopyable</b> will prevent the otherwise implicitly-generated
|
||||||
|
functions (which don't have the proper semantics) from becoming a trap for other programmers.</p>
|
||||||
|
|
||||||
template<class F, class T>
|
<p>The traditional way to deal with these is to declare a private copy constructor and copy assignment, and then
|
||||||
struct result<F(T)> {
|
document why this is done. But deriving from <b>noncopyable</b> is simpler
|
||||||
typedef T type;
|
and clearer, and doesn't require additional documentation.</p>
|
||||||
};
|
|
||||||
|
|
||||||
template<class T>
|
<p>The program <a href="noncopyable_test.cpp">noncopyable_test.cpp</a> can be
|
||||||
T operator()(T x)
|
used to verify class <b>noncopyable</b> works as expected. It has have been run successfully under
|
||||||
{
|
GCC 2.95, Metrowerks
|
||||||
return x;
|
CodeWarrior 5.0, and Microsoft Visual C++ 6.0 sp 3.</p>
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef boost::result_of<
|
<p>Contributed by <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>.</p>
|
||||||
functor(int)
|
|
||||||
>::type type; // type is int</pre>
|
|
||||||
</blockquote>
|
|
||||||
|
|
||||||
<p>Since <code>decltype</code> is a new language
|
<h3>Example</h3>
|
||||||
feature recently standardized in C++11,
|
<blockquote>
|
||||||
if you are writing a function object
|
<pre>// inside one of your own headers ...
|
||||||
to be used with <code>result_of</code>, for
|
#include <boost/utility.hpp>
|
||||||
maximum portability, you might consider following
|
|
||||||
the above protocol even if your compiler has
|
|
||||||
proper <code>decltype</code> support. If you wish to continue to
|
|
||||||
use the protocol on compilers that
|
|
||||||
support <code>decltype</code>, there are two options:
|
|
||||||
You can use <code>boost::tr1_result_of</code>, which is also
|
|
||||||
defined in <code><<a href="../../boost/utility/result_of.hpp">boost/utility/result_of.hpp</a>></code>.
|
|
||||||
Alternatively, you can define the macro
|
|
||||||
<code>BOOST_RESULT_OF_USE_TR1</code>, which causes
|
|
||||||
<code>result_of</code> to use the protocol described
|
|
||||||
above instead of <code>decltype</code>. If you choose to
|
|
||||||
follow the protocol, take care to ensure that the
|
|
||||||
<code>result_type</code> and
|
|
||||||
<code>result<></code> members accurately
|
|
||||||
represent the return type of
|
|
||||||
<code>operator()</code> given a call expression.</p>
|
|
||||||
|
|
||||||
<p>Additionally, <code>boost::result_of</code>
|
class ResourceLadenFileSystem : noncopyable {
|
||||||
provides a third mode of operation, which some users
|
...</pre>
|
||||||
may find convenient. When
|
</blockquote>
|
||||||
<code>BOOST_RESULT_OF_USE_TR1_WITH_DECLTYPE_FALLBACK</code>
|
|
||||||
is defined, <code>boost::result_of</code> behaves as
|
|
||||||
follows. If the function object has a member
|
|
||||||
type <code>result_type</code> or member
|
|
||||||
template <code>result<></code>, then
|
|
||||||
<code>boost::result_of</code> will use the TR1
|
|
||||||
protocol. Otherwise,
|
|
||||||
<code>boost::result_of</code> will
|
|
||||||
use <code>decltype</code>. Using TR1 with
|
|
||||||
a <code>declytpe</code> fallback may workaround
|
|
||||||
certain problems at the cost of portability. For
|
|
||||||
example:
|
|
||||||
<ul>
|
|
||||||
<li>Deficient compiler: If your code
|
|
||||||
requires <code>boost::result_of</code> to work
|
|
||||||
with incomplete return types but your
|
|
||||||
compiler's <code>decltype</code> implementation
|
|
||||||
does not support incomplete return types, then you
|
|
||||||
can use the TR1 protocol as a workaround. Support
|
|
||||||
for incomplete return types was added late in the
|
|
||||||
C++11 standardization process
|
|
||||||
(see <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf">N3276</a>)
|
|
||||||
and is not implemented by some compilers.</li>
|
|
||||||
|
|
||||||
<li>Deficient legacy code: If your existing TR1
|
<h3>Rationale</h3>
|
||||||
function object advertises a different type than
|
<p>Class noncopyable has protected constructor and destructor members to
|
||||||
the actual result type deduced
|
emphasize that it is to be used only as a base class. Dave Abrahams notes
|
||||||
by <code>decltype</code>, then using TR1 with a
|
concern about the effect on compiler optimization of adding (even trivial inline)
|
||||||
<code>decltype</code> fallback will allow you to
|
destructor declarations. He says "Probably this concern is misplaced, because
|
||||||
work with both your existing TR1 function objects
|
noncopyable will be used mostly for classes which own resources and thus have non-trivial destruction semantics."</p>
|
||||||
and new C++11 function object. This situation
|
<hr>
|
||||||
could occur if your legacy function objects
|
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
|
||||||
misused the TR1 protocol. See the documentation on
|
-->26 January, 2000<!--webbot bot="Timestamp" endspan i-checksum="38194"
|
||||||
known <a href="#result_of_tr1_diff">differences</a>
|
|
||||||
between <code>boost::result_of</code> and TR1.</li>
|
|
||||||
</ul>
|
|
||||||
|
|
||||||
<a name="BOOST_NO_RESULT_OF"></a>
|
|
||||||
<p>This implementation of <code>result_of</code>
|
|
||||||
requires class template partial specialization, the
|
|
||||||
ability to parse function types properly, and support
|
|
||||||
for SFINAE. If <code>result_of</code> is not supported
|
|
||||||
by your compiler, including the header
|
|
||||||
<code>boost/utility/result_of.hpp</code> will
|
|
||||||
define the macro <code>BOOST_NO_RESULT_OF</code>.</p>
|
|
||||||
|
|
||||||
<p>For additional information
|
|
||||||
about <code>result_of</code>, see the C++ Library
|
|
||||||
Technical Report,
|
|
||||||
<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf">N1836</a>,
|
|
||||||
or, for motivation and design rationale,
|
|
||||||
the <code>result_of</code> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2003/n1454.html">proposal</a>.</p>
|
|
||||||
|
|
||||||
<a name="result_of_guidelines">
|
|
||||||
<h3>Usage guidelines for boost::result_of</h3>
|
|
||||||
</a>
|
|
||||||
|
|
||||||
<p>The following are general suggestions about when
|
|
||||||
and how to use <code>boost::result_of</code>.</p>
|
|
||||||
|
|
||||||
<ol>
|
|
||||||
<li> If you are targeting C++11 and are not concerned
|
|
||||||
about portability to non-compliant compilers or
|
|
||||||
previous versions of the standard, then use
|
|
||||||
<code>std::result_of</code>. If <code>std::result_of</code>
|
|
||||||
meets your needs, then there's no reason to stop using
|
|
||||||
it.</li>
|
|
||||||
|
|
||||||
<li> If you are targeting C++11 but may port your code
|
|
||||||
to legacy compilers at some time in the future, then
|
|
||||||
use <code>boost::result_of</code> with
|
|
||||||
<code>decltype</code>. When <code>decltype</code> is
|
|
||||||
used <code>boost::result_of</code>
|
|
||||||
and <code>std::result_of</code> are usually
|
|
||||||
interchangeable. See the documentation on
|
|
||||||
known <a href="#result_of_cxx11_diff">differences</a>
|
|
||||||
between boost::result_of and C++11 result_of.</li>
|
|
||||||
|
|
||||||
<li> If compiler portability is required,
|
|
||||||
use <code>boost::result_of</code> with the TR1 protocol.</li>
|
|
||||||
</ol>
|
|
||||||
|
|
||||||
<p>Regardless of how you
|
|
||||||
configure <code>boost::result_of</code>, it is
|
|
||||||
important to bear in mind that the return type of a
|
|
||||||
function may change depending on its arguments, and
|
|
||||||
additionally, the return type of a member function may
|
|
||||||
change depending on the cv-qualification of the
|
|
||||||
object. <code>boost::result_of</code> must be passed
|
|
||||||
the appropriately cv-qualified types in order to
|
|
||||||
deduce the corresponding return type. For example:
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>struct functor {
|
|
||||||
int& operator()(int);
|
|
||||||
int const& operator()(int) const;
|
|
||||||
|
|
||||||
float& operator()(float&);
|
|
||||||
float const& operator()(float const&);
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef boost::result_of<
|
|
||||||
functor(int)
|
|
||||||
>::type type1; // type1 is int &
|
|
||||||
|
|
||||||
typedef boost::result_of<
|
|
||||||
const functor(int)
|
|
||||||
>::type type2; // type2 is int const &
|
|
||||||
|
|
||||||
typedef boost::result_of<
|
|
||||||
functor(float&)
|
|
||||||
>::type type3; // type3 is float &
|
|
||||||
|
|
||||||
typedef boost::result_of<
|
|
||||||
functor(float const&)
|
|
||||||
>::type type4; // type4 is float const &</pre>
|
|
||||||
</blockquote>
|
|
||||||
|
|
||||||
<a name="result_of_tr1_protocol_guidelines">
|
|
||||||
<h3>Usage guidelines for the TR1 result_of protocol</h3>
|
|
||||||
</a>
|
|
||||||
|
|
||||||
<p>On compliant C++11
|
|
||||||
compilers, <code>boost::result_of</code> can
|
|
||||||
use <code>decltype</code> to deduce the type of any
|
|
||||||
call expression, including calls to function
|
|
||||||
objects. However, on pre-C++11 compilers or on
|
|
||||||
compilers without adequate decltype support,
|
|
||||||
additional scaffolding is needed from function
|
|
||||||
objects as described above. The following are
|
|
||||||
suggestions about how to use the TR1 protocol.</p>
|
|
||||||
|
|
||||||
<ul>
|
|
||||||
<li>When the return type does not depend on the
|
|
||||||
argument types or the cv-qualification of the
|
|
||||||
function object, simply
|
|
||||||
define <code>result_type</code>. There is no need
|
|
||||||
to use the <code>result</code> template unless the
|
|
||||||
return type varies.</li>
|
|
||||||
|
|
||||||
<li>Use the protocol specified type when defining
|
|
||||||
function prototypes. This can help ensure the
|
|
||||||
actual return type does not get out of sync with
|
|
||||||
the protocol specification. For example:
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>struct functor {
|
|
||||||
typedef int result_type;
|
|
||||||
result_type operator()(int);
|
|
||||||
};</pre>
|
|
||||||
</blockquote> </li>
|
|
||||||
|
|
||||||
<li>Always specify the <code>result</code>
|
|
||||||
specialization near the corresponding
|
|
||||||
<code>operator()</code> overload. This can make it
|
|
||||||
easier to keep the specializations in sync with the
|
|
||||||
overloads. For example:
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>struct functor {
|
|
||||||
template<class> struct result;
|
|
||||||
|
|
||||||
template<class F>
|
|
||||||
struct result<F(int)> {
|
|
||||||
typedef int& type;
|
|
||||||
};
|
|
||||||
result<functor(int)>::type operator()(int);
|
|
||||||
|
|
||||||
template<class F>
|
|
||||||
struct result<const F(int)> {
|
|
||||||
typedef int const& type;
|
|
||||||
};
|
|
||||||
result<const functor(int)>::type operator()(int) const;
|
|
||||||
};</pre>
|
|
||||||
</blockquote> </li>
|
|
||||||
|
|
||||||
<li>Use type transformations to simplify
|
|
||||||
the <code>result</code> template specialization. For
|
|
||||||
example, the following uses
|
|
||||||
<a href="../type_traits/doc/html/index.html">Boost.TypeTraits</a>
|
|
||||||
to specialize the <code>result</code> template for
|
|
||||||
a single <code>operator()</code> that can be called on
|
|
||||||
both a const and non-const function object with
|
|
||||||
either an lvalue or rvalue argument.
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>struct functor {
|
|
||||||
template<class> struct result;
|
|
||||||
|
|
||||||
template<class F, class T>
|
|
||||||
struct result<F(T)>
|
|
||||||
: boost::remove_cv<
|
|
||||||
typename boost::remove_reference<T>::type
|
|
||||||
>
|
|
||||||
{};
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
T operator()(T const& x) const;
|
|
||||||
};</pre>
|
|
||||||
</blockquote></li>
|
|
||||||
</ul>
|
|
||||||
|
|
||||||
<a name="result_of_tr1_diff">
|
|
||||||
<h3>Known differences between boost::result_of and TR1 result_of</h3>
|
|
||||||
</a>
|
|
||||||
|
|
||||||
When using <code>decltype</code>, <code>boost::result_of</code>
|
|
||||||
ignores the TR1 protocol and instead deduces the
|
|
||||||
return type of function objects directly
|
|
||||||
via <code>decltype</code>. In most situations, users
|
|
||||||
will not notice a difference, so long as they use the
|
|
||||||
protocol correctly. The following are situations in
|
|
||||||
which the type deduced
|
|
||||||
by <code>boost::result_of</code> is known to differ depending on
|
|
||||||
whether <code>decltype</code> or the TR1 protocol is
|
|
||||||
used.
|
|
||||||
|
|
||||||
<ul>
|
|
||||||
<li> TR1 protocol misusage
|
|
||||||
|
|
||||||
<p>When using the TR1
|
|
||||||
protocol, <code>boost::result_of</code> cannot
|
|
||||||
detect whether the actual type of a call to a
|
|
||||||
function object is the same as the type specified
|
|
||||||
by the protocol, which allows for the possibility
|
|
||||||
of inadvertent mismatches between the specified
|
|
||||||
type and the actual type. When
|
|
||||||
using <code>decltype</code>, these subtle bugs
|
|
||||||
may result in compilation errors. For example:</p>
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>struct functor {
|
|
||||||
typedef short result_type;
|
|
||||||
int operator()(short);
|
|
||||||
};
|
|
||||||
|
|
||||||
#ifdef BOOST_RESULT_OF_USE_DECLTYPE
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((
|
|
||||||
boost::is_same<boost::result_of<functor(short)>::type, int>::value
|
|
||||||
));
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((
|
|
||||||
boost::is_same<boost::result_of<functor(short)>::type, short>::value
|
|
||||||
));
|
|
||||||
|
|
||||||
#endif</pre>
|
|
||||||
</blockquote>
|
|
||||||
|
|
||||||
<p>Note that the user can
|
|
||||||
force <code>boost::result_of</code> to use the TR1
|
|
||||||
protocol even on platforms that
|
|
||||||
support <code>decltype</code> by
|
|
||||||
defining <code>BOOST_RESULT_OF_USE_TR1</code>.</p></li>
|
|
||||||
|
|
||||||
<li> Nullary function objects
|
|
||||||
|
|
||||||
<p>When using the TR1 protocol, <code>boost::result_of</code>
|
|
||||||
cannot always deduce the type of calls to
|
|
||||||
nullary function objects, in which case the
|
|
||||||
type defaults to void. When using <code>decltype</code>,
|
|
||||||
<code>boost::result_of</code> always gives the actual type of the
|
|
||||||
call expression. For example:</p>
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>struct functor {
|
|
||||||
template<class> struct result {
|
|
||||||
typedef int type;
|
|
||||||
};
|
|
||||||
int operator()();
|
|
||||||
};
|
|
||||||
|
|
||||||
#ifdef BOOST_RESULT_OF_USE_DECLTYPE
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((
|
|
||||||
boost::is_same<boost::result_of<functor()>::type, int>::value
|
|
||||||
));
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((
|
|
||||||
boost::is_same<boost::result_of<functor()>::type, void>::value
|
|
||||||
));
|
|
||||||
|
|
||||||
#endif</pre>
|
|
||||||
</blockquote>
|
|
||||||
|
|
||||||
<p>Note that there are some workarounds for the
|
|
||||||
nullary function problem. So long as the return
|
|
||||||
type does not vary,
|
|
||||||
<code>result_type</code> can always be used to
|
|
||||||
specify the return type regardless of arity. If the
|
|
||||||
return type does vary, then the user can
|
|
||||||
specialize <code>boost::result_of</code> itself for
|
|
||||||
nullary calls.</p></li>
|
|
||||||
|
|
||||||
<li> Non-class prvalues and cv-qualification
|
|
||||||
|
|
||||||
<p>When using the TR1
|
|
||||||
protocol, <code>boost::result_of</code> will
|
|
||||||
report the cv-qualified type specified
|
|
||||||
by <code>result_type</code> or
|
|
||||||
the <code>result</code> template regardless of
|
|
||||||
the actual cv-qualification of the call
|
|
||||||
expression. When using
|
|
||||||
<code>decltype</code>, <code>boost::result_of</code>
|
|
||||||
will report the actual type of the call expression,
|
|
||||||
which is not cv-qualified when the expression is a
|
|
||||||
non-class prvalue. For example:</p>
|
|
||||||
|
|
||||||
<blockquote>
|
|
||||||
<pre>struct functor {
|
|
||||||
template<class> struct result;
|
|
||||||
template<class F, class T> struct result<F(const T)> {
|
|
||||||
typedef const T type;
|
|
||||||
};
|
|
||||||
|
|
||||||
const short operator()(const short);
|
|
||||||
int const & operator()(int const &);
|
|
||||||
};
|
|
||||||
|
|
||||||
// Non-prvalue call expressions work the same with or without decltype.
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((
|
|
||||||
boost::is_same<
|
|
||||||
boost::result_of<functor(int const &)>::type,
|
|
||||||
int const &
|
|
||||||
::value
|
|
||||||
));
|
|
||||||
|
|
||||||
// Non-class prvalue call expressions are not actually cv-qualified,
|
|
||||||
// but only the decltype-based result_of reports this accurately.
|
|
||||||
|
|
||||||
#ifdef BOOST_RESULT_OF_USE_DECLTYPE
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((
|
|
||||||
boost::is_same<
|
|
||||||
boost::result_of<functor(const short)>::type,
|
|
||||||
short
|
|
||||||
::value
|
|
||||||
));
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
BOOST_STATIC_ASSERT((
|
|
||||||
boost::is_same<
|
|
||||||
boost::result_of<functor(const short)>::type,
|
|
||||||
const short
|
|
||||||
::value
|
|
||||||
));
|
|
||||||
|
|
||||||
#endif</pre>
|
|
||||||
</blockquote></li>
|
|
||||||
</ul>
|
|
||||||
|
|
||||||
<a name="result_of_cxx11_diff">
|
|
||||||
<h3>Known differences between boost::result_of and C++11 result_of</h3>
|
|
||||||
</a>
|
|
||||||
|
|
||||||
<p>When using <code>decltype</code>, <code>boost::result_of</code>
|
|
||||||
implements most of the C++11 result_of
|
|
||||||
specification. One known exception is that
|
|
||||||
<code>boost::result_of</code> does not implement the
|
|
||||||
requirements regarding pointers to member data.</p>
|
|
||||||
|
|
||||||
<p>Created by Doug Gregor. Contributions from Daniel Walker, Eric Niebler, Michel Morin and others</p>
|
|
||||||
|
|
||||||
<h2><a name="BOOST_BINARY">Macro BOOST_BINARY</a></h2>
|
|
||||||
|
|
||||||
<p>The macro <code>BOOST_BINARY</code> is used for the
|
|
||||||
representation of binary literals. It takes as an argument
|
|
||||||
a binary number arranged as an arbitrary amount of 1s and 0s in
|
|
||||||
groupings of length 1 to 8, with groups separated
|
|
||||||
by spaces. The type of the literal yielded is determined by
|
|
||||||
the same rules as those of hex and octal
|
|
||||||
literals (<i>2.13.1p1</i>). By implementation, this macro
|
|
||||||
expands directly to an octal literal during preprocessing, so
|
|
||||||
there is no overhead at runtime and the result is useable in
|
|
||||||
any place that an octal literal would be.</p>
|
|
||||||
|
|
||||||
<p>In order to directly support binary literals with suffixes,
|
|
||||||
additional macros of the form BOOST_BINARY_XXX are also
|
|
||||||
provided, where XXX is a standard integer suffix in all capital
|
|
||||||
letters. In addition, LL and ULL suffixes may be used for representing
|
|
||||||
long long and unsigned long long types in compilers which provide
|
|
||||||
them as an extension.</p>
|
|
||||||
|
|
||||||
|
|
||||||
<p>The BOOST_BINARY family of macros resides in the header
|
|
||||||
<a
|
|
||||||
href="../../boost/utility/binary.hpp"><boost/utility/binary.hpp></a>
|
|
||||||
which is automatically included by
|
|
||||||
<a
|
|
||||||
href="../../boost/utility.hpp"><boost/utility.hpp></a>.
|
|
||||||
|
|
||||||
<p>Contributed by Matt Calabrese.</p><p>
|
|
||||||
</p><h3>Example</h3>
|
|
||||||
<blockquote>
|
|
||||||
<pre>
|
|
||||||
void foo( int );
|
|
||||||
|
|
||||||
void foo( unsigned long );
|
|
||||||
|
|
||||||
void bar()
|
|
||||||
{
|
|
||||||
int value1 = BOOST_BINARY( 100 111000 01 1 110 );
|
|
||||||
|
|
||||||
unsigned long value2 = BOOST_BINARY_UL( 100 001 ); // unsigned long
|
|
||||||
|
|
||||||
long long value3 = BOOST_BINARY_LL( 11 000 ); // long long if supported
|
|
||||||
|
|
||||||
assert( BOOST_BINARY( 10010 )
|
|
||||||
& BOOST_BINARY( 11000 )
|
|
||||||
== BOOST_BINARY( 10000 )
|
|
||||||
);
|
|
||||||
|
|
||||||
foo( BOOST_BINARY( 1010 ) ); // calls the first foo
|
|
||||||
|
|
||||||
foo( BOOST_BINARY_LU( 1010 ) ); // calls the second foo
|
|
||||||
}
|
|
||||||
</pre></blockquote>
|
|
||||||
<hr>
|
|
||||||
<p>Revised <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan
|
|
||||||
-->04 September, 2008<!--webbot bot="Timestamp" endspan i-checksum="39369"
|
|
||||||
-->
|
-->
|
||||||
</p>
|
</p>
|
||||||
<p>© Copyright Beman Dawes 1999-2003.</p>
|
<p><EFBFBD> Copyright boost.org 1999. Permission to copy, use, modify, sell and
|
||||||
<p>Distributed under the Boost Software License, Version 1.0. See
|
distribute this document is granted provided this copyright notice appears in
|
||||||
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a></p>
|
all copies. This document is provided "as is" without express or
|
||||||
|
implied warranty, and with no claim as to its suitability for any purpose.</p>
|
||||||
</body>
|
</body>
|
||||||
</html>
|
</html>
|
||||||
|
|||||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user