/usr/include/Ice/LoggerUtil.h is in libzeroc-ice-dev 3.7.0-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 | // **********************************************************************
//
// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
#ifndef ICE_LOGGER_UTIL_H
#define ICE_LOGGER_UTIL_H
#include <Ice/Logger.h>
#include <Ice/CommunicatorF.h>
#include <Ice/Plugin.h>
#include <Ice/Exception.h>
namespace Ice
{
class ICE_API LoggerOutputBase : private IceUtil::noncopyable
{
public:
std::string str() const;
std::ostringstream& _stream(); // For internal use only. Don't use in your code.
private:
std::ostringstream _os;
};
ICE_API LoggerOutputBase& loggerInsert(LoggerOutputBase& out, const IceUtil::Exception& ex);
template<typename T>
struct IsException
{
static char testex(IceUtil::Exception*);
static long testex(...);
static const bool value = sizeof(testex(static_cast<T*>(0))) == sizeof(char);
};
template<typename T, bool = false>
struct LoggerOutputInserter
{
static inline LoggerOutputBase&
insert(LoggerOutputBase& out, const T& val)
{
out._stream() << val;
return out;
}
};
// Partial specialization
template<typename T>
struct LoggerOutputInserter<T, true>
{
static inline LoggerOutputBase&
insert(LoggerOutputBase& out, const T& ex)
{
return loggerInsert(out, ex);
}
};
template<typename T>
inline LoggerOutputBase&
operator<<(LoggerOutputBase& out, const T& val)
{
return LoggerOutputInserter<T, IsException<T>::value>::insert(out, val);
}
#ifdef ICE_CPP11_MAPPING
template<typename T, typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type* = nullptr>
inline LoggerOutputBase&
operator<<(LoggerOutputBase& os, const ::std::shared_ptr<T>& p)
#else
template<typename T>
inline LoggerOutputBase&
operator<<(LoggerOutputBase& os, const ::IceInternal::ProxyHandle<T>& p)
#endif
{
return os << (p ? p->ice_toString() : "");
}
inline LoggerOutputBase&
operator<<(LoggerOutputBase& out, const ::std::exception& ex)
{
out._stream() << ex.what();
return out;
}
ICE_API LoggerOutputBase& operator<<(LoggerOutputBase&, std::ios_base& (*)(std::ios_base&));
template<class L, class LPtr, void (L::*output)(const std::string&)>
class LoggerOutput : public LoggerOutputBase
{
public:
inline LoggerOutput(const LPtr& lptr) :
_logger(lptr)
{}
inline ~LoggerOutput()
{
flush();
}
inline void flush()
{
std::string s = _stream().str();
if(!s.empty())
{
L& ref = *_logger;
(ref.*output)(s);
}
_stream().str("");
}
private:
LPtr _logger;
};
typedef LoggerOutput<Logger, LoggerPtr, &Logger::print> Print;
typedef LoggerOutput<Logger, LoggerPtr, &Logger::warning> Warning;
typedef LoggerOutput<Logger, LoggerPtr, &Logger::error> Error;
class ICE_API Trace : public LoggerOutputBase
{
public:
Trace(const LoggerPtr&, const std::string&);
~Trace();
void flush();
private:
LoggerPtr _logger;
std::string _category;
};
//
// A special plug-in that installs a logger during a communicator's initialization.
// Both initialize and destroy are no-op. See Ice::InitializationData.
//
class ICE_API LoggerPlugin : public Ice::Plugin
{
public:
LoggerPlugin(const CommunicatorPtr& communicator, const LoggerPtr&);
virtual void initialize();
virtual void destroy();
};
}
#endif
|