cpp/src/Ice/LoggerUtil.cpp

   1
   2 // **********************************************************************
   3 //
   4 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   5 //
   6 // This copy of Ice is licensed to you under the terms described in the
   7 // ICE_LICENSE file included in this distribution.
   8 //
   9 // **********************************************************************
  10
  11 #include <Ice/LoggerUtil.h>
  12 #include <Ice/Logger.h>
  13 #include <Ice/Plugin.h>
  14 #include <Ice/LocalException.h>
  15 #include <Ice/Instance.h>
  16
  17 using namespace std;
  18
  19 namespace IceUtilInternal
  20 {
  21
  22 extern bool ICE_DECLSPEC_IMPORT printStackTraces;
  23
  24 }
  25
  26 ostringstream&
  27 Ice::LoggerOutputBase::__str()
  28 {
  29     return _str;
  30 }
  31
  32 Ice::LoggerOutputBase&
  33 Ice::operator<<(Ice::LoggerOutputBase& out, ios_base& (*val)(ios_base&))
  34 {
  35     out.__str() << val;
  36     return out;
  37 }
  38
  39 Ice::LoggerOutputBase&
  40 Ice::operator<<(Ice::LoggerOutputBase& out, const std::exception& ex)
  41 {
  42 #ifdef __GNUC__
  43     if(IceUtilInternal::printStackTraces)
  44     {
  45         const ::IceUtil::Exception* exception = dynamic_cast<const ::IceUtil::Exception*>(&ex);
  46         if(exception)
  47         {
  48             out.__str() << exception->what() << '\n' << exception->ice_stackTrace();
  49             return out;
  50         }
  51     }
  52 #endif
  53     out.__str() << ex.what();
  54     return out;
  55 }
  56
  57 Ice::Print::Print(const LoggerPtr& logger) :
  58     _logger(logger)
  59 {
  60 }
  61
  62 Ice::Print::~Print()
  63 {
  64     flush();
  65 }
  66
  67 void
  68 Ice::Print::flush()
  69 {
  70     string s = __str().str();
  71     if(!s.empty())
  72     {
  73         _logger->print(s);
  74     }
  75     __str().str("");
  76 }
  77
  78 Ice::Warning::Warning(const LoggerPtr& logger) :
  79     _logger(logger)
  80 {
  81 }
  82
  83 Ice::Warning::~Warning()
  84 {
  85     flush();
  86 }
  87
  88 void
  89 Ice::Warning::flush()
  90 {
  91     string s = __str().str();
  92     if(!s.empty())
  93     {
  94         _logger->warning(s);
  95     }
  96     __str().str("");
  97 }
  98
  99 Ice::Error::Error(const LoggerPtr& logger) :
 100     _logger(logger)
 101 {
 102 }
 103
 104 Ice::Error::~Error()
 105 {
 106     flush();
 107 }
 108
 109 void
 110 Ice::Error::flush()
 111 {
 112     string s = __str().str();
 113     if(!s.empty())
 114     {
 115         _logger->error(s);
 116     }
 117     __str().str("");
 118 }
 119
 120 Ice::Trace::Trace(const LoggerPtr& logger, const string& category) :
 121     _logger(logger),
 122     _category(category)
 123 {
 124 }
 125
 126 Ice::Trace::~Trace()
 127 {
 128     flush();
 129 }
 130
 131 void
 132 Ice::Trace::flush()
 133 {
 134     string s = __str().str();
 135     if(!s.empty())
 136     {
 137         _logger->trace(_category, s);
 138     }
 139     __str().str("");
 140 }
 141
 142 Ice::LoggerPlugin::LoggerPlugin(const CommunicatorPtr& communicator, const LoggerPtr& logger)
 143 {
 144     if(communicator == 0)
 145     {
 146         throw PluginInitializationException(__FILE__, __LINE__, "Communicator cannot be null");
 147     }
 148
 149     if(logger == 0)
 150     {
 151         throw PluginInitializationException(__FILE__, __LINE__, "Logger cannot be null");
 152     }
 153
 154     IceInternal::InstancePtr instance = IceInternal::getInstance(communicator);
 155     instance->setLogger(logger);
 156 }
 157
 158 void
 159 Ice::LoggerPlugin::initialize()
 160 {
 161 }
 162
 163 void
 164 Ice::LoggerPlugin::destroy()
 165 {
 166 }