Add hex/unhex algorithms suggested by Olaf

[SVN r77138]

include/boost/algorithm/hex.hpp

@@ -0,0 +1,278 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+   
+   Thanks to Nevin for his comments/help.
+*/
+
+/*
+    General problem - turn a sequence of integral types into a sequence of hexadecimal characters.
+    - and back.
+
+TO DO:
+    1. these should really only work on integral types. (see the >> and << operations)
+        -- this is done, I think.
+    2. The 'value_type_or_char' struct is really a hack.
+        -- but it's a better hack now that it works with back_insert_iterators
+*/
+
+/// \file  hex.hpp
+/// \brief Convert sequence of integral types into a sequence of hexadecimal 
+///     characters and back. Based on the MySQL functions HEX and UNHEX
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_HEXHPP
+#define BOOST_ALGORITHM_HEXHPP
+
+#include <iterator>     // for std::iterator_traits
+#include <stdexcept>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/exception/all.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_integral.hpp>
+
+
+namespace boost { namespace algorithm {
+
+/*! 
+    \struct hex_decode_error 
+    \brief  Base exception class for all hex decoding errors 
+    
+    \struct non_hex_input    
+    \brief  Thrown when a non-hex value (0-9, A-F) encountered when decoding.
+    			Contains the offending character
+    
+    \struct not_enough_input 
+    \brief  Thrown when the input sequence unexpectedly ends
+    
+*/
+struct hex_decode_error: virtual boost::exception, virtual std::exception {};
+struct not_enough_input : public hex_decode_error {};
+struct non_hex_input : public hex_decode_error {
+    non_hex_input ( char ch ) : bad_char ( ch ) {}
+    char bad_char;
+private:
+    non_hex_input ();       // don't allow creation w/o a char
+    };
+
+namespace detail {
+/// \cond DOXYGEN_HIDE
+
+    template <typename T, typename OutputIterator>
+    OutputIterator encode_one ( T val, OutputIterator out ) {
+        const std::size_t num_hex_digits =  2 * sizeof ( T );
+        char res [ num_hex_digits ];
+        char  *p = res + num_hex_digits;
+        for ( std::size_t i = 0; i < num_hex_digits; ++i, val >>= 4 )
+            *--p = "0123456789ABCDEF" [ val & 0x0F ];
+        return std::copy ( res, res + num_hex_digits, out );
+        }
+
+    unsigned hex_char_to_int ( char c ) {
+        if ( c >= '0' && c <= '9' ) return c - '0';
+        if ( c >= 'A' && c <= 'F' ) return c - 'A' + 10;
+        if ( c >= 'a' && c <= 'f' ) return c - 'a' + 10;
+        BOOST_THROW_EXCEPTION (non_hex_input (c));
+        return 0;   // keep dumb compilers happy
+        }
+    
+
+//  My own iterator_traits class.
+//  It is here so that I can "reach inside" some kinds of output iterators
+//      and get the type to write.
+    template <typename Iterator>
+    struct hex_iterator_traits {
+        typedef typename std::iterator_traits<Iterator>::value_type value_type;
+    };
+
+    template<typename Container>
+    struct hex_iterator_traits< std::back_insert_iterator<Container> > {
+        typedef typename Container::value_type value_type;
+    };
+
+    template<typename Container>
+    struct hex_iterator_traits< std::front_insert_iterator<Container> > {
+        typedef typename Container::value_type value_type;
+    };
+
+    template<typename Container>
+    struct hex_iterator_traits< std::insert_iterator<Container> > {
+        typedef typename Container::value_type value_type;
+    };
+
+//  ostream_iterators have three template parameters.
+//  The first one is the output type, the second one is the character type of
+//  the underlying stream, the third is the character traits.
+//      We only care about the first one.
+  template<typename T, typename charType, typename traits>
+  struct hex_iterator_traits< std::ostream_iterator<T, charType, traits> > {
+      typedef T value_type;
+  };
+
+//  Output Iterators have a value type of 'void'. Kinda sucks. 
+//  We special case some output iterators, but we can't enumerate them all.
+//  If we can't figure it out, we assume that you want to output chars.
+//  If you don't, pass in an iterator with a real value_type.
+    template <typename T> struct value_type_or_char       { typedef T value_type; };
+    template <>           struct value_type_or_char<void> { typedef char value_type; };
+    
+//  All in one step
+    template <typename Iterator> 
+    struct iterator_value_type {
+//        typedef typename value_type_or_char<typename hex_iterator_traits<Iterator>::value_type>::value_type value_type;
+        typedef typename hex_iterator_traits<Iterator>::value_type value_type;
+        };
+        
+//  What can we assume here about the inputs?
+//      is std::iterator_traits<InputIterator>::value_type always 'char' ?
+//  Could it be wchar_t, say? Does it matter?
+//      We are assuming ASCII for the values - but what about the storage?
+    template <typename InputIterator, typename OutputIterator>
+    typename boost::enable_if<boost::is_integral<typename iterator_value_type<OutputIterator>::value_type>, OutputIterator>::type
+    decode_one ( InputIterator &first, InputIterator last, OutputIterator out ) {
+        typedef typename iterator_value_type<OutputIterator>::value_type T;
+        T res (0);
+
+    //  Need to make sure that we get can read that many chars here.
+        for ( std::size_t i = 0; i < 2 * sizeof ( T ); ++i, ++first ) {
+            if ( first == last ) 
+                BOOST_THROW_EXCEPTION (not_enough_input ());
+            res = ( 16 * res ) + hex_char_to_int (static_cast<char> (*first));
+            }
+        
+        *out = res;
+        return ++out;
+        }
+/// \endcond
+    }
+
+
+/// \fn hex ( InputIterator first, InputIterator last, OutputIterator out )
+/// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
+/// 
+/// \param first    The start of the input sequence
+/// \param last     One past the end of the input sequence
+/// \param out      An output iterator to the results into
+/// \note           Based on the MySQL function of the same name
+template <typename InputIterator, typename OutputIterator>
+typename boost::enable_if<boost::is_integral<typename detail::hex_iterator_traits<InputIterator>::value_type>, OutputIterator>::type
+hex ( InputIterator first, InputIterator last, OutputIterator out ) {
+    for ( ; first != last; ++first )
+        out = detail::encode_one ( *first, out );
+    return out;
+    }
+    
+
+/// \fn hex ( const T *ptr, OutputIterator out )
+/// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
+/// 
+/// \param ptr      A pointer to a 0-terminated sequence of data.
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename T, typename OutputIterator>
+typename boost::enable_if<boost::is_integral<T>, OutputIterator>::type
+hex ( const T *ptr, OutputIterator out ) {
+    while ( *ptr )
+        out = detail::encode_one ( *ptr++, out );
+    return out;
+    }
+
+/// \fn hex ( const Range &r, OutputIterator out )
+/// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
+/// 
+/// \param r        The input range
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename Range, typename OutputIterator>
+typename boost::enable_if<boost::is_integral<typename detail::hex_iterator_traits<typename Range::iterator>::value_type>, OutputIterator>::type
+hex ( const Range &r, OutputIterator out ) {
+    return hex (boost::begin(r), boost::end(r), out);
+}
+
+
+/// \fn unhex ( InputIterator first, InputIterator last, OutputIterator out )
+/// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
+/// 
+/// \param first    The start of the input sequence
+/// \param last     One past the end of the input sequence
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename InputIterator, typename OutputIterator>
+OutputIterator unhex ( InputIterator first, InputIterator last, OutputIterator out ) {
+    while ( first != last )
+        out = detail::decode_one ( first, last, out );
+    return out;
+    }
+
+
+/// \fn unhex ( const T *ptr, OutputIterator out )
+/// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
+/// 
+/// \param ptr      A pointer to a null-terminated input sequence.
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename T, typename OutputIterator>
+OutputIterator unhex ( const T *ptr, OutputIterator out ) {
+    typedef typename detail::iterator_value_type<OutputIterator>::value_type OutputType;
+//  If we run into the terminator while decoding, we will throw a
+//      malformed input exception. It would be nicer to throw a 'Not enough input'
+//      exception - but how much extra work would that require?
+//  I just make up an "end iterator" which we will never get to - 
+//      two Ts per byte of the output type.
+    while ( *ptr )
+        out = detail::decode_one ( ptr, ptr + 2 * sizeof(OutputType), out );
+    return out;
+    }
+
+
+/// \fn unhex ( const Range &r, OutputIterator out )
+/// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
+/// 
+/// \param r        The input range
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename Range, typename OutputIterator>
+OutputIterator unhex ( const Range &r, OutputIterator out ) {
+    return unhex (boost::begin(r), boost::end(r), out);
+    }
+
+
+/// \fn hex ( const String &input )
+/// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
+/// 
+/// \param input    A container to be converted
+/// \return         A container with the encoded text
+template<typename String>
+String hex ( const String &input ) {
+    String output;
+    output.reserve (input.size () * (2 * sizeof (typename String::value_type)));
+    (void) hex (input, std::back_inserter (output));
+    return output;
+    }
+
+/// \fn unhex ( const String &input )
+/// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
+/// 
+/// \param input    A container to be converted
+/// \return         A container with the decoded text
+template<typename String>
+String unhex ( const String &input ) {
+    String output;
+    output.reserve (input.size () / (2 * sizeof (typename String::value_type)));
+    (void) unhex (input, std::back_inserter (output));
+    return output;
+    }
+
+}}
+
+#endif // BOOST_ALGORITHM_HEXHPP

