2018-01-12 21:47:58 +01:00
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
< html xmlns = "http://www.w3.org/1999/xhtml" xml:lang = "en" lang = "en" >
< head >
< meta http-equiv = "Content-Type" content = "text/html; charset=utf-8" / >
2021-10-05 21:37:46 +02:00
< meta name = "generator" content = "Docutils 0.14: http://docutils.sourceforge.net/" / >
2018-01-12 21:47:58 +01:00
< title > Boost Pointer Container Library< / title >
< style type = "text/css" >
/*
2021-10-05 21:37:46 +02:00
:Author: David Goodger (goodger@python.org)
:Id: $Id: html4css1.css 7952 2016-07-26 18:15:59Z milde $
2018-01-12 21:47:58 +01:00
: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.
*/
2021-10-05 21:37:46 +02:00
/* used to remove borders from tables and images */
.borderless, table.borderless td, table.borderless th {
border: 0 }
table.borderless td, table.borderless th {
/* Override padding for "table.docutils td" with "! important".
The right padding separates the table cells. */
padding: 0 0.5em 0 0 ! important }
2018-01-12 21:47:58 +01:00
.first {
2021-10-05 21:37:46 +02:00
/* Override more specific margin styles with "! important". */
2018-01-12 21:47:58 +01:00
margin-top: 0 ! important }
.last, .with-subtitle {
margin-bottom: 0 ! important }
.hidden {
display: none }
2021-10-05 21:37:46 +02:00
.subscript {
vertical-align: sub;
font-size: smaller }
.superscript {
vertical-align: super;
font-size: smaller }
2018-01-12 21:47:58 +01:00
a.toc-backref {
text-decoration: none ;
color: black }
blockquote.epigraph {
margin: 2em 5em ; }
dl.docutils dd {
margin-bottom: 0.5em }
2021-10-05 21:37:46 +02:00
object[type="image/svg+xml"], object[type="application/x-shockwave-flash"] {
overflow: hidden;
}
2018-01-12 21:47:58 +01:00
/* 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,
2021-10-05 21:37:46 +02:00
div.warning p.admonition-title, .code .error {
2018-01-12 21:47:58 +01:00
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 {
2021-10-05 21:37:46 +02:00
margin-left: 2em ;
margin-right: 2em }
2018-01-12 21:47:58 +01:00
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 {
2021-10-05 21:37:46 +02:00
margin: 0 0 0.5em 1em ;
2018-01-12 21:47:58 +01:00
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% }
2021-10-05 21:37:46 +02:00
img.align-left, .figure.align-left, object.align-left, table.align-left {
clear: left ;
float: left ;
margin-right: 1em }
2018-01-12 21:47:58 +01:00
2021-10-05 21:37:46 +02:00
img.align-right, .figure.align-right, object.align-right, table.align-right {
clear: right ;
float: right ;
margin-left: 1em }
2018-01-12 21:47:58 +01:00
2021-10-05 21:37:46 +02:00
img.align-center, .figure.align-center, object.align-center {
display: block;
margin-left: auto;
margin-right: auto;
}
table.align-center {
margin-left: auto;
margin-right: auto;
}
.align-left {
text-align: left }
.align-center {
clear: both ;
text-align: center }
.align-right {
text-align: right }
/* reset inner alignment in figures */
div.align-right {
text-align: inherit }
/* div.align-center * { */
/* text-align: left } */
.align-top {
vertical-align: top }
.align-middle {
vertical-align: middle }
.align-bottom {
vertical-align: bottom }
2018-01-12 21:47:58 +01:00
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 ;
2021-10-05 21:37:46 +02:00
font: inherit }
2018-01-12 21:47:58 +01:00
2021-10-05 21:37:46 +02:00
pre.literal-block, pre.doctest-block, pre.math, pre.code {
2018-01-12 21:47:58 +01:00
margin-left: 2em ;
2021-10-05 21:37:46 +02:00
margin-right: 2em }
pre.code .ln { color: grey; } /* line numbers */
pre.code, code { background-color: #eeeeee }
pre.code .comment, code .comment { color: #5C6576 }
pre.code .keyword, code .keyword { color: #3B0D06; font-weight: bold }
pre.code .literal.string, code .literal.string { color: #0C5404 }
pre.code .name.builtin, code .name.builtin { color: #352B84 }
pre.code .deleted, code .deleted { background-color: #DEB0A1}
pre.code .inserted, code .inserted { background-color: #A3D289}
2018-01-12 21:47:58 +01:00
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 {
2021-10-05 21:37:46 +02:00
border-left: solid 1px gray;
margin-left: 1px }
2018-01-12 21:47:58 +01:00
table.docinfo {
margin: 2em 4em }
table.docutils {
margin-top: 0.5em ;
margin-bottom: 0.5em }
table.footnote {
2021-10-05 21:37:46 +02:00
border-left: solid 1px black;
margin-left: 1px }
2018-01-12 21:47:58 +01:00
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 }
2021-10-05 21:37:46 +02:00
/* "booktabs" style (no vertical lines) */
table.docutils.booktabs {
border: 0px;
border-top: 2px solid;
border-bottom: 2px solid;
border-collapse: collapse;
}
table.docutils.booktabs * {
border: 0px;
}
table.docutils.booktabs th {
border-bottom: thin solid;
text-align: left;
}
2018-01-12 21:47:58 +01:00
h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
font-size: 100% }
ul.auto-toc {
list-style-type: none }
< / style >
< / head >
< body >
< div class = "document" id = "boost-pointer-container-library" >
< h1 class = "title" > < img alt = "Boost" src = "boost.png" / > Pointer Container Library< / h1 >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "class-reversible-ptr-container" >
< h1 > Class < tt class = "docutils literal" > reversible_ptr_container< / tt > < / h1 >
< p > This class is not a real class that can be found in the library.
2018-01-12 21:47:58 +01:00
Its purpose is to present the general interface of all the pointer containers.< / p >
< p > < strong > Hierarchy:< / strong > < / p >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > < tt class = "docutils literal" > reversible_ptr_container< / tt > < ul >
< li > < a class = "reference external" href = "ptr_sequence_adapter.html" > ptr_sequence_adapter< / a > < ul >
< li > < a class = "reference external" href = "ptr_vector.html" > ptr_vector< / a > < / li >
< li > < a class = "reference external" href = "ptr_list.html" > ptr_list< / a > < / li >
< li > < a class = "reference external" href = "ptr_deque.html" > ptr_deque< / a > < / li >
< li > < a class = "reference external" href = "ptr_array.html" > ptr_array< / a > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / li >
2021-10-05 21:37:46 +02:00
< li > < a class = "reference external" href = "associative_ptr_container.html" > associative_ptr_container< / a > < ul >
< li > < a class = "reference external" href = "ptr_set_adapter.html" > ptr_set_adapter< / a > < / li >
< li > < a class = "reference external" href = "ptr_multiset_adapter.html" > ptr_multiset_adapter< / a > < / li >
< li > < a class = "reference external" href = "ptr_map_adapter.html" > ptr_map_adapter< / a > < / li >
< li > < a class = "reference external" href = "ptr_multimap_adapter.html" > ptr_multi_map_adapter< / a > < ul >
< li > < a class = "reference external" href = "ptr_set.html" > ptr_set< / a > < / li >
< li > < a class = "reference external" href = "ptr_multiset.html" > ptr_multi_set< / a > < / li >
< li > < a class = "reference external" href = "ptr_map.html" > ptr_map< / a > < / li >
< li > < a class = "reference external" href = "ptr_multimap.html" > ptr_multimap< / a > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / li >
< / ul >
< / li >
< / ul >
< / li >
< / ul >
< p > < strong > Navigate:< / strong > < / p >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > < a class = "reference external" href = "ptr_container.html" > home< / a > < / li >
< li > < a class = "reference external" href = "reference.html" > reference< / a > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< p > < strong > synopsis:< / strong > < / p >
< pre class = "literal-block" >
namespace boost
2021-10-05 21:37:46 +02:00
{
2018-01-12 21:47:58 +01:00
template
2021-10-05 21:37:46 +02:00
<
class T,
2018-01-12 21:47:58 +01:00
class CloneAllocator,
class VoidPtrContainer
>
2021-10-05 21:37:46 +02:00
class reversible_ptr_container
2018-01-12 21:47:58 +01:00
{
2021-10-05 21:37:46 +02:00
public: // < a class = "reference internal" href = "#typedefs" > typedefs< / a >
2018-01-12 21:47:58 +01:00
typedef T* value_type;
typedef T& reference;
typedef const T& const_reference;
typedef < em > implementation defined< / em > iterator;
typedef < em > implementation defined< / em > const_iterator;
2021-10-05 21:37:46 +02:00
typedef typename VoidPtrContainer::differnce_type difference_type;
2018-01-12 21:47:58 +01:00
typedef typename VoidPtrContainer::size_type size_type;
typedef typename VoidPtrContainer::allocator_type allocator_type;
typedef < em > implementation defined< / em > reverse_iterator;
typedef < em > implementation defined< / em > const_reverse_iterator;
typedef < em > implementation defined< / em > auto_type;
2021-10-05 21:37:46 +02:00
public: // < a class = "reference internal" href = "#construct-copy-destroy" > construct/copy/destroy< / a >
2018-01-12 21:47:58 +01:00
reversible_ptr_container();
2021-10-05 21:37:46 +02:00
explicit reversible_ptr_container( const reversible_ptr_container& r );
2018-01-12 21:47:58 +01:00
template< class Derived >
explicit reversible_ptr_container( const reversible_ptr_container< Derived> & r );
2021-10-05 21:37:46 +02:00
explicit reversible_ptr_container( < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < reversible_ptr_container> r );
2018-01-12 21:47:58 +01:00
template< class InputIterator >
reversible_ptr_container( InputIterator first, InputIterator last );
2021-10-05 21:37:46 +02:00
2018-01-12 21:47:58 +01:00
~reversible_ptr_container();
reversible_ptr_container& operator=( const reversible_ptr_container& r );
template< class Derived>
reversible_ptr_container& operator=( const reversible_ptr_container< Derived> & r );
2021-10-05 21:37:46 +02:00
reversible_ptr_container& operator=( < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < reversible_ptr_container> r );
allocator_type get_allocator() const;
public: // < a class = "reference internal" href = "#iterators" > iterators< / a >
2018-01-12 21:47:58 +01:00
iterator begin();
const_iterator begin() const;
iterator end();
const_iterator end() const;
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
reverse_iterator rend();
const_reverse_iterator rend() const;
2021-10-05 21:37:46 +02:00
public: // < a class = "reference internal" href = "#capacity" > capacity< / a >
2018-01-12 21:47:58 +01:00
size_type size() const;
size_type max_size() const;
2021-10-05 21:37:46 +02:00
bool empty() const;
public: // < a class = "reference internal" href = "#modifiers" > modifiers< / a >
2018-01-12 21:47:58 +01:00
void swap( reversible_ptr_container& r );
void clear():
VoidPtrContainer& base();
const VoidPtrContainer& base() const;
2021-10-05 21:37:46 +02:00
public: // < a class = "reference internal" href = "#pointer-container-requirements" > pointer container requirements< / a >
2018-01-12 21:47:58 +01:00
auto_type replace( iterator position, T* x );
template< class U >
2021-10-05 21:37:46 +02:00
auto_type replace( iterator position, < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < U> x );
< a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < reversible_ptr_container> clone() const;
< a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < reversible_ptr_container> release();
2018-01-12 21:47:58 +01:00
auto_type release( iterator position );
2021-10-05 21:37:46 +02:00
2018-01-12 21:47:58 +01:00
}; // class 'reversible_ptr_container'
2021-10-05 21:37:46 +02:00
// < a class = "reference internal" href = "#comparison" > comparison< / a >
2018-01-12 21:47:58 +01:00
template < class T, class CA, class VPC >
bool operator==( const reversible_ptr_container< T,CA,VPC> & x,
const reversible_ptr_container< T,CA,VPC> & y);
2021-10-05 21:37:46 +02:00
2018-01-12 21:47:58 +01:00
template < class T, class CA, class VPC >
bool operator< ( const reversible_ptr_container< T,CA,VPC> & x,
const reversible_ptr_container< T,CA,VPC> & y);
2021-10-05 21:37:46 +02:00
2018-01-12 21:47:58 +01:00
template < class T, class CA, class VPC >
bool operator!=( const reversible_ptr_container< T,CA,VPC> & x,
const reversible_ptr_container< T,CA,VPC> & y);
2021-10-05 21:37:46 +02:00
2018-01-12 21:47:58 +01:00
template < class T, class CA, class VPC >
bool operator> ( const reversible_ptr_container< T,CA,VPC> & x,
const reversible_ptr_container< T,CA,VPC> & y);
2021-10-05 21:37:46 +02:00
2018-01-12 21:47:58 +01:00
template < class T, class CA, class VPC >
bool operator> =( const reversible_ptr_container< T,CA,VPC> & x,
const reversible_ptr_container< T,CA,VPC> & y);
2021-10-05 21:37:46 +02:00
2018-01-12 21:47:58 +01:00
template < class T, class CA, class VPC >
bool operator< =( const reversible_ptr_container< T,CA,VPC> & x,
const reversible_ptr_container< T,CA,VPC> & y);
template< class T, class CA, class VPC >
void swap( reversible_ptr_container< T,CA,VPC> & x,
reversible_ptr_container< T,CA,VPC> & y );
2021-10-05 21:37:46 +02:00
// < a class = "reference internal" href = "#cloneability" > cloneability< / a >
2018-01-12 21:47:58 +01:00
template< class T, class CA, class VPC >
reversible_ptr_container< T,CA,VPC> *
new_clone( const reversible_ptr_container< T,CA,VPC> & r );
2021-10-05 21:37:46 +02:00
// < a class = "reference internal" href = "#null-predicate" > null predicate< / a >
2018-01-12 21:47:58 +01:00
template< class Iterator >
bool is_null( Iterator i );
2021-10-05 21:37:46 +02:00
// < a class = "reference internal" href = "#serialization" > serialization< / a >
2018-01-12 21:47:58 +01:00
template< class Archive, class T, class CA, class VPC>
void serialize( Archive& ar, reversible_ptr_container< T,CÁ,VPC> & c, const unsigned int version );
} // namespace 'boost'
< / pre >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics" >
< h1 > Semantics< / h1 >
< div class = "section" id = "semantics-typedefs" >
< span id = "typedefs" > < / span > < h2 > Semantics: typedefs< / h2 >
2018-01-12 21:47:58 +01:00
< p > Notice how these two types differ:< / p >
< ul >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > typedef T* value_type;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > notice this has pointer type< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > typedef T& reference;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > notice this is not a pointer type< / li >
< / ul >
< / blockquote >
< / li >
< / ul >
< p > This is done to be able to add pointers directly
to the container, but to hide the pointers externally.< / p >
<!-- - ``typedef *implementation defined* object_type;``
- this is ``T`` for sequences and sets
- this is ``std::pair< const Key , void * > `` for maps -->
< p > Also notice that< / p >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > < tt class = "docutils literal" > typedef ... iterator< / tt > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
2021-10-05 21:37:46 +02:00
< p > allows one to iterate over < tt class = "docutils literal" > T& < / tt > objects, not < tt class = "docutils literal" > T*< / tt > .
2018-01-12 21:47:58 +01:00
Note that:< / p >
< pre class = "literal-block" >
iterator i = ...;
i.base();
< / pre >
2021-10-05 21:37:46 +02:00
< p > returns an iterator that allows one to iterate over < tt class = "docutils literal" > void*< / tt >
2018-01-12 21:47:58 +01:00
elements (< em > this is very rarely needed and you should not use the
functionality unless you know what you are doing< / em > ).< / p >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > < tt class = "docutils literal" > typedef ... auto_type< / tt > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< p > This declaration hides a pointer pointer type. You can rely on the following
operations< / p >
< pre class = "literal-block" >
T* operator-> () const;
T& operator*() const;
T* release();
~auto_type();
operator < em > implementation-defined bool< / em > ();
< / pre >
< p > The destructor will delete the stored object < em > using the clone allocator of the container< / em >
2021-10-05 21:37:46 +02:00
(this explains why we cannot use < tt class = "docutils literal" > < span class = "pre" > std::auto_ptr< T> < / span > < / tt > nor < tt class = "docutils literal" > < span class = "pre" > std::unique_ptr< T> < / span > < / tt > ). It might help to
think it is just a < tt class = "docutils literal" > < span class = "pre" > < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < T> < / span > < / tt > . You can also return
the pointer from a function or assign it to another pointer via the < tt class = "docutils literal" > move()< / tt >
2018-01-12 21:47:58 +01:00
function< / p >
< pre class = "literal-block" >
auto_type ptr = ...;
auto_type other = boost::ptr_container::move( ptr );
return boost::ptr_container::move( other );
< / pre >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-construct-copy-destroy" >
< span id = "construct-copy-destroy" > < / span > < h2 > Semantics: construct/copy/destroy< / h2 >
2018-01-12 21:47:58 +01:00
< ul >
< li > < p class = "first" > < tt class = "docutils literal" > < span class = "pre" > reversible_ptr_container();< / span > < / tt > < / p >
< blockquote >
< ul class = "simple" >
< li > Effects: Constructs an empty container< / li >
2021-10-05 21:37:46 +02:00
< li > Postconditions: < tt class = "docutils literal" > size() == 0< / tt > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / blockquote >
< / li >
< / ul >
<!-- - ``reversible_ptr_container( size_type n, const T& x );``
- Effects: Constructs a container with ``n`` clones of ``x``
- Postconditions: ``size() == n`` -->
< ul >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > explicit reversible_ptr_container( const reversible_ptr_container& r );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: Constructs a container by cloning all elements of < tt class = "docutils literal" > r< / tt > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > template< class Derived > explicit reversible_ptr_container( const reversible_ptr_container< Derived> & r );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: Constructs a container by cloning all elements of < tt class = "docutils literal" > r< / tt > < / li >
< li > Requirements: < tt class = "docutils literal" > Derived< / tt > is derived from < tt class = "docutils literal" > T< / tt > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > explicit reversible_ptr_container( < span class = "pre" > < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < < / span > reversible_ptr_container > r );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Constructs a container by taking ownership of the supplied pointers< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > template< class InputIterator > < / tt >
< tt class = "docutils literal" > reversible_ptr_container( InputIterator first, InputIterator last );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Requirements: < tt class = "docutils literal" > (first,last]< / tt > is a valid range< / li >
< li > Effects: Constructs a container with a cloned range of < tt class = "docutils literal" > (first,last]< / tt > < / li >
< li > Postconditions: < tt class = "docutils literal" > size() == < span class = "pre" > std::distance(< / span > first, last )< / tt > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / blockquote >
< / li >
< li > < p class = "first" > < tt class = "docutils literal" > < span class = "pre" > ~reversible_ptr_container();< / span > < / tt > < / p >
< blockquote >
< ul class = "simple" >
< li > Effects: Deletes the stored objects via the clone allocator< / li >
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > reversible_ptr_container& operator=( const reversible_ptr_container& r );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: Assigns a clone of < tt class = "docutils literal" > r< / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Exception safety: strong guarantee< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > template< class Derived> reversible_ptr_container& operator=( const reversible_ptr_container< Derived> & r );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: Assigns a clone of < tt class = "docutils literal" > r< / tt > < / li >
< li > Requirements: < tt class = "docutils literal" > Derived< / tt > is derived from < tt class = "docutils literal" > T< / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Exception safety: Strong guarantee< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > reversible_ptr_container& operator=( < span class = "pre" > < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < reversible_ptr_container> < / span > r );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Deletes the stored objects and then takes ownership of the supplied pointers< / li >
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > allocator_type get_allocator() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Returns a copy of the allocator of the container object< / li >
< / ul >
< / blockquote >
< / li >
< / ul >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-iterators" >
< span id = "iterators" > < / span > < h2 > Semantics: iterators< / h2 >
< p > < strong > See also:< / strong > < a class = "reference external" href = "conventions.html#iterators-are-invalidated-as-in-the-corresponding-standard-container" > iterator invalidation< / a > < / p >
2018-01-12 21:47:58 +01:00
< ul >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > iterator < span class = "pre" > begin();< / span > < / tt > < / p >
2018-01-12 21:47:58 +01:00
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > const_iterator begin() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: Returns a mutable/non-mutable iterator with < tt class = "docutils literal" > value_type T< / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > iterator < span class = "pre" > end();< / span > < / tt > < / p >
2018-01-12 21:47:58 +01:00
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > const_iterator end() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: Returns a mutable/non-mutable iterator with < tt class = "docutils literal" > value_type T< / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > reverse_iterator < span class = "pre" > rbegin();< / span > < / tt > < / p >
2018-01-12 21:47:58 +01:00
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > const_reverse_iterator rbegin() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: Returns a mutable/non-mutable reverse iterator with < tt class = "docutils literal" > value_type T< / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > reverse_iterator < span class = "pre" > rend();< / span > < / tt > < / p >
2018-01-12 21:47:58 +01:00
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > const_reverse_iterator rend() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: Returns a mutable/non-mutable reverse iterator with < tt class = "docutils literal" > value_type T< / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
< / ul >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-capacity" >
< span id = "capacity" > < / span > < h2 > Semantics: capacity< / h2 >
2018-01-12 21:47:58 +01:00
< ul >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > size_type size() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Returns the number of stored elements< / li >
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > size_type max_size() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Returns the maximum number of stored elements< / li >
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > bool empty() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Returns whether the container is empty or not< / li >
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
< / ul >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-modifiers" >
< span id = "modifiers" > < / span > < h2 > Semantics: modifiers< / h2 >
2018-01-12 21:47:58 +01:00
< ul >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > void swap( reversible_ptr_container& r );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Swaps the content of the two containers< / li >
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > void < span class = "pre" > clear();< / span > < / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Destroys all object of the container< / li >
2021-10-05 21:37:46 +02:00
< li > Postconditions: < tt class = "docutils literal" > empty() == true< / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Throws: Nothing< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > VoidPtrContainer& < span class = "pre" > base();< / span > < / tt > < / p >
2018-01-12 21:47:58 +01:00
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > const VoidPtrContainer& base() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Returns: a reference to the wrapped container< / li >
< / ul >
< / blockquote >
< / li >
< / ul >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-pointer-container-requirements" >
< span id = "pointer-container-requirements" > < / span > < h2 > Semantics: pointer container requirements< / h2 >
2018-01-12 21:47:58 +01:00
< ul >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > auto_type replace( iterator position, T* x );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Requirements: < tt class = "docutils literal" > not empty() and x != 0< / tt > < / li >
< li > Effects: returns the object pointed to by < tt class = "docutils literal" > position< / tt > and replaces it with < tt class = "docutils literal" > x< / tt > .< / li >
< li > Throws: < tt class = "docutils literal" > bad_ptr_container_operation< / tt > if the container is empty and < tt class = "docutils literal" > bad_pointer< / tt > if < tt class = "docutils literal" > x == 0< / tt > .< / li >
2018-01-12 21:47:58 +01:00
< li > Exception safety: Strong guarantee< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > template< class U > auto_type replace( iterator position, < span class = "pre" > < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < U> < / span > x );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: < tt class = "docutils literal" > return replace( position, x.release() );< / tt > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > < span class = "pre" > < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < < / span > reversible_ptr_container > clone() const;< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Returns a deep copy of the container< / li >
< li > Throws: < tt class = "docutils literal" > < span class = "pre" > std::bad_alloc< / span > < / tt > if there is not enough memory to make a clone of the container< / li >
< li > Complexity: Linear< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > < span class = "pre" > < a class = "reference external" href = "compatible_smart_ptr.html" > < em > compatible-smart-ptr< / em > < / a > < < / span > reversible_ptr_container > < span class = "pre" > release();< / span > < / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
< li > Effects: Releases ownership of the container. This is a useful way of returning a container from a function.< / li >
2021-10-05 21:37:46 +02:00
< li > Postconditions: < tt class = "docutils literal" > empty() == true< / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Throws: < tt class = "docutils literal" > < span class = "pre" > std::bad_alloc< / span > < / tt > if the return value cannot be allocated< / li >
< li > Exception safety: Strong guarantee< / li >
< / ul >
< / blockquote >
< / li >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > auto_type release( iterator position );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Requirements: < tt class = "docutils literal" > not < span class = "pre" > empty();< / span > < / tt > < / li >
2018-01-12 21:47:58 +01:00
< li > Effects: Releases ownership of the pointer referred to by position< / li >
2021-10-05 21:37:46 +02:00
< li > Postconditions: < tt class = "docutils literal" > size()< / tt > is one less< / li >
< li > Throws: < tt class = "docutils literal" > bad_ptr_container_operation< / tt > if the container is empty< / li >
2018-01-12 21:47:58 +01:00
< li > Exception safety: Strong guarantee< / li >
< / ul >
< / blockquote >
< / li >
< / ul >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-comparison" >
< span id = "comparison" > < / span > < h2 > Semantics: comparison< / h2 >
< p > These functions compare the underlying range of objects.
2018-01-12 21:47:58 +01:00
So< / p >
< pre class = "literal-block" >
operation( const ptr_container& l, const ptr_container& r );
< / pre >
< p > has the effect one would expect of normal standard containers. Hence
objects are compared and not the pointers to objects.< / p >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-cloneability" >
< span id = "cloneability" > < / span > < h2 > Semantics: cloneability< / h2 >
2018-01-12 21:47:58 +01:00
< ul >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > template< class T, class CloneAllocator >
reversible_ptr_container< T,CA,VPC> *
new_clone( const reversible_ptr_container< T,CA,VPC> & r );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Effects: < tt class = "docutils literal" > return < span class = "pre" > r.clone().release();< / span > < / tt > < / li >
< li > Remarks: This function is only defined for concrete < a class = "reference external" href = "ptr_container.html#smart-containers" > pointer containers< / a > , but not for
< a class = "reference external" href = "ptr_container.html#smart-container-adapters" > pointer container adapters< / a > .< / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / blockquote >
< / li >
< / ul >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-null-predicate" >
< span id = "null-predicate" > < / span > < h2 > Semantics: null predicate< / h2 >
2018-01-12 21:47:58 +01:00
< ul >
2021-10-05 21:37:46 +02:00
< li > < p class = "first" > < tt class = "docutils literal" > template< class Iterator > bool is_null( Iterator i );< / tt > < / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< ul class = "simple" >
2021-10-05 21:37:46 +02:00
< li > Requirements: < tt class = "docutils literal" > i< / tt > is a valid dereferencable iterator< / li >
< li > Returns: < tt class = "docutils literal" > *i.base() == 0;< / tt > < / li >
2018-01-12 21:47:58 +01:00
< / ul >
< / blockquote >
< / li >
< / ul >
< / div >
2021-10-05 21:37:46 +02:00
< div class = "section" id = "semantics-serialization" >
< span id = "serialization" > < / span > < h2 > Semantics: serialization< / h2 >
2018-01-12 21:47:58 +01:00
< p > All containers can be serialized by means of
2021-10-05 21:37:46 +02:00
< a class = "reference external" href = "../../serialization/index.html" > Boost.Serialization< / a > . For an overview, see
< a class = "reference external" href = "reference.html#serialization" > Serialization of Pointer Containers< / a > .< / p >
2018-01-12 21:47:58 +01:00
< blockquote >
< pre class = "literal-block" >
template< class Archive, class T, class CA, class VPC>
void serialize( Archive& ar, reversible_ptr_container< T,CA,VPC> & c, const unsigned int version );
< / pre >
< / blockquote >
< ul class = "simple" >
< li > Effects: Saves or loads the container to/from the archive.< / li >
< li > Remarks: This function is called automatically be stream operators in
Boost.Serialization< / li >
< li > Exception safety: Loading gives the basic guarantee< / li >
< / ul >
< hr > < table class = "docutils field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
2021-10-05 21:37:46 +02:00
< tr class = "field" > < th class = "field-name" > Copyright:< / th > < td class = "field-body" > Thorsten Ottosen 2004-2007. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see < a class = "reference external" href = "http://www.boost.org/LICENSE_1_0.txt" > LICENSE_1_0.txt< / a > ).< / td >
2018-01-12 21:47:58 +01:00
< / tr >
< / tbody >
< / table >
< / div >
< / div >
< / div >
< / body >
< / html >
