Boost-Commit :

Date view	Thread view	Subject view	Author view

From: nesotto_at_[hidden]
Date: 2007-11-09 05:27:43

Next message: john_at_[hidden]: "[Boost-commit] svn:boost r40963 - trunk/libs/math/test"
Previous message: john_at_[hidden]: "[Boost-commit] svn:boost r40961 - in trunk/libs/math/doc/octonion: . html html/boost_octonions html/boost_octonions/octonions"

Author: nesotto
Date: 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
New Revision: 40962
URL: http://svn.boost.org/trac/boost/changeset/40962

Log:
major update wrt. new range concepts
Text files modified:
   trunk/libs/range/doc/boost_range.html | 185 ++++++++----------------
   trunk/libs/range/doc/examples.html | 4
   trunk/libs/range/doc/intro.html | 10
   trunk/libs/range/doc/mfc_atl.html | 300 +++++++++++++++++++++++++++++++++++++--
   trunk/libs/range/doc/mfc_atl.rst | 8
   trunk/libs/range/doc/portability.html | 2
   trunk/libs/range/doc/range.html | 209 +++------------------------
   trunk/libs/range/doc/utility_class.html | 19 -
   8 files changed, 393 insertions(+), 344 deletions(-)

Modified: trunk/libs/range/doc/boost_range.html
==============================================================================
--- trunk/libs/range/doc/boost_range.html (original)
+++ trunk/libs/range/doc/boost_range.html 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
@@ -94,14 +94,6 @@
 struct <a
href="#range_reverse_iterator">range_reverse_iterator</a>;
-
- //
- // Random Access Range metafunctions
- //
-
- template< class T >
- struct <a href="#range_size">range_size</a>;

 //
 // Single Pass Range functions
@@ -112,7 +104,7 @@
 begin( T& c );

 template< class T >
- typename range_iterator<T>::type
+ typename range_iterator<const T>::type
 begin( const T& c );

 template< class T >
@@ -120,7 +112,7 @@
 end( T& c );

 template< class T >
- typename range_iterator<T>::type
+ typename range_iterator<const T>::type
 end( const T& c );

 template< class T >
@@ -144,7 +136,7 @@
 rbegin( T& c );

 template< class T >
- typename range_reverse_iterator<T>::type
+ typename range_reverse_iterator<const T>::type
 rbegin( const T& c );

 template< class T >
@@ -152,11 +144,10 @@
 rend( T& c );

 template< class T >
- typename range_reverse_iterator<T>::type
+ typename range_reverse_iterator<const T>::type
 rend( const T& c );
 
-
 //
 // Random Access Range functions
 //
@@ -164,7 +155,7 @@
 template< class T >
 typename range_size<T>::type
 size( const T& c );
-
+
 //
 // Special const Range functions
 //
@@ -247,10 +238,8 @@
 <tr>
 <a name="range_value"></a>
 <td><code>range_value<X>::type</code></td>
- <td><code>T::value_type</code> 
- <code>boost::iterator_value<P::first_type>::type</code>  
- <code>A</code> 
- <code>Char</code>
+ <td><code>boost::iterator_value<range_iterator<X>::type>::type</code>
+ </td>
 <td>compile time</td>
 </tr>
 <tr>
@@ -264,7 +253,7 @@
 </tr>
 <tr>
 <a name="range_const_iterator"></a>
- <td><code>range_const_iterator<X>::type</code></td>
+ <td><code>range_iterator<const X>::type</code></td>
 <td><code>T::const_iterator</code> 
 <code>P::first_type</code> 
 <code>const A*</code> 
@@ -274,20 +263,11 @@
 <tr>
 <a name="range_difference"></a>
 <td><code>range_difference<X>::type</code></td>
- <td><code>T::difference_type</code> 
- <code>boost::iterator_difference<P::first_type>::type</code> 
- <code>std::ptrdiff_t</code> 
- <code>std::ptrdiff_t</code> 
+ <td>
+ <code>boost::iterator_difference<range_iterator<X>::type>::type</code></td>
+
 <td>compile time</td>
 </tr>
- <tr>
- <a name="range_size"></a>
- <td><code>range_size<X>::type</code></td>
- <td><code>T::size_type</code> 
- <code>std::size_t</code> 
- <code>std::size_t</code> 
- <code>std::size_t</code> 
- <td>compile time</td>
 </tr>
 <tr>
 <a name="range_result_iterator"></a>
@@ -301,31 +281,18 @@
 <tr>
 <a name="range_reverse_iterator"></a>
 <td><code>range_reverse_iterator<X>::type</code></td>
- <td><code>boost::reverse_iterator< typename range_iterator<T>::type ></code> 
+ <td><code>boost::reverse_iterator<range_iterator<X>::type></code> 
 <td>compile time</td>
 </tr>
 <tr>
 <a name="range_const_reverse_iterator"></a>
- <td><code>range_const_reverse_iterator<X>::type</code></td>
- <td><code>boost::reverse_iterator< typename range_const_iterator<T>::type ></code>
+ <td><code>range_reverse_iterator<const X>::type</code></td>
+ <td><code>boost::reverse_iterator<range_iterator<const X>::type></code>
 
 <td>compile time</td>
 </tr>
- <tr>
- <a name="range_reverse_result_iterator"></a>
- <td><code>range_reverse_result_iterator<X>::type</code></td>
- <td><code>boost::reverse_iterator< typename range_result_iterator<T>::type
- ></code>
- <td>compile time</td>
- </tr>
 </table>
 
