Change "in_place" to "inplace". Rationale: shortens names without impacting expressiveness.

test/benchmark.cpp

@@ -120,7 +120,7 @@ namespace
     }
   }
 
-  inline void in_place(int32_t& x)
+  inline void inplace(int32_t& x)
   {
     x =  (static_cast<uint32_t>(x) << 24)
       | ((static_cast<uint32_t>(x) << 8) & 0x00ff0000)
@@ -162,10 +162,10 @@ namespace
     return v;
   }
 
-  inline int32_t modify_in_place(int32_t x)
+  inline int32_t modify_inplace(int32_t x)
   {
     int32_t v(x);
-    in_place(v);
+    inplace(v);
     return v;
   }
 
@@ -214,7 +214,7 @@ int main(int argc, char * argv[])
 
 #ifndef BOOST_TWO_ARG
   overhead = benchmark(modify_noop, "modify no-op");
-  benchmark(modify_in_place, "modify in place"/*, overhead*/);
+  benchmark(modify_inplace, "modify in place"/*, overhead*/);
   benchmark(modify_by_return, "modify by return"/*, overhead*/);
   benchmark(modify_by_return_pyry, "modify by return_pyry"/*, overhead*/);
   benchmark(modify_by_return_intrinsic, "modify by return_intrinsic"/*, overhead*/);

test/conversion_test.cpp

@@ -201,62 +201,62 @@ namespace
     T x;
 
     //  unconditional reverse
-    x = big; be::endian_reverse_in_place(x); BOOST_TEST_EQ(x, little);
-    x = little; be::endian_reverse_in_place(x); BOOST_TEST_EQ(x, big);
+    x = big; be::endian_reverse_inplace(x); BOOST_TEST_EQ(x, little);
+    x = little; be::endian_reverse_inplace(x); BOOST_TEST_EQ(x, big);
 
     //  conditional reverse
-    x = native; be::native_to_big_in_place(x); BOOST_TEST_EQ(x, big);
-    x = native; be::native_to_little_in_place(x);  BOOST_TEST_EQ(x, little);
-    x = big; be::big_to_native_in_place(x);  BOOST_TEST_EQ(x, native);
-    x = little; be::little_to_native_in_place(x); BOOST_TEST_EQ(x, native);
+    x = native; be::native_to_big_inplace(x); BOOST_TEST_EQ(x, big);
+    x = native; be::native_to_little_inplace(x);  BOOST_TEST_EQ(x, little);
+    x = big; be::big_to_native_inplace(x);  BOOST_TEST_EQ(x, native);
+    x = little; be::little_to_native_inplace(x); BOOST_TEST_EQ(x, native);
 
     //  generic conditional reverse
-    x = big; be::conditional_reverse_in_place<be::order::big, be::order::big>(x);
+    x = big; be::conditional_reverse_inplace<be::order::big, be::order::big>(x);
       BOOST_TEST_EQ(x, big);
-    x = little; be::conditional_reverse_in_place<be::order::little, be::order::little>(x);
+    x = little; be::conditional_reverse_inplace<be::order::little, be::order::little>(x);
       BOOST_TEST_EQ(x, little);
-    x = native; be::conditional_reverse_in_place<be::order::native, be::order::native>(x);
+    x = native; be::conditional_reverse_inplace<be::order::native, be::order::native>(x);
       BOOST_TEST_EQ(x, native);
-    x = big; be::conditional_reverse_in_place<be::order::big, be::order::little>(x);
+    x = big; be::conditional_reverse_inplace<be::order::big, be::order::little>(x);
       BOOST_TEST_EQ(x, little);
-    x = big; be::conditional_reverse_in_place<be::order::big, be::order::native>(x);
+    x = big; be::conditional_reverse_inplace<be::order::big, be::order::native>(x);
       BOOST_TEST_EQ(x, native);
-    x = little; be::conditional_reverse_in_place<be::order::little, be::order::big>(x);
+    x = little; be::conditional_reverse_inplace<be::order::little, be::order::big>(x);
       BOOST_TEST_EQ(x, big);
-    x = little; be::conditional_reverse_in_place<be::order::little, be::order::native>(x);
+    x = little; be::conditional_reverse_inplace<be::order::little, be::order::native>(x);
       BOOST_TEST_EQ(x, native);
-      x = native; be::conditional_reverse_in_place<be::order::native, be::order::big>(x);
+      x = native; be::conditional_reverse_inplace<be::order::native, be::order::big>(x);
       BOOST_TEST_EQ(x, big);
-    x = native; be::conditional_reverse_in_place<be::order::native, be::order::little>(x);
+    x = native; be::conditional_reverse_inplace<be::order::native, be::order::little>(x);
       BOOST_TEST_EQ(x, little);
 
     //  runtime conditional reverse
     x = big;
-      be::conditional_reverse_in_place(x, be::order::big, be::order::big);
+      be::conditional_reverse_inplace(x, be::order::big, be::order::big);
       BOOST_TEST_EQ(x, big);
     x = little;
-      be::conditional_reverse_in_place(x, be::order::little, be::order::little);
+      be::conditional_reverse_inplace(x, be::order::little, be::order::little);
       BOOST_TEST_EQ(x, little);
     x = native;
-      be::conditional_reverse_in_place(x, be::order::native, be::order::native);
+      be::conditional_reverse_inplace(x, be::order::native, be::order::native);
       BOOST_TEST_EQ(x, native);
     x = big;
-      be::conditional_reverse_in_place(x, be::order::big, be::order::little);
+      be::conditional_reverse_inplace(x, be::order::big, be::order::little);
       BOOST_TEST_EQ(x, little);
     x = big;
-      be::conditional_reverse_in_place(x, be::order::big, be::order::native);
+      be::conditional_reverse_inplace(x, be::order::big, be::order::native);
       BOOST_TEST_EQ(x, native);
     x = little;
-      be::conditional_reverse_in_place(x, be::order::little, be::order::big); 
+      be::conditional_reverse_inplace(x, be::order::little, be::order::big); 
       BOOST_TEST_EQ(x, big);
     x = little;
-      be::conditional_reverse_in_place(x, be::order::little, be::order::native); 
+      be::conditional_reverse_inplace(x, be::order::little, be::order::native); 
       BOOST_TEST_EQ(x, native);
     x = native;
-      be::conditional_reverse_in_place(x, be::order::native, be::order::big); 
+      be::conditional_reverse_inplace(x, be::order::native, be::order::big); 
       BOOST_TEST_EQ(x, big);
     x = native;
-      be::conditional_reverse_in_place(x, be::order::native, be::order::little); 
+      be::conditional_reverse_inplace(x, be::order::native, be::order::little); 
       BOOST_TEST_EQ(x, little);
 
   }
@@ -283,7 +283,7 @@ namespace
     BOOST_TEST_EQ(tmp.member2, be::endian_reverse(little));
     BOOST_TEST_EQ(tmp.member3, be::endian_reverse(native));
 
-    be::conditional_reverse_in_place<be::order::big, be::order::little>(udt);
+    be::conditional_reverse_inplace<be::order::big, be::order::little>(udt);
     BOOST_TEST_EQ(udt.member1, be::endian_reverse(big));
     BOOST_TEST_EQ(udt.member2, be::endian_reverse(little));
     BOOST_TEST_EQ(udt.member3, be::endian_reverse(native));
@@ -298,7 +298,7 @@ namespace
     BOOST_TEST_EQ(tmp.member2, little);
     BOOST_TEST_EQ(tmp.member3, native);
 
-    be::conditional_reverse_in_place<be::order::big, be::order::big>(udt);
+    be::conditional_reverse_inplace<be::order::big, be::order::big>(udt);
     BOOST_TEST_EQ(udt.member1, big);
     BOOST_TEST_EQ(udt.member2, little);
     BOOST_TEST_EQ(udt.member3, native);
@@ -311,7 +311,7 @@ namespace
   
   namespace user
   {
-    //  UDT1 supplies both endian_reverse and endian_reverse_in_place
+    //  UDT1 supplies both endian_reverse and endian_reverse_inplace
     struct UDT1
     {
       int64_t member1;
@@ -328,11 +328,11 @@ namespace
       return tmp;
     }
 
-    void endian_reverse_in_place(UDT1& udt) BOOST_NOEXCEPT
+    void endian_reverse_inplace(UDT1& udt) BOOST_NOEXCEPT
     {
-      boost::endian::endian_reverse_in_place(udt.member1);
-      boost::endian::endian_reverse_in_place(udt.member2);
-      boost::endian::endian_reverse_in_place(udt.member3);
+      boost::endian::endian_reverse_inplace(udt.member1);
+      boost::endian::endian_reverse_inplace(udt.member2);
+      boost::endian::endian_reverse_inplace(udt.member3);
     }
 
     //  UDT2 supplies only endian_reverse
@@ -352,7 +352,7 @@ namespace
       return tmp;
     }
 
-    //  UDT3 supplies neither endian_reverse nor endian_reverse_in_place,
+    //  UDT3 supplies neither endian_reverse nor endian_reverse_inplace,
     //  so udt_test<UDT3>() should fail to compile
     struct UDT3
     {

test/endian_test.cpp

@@ -604,25 +604,25 @@ namespace
   {
     // aligned floating point types
     float big_float32_expected = (std::numeric_limits<float>::max) ();
-    boost::endian::native_to_big_in_place(big_float32_expected);
+    boost::endian::native_to_big_inplace(big_float32_expected);
     big_float32_t big_float32((std::numeric_limits<float>::max) ());
     VERIFY(std::memcmp(big_float32.data(),
       reinterpret_cast<const char*>(&big_float32_expected), sizeof(float)) == 0);
 
     float little_float32_expected = (std::numeric_limits<float>::max) ();
-    boost::endian::native_to_little_in_place(little_float32_expected);
+    boost::endian::native_to_little_inplace(little_float32_expected);
     little_float32_t little_float32((std::numeric_limits<float>::max) ());
     VERIFY(std::memcmp(little_float32.data(),
       reinterpret_cast<const char*>(&little_float32_expected), sizeof(float)) == 0);
 
     double big_float64_expected = (std::numeric_limits<double>::max) ();
-    boost::endian::native_to_big_in_place(big_float64_expected);
+    boost::endian::native_to_big_inplace(big_float64_expected);
     big_float64_t big_float64((std::numeric_limits<double>::max) ());
     VERIFY(std::memcmp(big_float64.data(),
       reinterpret_cast<const char*>(&big_float64_expected), sizeof(double)) == 0);
 
     double little_float64_expected = (std::numeric_limits<double>::max) ();
-    boost::endian::native_to_little_in_place(little_float64_expected);
+    boost::endian::native_to_little_inplace(little_float64_expected);
     little_float64_t little_float64((std::numeric_limits<double>::max) ());
     VERIFY(std::memcmp(little_float64.data(),
       reinterpret_cast<const char*>(&little_float64_expected), sizeof(double)) == 0);
@@ -639,25 +639,25 @@ namespace
 
     // unaligned floating point types
     float big_float32un_expected = (std::numeric_limits<float>::max) ();
-    boost::endian::native_to_big_in_place(big_float32un_expected);
+    boost::endian::native_to_big_inplace(big_float32un_expected);
     big_float32_ut big_float32un((std::numeric_limits<float>::max) ());
     VERIFY(std::memcmp(big_float32un.data(),
       reinterpret_cast<const char*>(&big_float32un_expected), sizeof(float)) == 0);
 
     float little_float32un_expected = (std::numeric_limits<float>::max) ();
-    boost::endian::native_to_little_in_place(little_float32un_expected);
+    boost::endian::native_to_little_inplace(little_float32un_expected);
     little_float32_ut little_float32un((std::numeric_limits<float>::max) ());
     VERIFY(std::memcmp(little_float32un.data(),
       reinterpret_cast<const char*>(&little_float32un_expected), sizeof(float)) == 0);
 
     double big_float64un_expected = (std::numeric_limits<double>::max) ();
-    boost::endian::native_to_big_in_place(big_float64un_expected);
+    boost::endian::native_to_big_inplace(big_float64un_expected);
     big_float64_ut big_float64un((std::numeric_limits<double>::max) ());
     VERIFY(std::memcmp(big_float64un.data(),
       reinterpret_cast<const char*>(&big_float64un_expected), sizeof(double)) == 0);
 
     double little_float64un_expected = (std::numeric_limits<double>::max) ();
-    boost::endian::native_to_little_in_place(little_float64un_expected);
+    boost::endian::native_to_little_inplace(little_float64un_expected);
     little_float64_ut little_float64un((std::numeric_limits<double>::max) ());
     VERIFY(std::memcmp(little_float64un.data(),
       reinterpret_cast<const char*>(&little_float64un_expected), sizeof(double)) == 0);

test/loop_time_test.cpp

@@ -101,14 +101,14 @@ namespace
 //      cout << "***************Endian conversion approach...\n";
       T x(0);
       boost::timer::cpu_timer t;
-      native_to_big_in_place(x);
+      native_to_big_inplace(x);
       for (uint64_t i = 0; i < n; ++i)
       {
         x += static_cast<T>(i);
       }
-      big_to_native_in_place(x);
+      big_to_native_inplace(x);
       t.stop();
-      native_to_big_in_place(x);
+      native_to_big_inplace(x);
       if (x != total)
         throw std::logic_error("integer approach total != conversion approach total");
       cout << "<td align=\"right\">" << t.format(places, "%t") << " s</td>";

test/speed_test.cpp

@@ -101,7 +101,7 @@ namespace
     cout << "<tr><td>16-bit aligned big endian</td>";
     time<int16_t, big_int16_ut>(user::return_x_big_int16);
     time<int16_t, big_int16_ut>(user::return_x_value_big_int16);
-    time<int16_t, big_int16_ut>(user::return_x_in_place_big_int16);
+    time<int16_t, big_int16_ut>(user::return_x_inplace_big_int16);
     time<int16_t, big_int16_ut>(user::return_x_big_int16);
     cout << "</tr>\n";
   }
@@ -111,7 +111,7 @@ namespace
     cout << "<tr><td>16-bit aligned little endian</td>";
     time<int16_t, little_int16_ut>(user::return_x_little_int16);
     time<int16_t, little_int16_ut>(user::return_x_value_little_int16);
-    time<int16_t, little_int16_ut>(user::return_x_in_place_little_int16);
+    time<int16_t, little_int16_ut>(user::return_x_inplace_little_int16);
     time<int16_t, little_int16_ut>(user::return_x_little_int16);
     cout << "</tr>\n";
   }
@@ -121,7 +121,7 @@ namespace
     cout << "<tr><td>32-bit aligned big endian</td>";
     time<int32_t, big_int32_ut>(user::return_x_big_int32);
     time<int32_t, big_int32_ut>(user::return_x_value_big_int32);
-    time<int32_t, big_int32_ut>(user::return_x_in_place_big_int32);
+    time<int32_t, big_int32_ut>(user::return_x_inplace_big_int32);
     time<int32_t, big_int32_ut>(user::return_x_big_int32);
     cout << "</tr>\n";
   }
@@ -131,7 +131,7 @@ namespace
     cout << "<tr><td>32-bit aligned little endian</td>";
     time<int32_t, little_int32_ut>(user::return_x_little_int32);
     time<int32_t, little_int32_ut>(user::return_x_value_little_int32);
-    time<int32_t, little_int32_ut>(user::return_x_in_place_little_int32);
+    time<int32_t, little_int32_ut>(user::return_x_inplace_little_int32);
     time<int32_t, little_int32_ut>(user::return_x_little_int32);
     cout << "</tr>\n";
   }
@@ -141,7 +141,7 @@ namespace
     cout << "<tr><td>64-bit aligned big endian</td>";
     time<int64_t, big_int64_ut>(user::return_x_big_int64);
     time<int64_t, big_int64_ut>(user::return_x_value_big_int64);
-    time<int64_t, big_int64_ut>(user::return_x_in_place_big_int64);
+    time<int64_t, big_int64_ut>(user::return_x_inplace_big_int64);
     time<int64_t, big_int64_ut>(user::return_x_big_int64);
     cout << "</tr>\n";
   }
