* Add missing extract() and insert(node_type) funtion to associative containers.

* Simplify select1st

test/map_test.cpp

@@ -110,6 +110,118 @@ void test_move()
    move_assign.swap(original);
 }
 
+bool node_type_test()
+{
+   using namespace boost::container;
+   {
+      typedef map<test::movable_int, test::movable_int> map_type;
+      map_type src;
+      {
+         test::movable_int mv_1(1), mv_2(2), mv_3(3), mv_11(11), mv_12(12), mv_13(13);
+         src.try_emplace(boost::move(mv_1), boost::move(mv_11)); 
+         src.try_emplace(boost::move(mv_2), boost::move(mv_12)); 
+         src.try_emplace(boost::move(mv_3), boost::move(mv_13)); 
+      }
+      if(src.size() != 3)
+         return false;
+
+      map_type dst;
+      {
+         test::movable_int mv_3(3), mv_33(33);
+         dst.try_emplace(boost::move(mv_3), boost::move(mv_33)); 
+      }
+
+      if(dst.size() != 1)
+         return false;
+
+      const test::movable_int mv_1(1);
+      const test::movable_int mv_2(2);
+      const test::movable_int mv_3(3);
+      const test::movable_int mv_33(33);
+      const test::movable_int mv_13(13);
+      map_type::insert_return_type r;
+
+      r = dst.insert(src.extract(mv_33)); // Key version, try to insert empty node
+      if(! (r.position == dst.end() && r.inserted == false && r.node.empty()) )
+         return false;
+      r = dst.insert(src.extract(src.find(mv_1))); // Iterator version, successful
+      if(! (r.position == dst.find(mv_1) && r.inserted == true && r.node.empty()) )
+         return false;
+      r = dst.insert(dst.begin(), src.extract(mv_2)); // Key type version, successful
+      if(! (r.position == dst.find(mv_2) && r.inserted == true && r.node.empty()) )
+         return false;
+      r = dst.insert(src.extract(mv_3)); // Key type version, unsuccessful
+
+      if(!src.empty())
+         return false;
+      if(dst.size() != 3)
+         return false;
+      if(! (r.position == dst.find(mv_3) && r.inserted == false && r.node.key() == mv_3 && r.node.mapped() == mv_13) )
+         return false;
+   }
+
+   {
+      typedef multimap<test::movable_int, test::movable_int> multimap_type;
+      multimap_type src;
+      {
+         test::movable_int mv_1(1), mv_2(2), mv_3(3), mv_3bis(3), mv_11(11), mv_12(12), mv_13(13), mv_23(23);
+         src.emplace(boost::move(mv_1), boost::move(mv_11));
+         src.emplace(boost::move(mv_2), boost::move(mv_12));
+         src.emplace(boost::move(mv_3), boost::move(mv_13));
+         src.emplace_hint(src.begin(), boost::move(mv_3bis), boost::move(mv_23));
+      }
+      if(src.size() != 4)
+         return false;
+
+      multimap_type dst;
+      {
+         test::movable_int mv_3(3), mv_33(33);
+         dst.emplace(boost::move(mv_3), boost::move(mv_33)); 
+      }
+
+      if(dst.size() != 1)
+         return false;
+
+      const test::movable_int mv_1(1);
+      const test::movable_int mv_2(2);
+      const test::movable_int mv_3(3);
+      const test::movable_int mv_4(4);
+      const test::movable_int mv_33(33);
+      const test::movable_int mv_13(13);
+      const test::movable_int mv_23(23);
+      multimap_type::iterator r;
+
+      multimap_type::node_type nt(src.extract(mv_3));
+      r = dst.insert(dst.begin(), boost::move(nt));
+      if(! (r->first == mv_3 && r->second == mv_23 && dst.find(mv_3) == r && nt.empty()) )
+         return false;
+
+      nt = src.extract(src.find(mv_1));
+      r = dst.insert(boost::move(nt)); // Iterator version, successful
+      if(! (r->first == mv_1 && nt.empty()) )
+         return false;
+
+      nt = src.extract(mv_2);
+      r = dst.insert(boost::move(nt)); // Key type version, successful
+      if(! (r->first == mv_2 && nt.empty()) )
+         return false;
+
+      r = dst.insert(src.extract(mv_3)); // Key type version, successful
+      if(! (r->first == mv_3 && r->second == mv_13 && r == --multimap_type::iterator(dst.upper_bound(mv_3)) && nt.empty()) )
+         return false;
+
+      r = dst.insert(src.extract(mv_4)); // Key type version, unsuccessful
+      if(! (r == dst.end()) )
+         return false;
+
+      if(!src.empty())
+         return false;
+      if(dst.size() != 5)
+         return false;
+   }
+   return true;
+}
+
 template<class VoidAllocator, boost::container::tree_type_enum tree_type_value>
 struct GetAllocatorMap
 {
@@ -329,6 +441,12 @@ int main ()
       }
    }
 
+   ////////////////////////////////////
+   //    Node extraction/insertion testing functions
+   ////////////////////////////////////
+   if(!node_type_test())
+      return 1;
+
    ////////////////////////////////////
    //    Test optimize_size option
    ////////////////////////////////////