- 
- The special metafunctions <code>range_result_iterator</code> and <code>range_reverse_result_iterator</code>
- are not part of any Range concept, but they are very useful when implementing
- certain Range classes like sub_range
- because of their ability to select iterators based on constness.
- 
 <h4>Functions</h4>
 
 <table border="1" cellpadding="5">
@@ -347,7 +314,7 @@
 <code>p.first</code> if <code>p</code> is of type <code>std::pair&ltT><code> 
 <code>a</code> if <code>a</code> is an array 
 <code>s</code> if <code>s</code> is a string literal 
- <code>boost_range_begin(x)</code> if that expression would invoke a function found by ADL 
+ <code>range_begin(x)</code> if that expression would invoke a function found by ADL 
 <code>t.begin()</code> otherwise

 <td>constant time</td>
@@ -363,7 +330,7 @@
 
 <code>s + sz - 1</code> if <code>s</code> is a string literal of size <code>sz</code>
 
- <code>boost_range_end(x)</code> if that expression would invoke a function found by ADL 
+ <code>range_end(x)</code> if that expression would invoke a function found by ADL 
 <code>t.end()</code> otherwise

 <td>linear if <code>X</code> is <code>Char*</code>
@@ -381,26 +348,31 @@
 </td>
 </tr>
 <tr>
+ <a name="distance"></a>
+ <td><code>distance(x)</code></td>
+ <td><code>range_difference<X>::type</code></td>
+ <td>
+ <code>
+ std::distance(boost::begin(x),boost::end(x))
+ </code>
+ </td>
+ <td>-</td>
+
+ </tr>
+
+ <tr>
 <a name="size"></a>
 <td><code>size(x)</code></td>
- <td><code>range_size<X>::type</code></td>
- <td>
- <code>std::distance(p.first,p.second)</code> if <code>p</code> is of type <code>std::pair&ltT><code> 
- <code>sz</code> if <code>a</code> is an array of size <code>sz</code> 
- <code>end(s) - s</code> if <code>s</code> is a string literal or a <code>Char*</code> 
- <code>boost_range_size(x)</code> if that expression would invoke a function found by ADL 
- <code>t.size()</code> otherwise
- <td>linear if <code>X</code> is <code>Char*</code>
- 
- or if <code>std::distance()</code> is linear
- 
- constant time otherwise</td>
+ <td><code>range_difference<X>::type</code></td>
+ <td><code> boost::end(x) - boost::begin(x)</code>
+
+ <td> constant time </td>
 </tr>
 <tr>
 <a name="rbegin"></a>
 <td><code>rbegin(x)</code></td>
- <td><code>range_reverse_result_iterator<X>::type</code></td>
- <td><code>range_reverse_result_iterator<X>::type( end(x) )</code>
+ <td><code>range_reverse_iterator<X>::type</code></td>
+ <td><code>range_reverse_iterator<X>::type( end(x) )</code>
 
 <td>same as <code>end(x)</code>
 </td>
@@ -408,15 +380,15 @@
 <tr>
 <a name="rend"></a>
 <td><code>rend(x)</code></td>
- <td><code>range_reverse_result_iterator<X>::type</code></td>
- <td><code>range_reverse_result_iterator<X>::type( begin(x) )</code>
+ <td><code>range_reverse_iterator<X>::type</code></td>
+ <td><code>range_reverse_iterator<X>::type( begin(x) )</code>
 <td>same as <code>begin(x)</code></td>
 </tr>
 <tr>
 <a name="const_begin"></a>
 <td><code>const_begin(x)</code></td>
- <td><code>range_const_iterator<X>::type</code></td>
- <td><code>range_const_iterator<X>::type( begin(x) )</code>
+ <td><code>range_iterator<const X>::type</code></td>
+ <td><code>range_iterator<const X>::type( begin(x) )</code>
 
 <td>same as <code>begin(x)</code>
 </td>
@@ -424,15 +396,15 @@
 <tr>
 <a name="const_end"></a>
 <td><code>const_end(x)</code></td>
- <td><code>range_const_iterator<X>::type</code></td>
- <td><code>range_const_iterator<X>::type( end(x) )</code>
+ <td><code>range_iterator<const X>::type</code></td>
+ <td><code>range_iterator<const X>::type( end(x) )</code>
 <td>same as <code>end(x)</code></td>
 </tr>
 <tr>
 <a name="const_rbegin"></a>
 <td><code>const_rbegin(x)</code></td>
- <td><code>range_const_reverse_iterator<X>::type</code></td>
- <td><code>range_const_reverse_iterator<X>::type( rbegin(x) )</code>
+ <td><code>range_reverse_iterator<const X>::type</code></td>
+ <td><code>range_reverse_iterator<const X>::type( rbegin(x) )</code>
 
 <td>same as <code>rbegin(x)</code>
 </td>
@@ -440,21 +412,22 @@
 <tr>
 <a name="const_rend"></a>
 <td><code>const_rend(x)</code></td>
- <td><code>range_const_reverse_iterator<X>::type</code></td>
- <td><code>range_const_reverse_iterator<X>::type( rend(x) )</code>
+ <td><code>range_reverse_iterator<const X>::type</code></td>
+ <td><code>range_reverse_iterator<const X>::type( rend(x) )</code>
 <td>same as <code>rend(x)</code></td>
 </tr>
 </table>
 
 
- The special <code>const</code> functions are not part of any Range concept, but
- are very useful when you want to document clearly that your code is read-only.
+ The special <code>const_</code>-named functions are useful when you
+ want to document clearly that your code is read-only.
 
 <hr>
 <a name="minimal_interface"></a>
 <h3>Extending the library</h3>
 <ul>
 <li>Method 1: provide member functions and nested types</li>
+
 <li>Method 2: provide free-standing functions and specialize metafunctions</li>
 </ul>

@@ -491,10 +464,6 @@
 </td>
 <td>Single Pass Range</td>
 </tr>
- <tr>
- <td><code>size()</code></td>
- <td>Forward Range</td>
- </tr>
 </table>
 
 
@@ -520,10 +489,6 @@
 <td><code>const_iterator</code></td>
 <td>Single Pass Range</td>
 </tr>
- <tr>
- <td><code>size_type</code></td>
- <td>Forward Range</td>
- </tr>
 </table>
 
 
@@ -554,26 +519,23 @@
 <th>
 Related concept</th>
 <tr>
- <td><code>boost_range_begin(x)</code></td>
+ <td><code>range_begin(x)</code></td>
 <td>Single Pass Range</td>
 </tr>
 <tr>
- <td><code>boost_range_end(x)</code>
+ <td><code>range_end(x)</code>
 </td>
 <td>Single Pass Range</td>
 </tr>
- <tr>
- <td><code>boost_range_size(x)</code></td>
- <td>Forward Range</td>
- </tr>
+
 </table>
 
- <code>boost_range_begin()</code> and <code>boost_range_end()</code> must be
+ <code>range_begin()</code> and <code>range_end()</code> must be
 overloaded for both <code>const</code> and mutable reference arguments.
 

 
- You must also specialize 3 metafunctions for your type <code>X</code>:
+ You must also specialize two metafunctions for your type <code>X</code>:
 
 
 <table cellpadding="5" border="1" ID="Table2">
@@ -583,17 +545,14 @@
 <th>
 Related concept</th>
 <tr>
- <td><code>boost::range_iterator</code></td>
+ <td><code>boost::range_mutable_iterator</code></td>
 <td>Single Pass Range</td>
 </tr>
 <tr>
 <td><code>boost::range_const_iterator</code></td>
 <td>Single Pass Range</td>
 </tr>
- <tr>
- <td><code>boost::range_size</code></td>
- <td>Forward Range</td>
- </tr>
+
 </table>
 
 
@@ -627,7 +586,7 @@
 //

 template< class T >
- struct range_iterator< Foo::Pair<T> >
+ struct range_mutable_iterator< Foo::Pair<T> >
 {
 typedef T type;
 };
@@ -636,20 +595,13 @@
 struct range_const_iterator< Foo::Pair<T> >
 {
 //
- // Remark: this is defined similar to 'range_iterator'
+ // Remark: this is defined similar to 'range_mutable_iterator'
 // because the 'Pair' type does not distinguish
 // between an iterator and a const_iterator.
 //
 typedef T type;
 };

- template< class T >
- struct range_size< Foo::Pair<T> >
- {
-
- typedef std::size_t type;
- };
-
} // namespace 'boost'

namespace Foo
@@ -661,36 +613,29 @@
 //

 template< class T >
- inline T boost_range_begin( Pair<T>& x )
+ inline T range_begin( Pair<T>& x )
 {
 return x.first;
 }

 template< class T >
- inline T boost_range_begin( const Pair<T>& x )
+ inline T range_begin( const Pair<T>& x )
 {
 return x.first;
 }

 template< class T >
- inline T boost_range_end( Pair<T>& x )
+ inline T range_end( Pair<T>& x )
 {
 return x.last;
 }

 template< class T >
- inline T boost_range_end( const Pair<T>& x )
+ inline T range_end( const Pair<T>& x )
 {
 return x.last;
 }

- template< class T >
- inline typename boost::range_size< Pair<T> >::type
- boost_range_size( const Pair<T>& x )
- {
- return std::distance(x.first,x.last);
- }
-
} // namespace 'Foo'

#include <vector>
@@ -699,7 +644,7 @@
{
 typedef std::vector<int>::iterator iter;
 std::vector<int> vec;
- Foo::Pair<iter> pair = { vec.begin(), vec.end() };
+ Foo::Pair<iter> pair = { vec.begin(), vec.end() };
 const Foo::Pair<iter>& cpair = pair;
 //
 // Notice that we call 'begin' etc with qualification.
@@ -708,9 +653,9 @@
 iter e = boost::end( pair );
 i = boost::begin( cpair );
 e = boost::end( cpair );
- boost::range_size< Foo::Pair<iter> >::type s = boost::size( pair );
+ boost::range_difference< Foo::Pair<iter> >::type s = boost::size( pair );
 s = boost::size( cpair );
- boost::range_const_reverse_iterator< Foo::Pair<iter> >::type
+ boost::range_reverse_iterator< const Foo::Pair<iter> >::type
 ri = boost::rbegin( cpair ),
 re = boost::rend( cpair );
}
@@ -719,7 +664,7 @@

 <hr>
 
- (C) Copyright Thorsten Ottosen 2003-2004
+ (C) Copyright Thorsten Ottosen 2003-2007

Modified: trunk/libs/range/doc/examples.html
==============================================================================
--- trunk/libs/range/doc/examples.html (original)
+++ trunk/libs/range/doc/examples.html 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
@@ -26,10 +26,6 @@
 </li>
 shows how to implement a container version of <code >std::find()</code> that
 works with <code >char[],wchar_t[],char*,wchar_t*.</code>
- 
- Warning: support for null-terminated strings is deprecated and will
- disappear in the next Boost release (1.34). 
- 

 <li >
 <a href="../test/algorithm_example.cpp" target="_self" ><code >algorithm_example.cpp</code></a>

