| /* |
| * Copyright Andrey Semashev 2007 - 2015. |
| * 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 formatters/c_decorator.hpp |
| * \author Andrey Semashev |
| * \date 18.11.2012 |
| * |
| * The header contains implementation of C-style character decorators. |
| */ |
| |
| #ifndef BOOST_LOG_EXPRESSIONS_FORMATTERS_C_DECORATOR_HPP_INCLUDED_ |
| #define BOOST_LOG_EXPRESSIONS_FORMATTERS_C_DECORATOR_HPP_INCLUDED_ |
| |
| #include <limits> |
| #include <boost/range/iterator_range_core.hpp> |
| #include <boost/log/detail/config.hpp> |
| #include <boost/log/detail/snprintf.hpp> |
| #include <boost/log/expressions/formatters/char_decorator.hpp> |
| #include <boost/log/detail/header.hpp> |
| |
| #ifdef BOOST_HAS_PRAGMA_ONCE |
| #pragma once |
| #endif |
| |
| namespace boost { |
| |
| BOOST_LOG_OPEN_NAMESPACE |
| |
| namespace expressions { |
| |
| namespace aux { |
| |
| template< typename > |
| struct c_decorator_traits; |
| |
| #ifdef BOOST_LOG_USE_CHAR |
| template< > |
| struct c_decorator_traits< char > |
| { |
| static boost::iterator_range< const char* const* > get_patterns() |
| { |
| static const char* const patterns[] = |
| { |
| "\\", "\a", "\b", "\f", "\n", "\r", "\t", "\v", "'", "\"", "?" |
| }; |
| return boost::make_iterator_range(patterns); |
| } |
| static boost::iterator_range< const char* const* > get_replacements() |
| { |
| static const char* const replacements[] = |
| { |
| "\\\\", "\\a", "\\b", "\\f", "\\n", "\\r", "\\t", "\\v", "\\'", "\\\"", "\\?" |
| }; |
| return boost::make_iterator_range(replacements); |
| } |
| template< unsigned int N > |
| static std::size_t print_escaped(char (&buf)[N], char c) |
| { |
| int n = boost::log::aux::snprintf(buf, N, "\\x%0.2X", static_cast< unsigned int >(static_cast< uint8_t >(c))); |
| if (n < 0) |
| { |
| n = 0; |
| buf[0] = '\0'; |
| } |
| return static_cast< unsigned int >(n) >= N ? N - 1 : static_cast< unsigned int >(n); |
| } |
| }; |
| #endif // BOOST_LOG_USE_CHAR |
| |
| #ifdef BOOST_LOG_USE_WCHAR_T |
| template< > |
| struct c_decorator_traits< wchar_t > |
| { |
| static boost::iterator_range< const wchar_t* const* > get_patterns() |
| { |
| static const wchar_t* const patterns[] = |
| { |
| L"\\", L"\a", L"\b", L"\f", L"\n", L"\r", L"\t", L"\v", L"'", L"\"", L"?" |
| }; |
| return boost::make_iterator_range(patterns); |
| } |
| static boost::iterator_range< const wchar_t* const* > get_replacements() |
| { |
| static const wchar_t* const replacements[] = |
| { |
| L"\\\\", L"\\a", L"\\b", L"\\f", L"\\n", L"\\r", L"\\t", L"\\v", L"\\'", L"\\\"", L"\\?" |
| }; |
| return boost::make_iterator_range(replacements); |
| } |
| template< unsigned int N > |
| static std::size_t print_escaped(wchar_t (&buf)[N], wchar_t c) |
| { |
| const wchar_t* format; |
| unsigned int val; |
| if (sizeof(wchar_t) == 1) |
| { |
| format = L"\\x%0.2X"; |
| val = static_cast< uint8_t >(c); |
| } |
| else if (sizeof(wchar_t) == 2) |
| { |
| format = L"\\x%0.4X"; |
| val = static_cast< uint16_t >(c); |
| } |
| else |
| { |
| format = L"\\x%0.8X"; |
| val = static_cast< uint32_t >(c); |
| } |
| |
| int n = boost::log::aux::swprintf(buf, N, format, val); |
| if (n < 0) |
| { |
| n = 0; |
| buf[0] = L'\0'; |
| } |
| return static_cast< unsigned int >(n) >= N ? N - 1 : static_cast< unsigned int >(n); |
| } |
| }; |
| #endif // BOOST_LOG_USE_WCHAR_T |
| |
| template< typename CharT > |
| struct c_decorator_gen |
| { |
| typedef CharT char_type; |
| |
| template< typename SubactorT > |
| BOOST_FORCEINLINE char_decorator_actor< SubactorT, pattern_replacer< char_type > > operator[] (SubactorT const& subactor) const |
| { |
| typedef c_decorator_traits< char_type > traits_type; |
| typedef pattern_replacer< char_type > replacer_type; |
| typedef char_decorator_actor< SubactorT, replacer_type > result_type; |
| typedef typename result_type::terminal_type terminal_type; |
| typename result_type::base_type act = {{ terminal_type(subactor, replacer_type(traits_type::get_patterns(), traits_type::get_replacements())) }}; |
| return result_type(act); |
| } |
| }; |
| |
| } // namespace aux |
| |
| /*! |
| * C-style decorator generator object. The decorator replaces characters with specific meaning in C |
| * language with the corresponding escape sequences. The generator provides <tt>operator[]</tt> that |
| * can be used to construct the actual decorator. For example: |
| * |
| * <code> |
| * c_decor[ attr< std::string >("MyAttr") ] |
| * </code> |
| * |
| * For wide-character formatting there is the similar \c wc_decor decorator generator object. |
| */ |
| #ifdef BOOST_LOG_USE_CHAR |
| const aux::c_decorator_gen< char > c_decor = {}; |
| #endif |
| #ifdef BOOST_LOG_USE_WCHAR_T |
| const aux::c_decorator_gen< wchar_t > wc_decor = {}; |
| #endif |
| |
| /*! |
| * The function creates a C-style decorator generator for arbitrary character type. |
| */ |
| template< typename CharT > |
| BOOST_FORCEINLINE aux::c_decorator_gen< CharT > make_c_decor() |
| { |
| return aux::c_decorator_gen< CharT >(); |
| } |
| |
| /*! |
| * A character decorator implementation that escapes all non-prontable and non-ASCII characters |
| * in the output with C-style escape sequences. |
| */ |
| template< typename CharT > |
| class c_ascii_pattern_replacer : |
| public pattern_replacer< CharT > |
| { |
| private: |
| //! Base type |
| typedef pattern_replacer< CharT > base_type; |
| |
| public: |
| //! Result type |
| typedef typename base_type::result_type result_type; |
| //! Character type |
| typedef typename base_type::char_type char_type; |
| //! String type |
| typedef typename base_type::string_type string_type; |
| |
| private: |
| //! Traits type |
| typedef aux::c_decorator_traits< char_type > traits_type; |
| |
| public: |
| //! Default constructor |
| c_ascii_pattern_replacer() : base_type(traits_type::get_patterns(), traits_type::get_replacements()) |
| { |
| } |
| |
| //! Applies string replacements starting from the specified position |
| result_type operator() (string_type& str, typename string_type::size_type start_pos = 0) const |
| { |
| base_type::operator() (str, start_pos); |
| |
| typedef typename string_type::iterator string_iterator; |
| for (string_iterator it = str.begin() + start_pos, end = str.end(); it != end; ++it) |
| { |
| char_type c = *it; |
| if (c < 0x20 || c > 0x7e) |
| { |
| char_type buf[(std::numeric_limits< char_type >::digits + 3) / 4 + 3]; |
| std::size_t n = traits_type::print_escaped(buf, c); |
| std::size_t pos = it - str.begin(); |
| str.replace(pos, 1, buf, n); |
| it = str.begin() + n - 1; |
| end = str.end(); |
| } |
| } |
| } |
| }; |
| |
| namespace aux { |
| |
| template< typename CharT > |
| struct c_ascii_decorator_gen |
| { |
| typedef CharT char_type; |
| |
| template< typename SubactorT > |
| BOOST_FORCEINLINE char_decorator_actor< SubactorT, c_ascii_pattern_replacer< char_type > > operator[] (SubactorT const& subactor) const |
| { |
| typedef c_decorator_traits< char_type > traits_type; |
| typedef c_ascii_pattern_replacer< char_type > replacer_type; |
| typedef char_decorator_actor< SubactorT, replacer_type > result_type; |
| typedef typename result_type::terminal_type terminal_type; |
| typename result_type::base_type act = {{ terminal_type(subactor, replacer_type()) }}; |
| return result_type(act); |
| } |
| }; |
| |
| } // namespace aux |
| |
| /*! |
| * C-style decorator generator object. Acts similarly to \c c_decor, except that \c c_ascii_decor also |
| * converts all non-ASCII and non-printable ASCII characters, except for space character, into |
| * C-style hexadecimal escape sequences. The generator provides <tt>operator[]</tt> that |
| * can be used to construct the actual decorator. For example: |
| * |
| * <code> |
| * c_ascii_decor[ attr< std::string >("MyAttr") ] |
| * </code> |
| * |
| * For wide-character formatting there is the similar \c wc_ascii_decor decorator generator object. |
| */ |
| #ifdef BOOST_LOG_USE_CHAR |
| const aux::c_ascii_decorator_gen< char > c_ascii_decor = {}; |
| #endif |
| #ifdef BOOST_LOG_USE_WCHAR_T |
| const aux::c_ascii_decorator_gen< wchar_t > wc_ascii_decor = {}; |
| #endif |
| |
| /*! |
| * The function creates a C-style decorator generator for arbitrary character type. |
| */ |
| template< typename CharT > |
| BOOST_FORCEINLINE aux::c_ascii_decorator_gen< CharT > make_c_ascii_decor() |
| { |
| return aux::c_ascii_decorator_gen< CharT >(); |
| } |
| |
| } // namespace expressions |
| |
| BOOST_LOG_CLOSE_NAMESPACE // namespace log |
| |
| } // namespace boost |
| |
| #include <boost/log/detail/footer.hpp> |
| |
| #endif // BOOST_LOG_EXPRESSIONS_FORMATTERS_C_DECORATOR_HPP_INCLUDED_ |