@@ -151,7 +151,7 @@ namespace
     cout << "<tr><td>64-bit aligned little endian</td>";
     time<int64_t, little_int64_ut>(user::return_x_little_int64);
     time<int64_t, little_int64_ut>(user::return_x_value_little_int64);
-    time<int64_t, little_int64_ut>(user::return_x_in_place_little_int64);
+    time<int64_t, little_int64_ut>(user::return_x_inplace_little_int64);
     time<int64_t, little_int64_ut>(user::return_x_little_int64);
     cout << "</tr>\n";
   }

test/speed_test_functions.cpp

@@ -30,13 +30,13 @@ namespace user
   {
     return conditional_reverse<order::native, order::little>(x);
   }
-  int16_t return_x_in_place_big_int16(int16_t x, big_int16_ut) BOOST_NOEXCEPT
+  int16_t return_x_inplace_big_int16(int16_t x, big_int16_ut) BOOST_NOEXCEPT
   {
-    conditional_reverse_in_place<order::native, order::big>(x); return x;
+    conditional_reverse_inplace<order::native, order::big>(x); return x;
   }
-  int16_t return_x_in_place_little_int16(int16_t x, little_int16_ut) BOOST_NOEXCEPT
+  int16_t return_x_inplace_little_int16(int16_t x, little_int16_ut) BOOST_NOEXCEPT
   {
-    conditional_reverse_in_place<order::native, order::little>(x); return x;
+    conditional_reverse_inplace<order::native, order::little>(x); return x;
   }
   int16_t return_y_big_int16(int16_t x, big_int16_ut y) BOOST_NOEXCEPT { return y; }
   int16_t return_y_little_int16(int16_t x, little_int16_ut y) BOOST_NOEXCEPT { return y; }
@@ -51,13 +51,13 @@ namespace user
   {
     return conditional_reverse<order::native, order::little>(x);
   }
-  int32_t return_x_in_place_big_int32(int32_t x, big_int32_ut) BOOST_NOEXCEPT
+  int32_t return_x_inplace_big_int32(int32_t x, big_int32_ut) BOOST_NOEXCEPT
   {
-    conditional_reverse_in_place<order::native, order::big>(x); return x;
+    conditional_reverse_inplace<order::native, order::big>(x); return x;
   }
-  int32_t return_x_in_place_little_int32(int32_t x, little_int32_ut) BOOST_NOEXCEPT
+  int32_t return_x_inplace_little_int32(int32_t x, little_int32_ut) BOOST_NOEXCEPT
   {
-    conditional_reverse_in_place<order::native, order::little>(x); return x;
+    conditional_reverse_inplace<order::native, order::little>(x); return x;
   }
   int32_t return_y_big_int32(int32_t x, big_int32_ut y) BOOST_NOEXCEPT { return y; }
   int32_t return_y_little_int32(int32_t x, little_int32_ut y) BOOST_NOEXCEPT { return y; }
@@ -72,13 +72,13 @@ namespace user
   {
     return conditional_reverse<order::native, order::little>(x);
   }
-  int64_t return_x_in_place_big_int64(int64_t x, big_int64_ut) BOOST_NOEXCEPT
+  int64_t return_x_inplace_big_int64(int64_t x, big_int64_ut) BOOST_NOEXCEPT
   {
-    conditional_reverse_in_place<order::native, order::big>(x); return x;
+    conditional_reverse_inplace<order::native, order::big>(x); return x;
   }
-  int64_t return_x_in_place_little_int64(int64_t x, little_int64_ut) BOOST_NOEXCEPT
+  int64_t return_x_inplace_little_int64(int64_t x, little_int64_ut) BOOST_NOEXCEPT
   {
-    conditional_reverse_in_place<order::native, order::little>(x); return x;
+    conditional_reverse_inplace<order::native, order::little>(x); return x;
   }
   int64_t return_y_big_int64(int64_t x, big_int64_ut y) BOOST_NOEXCEPT { return y; }
   int64_t return_y_little_int64(int64_t x, little_int64_ut y) BOOST_NOEXCEPT { return y; }