Modified: trunk/libs/range/doc/intro.html
==============================================================================
--- trunk/libs/range/doc/intro.html (original)
+++ trunk/libs/range/doc/intro.html 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
@@ -35,16 +35,14 @@
 enough functionality to satisfy the needs of the generic code
 if a suitable layer of indirection is applied . For
 example, raw arrays are often suitable for use with generic code that
- works with containers, provided a suitable adapter is used. Likewise, null
- terminated strings can be treated as containers of characters, if suitably
- adapted.
+ works with containers, provided a suitable adapter is used.
 

 
 This library therefore provides the means to adapt standard-like
- containers,
- null terminated strings, <code>std::pairs</code> of iterators, and raw
- arrays (and more), such that the same generic code can work with them all.
+ containers, <code>std::pairs</code> of iterators, and raw arrays (and
+ more), such that
+ the same generic code can work with them all.
The basic idea is to add another layer of indirection using <a
href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a> and
free-standing functions so syntactic and/or semantic differences can be removed.

Modified: trunk/libs/range/doc/mfc_atl.html
==============================================================================
--- trunk/libs/range/doc/mfc_atl.html (original)
+++ trunk/libs/range/doc/mfc_atl.html 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
@@ -3,14 +3,289 @@
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.4: http://docutils.sourceforge.net/" />
+<meta name="generator" content="Docutils 0.3.10: http://docutils.sourceforge.net/" />
<title>Boost Range MFC/ATL Extension</title>
<meta name="author" content="Shunsuke Sogame" />
<meta name="date" content="26th of May 2006" />
<meta name="copyright" content="Shunsuke Sogame 2005-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt)." />
<style type="text/css">

-_at_import "http://www.boost.org/libs/ptr_container/doc/default.css";
+/*
+:Author: David Goodger
+:Contact: goodger_at_[hidden]
+:Date: $Date: 2005-09-25 17:49:54 +0200 (Sun, 25 Sep 2005) $
+:Revision: $Revision: 3901 $
+:Copyright: This stylesheet has been placed in the public domain.
+
+Default cascading style sheet for the HTML output of Docutils.
+
+See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
+customize this style sheet.
+*/
+
+/* "! important" is used here to override other ``margin-top`` and
+ ``margin-bottom`` styles that are later in the stylesheet or
+ more specific. See http://www.w3.org/TR/CSS1#the-cascade */
+.first {
+ margin-top: 0 ! important }
+
+.last, .with-subtitle {
+ margin-bottom: 0 ! important }
+
+.hidden {
+ display: none }
+
+a.toc-backref {
+ text-decoration: none ;
+ color: black }
+
+blockquote.epigraph {
+ margin: 2em 5em ; }
+
+dl.docutils dd {
+ margin-bottom: 0.5em }
+
+/* Uncomment (and remove this text!) to get bold-faced definition list terms
+dl.docutils dt {
+ font-weight: bold }
+*/
+
+div.abstract {
+ margin: 2em 5em }
+
+div.abstract p.topic-title {
+ font-weight: bold ;
+ text-align: center }
+
+div.admonition, div.attention, div.caution, div.danger, div.error,
+div.hint, div.important, div.note, div.tip, div.warning {
+ margin: 2em ;
+ border: medium outset ;
+ padding: 1em }
+
+div.admonition p.admonition-title, div.hint p.admonition-title,
+div.important p.admonition-title, div.note p.admonition-title,
+div.tip p.admonition-title {
+ font-weight: bold ;
+ font-family: sans-serif }
+
+div.attention p.admonition-title, div.caution p.admonition-title,
+div.danger p.admonition-title, div.error p.admonition-title,
+div.warning p.admonition-title {
+ color: red ;
+ font-weight: bold ;
+ font-family: sans-serif }
+
+/* Uncomment (and remove this text!) to get reduced vertical space in
+ compound paragraphs.
+div.compound .compound-first, div.compound .compound-middle {
+ margin-bottom: 0.5em }
+
+div.compound .compound-last, div.compound .compound-middle {
+ margin-top: 0.5em }
+*/
+
+div.dedication {
+ margin: 2em 5em ;
+ text-align: center ;
+ font-style: italic }
+
+div.dedication p.topic-title {
+ font-weight: bold ;
+ font-style: normal }
+
+div.figure {
+ margin-left: 2em }
+
+div.footer, div.header {
+ clear: both;
+ font-size: smaller }
+
+div.line-block {
+ display: block ;
+ margin-top: 1em ;
+ margin-bottom: 1em }
+
+div.line-block div.line-block {
+ margin-top: 0 ;
+ margin-bottom: 0 ;
+ margin-left: 1.5em }
+
+div.sidebar {
+ margin-left: 1em ;
+ border: medium outset ;
+ padding: 1em ;
+ background-color: #ffffee ;
+ width: 40% ;
+ float: right ;
+ clear: right }
+
+div.sidebar p.rubric {
+ font-family: sans-serif ;
+ font-size: medium }
+
+div.system-messages {
+ margin: 5em }
+
+div.system-messages h1 {
+ color: red }
+
+div.system-message {
+ border: medium outset ;
+ padding: 1em }
+
+div.system-message p.system-message-title {
+ color: red ;
+ font-weight: bold }
+
+div.topic {
+ margin: 2em }
+
+h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
+h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
+ margin-top: 0.4em }
+
+h1.title {
+ text-align: center }
+
+h2.subtitle {
+ text-align: center }
+
+hr.docutils {
+ width: 75% }
+
+img.align-left {
+ clear: left }
+
+img.align-right {
+ clear: right }
+
+img.borderless {
+ border: 0 }
+
+ol.simple, ul.simple {
+ margin-bottom: 1em }
+
+ol.arabic {
+ list-style: decimal }
+
+ol.loweralpha {
+ list-style: lower-alpha }
+
+ol.upperalpha {
+ list-style: upper-alpha }
+
+ol.lowerroman {
+ list-style: lower-roman }
+
+ol.upperroman {
+ list-style: upper-roman }
+
+p.attribution {
+ text-align: right ;
+ margin-left: 50% }
+
+p.caption {
+ font-style: italic }
+
+p.credits {
+ font-style: italic ;
+ font-size: smaller }
+
+p.label {
+ white-space: nowrap }
+
+p.rubric {
+ font-weight: bold ;
+ font-size: larger ;
+ color: maroon ;
+ text-align: center }
+
+p.sidebar-title {
+ font-family: sans-serif ;
+ font-weight: bold ;
+ font-size: larger }
+
+p.sidebar-subtitle {
+ font-family: sans-serif ;
+ font-weight: bold }
+
+p.topic-title {
+ font-weight: bold }
+
+pre.address {
+ margin-bottom: 0 ;
+ margin-top: 0 ;
+ font-family: serif ;
+ font-size: 100% }
+
+pre.line-block {
+ font-family: serif ;
+ font-size: 100% }
+
+pre.literal-block, pre.doctest-block {
+ margin-left: 2em ;
+ margin-right: 2em ;
+ background-color: #eeeeee }
+
+span.classifier {
+ font-family: sans-serif ;
+ font-style: oblique }
+
+span.classifier-delimiter {
+ font-family: sans-serif ;
+ font-weight: bold }
+
+span.interpreted {
+ font-family: sans-serif }
+
+span.option {
+ white-space: nowrap }
+
+span.pre {
+ white-space: pre }
+
+span.problematic {
+ color: red }
+
+span.section-subtitle {
+ /* font-size relative to parent (h1..h6 element) */
+ font-size: 80% }
+
+table.citation {
+ border-left: solid thin gray }
+
+table.docinfo {
+ margin: 2em 4em }
+
+table.docutils {
+ margin-top: 0.5em ;
+ margin-bottom: 0.5em }
+
+table.footnote {
+ border-left: solid thin black }
+
+table.docutils td, table.docutils th,
+table.docinfo td, table.docinfo th {
+ padding-left: 0.5em ;
+ padding-right: 0.5em ;
+ vertical-align: top }
+
+table.docutils th.field-name, table.docinfo th.docinfo-name {
+ font-weight: bold ;
+ text-align: left ;
+ white-space: nowrap ;
+ padding-left: 0 }
+
+h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
+h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
+ font-size: 100% }
+
+tt.docutils {
+ background-color: #eeeeee }
+
+ul.auto-toc {
+ list-style-type: none }

</style>
</head>
@@ -33,7 +308,7 @@
</table>
<div class="section">
<h1><a id="overview" name="overview">Overview</a></h1>
-Boost.Range MFC/ATL Extension provides <a class="reference" href="http://www.boost.org/libs/range/">Boost.Range</a> support for MFC/ATL collection and string types.
+Boost.Range MFC/ATL Extension provides <a class="reference" href="../index.html">Boost.Range</a> support for MFC/ATL collection and string types.
<pre class="literal-block">
CTypedPtrArray<CPtrArray, CList<CString> *> myArray;
...
@@ -64,7 +339,7 @@
</div>
<div class="section">
<h1><a id="mfc-ranges" name="mfc-ranges">MFC Ranges</a></h1>
-If the <tt class="docutils literal"><boost/range/mfc.hpp></tt> is included before or after <a class="reference" href="http://www.boost.org/libs/range/">Boost.Range</a> headers,
+If the <tt class="docutils literal"><boost/range/mfc.hpp></tt> is included before or after <a class="reference" href="../index.html">Boost.Range</a> headers,
the MFC collections and strings become models of Range.
The table below lists the Traversal Category and <tt class="docutils literal">range_reference</tt> of MFC ranges.
<table border="1" class="docutils">
@@ -170,7 +445,7 @@
</tr>
</tbody>
</table>
-Other <a class="reference" href="http://www.boost.org/libs/range/">Boost.Range</a> metafunctions are defined by the following.
+Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
Let <tt class="docutils literal">Range</tt> be any type listed above and <tt class="docutils literal">ReF</tt> be the same as <tt class="docutils literal">range_reference<Range>::type</tt>.
<tt class="docutils literal">range_value<Range>::type</tt> is the same as <tt class="docutils literal">remove_reference<remove_const<Ref>::type>::type</tt>,
<tt class="docutils literal">range_difference<Range>::type</tt> is the same as <tt class="docutils literal">std::ptrdiff_t</tt>, and
@@ -179,7 +454,7 @@
</div>
<div class="section">
<h1><a id="atl-ranges" name="atl-ranges">ATL Ranges</a></h1>
-If the <tt class="docutils literal"><boost/range/atl.hpp></tt> is included before or after <a class="reference" href="http://www.boost.org/libs/range/">Boost.Range</a> headers,
+If the <tt class="docutils literal"><boost/range/atl.hpp></tt> is included before or after <a class="reference" href="../index.html">Boost.Range</a> headers,
the ATL collections and strings become models of Range.
The table below lists the Traversal Category and <tt class="docutils literal">range_reference</tt> of ATL ranges.
<table border="1" class="docutils">
@@ -265,7 +540,7 @@
</tr>
</tbody>
</table>
-Other <a class="reference" href="http://www.boost.org/libs/range/">Boost.Range</a> metafunctions are defined by the following.
+Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
Let <tt class="docutils literal">Range</tt> be any type listed above and <tt class="docutils literal">ReF</tt> be the same as <tt class="docutils literal">range_reference<Range>::type</tt>.
<tt class="docutils literal">range_value<Range>::type</tt> is the same as <tt class="docutils literal">remove_reference<Ref>::type</tt>,
<tt class="docutils literal">range_difference<Range>::type</tt> is the same as <tt class="docutils literal">std::ptrdiff_t</tt>, and
@@ -288,7 +563,7 @@
else
return ReF
</pre>
-Other <a class="reference" href="http://www.boost.org/libs/range/">Boost.Range</a> metafunctions are defined by the following.
+Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
<tt class="docutils literal">range_value<const Range>::type</tt> is the same as <tt class="docutils literal">range_value<Range>::type</tt>,
<tt class="docutils literal">range_difference<const Range>::type</tt> is the same as <tt class="docutils literal">std::ptrdiff_t</tt>, and
<tt class="docutils literal">range_pointer<const Range>::type</tt> is the same as <tt class="docutils literal">add_pointer<remove_reference<range_reference<const Range>::type>::type>::type</tt>.
@@ -296,18 +571,11 @@
<div class="section">
<h1><a id="references" name="references">References</a></h1>
<ul class="simple">
-<li><a class="reference" href="http://www.boost.org/libs/range/">Boost.Range</a></li>
+<li><a class="reference" href="../index.html">Boost.Range</a></li>
<li><a class="reference" href="http://msdn2.microsoft.com/en-us/library/942860sh.aspx">MFC Collections</a></li>
<li><a class="reference" href="http://msdn2.microsoft.com/en-US/library/15e672bd.aspx">ATL Collection Classes</a></li>
</ul>
</div>
</div>
-<div class="footer">
-<hr class="footer" />
-<a class="reference" href="mfc_atl.rst">View document source</a>.
-Generated on: 2006-06-04 22:37 UTC.
-Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
-
-</div>
</body>
</html>

Modified: trunk/libs/range/doc/mfc_atl.rst
==============================================================================
--- trunk/libs/range/doc/mfc_atl.rst (original)
+++ trunk/libs/range/doc/mfc_atl.rst 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
@@ -225,8 +225,8 @@

.. _Boost C++ Libraries: http://www.boost.org/
.. _Boost: `Boost C++ Libraries`_
-.. _Boost.Range: http://www.boost.org/libs/range/
-.. _forward: http://www.boost.org/libs/range/doc/range.html#forward_range
-.. _bidirectional: http://www.boost.org/libs/range/doc/range.html#forward_range
-.. _random access: http://www.boost.org/libs/range/doc/range.html#random_access_range
+.. _Boost.Range: ../index.html
+.. _forward: range.html#forward_range
+.. _bidirectional: range.html#forward_range
+.. _random access: range.html#random_access_range

Modified: trunk/libs/range/doc/portability.html
==============================================================================
--- trunk/libs/range/doc/portability.html (original)
+++ trunk/libs/range/doc/portability.html 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
@@ -36,7 +36,7 @@
 
 Notice also that some compilers cannot do function template ordering properly.
 In that case one must rely of <a
- href="boost_range.html#range_result_iterator"><code >range_result_iterator</code></a>
+ href="boost_range.html#range_iterator"><code >range_iterator</code></a>
 and a single function definition instead of overloaded versions for const and
 non-const arguments.

Modified: trunk/libs/range/doc/range.html
==============================================================================
--- trunk/libs/range/doc/range.html (original)
+++ trunk/libs/range/doc/range.html 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
@@ -50,7 +50,7 @@
 Range provides iterators for accessing a half-open range
<code>[first,one_past_last)</code> of elements and provides
 information about the number of elements in the Range. However, a Range has
- fewer requirements than a Container.
+ much fewer requirements than a Container.
 
 
 The motivation for the Range concept is
@@ -78,9 +78,9 @@
 The operations that can be performed on a Range is dependent on the
 <a href="../../iterator/doc/new-iter-concepts.html#iterator-traversal-concepts-lib-iterator-traversal">traversal
category</a> of the underlying iterator type. Therefore
- the range concepts are named to reflect which traversal category its
- iterators support. See also terminology and style guidelines.
- for more information about naming of ranges.
+ the range concepts are named to reflect which traversal category their
+ iterators support. See also <a href="style.html">terminology and style
+ guidelines.</a> for more information about naming of ranges.

 The concepts described below specifies associated types as
<a href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a> and all
@@ -118,11 +118,7 @@
 <h3>Associated types</h3>

 <table border="1" cellpadding="5">
- <TR>
- <TD VAlign="top">Value type</TD>
- <TD VAlign="top"><code>boost::range_value<X>::type</code></TD>
- <TD VAlign="top">The type of the object stored in a Range.
- </TR>
+
 <TR>
 <TD VAlign="top">Iterator type</TD>
 <TD VAlign="top"><code>boost::range_iterator<X>::type</code></TD>
@@ -132,7 +128,7 @@
 </TR>
 <TR>
 <TD VAlign="top">Const iterator type</TD>
- <TD VAlign="top"><code>boost::range_const_iterator<X>::type</code></TD>
+ <TD VAlign="top"><code>boost::range_iterator<const X>::type</code></TD>
 <TD VAlign="top">A type of iterator that may be used to examine, but not to
 modify, a Range's elements.</TD>
 </TR>
@@ -161,20 +157,16 @@
 <TD VAlign="top">Beginning of range</TD>
 <TD VAlign="top"><code>boost::begin(a)</code></TD>
 <TD VAlign="top"><code>boost::range_iterator<X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_const_iterator<X>::type</code>
+<code>a</code> is mutable, <code>boost::range_iterator<const X>::type</code>
otherwise</TD> </TR>
 <TR>
 <TD VAlign="top">End of range</TD>
 <TD VAlign="top"><code>boost::end(a)</code></TD>
 <TD VAlign="top"><code>boost::range_iterator<X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_const_iterator<X>::type</code>
+<code>a</code> is mutable, <code>boost::range_iterator<const X>::type</code>
otherwise</TD>
 </TR>
- <tr>
- <TD VAlign="top">Is range empty?</TD>
- <TD VAlign="top"><code>boost::empty(a)</code></TD>
- <TD VAlign="top">Convertible to <code>bool</code></TD>
- </TR>
+
 </table>
 <h3>Expression semantics</h3>

@@ -188,7 +180,7 @@
 <TD VAlign="top"><code>boost::begin(a)</code></TD>
 <TD VAlign="top">Returns an iterator pointing to the first element in the Range.</TD>
 <TD VAlign="top"><code>boost::begin(a)</code> is either dereferenceable or past-the-end.
- It is past-the-end if and only if <code>boost::size(a) == 0</code>.</TD>
+ It is past-the-end if and only if <code>boost::distance(a) == 0</code>.</TD>
 </TR>
 <TR>
 <TD VAlign="top"><code>boost::end(a)</code></TD>
@@ -196,19 +188,14 @@
 Range.</TD>
 <TD VAlign="top"><code>boost::end(a)</code> is past-the-end.</TD>
 </TR>
- <TR>
- <TD VAlign="top"><code>boost::empty(a)</code></TD>
- <TD VAlign="top">Equivalent to <code>boost::begin(a) == boost::end(a)</code>. (But possibly
- faster.)</TD>
- <TD VAlign="top"> - </TD>
- </TR>
+
 </table>

 <h3>Complexity guarantees</h3>

- All three functions are at most amortized linear time. For most practical
- purposes, one can expect <code>boost::begin(a)</code>, <code>boost::end(a)</code> and <code>boost::empty(a)</code>
- to be amortized constant time.
+ <code>boost::end(a)</code> is at most amortized linear time, <code>boost::begin(a)</code> is
+ amortized constant time. For most practical
+ purposes, one can expect both to be amortized constant time.

 <h3>Invariants</h3>
 <Table border>
@@ -227,14 +214,17 @@

 <h3>See also</h3>
- 
- Container
- 
- <a href="boost_range.html#boost::range_value">implementation of
+ <a
+ href="boost_range.html#minimal_interface">Extending the library for UDTs </a>
+ <a href="boost_range.html#boost::rang_difference">Implementation of
 metafunctions </a>

- <a href="boost_range.html#begin">implementation of
+ <a href="boost_range.html#begin">Implementation of
 functions </a>
+ 
+ Container
+ 
+

 <hr>
 <a name=forward_range><h2>Forward Range</h2>
@@ -261,76 +251,8 @@
 <h3>Refinement of</h3> <a href="#single_pass_range">Single Pass
Range</a>

- <h3>Associated types</h3>
-
- <table cellpadding="5" border="1">
- <TR>
- <TD VAlign="top">Distance type</TD>
- <TD VAlign="top"><code>boost::range_difference<X>::type</code></TD>
- <TD VAlign="top">A signed integral type used to represent the distance between
- two of the Range'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"><code>boost::range_size<X>::type</code></TD>
- <TD VAlign="top">An unsigned integral type that can represent any nonnegative
- value of the Range's distance type.</TD>
- </tr>
- </table>
-
- <h3>Valid expressions</h3>
-
- <table border="1" cellpadding="5">
- <tr>
- <th>Name</th>
- <th>Expression</th>
- <th>Return type</th>
- </tr>
- <TR>
- <TD VAlign="top">Size of range</TD>
- <TD VAlign="top"><code>boost::size(a)</code></TD>
- <TD VAlign="top"><code>boost::range_size<X>::type</code></TD>
- </TR>
- </table>
-
- <h3>Expression semantics </h3>
-
- <table border="1" cellpadding="5">
- <TR>
- <TH>Expression</TH>
- <TH>Semantics</TH>
- <TH>Postcondition</TH>
- </TR>
- <tr>
- <TD VAlign="top"><code>boost::size(a)</code></TD>
- <TD VAlign="top">Returns the size of the Range, that is, its number
-of elements. Note <code>boost::size(a) == 0u</code> is equivalent to
-<code>boost::empty(a).</code></TD>
- <TD VAlign="top"><code>boost::size(a) >= 0</TD>
- </TR>
- </table>
-
- <h3>Complexity guarantees</h3>
-
- <code>boost::size(a)</code> is at most amortized linear time.
-
- <h3>Invariants</h3>
- 
- <Table border="1" cellpadding="5">
- <TR>
- <TD VAlign="top">Range size</TD>
- <TD VAlign="top"><code>boost::size(a)</code> is equal to the distance from <code>boost::begin(a)</code>
- to <code>boost::end(a)</code>.</TD> </table>
- 
-
- <h3>See also</h3>
- <a href="boost_range.html#boost::range_difference">implementation of
- metafunctions </a>
-
- <a href="boost_range.html#size">implementation of
- functions </a>
-
+ 
+
 <hr>

 <a name="bidirectional_range"><h2>Bidirectional Range</h2>
@@ -356,83 +278,8 @@

 <h3>Refinement of</h3> Forward Range

- <h3>Associated types</h3>
-
- <Table border>
- <TR>
- <TD VAlign="top">Reverse Iterator type</TD>
- <TD VAlign="top"><code>boost::range_reverse_iterator<X>::type</code></TD>
- <TD VAlign="top">The type of iterator used to iterate through a Range's elements
- in reverse order. The iterator's value type is expected to be the Range's value
- type. A conversion from the reverse iterator type to the const reverse iterator
- type must exist. </TD>
- </TR>
- <TR>
- <TD VAlign="top">Const reverse iterator type</TD>
- <TD
-VAlign="top"><code>boost::range_const_reverse_iterator&ltX>::type</code></TD>
- <TD VAlign="top">A type of reverse iterator that may be used to examine, but not
- to modify, a Range's elements.</TD>
- </TR>
- </table>
-
-
- <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">Beginning of range</TD>
- <TD VAlign="top"><code>boost::rbegin(a)</code></TD>
- <TD VAlign="top"><code>boost::range_reverse_iterator<X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_const_reverse_iterator<X>::type</code>
-otherwise.</TD>
- <TD VAlign="top">Equivalent to
-<code>boost::range_reverse_iterator<X>::type(boost::end(a))</code>.</TD> </TR>
- <TR>
- <TD VAlign="top">End of range</TD>
- <TD VAlign="top"><code>boost::rend(a)</code></TD>
- <TD VAlign="top"><code>boost::range_reverse_iterator<X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_const_reverse_iterator<X>::type</code>
-otherwise.</TD>
- <TD VAlign="top">Equivalent to
-<code>boost::range_reverse_iterator<X>::type(boost::begin(a))</code>.</TD> </tr>
-
- </table>
-
- <h3>Complexity guarantees</h3>
-
- <code>boost::rbegin(a)</code> has the same complexity as <code>boost::end(a)</code> and <code>boost::rend(a)</code>
- has the same complexity as <code>boost::begin(a)</code> from <a
- href="#forward_range">Forward Range</a>.
-
- <h3>Invariants</h3>
- 
- <Table border="1" cellpadding="5">
- <TR>
- <TD VAlign="top">Valid reverse range</TD>
- <TD VAlign="top">For any Bidirectional Range <code>a</code>, <code>[boost::rbegin(a),boost::rend(a))</code>
- is a valid range, that is, <code>boost::rend(a)</code> is reachable from <code>boost::rbegin(a)</code>
- in a finite number of increments.</TD>
- </TR>
- <TR>
- <TD VAlign="top">Completeness</TD>
- <TD VAlign="top">An algorithm that iterates through the range <code>[boost::rbegin(a),boost::rend(a))</code>
- will pass through every element of <code>a</code>.</TD>
- </tr>
- </table>
- 
-
- <h3>See also</h3>
- implementation of metafunctions 
-
- <a href="boost_range.html#rbegin">implementation of
- functions </a>
+
+

 <hr>

@@ -455,7 +302,7 @@
 <a name=concept_checking><h2>Concept Checking</h2>

 Each of the range concepts has a corresponding concept checking
- class in the file boost/range/concepts.hpp. These classes may be
+ class in the file <code><boost/range/concepts.hpp></codE>. These classes may be
 used in conjunction with the <a
 href="../../concept_check/concept_check.htm">Boost Concept
 Check</a> library to insure that the type of a template parameter
@@ -529,7 +376,7 @@
 <TD><A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>
 </TR>
 <tr >
- <TD nowrap>Copyright &copy 2004</TD>
+ <TD nowrap>Copyright &copy 2004-2007</TD>
 <TD>Thorsten Ottosen.
 </TABLE>

Modified: trunk/libs/range/doc/utility_class.html
==============================================================================
--- trunk/libs/range/doc/utility_class.html (original)
+++ trunk/libs/range/doc/utility_class.html 2007-11-09 05:27:42 EST (Fri, 09 Nov 2007)
@@ -59,19 +59,16 @@
 
 If the template argument is not a model of Forward Traversal Iterator, one can
 still use a subset of the interface. In particular, <code>size()</code> requires
- Forward Traversal Iterators whereas <code>empty()</code> only requires Single
+ Random Access Iterators whereas <code>empty()</code> only requires Single
 Pass Iterators.
 

 
 Recall that many default constructed iterators
 are singular and hence can only be assigned, but not compared or
- incremented or anything. However, if one creates a default constructed
- <code>iterator_range</code>, then one
- can still call all its member functions. This means that the
- <code>iterator_range</code> will still be usable in many contexts even
- though the iterators underneath are not.
- 
+ incremented or anything. Likewise, if one creates a default constructed
+ <code>iterator_range</code>, then one have to be careful about not doing
+ anything besides copying. 

 <h3>Synopsis</h3>

@@ -82,9 +79,6 @@
 class iterator_range
 {
 public: // Forward Range types
- typedef ... value_type;
- typedef ... difference_type;
- typedef ... size_type;
 typedef ForwardTraversalIterator iterator;
 typedef ForwardTraversalIterator const_iterator;

@@ -117,10 +111,11 @@
class=special>( const iterator_range& ) const;
- value_type& front() const;
- value_type& back() const;
+ referencefront() const;
+ reference back() const;
 // for Random Access Range only: 
 value_type& operator[]( size_type at ) const;
+ value_typecial>& operator()( size_type at ) const;
 };

 // stream output

Next message: john_at_[hidden]: "[Boost-commit] svn:boost r40963 - trunk/libs/math/test"
Previous message: john_at_[hidden]: "[Boost-commit] svn:boost r40961 - in trunk/libs/math/doc/octonion: . html html/boost_octonions html/boost_octonions/octonions"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk