|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r74214 - in sandbox/endian: boost/endian libs/endian/doc libs/endian/test libs/endian/test/msvc10
From: bdawes_at_[hidden]
Date: 2011-09-03 13:50:47
Author: bemandawes
Date: 2011-09-03 13:50:46 EDT (Sat, 03 Sep 2011)
New Revision: 74214
URL: http://svn.boost.org/trac/boost/changeset/74214
Log:
Rename flip() to invert()
Text files modified:
sandbox/endian/boost/endian/conversion.hpp | 66 +++++++++++-----------
sandbox/endian/libs/endian/doc/conversion.html | 115 +++++++++++++++++++++++++++------------
sandbox/endian/libs/endian/doc/index.html | 36 ++++++++++--
sandbox/endian/libs/endian/test/conversion_test.cpp | 104 ++++++++++++++++++------------------
sandbox/endian/libs/endian/test/msvc10/endian.sln | 2
5 files changed, 193 insertions(+), 130 deletions(-)
Modified: sandbox/endian/boost/endian/conversion.hpp
==============================================================================
--- sandbox/endian/boost/endian/conversion.hpp (original)
+++ sandbox/endian/boost/endian/conversion.hpp 2011-09-03 13:50:46 EDT (Sat, 03 Sep 2011)
@@ -19,24 +19,24 @@
{
// unconditional modifying (i.e. in-place) endianness reversal
- inline void flip(int16_t& x);
- inline void flip(int32_t& x);
- inline void flip(int64_t& x);
- inline void flip(uint16_t& x);
- inline void flip(uint32_t& x);
- inline void flip(uint64_t& x);
+ inline void invert(int16_t& x);
+ inline void invert(int32_t& x);
+ inline void invert(int64_t& x);
+ inline void invert(uint16_t& x);
+ inline void invert(uint32_t& x);
+ inline void invert(uint64_t& x);
// unconditional non-modifying endianness reversing copy
- inline void flip(int16_t source, int16_t& target);
- inline void flip(int32_t source, int32_t& target);
- inline void flip(int64_t source, int64_t& target);
- inline void flip(uint16_t source, uint16_t& target);
- inline void flip(uint32_t source, uint32_t& target);
- inline void flip(uint64_t source, uint64_t& target);
+ inline void invert(int16_t source, int16_t& target);
+ inline void invert(int32_t source, int32_t& target);
+ inline void invert(int64_t source, int64_t& target);
+ inline void invert(uint16_t source, uint16_t& target);
+ inline void invert(uint32_t source, uint32_t& target);
+ inline void invert(uint64_t source, uint64_t& target);
// conditional modifying (i.e. in-place) endianness reversal;
- // no effect if native endianness and specified endianness are the same
+ // no effect if native endianness and indicated endianness are the same
template <class T> inline void native_to_big(T& x);
template <class T> inline void native_to_little(T& x);
@@ -54,7 +54,7 @@
//----------------------------------- implementation -----------------------------------//
- inline void flip(int16_t& x)
+ inline void invert(int16_t& x)
{
char* rep = reinterpret_cast<char*>(&x);
char tmp;
@@ -63,7 +63,7 @@
*(rep+1) = tmp;
}
- inline void flip(int32_t& x)
+ inline void invert(int32_t& x)
{
char* rep = reinterpret_cast<char*>(&x);
char tmp;
@@ -75,7 +75,7 @@
*(rep+2) = tmp;
}
- inline void flip(int64_t& x)
+ inline void invert(int64_t& x)
{
char* rep = reinterpret_cast<char*>(&x);
char tmp;
@@ -93,7 +93,7 @@
*(rep+4) = tmp;
}
- inline void flip(uint16_t& x)
+ inline void invert(uint16_t& x)
{
char* rep = reinterpret_cast<char*>(&x);
char tmp;
@@ -102,7 +102,7 @@
*(rep+1) = tmp;
}
- inline void flip(uint32_t& x)
+ inline void invert(uint32_t& x)
{
char* rep = reinterpret_cast<char*>(&x);
char tmp;
@@ -114,7 +114,7 @@
*(rep+2) = tmp;
}
- inline void flip(uint64_t& x)
+ inline void invert(uint64_t& x)
{
char* rep = reinterpret_cast<char*>(&x);
char tmp;
@@ -132,7 +132,7 @@
*(rep+4) = tmp;
}
- inline void flip(int16_t source, int16_t& target)
+ inline void invert(int16_t source, int16_t& target)
{
const char* s (reinterpret_cast<const char*>(&source));
char * t (reinterpret_cast<char*>(&target) + sizeof(target) - 1);
@@ -140,7 +140,7 @@
*--t = *++s;
}
- inline void flip(int32_t source, int32_t& target)
+ inline void invert(int32_t source, int32_t& target)
{
const char* s (reinterpret_cast<const char*>(&source));
char * t (reinterpret_cast<char*>(&target) + sizeof(target) - 1);
@@ -150,7 +150,7 @@
*--t = *++s;
}
- inline void flip(int64_t source, int64_t& target)
+ inline void invert(int64_t source, int64_t& target)
{
const char* s (reinterpret_cast<const char*>(&source));
char * t (reinterpret_cast<char*>(&target) + sizeof(target) - 1);
@@ -164,7 +164,7 @@
*--t = *++s;
}
- inline void flip(uint16_t source, uint16_t& target)
+ inline void invert(uint16_t source, uint16_t& target)
{
const char* s (reinterpret_cast<const char*>(&source));
char * t (reinterpret_cast<char*>(&target) + sizeof(target) - 1);
@@ -172,7 +172,7 @@
*--t = *++s;
}
- inline void flip(uint32_t source, uint32_t& target)
+ inline void invert(uint32_t source, uint32_t& target)
{
const char* s (reinterpret_cast<const char*>(&source));
char * t (reinterpret_cast<char*>(&target) + sizeof(target) - 1);
@@ -182,7 +182,7 @@
*--t = *++s;
}
- inline void flip(uint64_t source, uint64_t& target)
+ inline void invert(uint64_t source, uint64_t& target)
{
const char* s (reinterpret_cast<const char*>(&source));
char * t (reinterpret_cast<char*>(&target) + sizeof(target) - 1);
@@ -197,23 +197,23 @@
}
#ifdef BOOST_LITTLE_ENDIAN
- template <class T> inline void native_to_big(T& x) { flip(x); }
+ template <class T> inline void native_to_big(T& x) { invert(x); }
template <class T> inline void native_to_little(T&) {}
- template <class T> inline void big_to_native(T& x) { flip(x); }
+ template <class T> inline void big_to_native(T& x) { invert(x); }
template <class T> inline void little_to_native(T&) {}
- template <class T> inline void native_to_big(T source, T& target) { flip(source, target); }
+ template <class T> inline void native_to_big(T source, T& target) { invert(source, target); }
template <class T> inline void native_to_little(T source, T& target) { target = source; }
- template <class T> inline void big_to_native(T source, T& target) { flip(source, target); }
+ template <class T> inline void big_to_native(T source, T& target) { invert(source, target); }
template <class T> inline void little_to_native(T source, T& target) { target = source; }
#else
template <class T> inline void native_to_big(T&) {}
- template <class T> inline void native_to_little(T& x) { flip(x); }
+ template <class T> inline void native_to_little(T& x) { invert(x); }
template <class T> inline void big_to_native(T&) {}
- template <class T> inline void little_to_native(T& x) { flip(x); }
+ template <class T> inline void little_to_native(T& x) { invert(x); }
template <class T> inline void native_to_big(T native, T& big) { target = source; }
- template <class T> inline void native_to_little(T native, T& little) { flip(source, target); }
+ template <class T> inline void native_to_little(T native, T& little) { invert(source, target); }
template <class T> inline void big_to_native(T big, T& native) { target = source; }
- template <class T> inline void little_to_native(T little, T& native) { flip(source, target); }
+ template <class T> inline void little_to_native(T little, T& native) { invert(source, target); }
#endif
} // namespace endian
Modified: sandbox/endian/libs/endian/doc/conversion.html
==============================================================================
--- sandbox/endian/libs/endian/doc/conversion.html (original)
+++ sandbox/endian/libs/endian/doc/conversion.html 2011-09-03 13:50:46 EDT (Sat, 03 Sep 2011)
@@ -32,62 +32,103 @@
<h2><a name="Introduction">Introduction</a></h2>
-<p> </p>
+<p>Header boost/endian/conversion.hpp
+provides functions that convert built-in
+integers from the native byte ordering to or from big or little endian byte
+ordering.</p>
-<h2>Header <font face="Courier New"><boost/endian/conversion></font>
-<a name="Synopsis">Synopsis</a></h2>
+<h2><a name="Reference">Reference</a></h2>
+
+<h3>
+<a name="Synopsis">Synopsis</a></h3>
<pre>namespace boost
{
namespace endian
{
+ // invert: <span class="f">verb: p</span>ut upside down or in the opposite position, order, or arrangement.
+
// unconditional modifying (i.e. in-place) endianness reversal
- inline void flip(int16_t& x);
- inline void flip(int32_t& x);
- inline void flip(int64_t& x);
- inline void flip(uint16_t& x);
- inline void flip(uint32_t& x);
- inline void flip(uint64_t& x);
+ inline void invert(int16_t& x);
+ inline void invert(int32_t& x);
+ inline void invert(int64_t& x);
+ inline void invert(uint16_t& x);
+ inline void invert(uint32_t& x);
+ inline void invert(uint64_t& x);
// unconditional non-modifying endianness reversing copy
- inline void flip(int16_t source, int16_t& target);
- inline void flip(int32_t source, int32_t& target);
- inline void flip(int64_t source, int64_t& target);
- inline void flip(uint16_t source, uint16_t& target);
- inline void flip(uint32_t source, uint32_t& target);
- inline void flip(uint64_t source, uint64_t& target);
-
- // conditional modifying (i.e. in-place) endianness reversal;
- // no effect if native endianness and specified endianness are the same
-
- template <class T> inline void to_big(T& x); // if different, convert native to big
- template <class T> inline void to_little(T& x); // if different, convert native to little
- template <class T> inline void from_big(T& x); // if different, convert big to native
- template <class T> inline void from_little(T& x); // if different, convert little to native
-
- // non-modifying copy, conditionally reversing endianness;
- // copy the first argument to the second argument, converting to or from the
- // specified endianness if different than native endianness
-
- template <class T> inline void to_big(T native, T& big);
- template <class T> inline void to_little(T native, T& little);
- template <class T> inline void from_big(T big, T& native);
- template <class T> inline void from_little(T little, T& native);
-</pre>
-<pre>} // namespace endian
+ inline void invert(int16_t source, int16_t& target);
+ inline void invert(int32_t source, int32_t& target);
+ inline void invert(int64_t source, int64_t& target);
+ inline void invert(uint16_t source, uint16_t& target);
+ inline void invert(uint32_t source, uint32_t& target);
+ inline void invert(uint64_t source, uint64_t& target);
+
+ // conditional modifying (i.e. in-place) endianness reversal
+
+ template <class T> void native_to_big(T& x);
+ template <class T> void native_to_little(T& x);
+ template <class T> void big_to_native(T& x);
+ template <class T> void little_to_native(T& x);
+
+ // non-modifying copy conditionally reversing endianness;
+
+ template <class T> void native_to_big(T source, T& target);
+ template <class T> void native_to_little(T source, T& target);
+ template <class T> void big_to_native(T source, T& target);
+ template <class T> void little_to_native(T source, T& target);
+
+} // namespace endian
} // namespace boost</pre>
+<h3 dir="ltr">Members</h3>
+<pre dir="ltr">inline void invert(int16_t& x);
+inline void invert(int32_t& x);
+inline void invert(int64_t& x);
+inline void invert(uint16_t& x);
+inline void invert(uint32_t& x);
+inline void invert(uint64_t& x);</pre>
+<blockquote>
+ <p dir="ltr"><i>Effects:</i> Reverses the byte order of <i><code>x</code></i>.</p>
+</blockquote>
+<pre dir="ltr">inline void invert(int16_t source, int16_t& target);
+inline void invert(int32_t source, int32_t& target);
+inline void invert(int64_t source, int64_t& target);
+inline void invert(uint16_t source, uint16_t& target);
+inline void invert(uint32_t source, uint32_t& target);
+inline void invert(uint64_t source, uint64_t& target);</pre>
+<blockquote>
+ <p dir="ltr"><i>Effects:</i> Copies <code>source</code> to <code>target</code>,
+ reversing the byte order.</p>
+</blockquote>
+<pre dir="ltr">template <class T> void native_to_big(T& x);
+template <class T> void native_to_little(T& x);
+template <class T> void big_to_native(T& x);
+template <class T> void little_to_native(T& x);</pre>
+<blockquote>
+ <p dir="ltr"><i>Effects:</i> If the native byte ordering and indicated byte
+ ordering are different, <code>invert(x)</code>, otherwise no effect.</p>
+</blockquote>
+<pre dir="ltr">template <class T> void native_to_big(T source, T& target);
+template <class T> void native_to_little(T source, T& target);
+template <class T> void big_to_native(T source, T& target);
+template <class T> void little_to_native(T source, T& target);</pre>
+<blockquote>
+ <p dir="ltr"><i>Effects:</i> If the native byte ordering and indicated byte
+ ordering are different, <code>invert(source, target)</code>, otherwise <code>
+ target = source</code>.</p>
+</blockquote>
<h2><a name="Acknowledgements">Acknowledgements</a></h2>
+<p>Tomas Puverle was instrumental in identifying and articulating the need to
+support endian conversion as separate from endian types.</p>
<hr>
<p>Last revised:
-<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->27 May, 2011<!--webbot bot="Timestamp" endspan i-checksum="13974" --></p>
+<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->03 September, 2011<!--webbot bot="Timestamp" endspan i-checksum="39334" --></p>
<p>© Copyright Beman Dawes, 2011</p>
<p>Distributed under the Boost Software License, Version 1.0. See
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/ LICENSE_1_0.txt</a></p>
-<p> </p>
-
</body>
</html>
\ No newline at end of file
Modified: sandbox/endian/libs/endian/doc/index.html
==============================================================================
--- sandbox/endian/libs/endian/doc/index.html (original)
+++ sandbox/endian/libs/endian/doc/index.html 2011-09-03 13:50:46 EDT (Sat, 03 Sep 2011)
@@ -32,7 +32,7 @@
<h2><a name="Introduction">Introduction</a></h2>
-<p>The Boost Endian Library provides facilities to deal with endianness. See
+<p>The Boost Endian Library provides facilities to deal with integer endianness. See
<a href="#Introduction-to-endianness">Introduction to endianness</a> below for
the basics of endianness.</p>
@@ -40,17 +40,21 @@
<blockquote>
-<p><b>Endian conversions for native integers -</b> The application uses the
-built-in integer types, and calls the provided conversion functions to swap
-bytes as needed. Both mutating and non-mutating conversions are supplied, and
+<p><b>Endian conversions for native integers -</b> With this approach, the application uses the
+built-in integer types, and calls the provided conversion functions to convert
+byte ordering as needed. Both mutating and non-mutating conversions are supplied, and
each comes in unconditional and conditional variants. This approach is simple
and efficient, but is less flexible in terms of size and alignment, and can be
-hard to manage in code with many logical paths involving endianness transitions.</p>
+hard-to-manage and error-prone in code with many logical paths involving endianness transitions.</p>
-<p><b>Endian integer types</b></p>
+<p><b>Endian integer types -</b> With this approach, the application uses the
+provided endian classes which mimic the
+built-in integer types. For example, <code>big32_t</code> or <code>little64_t</code>. </p>
</blockquote>
+<p>Boost Endian is header-only library.</p>
+
<h2><a name="Introduction-to-endianness">Introduction to endianness</a></h2>
<p>Consider a C++ program that defines variables x, y, and z as 16, 32, and
@@ -190,9 +194,27 @@
<p>External memory, such as disks, generally uses the same endianness as the
operating system. Networks traditionally use big endian ordering, so this is
sometimes referred as network endianness.</p>
+<h2><a name="Acknowledgements">Acknowledgements</a></h2>
+<p>Comments and suggestions were
+received from
+Benaka Moorthi,
+Christopher Kohlhoff,
+Cliff Green,
+Gennaro Proto,
+Giovanni Piero Deretta, dizzy, Jeff Flinn,
+John Maddock,
+Kim Barrett,
+Marsh Ray,
+Martin Bonner,
+Matias Capeletto,
+Neil Mayhew, Phil Endecott, Rene Rivera,
+Roland Schwarz, Scott McMurray,
+Sebastian Redl,
+Tomas Puverle, Vincente Botet, and
+Yuval Ronen.</p>
<hr>
<p>Last revised:
-<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->27 May, 2011<!--webbot bot="Timestamp" endspan i-checksum="13974" --></p>
+<!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B, %Y" startspan -->03 September, 2011<!--webbot bot="Timestamp" endspan i-checksum="39334" --></p>
<p>© Copyright Beman Dawes, 2011</p>
<p>Distributed under the Boost Software License, Version 1.0. See
<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/ LICENSE_1_0.txt</a></p>
Modified: sandbox/endian/libs/endian/test/conversion_test.cpp
==============================================================================
--- sandbox/endian/libs/endian/test/conversion_test.cpp (original)
+++ sandbox/endian/libs/endian/test/conversion_test.cpp 2011-09-03 13:50:46 EDT (Sat, 03 Sep 2011)
@@ -19,127 +19,127 @@
namespace
{
- void test_in_place_flip()
+ void test_in_place_invert()
{
- std::cout << "test_in_place_flip...\n";
+ std::cout << "test_in_place_invert...\n";
boost::int64_t i64 = 0x0102030405060708LL;
- be::flip(i64);
+ be::invert(i64);
BOOST_TEST_EQ(i64, 0x0807060504030201LL);
- be::flip(i64);
+ be::invert(i64);
BOOST_TEST_EQ(i64, 0x0102030405060708LL);
i64 = 0xfefdfcfbfaf9f8f7LL;
- be::flip(i64);
+ be::invert(i64);
BOOST_TEST_EQ(i64, static_cast<boost::int64_t>(0xf7f8f9fafbfcfdfeULL));
- be::flip(i64);
+ be::invert(i64);
BOOST_TEST_EQ(i64, static_cast<boost::int64_t>(0xfefdfcfbfaf9f8f7ULL));
boost::int32_t i32 = 0x01020304;
- be::flip(i32);
+ be::invert(i32);
BOOST_TEST_EQ(i32, 0x04030201);
- be::flip(i32);
+ be::invert(i32);
BOOST_TEST_EQ(i32, 0x01020304);
i32 = 0xfefdfcfb;
- be::flip(i32);
+ be::invert(i32);
BOOST_TEST_EQ(i32, static_cast<boost::int32_t>(0xfbfcfdfe));
- be::flip(i32);
+ be::invert(i32);
BOOST_TEST_EQ(i32, static_cast<boost::int32_t>(0xfefdfcfb));
boost::int16_t i16 = 0x0102;
- be::flip(i16);
+ be::invert(i16);
BOOST_TEST_EQ(i16, 0x0201);
- be::flip(i16);
+ be::invert(i16);
BOOST_TEST_EQ(i16, 0x0102);
i16 = static_cast<boost::int16_t>(static_cast<boost::uint16_t>(0xfefd));
- be::flip(i16);
+ be::invert(i16);
BOOST_TEST_EQ(i16, static_cast<boost::int16_t>(static_cast<boost::uint16_t>(0xfdfe)));
- be::flip(i16);
+ be::invert(i16);
BOOST_TEST_EQ(i16, static_cast<boost::int16_t>(static_cast<boost::uint16_t>(0xfefd)));
boost::uint64_t ui64 = 0x0102030405060708ULL;
- be::flip(ui64);
+ be::invert(ui64);
BOOST_TEST_EQ(ui64, 0x0807060504030201ULL);
- be::flip(ui64);
+ be::invert(ui64);
BOOST_TEST_EQ(ui64, 0x0102030405060708ULL);
boost::uint32_t ui32 = 0x01020304;
- be::flip(ui32);
+ be::invert(ui32);
BOOST_TEST_EQ(ui32, static_cast<boost::uint32_t>(0x04030201));
- be::flip(ui32);
+ be::invert(ui32);
BOOST_TEST_EQ(ui32, static_cast<boost::uint32_t>(0x01020304));
boost::uint16_t ui16 = 0x0102;
- be::flip(ui16);
+ be::invert(ui16);
BOOST_TEST_EQ(ui16, 0x0201);
- be::flip(ui16);
+ be::invert(ui16);
BOOST_TEST_EQ(ui16, static_cast<boost::uint16_t>(0x0102));
- std::cout << " test_in_place_flip complete\n";
+ std::cout << " test_in_place_invert complete\n";
}
- void test_copying_flip()
+ void test_copying_invert()
{
- std::cout << "test_copying_flip...\n";
+ std::cout << "test_copying_invert...\n";
boost::int64_t i64 = 0x0102030405060708LL, j64, k64;
- be::flip(i64, j64);
+ be::invert(i64, j64);
BOOST_TEST_EQ(j64, 0x0807060504030201LL);
BOOST_TEST_EQ(i64, 0x0102030405060708LL);
- be::flip(j64, k64);
+ be::invert(j64, k64);
BOOST_TEST_EQ(k64, 0x0102030405060708LL);
i64 = 0xfefdfcfbfaf9f8f7LL;
- be::flip(i64, j64);
+ be::invert(i64, j64);
BOOST_TEST_EQ(j64, static_cast<boost::int64_t>(0xf7f8f9fafbfcfdfeLL));
- be::flip(j64, k64);
+ be::invert(j64, k64);
BOOST_TEST_EQ(k64, static_cast<boost::int64_t>(0xfefdfcfbfaf9f8f7LL));
boost::int32_t i32 = 0x01020304, j32, k32;
- be::flip(i32, j32);
+ be::invert(i32, j32);
BOOST_TEST_EQ(j32, 0x04030201);
- be::flip(j32, k32);
+ be::invert(j32, k32);
BOOST_TEST_EQ(k32, 0x01020304);
i32 = 0xfefdfcfb;
- be::flip(i32, j32);
+ be::invert(i32, j32);
BOOST_TEST_EQ(j32, static_cast<boost::int32_t>(0xfbfcfdfe));
- be::flip(j32, k32);
+ be::invert(j32, k32);
BOOST_TEST_EQ(k32, static_cast<boost::int32_t>(0xfefdfcfb));
boost::int16_t i16 = 0x0102, j16, k16;
- be::flip(i16, j16);
+ be::invert(i16, j16);
BOOST_TEST_EQ(j16, 0x0201);
- be::flip(j16, k16);
+ be::invert(j16, k16);
BOOST_TEST_EQ(k16, 0x0102);
i16 = static_cast<boost::int16_t>(static_cast<boost::uint16_t>(0xfefd));
- be::flip(i16, j16);
+ be::invert(i16, j16);
BOOST_TEST_EQ(j16, static_cast<boost::int16_t>(static_cast<boost::uint16_t>(0xfdfe)));
- be::flip(j16, k16);
+ be::invert(j16, k16);
BOOST_TEST_EQ(k16, static_cast<boost::int16_t>(static_cast<boost::uint16_t>(0xfefd)));
boost::uint64_t ui64 = 0x0102030405060708ULL, uj64, uk64;
- be::flip(ui64, uj64);
+ be::invert(ui64, uj64);
BOOST_TEST_EQ(uj64, 0x0807060504030201ULL);
- be::flip(uj64, uk64);
+ be::invert(uj64, uk64);
BOOST_TEST_EQ(uk64, 0x0102030405060708ULL);
boost::uint32_t ui32 = 0x01020304, uj32, uk32;
- be::flip(ui32, uj32);
+ be::invert(ui32, uj32);
BOOST_TEST_EQ(uj32, static_cast<boost::uint32_t>(0x04030201));
- be::flip(uj32, uk32);
+ be::invert(uj32, uk32);
BOOST_TEST_EQ(uk32, static_cast<boost::uint32_t>(0x01020304));
boost::uint16_t ui16 = 0x0102, uj16, uk16;
- be::flip(ui16, uj16);
+ be::invert(ui16, uj16);
BOOST_TEST_EQ(uj16, 0x0201);
- be::flip(uj16, uk16);
+ be::invert(uj16, uk16);
BOOST_TEST_EQ(uk16, 0x0102);
- std::cout << " test_copying_flip complete\n";
+ std::cout << " test_copying_invert complete\n";
}
const boost::int64_t ni64 = 0x0102030405060708LL;
@@ -196,9 +196,9 @@
const boost::uint16_t lui16 = 0x0102;
# endif
- void test_in_place_conditional_flip()
+ void test_in_place_conditional_invert()
{
- std::cout << "test_in_place_conditional_flip...\n";
+ std::cout << "test_in_place_conditional_invert...\n";
boost::int64_t i64;
@@ -308,12 +308,12 @@
be::little_to_native(ui16);
BOOST_TEST_EQ(ui16, nui16);
- std::cout << " test_in_place_conditional_flip complete\n";
+ std::cout << " test_in_place_conditional_invert complete\n";
}
- void test_copying_conditional_flip()
+ void test_copying_conditional_invert()
{
- std::cout << "test_copying_conditional_flip...\n";
+ std::cout << "test_copying_conditional_invert...\n";
boost::int64_t i64, ti64;
@@ -423,7 +423,7 @@
be::little_to_native(ui16, tui16);
BOOST_TEST_EQ(tui16, nui16);
- std::cout << " test_copying_conditional_flip complete\n";
+ std::cout << " test_copying_conditional_invert complete\n";
}
} // unnamed namespace
@@ -431,10 +431,10 @@
int cpp_main(int, char * [])
{
std::cerr << std::hex;
- test_in_place_flip();
- test_copying_flip();
- test_in_place_conditional_flip();
- test_copying_conditional_flip();
+ test_in_place_invert();
+ test_copying_invert();
+ test_in_place_conditional_invert();
+ test_copying_conditional_invert();
return ::boost::report_errors();
}
Modified: sandbox/endian/libs/endian/test/msvc10/endian.sln
==============================================================================
--- sandbox/endian/libs/endian/test/msvc10/endian.sln (original)
+++ sandbox/endian/libs/endian/test/msvc10/endian.sln 2011-09-03 13:50:46 EDT (Sat, 03 Sep 2011)
@@ -15,7 +15,7 @@
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "binary_stream_test", "binary_stream_test\binary_stream_test.vcxproj", "{1382D085-FF3F-4573-8709-E10D3D74D620}"
EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "binary_stream_example", "binary_stream_example\binary_stream_example.vcxproj", "{06736C67-6305-4A9F-8D10-850FD0CE907D}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bin_manip_example", "binary_stream_example\binary_stream_example.vcxproj", "{06736C67-6305-4A9F-8D10-850FD0CE907D}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "conversion_test", "conversion_test\conversion_test.vcxproj", "{9FA33B0B-2B00-49E8-A892-E049D86076A9}"
EndProject
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk