|
|
Boost-Commit : |
From: stipe_at_[hidden]
Date: 2007-08-09 21:16:18
Author: srajko
Date: 2007-08-09 21:16:16 EDT (Thu, 09 Aug 2007)
New Revision: 38556
URL: http://svn.boost.org/trac/boost/changeset/38556
Log:
add internal links to function / operator reference
Text files modified:
sandbox/boost_docs/trunk/libs/smart_ptr/doc/Jamfile.v2 | 11 ++++
sandbox/boost_docs/trunk/libs/smart_ptr/doc/intrusive_ptr.qbk | 78 +++++++++++++++++++++++------------
sandbox/boost_docs/trunk/libs/smart_ptr/doc/scoped_ptr.qbk | 35 ++++++++-------
sandbox/boost_docs/trunk/libs/smart_ptr/doc/shared_array.qbk | 56 ++++++++++++++++++-------
sandbox/boost_docs/trunk/libs/smart_ptr/doc/shared_ptr.qbk | 87 +++++++++++++++++++++++++--------------
sandbox/boost_docs/trunk/libs/smart_ptr/doc/smart_ptr.qbk | 2
sandbox/boost_docs/trunk/libs/smart_ptr/doc/weak_ptr.qbk | 57 +++++++++++++++++++------
7 files changed, 216 insertions(+), 110 deletions(-)
Modified: sandbox/boost_docs/trunk/libs/smart_ptr/doc/Jamfile.v2
==============================================================================
--- sandbox/boost_docs/trunk/libs/smart_ptr/doc/Jamfile.v2 (original)
+++ sandbox/boost_docs/trunk/libs/smart_ptr/doc/Jamfile.v2 2007-08-09 21:16:16 EDT (Thu, 09 Aug 2007)
@@ -10,6 +10,13 @@
:
smart_ptr
:
+ # pull in the online .css and images
+ <xsl:param>project.root=http://beta.boost.org/development
+ # without the next line, build complains
+ <xsl:param>annotation.support=1
+ # pulled this from the doc_test Jamfile
+ <xsl:param>quickbook.source.style.show="'true'"
+
# HTML options first:
# Use graphics not text for navigation:
<xsl:param>navig.graphics=1
@@ -24,9 +31,9 @@
# How far down we go with TOC's
<xsl:param>generate.section.toc.level=10
# Logo location:
- <xsl:param>boost.logo=../boost.png
+# <xsl:param>boost.logo=../boost.png
- <xsl:param>boost.root=http://www.boost.org
+# <xsl:param>boost.root=http://www.boost.org
# The page style
<xsl:param>page.style="'website'"
Modified: sandbox/boost_docs/trunk/libs/smart_ptr/doc/intrusive_ptr.qbk
==============================================================================
--- sandbox/boost_docs/trunk/libs/smart_ptr/doc/intrusive_ptr.qbk (original)
+++ sandbox/boost_docs/trunk/libs/smart_ptr/doc/intrusive_ptr.qbk 2007-08-09 21:16:16 EDT (Thu, 09 Aug 2007)
@@ -1,5 +1,29 @@
[section:intrusive_ptr intrusive_ptr class template]
+[def __const_pointer_cast__ [link smart_ptr.reference.intrusive_ptr.members.const_pointer_cast const_pointer_cast]]
+[def __dynamic_pointer_cast__ [link smart_ptr.reference.intrusive_ptr.members.dynamic_pointer_cast dynamic_pointer_cast]]
+[def __ctor__ [link smart_ptr.reference.intrusive_ptr.members.constructors intrusive_ptr]]
+[def __destructor__ [link smart_ptr.reference.intrusive_ptr.members.destructor ~intrusive_ptr]]
+[def __element_type__ [link smart_ptr.reference.intrusive_ptr.members.element_type element_type]]
+[def __free_swap__ [link smart_ptr.reference.intrusive_ptr.free_functions.swap swap]]
+[def __get__ [link smart_ptr.reference.intrusive_ptr.members.get get]]
+[def __get_deleter__ [link smart_ptr.reference.intrusive_ptr.members.get_deleter get_deleter]]
+[def __get_pointer__ [link smart_ptr.reference.intrusive_ptr.members.get_pointer get_pointer]]
+[def __operatorstar__ [link smart_ptr.reference.intrusive_ptr.members.indirection operator*]]
+[def __operatorarrow__ [link smart_ptr.reference.intrusive_ptr.members.indirection operator->]]
+[def __operatorconv__ [link smart_ptr.reference.intrusive_ptr.members.conversions operator ['unspecified-bool-type]]]
+[def __operator_indexing__ [link smart_ptr.reference.intrusive_ptr.members.indexing operator\[\]]]
+[def __operator_assign__ [link smart_ptr.reference.intrusive_ptr.members.assignment operator=]]
+[def __operator_insertion__ [link smart_ptr.reference.intrusive_ptr.members.operator_insertion operator<<]]
+[def __operator_eq__ [link smart_ptr.reference.intrusive_ptr.members.comparison operator==]]
+[def __operator_ne__ [link smart_ptr.reference.intrusive_ptr.members.comparison operator!=]]
+[def __operator_lt__ [link smart_ptr.reference.intrusive_ptr.members.comparison operator<]]
+[def __reset__ [link smart_ptr.reference.intrusive_ptr.members.reset reset]]
+[def __unique__ [link smart_ptr.reference.intrusive_ptr.members.unique unique]]
+[def __use_count__ [link smart_ptr.reference.intrusive_ptr.members.use_count use_count]]
+[def __static_pointer_cast__ [link smart_ptr.reference.intrusive_ptr.members.static_pointer_cast static_pointer_cast]]
+[def __swap__ [link smart_ptr.reference.intrusive_ptr.members.swap swap]]
+
[section Introduction]
The [*intrusive_ptr] class template stores a pointer to an object with an embedded reference count. Every new [*intrusive_ptr] instance increments the reference count by using an unqualified call to the function intrusive_ptr_add_ref, passing it the pointer as an argument. Similarly, when an intrusive_ptr is destroyed, it calls intrusive_ptr_release; this function is responsible for destroying the object when its reference count drops to zero. The user is expected to provide suitable definitions of these two functions. On compilers that support argument-dependent lookup, intrusive_ptr_add_ref and intrusive_ptr_release should be defined in the namespace that corresponds to their parameter; otherwise, the definitions need to go in namespace boost.
@@ -23,66 +47,66 @@
public:
- typedef T [@#element_type element_type];
+ typedef T __element_type__;
- [@#constructors intrusive_ptr](); // never throws
- [@#constructors intrusive_ptr](T * p, bool add_ref = true);
+ __ctor__(); // never throws
+ __ctor__(T * p, bool add_ref = true);
- [@#constructors intrusive_ptr](intrusive_ptr const & r);
- template<class Y> [@#constructors intrusive_ptr](intrusive_ptr<Y> const & r);
+ __ctor__(intrusive_ptr const & r);
+ template<class Y> __ctor__(intrusive_ptr<Y> const & r);
- [@#destructor ~intrusive_ptr]();
+ __destructor__();
- intrusive_ptr & [@#assignment operator=](intrusive_ptr const & r);
- template<class Y> intrusive_ptr & [@#assignment operator=](intrusive_ptr<Y> const & r);
- intrusive_ptr & [@#assignment operator=](T * r);
+ intrusive_ptr & __operator_assign__(intrusive_ptr const & r);
+ template<class Y> intrusive_ptr & __operator_assign__(intrusive_ptr<Y> const & r);
+ intrusive_ptr & __operator_assign__(T * r);
void __reset__(T * r);
- T & [@#indirection operator*]() const; // never throws
- T * [@#indirection operator->]() const; // never throws
- T * [@#get get]() const; // never throws
+ T & __operatorstar__() const; // never throws
+ T * __operatorarrow__() const; // never throws
+ T * __get__() const; // never throws
- operator [@#conversions ['unspecified-bool-type]]() const; // never throws
+ __operatorconv__() const; // never throws
- void [@#swap swap](intrusive_ptr & b); // never throws
+ void __swap__(intrusive_ptr & b); // never throws
};
template<class T, class U>
- bool [@#comparison operator==](intrusive_ptr<T> const & a, intrusive_ptr<U> const & b); // never throws
+ bool __operator_eq__(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b); // never throws
template<class T, class U>
- bool [@#comparison operator!=](intrusive_ptr<T> const & a, intrusive_ptr<U> const & b); // never throws
+ bool __operator_ne__(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b); // never throws
template<class T>
- bool [@#comparison operator==](intrusive_ptr<T> const & a, T * b); // never throws
+ bool __operator_eq__(intrusive_ptr<T> const & a, T * b); // never throws
template<class T>
- bool [@#comparison operator!=](intrusive_ptr<T> const & a, T * b); // never throws
+ bool __operator_ne__(intrusive_ptr<T> const & a, T * b); // never throws
template<class T>
- bool [@#comparison operator==](T * a, intrusive_ptr<T> const & b); // never throws
+ bool __operator_eq__(T * a, intrusive_ptr<T> const & b); // never throws
template<class T>
- bool [@#comparison operator!=](T * a, intrusive_ptr<T> const & b); // never throws
+ bool __operator_ne__(T * a, intrusive_ptr<T> const & b); // never throws
template<class T, class U>
- bool [@#comparison operator<](intrusive_ptr<T> const & a, intrusive_ptr<U> const & b); // never throws
+ bool __operator_lt__(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b); // never throws
- template<class T> void [@#free-swap swap](intrusive_ptr<T> & a, intrusive_ptr<T> & b); // never throws
+ template<class T> void __free_swap__(intrusive_ptr<T> & a, intrusive_ptr<T> & b); // never throws
- template<class T> T * [@#get_pointer get_pointer](intrusive_ptr<T> const & p); // never throws
+ template<class T> T * __get_pointer__(intrusive_ptr<T> const & p); // never throws
template<class T, class U>
- intrusive_ptr<T> [@#static_pointer_cast static_pointer_cast](intrusive_ptr<U> const & r); // never throws
+ intrusive_ptr<T> __static_pointer_cast__(intrusive_ptr<U> const & r); // never throws
template<class T, class U>
- intrusive_ptr<T> [@#const_pointer_cast const_pointer_cast](intrusive_ptr<U> const & r); // never throws
+ intrusive_ptr<T> __const_pointer_cast__(intrusive_ptr<U> const & r); // never throws
template<class T, class U>
- intrusive_ptr<T> [@#dynamic_pointer_cast dynamic_pointer_cast](intrusive_ptr<U> const & r); // never throws
+ intrusive_ptr<T> __dynamic_pointer_cast__(intrusive_ptr<U> const & r); // never throws
template<class E, class T, class Y>
- std::basic_ostream<E, T> & [@#insertion-operator operator<<] (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p);
+ std::basic_ostream<E, T> & __operator_insertion__ (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p);
}
Modified: sandbox/boost_docs/trunk/libs/smart_ptr/doc/scoped_ptr.qbk
==============================================================================
--- sandbox/boost_docs/trunk/libs/smart_ptr/doc/scoped_ptr.qbk (original)
+++ sandbox/boost_docs/trunk/libs/smart_ptr/doc/scoped_ptr.qbk 2007-08-09 21:16:16 EDT (Thu, 09 Aug 2007)
@@ -3,7 +3,9 @@
[def __ctor__ [link smart_ptr.reference.scoped_ptr.members.constructors scoped_ptr]]
[def __destructor__ [link smart_ptr.reference.scoped_ptr.members.destructor ~scoped_ptr]]
[def __operatorlbrb__ [link smart_ptr.reference.scoped_ptr.members.subscripting operator\[\]]]
-[def __get__ [link smart_ptr.reference.scoped_ptr.members.get]]
+[def __operatorstar__ [link smart_ptr.reference.scoped_ptr.members.indirection operator*]]
+[def __operatorarrow__ [link smart_ptr.reference.scoped_ptr.members.indirection operator->]]
+[def __get__ [link smart_ptr.reference.scoped_ptr.members.get get]]
[def __operatorconv__ [link smart_ptr.reference.scoped_ptr.members.conversions operator ['unspecified-bool-type]]]
[def __swap__ [link smart_ptr.reference.scoped_ptr.members.swap swap]]
[def __free_swap__ [link smart_ptr.reference.scoped_ptr.free_functions.swap swap]]
@@ -35,23 +37,23 @@
template<class T> class scoped_ptr : __noncopyable__ {
public:
- typedef T [@#element_type element_type];
+ typedef T __element_type__;
- explicit [@#constructors scoped_ptr](T * p = 0); // never throws
- [@#destructor ~scoped_ptr](); // never throws
+ explicit __ctor__(T * p = 0); // never throws
+ __destructor__(); // never throws
void __reset__(T * p = 0); // never throws
- T & [@#indirection operator*]() const; // never throws
- T * [@#indirection operator->]() const; // never throws
- T * [@#get get]() const; // never throws
+ T & __operatorstar__() const; // never throws
+ T * __operatorarrow__() const; // never throws
+ T * __get__() const; // never throws
- operator [@#conversions ['unspecified-bool-type]]() const; // never throws
+ __operatorconv__() const; // never throws
- void [@#swap swap](scoped_ptr & b); // never throws
+ void __swap__(scoped_ptr & b); // never throws
};
- template<class T> void [@#free-swap swap](scoped_ptr<T> & a, scoped_ptr<T> & b); // never throws
+ template<class T> void __free_swap__(scoped_ptr<T> & a, scoped_ptr<T> & b); // never throws
}
@@ -103,7 +105,7 @@
[heading conversions]
- operator ['unspecified-bool-type] () const; // never throws
+ operator ``['unspecified-bool-type]`` () const; // never throws
Returns an unspecified value that, when used in boolean contexts, is equivalent to [^get() != 0].
@@ -127,7 +129,7 @@
[section Example]
- Here's an example that uses __scoped_ptr__.
+Here's an example that uses __scoped_ptr__.
#include <boost/scoped_ptr.hpp>
#include <iostream>
@@ -151,13 +153,12 @@
The example program produces the beginning of a child's nursery rhyme:
-[:
[pre
-1
-2
-Buckle my shoe
-]
+ 1
+ 2
+ Buckle my shoe
]
+
[endsect]
[section Rationale]
Modified: sandbox/boost_docs/trunk/libs/smart_ptr/doc/shared_array.qbk
==============================================================================
--- sandbox/boost_docs/trunk/libs/smart_ptr/doc/shared_array.qbk (original)
+++ sandbox/boost_docs/trunk/libs/smart_ptr/doc/shared_array.qbk 2007-08-09 21:16:16 EDT (Thu, 09 Aug 2007)
@@ -1,5 +1,29 @@
[section:shared_array shared_array class template]
+[def __const_pointer_cast__ [link smart_ptr.reference.shared_array.members.const_pointer_cast const_pointer_cast]]
+[def __dynamic_pointer_cast__ [link smart_ptr.reference.shared_array.members.dynamic_pointer_cast dynamic_pointer_cast]]
+[def __ctor__ [link smart_ptr.reference.shared_array.members.constructors shared_array]]
+[def __destructor__ [link smart_ptr.reference.shared_array.members.destructor ~shared_array]]
+[def __element_type__ [link smart_ptr.reference.shared_array.members.element_type element_type]]
+[def __free_swap__ [link smart_ptr.reference.shared_array.free_functions.swap swap]]
+[def __get__ [link smart_ptr.reference.shared_array.members.get get]]
+[def __get_deleter__ [link smart_ptr.reference.shared_array.members.get_deleter get_deleter]]
+[def __get_pointer__ [link smart_ptr.reference.shared_array.members.get_pointer get_pointer]]
+[def __operatorstar__ [link smart_ptr.reference.shared_array.members.indirection operator*]]
+[def __operatorarrow__ [link smart_ptr.reference.shared_array.members.indirection operator->]]
+[def __operatorconv__ [link smart_ptr.reference.shared_array.members.conversions operator ['unspecified-bool-type]]]
+[def __operator_indexing__ [link smart_ptr.reference.shared_array.members.indexing operator\[\]]]
+[def __operator_assign__ [link smart_ptr.reference.shared_array.members.assignment operator=]]
+[def __operator_insertion__ [link smart_ptr.reference.shared_array.members.operator_insertion operator<<]]
+[def __operator_eq__ [link smart_ptr.reference.shared_array.members.comparison operator==]]
+[def __operator_ne__ [link smart_ptr.reference.shared_array.members.comparison operator!=]]
+[def __operator_lt__ [link smart_ptr.reference.shared_array.members.comparison operator<]]
+[def __reset__ [link smart_ptr.reference.shared_array.members.reset reset]]
+[def __unique__ [link smart_ptr.reference.shared_array.members.unique unique]]
+[def __use_count__ [link smart_ptr.reference.shared_array.members.use_count use_count]]
+[def __static_pointer_cast__ [link smart_ptr.reference.shared_array.members.static_pointer_cast static_pointer_cast]]
+[def __swap__ [link smart_ptr.reference.shared_array.members.swap swap]]
+
[section Introduction]
The __shared_array__ class template stores a pointer to a dynamically allocated array. (Dynamically allocated array are allocated with the C++ [*new[]] expression.) The object pointed to is guaranteed to be deleted when the last __shared_array__ pointing to it is destroyed or reset.
@@ -23,38 +47,38 @@
template<class T> class shared_array {
public:
- typedef T [@#element_type element_type];
+ typedef T __element_type__;
- explicit [@#constructors shared_array](T * p = 0);
- template<class D> [@#constructors shared_array](T * p, D d);
- [@#destructor ~shared_array](); // never throws
+ explicit __ctor__(T * p = 0);
+ template<class D> __ctor__(T * p, D d);
+ __destructor__(); // never throws
- [@#constructors shared_array](shared_array const & r); // never throws
+ __ctor__(shared_array const & r); // never throws
- shared_array & [@#assignment operator=](shared_array const & r); // never throws
+ shared_array & __operator_assign__(shared_array const & r); // never throws
void __reset__(T * p = 0);
template<class D> void __reset__(T * p, D d);
- T & [@#indexing operator[]](std::ptrdiff_t i) const() const; // never throws
- T * [@#get get]() const; // never throws
+ T & __operator_indexing__(std::ptrdiff_t i) const() const; // never throws
+ T * __get__() const; // never throws
- bool [@#unique unique]() const; // never throws
- long [@#use_count use_count]() const; // never throws
+ bool __unique__() const; // never throws
+ long __use_count__() const; // never throws
- operator [@#conversions ['unspecified-bool-type]]() const; // never throws
+ __operatorconv__() const; // never throws
- void [@#swap swap](shared_array<T> & b); // never throws
+ void __swap__(shared_array<T> & b); // never throws
};
template<class T>
- bool [@#comparison operator==](shared_array<T> const & a, shared_array<T> const & b); // never throws
+ bool __operator_eq__(shared_array<T> const & a, shared_array<T> const & b); // never throws
template<class T>
- bool [@#comparison operator!=](shared_array<T> const & a, shared_array<T> const & b); // never throws
+ bool __operator_ne__(shared_array<T> const & a, shared_array<T> const & b); // never throws
template<class T>
- bool [@#comparison operator<](shared_array<T> const & a, shared_array<T> const & b); // never throws
+ bool __operator_lt__(shared_array<T> const & a, shared_array<T> const & b); // never throws
- template<class T> void [@#free-swap swap](shared_array<T> & a, shared_array<T> & b); // never throws
+ template<class T> void __free_swap__(shared_array<T> & a, shared_array<T> & b); // never throws
}
Modified: sandbox/boost_docs/trunk/libs/smart_ptr/doc/shared_ptr.qbk
==============================================================================
--- sandbox/boost_docs/trunk/libs/smart_ptr/doc/shared_ptr.qbk (original)
+++ sandbox/boost_docs/trunk/libs/smart_ptr/doc/shared_ptr.qbk 2007-08-09 21:16:16 EDT (Thu, 09 Aug 2007)
@@ -1,5 +1,28 @@
[section:shared_ptr shared_ptr class template]
+[def __const_pointer_cast__ [link smart_ptr.reference.shared_ptr.members.const_pointer_cast const_pointer_cast]]
+[def __dynamic_pointer_cast__ [link smart_ptr.reference.shared_ptr.members.dynamic_pointer_cast [def __ctor__ [link smart_ptr.reference.shared_ptr.members.constructors shared_ptr]]
+[def __destructor__ [link smart_ptr.reference.shared_ptr.members.destructor ~shared_ptr]]
+[def __element_type__ [link smart_ptr.reference.shared_ptr.members.element_type element_type]]
+[def __free_swap__ [link smart_ptr.reference.shared_ptr.free_functions.swap swap]]
+[def __get__ [link smart_ptr.reference.shared_ptr.members.get get]]
+[def __get_deleter__ [link smart_ptr.reference.shared_ptr.members.get_deleter get_deleter]]
+[def __get_pointer__ [link smart_ptr.reference.shared_ptr.members.get_pointer get_pointer]]
+[def __operatorstar__ [link smart_ptr.reference.shared_ptr.members.indirection operator*]]
+[def __operatorarrow__ [link smart_ptr.reference.shared_ptr.members.indirection operator->]]
+[def __operatorconv__ [link smart_ptr.reference.shared_ptr.members.conversions operator ['unspecified-bool-type]]]
+dynamic_pointer_cast]]
+[def __operator_assign__ [link smart_ptr.reference.shared_ptr.members.assignment operator=]]
+[def __operator_insertion__ [link smart_ptr.reference.shared_ptr.members.operator_insertion operator<<]]
+[def __operator_eq__ [link smart_ptr.reference.shared_ptr.members.comparison operator==]]
+[def __operator_ne__ [link smart_ptr.reference.shared_ptr.members.comparison operator!=]]
+[def __operator_lt__ [link smart_ptr.reference.shared_ptr.members.comparison operator<]]
+[def __reset__ [link smart_ptr.reference.shared_ptr.members.reset reset]]
+[def __unique__ [link smart_ptr.reference.shared_ptr.members.unique unique]]
+[def __use_count__ [link smart_ptr.reference.shared_ptr.members.use_count use_count]]
+[def __static_pointer_cast__ [link smart_ptr.reference.shared_ptr.members.static_pointer_cast static_pointer_cast]]
+[def __swap__ [link smart_ptr.reference.shared_ptr.members.swap swap]]
+
[section Introduction]
The __shared_ptr__ class template stores a pointer to a dynamically allocated object, typically with a C++ new-expression. The object pointed to is guaranteed to be deleted when the last __shared_ptr__ pointing to it is destroyed or reset. See the __example__.
@@ -63,23 +86,23 @@
public:
- typedef T [@#element_type element_type];
+ typedef T __element_type__;
- [@#constructors shared_ptr](); // never throws
- template<class Y> explicit [@#constructors shared_ptr](Y * p);
- template<class Y, class D> [@#constructors shared_ptr](Y * p, D d);
+ __ctor__(); // never throws
+ template<class Y> explicit __ctor__(Y * p);
+ template<class Y, class D> __ctor__(Y * p, D d);
template<class Y, class D, class A> [@#allocator_constructor shared_ptr](Y * p, D d, A a);
- [@#destructor ~shared_ptr](); // never throws
+ __destructor__(); // never throws
- [@#constructors shared_ptr](shared_ptr const & r); // never throws
- template<class Y> [@#constructors shared_ptr](shared_ptr<Y> const & r); // never throws
- template<class Y> [@#constructors shared_ptr](shared_ptr<Y> const & r, T * p); // never throws
- template<class Y> explicit [@#constructors shared_ptr](__weak_ptr__<Y> const & r);
- template<class Y> explicit [@#constructors shared_ptr](std::auto_ptr<Y> & r);
-
- shared_ptr & [@#assignment operator=](shared_ptr const & r); // never throws
- template<class Y> shared_ptr & [@#assignment operator=](shared_ptr<Y> const & r); // never throws
- template<class Y> shared_ptr & [@#assignment operator=](std::auto_ptr<Y> & r);
+ __ctor__(shared_ptr const & r); // never throws
+ template<class Y> __ctor__(shared_ptr<Y> const & r); // never throws
+ template<class Y> __ctor__(shared_ptr<Y> const & r, T * p); // never throws
+ template<class Y> explicit __ctor__(__weak_ptr__<Y> const & r);
+ template<class Y> explicit __ctor__(std::auto_ptr<Y> & r);
+
+ shared_ptr & __operator_assign__(shared_ptr const & r); // never throws
+ template<class Y> shared_ptr & __operator_assign__(shared_ptr<Y> const & r); // never throws
+ template<class Y> shared_ptr & __operator_assign__(std::auto_ptr<Y> & r);
void __reset__(); // never throws
template<class Y> void __reset__(Y * p);
@@ -87,45 +110,45 @@
template<class Y, class D, class A> void __reset__(Y * p, D d, A a);
template<class Y> void __reset__(shared_ptr<Y> const & r, T * p); // never throws
- T & [@#indirection operator*]() const; // never throws
- T * [@#indirection operator->]() const; // never throws
- T * [@#get get]() const; // never throws
+ T & __operatorstar__() const; // never throws
+ T * __operatorarrow__() const; // never throws
+ T * __get__() const; // never throws
- bool [@#unique unique]() const; // never throws
- long [@#use_count use_count]() const; // never throws
+ bool __unique__() const; // never throws
+ long __use_count__() const; // never throws
- operator [@#conversions ['unspecified-bool-type]]() const; // never throws
+ __operatorconv__() const; // never throws
- void [@#swap swap](shared_ptr & b); // never throws
+ void __swap__(shared_ptr & b); // never throws
};
template<class T, class U>
- bool [@#comparison operator==](shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws
+ bool __operator_eq__(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws
template<class T, class U>
- bool [@#comparison operator!=](shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws
+ bool __operator_ne__(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws
template<class T, class U>
- bool [@#comparison operator<](shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws
+ bool __operator_lt__(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws
- template<class T> void [@#free-swap swap](shared_ptr<T> & a, shared_ptr<T> & b); // never throws
+ template<class T> void __free_swap__(shared_ptr<T> & a, shared_ptr<T> & b); // never throws
- template<class T> T * [@#get_pointer get_pointer](shared_ptr<T> const & p); // never throws
+ template<class T> T * __get_pointer__(shared_ptr<T> const & p); // never throws
template<class T, class U>
- shared_ptr<T> [@#static_pointer_cast static_pointer_cast](shared_ptr<U> const & r); // never throws
+ shared_ptr<T> __static_pointer_cast__(shared_ptr<U> const & r); // never throws
template<class T, class U>
- shared_ptr<T> [@#const_pointer_cast const_pointer_cast](shared_ptr<U> const & r); // never throws
+ shared_ptr<T> __const_pointer_cast__(shared_ptr<U> const & r); // never throws
template<class T, class U>
- shared_ptr<T> [@#dynamic_pointer_cast dynamic_pointer_cast](shared_ptr<U> const & r); // never throws
+ shared_ptr<T> __dynamic_pointer_cast__(shared_ptr<U> const & r); // never throws
template<class E, class T, class Y>
- std::basic_ostream<E, T> & [@#insertion-operator operator<<] (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p);
+ std::basic_ostream<E, T> & __operator_insertion__ (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p);
template<class D, class T>
- D * [@#get_deleter get_deleter](shared_ptr<T> const & p);
+ D * __get_deleter__(shared_ptr<T> const & p);
}
[endsect]
@@ -392,7 +415,7 @@
[*Notes:] This conversion operator allows __shared_ptr__ objects to be used in boolean contexts, like [^if (p && p->valid()) {}]. The actual target type is typically a pointer to a member function, avoiding many of the implicit conversion pitfalls.
]
-[The conversion to bool is not merely syntactic sugar. It allows shared_ptrs to be declared in conditions when using [@#dynamic_pointer_cast dynamic_pointer_cast] or [@weak_ptr.htm#lock weak_ptr::lock].]
+[The conversion to bool is not merely syntactic sugar. It allows shared_ptrs to be declared in conditions when using __dynamic_pointer_cast__ or [@weak_ptr.htm#lock weak_ptr::lock].]
[heading swap]
Modified: sandbox/boost_docs/trunk/libs/smart_ptr/doc/smart_ptr.qbk
==============================================================================
--- sandbox/boost_docs/trunk/libs/smart_ptr/doc/smart_ptr.qbk (original)
+++ sandbox/boost_docs/trunk/libs/smart_ptr/doc/smart_ptr.qbk 2007-08-09 21:16:16 EDT (Thu, 09 Aug 2007)
@@ -1,4 +1,4 @@
-[library smart_ptr
+[article smart_ptr
[quickbook 1.4]
[copyright 1999 Greg Colvin and Beman Dawes, 2002 Darin Adler, 2002 Peter Dimov]
[purpose Five smart pointer class templates, from Greg Colvin, Beman Dawes, Peter Dimov, and Darin Adler.]
Modified: sandbox/boost_docs/trunk/libs/smart_ptr/doc/weak_ptr.qbk
==============================================================================
--- sandbox/boost_docs/trunk/libs/smart_ptr/doc/weak_ptr.qbk (original)
+++ sandbox/boost_docs/trunk/libs/smart_ptr/doc/weak_ptr.qbk 2007-08-09 21:16:16 EDT (Thu, 09 Aug 2007)
@@ -1,5 +1,32 @@
[section:weak_ptr weak_ptr class template]
+[def __const_pointer_cast__ [link smart_ptr.reference.weak_ptr.members.const_pointer_cast const_pointer_cast]]
+[def __dynamic_pointer_cast__ [link smart_ptr.reference.weak_ptr.members.dynamic_pointer_cast dynamic_pointer_cast]]
+[def __ctor__ [link smart_ptr.reference.weak_ptr.members.constructors weak_ptr]]
+[def __destructor__ [link smart_ptr.reference.weak_ptr.members.destructor ~weak_ptr]]
+[def __element_type__ [link smart_ptr.reference.weak_ptr.members.element_type element_type]]
+[def __free_swap__ [link smart_ptr.reference.weak_ptr.free_functions.swap swap]]
+[def __get__ [link smart_ptr.reference.weak_ptr.members.get get]]
+[def __get_deleter__ [link smart_ptr.reference.weak_ptr.members.get_deleter get_deleter]]
+[def __get_pointer__ [link smart_ptr.reference.weak_ptr.members.get_pointer get_pointer]]
+[def __operatorstar__ [link smart_ptr.reference.weak_ptr.members.indirection operator*]]
+[def __operatorarrow__ [link smart_ptr.reference.weak_ptr.members.indirection operator->]]
+[def __operatorconv__ [link smart_ptr.reference.weak_ptr.members.conversions operator ['unspecified-bool-type]]]
+[def __operator_indexing__ [link smart_ptr.reference.weak_ptr.members.indexing operator\[\]]]
+[def __operator_assign__ [link smart_ptr.reference.weak_ptr.members.assignment operator=]]
+[def __operator_insertion__ [link smart_ptr.reference.weak_ptr.members.operator_insertion operator<<]]
+[def __operator_eq__ [link smart_ptr.reference.weak_ptr.members.comparison operator==]]
+[def __operator_ne__ [link smart_ptr.reference.weak_ptr.members.comparison operator!=]]
+[def __operator_lt__ [link smart_ptr.reference.weak_ptr.members.comparison operator<]]
+[def __reset__ [link smart_ptr.reference.weak_ptr.members.reset reset]]
+[def __unique__ [link smart_ptr.reference.weak_ptr.members.unique unique]]
+[def __use_count__ [link smart_ptr.reference.weak_ptr.members.use_count use_count]]
+[def __static_pointer_cast__ [link smart_ptr.reference.weak_ptr.members.static_pointer_cast static_pointer_cast]]
+[def __swap__ [link smart_ptr.reference.weak_ptr.members.swap swap]]
+
+[def __expired__ [link smart_ptr.reference.weak_ptr.members.expired expired]]
+[def __lock__ [link smart_ptr.reference.weak_ptr.members.lock lock]]
+
[section Introduction]
The [*weak_ptr] class template stores a "weak reference" to an object that's already managed by a __shared_ptr__. To access the object, a weak_ptr can be converted to a shared_ptr using [@shared_ptr.htm#constructors the shared_ptr constructor] or the member function [@#lock lock]. When the last __shared_ptr__ to the object goes away and the object is deleted, the attempt to obtain a shared_ptr from the [*weak_ptr] instances that refer to the deleted object will fail: the constructor will throw an exception of type boost::bad_weak_ptr, and weak_ptr::lock will return an empty shared_ptr.
@@ -47,33 +74,33 @@
template<class T> class weak_ptr {
public:
- typedef T [@#element_type element_type];
+ typedef T __element_type__;
- [@#default-constructor weak_ptr]();
+ __ctor__();
- template<class Y> [@#constructors weak_ptr](shared_ptr<Y> const & r);
- [@#constructors weak_ptr](weak_ptr const & r);
- template<class Y> [@#constructors weak_ptr](weak_ptr<Y> const & r);
+ template<class Y> __ctor__(shared_ptr<Y> const & r);
+ __ctor__(weak_ptr const & r);
+ template<class Y> __ctor__(weak_ptr<Y> const & r);
- [@#destructor ~weak_ptr]();
+ __destructor__();
- weak_ptr & [@#assignment operator=](weak_ptr const & r);
- template<class Y> weak_ptr & [@#assignment operator=](weak_ptr<Y> const & r);
- template<class Y> weak_ptr & [@#assignment operator=](shared_ptr<Y> const & r);
+ weak_ptr & __operator_assign__(weak_ptr const & r);
+ template<class Y> weak_ptr & __operator_assign__(weak_ptr<Y> const & r);
+ template<class Y> weak_ptr & __operator_assign__(shared_ptr<Y> const & r);
- long [@#use_count use_count]() const;
- bool [@#expired expired]() const;
- shared_ptr<T> [@#lock lock]() const;
+ long __use_count__() const;
+ bool __expired__() const;
+ shared_ptr<T> __lock__() const;
void __reset__();
- void [@#swap swap](weak_ptr<T> & b);
+ void __swap__(weak_ptr<T> & b);
};
template<class T, class U>
- bool [@#comparison operator<](weak_ptr<T> const & a, weak_ptr<U> const & b);
+ bool __operator_lt__(weak_ptr<T> const & a, weak_ptr<U> const & b);
template<class T>
- void [@#free-swap swap](weak_ptr<T> & a, weak_ptr<T> & b);
+ void __free_swap__(weak_ptr<T> & a, weak_ptr<T> & b);
}
[endsect]
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