diff --git a/Code/Mantid/API/inc/MantidAPI/IInstrument.h b/Code/Mantid/API/inc/MantidAPI/IInstrument.h
index 38bf899e30575fe30c663ae741412edef625152d..f423e279211e2aa1f372564e7080ad702fa49060 100644
--- a/Code/Mantid/API/inc/MantidAPI/IInstrument.h
+++ b/Code/Mantid/API/inc/MantidAPI/IInstrument.h
@@ -8,6 +8,7 @@
#include "MantidGeometry/ICompAssembly.h"
#include "MantidGeometry/Detector.h"
#include <boost/shared_ptr.hpp>
+#include <map>
#include <string>
#include <ostream>
diff --git a/Code/Mantid/API/inc/MantidAPI/Instrument.h b/Code/Mantid/API/inc/MantidAPI/Instrument.h
index 7e7f19b539cd3532295309bf496e7890f9b36214..18b3b6fd1e8bf922fe5234e21c8205b557151c75 100644
--- a/Code/Mantid/API/inc/MantidAPI/Instrument.h
+++ b/Code/Mantid/API/inc/MantidAPI/Instrument.h
@@ -9,7 +9,8 @@
#include "MantidGeometry/CompAssembly.h"
#include "MantidGeometry/ObjComponent.h"
#include "MantidGeometry/Detector.h"
-#include <string>
+#include <string>
+#include <map>
#include <ostream>
namespace Mantid
diff --git a/Code/Mantid/Geometry/inc/MantidGeometry/DetectorGroup.h b/Code/Mantid/Geometry/inc/MantidGeometry/DetectorGroup.h
index 44115c683b2060489c68136d61e99c0116eb95c6..74e32e5d4fdb6b0ec9bba753e57bee9930db4324 100644
--- a/Code/Mantid/Geometry/inc/MantidGeometry/DetectorGroup.h
+++ b/Code/Mantid/Geometry/inc/MantidGeometry/DetectorGroup.h
@@ -8,6 +8,7 @@
#include "MantidGeometry/Component.h"
#include <boost/shared_ptr.hpp>
#include <vector>
+#include <map>
namespace Mantid
{
diff --git a/Code/Mantid/Geometry/inc/MantidGeometry/ParameterFactory.h b/Code/Mantid/Geometry/inc/MantidGeometry/ParameterFactory.h
index 61bbfa3a30ff02e0a0c5f45ba03969fdf4b1a6dd..c914a35ed0c3a30d69c0574a42a617962f6f2cee 100644
--- a/Code/Mantid/Geometry/inc/MantidGeometry/ParameterFactory.h
+++ b/Code/Mantid/Geometry/inc/MantidGeometry/ParameterFactory.h
@@ -5,8 +5,8 @@
// Includes
//----------------------------------------------------------------------
#include <vector>
-#include "MantidKernel/System.h"
-//#include "MantidKernel/DynamicFactory.h"
+#include <map>
+#include "MantidKernel/System.h"
#include "MantidKernel/Instantiator.h"
#include "MantidKernel/SingletonHolder.h"
#include "MantidKernel/Logger.h"
diff --git a/Code/Mantid/Geometry/inc/MantidGeometry/Rules.h b/Code/Mantid/Geometry/inc/MantidGeometry/Rules.h
index aabf2e44f758f6fd9857f421e737993b52c40460..ea15e4412a5fe4d0cea66006518dd53cb65f1338 100644
--- a/Code/Mantid/Geometry/inc/MantidGeometry/Rules.h
+++ b/Code/Mantid/Geometry/inc/MantidGeometry/Rules.h
@@ -1,6 +1,8 @@
#ifndef Rules_h
#define Rules_h
+#include <map>
+
namespace Mantid
{
diff --git a/Code/Mantid/Kernel/inc/MantidKernel/Logger.h b/Code/Mantid/Kernel/inc/MantidKernel/Logger.h
index bce92acce501911bd70e24c8502d06936cd2c472..9acd2bbcefdfddf938817214c67fb2f8bd15f800 100755
--- a/Code/Mantid/Kernel/inc/MantidKernel/Logger.h
+++ b/Code/Mantid/Kernel/inc/MantidKernel/Logger.h
@@ -6,8 +6,8 @@
//----------------------------------------------------------------------
#include "System.h"
#include <string>
+#include <set>
#include <exception>
-#include <map>
#include <ostream>
#include <streambuf>
@@ -19,6 +19,8 @@ namespace Poco
{
class Logger;
class LogStream;
+ class NullChannel;
+ class Mutex;
}
/// @endcond
@@ -70,6 +72,7 @@ namespace Kernel
PRIO_FATAL = 1, ///< A fatal error. The application will most likely terminate. This is the highest priority.
PRIO_ERROR = 3, ///< An error. An operation did not complete successfully, but the application as a whole is not affected.
PRIO_WARNING = 4, ///< A warning. An operation completed with an unexpected result.
+ PRIO_NOTICE = 5, ///< An informational message, usually denoting the successful completion of an Algorithm, These are the headlines of what we should be reporting to the user.
PRIO_INFORMATION = 6, ///< An informational message, usually denoting the successful completion of an operation.
PRIO_DEBUG = 7 ///< A debugging message.This is the lowest priority.
};
@@ -77,36 +80,67 @@ namespace Kernel
void fatal(const std::string& msg);
void error(const std::string& msg);
void warning(const std::string& msg);
+ void notice(const std::string& msg);
void information(const std::string& msg);
void debug(const std::string& msg);
std::ostream& fatal();
std::ostream& error();
std::ostream& warning();
+ std::ostream& notice();
std::ostream& information();
std::ostream& debug();
/// Logs the given message at debug level, followed by the data in buffer.
void dump(const std::string& msg, const void* buffer, std::size_t length);
+ /// Sets the Logger's log level.
+ void setLevel(int level);
+
+ /// Returns the Logger's log level.
+ int getLevel() const;
+
+ /// Sets the Logger's log level using a symbolic value.
+ ///
+ /// Valid values are:
+ /// - fatal
+ /// - critical
+ /// - error
+ /// - warning
+ /// - notice
+ /// - information
+ /// - debug
+ void setLevel(const std::string& level);
+
+ ///returns true if the log is enabled
+ bool getEnabled() const;
+
+ ///set if the logging is enabled
+ void setEnabled(const bool enabled);
+
/// Returns true if at least the given log level is set.
bool is(int level) const;
+ /// releases resources and deletes this object
+ void release();
+
/// Returns a reference to the Logger with the given name.
static Logger& get(const std::string& name);
+ //destroy the given logger and releases resources
+ static void Logger::destroy(Logger& logger);
+
/// Shuts down the logging framework and releases all Loggers.
static void shutdown();
- ~Logger();
protected:
/// Protected constructor called by static get method
Logger(const std::string& name);
-
+ /// Protected destructor - call release instead
+ ~Logger();
private:
-
Logger();
/// Overload of = operator
@@ -114,11 +148,24 @@ namespace Kernel
/// Internal handle to third party logging objects
Poco::Logger& _log;
- ///This pointer is owned by this class, initialized in the constructor and deleted in the destructor
+ ///A Log stream to allow streaming operations. This pointer is owned by this class, initialized in the constructor and deleted in the destructor
Poco::LogStream* _logStream;
+ ///A Null stream, used when the logger is disabled. This pointer is owned by this class, initialized in the constructor and deleted in the destructor
+ Poco::LogStream* _nullStream;
+ /// a null channell used to create the null stream
+ Poco::NullChannel* _nullChannel;
+
+ ///returns the correct stream depending on the enabled status
+ Poco::LogStream* getStream();
/// Name of this logging object
std::string _name;
+ /// The state of this logger, disabled loggers send no messages
+ bool _enabled;
+
+ typedef std::set<Logger*> LoggerList;
+ static LoggerList* m_LoggerList;
+ static Poco::Mutex m_ListMtx;
};
} // namespace Kernel
diff --git a/Code/Mantid/Kernel/src/ConfigService.cpp b/Code/Mantid/Kernel/src/ConfigService.cpp
index 352fc2da7d8c7ab9d9b0b434ae8b1a3f4a8cbe56..832003ada9315d3b8c96e92b12488a25c8d61d36 100644
--- a/Code/Mantid/Kernel/src/ConfigService.cpp
+++ b/Code/Mantid/Kernel/src/ConfigService.cpp
@@ -81,9 +81,9 @@ namespace Mantid
*/
ConfigServiceImpl::~ConfigServiceImpl()
{
+ Kernel::Logger::shutdown();
delete m_pSysConfig;
delete m_pConf; // potential double delete???
- // g_log.debug() << "ConfigService destroyed." << std::endl;
}
/**
diff --git a/Code/Mantid/Kernel/src/Logger.cpp b/Code/Mantid/Kernel/src/Logger.cpp
index 6a40795720fa440991619b335057aab2978183cf..32ed74108c76259d60a9a24eeffa9e8e58d63a8e 100755
--- a/Code/Mantid/Kernel/src/Logger.cpp
+++ b/Code/Mantid/Kernel/src/Logger.cpp
@@ -1,253 +1,410 @@
#include "MantidKernel/Logger.h"
#include <Poco/Logger.h>
#include <Poco/LogStream.h>
-#include <Poco/Message.h>
+#include <Poco/Message.h>
+#include <Poco/Mutex.h>
+#include <Poco/NullChannel.h>
#include <iostream>
#include <sstream>
namespace Mantid
{
-namespace Kernel
-{
-
- /** Constructor
- * @param name The class name invoking this logger
- */
- Logger::Logger(const std::string& name): _log(Poco::Logger::get(name))
- {
- _name = name;
- _logStream = new Poco::LogStream(_log);
- }
-
- ///destructor
- Logger::~Logger()
- {
- delete (_logStream);
- }
-
- /** If the Logger's log level is at least PRIO_FATAL, creates a Message with
- * priority PRIO_FATAL and the given message text and sends it to the attached channel.
- *
- * @param msg The message to log.
- */
- void Logger::fatal(const std::string& msg)
- {
- try
- {
- _log.fatal(msg);
- }
- catch (std::exception& e)
- {
- //failures in logging are not allowed to throw exceptions out of the logging class
- std::cerr << e.what();
- }
- }
-
- /** If the Logger's log level is at least PRIO_ERROR, creates a Message with priority
- * PRIO_ERROR and the given message text and sends it to the attached channel.
- *
- * @param msg The message to log.
- */
- void Logger::error(const std::string& msg)
+ namespace Kernel
{
- try
+ Logger::LoggerList* Logger::m_LoggerList = 0;
+ Poco::Mutex Logger::m_ListMtx;
+
+ /** Constructor
+ * @param name The class name invoking this logger
+ */
+ Logger::Logger(const std::string& name): _log(Poco::Logger::get(name)),_enabled(true)
+ {
+ _name = name;
+ _logStream = new Poco::LogStream(_log);
+ _nullChannel = new Poco::NullChannel;
+ Poco::Logger& nullLogger = Poco::Logger::get("NULL");
+ nullLogger.setChannel(_nullChannel);
+ _nullStream = new Poco::LogStream(nullLogger,Poco::Message::PRIO_FATAL);
+
+ }
+
+ ///destructor
+ Logger::~Logger()
{
- _log.error(msg);
- }
- catch (std::exception& e)
+ delete (_logStream);
+ delete (_nullStream);
+ delete (_nullChannel);
+ }
+
+ /** Returns true if the log is enabled
+ *
+ * @retval true - logging is enabled
+ * @retval false - all messages are ignored.
+ */
+ bool Logger::getEnabled() const
{
- //failures in logging are not allowed to throw exceptions out of the logging class
- std::cerr << e.what();
+ return _enabled;
}
-
- }
- /** If the Logger's log level is at least PRIO_WARNING, creates a Message with
- * priority PRIO_WARNING and the given message text and sends it to the attached channel.
- *
- * @param msg The message to log.
- */
- void Logger::warning(const std::string& msg)
- {
- try
+ /** set if the logging is enabled
+ *
+ * @param enabled true - logging is enabled, false - all messages are ignored.
+ */
+ void Logger::setEnabled(const bool enabled)
{
- _log.warning(msg);
- }
- catch (std::exception& e)
+ _enabled = enabled;
+ }
+
+ /** If the Logger's log level is at least PRIO_FATAL, creates a Message with
+ * priority PRIO_FATAL and the given message text and sends it to the attached channel.
+ *
+ * @param msg The message to log.
+ */
+ void Logger::fatal(const std::string& msg)
{
- //failures in logging are not allowed to throw exceptions out of the logging class
- std::cerr << e.what();
+ if(_enabled)
+ {
+ try
+ {
+ _log.fatal(msg);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
}
- }
- /** If the Logger's log level is at least PRIO_INFORMATION, creates a Message with
- * priority PRIO_INFORMATION and the given message text and sends it to the
- * attached channel.
- *
- * @param msg The message to log.
- */
- void Logger::information(const std::string& msg)
- {
- try
+ /** If the Logger's log level is at least PRIO_ERROR, creates a Message with priority
+ * PRIO_ERROR and the given message text and sends it to the attached channel.
+ *
+ * @param msg The message to log.
+ */
+ void Logger::error(const std::string& msg)
{
- _log.information(msg);
- }
- catch (std::exception& e)
+ if(_enabled)
+ {
+ try
+ {
+ _log.error(msg);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
+ }
+
+ /** If the Logger's log level is at least PRIO_WARNING, creates a Message with
+ * priority PRIO_WARNING and the given message text and sends it to the attached channel.
+ *
+ * @param msg The message to log.
+ */
+ void Logger::warning(const std::string& msg)
{
- //failures in logging are not allowed to throw exceptions out of the logging class
- std::cerr << e.what();
+ if(_enabled)
+ {
+ try
+ {
+ _log.warning(msg);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
}
- }
- /** If the Logger's log level is at least PRIO_DEBUG, creates a Message with priority
- * PRIO_DEBUG and the given message text and sends it to the attached channel.
- *
- * @param msg The message to log.
- */
- void Logger::debug(const std::string& msg)
- {
- try
- {
- _log.debug(msg);
- }
- catch (std::exception& e)
- {
- //failures in logging are not allowed to throw exceptions out of the logging class
- std::cerr << e.what();
- }
- }
-
- /** Logs the given message at debug level, followed by the data in buffer.
- *
- * The data in buffer is written in canonical hex+ASCII form:
- * Offset (4 bytes) in hexadecimal, followed by sixteen space-separated,
- * two column, hexadecimal bytes, followed by the same sixteen bytes as
- * ASCII characters.
- * For bytes outside the range 32 .. 127, a dot is printed.
- * Note all Dump messages go out at Debug message level
- *
- * @param msg The message to log
- * @param buffer the binary data to log
- * @param length The length of the binaary data to log
- */
- void Logger::dump(const std::string& msg, const void* buffer, std::size_t length)
- {
- try
+ /** If the Logger's log level is at least PRIO_NOTICE, creates a Message with
+ * priority PRIO_NOTICE and the given message text and sends it to the attached channel.
+ *
+ * @param msg The message to log.
+ */
+ void Logger::notice(const std::string& msg)
{
- _log.dump(msg,buffer,length);
- }
- catch (std::exception& e)
+ if(_enabled)
+ {
+ try
+ {
+ _log.notice(msg);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
+ }
+ /** If the Logger's log level is at least PRIO_INFORMATION, creates a Message with
+ * priority PRIO_INFORMATION and the given message text and sends it to the
+ * attached channel.
+ *
+ * @param msg The message to log.
+ */
+ void Logger::information(const std::string& msg)
{
- //failures in logging are not allowed to throw exceptions out of the logging class
- std::cerr << e.what();
+ if(_enabled)
+ {
+ try
+ {
+ _log.information(msg);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
}
- }
-
- /** Returns true if at least the given log level is set.
- * @param level The logging level it is best to use the Logger::Priority enum (7=debug, 6=information, 4=warning, 3=error, 2=critical, 1=fatal)
- */
- bool Logger::is(int level) const
- {
- bool retVal = false;
- try
- {
- retVal = _log.is(level);
- }
- catch (std::exception& e)
- {
- //failures in logging are not allowed to throw exceptions out of the logging class
- std::cerr << e.what();
- }
- return retVal;
- }
-
- /** This class implements an ostream interface to the Logger for fatal messages.
- *
- * The stream's buffer appends all characters written to it
- * to a string. As soon as a CR or LF (std::endl) is written,
- * the string is sent to the Logger.
- * @returns an std::ostream reference.
- */
- std::ostream& Logger::fatal()
- {
- return _logStream->fatal();
- }
-
- /** This class implements an ostream interface to the Logger for error messages.
- *
- * The stream's buffer appends all characters written to it
- * to a string. As soon as a CR or LF (std::endl) is written,
- * the string is sent to the Logger.
- * @returns an std::ostream reference.
- */
- std::ostream& Logger::error()
- {
- return _logStream->error();
- }
-
- /** This class implements an ostream interface to the Logger for warning messages.
- *
- * The stream's buffer appends all characters written to it
- * to a string. As soon as a CR or LF (std::endl) is written,
- * the string is sent to the Logger.
- * @returns an std::ostream reference.
- */
- std::ostream& Logger::warning()
- {
- return _logStream->warning();
- }
-
- /** This class implements an ostream interface to the Logger for information messages.
- *
- * The stream's buffer appends all characters written to it
- * to a string. As soon as a CR or LF (std::endl) is written,
- * the string is sent to the Logger.
- * @returns an std::ostream reference.
- */
- std::ostream& Logger::information()
- {
- return _logStream->information();
- }
-
- /** This class implements an ostream interface to the Logger for debug messages.
- *
- * The stream's buffer appends all characters written to it
- * to a string. As soon as a CR or LF (std::endl) is written,
- * the string is sent to the Logger.
- * @returns an std::ostream reference.
- */
- std::ostream& Logger::debug()
- {
- return _logStream->debug();
- }
+ /** If the Logger's log level is at least PRIO_DEBUG, creates a Message with priority
+ * PRIO_DEBUG and the given message text and sends it to the attached channel.
+ *
+ * @param msg The message to log.
+ */
+ void Logger::debug(const std::string& msg)
+ {
+ if(_enabled)
+ {
+ try
+ {
+ _log.debug(msg);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
+ }
- /// Shuts down the logging framework and releases all Loggers.
- void Logger::shutdown()
- {
- try
+ /** Logs the given message at debug level, followed by the data in buffer.
+ *
+ * The data in buffer is written in canonical hex+ASCII form:
+ * Offset (4 bytes) in hexadecimal, followed by sixteen space-separated,
+ * two column, hexadecimal bytes, followed by the same sixteen bytes as
+ * ASCII characters.
+ * For bytes outside the range 32 .. 127, a dot is printed.
+ * Note all Dump messages go out at Debug message level
+ *
+ * @param msg The message to log
+ * @param buffer the binary data to log
+ * @param length The length of the binaary data to log
+ */
+ void Logger::dump(const std::string& msg, const void* buffer, std::size_t length)
+ {
+ if(_enabled)
+ {
+ try
+ {
+ _log.dump(msg,buffer,length);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
+ }
+
+ /** Returns true if at least the given log level is set.
+ * @param level The logging level it is best to use the Logger::Priority enum (7=debug, 6=information, 4=warning, 3=error, 2=critical, 1=fatal)
+ */
+ bool Logger::is(int level) const
{
- Poco::Logger::shutdown();
- }
- catch (std::exception& e)
+ bool retVal = false;
+ try
+ {
+ retVal = _log.is(level);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ return retVal;
+ }
+
+ void Logger::setLevel(int level)
{
- //failures in logging are not allowed to throw exceptions out of the logging class
- std::cerr << e.what();
+ try
+ {
+ _log.setLevel(level);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
}
- }
- /** Returns a reference to the Logger with the given name.
- * If the Logger does not yet exist, it is created, based on its parent logger.
- *
- * @param name The name of the logger to use - this is usually the class name.
- */
- Logger& Logger::get(const std::string& name)
- {
- Logger* pLogger = new Logger(name);
- return *pLogger;
- }
+ void Logger::setLevel(const std::string& level)
+ {
+ try
+ {
+ _log.setLevel(level);
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
+
+ int Logger::getLevel() const
+ {
+ return _log.getLevel();
+ }
+
+ Poco::LogStream* Logger::getStream()
+ {
+ return _enabled?_logStream:_nullStream;
+ }
+
+ /** This class implements an ostream interface to the Logger for fatal messages.
+ *
+ * The stream's buffer appends all characters written to it
+ * to a string. As soon as a CR or LF (std::endl) is written,
+ * the string is sent to the Logger.
+ * @returns an std::ostream reference.
+ */
+ std::ostream& Logger::fatal()
+ {
+ return getStream()->fatal();
+ }
+
+ /** This class implements an ostream interface to the Logger for error messages.
+ *
+ * The stream's buffer appends all characters written to it
+ * to a string. As soon as a CR or LF (std::endl) is written,
+ * the string is sent to the Logger.
+ * @returns an std::ostream reference.
+ */
+ std::ostream& Logger::error()
+ {
+ return getStream()->error();
+ }
+
+ /** This class implements an ostream interface to the Logger for warning messages.
+ *
+ * The stream's buffer appends all characters written to it
+ * to a string. As soon as a CR or LF (std::endl) is written,
+ * the string is sent to the Logger.
+ * @returns an std::ostream reference.
+ */
+ std::ostream& Logger::warning()
+ {
+ return getStream()->warning();
+ }
+
+ /** This class implements an ostream interface to the Logger for notice messages.
+ *
+ * The stream's buffer appends all characters written to it
+ * to a string. As soon as a CR or LF (std::endl) is written,
+ * the string is sent to the Logger.
+ * @returns an std::ostream reference.
+ */
+ std::ostream& Logger::notice()
+ {
+ return getStream()->notice();
+ }
+
+ /** This class implements an ostream interface to the Logger for information messages.
+ *
+ * The stream's buffer appends all characters written to it
+ * to a string. As soon as a CR or LF (std::endl) is written,
+ * the string is sent to the Logger.
+ * @returns an std::ostream reference.
+ */
+ std::ostream& Logger::information()
+ {
+ return getStream()->information();
+ }
+
+ /** This class implements an ostream interface to the Logger for debug messages.
+ *
+ * The stream's buffer appends all characters written to it
+ * to a string. As soon as a CR or LF (std::endl) is written,
+ * the string is sent to the Logger.
+ * @returns an std::ostream reference.
+ */
+ std::ostream& Logger::debug()
+ {
+ return getStream()->debug();
+ }
+
+ /** releases resources and deletes this object.
+ */
+ void Logger::release()
+ {
+ delete(this);
+ }
+
+ /** Deletes the logger and clears it from the cache.
+ *
+ * @param name The logger to destroy.
+ */
+ void Logger::destroy(Logger& logger)
+ {
+ Poco::Mutex::ScopedLock lock(m_ListMtx);
+
+ if (m_LoggerList)
+ {
+ LoggerList::iterator it = m_LoggerList->find(&logger);
+ if (it != m_LoggerList->end())
+ {
+ delete(*it);
+ m_LoggerList->erase(it);
+ }
+ }
+ }
+
+ /// Shuts down the logging framework and releases all Loggers.
+ void Logger::shutdown()
+ {
+ Poco::Mutex::ScopedLock lock(m_ListMtx);
+ try
+ {
+ //first release the POCO loggers
+ Poco::Logger::shutdown();
+
+ //now delete our static cache of loggers
+ if (m_LoggerList)
+ {
+ for (LoggerList::iterator it = m_LoggerList->begin(); it != m_LoggerList->end(); ++it)
+ {
+ delete(*it);
+ }
+ delete m_LoggerList;
+ m_LoggerList = 0;
+ }
+ }
+ catch (std::exception& e)
+ {
+ //failures in logging are not allowed to throw exceptions out of the logging class
+ std::cerr << e.what();
+ }
+ }
+
+ /** Returns a reference to the Logger with the given name.
+ * This logger is stored until in a static list until it is destroyed, released or Logger::shutdown is called.
+ *
+ * @param name The name of the logger to use - this is usually the class name.
+ */
+ Logger& Logger::get(const std::string& name)
+ {
+ Logger* pLogger = new Logger(name);
+ if (!m_LoggerList)
+ m_LoggerList = new LoggerList;
+ m_LoggerList->insert(pLogger);
+
+ return *pLogger;
+ }
-} // namespace Kernel
+ } // namespace Kernel
} // Namespace Mantid
diff --git a/Code/Mantid/Kernel/test/ConfigServiceTest.h b/Code/Mantid/Kernel/test/ConfigServiceTest.h
index 6d7279a666129b2cb823671db2d7369a2a3fd009..61c800066a9362f787e3ec9cc25be3ebd33c22c3 100644
--- a/Code/Mantid/Kernel/test/ConfigServiceTest.h
+++ b/Code/Mantid/Kernel/test/ConfigServiceTest.h
@@ -6,6 +6,8 @@
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Logger.h"
#include "Poco/Path.h"
+#include "boost/shared_ptr.hpp"
+#include "TestChannel.hh"
#include <string>
using namespace Mantid::Kernel;
@@ -26,6 +28,7 @@ public:
TS_ASSERT_THROWS_NOTHING(log1.debug("a debug string"));
TS_ASSERT_THROWS_NOTHING(log1.information("an information string"));
+ TS_ASSERT_THROWS_NOTHING(log1.information("a notice string"));
TS_ASSERT_THROWS_NOTHING(log1.warning("a warning string"));
TS_ASSERT_THROWS_NOTHING(log1.error("an error string"));
TS_ASSERT_THROWS_NOTHING(log1.fatal("a fatal string"));
@@ -34,17 +37,40 @@ public:
log1.fatal()<<"A fatal message from the stream operators " << 4.5 << std::endl;
log1.error()<<"A error message from the stream operators " << -0.2 << std::endl;
log1.warning()<<"A warning message from the stream operators " << 999.99 << std::endl;
+ log1.notice()<<"A notice message from the stream operators " << 0.0 << std::endl;
log1.information()<<"A information message from the stream operators " << -999.99 << std::endl;
log1.debug()<<"A debug message from the stream operators " << 5684568 << std::endl;
+
+
);
//checking the level - this should be set to debug in the config file
//therefore this should only return false for debug
TS_ASSERT(log1.is(Logger::PRIO_DEBUG) == false); //debug
TS_ASSERT(log1.is(Logger::PRIO_INFORMATION)); //information
+ TS_ASSERT(log1.is(Logger::PRIO_NOTICE)); //information
TS_ASSERT(log1.is(Logger::PRIO_WARNING)); //warning
TS_ASSERT(log1.is(Logger::PRIO_ERROR)); //error
TS_ASSERT(log1.is(Logger::PRIO_FATAL)); //fatal
+ }
+
+ void testEnabled()
+ {
+ //attempt some logging
+ Logger& log1 = Logger::get("logTestEnabled");
+ TS_ASSERT(log1.getEnabled());
+ TS_ASSERT_THROWS_NOTHING(log1.fatal("a fatal string with enabled=true"));
+ TS_ASSERT_THROWS_NOTHING(log1.fatal()<<"A fatal message from the stream operators with enabled=true " << 4.5 << std::endl;);
+
+ TS_ASSERT_THROWS_NOTHING(log1.setEnabled(false));
+ TS_ASSERT(!log1.getEnabled());
+ TS_ASSERT_THROWS_NOTHING(log1.fatal("YOU SHOULD NEVER SEE THIS"));
+ TS_ASSERT_THROWS_NOTHING(log1.fatal()<<"YOU SHOULD NEVER SEE THIS VIA A STREAM" << std::endl;);
+
+ TS_ASSERT_THROWS_NOTHING(log1.setEnabled(true));
+ TS_ASSERT(log1.getEnabled());
+ TS_ASSERT_THROWS_NOTHING(log1.fatal("you are allowed to see this"));
+ TS_ASSERT_THROWS_NOTHING(log1.fatal()<<"you are allowed to see this via a stream" << std::endl;);
}