diff options
Diffstat (limited to 'boost/log/utility/manipulators/dump.hpp')
-rw-r--r-- | boost/log/utility/manipulators/dump.hpp | 231 |
1 files changed, 231 insertions, 0 deletions
diff --git a/boost/log/utility/manipulators/dump.hpp b/boost/log/utility/manipulators/dump.hpp new file mode 100644 index 0000000000..99b2fad749 --- /dev/null +++ b/boost/log/utility/manipulators/dump.hpp @@ -0,0 +1,231 @@ +/* + * Copyright Andrey Semashev 2007 - 2014. + * 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) + */ +/*! + * \file dump.hpp + * \author Andrey Semashev + * \date 03.05.2013 + * + * This header contains the \c dump output manipulator. + */ + +#ifndef BOOST_LOG_UTILITY_MANIPULATORS_DUMP_HPP_INCLUDED_ +#define BOOST_LOG_UTILITY_MANIPULATORS_DUMP_HPP_INCLUDED_ + +#include <cstddef> +#include <iosfwd> +#include <boost/log/detail/config.hpp> +#include <boost/log/detail/header.hpp> + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { + +BOOST_LOG_OPEN_NAMESPACE + +namespace aux { + +typedef void dump_data_char_t(const void* data, std::size_t size, std::basic_ostream< char >& strm); +extern BOOST_LOG_API dump_data_char_t* dump_data_char; +BOOST_FORCEINLINE void dump_data(const void* data, std::size_t size, std::basic_ostream< char >& strm) +{ + (dump_data_char)(data, size, strm); +} + +typedef void dump_data_wchar_t(const void* data, std::size_t size, std::basic_ostream< wchar_t >& strm); +extern BOOST_LOG_API dump_data_wchar_t* dump_data_wchar; +BOOST_FORCEINLINE void dump_data(const void* data, std::size_t size, std::basic_ostream< wchar_t >& strm) +{ + (dump_data_wchar)(data, size, strm); +} + +#if !defined(BOOST_NO_CXX11_CHAR16_T) +typedef void dump_data_char16_t(const void* data, std::size_t size, std::basic_ostream< char16_t >& strm); +extern BOOST_LOG_API dump_data_char16_t* dump_data_char16; +BOOST_FORCEINLINE void dump_data(const void* data, std::size_t size, std::basic_ostream< char16_t >& strm) +{ + (dump_data_char16)(data, size, strm); +} +#endif + +#if !defined(BOOST_NO_CXX11_CHAR32_T) +typedef void dump_data_char32_t(const void* data, std::size_t size, std::basic_ostream< char32_t >& strm); +extern BOOST_LOG_API dump_data_char32_t* dump_data_char32; +BOOST_FORCEINLINE void dump_data(const void* data, std::size_t size, std::basic_ostream< char32_t >& strm) +{ + (dump_data_char32)(data, size, strm); +} +#endif + +template< std::size_t SizeV, typename R > +struct enable_dump_size_based +{ +}; + +template< typename R > +struct enable_dump_size_based< 1u, R > +{ + typedef R type; +}; + +template< typename T, typename R > +struct enable_dump : + public enable_dump_size_based< sizeof(T), R > +{ +}; + +template< typename R > +struct enable_dump< void, R > +{ + typedef R type; +}; + +template< typename R > +struct enable_dump< const void, R > +{ + typedef R type; +}; + +template< typename R > +struct enable_dump< volatile void, R > +{ + typedef R type; +}; + +template< typename R > +struct enable_dump< const volatile void, R > +{ + typedef R type; +}; + +} // namespace aux + +/*! + * \brief Manipulator for printing binary representation of the data + */ +class dump_manip +{ +private: + //! Beginning of the data + const void* m_data; + //! Size of the data, in bytes + std::size_t m_size; + +public: + dump_manip(const void* data, std::size_t size) BOOST_NOEXCEPT : m_data(data), m_size(size) {} + dump_manip(dump_manip const& that) BOOST_NOEXCEPT : m_data(that.m_data), m_size(that.m_size) {} + + const void* get_data() const BOOST_NOEXCEPT { return m_data; } + std::size_t get_size() const BOOST_NOEXCEPT { return m_size; } +}; + +//! The operator outputs binary data to a stream +template< typename CharT, typename TraitsT > +inline std::basic_ostream< CharT, TraitsT >& operator<< (std::basic_ostream< CharT, TraitsT >& strm, dump_manip const& manip) +{ + if (strm.good()) + aux::dump_data(manip.get_data(), manip.get_size(), strm); + + return strm; +} + +/*! + * \brief Manipulator for printing binary representation of the data with a size limit + */ +class bounded_dump_manip : + public dump_manip +{ +private: + //! Maximum size to output, in bytes + std::size_t m_max_size; + +public: + bounded_dump_manip(const void* data, std::size_t size, std::size_t max_size) BOOST_NOEXCEPT : dump_manip(data, size), m_max_size(max_size) {} + bounded_dump_manip(bounded_dump_manip const& that) BOOST_NOEXCEPT : dump_manip(static_cast< dump_manip const& >(that)), m_max_size(that.m_max_size) {} + + std::size_t get_max_size() const BOOST_NOEXCEPT { return m_max_size; } +}; + +//! The operator outputs binary data to a stream +template< typename CharT, typename TraitsT > +inline std::basic_ostream< CharT, TraitsT >& operator<< (std::basic_ostream< CharT, TraitsT >& strm, bounded_dump_manip const& manip) +{ + if (strm.good()) + { + const std::size_t size = manip.get_size(), max_size = manip.get_max_size(); + if (max_size >= size) + { + aux::dump_data(manip.get_data(), size, strm); + } + else + { + aux::dump_data(manip.get_data(), max_size, strm); + strm << " and " << (size - max_size) << " bytes more"; + } + } + + return strm; +} + +/*! + * \brief Creates a stream manipulator that will output contents of a memory region in hexadecimal form + * \param data The pointer to the beginning of the region + * \param size The size of the region, in bytes + * \return The manipulator that is to be put to a stream + */ +template< typename T > +inline typename aux::enable_dump< T, dump_manip >::type dump(T* data, std::size_t size) BOOST_NOEXCEPT +{ + return dump_manip((const void*)data, size); +} + +/*! + * \brief Creates a stream manipulator that will dump elements of an array in hexadecimal form + * \param data The pointer to the beginning of the array + * \param count The size of the region, in number of \c T elements + * \return The manipulator that is to be put to a stream + */ +template< typename T > +inline dump_manip dump_elements(T* data, std::size_t count) BOOST_NOEXCEPT +{ + return dump_manip((const void*)data, count * sizeof(T)); +} + +/*! + * \brief Creates a stream manipulator that will output contents of a memory region in hexadecimal form + * \param data The pointer to the beginning of the region + * \param size The size of the region, in bytes + * \params max_size The maximum number of bytes of the region to output + * \return The manipulator that is to be put to a stream + */ +template< typename T > +inline typename aux::enable_dump< T, bounded_dump_manip >::type dump(T* data, std::size_t size, std::size_t max_size) BOOST_NOEXCEPT +{ + return bounded_dump_manip((const void*)data, size, max_size); +} + +/*! + * \brief Creates a stream manipulator that will dump elements of an array in hexadecimal form + * \param data The pointer to the beginning of the array + * \param count The size of the region, in number of \c T elements + * \params max_count The maximum number of elements to output + * \return The manipulator that is to be put to a stream + */ +template< typename T > +inline bounded_dump_manip dump_elements(T* data, std::size_t count, std::size_t max_count) BOOST_NOEXCEPT +{ + return bounded_dump_manip((const void*)data, count * sizeof(T), max_count * sizeof(T)); +} + +BOOST_LOG_CLOSE_NAMESPACE // namespace log + +} // namespace boost + +#include <boost/log/detail/footer.hpp> + +#endif // BOOST_LOG_UTILITY_MANIPULATORS_DUMP_HPP_INCLUDED_ |