Update of /cvsroot/boost/boost/boost/interprocess/containers
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv17930/containers
Modified Files:
deque.hpp flat_map.hpp flat_set.hpp list.hpp map.hpp set.hpp
slist.hpp string.hpp vector.hpp
Log Message:
Changes for official inclusion in the regression tests
Index: deque.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/deque.hpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- deque.hpp 28 Jan 2007 09:13:21 -0000 1.5
+++ deque.hpp 4 May 2007 20:53:08 -0000 1.6
@@ -63,11 +63,13 @@
#include <boost/detail/no_exceptions_support.hpp>
#include <boost/interprocess/detail/move_iterator.hpp>
#include <boost/interprocess/detail/move.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
namespace boost {
namespace interprocess {
+/// @cond
template <class T, class Alloc>
class deque;
@@ -107,7 +109,9 @@
allocator_type get_allocator() const
{ return *this; }
- protected:
+ protected:
+ enum { trivial_dctr_after_move =
boost::has_trivial_destructor<val_alloc_val>::value };
+
typedef typename boost::detail::allocator::
rebind_to<Alloc, typename Alloc::pointer>::type map_allocator_type;
@@ -293,9 +297,9 @@
};
//Vector iterator
- class iterator : public const_iterator
- {
- public:
+ class iterator : public const_iterator
+ {
+ public:
typedef std::random_access_iterator_tag iterator_category;
typedef val_alloc_val value_type;
typedef ptr_alloc_ptr pointer;
@@ -325,37 +329,37 @@
reference operator[](difference_type n) const { return *(*this + n); }
//Increment / Decrement
- iterator& operator++()
+ iterator& operator++()
{ this->const_iterator::operator++(); return *this; }
- iterator operator++(int)
+ iterator operator++(int)
{ iterator tmp = *this; ++*this; return tmp; }
-
+
iterator& operator--()
- { this->const_iterator::operator--(); return *this; }
+ { this->const_iterator::operator--(); return *this; }
- iterator operator--(int)
- { iterator tmp = *this; --*this; return tmp; }
+ iterator operator--(int)
+ { iterator tmp = *this; --*this; return tmp; }
// Arithmetic
- iterator& operator+=(difference_type off)
- { this->const_iterator::operator+=(off); return *this; }
+ iterator& operator+=(difference_type off)
+ { this->const_iterator::operator+=(off); return *this; }
- iterator operator+(difference_type off) const
- { return
iterator(this->const_iterator::operator+(off)); }
+ iterator operator+(difference_type off) const
+ { return iterator(this->const_iterator::operator+(off)); }
- friend iterator operator+(difference_type off, const iterator&
right)
+ friend iterator operator+(difference_type off, const iterator& right)
{ return iterator(off+static_cast<const const_iterator &>(right)); }
- iterator& operator-=(difference_type off)
- { this->const_iterator::operator-=(off); return *this;
}
+ iterator& operator-=(difference_type off)
+ { this->const_iterator::operator-=(off); return *this; }
- iterator operator-(difference_type off) const
- { return
iterator(this->const_iterator::operator-(off)); }
+ iterator operator-(difference_type off) const
+ { return iterator(this->const_iterator::operator-(off)); }
- difference_type operator-(const const_iterator& right) const
- { return static_cast<const const_iterator&>(*this) -
right; }
- };
+ difference_type operator-(const const_iterator& right) const
+ { return static_cast<const const_iterator&>(*this) - right; }
+ };
deque_base(const allocator_type& a, std::size_t num_elements)
: allocator_type(a), map_allocator_type(a),
@@ -444,13 +448,16 @@
iterator m_start;
iterator m_finish;
};
+/// @endcond
template <class T, class Alloc>
class deque : protected deque_base<T, Alloc>
{
-
+ /// @cond
typedef deque_base<T, Alloc> Base;
- public: // Basic types
+ /// @endcond
+
+ public: // Basic types
typedef typename Alloc::value_type val_alloc_val;
typedef typename Alloc::pointer val_alloc_ptr;
typedef typename Alloc::const_pointer val_alloc_cptr;
@@ -482,12 +489,13 @@
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
- protected: // Internal typedefs
+ /// @cond
+ protected: // Internal typedefs
typedef ptr_alloc_ptr index_pointer;
static std::size_t s_buffer_size()
{ return deque_buf_size(sizeof(T)); }
- protected:
+ protected:
using Base::priv_initialize_map;
using Base::priv_create_nodes;
using Base::priv_destroy_nodes;
@@ -500,8 +508,9 @@
using Base::m_map_size;
using Base::m_start;
using Base::m_finish;
+ /// @endcond
- public: // Basic accessors
+ public: // Basic accessors
iterator begin()
{ return this->m_start; }
@@ -560,7 +569,7 @@
{ return this->m_finish - this->m_start; }
size_type max_size() const
- { return size_type(-1); }
+ { return allocator_type::max_size(); }
bool empty() const
{ return this->m_finish == this->m_start; }
@@ -593,8 +602,8 @@
this->priv_initialize_dispatch(first, last, Result());
}
- ~deque()
- { priv_destroy_range(this->m_start, this->m_finish); }
+ ~deque()
+ { priv_destroy_range(this->m_start, this->m_finish); }
deque& operator= (const deque& x)
{
@@ -612,7 +621,7 @@
}
deque& operator= (const detail::moved_object<deque> &mx)
- { this->swap(mx.get()); return *this; }
+ { this->clear(); this->swap(mx.get()); return *this; }
void swap(deque& x)
{
@@ -779,11 +788,15 @@
++next;
difference_type index = pos - this->m_start;
if (size_type(index) < (this->size() >> 1)) {
- std::copy_backward(detail::make_move_iterator(this->m_start),
detail::make_move_iterator(pos), next);
+ std::copy_backward( detail::make_move_iterator(this->m_start)
+ , detail::make_move_iterator(pos)
+ , next);
pop_front();
}
else {
- std::copy(detail::make_move_iterator(next),
detail::make_move_iterator(this->m_finish), pos);
+ std::copy( detail::make_move_iterator(next)
+ , detail::make_move_iterator(this->m_finish)
+ , pos);
pop_back();
}
return this->m_start + index;
@@ -799,16 +812,22 @@
difference_type n = last - first;
difference_type elems_before = first - this->m_start;
if (elems_before < static_cast<difference_type>(this->size() - n) -
elems_before) {
- std::copy_backward(detail::make_move_iterator(this->m_start),
detail::make_move_iterator(first), last);
+ std::copy_backward( detail::make_move_iterator(this->m_start)
+ , detail::make_move_iterator(first)
+ , last);
iterator new_start = this->m_start + n;
- this->priv_destroy_range(this->m_start, new_start);
+ if(!Base::trivial_dctr_after_move)
+ this->priv_destroy_range(this->m_start, new_start);
this->priv_destroy_nodes(new_start.m_node, this->m_start.m_node);
this->m_start = new_start;
}
else {
- std::copy(last, this->m_finish, first);
+ std::copy( detail::make_move_iterator(last)
+ , detail::make_move_iterator(this->m_finish)
+ , first);
iterator new_finish = this->m_finish - n;
- this->priv_destroy_range(new_finish, this->m_finish);
+ if(!Base::trivial_dctr_after_move)
+ this->priv_destroy_range(new_finish, this->m_finish);
this->priv_destroy_nodes(new_finish.m_node + 1,
this->m_finish.m_node + 1);
this->m_finish = new_finish;
}
@@ -836,7 +855,8 @@
this->m_finish = this->m_start;
}
- private:
+ /// @cond
+ private:
template <class InpIt>
void insert(iterator pos, InpIt first, InpIt last, std::input_iterator_tag)
@@ -1368,6 +1388,7 @@
}
BOOST_CATCH_END
}
+ /// @endcond
};
// Nonmember functions.
@@ -1409,8 +1430,17 @@
inline void swap(deque<T,Alloc>& x, deque<T,Alloc>& y)
{ x.swap(y); }
-} //namespace interprocess {
+/// @cond
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class T, class A>
+struct has_trivial_destructor_after_move<deque<T, A> >
+{
+ enum { value = has_trivial_destructor<A>::value };
+};
+/// @endcond
+} //namespace interprocess {
} //namespace boost {
#include <boost/interprocess/detail/config_end.hpp>
Index: flat_map.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/flat_map.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- flat_map.hpp 15 Oct 2006 13:11:06 -0000 1.2
+++ flat_map.hpp 4 May 2007 20:53:08 -0000 1.3
@@ -1,45 +1,12 @@
-/*
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation. Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
[...986 lines suppressed...]
enum { value = true };
};
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class K, class T, class C, class A>
+struct has_trivial_destructor_after_move<flat_multimap<K, T, C, A> >
+{
+ enum { value =
+ has_trivial_destructor<A>::value &&
+ has_trivial_destructor<C>::value };
+};
+/// @endcond
+
}} //namespace boost { namespace interprocess {
#include <boost/interprocess/detail/config_end.hpp>
#endif /* BOOST_INTERPROCESS_FLAT_MAP_HPP */
-
Index: flat_set.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/flat_set.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- flat_set.hpp 15 Oct 2006 13:11:06 -0000 1.2
+++ flat_set.hpp 4 May 2007 20:53:08 -0000 1.3
@@ -1,44 +1,12 @@
-/*
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation. Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
- * purpose. It is provided "as is" without express or implied warranty.
- *
- *
- * Copyright (c) 1996
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation. Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose. It is provided "as is" without express or implied warranty.
- *
- */
//////////////////////////////////////////////////////////////////////////////
//
-// (C) Copyright Ion Gaztañaga 2005-2006. Distributed under the Boost
+// (C) Copyright Ion Gaztañaga 2005-2007. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/interprocess for documentation.
//
//////////////////////////////////////////////////////////////////////////////
-//
-// This file comes from SGI's stl_set/stl_multiset files. Modified by Ion
Gaztañaga 2004.
-// Renaming, isolating and porting to generic algorithms. Pointer typedef
-// set to allocator::pointer to allow placing it in shared memory.
-//
-///////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTERPROCESS_SHMEM_FLAT_SET_HPP
#define BOOST_INTERPROCESS_SHMEM_FLAT_SET_HPP
@@ -60,6 +28,7 @@
namespace boost { namespace interprocess {
+/// @cond
// Forward declarations of operators < and ==, needed for friend declaration.
template <class T, class Pred, class Alloc>
@@ -72,17 +41,30 @@
template <class T, class Pred, class Alloc>
inline bool operator<(const flat_set<T,Pred,Alloc>& x,
const flat_set<T,Pred,Alloc>& y);
+/// @endcond
-
+//! flat_set is a Sorted Associative Container that stores objects of type
Key.
+//! flat_set is a Simple Associative Container, meaning that its value type,
+//! as well as its key type, is Key. It is also a Unique Associative
Container,
+//! meaning that no two elements are the same.
+//!
+//! flat_set is similar to std::set but it's implemented like an ordered
vector.
+//! This means that inserting a new element into a flat_set invalidates
+//! previous iterators and references
+//!
+//! Erasing an element of a flat_set invalidates iterators and references
+//! pointing to elements that come after (their keys are bigger) the erased
element.
template <class T, class Pred, class Alloc>
class flat_set
{
- private:
+ /// @cond
+ private:
typedef detail::flat_tree<T, T,
detail::identity<T>, Pred, Alloc> tree_t;
tree_t m_flat_tree; // flat tree representing flat_set
+ /// @endcond
- public:
+ public:
// typedefs:
typedef typename tree_t::key_type key_type;
typedef typename tree_t::value_type value_type;
@@ -100,11 +82,20 @@
typedef typename tree_t::difference_type difference_type;
typedef typename tree_t::allocator_type allocator_type;
- // allocation/deallocation
+ //! <b>Effects</b>: Constructs an empty flat_map using the specified
+ //! comparison object and allocator.
+ //!
+ //! <b>Complexity</b>: Constant.
explicit flat_set(const Pred& comp = Pred(),
const allocator_type& a = allocator_type())
- : m_flat_tree(comp, a) {}
+ : m_flat_tree(comp, a)
+ {}
+ //! <b>Effects</b>: Constructs an empty map using the specified comparison
object and
+ //! allocator, and inserts elements from the range [first ,last ).
+ //!
+ //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already
sorted using
+ //! comp and otherwise N logN, where N is last - first.
template <class InputIterator>
flat_set(InputIterator first, InputIterator last,
const Pred& comp = Pred(),
@@ -112,136 +103,361 @@
: m_flat_tree(comp, a)
{ m_flat_tree.insert_unique(first, last); }
+ //! <b>Effects</b>: Copy constructs a map.
+ //!
+ //! <b>Complexity</b>: Linear in x.size().
flat_set(const flat_set<T,Pred,Alloc>& x)
: m_flat_tree(x.m_flat_tree) {}
+ //! <b>Effects</b>: Move constructs a map. Constructs *this using x's
resources.
+ //!
+ //! <b>Complexity</b>: Construct.
+ //!
+ //! <b>Postcondition</b>: x is emptied.
flat_set(const detail::moved_object<flat_set<T,Pred,Alloc> >& mx)
: m_flat_tree(move(mx.get().m_flat_tree)) {}
+ //! <b>Effects</b>: Makes *this a copy of x.
+ //!
+ //! <b>Complexity</b>: Linear in x.size().
flat_set<T,Pred,Alloc>& operator=(const flat_set<T, Pred, Alloc>& x)
{ m_flat_tree = x.m_flat_tree; return *this; }
- // accessors:
+ //! <b>Effects</b>: Makes *this a copy of x.
+ //!
+ //! <b>Complexity</b>: Linear in x.size().
+ flat_set<T,Pred,Alloc>& operator=(const detail::moved_object<flat_set<T,
Pred, Alloc> > &mx)
+ { m_flat_tree = move(mx.get().m_flat_tree); return *this; }
+ //! <b>Effects</b>: Returns the comparison object out
+ //! of which a was constructed.
+ //!
+ //! <b>Complexity</b>: Constant.
key_compare key_comp() const
{ return m_flat_tree.key_comp(); }
+ //! <b>Effects</b>: Returns an object of value_compare constructed out
+ //! of the comparison object.
+ //!
+ //! <b>Complexity</b>: Constant.
value_compare value_comp() const
{ return m_flat_tree.key_comp(); }
+ //! <b>Effects</b>: Returns a copy of the Allocator that
+ //! was passed to the objects constructor.
+ //!
+ //! <b>Complexity</b>: Constant.
allocator_type get_allocator() const
{ return m_flat_tree.get_allocator(); }
+ //! <b>Effects</b>: Returns an iterator to the first element contained in
the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ iterator begin()
+ { return m_flat_tree.begin(); }
+
+ //! <b>Effects</b>: Returns a const_iterator to the first element contained
in the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
const_iterator begin() const
{ return m_flat_tree.begin(); }
+ //! <b>Effects</b>: Returns an iterator to the end of the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ iterator end()
+ { return m_flat_tree.end(); }
+
+ //! <b>Effects</b>: Returns a const_iterator to the end of the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
const_iterator end() const
{ return m_flat_tree.end(); }
+ //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+ //! of the reversed container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ reverse_iterator rbegin()
+ { return m_flat_tree.rbegin(); }
+
+ //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the
beginning
+ //! of the reversed container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
const_reverse_iterator rbegin() const
{ return m_flat_tree.rbegin(); }
- const_reverse_iterator rend() const
+ //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
+ //! of the reversed container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ reverse_iterator rend()
{ return m_flat_tree.rend(); }
- iterator begin()
- { return m_flat_tree.begin(); }
-
- iterator end()
- { return m_flat_tree.end(); }
-
- reverse_iterator rbegin()
- { return m_flat_tree.rbegin(); }
-
- reverse_iterator rend()
+ //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
+ //! of the reversed container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ const_reverse_iterator rend() const
{ return m_flat_tree.rend(); }
+ //! <b>Effects</b>: Returns true if the container contains no elements.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
bool empty() const
{ return m_flat_tree.empty(); }
+ //! <b>Effects</b>: Returns the number of the elements contained in the
container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
size_type size() const
{ return m_flat_tree.size(); }
+ //! <b>Effects</b>: Returns the largest possible size of the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
size_type max_size() const
{ return m_flat_tree.max_size(); }
+ //! <b>Effects</b>: Swaps the contents of *this and x.
+ //! If this->allocator_type() != x.allocator_type() allocators are also
swapped.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
void swap(flat_set<T,Pred,Alloc>& x)
{ m_flat_tree.swap(x.m_flat_tree); }
+ //! <b>Effects</b>: Swaps the contents of *this and x.
+ //! If this->allocator_type() != x.allocator_type() allocators are also
swapped.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
void swap(const detail::moved_object <flat_set<T,Pred,Alloc> >& mx)
{ this->swap(mx.get()); }
- // insert/erase
+ //! <b>Effects</b>: Inserts x if and only if there is no element in the
container
+ //! with key equivalent to the key of x.
+ //!
+ //! <b>Returns</b>: The bool component of the returned pair is true if and
only
+ //! if the insertion takes place, and the iterator component of the pair
+ //! points to the element with key equivalent to the key of x.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
std::pair<iterator,bool> insert(const value_type& x)
{ return m_flat_tree.insert_unique(x); }
+ //! <b>Effects</b>: Inserts a new value_type move constructed from the pair
if and
+ //! only if there is no element in the container with key equivalent to the
key of x.
+ //!
+ //! <b>Returns</b>: The bool component of the returned pair is true if and
only
+ //! if the insertion takes place, and the iterator component of the pair
+ //! points to the element with key equivalent to the key of x.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
std::pair<iterator,bool> insert(const detail::moved_object<value_type>& x)
{ return m_flat_tree.insert_unique(x); }
+ //! <b>Effects</b>: Inserts a copy of x in the container if and only if
there is
+ //! no element in the container with key equivalent to the key of x.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! <b>Returns</b>: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
+ //! right before p) plus insertion linear to the elements with bigger
keys than x.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
iterator insert(iterator position, const value_type& x)
{ return m_flat_tree.insert_unique(position, x); }
+ //! <b>Effects</b>: Inserts an element move constructed from x in the
container.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! <b>Returns</b>: An iterator pointing to the element with key equivalent
to the key of x.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
+ //! right before p) plus insertion linear to the elements with bigger
keys than x.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
iterator insert(iterator position, const detail::moved_object<value_type>&
x)
{ return m_flat_tree.insert_unique(position, x); }
+ //! <b>Requires</b>: i, j are not iterators into *this.
+ //!
+ //! <b>Effects</b>: inserts each element from the range [i,j) if and only
+ //! if there is no element with key equivalent to the key of that element.
+ //!
+ //! <b>Complexity</b>: N log(size()+N) (N is the distance from i to j)
+ //! search time plus N*size() insertion time.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{ m_flat_tree.insert_unique(first, last); }
+ //! <b>Effects</b>: Erases the element pointed to by position.
+ //!
+ //! <b>Returns</b>: Returns an iterator pointing to the element immediately
+ //! following q prior to the element being erased. If no such element
exists,
+ //! returns end().
+ //!
+ //! <b>Complexity</b>: Linear to the elements with keys bigger than position
+ //!
+ //! <b>Note</b>: Invalidates elements with keys
+ //! not less than the erased element.
iterator erase(const_iterator position)
{ return m_flat_tree.erase(position); }
+ //! <b>Effects</b>: Erases all elements in the container with key
equivalent to x.
+ //!
+ //! <b>Returns</b>: Returns the number of erased elements.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time plus erasure time
+ //! linear to the elements with bigger keys.
size_type erase(const key_type& x)
{ return m_flat_tree.erase(x); }
+ //! <b>Effects</b>: Erases all the elements in the range [first, last).
+ //!
+ //! <b>Returns</b>: Returns last.
+ //!
+ //! <b>Complexity</b>: size()*N where N is the distance from first to last.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time plus erasure time
+ //! linear to the elements with bigger keys.
iterator erase(const_iterator first, const_iterator last)
{ return m_flat_tree.erase(first, last); }
+ //! <b>Effects</b>: erase(a.begin(),a.end()).
+ //!
+ //! <b>Postcondition</b>: size() == 0.
+ //!
+ //! <b>Complexity</b>: linear in size().
void clear()
{ m_flat_tree.clear(); }
- // flat_set operations:
-
- const_iterator find(const key_type& x) const
+ //! <b>Returns</b>: An iterator pointing to an element with the key
+ //! equivalent to x, or end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic.
+ iterator find(const key_type& x)
{ return m_flat_tree.find(x); }
- iterator find(const key_type& x)
+ //! <b>Returns</b>: A const_iterator pointing to an element with the key
+ //! equivalent to x, or end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic.s
+ const_iterator find(const key_type& x) const
{ return m_flat_tree.find(x); }
+ //! <b>Returns</b>: The number of elements with key equivalent to x.
+ //!
+ //! <b>Complexity</b>: log(size())+count(k)
size_type count(const key_type& x) const
{ return m_flat_tree.find(x) == m_flat_tree.end() ? 0 : 1; }
- const_iterator lower_bound(const key_type& x) const
+ //! <b>Returns</b>: An iterator pointing to the first element with key not
less
+ //! than k, or a.end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic
+ iterator lower_bound(const key_type& x)
{ return m_flat_tree.lower_bound(x); }
- iterator lower_bound(const key_type& x)
+ //! <b>Returns</b>: A const iterator pointing to the first element with key
not
+ //! less than k, or a.end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic
+ const_iterator lower_bound(const key_type& x) const
{ return m_flat_tree.lower_bound(x); }
- const_iterator upper_bound(const key_type& x) const
+ //! <b>Returns</b>: An iterator pointing to the first element with key not
less
+ //! than x, or end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic
+ iterator upper_bound(const key_type& x)
{ return m_flat_tree.upper_bound(x); }
- iterator upper_bound(const key_type& x)
+ //! <b>Returns</b>: A const iterator pointing to the first element with key
not
+ //! less than x, or end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic
+ const_iterator upper_bound(const key_type& x) const
{ return m_flat_tree.upper_bound(x); }
+ //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k),
this->upper_bound(k)).
+ //!
+ //! <b>Complexity</b>: Logarithmic
std::pair<const_iterator, const_iterator>
equal_range(const key_type& x) const
{ return m_flat_tree.equal_range(x); }
+ //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k),
this->upper_bound(k)).
+ //!
+ //! <b>Complexity</b>: Logarithmic
std::pair<iterator,iterator>
equal_range(const key_type& x)
{ return m_flat_tree.equal_range(x); }
+ //! <b>Effects</b>: Number of elements for which memory has been allocated.
+ //! capacity() is always greater than or equal to size().
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
size_type capacity() const
{ return m_flat_tree.capacity(); }
+ //! <b>Effects</b>: If n is less than or equal to capacity(), this call has
no
+ //! effect. Otherwise, it is a request for allocation of additional
memory.
+ //! If the request is successful, then capacity() is greater than or
equal to
+ //! n; otherwise, capacity() is unchanged. In either case, size() is
unchanged.
+ //!
+ //! <b>Throws</b>: If memory allocation allocation throws or T's copy
constructor throws.
+ //!
+ //! <b>Note</b>: If capacity() is less than "count", iterators and
references to
+ //! to values might be invalidated.
void reserve(size_type count)
{ m_flat_tree.reserve(count); }
+ /// @cond
template <class K1, class C1, class A1>
friend bool operator== (const flat_set<K1,C1,A1>&, const
flat_set<K1,C1,A1>&);
template <class K1, class C1, class A1>
friend bool operator< (const flat_set<K1,C1,A1>&, const
flat_set<K1,C1,A1>&);
+ /// @endcond
};
template <class T, class Pred, class Alloc>
@@ -289,6 +505,7 @@
const detail::moved_object<flat_set<T,Pred,Alloc> >& y)
{ x.swap(y.get()); }
+/// @cond
/*!This class is movable*/
template <class T, class P, class A>
struct is_movable<flat_set<T, P, A> >
@@ -296,6 +513,16 @@
enum { value = true };
};
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class T, class C, class A>
+struct has_trivial_destructor_after_move<flat_set<T, C, A> >
+{
+ enum { value =
+ has_trivial_destructor<A>::value &&
+ has_trivial_destructor<C>::value };
+};
+
// Forward declaration of operators < and ==, needed for friend declaration.
template <class T, class Pred, class Alloc>
@@ -308,16 +535,19 @@
template <class T, class Pred, class Alloc>
inline bool operator<(const flat_multiset<T,Pred,Alloc>& x,
const flat_multiset<T,Pred,Alloc>& y);
+/// @endcond
template <class T, class Pred, class Alloc>
class flat_multiset
{
- private:
+ /// @cond
+ private:
typedef detail::flat_tree<T, T,
detail::identity<T>, Pred, Alloc> tree_t;
tree_t m_flat_tree; // flat tree representing flat_multiset
+ /// @endcond
- public:
+ public:
// typedefs:
typedef typename tree_t::key_type key_type;
typedef typename tree_t::value_type value_type;
@@ -356,130 +586,330 @@
flat_multiset<T,Pred,Alloc>& operator=(const flat_multiset<T,Pred,Alloc>&
x)
{ m_flat_tree = x.m_flat_tree; return *this; }
- flat_multiset<T,Pred,Alloc>& operator=(const
detail::moved_object<flat_multiset<T,Pred,Alloc> >& x)
- { m_flat_tree.swap(x.get().m_flat_tree); return *this; }
-
- // accessors:
+ flat_multiset<T,Pred,Alloc>& operator=(const
detail::moved_object<flat_multiset<T,Pred,Alloc> >& mx)
+ { m_flat_tree = move(mx.get().m_flat_tree); return *this; }
+ //! <b>Effects</b>: Returns the comparison object out
+ //! of which a was constructed.
+ //!
+ //! <b>Complexity</b>: Constant.
key_compare key_comp() const
{ return m_flat_tree.key_comp(); }
+ //! <b>Effects</b>: Returns an object of value_compare constructed out
+ //! of the comparison object.
+ //!
+ //! <b>Complexity</b>: Constant.
value_compare value_comp() const
{ return m_flat_tree.key_comp(); }
+ //! <b>Effects</b>: Returns a copy of the Allocator that
+ //! was passed to the objects constructor.
+ //!
+ //! <b>Complexity</b>: Constant.
allocator_type get_allocator() const
{ return m_flat_tree.get_allocator(); }
+ //! <b>Effects</b>: Returns an iterator to the first element contained in
the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ iterator begin()
+ { return m_flat_tree.begin(); }
+
+ //! <b>Effects</b>: Returns a const_iterator to the first element contained
in the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
const_iterator begin() const
{ return m_flat_tree.begin(); }
+ //! <b>Effects</b>: Returns an iterator to the end of the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ iterator end()
+ { return m_flat_tree.end(); }
+
+ //! <b>Effects</b>: Returns a const_iterator to the end of the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
const_iterator end() const
{ return m_flat_tree.end(); }
+ //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
+ //! of the reversed container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ reverse_iterator rbegin()
+ { return m_flat_tree.rbegin(); }
+
+ //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the
beginning
+ //! of the reversed container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
const_reverse_iterator rbegin() const
{ return m_flat_tree.rbegin(); }
- const_reverse_iterator rend() const
+ //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
+ //! of the reversed container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ reverse_iterator rend()
{ return m_flat_tree.rend(); }
- iterator begin()
- { return m_flat_tree.begin(); }
-
- iterator end()
- { return m_flat_tree.end(); }
-
- reverse_iterator rbegin()
- { return m_flat_tree.rbegin(); }
-
- reverse_iterator rend()
+ //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
+ //! of the reversed container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
+ const_reverse_iterator rend() const
{ return m_flat_tree.rend(); }
+ //! <b>Effects</b>: Returns true if the container contains no elements.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
bool empty() const
{ return m_flat_tree.empty(); }
+ //! <b>Effects</b>: Returns the number of the elements contained in the
container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
size_type size() const
{ return m_flat_tree.size(); }
+ //! <b>Effects</b>: Returns the largest possible size of the container.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
size_type max_size() const
{ return m_flat_tree.max_size(); }
+ //! <b>Effects</b>: Swaps the contents of *this and x.
+ //! If this->allocator_type() != x.allocator_type() allocators are also
swapped.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
void swap(flat_multiset<T,Pred,Alloc>& x)
{ m_flat_tree.swap(x.m_flat_tree); }
+ //! <b>Effects</b>: Swaps the contents of *this and x.
+ //! If this->allocator_type() != x.allocator_type() allocators are also
swapped.
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
void swap(const detail::moved_object<flat_multiset<T,Pred,Alloc> >& mx)
{ this->swap(mx.get()); }
- // insert/erase
+ //! <b>Effects</b>: Inserts x and returns the iterator pointing to the
+ //! newly inserted element.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
iterator insert(const value_type& x)
{ return m_flat_tree.insert_equal(x); }
+ //! <b>Effects</b>: Inserts a new value_type move constructed from x
+ //! and returns the iterator pointing to the newly inserted element.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time plus linear insertion
+ //! to the elements with bigger keys than x.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
iterator insert(const detail::moved_object<value_type>& x)
{ return m_flat_tree.insert_equal(x); }
+ //! <b>Effects</b>: Inserts a copy of x in the container.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! <b>Returns</b>: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
+ //! right before p) plus insertion linear to the elements with bigger
keys than x.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
iterator insert(iterator position, const value_type& x)
{ return m_flat_tree.insert_equal(position, x); }
+ //! <b>Effects</b>: Inserts a new value move constructed from x in the
container.
+ //! p is a hint pointing to where the insert should start to search.
+ //!
+ //! <b>Returns</b>: An iterator pointing to the element with key equivalent
+ //! to the key of x.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted
+ //! right before p) plus insertion linear to the elements with bigger
keys than x.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
iterator insert(iterator position, const detail::moved_object<value_type>&
x)
{ return m_flat_tree.insert_equal(position, x); }
+ //! <b>Requires</b>: i, j are not iterators into *this.
+ //!
+ //! <b>Effects</b>: inserts each element from the range [i,j) .
+ //!
+ //! <b>Complexity</b>: N log(size()+N) (N is the distance from i to j)
+ //! search time plus N*size() insertion time.
+ //!
+ //! <b>Note</b>: If an element it's inserted it might invalidate elements.
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{ m_flat_tree.insert_equal(first, last); }
+ //! <b>Effects</b>: Erases the element pointed to by position.
+ //!
+ //! <b>Returns</b>: Returns an iterator pointing to the element immediately
+ //! following q prior to the element being erased. If no such element
exists,
+ //! returns end().
+ //!
+ //! <b>Complexity</b>: Linear to the elements with keys bigger than position
+ //!
+ //! <b>Note</b>: Invalidates elements with keys
+ //! not less than the erased element.
iterator erase(const_iterator position)
{ return m_flat_tree.erase(position); }
+ //! <b>Effects</b>: Erases all elements in the container with key
equivalent to x.
+ //!
+ //! <b>Returns</b>: Returns the number of erased elements.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time plus erasure time
+ //! linear to the elements with bigger keys.
size_type erase(const key_type& x)
{ return m_flat_tree.erase(x); }
- iterator erase(const_iterator first, const_iterator last)
- { return m_flat_tree.erase(first, last); }
+ //! <b>Effects</b>: Erases all the elements in the range [first, last).
+ //!
+ //! <b>Returns</b>: Returns last.
+ //!
+ //! <b>Complexity</b>: size()*N where N is the distance from first to last.
+ //!
+ //! <b>Complexity</b>: Logarithmic search time plus erasure time
+ //! linear to the elements with bigger keys.
+ iterator erase(const_iterator first, const_iterator last)
+ { return m_flat_tree.erase(first, last); }
+ //! <b>Effects</b>: erase(a.begin(),a.end()).
+ //!
+ //! <b>Postcondition</b>: size() == 0.
+ //!
+ //! <b>Complexity</b>: linear in size().
void clear()
{ m_flat_tree.clear(); }
- // flat_multiset operations:
- const_iterator find(const key_type& x) const
+ //! <b>Returns</b>: An iterator pointing to an element with the key
+ //! equivalent to x, or end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic.
+ iterator find(const key_type& x)
{ return m_flat_tree.find(x); }
- iterator find(const key_type& x)
+ //! <b>Returns</b>: A const_iterator pointing to an element with the key
+ //! equivalent to x, or end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic.s
+ const_iterator find(const key_type& x) const
{ return m_flat_tree.find(x); }
+ //! <b>Returns</b>: The number of elements with key equivalent to x.
+ //!
+ //! <b>Complexity</b>: log(size())+count(k)
size_type count(const key_type& x) const
- { return m_flat_tree.count(x); }
+ { return m_flat_tree.count(x); }
- const_iterator lower_bound(const key_type& x) const
+ //! <b>Returns</b>: An iterator pointing to the first element with key not
less
+ //! than k, or a.end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic
+ iterator lower_bound(const key_type& x)
{ return m_flat_tree.lower_bound(x); }
- iterator lower_bound(const key_type& x)
+ //! <b>Returns</b>: A const iterator pointing to the first element with key
not
+ //! less than k, or a.end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic
+ const_iterator lower_bound(const key_type& x) const
{ return m_flat_tree.lower_bound(x); }
- const_iterator upper_bound(const key_type& x) const
+ //! <b>Returns</b>: An iterator pointing to the first element with key not
less
+ //! than x, or end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic
+ iterator upper_bound(const key_type& x)
{ return m_flat_tree.upper_bound(x); }
- iterator upper_bound(const key_type& x)
+ //! <b>Returns</b>: A const iterator pointing to the first element with key
not
+ //! less than x, or end() if such an element is not found.
+ //!
+ //! <b>Complexity</b>: Logarithmic
+ const_iterator upper_bound(const key_type& x) const
{ return m_flat_tree.upper_bound(x); }
+ //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k),
this->upper_bound(k)).
+ //!
+ //! <b>Complexity</b>: Logarithmic
std::pair<const_iterator, const_iterator>
equal_range(const key_type& x) const
{ return m_flat_tree.equal_range(x); }
+ //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k),
this->upper_bound(k)).
+ //!
+ //! <b>Complexity</b>: Logarithmic
std::pair<iterator,iterator>
equal_range(const key_type& x)
{ return m_flat_tree.equal_range(x); }
+ //! <b>Effects</b>: Number of elements for which memory has been allocated.
+ //! capacity() is always greater than or equal to size().
+ //!
+ //! <b>Throws</b>: Nothing.
+ //!
+ //! <b>Complexity</b>: Constant.
size_type capacity() const
{ return m_flat_tree.capacity(); }
+ //! <b>Effects</b>: If n is less than or equal to capacity(), this call has
no
+ //! effect. Otherwise, it is a request for allocation of additional
memory.
+ //! If the request is successful, then capacity() is greater than or
equal to
+ //! n; otherwise, capacity() is unchanged. In either case, size() is
unchanged.
+ //!
+ //! <b>Throws</b>: If memory allocation allocation throws or T's copy
constructor throws.
+ //!
+ //! <b>Note</b>: If capacity() is less than "count", iterators and
references to
+ //! to values might be invalidated.
void reserve(size_type count)
{ m_flat_tree.reserve(count); }
+ /// @cond
template <class K1, class C1, class A1>
friend bool operator== (const flat_multiset<K1,C1,A1>&,
const flat_multiset<K1,C1,A1>&);
template <class K1, class C1, class A1>
friend bool operator< (const flat_multiset<K1,C1,A1>&,
const flat_multiset<K1,C1,A1>&);
+ /// @endcond
};
template <class T, class Pred, class Alloc>
@@ -527,6 +957,7 @@
const detail::moved_object<flat_multiset<T,Pred,Alloc> >& y)
{ x.swap(y.get()); }
+/// @cond
/*!This class is movable*/
template <class T, class P, class A>
struct is_movable<flat_multiset<T, P, A> >
@@ -534,12 +965,19 @@
enum { value = true };
};
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class T, class C, class A>
+struct has_trivial_destructor_after_move<flat_multiset<T, C, A> >
+{
+ enum { value =
+ has_trivial_destructor<A>::value &&
+ has_trivial_destructor<C>::value };
+};
+/// @endcond
+
}} //namespace boost { namespace interprocess {
#include <boost/interprocess/detail/config_end.hpp>
#endif /* BOOST_INTERPROCESS_SHMEM_FLAT_SET_HPP */
-
-// Local Variables:
-// mode:C++
-// End:
Index: list.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/list.hpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- list.hpp 2 Dec 2006 00:00:50 -0000 1.4
+++ list.hpp 4 May 2007 20:53:08 -0000 1.5
@@ -1,3 +1,18 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztañaga 2005-2007. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file comes from SGI's stl_list.h file. Modified by Ion Gaztañaga 2004
[...1762 lines suppressed...]
-template <class T, class A>
-struct is_movable<detail::interprocess_list_alloc<T, A> >
+template <class A>
+struct is_movable<detail::list_alloc<A> >
{
enum { value = true };
};
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class T, class A>
+struct has_trivial_destructor_after_move<list<T, A> >
+{
+ enum { value = has_trivial_destructor<A>::value };
+};
+/// @endcond
+
} //namespace interprocess {
} //namespace boost {
Index: map.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/map.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- map.hpp 15 Oct 2006 13:11:06 -0000 1.2
+++ map.hpp 4 May 2007 20:53:08 -0000 1.3
@@ -1,3 +1,18 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gazta�ga 2005-2007. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file comes from SGI's stl_map/stl_multimap files. Modified by Ion
Gazta�ga 2004.
[...1185 lines suppressed...]
template <class T, class P, class A>
struct is_movable<multimap<T, P, A> >
{
enum { value = true };
};
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class K, class T, class C, class A>
+struct has_trivial_destructor_after_move<multimap<K, T, C, A> >
+{
+ enum { value =
+ has_trivial_destructor<A>::value &&
+ has_trivial_destructor<C>::value };
+};
+/// @endcond
+
}} //namespace boost { namespace interprocess {
#include <boost/interprocess/detail/config_end.hpp>
Index: set.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/set.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- set.hpp 17 Oct 2006 05:09:40 -0000 1.3
+++ set.hpp 4 May 2007 20:53:08 -0000 1.4
@@ -1,3 +1,18 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztañaga 2005-2007. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file comes from SGI's stl_set/stl_multiset files. Modified by Ion
Gaztañaga 2004.
[...961 lines suppressed...]
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class T, class C, class A>
+struct has_trivial_destructor_after_move<multiset<T, C, A> >
+{
+ enum { value =
+ has_trivial_destructor<A>::value &&
+ has_trivial_destructor<C>::value };
+};
+/// @endcond
}} //namespace boost { namespace interprocess {
@@ -535,6 +956,3 @@
#endif /* BOOST_INTERPROCESS_SET_HPP */
-// Local Variables:
-// mode:C++
-// End:
Index: slist.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/slist.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- slist.hpp 2 Dec 2006 00:00:50 -0000 1.3
+++ slist.hpp 4 May 2007 20:53:08 -0000 1.4
@@ -1,3 +1,18 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztañaga 2004-2007. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This file comes from SGI's stl_slist.h file. Modified by Ion Gaztañaga
2004-2007
[...2138 lines suppressed...]
typename Container::iterator i,
bool is_previous = false)
- : container(&x), iter(is_previous ? i : x.previous(i)) { }
+ : container(&x), iter(is_previous ? i : x.previous(i)){ }
insert_iterator<Container>&
operator=(const typename Container::value_type& value)
@@ -1270,9 +1428,9 @@
iter = container->insert_after(iter, value);
return *this;
}
- insert_iterator<Container>& operator*() { return *this; }
- insert_iterator<Container>& operator++() { return *this; }
- insert_iterator<Container>& operator++(int) { return *this; }
+ insert_iterator<Container>& operator*(){ return *this; }
+ insert_iterator<Container>& operator++(){ return *this; }
+ insert_iterator<Container>& operator++(int){ return *this; }
};
} //namespace std;
Index: string.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/string.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- string.hpp 15 Oct 2006 13:14:54 -0000 1.3
+++ string.hpp 4 May 2007 20:53:08 -0000 1.4
@@ -1,18 +1,6 @@
-/*
- * Copyright (c) 1997-1999
- * Silicon Graphics Computer Systems, Inc.
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation. Silicon Graphics makes no
- * representations about the suitability of this software for any
- * purpose. It is provided "as is" without express or implied warranty.
[...1850 lines suppressed...]
/*!This class is movable*/
template <class A>
-struct is_movable<basic_string_base<A> >
+struct is_movable<detail::basic_string_base<A> >
{
enum { value = true };
};
-typedef basic_string<char, std::char_traits<char>, std::allocator<char> >
string;
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class C, class T, class A>
+struct has_trivial_destructor_after_move<basic_string<C, T, A> >
+{
+ enum { value = has_trivial_destructor<A>::value };
+};
+/// @endcond
}} //namespace boost { namespace interprocess
Index: vector.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/interprocess/containers/vector.hpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- vector.hpp 15 Oct 2006 13:11:06 -0000 1.4
+++ vector.hpp 4 May 2007 20:53:08 -0000 1.5
@@ -1,32 +1,6 @@
-/*
- *
- * Copyright (c) 1994
- * Hewlett-Packard Company
- *
- * Permission to use, copy, modify, distribute and sell this software
- * and its documentation for any purpose is hereby granted without fee,
- * provided that the above copyright notice appear in all copies and
- * that both that copyright notice and this permission notice appear
- * in supporting documentation. Hewlett-Packard Company makes no
- * representations about the suitability of this software for any
[...1097 lines suppressed...]
+/// @cond
/*!This class is movable*/
template <class T, class A>
struct is_movable<vector<T, A> >
@@ -1377,6 +1684,15 @@
enum { value = true };
};
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class T, class A>
+struct has_trivial_destructor_after_move<vector<T, A> >
+{
+ enum { value = has_trivial_destructor<A>::value };
+};
+/// @endcond
+
} //namespace interprocess {
} //namespace boost {
-------------------------------------------------------------------------
This SF.net email is sponsored by DB2 Express
Download DB2 Express C - the FREE version of DB2 express and take
control of your XML. No limits. Just data. Click to get it now.
http://sourceforge.net/powerbar/db2/
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
