| /* |
| 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. |
| */ |
| |
| /// \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 : virtual hex_decode_error {}; |
| struct non_hex_input : virtual hex_decode_error {}; |
| typedef boost::error_info<struct bad_char_,char> bad_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 ); |
| } |
| |
| template <typename T> |
| unsigned char hex_char_to_int ( T val ) { |
| char c = static_cast<char> ( val ); |
| unsigned retval = 0; |
| if ( c >= '0' && c <= '9' ) retval = c - '0'; |
| else if ( c >= 'A' && c <= 'F' ) retval = c - 'A' + 10; |
| else if ( c >= 'a' && c <= 'f' ) retval = c - 'a' + 10; |
| else BOOST_THROW_EXCEPTION (non_hex_input() << bad_char (c)); |
| return retval; |
| } |
| |
| // 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; |
| }; |
| |
| template <typename Iterator> |
| bool iter_end ( Iterator current, Iterator last ) { return current == last; } |
| |
| template <typename T> |
| bool ptr_end ( const T* ptr, const T* /*end*/ ) { return *ptr == '\0'; } |
| |
| // 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 EndPred> |
| typename boost::enable_if<boost::is_integral<typename hex_iterator_traits<OutputIterator>::value_type>, OutputIterator>::type |
| decode_one ( InputIterator &first, InputIterator last, OutputIterator out, EndPred pred ) { |
| typedef typename hex_iterator_traits<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 ( pred ( first, last )) |
| BOOST_THROW_EXCEPTION (not_enough_input ()); |
| res = ( 16 * res ) + hex_char_to_int (*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 |
| /// \return The updated output iterator |
| /// \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, detail::iter_end<InputIterator> ); |
| 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 ) { |
| // 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? |
| while ( *ptr ) |
| out = detail::decode_one ( ptr, (const T *) NULL, out, detail::ptr_end<T> ); |
| return out; |
| } |
| |
| |
| /// \fn OutputIterator 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 String 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 String unhex ( const String &input ) |
| /// \brief Converts a sequence of hexadecimal characters into a sequence of characters. |
| /// |
| /// \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 |