Unordered: Merge from trunk

- Remove use of BOOST_DEDUCED_TYPENAME and BOOST_UNORDERED_PAIR_CAST, it's
  unlikely that the compilers which require them will be able to cope with the
  new version of unordered.
- Use the old equality algorithm if BOOST_UNORDERED_DEPRECATED_EQUALITY is
  defined.
- Use SFINAE to control which overloads of `construct_impl` are available.
  Fixes problems with differing overload resolution on different compilers.
- Support for piecewise pair construction.
- Only support the old variadic pair construction when
  BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT is defined (also fixed some bugs).
- Avoid instantiating BOOST_RV_REF for non-classes.
- Support optional allocator member functions for compilers with SFINAE
  expressions and Visual C++ 9.0/10.0
- Follow boost macro naming conventions.
- Improved portability for `allocator_traits` emulation.

Current compiler support:

- Full support for GCC 4.4+, Visual C++ 9.0+, Clang.
- All other compilers odn't support optional allocator members.
- No other errors for GCC 3.4.6+, Visual C++ 8.0, Intel, Pathscale.
- Visual Age has a compile error if `select_on_container_copy_construction`
  isn't `const` (it should ignore it).
- `select_on_container_copy_construction` detection doesn't work on Sun.
- `unnecessary_copy_tests` is failling for vacpp on AIX, but not on linux.
- Warnings causing failures for Visual C++ with STLport and WM5.


[SVN r74234]

test/unordered/unnecessary_copy_tests.cpp

@@ -1,4 +1,4 @@
-
+#include <iostream>
 // Copyright 2006-2009 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)
@@ -327,6 +327,13 @@ namespace unnecessary_copy_tests
         x.emplace();
         COPY_COUNT(2); MOVE_COUNT(0);
 
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                boost::make_tuple(),
+                boost::make_tuple());
+        COPY_COUNT(2); MOVE_COUNT(0);
+
+
         //
         // 1 argument
         //
@@ -345,19 +352,23 @@ namespace unnecessary_copy_tests
     (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 2) || \
     (defined(BOOST_MSVC) && BOOST_MSVC >= 1600 ) || \
     (!defined(__GNUC__) && !defined(BOOST_MSVC))
+
         count_copies part;
         reset();
         std::pair<count_copies const&, count_copies const&> a_ref(part, part);
         x.emplace(a_ref);
         COPY_COUNT(2); MOVE_COUNT(0);
+
 #endif
 
 #if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
+
         // No move should take place.
         // (since a is already in the container)
         reset();
         x.emplace(std::move(a));
         COPY_COUNT(0); MOVE_COUNT(0);
+
 #endif
 
         //
@@ -382,6 +393,47 @@ namespace unnecessary_copy_tests
         reset();
         x.emplace(count_copies(b.first.tag_), count_copies(b.second.tag_));
         COPY_COUNT(2); MOVE_COUNT(0);        
+
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                boost::make_tuple(boost::ref(b.first)),
+                boost::make_tuple(boost::ref(b.second)));
+        COPY_COUNT(0); MOVE_COUNT(0);
+        
+#if !defined(BOOST_NO_0X_HDR_TUPLE) || defined(BOOST_HAS_TR1_TUPLE)
+
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                std::make_tuple(std::ref(b.first)),
+                std::make_tuple(std::ref(b.second)));
+        COPY_COUNT(0); MOVE_COUNT(0);
+
+        std::pair<count_copies const, count_copies> move_source_trial;
+        reset();
+        std::make_tuple(std::move(move_source_trial.first));
+        std::make_tuple(std::move(move_source_trial.second));
+        int tuple_move_cost = ::unnecessary_copy_tests::count_copies::moves;
+        int tuple_copy_cost = ::unnecessary_copy_tests::count_copies::copies;
+
+        std::pair<count_copies const, count_copies> move_source;
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                std::make_tuple(std::move(move_source.first)),
+                std::make_tuple(std::move(move_source.second)));
+        COPY_COUNT(tuple_copy_cost);
+        MOVE_COUNT(tuple_move_cost);
+
+#if defined(__GNUC__) && __GNUC__ > 4 || \
+    defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ >= 6
+        reset();
+        x.emplace(boost::unordered::piecewise_construct,
+                std::forward_as_tuple(b.first),
+                std::forward_as_tuple(b.second));
+        COPY_COUNT(0); MOVE_COUNT(0);
+#endif
+
+#endif
+
     }
 }