liborigin2 13/09/2010
Classes | Namespaces | Defines | Typedefs | Enumerations | Functions | Variables
/builddir/build/BUILD/liborigin2-20101029/logging.hpp File Reference
#include <list>
#include <stack>
#include <string>
#include <ostream>
#include <sstream>
#include <stdio.h>
#include <algorithm>
#include <exception>
#include <boost/shared_ptr.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/config.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/format.hpp>

Go to the source code of this file.

Classes

class  boost::logging::date_element
class  boost::logging::eol_element
class  boost::logging::error_qualifier
class  boost::logging::filename_element
class  boost::logging::format
class  boost::logging::level_element
class  boost::logging::line_element
class  boost::logging::literal_element
class  boost::logging::log_element
class  boost::logging::log_qualifier
class  boost::logging::logger
class  boost::logging::notice_qualifier
struct  boost::logging::null_deleter
class  boost::logging::qualifier
class  boost::logging::qualifier_element
class  boost::logging::sink
class  boost::logging::time_element
class  boost::logging::trace_element
class  boost::logging::warning_qualifier

Namespaces

namespace  boost
namespace  boost::logging

Defines

#define BOOST_LEVEL_UP_LIMIT   999
#define BOOST_LOG(level, qualifier, _trace)
#define BOOST_LOG_(level, _trace)   { BOOST_LOG(level, boost::logging::log, _trace) }
#define BOOST_LOG_ADD_OUTPUT_STREAM(sink)
#define BOOST_LOG_FINALIZE()
#define BOOST_LOG_INIT(format)
#define BOOST_LOG_UNFORMATTED(level, qualifier, _trace)
#define BOOST_MAX_LINE_STR_SIZE   20

Typedefs

typedef std::list
< boost::shared_ptr
< log_element > > 
boost::logging::element_list_t
typedef std::list< format > boost::logging::format_list_t
typedef unsigned short boost::logging::level_t
typedef tuple< level_t, const
qualifier *, std::string,
std::string, unsigned int > 
boost::logging::log_param_t
typedef std::list< qualifier * > boost::logging::qualifier_list_t
typedef std::list
< sink_format_assoc_t > 
boost::logging::sink_format_assoc_list_t
typedef tuple< sink, format & > boost::logging::sink_format_assoc_t
typedef std::list
< boost::shared_ptr
< std::ostream > > 
boost::logging::stream_list_t

Enumerations

enum  boost::logging::param_e {
  boost::logging::LEVEL = 0, boost::logging::QUALIFIER, boost::logging::TRACE, boost::logging::FILENAME,
  boost::logging::LINE
}
enum  boost::logging::sink_format_assoc_e { boost::logging::SINK = 0, boost::logging::FORMAT }

Functions

boost::logging::element_list_t operator>> (boost::logging::log_element &lhs, boost::logging::log_element &rhs)
boost::logging::element_list_t operator>> (boost::logging::element_list_t lhs, const std::string &s)
boost::logging::element_list_t operator>> (const std::string &s, boost::logging::log_element &rhs)
boost::logging::element_list_t operator>> (boost::logging::element_list_t lhs, boost::logging::log_element &rhs)

Variables

static date_element boost::logging::date = date_element()
static eol_element boost::logging::eol = eol_element()
static error_qualifier boost::logging::error = error_qualifier()
static filename_element boost::logging::filename = filename_element()
static level_element boost::logging::level = level_element()
static line_element boost::logging::line = line_element()
static log_qualifier boost::logging::log = log_qualifier()
static notice_qualifier boost::logging::notice = notice_qualifier()
static time_element boost::logging::time = time_element()
static trace_element boost::logging::trace = trace_element()
static warning_qualifier boost::logging::warning = warning_qualifier()

Define Documentation

#define BOOST_LEVEL_UP_LIMIT   999
#define BOOST_LOG (   level,
  qualifier,
  _trace 
)
Value:
{                                                                              \
  boost::logging::logger *l = boost::logging::logger::get_instance();          \
  assert(l);                                                                   \
  if (l->get_global_max_log_level() >= level)                                  \
  {                                                                            \
    if (l->m_string_stream.str() != "")                                        \
      l->m_string_stack.push(l->m_string_stream.str());                        \
                                                                               \
    l->m_string_stream.str("");                                                \
    l->m_string_stream << _trace;                                              \
    l->trace(level, qualifier, l->m_string_stream.str(), __FILE__, __LINE__);  \
    if (!l->m_string_stack.empty())                                            \
    {                                                                          \
      l->m_string_stream.str(l->m_string_stack.top());                         \
      l->m_string_stack.pop();                                                 \
    }                                                                          \
  }                                                                            \
}
#define BOOST_LOG_ (   level,
  _trace 
)    { BOOST_LOG(level, boost::logging::log, _trace) }
#define BOOST_LOG_ADD_OUTPUT_STREAM (   sink)
Value:
{                                                                              \
  boost::logging::logger *l = boost::logging::logger::get_instance();          \
  assert(l);                                                                   \
  l->add_sink(sink);                                                           \
}
#define BOOST_LOG_FINALIZE ( )
Value:
#define BOOST_LOG_INIT (   format)
Value:
{                                                                              \
  boost::logging::logger *l = boost::logging::logger::get_instance();          \
  assert(l);                                                                   \
  l->add_format(format);                                                       \
}
#define BOOST_LOG_UNFORMATTED (   level,
  qualifier,
  _trace 
)
Value:
{                                                                              \
  boost::logging::logger *l = boost::logging::logger::get_instance();          \
  assert(l);                                                                   \
  if (l->get_global_max_log_level() >= level)                                  \
  {                                                                            \
    if (l->m_string_stream.str() != "")                                        \
      l->m_string_stack.push(l->m_string_stream.str());                        \
                                                                               \
    l->m_string_stream.str("");                                                \
    l->m_string_stream << _trace;                                              \
    l->unformatted_trace(level, qualifier,                                     \
                         l->m_string_stream.str(), __FILE__, __LINE__);        \
    if (!l->m_string_stack.empty())                                            \
    {                                                                          \
      l->m_string_stream.str(l->m_string_stack.top());                         \
      l->m_string_stack.pop();                                                 \
    }                                                                          \
  }                                                                            \
}
#define BOOST_MAX_LINE_STR_SIZE   20

Function Documentation

boost::logging::element_list_t operator>> ( boost::logging::element_list_t  lhs,
const std::string &  s 
) [inline]
boost::logging::element_list_t operator>> ( const std::string &  s,
boost::logging::log_element rhs 
) [inline]