485 lines
20 KiB
C++
485 lines
20 KiB
C++
|
/*
|
||
|
* 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 formatter.hpp
|
||
|
* \author Andrey Semashev
|
||
|
* \date 13.07.2012
|
||
|
*
|
||
|
* The header contains a formatter function object definition.
|
||
|
*/
|
||
|
|
||
|
#ifndef BOOST_LOG_EXPRESSIONS_FORMATTER_HPP_INCLUDED_
|
||
|
#define BOOST_LOG_EXPRESSIONS_FORMATTER_HPP_INCLUDED_
|
||
|
|
||
|
#include <locale>
|
||
|
#include <ostream>
|
||
|
#include <boost/ref.hpp>
|
||
|
#include <boost/move/core.hpp>
|
||
|
#include <boost/move/utility_core.hpp>
|
||
|
#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||
|
#include <boost/type_traits/is_same.hpp>
|
||
|
#include <boost/type_traits/remove_cv.hpp>
|
||
|
#include <boost/log/detail/sfinae_tools.hpp>
|
||
|
#endif
|
||
|
#include <boost/log/detail/config.hpp>
|
||
|
#include <boost/log/detail/light_function.hpp>
|
||
|
#include <boost/log/attributes/attribute_value_set.hpp>
|
||
|
#include <boost/log/attributes/value_visitation.hpp>
|
||
|
#include <boost/log/core/record_view.hpp>
|
||
|
#include <boost/log/utility/formatting_ostream.hpp>
|
||
|
#include <boost/log/utility/functional/bind_output.hpp>
|
||
|
#include <boost/log/expressions/message.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 {
|
||
|
|
||
|
// This reference class is a workaround for a Boost.Phoenix bug: https://svn.boost.org/trac/boost/ticket/9363
|
||
|
// It is needed to pass output streams by non-const reference to function objects wrapped in phoenix::bind and phoenix::function.
|
||
|
// It's an implementation detail and will be removed when Boost.Phoenix is fixed.
|
||
|
template< typename StreamT >
|
||
|
class stream_ref :
|
||
|
public reference_wrapper< StreamT >
|
||
|
{
|
||
|
public:
|
||
|
typedef typename StreamT::char_type char_type;
|
||
|
typedef typename StreamT::traits_type traits_type;
|
||
|
typedef typename StreamT::allocator_type allocator_type;
|
||
|
typedef typename StreamT::streambuf_type streambuf_type;
|
||
|
typedef typename StreamT::string_type string_type;
|
||
|
typedef typename StreamT::ostream_type ostream_type;
|
||
|
typedef typename StreamT::pos_type pos_type;
|
||
|
typedef typename StreamT::off_type off_type;
|
||
|
typedef typename StreamT::int_type int_type;
|
||
|
|
||
|
typedef typename StreamT::failure failure;
|
||
|
typedef typename StreamT::fmtflags fmtflags;
|
||
|
typedef typename StreamT::iostate iostate;
|
||
|
typedef typename StreamT::openmode openmode;
|
||
|
typedef typename StreamT::seekdir seekdir;
|
||
|
typedef typename StreamT::Init Init;
|
||
|
|
||
|
typedef typename StreamT::event event;
|
||
|
typedef typename StreamT::event_callback event_callback;
|
||
|
|
||
|
typedef typename StreamT::sentry sentry;
|
||
|
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags boolalpha = StreamT::boolalpha;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags dec = StreamT::dec;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags fixed = StreamT::fixed;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags hex = StreamT::hex;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags internal = StreamT::internal;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags left = StreamT::left;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags oct = StreamT::oct;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags right = StreamT::right;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags scientific = StreamT::scientific;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags showbase = StreamT::showbase;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags showpoint = StreamT::showpoint;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags skipws = StreamT::skipws;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags unitbuf = StreamT::unitbuf;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags uppercase = StreamT::uppercase;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags adjustfield = StreamT::adjustfield;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags basefield = StreamT::basefield;
|
||
|
static BOOST_CONSTEXPR_OR_CONST fmtflags floatfield = StreamT::floatfield;
|
||
|
|
||
|
static BOOST_CONSTEXPR_OR_CONST iostate badbit = StreamT::badbit;
|
||
|
static BOOST_CONSTEXPR_OR_CONST iostate eofbit = StreamT::eofbit;
|
||
|
static BOOST_CONSTEXPR_OR_CONST iostate failbit = StreamT::failbit;
|
||
|
static BOOST_CONSTEXPR_OR_CONST iostate goodbit = StreamT::goodbit;
|
||
|
|
||
|
static BOOST_CONSTEXPR_OR_CONST openmode app = StreamT::app;
|
||
|
static BOOST_CONSTEXPR_OR_CONST openmode ate = StreamT::ate;
|
||
|
static BOOST_CONSTEXPR_OR_CONST openmode binary = StreamT::binary;
|
||
|
static BOOST_CONSTEXPR_OR_CONST openmode in = StreamT::in;
|
||
|
static BOOST_CONSTEXPR_OR_CONST openmode out = StreamT::out;
|
||
|
static BOOST_CONSTEXPR_OR_CONST openmode trunc = StreamT::trunc;
|
||
|
|
||
|
static BOOST_CONSTEXPR_OR_CONST seekdir beg = StreamT::beg;
|
||
|
static BOOST_CONSTEXPR_OR_CONST seekdir cur = StreamT::cur;
|
||
|
static BOOST_CONSTEXPR_OR_CONST seekdir end = StreamT::end;
|
||
|
|
||
|
static BOOST_CONSTEXPR_OR_CONST event erase_event = StreamT::erase_event;
|
||
|
static BOOST_CONSTEXPR_OR_CONST event imbue_event = StreamT::imbue_event;
|
||
|
static BOOST_CONSTEXPR_OR_CONST event copyfmt_event = StreamT::copyfmt_event;
|
||
|
|
||
|
|
||
|
BOOST_FORCEINLINE explicit stream_ref(StreamT& strm) : reference_wrapper< StreamT >(strm)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||
|
template< typename T >
|
||
|
BOOST_FORCEINLINE StreamT& operator<< (T&& val) const
|
||
|
{
|
||
|
StreamT& strm = this->get();
|
||
|
strm << static_cast< T&& >(val);
|
||
|
return strm;
|
||
|
}
|
||
|
#if defined(BOOST_MSVC) && BOOST_MSVC < 1800
|
||
|
// MSVC 10 and 11 generate broken code for the perfect forwarding version above if T is an array type (e.g. a string literal)
|
||
|
template< typename T, unsigned int N >
|
||
|
BOOST_FORCEINLINE StreamT& operator<< (T (&val)[N]) const
|
||
|
{
|
||
|
StreamT& strm = this->get();
|
||
|
strm << val;
|
||
|
return strm;
|
||
|
}
|
||
|
#endif
|
||
|
#else
|
||
|
template< typename T >
|
||
|
BOOST_FORCEINLINE StreamT& operator<< (T& val) const
|
||
|
{
|
||
|
StreamT& strm = this->get();
|
||
|
strm << val;
|
||
|
return strm;
|
||
|
}
|
||
|
|
||
|
template< typename T >
|
||
|
BOOST_FORCEINLINE StreamT& operator<< (T const& val) const
|
||
|
{
|
||
|
StreamT& strm = this->get();
|
||
|
strm << val;
|
||
|
return strm;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
BOOST_FORCEINLINE void attach(string_type& str) const { this->get().attach(str); }
|
||
|
BOOST_FORCEINLINE void detach() const { this->get().detach(); }
|
||
|
BOOST_FORCEINLINE string_type const& str() const { return this->get().str(); }
|
||
|
BOOST_FORCEINLINE ostream_type& stream() const { return this->get().stream(); }
|
||
|
BOOST_FORCEINLINE fmtflags flags() const { return this->get().flags(); }
|
||
|
BOOST_FORCEINLINE fmtflags flags(fmtflags f) const { return this->get().flags(f); }
|
||
|
BOOST_FORCEINLINE fmtflags setf(fmtflags f) const { return this->get().setf(f); }
|
||
|
BOOST_FORCEINLINE fmtflags setf(fmtflags f, fmtflags mask) const { return this->get().setf(f, mask); }
|
||
|
BOOST_FORCEINLINE void unsetf(fmtflags f) const { this->get().unsetf(f); }
|
||
|
|
||
|
BOOST_FORCEINLINE std::streamsize precision() const { return this->get().precision(); }
|
||
|
BOOST_FORCEINLINE std::streamsize precision(std::streamsize p) const { return this->get().precision(p); }
|
||
|
|
||
|
BOOST_FORCEINLINE std::streamsize width() const { return this->get().width(); }
|
||
|
BOOST_FORCEINLINE std::streamsize width(std::streamsize w) const { return this->get().width(w); }
|
||
|
|
||
|
BOOST_FORCEINLINE std::locale getloc() const { return this->get().getloc(); }
|
||
|
BOOST_FORCEINLINE std::locale imbue(std::locale const& loc) const { return this->get().imbue(loc); }
|
||
|
|
||
|
static BOOST_FORCEINLINE int xalloc() { return StreamT::xalloc(); }
|
||
|
BOOST_FORCEINLINE long& iword(int index) const { return this->get().iword(index); }
|
||
|
BOOST_FORCEINLINE void*& pword(int index) const { return this->get().pword(index); }
|
||
|
|
||
|
BOOST_FORCEINLINE void register_callback(event_callback fn, int index) const { this->get().register_callback(fn, index); }
|
||
|
|
||
|
static BOOST_FORCEINLINE bool sync_with_stdio(bool sync = true) { return StreamT::sync_with_stdio(sync); }
|
||
|
|
||
|
BOOST_EXPLICIT_OPERATOR_BOOL()
|
||
|
BOOST_FORCEINLINE bool operator! () const { return !this->get(); }
|
||
|
|
||
|
BOOST_FORCEINLINE iostate rdstate() const { return this->get().rdstate(); }
|
||
|
BOOST_FORCEINLINE void clear(iostate state = goodbit) const { this->get().clear(state); }
|
||
|
BOOST_FORCEINLINE void setstate(iostate state) const { this->get().setstate(state); }
|
||
|
BOOST_FORCEINLINE bool good() const { return this->get().good(); }
|
||
|
BOOST_FORCEINLINE bool eof() const { return this->get().eof(); }
|
||
|
BOOST_FORCEINLINE bool fail() const { return this->get().fail(); }
|
||
|
BOOST_FORCEINLINE bool bad() const { return this->get().bad(); }
|
||
|
|
||
|
BOOST_FORCEINLINE iostate exceptions() const { return this->get().exceptions(); }
|
||
|
BOOST_FORCEINLINE void exceptions(iostate s) const { this->get().exceptions(s); }
|
||
|
|
||
|
BOOST_FORCEINLINE ostream_type* tie() const { return this->get().tie(); }
|
||
|
BOOST_FORCEINLINE ostream_type* tie(ostream_type* strm) const { return this->get().tie(strm); }
|
||
|
|
||
|
BOOST_FORCEINLINE streambuf_type* rdbuf() const { return this->get().rdbuf(); }
|
||
|
|
||
|
BOOST_FORCEINLINE StreamT& copyfmt(std::basic_ios< char_type, traits_type >& rhs) const { return this->get().copyfmt(rhs); }
|
||
|
BOOST_FORCEINLINE StreamT& copyfmt(StreamT& rhs) const { return this->get().copyfmt(rhs); }
|
||
|
|
||
|
BOOST_FORCEINLINE char_type fill() const { return this->get().fill(); }
|
||
|
BOOST_FORCEINLINE char_type fill(char_type ch) const { return this->get().fill(ch); }
|
||
|
|
||
|
BOOST_FORCEINLINE char narrow(char_type ch, char def) const { return this->get().narrow(ch, def); }
|
||
|
BOOST_FORCEINLINE char_type widen(char ch) const { return this->get().widen(ch); }
|
||
|
|
||
|
BOOST_FORCEINLINE StreamT& flush() const { return this->get().flush(); }
|
||
|
|
||
|
BOOST_FORCEINLINE pos_type tellp() const { return this->get().tellp(); }
|
||
|
BOOST_FORCEINLINE StreamT& seekp(pos_type pos) const { return this->get().seekp(pos); }
|
||
|
BOOST_FORCEINLINE StreamT& seekp(off_type off, std::ios_base::seekdir dir) const { return this->get().seekp(off, dir); }
|
||
|
|
||
|
template< typename CharT >
|
||
|
BOOST_FORCEINLINE typename boost::log::aux::enable_if_streamable_char_type< CharT, StreamT& >::type
|
||
|
put(CharT c) const { return this->get().put(c); }
|
||
|
|
||
|
template< typename CharT >
|
||
|
BOOST_FORCEINLINE typename boost::log::aux::enable_if_streamable_char_type< CharT, StreamT& >::type
|
||
|
write(const CharT* p, std::streamsize size) const { return this->get().write(p, size); }
|
||
|
};
|
||
|
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::boolalpha;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::dec;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::fixed;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::hex;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::internal;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::left;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::oct;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::right;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::scientific;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::showbase;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::showpoint;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::skipws;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::unitbuf;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::uppercase;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::adjustfield;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::basefield;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::fmtflags stream_ref< StreamT >::floatfield;
|
||
|
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::iostate stream_ref< StreamT >::badbit;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::iostate stream_ref< StreamT >::eofbit;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::iostate stream_ref< StreamT >::failbit;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::iostate stream_ref< StreamT >::goodbit;
|
||
|
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::openmode stream_ref< StreamT >::app;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::openmode stream_ref< StreamT >::ate;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::openmode stream_ref< StreamT >::binary;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::openmode stream_ref< StreamT >::in;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::openmode stream_ref< StreamT >::out;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::openmode stream_ref< StreamT >::trunc;
|
||
|
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::seekdir stream_ref< StreamT >::beg;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::seekdir stream_ref< StreamT >::cur;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::seekdir stream_ref< StreamT >::end;
|
||
|
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::event stream_ref< StreamT >::erase_event;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::event stream_ref< StreamT >::imbue_event;
|
||
|
template< typename StreamT >
|
||
|
BOOST_CONSTEXPR_OR_CONST typename stream_ref< StreamT >::event stream_ref< StreamT >::copyfmt_event;
|
||
|
|
||
|
//! Default log record message formatter
|
||
|
struct message_formatter
|
||
|
{
|
||
|
typedef void result_type;
|
||
|
|
||
|
message_formatter() : m_MessageName(expressions::tag::message::get_name())
|
||
|
{
|
||
|
}
|
||
|
|
||
|
template< typename StreamT >
|
||
|
BOOST_FORCEINLINE result_type operator() (record_view const& rec, StreamT& strm) const
|
||
|
{
|
||
|
boost::log::visit< expressions::tag::message::value_type >(m_MessageName, rec, boost::log::bind_output(strm));
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
const attribute_name m_MessageName;
|
||
|
};
|
||
|
|
||
|
} // namespace aux
|
||
|
|
||
|
} // namespace expressions
|
||
|
|
||
|
/*!
|
||
|
* Log record formatter function wrapper.
|
||
|
*/
|
||
|
template< typename CharT >
|
||
|
class basic_formatter
|
||
|
{
|
||
|
typedef basic_formatter this_type;
|
||
|
BOOST_COPYABLE_AND_MOVABLE(this_type)
|
||
|
|
||
|
public:
|
||
|
//! Result type
|
||
|
typedef void result_type;
|
||
|
|
||
|
//! Character type
|
||
|
typedef CharT char_type;
|
||
|
//! Output stream type
|
||
|
typedef basic_formatting_ostream< char_type > stream_type;
|
||
|
|
||
|
private:
|
||
|
//! Filter function type
|
||
|
typedef boost::log::aux::light_function< void (record_view const&, expressions::aux::stream_ref< stream_type >) > formatter_type;
|
||
|
|
||
|
private:
|
||
|
//! Formatter function
|
||
|
formatter_type m_Formatter;
|
||
|
|
||
|
public:
|
||
|
/*!
|
||
|
* Default constructor. Creates a formatter that only outputs log message.
|
||
|
*/
|
||
|
basic_formatter() : m_Formatter(expressions::aux::message_formatter())
|
||
|
{
|
||
|
}
|
||
|
/*!
|
||
|
* Copy constructor
|
||
|
*/
|
||
|
basic_formatter(basic_formatter const& that) : m_Formatter(that.m_Formatter)
|
||
|
{
|
||
|
}
|
||
|
/*!
|
||
|
* Move constructor. The moved-from formatter is left in an unspecified state.
|
||
|
*/
|
||
|
basic_formatter(BOOST_RV_REF(this_type) that) BOOST_NOEXCEPT : m_Formatter(boost::move(that.m_Formatter))
|
||
|
{
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
* Initializing constructor. Creates a formatter which will invoke the specified function object.
|
||
|
*/
|
||
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||
|
template< typename FunT >
|
||
|
basic_formatter(FunT&& fun) : m_Formatter(boost::forward< FunT >(fun))
|
||
|
{
|
||
|
}
|
||
|
#elif !defined(BOOST_MSVC) || BOOST_MSVC >= 1600
|
||
|
template< typename FunT >
|
||
|
basic_formatter(FunT const& fun, typename boost::disable_if_c< move_detail::is_rv< FunT >::value, boost::log::aux::sfinae_dummy >::type = boost::log::aux::sfinae_dummy()) : m_Formatter(fun)
|
||
|
{
|
||
|
}
|
||
|
#else
|
||
|
// MSVC 9 and older blows up in unexpected ways if we use SFINAE to disable constructor instantiation
|
||
|
template< typename FunT >
|
||
|
basic_formatter(FunT const& fun) : m_Formatter(fun)
|
||
|
{
|
||
|
}
|
||
|
template< typename FunT >
|
||
|
basic_formatter(rv< FunT >& fun) : m_Formatter(fun)
|
||
|
{
|
||
|
}
|
||
|
template< typename FunT >
|
||
|
basic_formatter(rv< FunT > const& fun) : m_Formatter(static_cast< FunT const& >(fun))
|
||
|
{
|
||
|
}
|
||
|
basic_formatter(rv< this_type > const& that) : m_Formatter(that.m_Formatter)
|
||
|
{
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
/*!
|
||
|
* Move assignment. The moved-from formatter is left in an unspecified state.
|
||
|
*/
|
||
|
basic_formatter& operator= (BOOST_RV_REF(this_type) that) BOOST_NOEXCEPT
|
||
|
{
|
||
|
m_Formatter.swap(that.m_Formatter);
|
||
|
return *this;
|
||
|
}
|
||
|
/*!
|
||
|
* Copy assignment.
|
||
|
*/
|
||
|
basic_formatter& operator= (BOOST_COPY_ASSIGN_REF(this_type) that)
|
||
|
{
|
||
|
m_Formatter = that.m_Formatter;
|
||
|
return *this;
|
||
|
}
|
||
|
/*!
|
||
|
* Initializing assignment. Sets the specified function object to the formatter.
|
||
|
*/
|
||
|
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||
|
template< typename FunT >
|
||
|
basic_formatter& operator= (FunT&& fun)
|
||
|
{
|
||
|
this_type(boost::forward< FunT >(fun)).swap(*this);
|
||
|
return *this;
|
||
|
}
|
||
|
#else
|
||
|
template< typename FunT >
|
||
|
typename boost::disable_if_c< is_same< typename remove_cv< FunT >::type, this_type >::value, this_type& >::type
|
||
|
operator= (FunT const& fun)
|
||
|
{
|
||
|
this_type(fun).swap(*this);
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
/*!
|
||
|
* Formatting operator.
|
||
|
*
|
||
|
* \param rec A log record to format.
|
||
|
* \param strm A stream to put the formatted characters to.
|
||
|
*/
|
||
|
result_type operator() (record_view const& rec, stream_type& strm) const
|
||
|
{
|
||
|
m_Formatter(rec, expressions::aux::stream_ref< stream_type >(strm));
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
* Resets the formatter to the default. The default formatter only outputs message text.
|
||
|
*/
|
||
|
void reset()
|
||
|
{
|
||
|
m_Formatter = expressions::aux::message_formatter();
|
||
|
}
|
||
|
|
||
|
/*!
|
||
|
* Swaps two formatters
|
||
|
*/
|
||
|
void swap(basic_formatter& that) BOOST_NOEXCEPT
|
||
|
{
|
||
|
m_Formatter.swap(that.m_Formatter);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
template< typename CharT >
|
||
|
inline void swap(basic_formatter< CharT >& left, basic_formatter< CharT >& right) BOOST_NOEXCEPT
|
||
|
{
|
||
|
left.swap(right);
|
||
|
}
|
||
|
|
||
|
#ifdef BOOST_LOG_USE_CHAR
|
||
|
typedef basic_formatter< char > formatter;
|
||
|
#endif
|
||
|
#ifdef BOOST_LOG_USE_WCHAR_T
|
||
|
typedef basic_formatter< wchar_t > wformatter;
|
||
|
#endif
|
||
|
|
||
|
BOOST_LOG_CLOSE_NAMESPACE // namespace log
|
||
|
|
||
|
} // namespace boost
|
||
|
|
||
|
#include <boost/log/detail/footer.hpp>
|
||
|
|
||
|
#endif // BOOST_LOG_EXPRESSIONS_FORMATTER_HPP_INCLUDED_
|