test/Jamfile.v2

@@ -39,6 +39,11 @@ import testing ;
      [ run is_partitioned_test1.cpp        : : : : is_partitioned_test1 ]
      [ run partition_copy_test1.cpp        : : : : partition_copy_test1 ]
 
+# Hex tests
+     [ run hex_test1.cpp        : : : : hex_test1 ]
+     [ run hex_test2.cpp        : : : : hex_test2 ]
+     [ run hex_test3.cpp        : : : : hex_test3 ]
+	 [ compile-fail hex_fail1.cpp ]
    ;
 }
 

test/hex_fail1.cpp

@@ -0,0 +1,25 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+#include <vector>
+
+//	should not compile: vector is not an integral type
+int test_main( int , char* [] )
+{
+  std::vector<float> v;
+  std::string out;
+  boost::algorithm::unhex ( out, std::back_inserter(v));
+  return 0;
+}

test/hex_test1.cpp

@@ -0,0 +1,154 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+
+
+template<typename String>
+void test_to_hex ( const typename String::value_type ** tests ) {
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, argh, one, two, three, four;
+        arg.assign ( *p );
+        boost::algorithm::hex ( *p, std::back_inserter ( one ));
+        boost::algorithm::hex ( arg, std::back_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        four = boost::algorithm::hex ( arg );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        argh = one;
+        one.clear (); two.clear (); three.clear (); four.clear ();
+        boost::algorithm::unhex ( argh.c_str (), std::back_inserter ( one ));
+        boost::algorithm::unhex ( argh, std::back_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+        four = boost::algorithm::unhex ( argh );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        BOOST_CHECK ( one == arg );
+        }
+    }
+
+
+template<typename String>
+void test_from_hex_success ( const typename String::value_type ** tests ) {
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, argh, one, two, three, four;
+        arg.assign ( *p );
+        boost::algorithm::unhex ( *p, std::back_inserter ( one ));
+        boost::algorithm::unhex ( arg, std::back_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        four = boost::algorithm::unhex ( arg );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        argh = one;
+        one.clear (); two.clear (); three.clear (); four.clear ();
+        boost::algorithm::hex ( argh.c_str (), std::back_inserter ( one ));
+        boost::algorithm::hex ( argh, std::back_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+        four = boost::algorithm::hex ( argh );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        BOOST_CHECK ( one == arg );
+        }
+    }
+
+template<typename String>
+void test_from_hex_failure ( const typename String::value_type ** tests ) {
+    int num_catches;
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, one;
+        arg.assign ( *p );
+        num_catches = 0;
+
+        try { boost::algorithm::unhex ( *p, std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        try { boost::algorithm::unhex ( arg, std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        try { boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        BOOST_CHECK ( num_catches == 3 );
+        }
+    }
+
+
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *tohex_w [] = {
+    L"",
+    L"a",
+    L"\001",
+    L"12",
+    L"asdfadsfsad",
+    L"01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *fromhex_w [] = {
+    L"00101020",
+    L"2122234556FF3456",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex_fail [] = {
+    "2",
+    "H",
+    "234",
+    "21222G4556FF",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *fromhex_fail_w [] = {
+    L"2",
+    L"12",
+    L"H",
+    L"234",
+    L"21222G4556FF",
+    NULL        // End of the list
+    };
+
+
+int test_main( int , char* [] )
+{
+  test_to_hex<std::string> ( tohex );
+  test_from_hex_success<std::string> ( fromhex );
+  test_from_hex_failure<std::string> ( fromhex_fail );
+
+  test_to_hex<std::wstring> ( tohex_w );
+  test_from_hex_success<std::wstring> ( fromhex_w );
+  test_from_hex_failure<std::wstring> ( fromhex_fail_w );
+  return 0;
+}

test/hex_test2.cpp

@@ -0,0 +1,137 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+
+Test non-string cases; vector and list
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+#include <deque>
+#include <list>
+
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+void test_to_hex () {
+    for ( const char **p = tohex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::hex ( *p,                       std::back_inserter ( one ));
+        boost::algorithm::hex ( arg,                      std::back_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+        std::copy ( one.begin (), one.end (), std::back_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::unhex ( argh.c_str (),              std::back_inserter ( one ));
+        boost::algorithm::unhex ( argh,                       std::back_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.begin ()));
+        }
+
+//  Again, with a front_inserter
+    for ( const char **p = tohex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::hex ( *p,                       std::front_inserter ( one ));
+        boost::algorithm::hex ( arg,                      std::front_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::front_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+    //  Copy, reversing
+        std::copy ( one.begin (), one.end (), std::front_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::unhex ( argh.c_str (),              std::front_inserter ( one ));
+        boost::algorithm::unhex ( argh,                       std::front_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::front_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.rbegin ()));   // reverse
+        }
+    }
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    NULL        // End of the list
+    };
+
+
+void test_from_hex_success () {
+    for ( const char **p = fromhex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::unhex ( *p,                       std::back_inserter ( one ));
+        boost::algorithm::unhex ( arg,                      std::back_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+        std::copy ( one.begin (), one.end (), std::back_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::hex ( argh.c_str (),              std::back_inserter ( one ));
+        boost::algorithm::hex ( argh,                       std::back_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.begin ()));
+        }
+
+//  Again, with a front_inserter
+    for ( const char **p = fromhex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::unhex ( *p,                       std::front_inserter ( one ));
+        boost::algorithm::unhex ( arg,                      std::front_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::front_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+    //  Copy, reversing
+        std::copy ( one.begin (), one.end (), std::front_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::hex ( argh.c_str (),              std::front_inserter ( one ));
+        boost::algorithm::hex ( argh,                       std::front_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::front_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.rbegin ()));   // reversed
+        }
+    }
+
+
+int test_main( int , char* [] )
+{
+  test_to_hex ();
+  test_from_hex_success ();
+  return 0;
+}

test/hex_test3.cpp

@@ -0,0 +1,123 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+
+Try ostream_iterators
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+#include <deque>
+#include <list>
+
+
+template <typename char_type>
+void test_to_hex ( const char_type ** tests ) {
+	typedef std::basic_string<char_type> String;
+	typedef std::basic_ostringstream<char_type> Stream;
+	typedef std::ostream_iterator<char_type, char_type> Iter;
+
+    for ( const char_type **p = tests; *p; p++ ) {
+    	String arg, argh;
+        Stream one, two, three;
+        arg.assign ( *p );
+        boost::algorithm::hex ( *p, Iter ( one ));
+        boost::algorithm::hex ( arg, Iter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), Iter ( three ));
+        boost::algorithm::hex ( arg );
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        argh = one.str ();
+        one.str (String()); two.str (String()); three.str (String());
+        boost::algorithm::unhex ( argh.c_str (), Iter ( one ));
+        boost::algorithm::unhex ( argh, Iter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), Iter ( three ));
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        BOOST_CHECK ( one.str () == arg );
+        }
+    }
+
+
+template <typename char_type>
+void test_from_hex_success ( const char_type ** tests ) {
+	typedef std::basic_string<char_type> String;
+	typedef std::basic_ostringstream<char_type> Stream;
+	typedef std::ostream_iterator<char_type, char_type> Iter;
+
+    for ( const char_type **p = tests; *p; p++ ) {
+    	String arg, argh;
+        Stream one, two, three;
+        arg.assign ( *p );
+        boost::algorithm::unhex ( *p,                       Iter ( one ));
+        boost::algorithm::unhex ( arg,                      Iter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), Iter ( three ));
+        
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+
+        argh = one.str ();
+        one.str (String()); two.str (String()); three.str (String());
+
+        boost::algorithm::hex ( argh.c_str (),              Iter ( one ));
+        boost::algorithm::hex ( argh,                       Iter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), Iter ( three ));
+
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        BOOST_CHECK ( one.str () == arg );
+        }
+
+    }
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+const wchar_t *tohex_w [] = {
+    L"",
+    L"a",
+    L"\001",
+    L"12",
+    L"asdfadsfsad",
+    L"01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    NULL        // End of the list
+    };
+
+const wchar_t *fromhex_w [] = {
+    L"11223320",
+    L"21222345010256FF",
+    NULL        // End of the list
+    };
+
+
+
+int test_main( int , char* [] )
+{
+  test_to_hex ( tohex );
+  test_to_hex ( tohex_w );
+  test_from_hex_success ( fromhex );
+  test_from_hex_success ( fromhex_w );
+  return 0;
+}