You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by be...@apache.org on 2011/06/05 08:40:27 UTC
svn commit: r1131945 [15/15] - in
/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0:
./ boost/ boost/bind/ boost/detail/ boost/exception/ boost/functional/
boost/functional/detail/ boost/functional/hash/ boost/integer/ boost/ms...
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/detail/move.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/detail/move.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/detail/move.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/detail/move.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,228 @@
+/*
+ Copyright 2005-2007 Adobe Systems Incorporated
+
+ Use, modification and distribution are subject to 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).
+*/
+
+/*************************************************************************************************/
+
+#ifndef BOOST_UNORDERED_DETAIL_MOVE_HEADER
+#define BOOST_UNORDERED_DETAIL_MOVE_HEADER
+
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/unordered/detail/config.hpp>
+
+/*************************************************************************************************/
+
+namespace boost {
+namespace unordered_detail {
+
+/*************************************************************************************************/
+
+namespace move_detail {
+
+/*************************************************************************************************/
+
+#if !defined(BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN)
+
+/*************************************************************************************************/
+
+template <typename T>
+struct class_has_move_assign {
+ class type {
+ typedef T& (T::*E)(T t);
+ typedef char (&no_type)[1];
+ typedef char (&yes_type)[2];
+ template <E e> struct sfinae { typedef yes_type type; };
+ template <class U>
+ static typename sfinae<&U::operator=>::type test(int);
+ template <class U>
+ static no_type test(...);
+ public:
+ enum {value = sizeof(test<T>(1)) == sizeof(yes_type)};
+ };
+ };
+
+/*************************************************************************************************/
+
+template<typename T>
+struct has_move_assign : boost::mpl::and_<boost::is_class<T>, class_has_move_assign<T> > {};
+
+/*************************************************************************************************/
+
+class test_can_convert_anything { };
+
+/*************************************************************************************************/
+
+#endif // BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+
+/*************************************************************************************************/
+
+/*
+ REVISIT (sparent@adobe.com): This is a work around for Boost 1.34.1 and VC++ 2008 where
+ boost::is_convertible<T, T> fails to compile.
+*/
+
+template <typename T, typename U>
+struct is_convertible : boost::mpl::or_<
+ boost::is_same<T, U>,
+ boost::is_convertible<T, U>
+> { };
+
+/*************************************************************************************************/
+
+} //namespace move_detail
+
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief move_from is used for move_ctors.
+*/
+
+template <typename T>
+struct move_from
+{
+ explicit move_from(T& x) : source(x) { }
+ T& source;
+};
+
+/*************************************************************************************************/
+
+#if !defined(BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN)
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief The is_movable trait can be used to identify movable types.
+*/
+template <typename T>
+struct is_movable : boost::mpl::and_<
+ boost::is_convertible<move_from<T>, T>,
+ move_detail::has_move_assign<T>,
+ boost::mpl::not_<boost::is_convertible<move_detail::test_can_convert_anything, T> >
+ > { };
+
+/*************************************************************************************************/
+
+#else // BOOST_UNORDERED_NO_HAS_MOVE_ASSIGN
+
+// On compilers which don't have adequate SFINAE support, treat most types as unmovable,
+// unless the trait is specialized.
+
+template <typename T>
+struct is_movable : boost::mpl::false_ { };
+
+#endif
+
+/*************************************************************************************************/
+
+#if !defined(BOOST_NO_SFINAE)
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief copy_sink and move_sink are used to select between overloaded operations according to
+ whether type T is movable and convertible to type U.
+\sa move
+*/
+
+template <typename T,
+ typename U = T,
+ typename R = void*>
+struct copy_sink : boost::enable_if<
+ boost::mpl::and_<
+ boost::unordered_detail::move_detail::is_convertible<T, U>,
+ boost::mpl::not_<is_movable<T> >
+ >,
+ R
+ >
+{ };
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief move_sink and copy_sink are used to select between overloaded operations according to
+ whether type T is movable and convertible to type U.
+ \sa move
+*/
+
+template <typename T,
+ typename U = T,
+ typename R = void*>
+struct move_sink : boost::enable_if<
+ boost::mpl::and_<
+ boost::unordered_detail::move_detail::is_convertible<T, U>,
+ is_movable<T>
+ >,
+ R
+ >
+{ };
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief This version of move is selected when T is_movable . It in turn calls the move
+constructor. This call, with the help of the return value optimization, will cause x to be moved
+instead of copied to its destination. See adobe/test/move/main.cpp for examples.
+
+*/
+template <typename T>
+T move(T& x, typename move_sink<T>::type = 0) { return T(move_from<T>(x)); }
+
+/*************************************************************************************************/
+
+/*!
+\ingroup move_related
+\brief This version of move is selected when T is not movable . The net result will be that
+x gets copied.
+*/
+template <typename T>
+T& move(T& x, typename copy_sink<T>::type = 0) { return x; }
+
+/*************************************************************************************************/
+
+#else // BOOST_NO_SFINAE
+
+// On compilers without SFINAE, define copy_sink to always use the copy function.
+
+template <typename T,
+ typename U = T,
+ typename R = void*>
+struct copy_sink
+{
+ typedef R type;
+};
+
+// Always copy the element unless this is overloaded.
+
+template <typename T>
+T& move(T& x) {
+ return x;
+}
+
+#endif // BOOST_NO_SFINAE
+
+} // namespace unordered_detail
+} // namespace boost
+
+/*************************************************************************************************/
+
+#endif
+
+/*************************************************************************************************/
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_map.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_map.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_map.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_map.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,788 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2008 Daniel James.
+// 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/unordered for documentation
+
+#ifndef BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED
+#define BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/unordered_map_fwd.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/unordered/detail/hash_table.hpp>
+
+#if !defined(BOOST_HAS_RVALUE_REFS)
+#include <boost/unordered/detail/move.hpp>
+#endif
+
+namespace boost
+{
+ template <class Key, class T, class Hash, class Pred, class Alloc>
+ class unordered_map
+ {
+ typedef boost::unordered_detail::hash_types_unique_keys<
+ std::pair<const Key, T>, Key, Hash, Pred, Alloc
+ > implementation;
+
+ BOOST_DEDUCED_TYPENAME implementation::hash_table base;
+
+ public:
+
+ // types
+
+ typedef Key key_type;
+ typedef std::pair<const Key, T> value_type;
+ typedef T mapped_type;
+ typedef Hash hasher;
+ typedef Pred key_equal;
+
+ typedef Alloc allocator_type;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
+
+ typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
+ typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
+
+ typedef BOOST_DEDUCED_TYPENAME implementation::iterator iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::local_iterator local_iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
+
+ // construct/destroy/copy
+
+ explicit unordered_map(
+ size_type n = boost::unordered_detail::default_initial_bucket_count,
+ const hasher &hf = hasher(),
+ const key_equal &eql = key_equal(),
+ const allocator_type &a = allocator_type())
+ : base(n, hf, eql, a)
+ {
+ }
+
+ explicit unordered_map(allocator_type const& a)
+ : base(boost::unordered_detail::default_initial_bucket_count,
+ hasher(), key_equal(), a)
+ {
+ }
+
+ unordered_map(unordered_map const& other, allocator_type const& a)
+ : base(other.base, a)
+ {
+ }
+
+ template <class InputIterator>
+ unordered_map(InputIterator f, InputIterator l)
+ : base(f, l, boost::unordered_detail::default_initial_bucket_count,
+ hasher(), key_equal(), allocator_type())
+ {
+ }
+
+ template <class InputIterator>
+ unordered_map(InputIterator f, InputIterator l,
+ size_type n,
+ const hasher &hf = hasher(),
+ const key_equal &eql = key_equal(),
+ const allocator_type &a = allocator_type())
+ : base(f, l, n, hf, eql, a)
+ {
+ }
+
+#if defined(BOOST_HAS_RVALUE_REFS)
+ unordered_map(unordered_map&& other)
+ : base(other.base, boost::unordered_detail::move_tag())
+ {
+ }
+
+ unordered_map(unordered_map&& other, allocator_type const& a)
+ : base(other.base, a, boost::unordered_detail::move_tag())
+ {
+ }
+
+ unordered_map& operator=(unordered_map&& x)
+ {
+ base.move(x.base);
+ return *this;
+ }
+#else
+ unordered_map(boost::unordered_detail::move_from<unordered_map<Key, T, Hash, Pred, Alloc> > other)
+ : base(other.source.base, boost::unordered_detail::move_tag())
+ {
+ }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
+ unordered_map& operator=(unordered_map x)
+ {
+ base.move(x.base);
+ return *this;
+ }
+#endif
+#endif
+
+ private:
+
+ BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
+ get(const_iterator const& it)
+ {
+ return boost::unordered_detail::iterator_access::get(it);
+ }
+
+ public:
+
+ allocator_type get_allocator() const
+ {
+ return base.get_allocator();
+ }
+
+ // size and capacity
+
+ bool empty() const
+ {
+ return base.empty();
+ }
+
+ size_type size() const
+ {
+ return base.size();
+ }
+
+ size_type max_size() const
+ {
+ return base.max_size();
+ }
+
+ // iterators
+
+ iterator begin()
+ {
+ return iterator(base.data_.begin());
+ }
+
+ const_iterator begin() const
+ {
+ return const_iterator(base.data_.begin());
+ }
+
+ iterator end()
+ {
+ return iterator(base.data_.end());
+ }
+
+ const_iterator end() const
+ {
+ return const_iterator(base.data_.end());
+ }
+
+ const_iterator cbegin() const
+ {
+ return const_iterator(base.data_.begin());
+ }
+
+ const_iterator cend() const
+ {
+ return const_iterator(base.data_.end());
+ }
+
+ // modifiers
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+ template <class... Args>
+ std::pair<iterator, bool> emplace(Args&&... args)
+ {
+ return boost::unordered_detail::pair_cast<iterator, bool>(
+ base.insert(std::forward<Args>(args)...));
+ }
+
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ {
+ return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+ }
+#endif
+
+ std::pair<iterator, bool> insert(const value_type& obj)
+ {
+ return boost::unordered_detail::pair_cast<iterator, bool>(
+ base.insert(obj));
+ }
+
+ iterator insert(const_iterator hint, const value_type& obj)
+ {
+ return iterator(base.insert_hint(get(hint), obj));
+ }
+
+ template <class InputIterator>
+ void insert(InputIterator first, InputIterator last)
+ {
+ base.insert_range(first, last);
+ }
+
+ iterator erase(const_iterator position)
+ {
+ return iterator(base.data_.erase(get(position)));
+ }
+
+ size_type erase(const key_type& k)
+ {
+ return base.erase_key(k);
+ }
+
+ iterator erase(const_iterator first, const_iterator last)
+ {
+ return iterator(base.data_.erase_range(get(first), get(last)));
+ }
+
+ void clear()
+ {
+ base.data_.clear();
+ }
+
+ void swap(unordered_map& other)
+ {
+ base.swap(other.base);
+ }
+
+ // observers
+
+ hasher hash_function() const
+ {
+ return base.hash_function();
+ }
+
+ key_equal key_eq() const
+ {
+ return base.key_eq();
+ }
+
+ mapped_type& operator[](const key_type &k)
+ {
+ return base[k].second;
+ }
+
+ mapped_type& at(const key_type& k)
+ {
+ return base.at(k).second;
+ }
+
+ mapped_type const& at(const key_type& k) const
+ {
+ return base.at(k).second;
+ }
+
+ // lookup
+
+ iterator find(const key_type& k)
+ {
+ return iterator(base.find(k));
+ }
+
+ const_iterator find(const key_type& k) const
+ {
+ return const_iterator(base.find(k));
+ }
+
+ size_type count(const key_type& k) const
+ {
+ return base.count(k);
+ }
+
+ std::pair<iterator, iterator>
+ equal_range(const key_type& k)
+ {
+ return boost::unordered_detail::pair_cast<iterator, iterator>(
+ base.equal_range(k));
+ }
+
+ std::pair<const_iterator, const_iterator>
+ equal_range(const key_type& k) const
+ {
+ return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
+ base.equal_range(k));
+ }
+
+ // bucket interface
+
+ size_type bucket_count() const
+ {
+ return base.bucket_count();
+ }
+
+ size_type max_bucket_count() const
+ {
+ return base.max_bucket_count();
+ }
+
+ size_type bucket_size(size_type n) const
+ {
+ return base.data_.bucket_size(n);
+ }
+
+ size_type bucket(const key_type& k) const
+ {
+ return base.bucket(k);
+ }
+
+ local_iterator begin(size_type n)
+ {
+ return local_iterator(base.data_.begin(n));
+ }
+
+ const_local_iterator begin(size_type n) const
+ {
+ return const_local_iterator(base.data_.begin(n));
+ }
+
+ local_iterator end(size_type n)
+ {
+ return local_iterator(base.data_.end(n));
+ }
+
+ const_local_iterator end(size_type n) const
+ {
+ return const_local_iterator(base.data_.end(n));
+ }
+
+ const_local_iterator cbegin(size_type n) const
+ {
+ return const_local_iterator(base.data_.begin(n));
+ }
+
+ const_local_iterator cend(size_type n) const
+ {
+ return const_local_iterator(base.data_.end(n));
+ }
+
+ // hash policy
+
+ float load_factor() const
+ {
+ return base.load_factor();
+ }
+
+ float max_load_factor() const
+ {
+ return base.max_load_factor();
+ }
+
+ void max_load_factor(float m)
+ {
+ base.max_load_factor(m);
+ }
+
+ void rehash(size_type n)
+ {
+ base.rehash(n);
+ }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+ friend bool operator==(unordered_map const&, unordered_map const&);
+ friend bool operator!=(unordered_map const&, unordered_map const&);
+#else
+ friend bool operator==<>(unordered_map const&, unordered_map const&);
+ friend bool operator!=<>(unordered_map const&, unordered_map const&);
+#endif
+ }; // class template unordered_map
+
+ template <class K, class T, class H, class P, class A>
+ inline bool operator==(unordered_map<K, T, H, P, A> const& m1,
+ unordered_map<K, T, H, P, A> const& m2)
+ {
+ return boost::unordered_detail::equals(m1.base, m2.base);
+ }
+
+ template <class K, class T, class H, class P, class A>
+ inline bool operator!=(unordered_map<K, T, H, P, A> const& m1,
+ unordered_map<K, T, H, P, A> const& m2)
+ {
+ return !boost::unordered_detail::equals(m1.base, m2.base);
+ }
+
+ template <class K, class T, class H, class P, class A>
+ inline void swap(unordered_map<K, T, H, P, A> &m1,
+ unordered_map<K, T, H, P, A> &m2)
+ {
+ m1.swap(m2);
+ }
+
+ template <class Key, class T, class Hash, class Pred, class Alloc>
+ class unordered_multimap
+ {
+ typedef boost::unordered_detail::hash_types_equivalent_keys<
+ std::pair<const Key, T>, Key, Hash, Pred, Alloc
+ > implementation;
+
+ BOOST_DEDUCED_TYPENAME implementation::hash_table base;
+
+ public:
+
+ // types
+
+ typedef Key key_type;
+ typedef std::pair<const Key, T> value_type;
+ typedef T mapped_type;
+ typedef Hash hasher;
+ typedef Pred key_equal;
+
+ typedef Alloc allocator_type;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
+
+ typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
+ typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
+
+ typedef BOOST_DEDUCED_TYPENAME implementation::iterator iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::local_iterator local_iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
+
+ // construct/destroy/copy
+
+ explicit unordered_multimap(
+ size_type n = boost::unordered_detail::default_initial_bucket_count,
+ const hasher &hf = hasher(),
+ const key_equal &eql = key_equal(),
+ const allocator_type &a = allocator_type())
+ : base(n, hf, eql, a)
+ {
+ }
+
+ explicit unordered_multimap(allocator_type const& a)
+ : base(boost::unordered_detail::default_initial_bucket_count,
+ hasher(), key_equal(), a)
+ {
+ }
+
+ unordered_multimap(unordered_multimap const& other, allocator_type const& a)
+ : base(other.base, a)
+ {
+ }
+
+ template <class InputIterator>
+ unordered_multimap(InputIterator f, InputIterator l)
+ : base(f, l, boost::unordered_detail::default_initial_bucket_count,
+ hasher(), key_equal(), allocator_type())
+ {
+ }
+
+ template <class InputIterator>
+ unordered_multimap(InputIterator f, InputIterator l,
+ size_type n,
+ const hasher &hf = hasher(),
+ const key_equal &eql = key_equal(),
+ const allocator_type &a = allocator_type())
+ : base(f, l, n, hf, eql, a)
+ {
+ }
+
+#if defined(BOOST_HAS_RVALUE_REFS)
+ unordered_multimap(unordered_multimap&& other)
+ : base(other.base, boost::unordered_detail::move_tag())
+ {
+ }
+
+ unordered_multimap(unordered_multimap&& other, allocator_type const& a)
+ : base(other.base, a, boost::unordered_detail::move_tag())
+ {
+ }
+
+ unordered_multimap& operator=(unordered_multimap&& x)
+ {
+ base.move(x.base);
+ return *this;
+ }
+#else
+ unordered_multimap(boost::unordered_detail::move_from<unordered_multimap<Key, T, Hash, Pred, Alloc> > other)
+ : base(other.source.base, boost::unordered_detail::move_tag())
+ {
+ }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
+ unordered_multimap& operator=(unordered_multimap x)
+ {
+ base.move(x.base);
+ return *this;
+ }
+#endif
+#endif
+
+
+ private:
+
+ BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
+ get(const_iterator const& it)
+ {
+ return boost::unordered_detail::iterator_access::get(it);
+ }
+
+ public:
+
+ allocator_type get_allocator() const
+ {
+ return base.get_allocator();
+ }
+
+ // size and capacity
+
+ bool empty() const
+ {
+ return base.empty();
+ }
+
+ size_type size() const
+ {
+ return base.size();
+ }
+
+ size_type max_size() const
+ {
+ return base.max_size();
+ }
+
+ // iterators
+
+ iterator begin()
+ {
+ return iterator(base.data_.begin());
+ }
+
+ const_iterator begin() const
+ {
+ return const_iterator(base.data_.begin());
+ }
+
+ iterator end()
+ {
+ return iterator(base.data_.end());
+ }
+
+ const_iterator end() const
+ {
+ return const_iterator(base.data_.end());
+ }
+
+ const_iterator cbegin() const
+ {
+ return const_iterator(base.data_.begin());
+ }
+
+ const_iterator cend() const
+ {
+ return const_iterator(base.data_.end());
+ }
+
+ // modifiers
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+ template <class... Args>
+ iterator emplace(Args&&... args)
+ {
+ return iterator(base.insert(std::forward<Args>(args)...));
+ }
+
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ {
+ return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+ }
+#endif
+
+ iterator insert(const value_type& obj)
+ {
+ return iterator(base.insert(obj));
+ }
+
+ iterator insert(const_iterator hint, const value_type& obj)
+ {
+ return iterator(base.insert_hint(get(hint), obj));
+ }
+
+ template <class InputIterator>
+ void insert(InputIterator first, InputIterator last)
+ {
+ base.insert_range(first, last);
+ }
+
+ iterator erase(const_iterator position)
+ {
+ return iterator(base.data_.erase(get(position)));
+ }
+
+ size_type erase(const key_type& k)
+ {
+ return base.erase_key(k);
+ }
+
+ iterator erase(const_iterator first, const_iterator last)
+ {
+ return iterator(base.data_.erase_range(get(first), get(last)));
+ }
+
+ void clear()
+ {
+ base.data_.clear();
+ }
+
+ void swap(unordered_multimap& other)
+ {
+ base.swap(other.base);
+ }
+
+ // observers
+
+ hasher hash_function() const
+ {
+ return base.hash_function();
+ }
+
+ key_equal key_eq() const
+ {
+ return base.key_eq();
+ }
+
+ // lookup
+
+ iterator find(const key_type& k)
+ {
+ return iterator(base.find(k));
+ }
+
+ const_iterator find(const key_type& k) const
+ {
+ return const_iterator(base.find(k));
+ }
+
+ size_type count(const key_type& k) const
+ {
+ return base.count(k);
+ }
+
+ std::pair<iterator, iterator>
+ equal_range(const key_type& k)
+ {
+ return boost::unordered_detail::pair_cast<iterator, iterator>(
+ base.equal_range(k));
+ }
+
+ std::pair<const_iterator, const_iterator>
+ equal_range(const key_type& k) const
+ {
+ return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
+ base.equal_range(k));
+ }
+
+ // bucket interface
+
+ size_type bucket_count() const
+ {
+ return base.bucket_count();
+ }
+
+ size_type max_bucket_count() const
+ {
+ return base.max_bucket_count();
+ }
+
+ size_type bucket_size(size_type n) const
+ {
+ return base.data_.bucket_size(n);
+ }
+
+ size_type bucket(const key_type& k) const
+ {
+ return base.bucket(k);
+ }
+
+ local_iterator begin(size_type n)
+ {
+ return local_iterator(base.data_.begin(n));
+ }
+
+ const_local_iterator begin(size_type n) const
+ {
+ return const_local_iterator(base.data_.begin(n));
+ }
+
+ local_iterator end(size_type n)
+ {
+ return local_iterator(base.data_.end(n));
+ }
+
+ const_local_iterator end(size_type n) const
+ {
+ return const_local_iterator(base.data_.end(n));
+ }
+
+ const_local_iterator cbegin(size_type n) const
+ {
+ return const_local_iterator(base.data_.begin(n));
+ }
+
+ const_local_iterator cend(size_type n) const
+ {
+ return const_local_iterator(base.data_.end(n));
+ }
+
+ // hash policy
+
+ float load_factor() const
+ {
+ return base.load_factor();
+ }
+
+ float max_load_factor() const
+ {
+ return base.max_load_factor();
+ }
+
+ void max_load_factor(float m)
+ {
+ base.max_load_factor(m);
+ }
+
+ void rehash(size_type n)
+ {
+ base.rehash(n);
+ }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+ friend bool operator==(unordered_multimap const&, unordered_multimap const&);
+ friend bool operator!=(unordered_multimap const&, unordered_multimap const&);
+#else
+ friend bool operator==<>(unordered_multimap const&, unordered_multimap const&);
+ friend bool operator!=<>(unordered_multimap const&, unordered_multimap const&);
+#endif
+ }; // class template unordered_multimap
+
+ template <class K, class T, class H, class P, class A>
+ inline bool operator==(unordered_multimap<K, T, H, P, A> const& m1,
+ unordered_multimap<K, T, H, P, A> const& m2)
+ {
+ return boost::unordered_detail::equals(m1.base, m2.base);
+ }
+
+ template <class K, class T, class H, class P, class A>
+ inline bool operator!=(unordered_multimap<K, T, H, P, A> const& m1,
+ unordered_multimap<K, T, H, P, A> const& m2)
+ {
+ return !boost::unordered_detail::equals(m1.base, m2.base);
+ }
+
+ template <class K, class T, class H, class P, class A>
+ inline void swap(unordered_multimap<K, T, H, P, A> &m1,
+ unordered_multimap<K, T, H, P, A> &m2)
+ {
+ m1.swap(m2);
+ }
+
+} // namespace boost
+
+#endif // BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_map_fwd.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_map_fwd.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_map_fwd.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_map_fwd.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,53 @@
+
+// Copyright (C) 2008 Daniel James.
+// 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)
+
+#ifndef BOOST_UNORDERED_MAP_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_MAP_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <memory>
+#include <functional>
+#include <boost/functional/hash_fwd.hpp>
+
+namespace boost
+{
+ template <class Key,
+ class T,
+ class Hash = hash<Key>,
+ class Pred = std::equal_to<Key>,
+ class Alloc = std::allocator<std::pair<const Key, T> > >
+ class unordered_map;
+ template <class K, class T, class H, class P, class A>
+ bool operator==(unordered_map<K, T, H, P, A> const&,
+ unordered_map<K, T, H, P, A> const&);
+ template <class K, class T, class H, class P, class A>
+ bool operator!=(unordered_map<K, T, H, P, A> const&,
+ unordered_map<K, T, H, P, A> const&);
+ template <class K, class T, class H, class P, class A>
+ void swap(unordered_map<K, T, H, P, A>&,
+ unordered_map<K, T, H, P, A>&);
+
+ template <class Key,
+ class T,
+ class Hash = hash<Key>,
+ class Pred = std::equal_to<Key>,
+ class Alloc = std::allocator<std::pair<const Key, T> > >
+ class unordered_multimap;
+ template <class K, class T, class H, class P, class A>
+ bool operator==(unordered_multimap<K, T, H, P, A> const&,
+ unordered_multimap<K, T, H, P, A> const&);
+ template <class K, class T, class H, class P, class A>
+ bool operator!=(unordered_multimap<K, T, H, P, A> const&,
+ unordered_multimap<K, T, H, P, A> const&);
+ template <class K, class T, class H, class P, class A>
+ void swap(unordered_multimap<K, T, H, P, A>&,
+ unordered_multimap<K, T, H, P, A>&);
+}
+
+#endif
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_set.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_set.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_set.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_set.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,745 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2008 Daniel James.
+// 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/unordered for documentation
+
+#ifndef BOOST_UNORDERED_UNORDERED_SET_HPP_INCLUDED
+#define BOOST_UNORDERED_UNORDERED_SET_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/unordered_set_fwd.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/unordered/detail/hash_table.hpp>
+
+#if !defined(BOOST_HAS_RVALUE_REFS)
+#include <boost/unordered/detail/move.hpp>
+#endif
+
+namespace boost
+{
+ template <class Value, class Hash, class Pred, class Alloc>
+ class unordered_set
+ {
+ typedef boost::unordered_detail::hash_types_unique_keys<
+ Value, Value, Hash, Pred, Alloc
+ > implementation;
+
+ BOOST_DEDUCED_TYPENAME implementation::hash_table base;
+
+ public:
+
+ // types
+
+ typedef Value key_type;
+ typedef Value value_type;
+ typedef Hash hasher;
+ typedef Pred key_equal;
+
+ typedef Alloc allocator_type;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
+
+ typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
+ typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
+
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator local_iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
+
+ // construct/destroy/copy
+
+ explicit unordered_set(
+ size_type n = boost::unordered_detail::default_initial_bucket_count,
+ const hasher &hf = hasher(),
+ const key_equal &eql = key_equal(),
+ const allocator_type &a = allocator_type())
+ : base(n, hf, eql, a)
+ {
+ }
+
+ explicit unordered_set(allocator_type const& a)
+ : base(boost::unordered_detail::default_initial_bucket_count,
+ hasher(), key_equal(), a)
+ {
+ }
+
+ unordered_set(unordered_set const& other, allocator_type const& a)
+ : base(other.base, a)
+ {
+ }
+
+ template <class InputIterator>
+ unordered_set(InputIterator f, InputIterator l)
+ : base(f, l, boost::unordered_detail::default_initial_bucket_count,
+ hasher(), key_equal(), allocator_type())
+ {
+ }
+
+ template <class InputIterator>
+ unordered_set(InputIterator f, InputIterator l, size_type n,
+ const hasher &hf = hasher(),
+ const key_equal &eql = key_equal(),
+ const allocator_type &a = allocator_type())
+ : base(f, l, n, hf, eql, a)
+ {
+ }
+
+#if defined(BOOST_HAS_RVALUE_REFS)
+ unordered_set(unordered_set&& other)
+ : base(other.base, boost::unordered_detail::move_tag())
+ {
+ }
+
+ unordered_set(unordered_set&& other, allocator_type const& a)
+ : base(other.base, a, boost::unordered_detail::move_tag())
+ {
+ }
+
+ unordered_set& operator=(unordered_set&& x)
+ {
+ base.move(x.base);
+ return *this;
+ }
+#else
+ unordered_set(boost::unordered_detail::move_from<unordered_set<Value, Hash, Pred, Alloc> > other)
+ : base(other.source.base, boost::unordered_detail::move_tag())
+ {
+ }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
+ unordered_set& operator=(unordered_set x)
+ {
+ base.move(x.base);
+ return *this;
+ }
+#endif
+#endif
+
+ private:
+
+ BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
+ get(const_iterator const& it)
+ {
+ return boost::unordered_detail::iterator_access::get(it);
+ }
+
+ public:
+
+ allocator_type get_allocator() const
+ {
+ return base.get_allocator();
+ }
+
+ // size and capacity
+
+ bool empty() const
+ {
+ return base.empty();
+ }
+
+ size_type size() const
+ {
+ return base.size();
+ }
+
+ size_type max_size() const
+ {
+ return base.max_size();
+ }
+
+ // iterators
+
+ iterator begin()
+ {
+ return iterator(base.data_.begin());
+ }
+
+ const_iterator begin() const
+ {
+ return const_iterator(base.data_.begin());
+ }
+
+ iterator end()
+ {
+ return iterator(base.data_.end());
+ }
+
+ const_iterator end() const
+ {
+ return const_iterator(base.data_.end());
+ }
+
+ const_iterator cbegin() const
+ {
+ return const_iterator(base.data_.begin());
+ }
+
+ const_iterator cend() const
+ {
+ return const_iterator(base.data_.end());
+ }
+
+ // modifiers
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+ template <class... Args>
+ std::pair<iterator, bool> emplace(Args&&... args)
+ {
+ return boost::unordered_detail::pair_cast<iterator, bool>(
+ base.insert(std::forward<Args>(args)...));
+ }
+
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ {
+ return iterator(
+ base.insert_hint(get(hint), std::forward<Args>(args)...));
+ }
+#endif
+
+ std::pair<iterator, bool> insert(const value_type& obj)
+ {
+ return boost::unordered_detail::pair_cast<iterator, bool>(
+ base.insert(obj));
+ }
+
+ iterator insert(const_iterator hint, const value_type& obj)
+ {
+ return iterator(base.insert_hint(get(hint), obj));
+ }
+
+ template <class InputIterator>
+ void insert(InputIterator first, InputIterator last)
+ {
+ base.insert_range(first, last);
+ }
+
+ iterator erase(const_iterator position)
+ {
+ return iterator(base.data_.erase(get(position)));
+ }
+
+ size_type erase(const key_type& k)
+ {
+ return base.erase_key(k);
+ }
+
+ iterator erase(const_iterator first, const_iterator last)
+ {
+ return iterator(base.data_.erase_range(get(first), get(last)));
+ }
+
+ void clear()
+ {
+ base.data_.clear();
+ }
+
+ void swap(unordered_set& other)
+ {
+ base.swap(other.base);
+ }
+
+ // observers
+
+ hasher hash_function() const
+ {
+ return base.hash_function();
+ }
+
+ key_equal key_eq() const
+ {
+ return base.key_eq();
+ }
+
+ // lookup
+
+ const_iterator find(const key_type& k) const
+ {
+ return const_iterator(base.find(k));
+ }
+
+ size_type count(const key_type& k) const
+ {
+ return base.count(k);
+ }
+
+ std::pair<const_iterator, const_iterator>
+ equal_range(const key_type& k) const
+ {
+ return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
+ base.equal_range(k));
+ }
+
+ // bucket interface
+
+ size_type bucket_count() const
+ {
+ return base.bucket_count();
+ }
+
+ size_type max_bucket_count() const
+ {
+ return base.max_bucket_count();
+ }
+
+ size_type bucket_size(size_type n) const
+ {
+ return base.data_.bucket_size(n);
+ }
+
+ size_type bucket(const key_type& k) const
+ {
+ return base.bucket(k);
+ }
+
+ local_iterator begin(size_type n)
+ {
+ return local_iterator(base.data_.begin(n));
+ }
+
+ const_local_iterator begin(size_type n) const
+ {
+ return const_local_iterator(base.data_.begin(n));
+ }
+
+ local_iterator end(size_type n)
+ {
+ return local_iterator(base.data_.end(n));
+ }
+
+ const_local_iterator end(size_type n) const
+ {
+ return const_local_iterator(base.data_.end(n));
+ }
+
+ const_local_iterator cbegin(size_type n) const
+ {
+ return const_local_iterator(base.data_.begin(n));
+ }
+
+ const_local_iterator cend(size_type n) const
+ {
+ return const_local_iterator(base.data_.end(n));
+ }
+
+ // hash policy
+
+ float load_factor() const
+ {
+ return base.load_factor();
+ }
+
+ float max_load_factor() const
+ {
+ return base.max_load_factor();
+ }
+
+ void max_load_factor(float m)
+ {
+ base.max_load_factor(m);
+ }
+
+ void rehash(size_type n)
+ {
+ base.rehash(n);
+ }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+ friend bool operator==(unordered_set const&, unordered_set const&);
+ friend bool operator!=(unordered_set const&, unordered_set const&);
+#else
+ friend bool operator==<>(unordered_set const&, unordered_set const&);
+ friend bool operator!=<>(unordered_set const&, unordered_set const&);
+#endif
+ }; // class template unordered_set
+
+ template <class T, class H, class P, class A>
+ inline bool operator==(unordered_set<T, H, P, A> const& m1,
+ unordered_set<T, H, P, A> const& m2)
+ {
+ return boost::unordered_detail::equals(m1.base, m2.base);
+ }
+
+ template <class T, class H, class P, class A>
+ inline bool operator!=(unordered_set<T, H, P, A> const& m1,
+ unordered_set<T, H, P, A> const& m2)
+ {
+ return !boost::unordered_detail::equals(m1.base, m2.base);
+ }
+
+ template <class T, class H, class P, class A>
+ inline void swap(unordered_set<T, H, P, A> &m1,
+ unordered_set<T, H, P, A> &m2)
+ {
+ m1.swap(m2);
+ }
+
+ template <class Value, class Hash, class Pred, class Alloc>
+ class unordered_multiset
+ {
+ typedef boost::unordered_detail::hash_types_equivalent_keys<
+ Value, Value, Hash, Pred, Alloc
+ > implementation;
+
+ BOOST_DEDUCED_TYPENAME implementation::hash_table base;
+
+ public:
+
+ //types
+
+ typedef Value key_type;
+ typedef Value value_type;
+ typedef Hash hasher;
+ typedef Pred key_equal;
+
+ typedef Alloc allocator_type;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::pointer pointer;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::const_pointer const_pointer;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::reference reference;
+ typedef BOOST_DEDUCED_TYPENAME allocator_type::const_reference const_reference;
+
+ typedef BOOST_DEDUCED_TYPENAME implementation::size_type size_type;
+ typedef BOOST_DEDUCED_TYPENAME implementation::difference_type difference_type;
+
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_iterator const_iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator local_iterator;
+ typedef BOOST_DEDUCED_TYPENAME implementation::const_local_iterator const_local_iterator;
+
+ // construct/destroy/copy
+
+ explicit unordered_multiset(
+ size_type n = boost::unordered_detail::default_initial_bucket_count,
+ const hasher &hf = hasher(),
+ const key_equal &eql = key_equal(),
+ const allocator_type &a = allocator_type())
+ : base(n, hf, eql, a)
+ {
+ }
+
+ explicit unordered_multiset(allocator_type const& a)
+ : base(boost::unordered_detail::default_initial_bucket_count,
+ hasher(), key_equal(), a)
+ {
+ }
+
+ unordered_multiset(unordered_multiset const& other, allocator_type const& a)
+ : base(other.base, a)
+ {
+ }
+
+ template <class InputIterator>
+ unordered_multiset(InputIterator f, InputIterator l)
+ : base(f, l, boost::unordered_detail::default_initial_bucket_count,
+ hasher(), key_equal(), allocator_type())
+ {
+ }
+
+ template <class InputIterator>
+ unordered_multiset(InputIterator f, InputIterator l, size_type n,
+ const hasher &hf = hasher(),
+ const key_equal &eql = key_equal(),
+ const allocator_type &a = allocator_type())
+ : base(f, l, n, hf, eql, a)
+ {
+ }
+
+#if defined(BOOST_HAS_RVALUE_REFS)
+ unordered_multiset(unordered_multiset&& other)
+ : base(other.base, boost::unordered_detail::move_tag())
+ {
+ }
+
+ unordered_multiset(unordered_multiset&& other, allocator_type const& a)
+ : base(other.base, a, boost::unordered_detail::move_tag())
+ {
+ }
+
+ unordered_multiset& operator=(unordered_multiset&& x)
+ {
+ base.move(x.base);
+ return *this;
+ }
+#else
+ unordered_multiset(boost::unordered_detail::move_from<unordered_multiset<Value, Hash, Pred, Alloc> > other)
+ : base(other.source.base, boost::unordered_detail::move_tag())
+ {
+ }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x0593)
+ unordered_multiset& operator=(unordered_multiset x)
+ {
+ base.move(x.base);
+ return *this;
+ }
+#endif
+#endif
+
+ private:
+
+ BOOST_DEDUCED_TYPENAME implementation::iterator_base const&
+ get(const_iterator const& it)
+ {
+ return boost::unordered_detail::iterator_access::get(it);
+ }
+
+ public:
+
+ allocator_type get_allocator() const
+ {
+ return base.get_allocator();
+ }
+
+ // size and capacity
+
+ bool empty() const
+ {
+ return base.empty();
+ }
+
+ size_type size() const
+ {
+ return base.size();
+ }
+
+ size_type max_size() const
+ {
+ return base.max_size();
+ }
+
+ // iterators
+
+ iterator begin()
+ {
+ return iterator(base.data_.begin());
+ }
+
+ const_iterator begin() const
+ {
+ return const_iterator(base.data_.begin());
+ }
+
+ iterator end()
+ {
+ return iterator(base.data_.end());
+ }
+
+ const_iterator end() const
+ {
+ return const_iterator(base.data_.end());
+ }
+
+ const_iterator cbegin() const
+ {
+ return const_iterator(base.data_.begin());
+ }
+
+ const_iterator cend() const
+ {
+ return const_iterator(base.data_.end());
+ }
+
+ // modifiers
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+ template <class... Args>
+ iterator emplace(Args&&... args)
+ {
+ return iterator(base.insert(std::forward<Args>(args)...));
+ }
+
+ template <class... Args>
+ iterator emplace_hint(const_iterator hint, Args&&... args)
+ {
+ return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+ }
+#endif
+
+ iterator insert(const value_type& obj)
+ {
+ return iterator(base.insert(obj));
+ }
+
+ iterator insert(const_iterator hint, const value_type& obj)
+ {
+ return iterator(base.insert_hint(get(hint), obj));
+ }
+
+ template <class InputIterator>
+ void insert(InputIterator first, InputIterator last)
+ {
+ base.insert_range(first, last);
+ }
+
+ iterator erase(const_iterator position)
+ {
+ return iterator(base.data_.erase(get(position)));
+ }
+
+ size_type erase(const key_type& k)
+ {
+ return base.erase_key(k);
+ }
+
+ iterator erase(const_iterator first, const_iterator last)
+ {
+ return iterator(base.data_.erase_range(get(first), get(last)));
+ }
+
+ void clear()
+ {
+ base.data_.clear();
+ }
+
+ void swap(unordered_multiset& other)
+ {
+ base.swap(other.base);
+ }
+
+ // observers
+
+ hasher hash_function() const
+ {
+ return base.hash_function();
+ }
+
+ key_equal key_eq() const
+ {
+ return base.key_eq();
+ }
+
+ // lookup
+
+ const_iterator find(const key_type& k) const
+ {
+ return const_iterator(base.find(k));
+ }
+
+ size_type count(const key_type& k) const
+ {
+ return base.count(k);
+ }
+
+ std::pair<const_iterator, const_iterator>
+ equal_range(const key_type& k) const
+ {
+ return boost::unordered_detail::pair_cast<const_iterator, const_iterator>(
+ base.equal_range(k));
+ }
+
+ // bucket interface
+
+ size_type bucket_count() const
+ {
+ return base.bucket_count();
+ }
+
+ size_type max_bucket_count() const
+ {
+ return base.max_bucket_count();
+ }
+
+ size_type bucket_size(size_type n) const
+ {
+ return base.data_.bucket_size(n);
+ }
+
+ size_type bucket(const key_type& k) const
+ {
+ return base.bucket(k);
+ }
+
+ local_iterator begin(size_type n)
+ {
+ return local_iterator(base.data_.begin(n));
+ }
+
+ const_local_iterator begin(size_type n) const
+ {
+ return const_local_iterator(base.data_.begin(n));
+ }
+
+ local_iterator end(size_type n)
+ {
+ return local_iterator(base.data_.end(n));
+ }
+
+ const_local_iterator end(size_type n) const
+ {
+ return const_local_iterator(base.data_.end(n));
+ }
+
+ const_local_iterator cbegin(size_type n) const
+ {
+ return const_local_iterator(base.data_.begin(n));
+ }
+
+ const_local_iterator cend(size_type n) const
+ {
+ return const_local_iterator(base.data_.end(n));
+ }
+
+ // hash policy
+
+ float load_factor() const
+ {
+ return base.load_factor();
+ }
+
+ float max_load_factor() const
+ {
+ return base.max_load_factor();
+ }
+
+ void max_load_factor(float m)
+ {
+ base.max_load_factor(m);
+ }
+
+ void rehash(size_type n)
+ {
+ base.rehash(n);
+ }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+ friend bool operator==(unordered_multiset const&, unordered_multiset const&);
+ friend bool operator!=(unordered_multiset const&, unordered_multiset const&);
+#else
+ friend bool operator==<>(unordered_multiset const&, unordered_multiset const&);
+ friend bool operator!=<>(unordered_multiset const&, unordered_multiset const&);
+#endif
+ }; // class template unordered_multiset
+
+ template <class T, class H, class P, class A>
+ inline bool operator==(unordered_multiset<T, H, P, A> const& m1,
+ unordered_multiset<T, H, P, A> const& m2)
+ {
+ return boost::unordered_detail::equals(m1.base, m2.base);
+ }
+
+ template <class T, class H, class P, class A>
+ inline bool operator!=(unordered_multiset<T, H, P, A> const& m1,
+ unordered_multiset<T, H, P, A> const& m2)
+ {
+ return !boost::unordered_detail::equals(m1.base, m2.base);
+ }
+
+ template <class T, class H, class P, class A>
+ inline void swap(unordered_multiset<T, H, P, A> &m1,
+ unordered_multiset<T, H, P, A> &m2)
+ {
+ m1.swap(m2);
+ }
+
+} // namespace boost
+
+#endif // BOOST_UNORDERED_UNORDERED_SET_HPP_INCLUDED
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_set_fwd.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_set_fwd.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_set_fwd.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered/unordered_set_fwd.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,51 @@
+
+// Copyright (C) 2008 Daniel James.
+// 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)
+
+#ifndef BOOST_UNORDERED_SET_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_SET_FWD_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <memory>
+#include <functional>
+#include <boost/functional/hash_fwd.hpp>
+
+namespace boost
+{
+ template <class Value,
+ class Hash = hash<Value>,
+ class Pred = std::equal_to<Value>,
+ class Alloc = std::allocator<Value> >
+ class unordered_set;
+ template <class T, class H, class P, class A>
+ bool operator==(unordered_set<T, H, P, A> const&,
+ unordered_set<T, H, P, A> const&);
+ template <class T, class H, class P, class A>
+ bool operator!=(unordered_set<T, H, P, A> const&,
+ unordered_set<T, H, P, A> const&);
+ template <class T, class H, class P, class A>
+ void swap(unordered_set<T, H, P, A> &m1,
+ unordered_set<T, H, P, A> &m2);
+
+ template <class Value,
+ class Hash = hash<Value>,
+ class Pred = std::equal_to<Value>,
+ class Alloc = std::allocator<Value> >
+ class unordered_multiset;
+ template <class T, class H, class P, class A>
+ bool operator==(unordered_multiset<T, H, P, A> const&,
+ unordered_multiset<T, H, P, A> const&);
+ template <class T, class H, class P, class A>
+ bool operator!=(unordered_multiset<T, H, P, A> const&,
+ unordered_multiset<T, H, P, A> const&);
+ template <class T, class H, class P, class A>
+ void swap(unordered_multiset<T, H, P, A> &m1,
+ unordered_multiset<T, H, P, A> &m2);
+}
+
+#endif
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered_map.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered_map.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered_map.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered_map.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,18 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2008 Daniel James.
+// 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/unordered for documentation
+
+#ifndef BOOST_UNORDERED_MAP_HPP_INCLUDED
+#define BOOST_UNORDERED_MAP_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/unordered_map.hpp>
+
+#endif // BOOST_UNORDERED_MAP_HPP_INCLUDED
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered_set.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered_set.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered_set.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/unordered_set.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,18 @@
+
+// Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
+// Copyright (C) 2005-2008 Daniel James.
+// 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/unordered for documentation
+
+#ifndef BOOST_UNORDERED_SET_HPP_INCLUDED
+#define BOOST_UNORDERED_SET_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/unordered/unordered_set.hpp>
+
+#endif // BOOST_UNORDERED_SET_HPP_INCLUDED
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/variant.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/variant.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/variant.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/variant.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,27 @@
+//-----------------------------------------------------------------------------
+// boost variant.hpp header file
+// See http://www.boost.org/libs/variant for documentation.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman, Itay Maman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_HPP
+#define BOOST_VARIANT_HPP
+
+// variant "main"
+#include "boost/variant/variant.hpp"
+#include "boost/variant/recursive_variant.hpp"
+#include "boost/variant/recursive_wrapper.hpp"
+
+// common applications
+#include "boost/variant/get.hpp"
+#include "boost/variant/apply_visitor.hpp"
+#include "boost/variant/static_visitor.hpp"
+#include "boost/variant/visitor_ptr.hpp"
+
+#endif // BOOST_VARIANT_HPP
Added: incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/visit_each.hpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/visit_each.hpp?rev=1131945&view=auto
==============================================================================
--- incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/visit_each.hpp (added)
+++ incubator/mesos/trunk/src/third_party/libprocess/third_party/boost-1.37.0/boost/visit_each.hpp Sun Jun 5 06:40:23 2011
@@ -0,0 +1,29 @@
+// Boost.Signals library
+
+// Copyright Douglas Gregor 2001-2003. Use, modification and
+// distribution is subject to 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)
+
+// For more information, see http://www.boost.org/libs/signals
+
+#ifndef BOOST_VISIT_EACH_HPP
+#define BOOST_VISIT_EACH_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+ template<typename Visitor, typename T>
+ inline void visit_each(Visitor& visitor, const T& t, long)
+ {
+ visitor(t);
+ }
+
+ template<typename Visitor, typename T>
+ inline void visit_each(Visitor& visitor, const T& t)
+ {
+ visit_each(visitor, t, 0);
+ }
+}
+
+#endif // BOOST_VISIT_EACH_HPP