350 lines
13 KiB
C++
350 lines
13 KiB
C++
/*******************************************************************************
|
|
Copyright (c) 2005-2009 David Williams and Matthew Williams
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any damages
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not
|
|
claim that you wrote the original software. If you use this software
|
|
in a product, an acknowledgment in the product documentation would be
|
|
appreciated but is not required.
|
|
|
|
2. Altered source versions must be plainly marked as such, and must not be
|
|
misrepresented as being the original software.
|
|
|
|
3. This notice may not be removed or altered from any source
|
|
distribution.
|
|
*******************************************************************************/
|
|
|
|
#ifndef __PolyVox_Logging_H__
|
|
#define __PolyVox_Logging_H__
|
|
|
|
#include "PolyVoxCore/Impl/Config.h"
|
|
|
|
#include <iostream>
|
|
#include <sstream>
|
|
|
|
/*
|
|
* Logging
|
|
* --------
|
|
* PolyVox provides basic logging facilities which can be redirected by your application.
|
|
*/
|
|
|
|
namespace PolyVox
|
|
{
|
|
class Logger
|
|
{
|
|
public:
|
|
// Passing zero to the null stream constructor guarentees it will discard all input. See
|
|
// here http://stackoverflow.com/a/8244052 and here http://stackoverflow.com/a/6240980
|
|
Logger() {};
|
|
virtual ~Logger() {};
|
|
|
|
virtual void logTraceMessage(const std::string& message) = 0;
|
|
virtual void logDebugMessage(const std::string& message) = 0;
|
|
virtual void logInfoMessage(const std::string& message) = 0;
|
|
virtual void logWarningMessage(const std::string& message) = 0;
|
|
virtual void logErrorMessage(const std::string& message) = 0;
|
|
virtual void logFatalMessage(const std::string& message) = 0;
|
|
};
|
|
|
|
class DefaultLogger : public Logger
|
|
{
|
|
public:
|
|
DefaultLogger() : Logger() {}
|
|
virtual ~DefaultLogger() {}
|
|
|
|
// Appending the 'std::endl' forces the stream to be flushed.
|
|
void logTraceMessage(const std::string& /*message*/) { }
|
|
void logDebugMessage(const std::string& /*message*/) { }
|
|
void logInfoMessage(const std::string& message) { std::cout << message << std::endl; }
|
|
void logWarningMessage(const std::string& message) { std::cerr << message << std::endl; }
|
|
void logErrorMessage(const std::string& message) { std::cerr << message << std::endl; }
|
|
void logFatalMessage(const std::string& message) { std::cerr << message << std::endl; }
|
|
};
|
|
|
|
namespace Impl
|
|
{
|
|
inline Logger*& getLoggerInstance()
|
|
{
|
|
static Logger* s_pLogger = new DefaultLogger;
|
|
return s_pLogger;
|
|
}
|
|
}
|
|
|
|
inline void setLogger(Logger* pLogger)
|
|
{
|
|
Impl::getLoggerInstance() = pLogger;
|
|
}
|
|
}
|
|
|
|
#ifdef POLYVOX_LOG_TRACE_ENABLED
|
|
|
|
#define POLYVOX_LOG_TRACE(message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logTraceMessage(ss.str()); \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#define POLYVOX_LOG_TRACE_IF(condition, message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
if ((condition)) \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logTraceMessage(ss.str()); \
|
|
} \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#else
|
|
|
|
// We don't bother with the do...while(0) construct here as we're not executing multiple statements
|
|
// We also don't bother with forcing variables to be 'used'. If this causes a problem then calling
|
|
// code can just force them to be used itself in addition to calling the logging macro. Basically
|
|
// we just want to reduce the chance of extra code being generated.
|
|
#define POLYVOX_LOG_TRACE(message)
|
|
#define POLYVOX_LOG_TRACE_IF(condition, message)
|
|
|
|
#endif
|
|
|
|
#ifdef POLYVOX_LOG_DEBUG_ENABLED
|
|
|
|
#define POLYVOX_LOG_DEBUG(message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logDebugMessage(ss.str()); \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#define POLYVOX_LOG_DEBUG_IF(condition, message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
if ((condition)) \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logDebugMessage(ss.str()); \
|
|
} \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#else
|
|
|
|
// We don't bother with the do...while(0) construct here as we're not executing multiple statements
|
|
// We also don't bother with forcing variables to be 'used'. If this causes a problem then calling
|
|
// code can just force them to be used itself in addition to calling the logging macro. Basically
|
|
// we just want to reduce the chance of extra code being generated.
|
|
#define POLYVOX_LOG_DEBUG(message)
|
|
#define POLYVOX_LOG_DEBUG_IF(condition, message)
|
|
|
|
#endif
|
|
|
|
#ifdef POLYVOX_LOG_INFO_ENABLED
|
|
|
|
#define POLYVOX_LOG_INFO(message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logInfoMessage(ss.str()); \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#define POLYVOX_LOG_INFO_IF(condition, message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
if ((condition)) \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logInfoMessage(ss.str()); \
|
|
} \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#else
|
|
|
|
// We don't bother with the do...while(0) construct here as we're not executing multiple statements
|
|
// We also don't bother with forcing variables to be 'used'. If this causes a problem then calling
|
|
// code can just force them to be used itself in addition to calling the logging macro. Basically
|
|
// we just want to reduce the chance of extra code being generated.
|
|
#define POLYVOX_LOG_INFO(message)
|
|
#define POLYVOX_LOG_INFO_IF(condition, message)
|
|
|
|
#endif
|
|
|
|
#ifdef POLYVOX_LOG_WARNING_ENABLED
|
|
|
|
#define POLYVOX_LOG_WARNING(message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logWarningMessage(ss.str()); \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#define POLYVOX_LOG_WARNING_IF(condition, message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
if ((condition)) \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logWarningMessage(ss.str()); \
|
|
} \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#else
|
|
|
|
// We don't bother with the do...while(0) construct here as we're not executing multiple statements
|
|
// We also don't bother with forcing variables to be 'used'. If this causes a problem then calling
|
|
// code can just force them to be used itself in addition to calling the logging macro. Basically
|
|
// we just want to reduce the chance of extra code being generated.
|
|
#define POLYVOX_LOG_WARNING(message)
|
|
#define POLYVOX_LOG_WARNING_IF(condition, message)
|
|
|
|
#endif
|
|
|
|
#ifdef POLYVOX_LOG_ERROR_ENABLED
|
|
|
|
#define POLYVOX_LOG_ERROR(message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logErrorMessage(ss.str()); \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#define POLYVOX_LOG_ERROR_IF(condition, message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
if ((condition)) \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logErrorMessage(ss.str()); \
|
|
} \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#else
|
|
|
|
// We don't bother with the do...while(0) construct here as we're not executing multiple statements
|
|
// We also don't bother with forcing variables to be 'used'. If this causes a problem then calling
|
|
// code can just force them to be used itself in addition to calling the logging macro. Basically
|
|
// we just want to reduce the chance of extra code being generated.
|
|
#define POLYVOX_LOG_ERROR(message)
|
|
#define POLYVOX_LOG_ERROR_IF(condition, message)
|
|
|
|
#endif
|
|
|
|
#ifdef POLYVOX_LOG_FATAL_ENABLED
|
|
|
|
#define POLYVOX_LOG_FATAL(message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logFatalMessage(ss.str()); \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#define POLYVOX_LOG_FATAL_IF(condition, message) \
|
|
/* We use the do...while(0) construct in our macros (for reasons see here: http://stackoverflow.com/a/154138) \
|
|
but Visual Studio gives unhelpful 'conditional expression is constant' warnings. The recommended solution \
|
|
(http://stackoverflow.com/a/1946485) is to disable these warnings. */ \
|
|
POLYVOX_MSC_WARNING_PUSH \
|
|
POLYVOX_DISABLE_MSC_WARNING(4127) \
|
|
do \
|
|
{ \
|
|
if ((condition)) \
|
|
{ \
|
|
std::stringstream ss; \
|
|
ss << message; \
|
|
PolyVox::Impl::getLoggerInstance()->logFatalMessage(ss.str()); \
|
|
} \
|
|
} while(0) \
|
|
POLYVOX_MSC_WARNING_POP
|
|
|
|
#else
|
|
|
|
// We don't bother with the do...while(0) construct here as we're not executing multiple statements
|
|
// We also don't bother with forcing variables to be 'used'. If this causes a problem then calling
|
|
// code can just force them to be used itself in addition to calling the logging macro. Basically
|
|
// we just want to reduce the chance of extra code being generated.
|
|
#define POLYVOX_LOG_FATAL(message)
|
|
#define POLYVOX_LOG_FATAL_IF(condition, message)
|
|
|
|
#endif
|
|
|
|
#endif //__PolyVox_Logging_H__
|