mirror of
https://github.com/boostorg/utility.git
synced 2025-10-13 00:55:20 +02:00
Compare commits
1 Commits
svn-branch
...
svn-branch
| Author | SHA1 | Date | |
|---|---|---|---|
|
d2b51cc247 |
273
filter_iterator.htm
Normal file
273
filter_iterator.htm
Normal file
@@ -0,0 +1,273 @@
|
|||||||
|
<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>Filter Iterator Adaptor Documentation</title>
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<body bgcolor="#FFFFFF" text="#000000">
|
||||||
|
|
||||||
|
<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)"
|
||||||
|
align="center" width="277" height="86">
|
||||||
|
|
||||||
|
<h1>Filter Iterator Adaptor</h1>
|
||||||
|
|
||||||
|
Defined in header
|
||||||
|
<a href="../../boost/iterator_adaptors.hpp">boost/iterator_adaptors.hpp</a>
|
||||||
|
|
||||||
|
|
||||||
|
<p>
|
||||||
|
The filter iterator adaptor creates a view of an iterator range in
|
||||||
|
which some elements of the range are skipped over. A <a
|
||||||
|
href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>
|
||||||
|
function object controls which elements are skipped. When the
|
||||||
|
predicate is applied to an element, if it returns <tt>true</tt> then
|
||||||
|
the element is retained and if it returns <tt>false</tt> then the
|
||||||
|
element is skipped over.
|
||||||
|
|
||||||
|
|
||||||
|
<h2>Synopsis</h2>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
namespace boost {
|
||||||
|
template <class Predicate, class BaseIterator, ...>
|
||||||
|
class filter_iterator_generator;
|
||||||
|
|
||||||
|
template <class Predicate, class BaseIterator>
|
||||||
|
typename filter_iterator_generator<Predicate, BaseIterator>::type
|
||||||
|
make_filter_iterator(BaseIterator first, BaseIterator last, const Predicate& p = Predicate());
|
||||||
|
}
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<hr>
|
||||||
|
|
||||||
|
<h2><a name="filter_iterator_generator">The Filter Iterator Type
|
||||||
|
Generator</a></h2>
|
||||||
|
|
||||||
|
The class <tt>filter_iterator_generator</tt> is a helper class whose
|
||||||
|
purpose is to construct a filter iterator type. The template
|
||||||
|
parameters for this class are the <tt>Predicate</tt> function object
|
||||||
|
type and the <tt>BaseIterator</tt> type that is being wrapped. In
|
||||||
|
most cases the associated types for the wrapped iterator can be
|
||||||
|
deduced from <tt>std::iterator_traits</tt>, but in some situations the
|
||||||
|
user may want to override these types, so there are also template
|
||||||
|
parameters for each of the iterator's associated types.
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
template <class Predicate, class BaseIterator,
|
||||||
|
class Value, class Reference, class Pointer, class Category, class Distance>
|
||||||
|
class filter_iterator_generator
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef <tt><a href="./iterator_adaptors.htm#iterator_adaptor">iterator_adaptor</a><...></tt> type; // the resulting filter iterator type
|
||||||
|
}
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
|
||||||
|
<h3>Example</h3>
|
||||||
|
|
||||||
|
The following example uses filter iterator to print out all the
|
||||||
|
positive integers in an array.
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
struct is_positive_number {
|
||||||
|
bool operator()(int x) { return 0 < x; }
|
||||||
|
};
|
||||||
|
int main() {
|
||||||
|
int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
|
||||||
|
const int N = sizeof(numbers)/sizeof(int);
|
||||||
|
|
||||||
|
typedef boost::filter_iterator_generator<is_positive_number, int*, int>::type FilterIter;
|
||||||
|
is_positive_number predicate;
|
||||||
|
FilterIter::policies_type policies(predicate, numbers + N);
|
||||||
|
FilterIter filter_iter_first(numbers, policies);
|
||||||
|
FilterIter filter_iter_last(numbers + N, policies);
|
||||||
|
|
||||||
|
std::copy(filter_iter_first, filter_iter_last, std::ostream_iterator<int>(std::cout, " "));
|
||||||
|
std::cout << std::endl;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
</pre>
|
||||||
|
The output is:
|
||||||
|
<pre>
|
||||||
|
4 5 8
|
||||||
|
</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/Predicate.html"><tt>Predicate</tt></a></TD>
|
||||||
|
<TD>The function object that determines which elements are retained and which elements are skipped.
|
||||||
|
</TR>
|
||||||
|
|
||||||
|
<TR>
|
||||||
|
<TD><tt>BaseIterator</tt></TD>
|
||||||
|
<TD>The iterator type being wrapped. This type must at least be a model
|
||||||
|
of the <a href="http://www.sgi.com/tech/stl/InputIterator">InputIterator</a> concept.</TD>
|
||||||
|
</TR>
|
||||||
|
|
||||||
|
<TR>
|
||||||
|
<TD><tt>Value</tt></TD>
|
||||||
|
<TD>The <tt>value_type</tt> of the resulting iterator,
|
||||||
|
unless const. If const, a conforming compiler strips constness for the
|
||||||
|
<tt>value_type</tt>. Typically the default for this parameter is the
|
||||||
|
appropriate type<a href="#1">[1]</a>.<br> <b>Default:</b>
|
||||||
|
<tt>std::iterator_traits<BaseIterator>::value_type</TD>
|
||||||
|
</TR>
|
||||||
|
|
||||||
|
<TR>
|
||||||
|
<TD><tt>Reference</tt></TD>
|
||||||
|
<TD>The <tt>reference</tt> type of the resulting iterator, and in
|
||||||
|
particular, the result type of <tt>operator*()</tt>. Typically the default for
|
||||||
|
this parameter is the appropriate type.<br> <b>Default:</b> If
|
||||||
|
<tt>Value</tt> is supplied, <tt>Value&</tt> is used. Otherwise
|
||||||
|
<tt>std::iterator_traits<BaseIterator>::reference</tt> is
|
||||||
|
used.</TD>
|
||||||
|
</TR>
|
||||||
|
|
||||||
|
<TR>
|
||||||
|
<TD><tt>Pointer</tt></TD>
|
||||||
|
<TD>The <tt>pointer</tt> type of the resulting iterator, and in
|
||||||
|
particular, the result type of <tt>operator->()</tt>.
|
||||||
|
Typically the default for
|
||||||
|
this parameter is the appropriate type.<br>
|
||||||
|
<b>Default:</b> If <tt>Value</tt> was supplied, then <tt>Value*</tt>,
|
||||||
|
otherwise <tt>std::iterator_traits<BaseIterator>::pointer</tt>.</TD>
|
||||||
|
</TR>
|
||||||
|
|
||||||
|
|
||||||
|
<TR>
|
||||||
|
<TD><tt>Category</tt></TD>
|
||||||
|
<TD>The <tt>iterator_category</tt> type for the resulting iterator.
|
||||||
|
Typically the
|
||||||
|
default for this parameter is the appropriate type. If you override
|
||||||
|
this parameter, do not use <tt>bidirectional_iterator_tag</tt>
|
||||||
|
because filter iterators can not go in reverse.<br>
|
||||||
|
<b>Default:</b> <tt>std::iterator_traits<BaseIterator>::iterator_category</tt></TD>
|
||||||
|
</TR>
|
||||||
|
|
||||||
|
<TR>
|
||||||
|
<TD><tt>Distance</tt></TD>
|
||||||
|
<TD>The <tt>difference_type</tt> for the resulting iterator. Typically the default for
|
||||||
|
this parameter is the appropriate type.<br>
|
||||||
|
<b>Default:</b> <tt>std::iterator_traits<BaseIterator>::difference_type</TD>
|
||||||
|
</TR>
|
||||||
|
|
||||||
|
</table>
|
||||||
|
|
||||||
|
|
||||||
|
<h3>Model of</h3>
|
||||||
|
|
||||||
|
The filter iterator adaptor (the type
|
||||||
|
<tt>filter_iterator_generator<...>::type</tt>) may be a model of <a
|
||||||
|
href="www.sgi.com/tech/stl/InputIterator.html">InputIterator</a> or <a
|
||||||
|
href="www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>
|
||||||
|
depending on the adapted iterator type.
|
||||||
|
|
||||||
|
|
||||||
|
<h3>Members</h3>
|
||||||
|
|
||||||
|
The filter iterator type implements all of the member functions and
|
||||||
|
operators required of the <a
|
||||||
|
href="http://www.sgi.com/tech/stl/ForwardIterator.html">ForwardIterator</a>
|
||||||
|
concept. In addition it has the following constructor:
|
||||||
|
|
||||||
|
<pre>filter_iterator_generator::type(const BaseIterator& it, const Policies& p = Policies())</pre>
|
||||||
|
|
||||||
|
<p>
|
||||||
|
The policies type has only one public function, which is its constructor:
|
||||||
|
|
||||||
|
<pre>filter_iterator_generator::policies_type(const Predicate& p, const BaseIterator& end)</pre>
|
||||||
|
|
||||||
|
<p>
|
||||||
|
<hr>
|
||||||
|
<p>
|
||||||
|
|
||||||
|
<h2><a name="make_filter_iterator">The Make Filter Iterator Function</a></h2>
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
template <class Predicate, class BaseIterator>
|
||||||
|
typename detail::filter_generator<Predicate, BaseIterator>::type
|
||||||
|
make_filter_iterator(BaseIterator first, BaseIterator last, const Predicate& p = Predicate())
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
This function provides a convenient way to create filter iterators.
|
||||||
|
|
||||||
|
<h3>Example</h3>
|
||||||
|
|
||||||
|
In this example we print out all numbers in the array that are
|
||||||
|
greater than negative two.
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
|
||||||
|
const int N = sizeof(numbers)/sizeof(int);
|
||||||
|
|
||||||
|
std::copy(boost::make_filter_iterator(numbers, numbers + N,
|
||||||
|
std::bind2nd(std::greater<int>(), -2)),
|
||||||
|
boost::make_filter_iterator(numbers + N, numbers + N,
|
||||||
|
std::bind2nd(std::greater<int>(), -2)),
|
||||||
|
std::ostream_iterator<int>(std::cout, " "));
|
||||||
|
std::cout << std::endl;
|
||||||
|
|
||||||
|
}
|
||||||
|
</pre>
|
||||||
|
The output is:
|
||||||
|
<pre>
|
||||||
|
0 -1 4 5 8
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
<p>
|
||||||
|
In the next example we print the positive numbers using the
|
||||||
|
<tt>make_filter_iterator()</tt> function.
|
||||||
|
|
||||||
|
<pre>
|
||||||
|
struct is_positive_number {
|
||||||
|
bool operator()(int x) { return 0 < x; }
|
||||||
|
};
|
||||||
|
int main()
|
||||||
|
{
|
||||||
|
int numbers[] = { 0, -1, 4, -3, 5, 8, -2 };
|
||||||
|
const int N = sizeof(numbers)/sizeof(int);
|
||||||
|
|
||||||
|
std::copy(boost::make_filter_iterator<is_positive_number>(numbers, numbers + N),
|
||||||
|
boost::make_filter_iterator<is_positive_number>(numbers + N, numbers + N),
|
||||||
|
std::ostream_iterator<int>(std::cout, " "));
|
||||||
|
std::cout << std::endl;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
</pre>
|
||||||
|
The output is:
|
||||||
|
<pre>
|
||||||
|
4 5 8
|
||||||
|
</pre>
|
||||||
|
|
||||||
|
|
||||||
|
<h3>Notes</h3>
|
||||||
|
|
||||||
|
<a name="1">[1]</a> If the compiler does not support partial
|
||||||
|
specialization and the wrapped iterator type is a builtin pointer then
|
||||||
|
the <tt>Value</tt> type must be explicitly specified (don't use the
|
||||||
|
default).
|
||||||
|
|
||||||
|
|
||||||
|
<hr>
|
||||||
|
<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->18 Feb 2001<!--webbot bot="Timestamp" endspan i-checksum="14389" --></p>
|
||||||
|
<p><EFBFBD> Copyright Jeremy Siek 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>
|
||||||
|
|
||||||
|
</body>
|
||||||
|
|
||||||
|
</html>
|
||||||
@@ -1,38 +0,0 @@
|
|||||||
//
|
|
||||||
// boost/assert.hpp - BOOST_ASSERT(expr)
|
|
||||||
//
|
|
||||||
// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
|
|
||||||
//
|
|
||||||
// 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.
|
|
||||||
//
|
|
||||||
// Note: There are no include guards. This is intentional.
|
|
||||||
//
|
|
||||||
// See http://www.boost.org/libs/utility/assert.html for documentation.
|
|
||||||
//
|
|
||||||
|
|
||||||
#undef BOOST_ASSERT
|
|
||||||
|
|
||||||
#if defined(BOOST_DISABLE_ASSERTS)
|
|
||||||
|
|
||||||
# define BOOST_ASSERT(expr) ((void)0)
|
|
||||||
|
|
||||||
#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
|
|
||||||
|
|
||||||
#include <boost/current_function.hpp>
|
|
||||||
|
|
||||||
namespace boost
|
|
||||||
{
|
|
||||||
|
|
||||||
void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
|
|
||||||
|
|
||||||
#else
|
|
||||||
# include <assert.h>
|
|
||||||
# define BOOST_ASSERT(expr) assert(expr)
|
|
||||||
#endif
|
|
||||||
@@ -1,23 +0,0 @@
|
|||||||
// (C) Copyright Boost.org 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/libs/utility/call_traits.htm for Documentation.
|
|
||||||
// See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp
|
|
||||||
// for full copyright notices.
|
|
||||||
|
|
||||||
#ifndef BOOST_CALL_TRAITS_HPP
|
|
||||||
#define BOOST_CALL_TRAITS_HPP
|
|
||||||
|
|
||||||
#ifndef BOOST_CONFIG_HPP
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
||||||
#include <boost/detail/ob_call_traits.hpp>
|
|
||||||
#else
|
|
||||||
#include <boost/detail/call_traits.hpp>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif // BOOST_CALL_TRAITS_HPP
|
|
||||||
@@ -1,63 +0,0 @@
|
|||||||
#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
|
|
||||||
#define BOOST_CHECKED_DELETE_HPP_INCLUDED
|
|
||||||
|
|
||||||
#if _MSC_VER >= 1020
|
|
||||||
#pragma once
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//
|
|
||||||
// boost/checked_delete.hpp
|
|
||||||
//
|
|
||||||
// Copyright (c) 1999, 2000, 2001, 2002 boost.org
|
|
||||||
// Copyright (c) 2002, 2003 Peter Dimov
|
|
||||||
//
|
|
||||||
// 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/libs/utility/checked_delete.html for documentation.
|
|
||||||
//
|
|
||||||
|
|
||||||
namespace boost
|
|
||||||
{
|
|
||||||
|
|
||||||
// verify that types are complete for increased safety
|
|
||||||
|
|
||||||
template<class T> inline void checked_delete(T * x)
|
|
||||||
{
|
|
||||||
typedef char type_must_be_complete[sizeof(T)];
|
|
||||||
delete x;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T> inline void checked_array_delete(T * x)
|
|
||||||
{
|
|
||||||
typedef char type_must_be_complete[sizeof(T)];
|
|
||||||
delete [] x;
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T> struct checked_deleter
|
|
||||||
{
|
|
||||||
typedef void result_type;
|
|
||||||
typedef T * argument_type;
|
|
||||||
|
|
||||||
void operator()(T * x) const
|
|
||||||
{
|
|
||||||
boost::checked_delete(x);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class T> struct checked_array_deleter
|
|
||||||
{
|
|
||||||
typedef void result_type;
|
|
||||||
typedef T * argument_type;
|
|
||||||
|
|
||||||
void operator()(T * x) const
|
|
||||||
{
|
|
||||||
boost::checked_array_delete(x);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#endif // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED
|
|
||||||
@@ -1,23 +0,0 @@
|
|||||||
// (C) Copyright Boost.org 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.
|
|
||||||
// See boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp
|
|
||||||
// for full copyright notices.
|
|
||||||
|
|
||||||
#ifndef BOOST_COMPRESSED_PAIR_HPP
|
|
||||||
#define BOOST_COMPRESSED_PAIR_HPP
|
|
||||||
|
|
||||||
#ifndef BOOST_CONFIG_HPP
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
||||||
#include <boost/detail/ob_compressed_pair.hpp>
|
|
||||||
#else
|
|
||||||
#include <boost/detail/compressed_pair.hpp>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif // BOOST_COMPRESSED_PAIR_HPP
|
|
||||||
@@ -1,62 +0,0 @@
|
|||||||
#ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
|
|
||||||
#define BOOST_CURRENT_FUNCTION_HPP_INCLUDED
|
|
||||||
|
|
||||||
#if _MSC_VER >= 1020
|
|
||||||
#pragma once
|
|
||||||
#endif
|
|
||||||
|
|
||||||
//
|
|
||||||
// boost/current_function.hpp - BOOST_CURRENT_FUNCTION
|
|
||||||
//
|
|
||||||
// Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
|
|
||||||
//
|
|
||||||
// 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.
|
|
||||||
//
|
|
||||||
// http://www.boost.org/libs/utility/current_function.html
|
|
||||||
//
|
|
||||||
|
|
||||||
namespace boost
|
|
||||||
{
|
|
||||||
|
|
||||||
namespace detail
|
|
||||||
{
|
|
||||||
|
|
||||||
inline void current_function_helper()
|
|
||||||
{
|
|
||||||
|
|
||||||
#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600))
|
|
||||||
|
|
||||||
# define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
|
|
||||||
|
|
||||||
#elif defined(__FUNCSIG__)
|
|
||||||
|
|
||||||
# define BOOST_CURRENT_FUNCTION __FUNCSIG__
|
|
||||||
|
|
||||||
#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500))
|
|
||||||
|
|
||||||
# define BOOST_CURRENT_FUNCTION __FUNCTION__
|
|
||||||
|
|
||||||
#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
|
|
||||||
|
|
||||||
# define BOOST_CURRENT_FUNCTION __FUNC__
|
|
||||||
|
|
||||||
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
|
|
||||||
|
|
||||||
# define BOOST_CURRENT_FUNCTION __func__
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
# define BOOST_CURRENT_FUNCTION "(unknown)"
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace detail
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED
|
|
||||||
@@ -1,75 +0,0 @@
|
|||||||
// (C) Copyright Jens Maurer 2001. 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.
|
|
||||||
//
|
|
||||||
// Revision History:
|
|
||||||
|
|
||||||
// 15 Nov 2001 Jens Maurer
|
|
||||||
// created.
|
|
||||||
|
|
||||||
// See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation.
|
|
||||||
|
|
||||||
#ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
|
|
||||||
#define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
|
|
||||||
|
|
||||||
#include <boost/iterator_adaptors.hpp>
|
|
||||||
#include <boost/ref.hpp>
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
template<class Generator>
|
|
||||||
class generator_iterator_policies
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
generator_iterator_policies() { }
|
|
||||||
|
|
||||||
template<class Base>
|
|
||||||
void initialize(Base& base) {
|
|
||||||
m_value = (*base)();
|
|
||||||
}
|
|
||||||
|
|
||||||
// The Iter template argument is necessary for compatibility with a MWCW
|
|
||||||
// bug workaround
|
|
||||||
template <class IteratorAdaptor>
|
|
||||||
void increment(IteratorAdaptor& iter) {
|
|
||||||
m_value = (*iter.base())();
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class IteratorAdaptor>
|
|
||||||
const typename Generator::result_type&
|
|
||||||
dereference(const IteratorAdaptor&) const
|
|
||||||
{ return m_value; }
|
|
||||||
|
|
||||||
template <class IteratorAdaptor1, class IteratorAdaptor2>
|
|
||||||
bool equal(const IteratorAdaptor1& x, const IteratorAdaptor2& y) const
|
|
||||||
{ return x.base() == y.base() &&
|
|
||||||
x.policies().m_value == y.policies().m_value; }
|
|
||||||
|
|
||||||
private:
|
|
||||||
typename Generator::result_type m_value;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class Generator>
|
|
||||||
struct generator_iterator_generator
|
|
||||||
{
|
|
||||||
typedef iterator_adaptor<Generator*, generator_iterator_policies<Generator>,
|
|
||||||
typename Generator::result_type, const typename Generator::result_type&,
|
|
||||||
const typename Generator::result_type*, std::input_iterator_tag,
|
|
||||||
long> type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class Generator>
|
|
||||||
inline typename generator_iterator_generator<Generator>::type
|
|
||||||
make_generator_iterator(Generator & gen)
|
|
||||||
{
|
|
||||||
typedef typename generator_iterator_generator<Generator>::type result_t;
|
|
||||||
return result_t(&gen);
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
|
|
||||||
#endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP
|
|
||||||
|
|
||||||
@@ -1,33 +0,0 @@
|
|||||||
// Boost next_prior.hpp header file ---------------------------------------//
|
|
||||||
|
|
||||||
// (C) Copyright Boost.org 1999-2003. 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/libs/utility for documentation.
|
|
||||||
|
|
||||||
#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
|
|
||||||
#define BOOST_NEXT_PRIOR_HPP_INCLUDED
|
|
||||||
|
|
||||||
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);
|
|
||||||
|
|
||||||
// Contributed by Dave Abrahams
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
inline T next(T x) { return ++x; }
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
inline T prior(T x) { return --x; }
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#endif // BOOST_NEXT_PRIOR_HPP_INCLUDED
|
|
||||||
@@ -1,33 +0,0 @@
|
|||||||
// Boost noncopyable.hpp header file --------------------------------------//
|
|
||||||
|
|
||||||
// (C) Copyright Boost.org 1999-2003. 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/libs/utility for documentation.
|
|
||||||
|
|
||||||
#ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
|
|
||||||
#define BOOST_NONCOPYABLE_HPP_INCLUDED
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
// 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& );
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#endif // BOOST_NONCOPYABLE_HPP_INCLUDED
|
|
||||||
@@ -1,957 +0,0 @@
|
|||||||
// Boost operators.hpp header file ----------------------------------------//
|
|
||||||
|
|
||||||
// (C) Copyright David Abrahams, Jeremy Siek, and Daryle Walker 1999-2001.
|
|
||||||
// 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/libs/utility/operators.htm for documentation.
|
|
||||||
|
|
||||||
// Revision History
|
|
||||||
// 04 May 05 Added operator class bool_testable. (Sam Partington)
|
|
||||||
// 21 Oct 02 Modified implementation of operators to allow compilers with a
|
|
||||||
// correct named return value optimization (NRVO) to produce optimal
|
|
||||||
// code. (Daniel Frey)
|
|
||||||
// 02 Dec 01 Bug fixed in random_access_iteratable. (Helmut Zeisel)
|
|
||||||
// 28 Sep 01 Factored out iterator operator groups. (Daryle Walker)
|
|
||||||
// 27 Aug 01 'left' form for non commutative operators added;
|
|
||||||
// additional classes for groups of related operators added;
|
|
||||||
// workaround for empty base class optimization
|
|
||||||
// bug of GCC 3.0 (Helmut Zeisel)
|
|
||||||
// 25 Jun 01 output_iterator_helper changes: removed default template
|
|
||||||
// parameters, added support for self-proxying, additional
|
|
||||||
// documentation and tests (Aleksey Gurtovoy)
|
|
||||||
// 29 May 01 Added operator classes for << and >>. Added input and output
|
|
||||||
// iterator helper classes. Added classes to connect equality and
|
|
||||||
// relational operators. Added classes for groups of related
|
|
||||||
// operators. Reimplemented example operator and iterator helper
|
|
||||||
// classes in terms of the new groups. (Daryle Walker, with help
|
|
||||||
// from Alexy Gurtovoy)
|
|
||||||
// 11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
|
|
||||||
// supplied arguments from actually being used (Dave Abrahams)
|
|
||||||
// 04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
|
|
||||||
// refactoring of compiler workarounds, additional documentation
|
|
||||||
// (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
|
|
||||||
// Dave Abrahams)
|
|
||||||
// 28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
|
|
||||||
// Jeremy Siek (Dave Abrahams)
|
|
||||||
// 20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
|
|
||||||
// (Mark Rodgers)
|
|
||||||
// 20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
|
|
||||||
// 10 Jun 00 Support for the base class chaining technique was added
|
|
||||||
// (Aleksey Gurtovoy). See documentation and the comments below
|
|
||||||
// for the details.
|
|
||||||
// 12 Dec 99 Initial version with iterator operators (Jeremy Siek)
|
|
||||||
// 18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
|
|
||||||
// specializations of dividable, subtractable, modable (Ed Brey)
|
|
||||||
// 17 Nov 99 Add comments (Beman Dawes)
|
|
||||||
// Remove unnecessary specialization of operators<> (Ed Brey)
|
|
||||||
// 15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
|
|
||||||
// operators.(Beman Dawes)
|
|
||||||
// 12 Nov 99 Add operators templates (Ed Brey)
|
|
||||||
// 11 Nov 99 Add single template parameter version for compilers without
|
|
||||||
// partial specialization (Beman Dawes)
|
|
||||||
// 10 Nov 99 Initial version
|
|
||||||
|
|
||||||
// 10 Jun 00:
|
|
||||||
// An additional optional template parameter was added to most of
|
|
||||||
// operator templates to support the base class chaining technique (see
|
|
||||||
// documentation for the details). Unfortunately, a straightforward
|
|
||||||
// implementation of this change would have broken compatibility with the
|
|
||||||
// previous version of the library by making it impossible to use the same
|
|
||||||
// template name (e.g. 'addable') for both the 1- and 2-argument versions of
|
|
||||||
// an operator template. This implementation solves the backward-compatibility
|
|
||||||
// issue at the cost of some simplicity.
|
|
||||||
//
|
|
||||||
// One of the complications is an existence of special auxiliary class template
|
|
||||||
// 'is_chained_base<>' (see 'detail' namespace below), which is used
|
|
||||||
// to determine whether its template parameter is a library's operator template
|
|
||||||
// or not. You have to specialize 'is_chained_base<>' for each new
|
|
||||||
// operator template you add to the library.
|
|
||||||
//
|
|
||||||
// However, most of the non-trivial implementation details are hidden behind
|
|
||||||
// several local macros defined below, and as soon as you understand them,
|
|
||||||
// you understand the whole library implementation.
|
|
||||||
|
|
||||||
#ifndef BOOST_OPERATORS_HPP
|
|
||||||
#define BOOST_OPERATORS_HPP
|
|
||||||
|
|
||||||
#include <boost/config.hpp>
|
|
||||||
#include <boost/iterator.hpp>
|
|
||||||
#include <boost/preprocessor/seq/cat.hpp>
|
|
||||||
|
|
||||||
#if defined(__sgi) && !defined(__GNUC__)
|
|
||||||
# pragma set woff 1234
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(BOOST_MSVC)
|
|
||||||
# pragma warning( disable : 4284 ) // complaint about return type of
|
|
||||||
#endif // operator-> not begin a UDT
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
namespace detail {
|
|
||||||
|
|
||||||
// Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
|
|
||||||
#if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
|
|
||||||
class empty_base {
|
|
||||||
bool dummy;
|
|
||||||
};
|
|
||||||
#else
|
|
||||||
class empty_base {};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
} // namespace detail
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
// In this section we supply the xxxx1 and xxxx2 forms of the operator
|
|
||||||
// templates, which are explicitly targeted at the 1-type-argument and
|
|
||||||
// 2-type-argument operator forms, respectively. Some compilers get confused
|
|
||||||
// when inline friend functions are overloaded in namespaces other than the
|
|
||||||
// global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of
|
|
||||||
// these templates must go in the global namespace.
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
|
|
||||||
namespace boost
|
|
||||||
{
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// Basic operator classes (contributed by Dave Abrahams) ------------------//
|
|
||||||
|
|
||||||
// Note that friend functions defined in a class are implicitly inline.
|
|
||||||
// See the C++ std, 11.4 [class.friend] paragraph 5
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct less_than_comparable2 : B
|
|
||||||
{
|
|
||||||
friend bool operator<=(const T& x, const U& y) { return !(x > y); }
|
|
||||||
friend bool operator>=(const T& x, const U& y) { return !(x < y); }
|
|
||||||
friend bool operator>(const U& x, const T& y) { return y < x; }
|
|
||||||
friend bool operator<(const U& x, const T& y) { return y > x; }
|
|
||||||
friend bool operator<=(const U& x, const T& y) { return !(y < x); }
|
|
||||||
friend bool operator>=(const U& x, const T& y) { return !(y > x); }
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct less_than_comparable1 : B
|
|
||||||
{
|
|
||||||
friend bool operator>(const T& x, const T& y) { return y < x; }
|
|
||||||
friend bool operator<=(const T& x, const T& y) { return !(y < x); }
|
|
||||||
friend bool operator>=(const T& x, const T& y) { return !(x < y); }
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct equality_comparable2 : B
|
|
||||||
{
|
|
||||||
friend bool operator==(const U& y, const T& x) { return x == y; }
|
|
||||||
friend bool operator!=(const U& y, const T& x) { return !(x == y); }
|
|
||||||
friend bool operator!=(const T& y, const U& x) { return !(y == x); }
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct equality_comparable1 : B
|
|
||||||
{
|
|
||||||
friend bool operator!=(const T& x, const T& y) { return !(x == y); }
|
|
||||||
};
|
|
||||||
|
|
||||||
// A macro which produces "name_2left" from "name".
|
|
||||||
#define BOOST_OPERATOR2_LEFT(name) BOOST_PP_SEQ_CAT_S(1,(name)(2)(_)(left))
|
|
||||||
|
|
||||||
// NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
|
|
||||||
|
|
||||||
#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
|
|
||||||
|
|
||||||
// This is the optimal implementation for ISO/ANSI C++,
|
|
||||||
// but it requires the compiler to implement the NRVO.
|
|
||||||
// If the compiler has no NRVO, this is the best symmetric
|
|
||||||
// implementation available.
|
|
||||||
|
|
||||||
#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##2 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( const T& lhs, const U& rhs ) \
|
|
||||||
{ T nrv( lhs ); nrv OP##= rhs; return nrv; } \
|
|
||||||
friend T operator OP( const U& lhs, const T& rhs ) \
|
|
||||||
{ T nrv( rhs ); nrv OP##= lhs; return nrv; } \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
template <class T, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##1 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( const T& lhs, const T& rhs ) \
|
|
||||||
{ T nrv( lhs ); nrv OP##= rhs; return nrv; } \
|
|
||||||
};
|
|
||||||
|
|
||||||
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##2 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( const T& lhs, const U& rhs ) \
|
|
||||||
{ T nrv( lhs ); nrv OP##= rhs; return nrv; } \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct BOOST_OPERATOR2_LEFT(NAME) : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( const U& lhs, const T& rhs ) \
|
|
||||||
{ T nrv( lhs ); nrv OP##= rhs; return nrv; } \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
template <class T, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##1 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( const T& lhs, const T& rhs ) \
|
|
||||||
{ T nrv( lhs ); nrv OP##= rhs; return nrv; } \
|
|
||||||
};
|
|
||||||
|
|
||||||
#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
|
|
||||||
|
|
||||||
// For compilers without NRVO the following code is optimal, but not
|
|
||||||
// symmetric! Note that the implementation of
|
|
||||||
// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
|
|
||||||
// optimization opportunities to the compiler :)
|
|
||||||
|
|
||||||
#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##2 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
|
|
||||||
friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
template <class T, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##1 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
|
|
||||||
};
|
|
||||||
|
|
||||||
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##2 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct BOOST_OPERATOR2_LEFT(NAME) : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( const U& lhs, const T& rhs ) \
|
|
||||||
{ return T( lhs ) OP##= rhs; } \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
template <class T, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##1 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
|
|
||||||
|
|
||||||
BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
|
|
||||||
BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
|
|
||||||
BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
|
|
||||||
BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
|
|
||||||
BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
|
|
||||||
BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
|
|
||||||
BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
|
|
||||||
BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
|
|
||||||
|
|
||||||
#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
|
|
||||||
#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
|
|
||||||
#undef BOOST_OPERATOR2_LEFT
|
|
||||||
|
|
||||||
// incrementable and decrementable contributed by Jeremy Siek
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct incrementable : B
|
|
||||||
{
|
|
||||||
friend T operator++(T& x, int)
|
|
||||||
{
|
|
||||||
incrementable_type nrv(x);
|
|
||||||
++x;
|
|
||||||
return nrv;
|
|
||||||
}
|
|
||||||
private: // The use of this typedef works around a Borland bug
|
|
||||||
typedef T incrementable_type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct decrementable : B
|
|
||||||
{
|
|
||||||
friend T operator--(T& x, int)
|
|
||||||
{
|
|
||||||
decrementable_type nrv(x);
|
|
||||||
--x;
|
|
||||||
return nrv;
|
|
||||||
}
|
|
||||||
private: // The use of this typedef works around a Borland bug
|
|
||||||
typedef T decrementable_type;
|
|
||||||
};
|
|
||||||
|
|
||||||
// Iterator operator classes (contributed by Jeremy Siek) ------------------//
|
|
||||||
|
|
||||||
template <class T, class P, class B = ::boost::detail::empty_base>
|
|
||||||
struct dereferenceable : B
|
|
||||||
{
|
|
||||||
P operator->() const
|
|
||||||
{
|
|
||||||
return &*static_cast<const T&>(*this);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, class I, class R, class B = ::boost::detail::empty_base>
|
|
||||||
struct indexable : B
|
|
||||||
{
|
|
||||||
R operator[](I n) const
|
|
||||||
{
|
|
||||||
return *(static_cast<const T&>(*this) + n);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// bool_testable -----------------------------------------------------------//
|
|
||||||
// (contributed by Sam Partington, David Abrahams and Daniel Frey) ---------//
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct bool_testable : B
|
|
||||||
{
|
|
||||||
friend bool operator!(const T& t) { return !static_cast<bool>(t); }
|
|
||||||
private:
|
|
||||||
typedef signed char private_number_type;
|
|
||||||
operator private_number_type() const;
|
|
||||||
};
|
|
||||||
|
|
||||||
// More operator classes (contributed by Daryle Walker) --------------------//
|
|
||||||
// (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
|
|
||||||
|
|
||||||
#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
|
|
||||||
|
|
||||||
#define BOOST_BINARY_OPERATOR( NAME, OP ) \
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##2 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( const T& lhs, const U& rhs ) \
|
|
||||||
{ T nrv( lhs ); nrv OP##= rhs; return nrv; } \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
template <class T, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##1 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( const T& lhs, const T& rhs ) \
|
|
||||||
{ T nrv( lhs ); nrv OP##= rhs; return nrv; } \
|
|
||||||
};
|
|
||||||
|
|
||||||
#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
|
|
||||||
|
|
||||||
#define BOOST_BINARY_OPERATOR( NAME, OP ) \
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##2 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
template <class T, class B = ::boost::detail::empty_base> \
|
|
||||||
struct NAME##1 : B \
|
|
||||||
{ \
|
|
||||||
friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
|
|
||||||
|
|
||||||
BOOST_BINARY_OPERATOR( left_shiftable, << )
|
|
||||||
BOOST_BINARY_OPERATOR( right_shiftable, >> )
|
|
||||||
|
|
||||||
#undef BOOST_BINARY_OPERATOR
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct equivalent2 : B
|
|
||||||
{
|
|
||||||
friend bool operator==(const T& x, const U& y)
|
|
||||||
{
|
|
||||||
return !(x < y) && !(x > y);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct equivalent1 : B
|
|
||||||
{
|
|
||||||
friend bool operator==(const T&x, const T&y)
|
|
||||||
{
|
|
||||||
return !(x < y) && !(y < x);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct partially_ordered2 : B
|
|
||||||
{
|
|
||||||
friend bool operator<=(const T& x, const U& y)
|
|
||||||
{ return (x < y) || (x == y); }
|
|
||||||
friend bool operator>=(const T& x, const U& y)
|
|
||||||
{ return (x > y) || (x == y); }
|
|
||||||
friend bool operator>(const U& x, const T& y)
|
|
||||||
{ return y < x; }
|
|
||||||
friend bool operator<(const U& x, const T& y)
|
|
||||||
{ return y > x; }
|
|
||||||
friend bool operator<=(const U& x, const T& y)
|
|
||||||
{ return (y > x) || (y == x); }
|
|
||||||
friend bool operator>=(const U& x, const T& y)
|
|
||||||
{ return (y < x) || (y == x); }
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct partially_ordered1 : B
|
|
||||||
{
|
|
||||||
friend bool operator>(const T& x, const T& y)
|
|
||||||
{ return y < x; }
|
|
||||||
friend bool operator<=(const T& x, const T& y)
|
|
||||||
{ return (x < y) || (x == y); }
|
|
||||||
friend bool operator>=(const T& x, const T& y)
|
|
||||||
{ return (y < x) || (x == y); }
|
|
||||||
};
|
|
||||||
|
|
||||||
// Combined operator classes (contributed by Daryle Walker) ----------------//
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct totally_ordered2
|
|
||||||
: less_than_comparable2<T, U
|
|
||||||
, equality_comparable2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct totally_ordered1
|
|
||||||
: less_than_comparable1<T
|
|
||||||
, equality_comparable1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct additive2
|
|
||||||
: addable2<T, U
|
|
||||||
, subtractable2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct additive1
|
|
||||||
: addable1<T
|
|
||||||
, subtractable1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct multiplicative2
|
|
||||||
: multipliable2<T, U
|
|
||||||
, dividable2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct multiplicative1
|
|
||||||
: multipliable1<T
|
|
||||||
, dividable1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct integer_multiplicative2
|
|
||||||
: multiplicative2<T, U
|
|
||||||
, modable2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct integer_multiplicative1
|
|
||||||
: multiplicative1<T
|
|
||||||
, modable1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct arithmetic2
|
|
||||||
: additive2<T, U
|
|
||||||
, multiplicative2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct arithmetic1
|
|
||||||
: additive1<T
|
|
||||||
, multiplicative1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct integer_arithmetic2
|
|
||||||
: additive2<T, U
|
|
||||||
, integer_multiplicative2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct integer_arithmetic1
|
|
||||||
: additive1<T
|
|
||||||
, integer_multiplicative1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct bitwise2
|
|
||||||
: xorable2<T, U
|
|
||||||
, andable2<T, U
|
|
||||||
, orable2<T, U, B
|
|
||||||
> > > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct bitwise1
|
|
||||||
: xorable1<T
|
|
||||||
, andable1<T
|
|
||||||
, orable1<T, B
|
|
||||||
> > > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct unit_steppable
|
|
||||||
: incrementable<T
|
|
||||||
, decrementable<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct shiftable2
|
|
||||||
: left_shiftable2<T, U
|
|
||||||
, right_shiftable2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct shiftable1
|
|
||||||
: left_shiftable1<T
|
|
||||||
, right_shiftable1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct ring_operators2
|
|
||||||
: additive2<T, U
|
|
||||||
, subtractable2_left<T, U
|
|
||||||
, multipliable2<T, U, B
|
|
||||||
> > > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct ring_operators1
|
|
||||||
: additive1<T
|
|
||||||
, multipliable1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct ordered_ring_operators2
|
|
||||||
: ring_operators2<T, U
|
|
||||||
, totally_ordered2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct ordered_ring_operators1
|
|
||||||
: ring_operators1<T
|
|
||||||
, totally_ordered1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct field_operators2
|
|
||||||
: ring_operators2<T, U
|
|
||||||
, dividable2<T, U
|
|
||||||
, dividable2_left<T, U, B
|
|
||||||
> > > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct field_operators1
|
|
||||||
: ring_operators1<T
|
|
||||||
, dividable1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct ordered_field_operators2
|
|
||||||
: field_operators2<T, U
|
|
||||||
, totally_ordered2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct ordered_field_operators1
|
|
||||||
: field_operators1<T
|
|
||||||
, totally_ordered1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct euclidian_ring_operators2
|
|
||||||
: ring_operators2<T, U
|
|
||||||
, dividable2<T, U
|
|
||||||
, dividable2_left<T, U
|
|
||||||
, modable2<T, U
|
|
||||||
, modable2_left<T, U, B
|
|
||||||
> > > > > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct euclidian_ring_operators1
|
|
||||||
: ring_operators1<T
|
|
||||||
, dividable1<T
|
|
||||||
, modable1<T, B
|
|
||||||
> > > {};
|
|
||||||
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base>
|
|
||||||
struct ordered_euclidian_ring_operators2
|
|
||||||
: totally_ordered2<T, U
|
|
||||||
, euclidian_ring_operators2<T, U, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct ordered_euclidian_ring_operators1
|
|
||||||
: totally_ordered1<T
|
|
||||||
, euclidian_ring_operators1<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T, class P, class B = ::boost::detail::empty_base>
|
|
||||||
struct input_iteratable
|
|
||||||
: equality_comparable1<T
|
|
||||||
, incrementable<T
|
|
||||||
, dereferenceable<T, P, B
|
|
||||||
> > > {};
|
|
||||||
|
|
||||||
template <class T, class B = ::boost::detail::empty_base>
|
|
||||||
struct output_iteratable
|
|
||||||
: incrementable<T, B
|
|
||||||
> {};
|
|
||||||
|
|
||||||
template <class T, class P, class B = ::boost::detail::empty_base>
|
|
||||||
struct forward_iteratable
|
|
||||||
: input_iteratable<T, P, B
|
|
||||||
> {};
|
|
||||||
|
|
||||||
template <class T, class P, class B = ::boost::detail::empty_base>
|
|
||||||
struct bidirectional_iteratable
|
|
||||||
: forward_iteratable<T, P
|
|
||||||
, decrementable<T, B
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
// To avoid repeated derivation from equality_comparable,
|
|
||||||
// which is an indirect base class of bidirectional_iterable,
|
|
||||||
// random_access_iteratable must not be derived from totally_ordered1
|
|
||||||
// but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
|
|
||||||
template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
|
|
||||||
struct random_access_iteratable
|
|
||||||
: bidirectional_iteratable<T, P
|
|
||||||
, less_than_comparable1<T
|
|
||||||
, additive2<T, D
|
|
||||||
, indexable<T, D, R, B
|
|
||||||
> > > > {};
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
|
|
||||||
} // namespace boost
|
|
||||||
#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
|
|
||||||
|
|
||||||
|
|
||||||
// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 -
|
|
||||||
//
|
|
||||||
// When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
|
|
||||||
// operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
|
|
||||||
// for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for
|
|
||||||
// two-argument forms. Note that these macros expect to be invoked from within
|
|
||||||
// boost.
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
|
|
||||||
|
|
||||||
// The template is already in boost so we have nothing to do.
|
|
||||||
# define BOOST_IMPORT_TEMPLATE4(template_name)
|
|
||||||
# define BOOST_IMPORT_TEMPLATE3(template_name)
|
|
||||||
# define BOOST_IMPORT_TEMPLATE2(template_name)
|
|
||||||
# define BOOST_IMPORT_TEMPLATE1(template_name)
|
|
||||||
|
|
||||||
#else // BOOST_NO_OPERATORS_IN_NAMESPACE
|
|
||||||
|
|
||||||
# ifndef BOOST_NO_USING_TEMPLATE
|
|
||||||
|
|
||||||
// Bring the names in with a using-declaration
|
|
||||||
// to avoid stressing the compiler.
|
|
||||||
# define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name;
|
|
||||||
# define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
|
|
||||||
# define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
|
|
||||||
# define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
|
|
||||||
|
|
||||||
# else
|
|
||||||
|
|
||||||
// Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
|
|
||||||
// from working, we are forced to use inheritance for that compiler.
|
|
||||||
# define BOOST_IMPORT_TEMPLATE4(template_name) \
|
|
||||||
template <class T, class U, class V, class W, class B = ::boost::detail::empty_base> \
|
|
||||||
struct template_name : ::template_name<T, U, V, W, B> {};
|
|
||||||
|
|
||||||
# define BOOST_IMPORT_TEMPLATE3(template_name) \
|
|
||||||
template <class T, class U, class V, class B = ::boost::detail::empty_base> \
|
|
||||||
struct template_name : ::template_name<T, U, V, B> {};
|
|
||||||
|
|
||||||
# define BOOST_IMPORT_TEMPLATE2(template_name) \
|
|
||||||
template <class T, class U, class B = ::boost::detail::empty_base> \
|
|
||||||
struct template_name : ::template_name<T, U, B> {};
|
|
||||||
|
|
||||||
# define BOOST_IMPORT_TEMPLATE1(template_name) \
|
|
||||||
template <class T, class B = ::boost::detail::empty_base> \
|
|
||||||
struct template_name : ::template_name<T, B> {};
|
|
||||||
|
|
||||||
# endif // BOOST_NO_USING_TEMPLATE
|
|
||||||
|
|
||||||
#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
|
|
||||||
|
|
||||||
//
|
|
||||||
// Here's where we put it all together, defining the xxxx forms of the templates
|
|
||||||
// in namespace boost. We also define specializations of is_chained_base<> for
|
|
||||||
// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
|
|
||||||
// neccessary.
|
|
||||||
//
|
|
||||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
||||||
|
|
||||||
// is_chained_base<> - a traits class used to distinguish whether an operator
|
|
||||||
// template argument is being used for base class chaining, or is specifying a
|
|
||||||
// 2nd argument type.
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
// A type parameter is used instead of a plain bool because Borland's compiler
|
|
||||||
// didn't cope well with the more obvious non-type template parameter.
|
|
||||||
namespace detail {
|
|
||||||
struct true_t {};
|
|
||||||
struct false_t {};
|
|
||||||
} // namespace detail
|
|
||||||
|
|
||||||
// Unspecialized version assumes that most types are not being used for base
|
|
||||||
// class chaining. We specialize for the operator templates defined in this
|
|
||||||
// library.
|
|
||||||
template<class T> struct is_chained_base {
|
|
||||||
typedef ::boost::detail::false_t value;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
// Import a 4-type-argument operator template into boost (if neccessary) and
|
|
||||||
// provide a specialization of 'is_chained_base<>' for it.
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE4(template_name4) \
|
|
||||||
BOOST_IMPORT_TEMPLATE4(template_name4) \
|
|
||||||
template<class T, class U, class V, class W, class B> \
|
|
||||||
struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > { \
|
|
||||||
typedef ::boost::detail::true_t value; \
|
|
||||||
};
|
|
||||||
|
|
||||||
// Import a 3-type-argument operator template into boost (if neccessary) and
|
|
||||||
// provide a specialization of 'is_chained_base<>' for it.
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE3(template_name3) \
|
|
||||||
BOOST_IMPORT_TEMPLATE3(template_name3) \
|
|
||||||
template<class T, class U, class V, class B> \
|
|
||||||
struct is_chained_base< ::boost::template_name3<T, U, V, B> > { \
|
|
||||||
typedef ::boost::detail::true_t value; \
|
|
||||||
};
|
|
||||||
|
|
||||||
// Import a 2-type-argument operator template into boost (if neccessary) and
|
|
||||||
// provide a specialization of 'is_chained_base<>' for it.
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE2(template_name2) \
|
|
||||||
BOOST_IMPORT_TEMPLATE2(template_name2) \
|
|
||||||
template<class T, class U, class B> \
|
|
||||||
struct is_chained_base< ::boost::template_name2<T, U, B> > { \
|
|
||||||
typedef ::boost::detail::true_t value; \
|
|
||||||
};
|
|
||||||
|
|
||||||
// Import a 1-type-argument operator template into boost (if neccessary) and
|
|
||||||
// provide a specialization of 'is_chained_base<>' for it.
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE1(template_name1) \
|
|
||||||
BOOST_IMPORT_TEMPLATE1(template_name1) \
|
|
||||||
template<class T, class B> \
|
|
||||||
struct is_chained_base< ::boost::template_name1<T, B> > { \
|
|
||||||
typedef ::boost::detail::true_t value; \
|
|
||||||
};
|
|
||||||
|
|
||||||
// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
|
|
||||||
// can be used for specifying both 1-argument and 2-argument forms. Requires the
|
|
||||||
// existence of two previously defined class templates named '<template_name>1'
|
|
||||||
// and '<template_name>2' which must implement the corresponding 1- and 2-
|
|
||||||
// argument forms.
|
|
||||||
//
|
|
||||||
// The template type parameter O == is_chained_base<U>::value is used to
|
|
||||||
// distinguish whether the 2nd argument to <template_name> is being used for
|
|
||||||
// base class chaining from another boost operator template or is describing a
|
|
||||||
// 2nd operand type. O == true_t only when U is actually an another operator
|
|
||||||
// template from the library. Partial specialization is used to select an
|
|
||||||
// implementation in terms of either '<template_name>1' or '<template_name>2'.
|
|
||||||
//
|
|
||||||
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE(template_name) \
|
|
||||||
template <class T \
|
|
||||||
,class U = T \
|
|
||||||
,class B = ::boost::detail::empty_base \
|
|
||||||
,class O = typename is_chained_base<U>::value \
|
|
||||||
> \
|
|
||||||
struct template_name : template_name##2<T, U, B> {}; \
|
|
||||||
\
|
|
||||||
template<class T, class U, class B> \
|
|
||||||
struct template_name<T, U, B, ::boost::detail::true_t> \
|
|
||||||
: template_name##1<T, U> {}; \
|
|
||||||
\
|
|
||||||
template <class T, class B> \
|
|
||||||
struct template_name<T, T, B, ::boost::detail::false_t> \
|
|
||||||
: template_name##1<T, B> {}; \
|
|
||||||
\
|
|
||||||
template<class T, class U, class B, class O> \
|
|
||||||
struct is_chained_base< ::boost::template_name<T, U, B, O> > { \
|
|
||||||
typedef ::boost::detail::true_t value; \
|
|
||||||
}; \
|
|
||||||
\
|
|
||||||
BOOST_OPERATOR_TEMPLATE2(template_name##2) \
|
|
||||||
BOOST_OPERATOR_TEMPLATE1(template_name##1)
|
|
||||||
|
|
||||||
|
|
||||||
#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
||||||
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE4(template_name4) \
|
|
||||||
BOOST_IMPORT_TEMPLATE4(template_name4)
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE3(template_name3) \
|
|
||||||
BOOST_IMPORT_TEMPLATE3(template_name3)
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE2(template_name2) \
|
|
||||||
BOOST_IMPORT_TEMPLATE2(template_name2)
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE1(template_name1) \
|
|
||||||
BOOST_IMPORT_TEMPLATE1(template_name1)
|
|
||||||
|
|
||||||
// In this case we can only assume that template_name<> is equivalent to the
|
|
||||||
// more commonly needed template_name1<> form.
|
|
||||||
# define BOOST_OPERATOR_TEMPLATE(template_name) \
|
|
||||||
template <class T, class B = ::boost::detail::empty_base> \
|
|
||||||
struct template_name : template_name##1<T, B> {};
|
|
||||||
|
|
||||||
#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
||||||
|
|
||||||
namespace boost {
|
|
||||||
|
|
||||||
BOOST_OPERATOR_TEMPLATE(less_than_comparable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(equality_comparable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(multipliable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(addable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(subtractable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(dividable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE2(dividable2_left)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(modable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE2(modable2_left)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(xorable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(andable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(orable)
|
|
||||||
|
|
||||||
BOOST_OPERATOR_TEMPLATE1(incrementable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE1(decrementable)
|
|
||||||
|
|
||||||
BOOST_OPERATOR_TEMPLATE2(dereferenceable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE3(indexable)
|
|
||||||
|
|
||||||
BOOST_OPERATOR_TEMPLATE1(bool_testable)
|
|
||||||
|
|
||||||
BOOST_OPERATOR_TEMPLATE(left_shiftable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(right_shiftable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(equivalent)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(partially_ordered)
|
|
||||||
|
|
||||||
BOOST_OPERATOR_TEMPLATE(totally_ordered)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(additive)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(multiplicative)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(arithmetic)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(bitwise)
|
|
||||||
BOOST_OPERATOR_TEMPLATE1(unit_steppable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(shiftable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(ring_operators)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(field_operators)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
|
|
||||||
BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
|
|
||||||
BOOST_OPERATOR_TEMPLATE2(input_iteratable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE1(output_iteratable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
|
|
||||||
BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
|
|
||||||
|
|
||||||
#undef BOOST_OPERATOR_TEMPLATE
|
|
||||||
#undef BOOST_OPERATOR_TEMPLATE4
|
|
||||||
#undef BOOST_OPERATOR_TEMPLATE3
|
|
||||||
#undef BOOST_OPERATOR_TEMPLATE2
|
|
||||||
#undef BOOST_OPERATOR_TEMPLATE1
|
|
||||||
#undef BOOST_IMPORT_TEMPLATE1
|
|
||||||
#undef BOOST_IMPORT_TEMPLATE2
|
|
||||||
#undef BOOST_IMPORT_TEMPLATE3
|
|
||||||
#undef BOOST_IMPORT_TEMPLATE4
|
|
||||||
|
|
||||||
// The following 'operators' classes can only be used portably if the derived class
|
|
||||||
// declares ALL of the required member operators.
|
|
||||||
template <class T, class U>
|
|
||||||
struct operators2
|
|
||||||
: totally_ordered2<T,U
|
|
||||||
, integer_arithmetic2<T,U
|
|
||||||
, bitwise2<T,U
|
|
||||||
> > > {};
|
|
||||||
|
|
||||||
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
||||||
template <class T, class U = T>
|
|
||||||
struct operators : operators2<T, U> {};
|
|
||||||
|
|
||||||
template <class T> struct operators<T, T>
|
|
||||||
#else
|
|
||||||
template <class T> struct operators
|
|
||||||
#endif
|
|
||||||
: totally_ordered<T
|
|
||||||
, integer_arithmetic<T
|
|
||||||
, bitwise<T
|
|
||||||
, unit_steppable<T
|
|
||||||
> > > > {};
|
|
||||||
|
|
||||||
// Iterator helper classes (contributed by Jeremy Siek) -------------------//
|
|
||||||
// (Input and output iterator helpers contributed by Daryle Walker) -------//
|
|
||||||
// (Changed to use combined operator classes by Daryle Walker) ------------//
|
|
||||||
template <class T,
|
|
||||||
class V,
|
|
||||||
class D = std::ptrdiff_t,
|
|
||||||
class P = V const *,
|
|
||||||
class R = V const &>
|
|
||||||
struct input_iterator_helper
|
|
||||||
: input_iteratable<T, P
|
|
||||||
, boost::iterator<std::input_iterator_tag, V, D, P, R
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
struct output_iterator_helper
|
|
||||||
: output_iteratable<T
|
|
||||||
, boost::iterator<std::output_iterator_tag, void, void, void, void
|
|
||||||
> >
|
|
||||||
{
|
|
||||||
T& operator*() { return static_cast<T&>(*this); }
|
|
||||||
T& operator++() { return static_cast<T&>(*this); }
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T,
|
|
||||||
class V,
|
|
||||||
class D = std::ptrdiff_t,
|
|
||||||
class P = V*,
|
|
||||||
class R = V&>
|
|
||||||
struct forward_iterator_helper
|
|
||||||
: forward_iteratable<T, P
|
|
||||||
, boost::iterator<std::forward_iterator_tag, V, D, P, R
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T,
|
|
||||||
class V,
|
|
||||||
class D = std::ptrdiff_t,
|
|
||||||
class P = V*,
|
|
||||||
class R = V&>
|
|
||||||
struct bidirectional_iterator_helper
|
|
||||||
: bidirectional_iteratable<T, P
|
|
||||||
, boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
|
|
||||||
> > {};
|
|
||||||
|
|
||||||
template <class T,
|
|
||||||
class V,
|
|
||||||
class D = std::ptrdiff_t,
|
|
||||||
class P = V*,
|
|
||||||
class R = V&>
|
|
||||||
struct random_access_iterator_helper
|
|
||||||
: random_access_iteratable<T, P, D, R
|
|
||||||
, boost::iterator<std::random_access_iterator_tag, V, D, P, R
|
|
||||||
> >
|
|
||||||
{
|
|
||||||
friend D requires_difference_operator(const T& x, const T& y) {
|
|
||||||
return x - y;
|
|
||||||
}
|
|
||||||
}; // random_access_iterator_helper
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#if defined(__sgi) && !defined(__GNUC__)
|
|
||||||
#pragma reset woff 1234
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif // BOOST_OPERATORS_HPP
|
|
||||||
@@ -1,163 +0,0 @@
|
|||||||
#ifndef BOOST_REF_HPP_INCLUDED
|
|
||||||
# define BOOST_REF_HPP_INCLUDED
|
|
||||||
|
|
||||||
# if _MSC_VER+0 >= 1020
|
|
||||||
# pragma once
|
|
||||||
# endif
|
|
||||||
|
|
||||||
# include <boost/config.hpp>
|
|
||||||
# include <boost/utility/addressof.hpp>
|
|
||||||
# include <boost/mpl/bool.hpp>
|
|
||||||
|
|
||||||
//
|
|
||||||
// ref.hpp - ref/cref, useful helper functions
|
|
||||||
//
|
|
||||||
// Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
|
|
||||||
// Copyright (C) 2001, 2002 Peter Dimov
|
|
||||||
// Copyright (C) 2002 David Abrahams
|
|
||||||
//
|
|
||||||
// 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/libs/bind/ref.html for documentation.
|
|
||||||
//
|
|
||||||
|
|
||||||
namespace boost
|
|
||||||
{
|
|
||||||
|
|
||||||
template<class T> class reference_wrapper
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef T type;
|
|
||||||
|
|
||||||
#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
|
|
||||||
|
|
||||||
explicit reference_wrapper(T& t): t_(&t) {}
|
|
||||||
|
|
||||||
#else
|
|
||||||
|
|
||||||
explicit reference_wrapper(T& t): t_(addressof(t)) {}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
operator T& () const { return *t_; }
|
|
||||||
|
|
||||||
T& get() const { return *t_; }
|
|
||||||
|
|
||||||
T* get_pointer() const { return t_; }
|
|
||||||
|
|
||||||
private:
|
|
||||||
|
|
||||||
T* t_;
|
|
||||||
};
|
|
||||||
|
|
||||||
# if defined(__BORLANDC__) && (__BORLANDC__ <= 0x570)
|
|
||||||
# define BOOST_REF_CONST
|
|
||||||
# else
|
|
||||||
# define BOOST_REF_CONST const
|
|
||||||
# endif
|
|
||||||
|
|
||||||
template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t)
|
|
||||||
{
|
|
||||||
return reference_wrapper<T>(t);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & t)
|
|
||||||
{
|
|
||||||
return reference_wrapper<T const>(t);
|
|
||||||
}
|
|
||||||
|
|
||||||
# undef BOOST_REF_CONST
|
|
||||||
|
|
||||||
# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
||||||
template<typename T>
|
|
||||||
class is_reference_wrapper
|
|
||||||
: public mpl::false_
|
|
||||||
{
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
class is_reference_wrapper<reference_wrapper<T> >
|
|
||||||
: public mpl::true_
|
|
||||||
{
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
class unwrap_reference
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef T type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
class unwrap_reference<reference_wrapper<T> >
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
typedef T type;
|
|
||||||
};
|
|
||||||
# else // no partial specialization
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#include <boost/type.hpp>
|
|
||||||
|
|
||||||
namespace boost
|
|
||||||
{
|
|
||||||
|
|
||||||
namespace detail
|
|
||||||
{
|
|
||||||
typedef char (&yes_reference_wrapper_t)[1];
|
|
||||||
typedef char (&no_reference_wrapper_t)[2];
|
|
||||||
|
|
||||||
no_reference_wrapper_t is_reference_wrapper_test(...);
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper<T> >);
|
|
||||||
|
|
||||||
template<bool wrapped>
|
|
||||||
struct reference_unwrapper
|
|
||||||
{
|
|
||||||
template <class T>
|
|
||||||
struct apply
|
|
||||||
{
|
|
||||||
typedef T type;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct reference_unwrapper<true>
|
|
||||||
{
|
|
||||||
template <class T>
|
|
||||||
struct apply
|
|
||||||
{
|
|
||||||
typedef typename T::type type;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
class is_reference_wrapper
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
BOOST_STATIC_CONSTANT(
|
|
||||||
bool, value = (
|
|
||||||
sizeof(detail::is_reference_wrapper_test(type<T>()))
|
|
||||||
== sizeof(detail::yes_reference_wrapper_t)));
|
|
||||||
|
|
||||||
typedef ::boost::mpl::bool_<value> type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
class unwrap_reference
|
|
||||||
: public detail::reference_unwrapper<
|
|
||||||
is_reference_wrapper<T>::value
|
|
||||||
>::template apply<T>
|
|
||||||
{};
|
|
||||||
|
|
||||||
# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
#endif // #ifndef BOOST_REF_HPP_INCLUDED
|
|
||||||
@@ -1,21 +0,0 @@
|
|||||||
// Boost utility.hpp header file -------------------------------------------//
|
|
||||||
|
|
||||||
// (C) Copyright Boost.org 1999-2003. 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/libs/utility for documentation.
|
|
||||||
|
|
||||||
#ifndef BOOST_UTILITY_HPP
|
|
||||||
#define BOOST_UTILITY_HPP
|
|
||||||
|
|
||||||
#include <boost/utility/addressof.hpp>
|
|
||||||
#include <boost/utility/base_from_member.hpp>
|
|
||||||
#include <boost/checked_delete.hpp>
|
|
||||||
#include <boost/next_prior.hpp>
|
|
||||||
#include <boost/noncopyable.hpp>
|
|
||||||
|
|
||||||
#endif // BOOST_UTILITY_HPP
|
|
||||||
|
|
||||||
@@ -1,34 +0,0 @@
|
|||||||
// Boost utility_fwd.hpp header file ---------------------------------------//
|
|
||||||
|
|
||||||
// (C) Copyright boost.org 2001. 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/libs/utility for documentation.
|
|
||||||
|
|
||||||
#ifndef BOOST_UTILITY_FWD_HPP
|
|
||||||
#define BOOST_UTILITY_FWD_HPP
|
|
||||||
|
|
||||||
|
|
||||||
namespace boost
|
|
||||||
{
|
|
||||||
|
|
||||||
|
|
||||||
// From <boost/utility/base_from_member.hpp> -------------------------------//
|
|
||||||
|
|
||||||
template < typename MemberType, int UniqueID = 0 >
|
|
||||||
class base_from_member;
|
|
||||||
|
|
||||||
|
|
||||||
// From <boost/utility.hpp> ------------------------------------------------//
|
|
||||||
|
|
||||||
class noncopyable;
|
|
||||||
|
|
||||||
// Also has a few function templates
|
|
||||||
|
|
||||||
} // namespace boost
|
|
||||||
|
|
||||||
|
|
||||||
#endif // BOOST_UTILITY_FWD_HPP
|
|
||||||
Reference in New Issue
Block a user