activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tab...@apache.org
Subject svn commit: r908659 - in /activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging: Level.cpp Level.h LogManager.cpp LogManager.h Logger.cpp Logger.h
Date Wed, 10 Feb 2010 20:27:20 GMT
Author: tabish
Date: Wed Feb 10 20:26:34 2010
New Revision: 908659

URL: http://svn.apache.org/viewvc?rev=908659&view=rev
Log:
Refine the API a bit and implement some more of the functionality.  Update the documentation
as well.

Modified:
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp
    activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp?rev=908659&r1=908658&r2=908659&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.cpp Wed Feb
10 20:26:34 2010
@@ -38,6 +38,7 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+const Level Level::INHERIT( "INHERIT", 0 );
 const Level Level::OFF( "OFF", Integer::MAX_VALUE );
 const Level Level::SEVERE( "SEVERE", 1000 );
 const Level Level::WARNING( "WARNING", 900 );

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h?rev=908659&r1=908658&r2=908659&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Level.h Wed Feb 10
20:26:34 2010
@@ -39,6 +39,7 @@
      *   * SEVERE (highest value)
      *   * WARNING
      *   * INFO
+     *   * DEBUG
      *   * CONFIG
      *   * FINE
      *   * FINER
@@ -61,6 +62,12 @@
     public:
 
         /**
+         * NULL is a special level that indicates that the Logger should get its Level from
+         * its parent Logger, the value is initialized as zero.
+         */
+        static const Level INHERIT;
+
+        /**
          * OFF is a special level that can be used to turn off logging. This level is initialized
          * to Integer::MAX_VALUE
          */

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp?rev=908659&r1=908658&r2=908659&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.cpp Wed
Feb 10 20:26:34 2010
@@ -89,6 +89,13 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+bool LogManager::addLogger( Logger* logger DECAF_UNUSED )
+    throw( decaf::lang::exceptions::NullPointerException,
+           decaf::lang::exceptions::IllegalArgumentException ) {
+
+}
+
+////////////////////////////////////////////////////////////////////////////////
 Logger* LogManager::getLogger( const std::string& name DECAF_UNUSED ) {
     return NULL;
 }

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h?rev=908659&r1=908658&r2=908659&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/LogManager.h Wed
Feb 10 20:26:34 2010
@@ -27,6 +27,9 @@
 #include <decaf/util/concurrent/Mutex.h>
 #include <decaf/util/Config.h>
 
+#include <decaf/lang/exceptions/NullPointerException.h>
+#include <decaf/lang/exceptions/IllegalArgumentException.h>
+
 namespace decaf{
 namespace lang{
     class Runtime;
@@ -154,6 +157,22 @@
         virtual ~LogManager();
 
         /**
+         * Add a named logger. This does nothing and returns false if a logger with
+         * the same name is already registered.
+         *
+         * The Logger factory methods call this method to register each newly created Logger.
+         *
+         * @param logger
+         *      The new Logger instance to add to this LogManager.
+         *
+         * @throws NullPointerException if logger is NULL.
+         * @throws IllegalArgumentException if the logger has no name.
+         */
+        bool addLogger( Logger* logger )
+            throw( decaf::lang::exceptions::NullPointerException,
+                   decaf::lang::exceptions::IllegalArgumentException );
+
+        /**
          * Sets the Properties this LogManager should use to configure
          * its loggers.  Once set a properties change event is fired.
          * @param properties Pointer to read the configuration from
@@ -236,7 +255,7 @@
         LogManager();
 
         /**
-         * Copy Constructo
+         * Copy Constructor
          * @param manager the Manager to copy
          */
         LogManager( const LogManager& manager );

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp?rev=908659&r1=908658&r2=908659&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.cpp Wed Feb
10 20:26:34 2010
@@ -24,29 +24,33 @@
 using namespace decaf;
 using namespace decaf::lang;
 using namespace decaf::lang::exceptions;
+using namespace decaf::util;
 using namespace decaf::util::logging;
 
 ////////////////////////////////////////////////////////////////////////////////
-Logger::Logger( const std::string& name DECAF_UNUSED,
-                Logger* parent DECAF_UNUSED ) {
+Logger::Logger( const std::string& name ) : level( Level::INHERIT ) {
+
+    this->name = name;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 Logger::~Logger() {
+
+    std::list<Handler*>::iterator handler = this->handlers.begin();
+    for( ; handler != this->handlers.end(); ++handler ) {
+        delete *handler;
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::addHandler( Handler* handler ) throw ( IllegalArgumentException ) {
+void Logger::addHandler( Handler* handler ) throw ( NullPointerException ) {
 
-    if( handler == NULL )
-    {
-        IllegalArgumentException(
-            __FILE__, __LINE__,
-            "Logger::addHandler - HAndler cannot be null");
+    if( handler == NULL ) {
+        NullPointerException(
+            __FILE__, __LINE__, "Logger::addHandler - Handler cannot be null");
     }
 
-    if( find( handlers.begin(), handlers.end(), handler) != handlers.end() )
-    {
+    if( find( handlers.begin(), handlers.end(), handler) != handlers.end() ) {
         handlers.push_back( handler );
     }
 }
@@ -54,42 +58,57 @@
 ////////////////////////////////////////////////////////////////////////////////
 void Logger::removeHandler( Handler* handler ) {
 
+    if( handler == NULL ) {
+        return;
+    }
+
     list<Handler*>::iterator itr =
         find( handlers.begin(), handlers.end(), handler );
 
     if( itr != handlers.end() ) {
-
-        delete *itr;
-        handlers.erase(itr);
+        handlers.erase( itr );
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::setFilter( Filter* filter DECAF_UNUSED ){
+const std::list<Handler*>& Logger::getHandlers() const {
+    return this->handlers;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::setFilter( Filter* filter ){
+    this->filter = filter;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-bool Logger::isLoggable( Levels level DECAF_UNUSED ) const{
+bool Logger::isLoggable( const Level& level DECAF_UNUSED ) const{
     return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::entry( const std::string& blockName DECAF_UNUSED,
-                    const std::string& file DECAF_UNUSED,
-                    const int line DECAF_UNUSED ) {
+void Logger::entering( const std::string& blockName DECAF_UNUSED,
+                       const std::string& file DECAF_UNUSED,
+                       const int line DECAF_UNUSED ) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::exit(const std::string& blockName DECAF_UNUSED,
-                  const std::string& file DECAF_UNUSED,
-                  const int line DECAF_UNUSED) {
+void Logger::exiting( const std::string& blockName DECAF_UNUSED,
+                      const std::string& file DECAF_UNUSED,
+                      const int line DECAF_UNUSED) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::debug( const std::string& file DECAF_UNUSED,
-                    const int line DECAF_UNUSED,
-                    const std::string fnctionName DECAF_UNUSED,
-                    const std::string& message DECAF_UNUSED ) {
+void Logger::severe( const std::string& file DECAF_UNUSED,
+                     const int line DECAF_UNUSED,
+                     const std::string fnctionName DECAF_UNUSED,
+                     const std::string& message DECAF_UNUSED ) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::warning( const std::string& file DECAF_UNUSED,
+                      const int line DECAF_UNUSED,
+                      const std::string fnctionName DECAF_UNUSED,
+                      const std::string& message DECAF_UNUSED ) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -100,33 +119,54 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::error( const std::string& file DECAF_UNUSED,
+void Logger::debug( const std::string& file DECAF_UNUSED,
                     const int line DECAF_UNUSED,
                     const std::string fnctionName DECAF_UNUSED,
                     const std::string& message DECAF_UNUSED ) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::warn( const std::string& file DECAF_UNUSED,
+void Logger::config( const std::string& file DECAF_UNUSED,
+                     const int line DECAF_UNUSED,
+                     const std::string fnctionName DECAF_UNUSED,
+                     const std::string& message DECAF_UNUSED ) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::fine( const std::string& file DECAF_UNUSED,
                    const int line DECAF_UNUSED,
                    const std::string fnctionName DECAF_UNUSED,
                    const std::string& message DECAF_UNUSED ) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::fatal( const std::string& file DECAF_UNUSED,
+void Logger::finer( const std::string& file DECAF_UNUSED,
                     const int line DECAF_UNUSED,
                     const std::string fnctionName DECAF_UNUSED,
                     const std::string& message DECAF_UNUSED ) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::log( Levels level DECAF_UNUSED,
+void Logger::finest( const std::string& file DECAF_UNUSED,
+                     const int line DECAF_UNUSED,
+                     const std::string fnctionName DECAF_UNUSED,
+                     const std::string& message DECAF_UNUSED ) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::throwing( const std::string& file DECAF_UNUSED,
+                       const int line DECAF_UNUSED,
+                       const std::string functionName DECAF_UNUSED,
+                       const decaf::lang::Throwable& thrown DECAF_UNUSED ) {
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::log( const Level& level DECAF_UNUSED,
                   const std::string& message DECAF_UNUSED ) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::log( Levels level DECAF_UNUSED,
+void Logger::log( const Level& level DECAF_UNUSED,
                   const std::string& file DECAF_UNUSED,
                   const int line DECAF_UNUSED,
                   const std::string& message DECAF_UNUSED,
@@ -134,7 +174,7 @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void Logger::log( Levels level DECAF_UNUSED,
+void Logger::log( const Level& level DECAF_UNUSED,
                   const std::string& file DECAF_UNUSED,
                   const int line DECAF_UNUSED,
                   const std::string& message DECAF_UNUSED, ... ) {

Modified: activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h
URL: http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h?rev=908659&r1=908658&r2=908659&view=diff
==============================================================================
--- activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h (original)
+++ activemq/activemq-cpp/trunk/activemq-cpp/src/main/decaf/util/logging/Logger.h Wed Feb
10 20:26:34 2010
@@ -19,9 +19,14 @@
 
 #include <decaf/util/logging/LoggerCommon.h>
 #include <decaf/util/logging/LogRecord.h>
-#include <decaf/lang/exceptions/IllegalArgumentException.h>
+#include <decaf/util/logging/LogManager.h>
+#include <decaf/util/logging/Handler.h>
+#include <decaf/util/concurrent/Mutex.h>
 #include <decaf/util/Config.h>
 
+#include <decaf/lang/exceptions/IllegalArgumentException.h>
+#include <decaf/lang/exceptions/NullPointerException.h>
+
 #include <list>
 #include <string>
 #include <stdarg.h>
@@ -30,9 +35,54 @@
 namespace util{
 namespace logging{
 
-    class Handler;
     class Filter;
 
+    /**
+     * A Logger object is used to log messages for a specific system or application component.
+     * Loggers are normally named, using a hierarchical dot-separated namespace. Logger names
+     * can be arbitrary strings, but they should normally be based on the namespace or class
+     * name of the logged component, such as decaf.net or org.apache.decaf. In addition it
is
+     * possible to create "anonymous" Loggers that are not stored in the Logger namespace.
+     *
+     * Logger objects may be obtained by calls on one of the getLogger factory methods. These
+     * will either create a new Logger or return a suitable existing Logger.
+     *
+     * Logging messages will be forwarded to registered Handler objects, which can forward
+     * the messages to a variety of destinations, including consoles, files, OS logs, etc.
+     *
+     * Each Logger keeps track of a "parent" Logger, which is its nearest existing ancestor
+     * in the Logger namespace.
+     *
+     * Each Logger has a "Level" associated with it. This reflects a minimum Level that this
+     * logger cares about. If a Logger's level is set to Level::INHERIT, then its effective
level
+     * is inherited from its parent, which may in turn obtain it recursively from its parent,
+     * and so on up the tree.
+     *
+     * The log level can be configured based on the properties from the logging configuration
+     * file, as described in the description of the LogManager class. However it may also
be
+     * dynamically changed by calls on the Logger.setLevel method. If a logger's level is
changed
+     * the change may also affect child loggers, since any child logger that has 'inherit'
as its
+     * level will inherit its effective level from its parent.
+     *
+     * On each logging call the Logger initially performs a cheap check of the request level
+     * (e.g. SEVERE or FINE) against the effective log level of the logger. If the request
level
+     * is lower than the log level, the logging call returns immediately.
+     *
+     * After passing this initial (cheap) test, the Logger will allocate a LogRecord to describe
+     * the logging message. It will then call a Filter (if present) to do a more detailed
check
+     * on whether the record should be published. If that passes it will then publish the
LogRecord
+     * to its output Handlers. By default, loggers also publish to their parent's Handlers,
+     * recursively up the tree.
+     *
+     * Formatting is the responsibility of the output Handler, which will typically call
a Formatter.
+     *
+     * Note that formatting need not occur synchronously. It may be delayed until a LogRecord
is
+     * actually written to an external sink.
+     *
+     * All methods on Logger are thread safe.
+     *
+     * @since 1.0
+     */
     class DECAF_API Logger {
     private:
 
@@ -49,26 +99,28 @@
         Filter* filter;
 
         // The Log Level of this Logger
-        Levels level;
+        Level level;
 
         // Using Parent Handlers?
         bool useParentHandlers;
 
-    public:
+    protected:
 
         /**
-         * Creates a new instance of the Logger with the given name
-         * and assign it the given parent logger.
-         * <p>
+         * Creates a new instance of the Logger with the given name.
+         *
          * The logger will be initially configured with a null Level
          * and with useParentHandlers true.
-         * @param name - A name for the logger. This should be a
-         * dot-separated name and should normally be based on the package
-         * name or class name of the subsystem, such as java.net or
-         * javax.swing. It may be null for anonymous Loggers.
-         * @param parent logger that is this one's parent
+         *
+         * @param name
+         *      A name for the logger. This should be a dot-separated name and
+         *      should normally be based on the package name or class name of the
+         *      subsystem, such as decaf.net or org.apache.decaf.  It may be empty
+         *      for anonymous Loggers.
          */
-        Logger( const std::string& name, Logger* parent );
+        Logger( const std::string& name );
+
+    public:
 
         virtual ~Logger();
 
@@ -76,79 +128,114 @@
          * Gets the name of this Logger
          * @return logger name
          */
-        virtual const std::string& getName() const {
+        const std::string& getName() const {
             return name;
         }
 
         /**
+         * Gets the parent of this Logger which will be the nearest existing Logger in this
+         * Loggers namespace.
+         *
+         * If this is the Root Logger than this method returns NULL.
+         *
+         * @return Pointer to this Loggers nearest parent Logger.
+         */
+        Logger* getParent() const {
+            return this->parent;
+        }
+
+        /**
+         * Set the parent for this Logger. This method is used by the LogManager to update
+         * a Logger when the namespace changes.
+         *
+         * It should not be called from application code.
+         */
+        void setParent( Logger* parent ) {
+            this->parent = parent;
+        }
+
+        /**
          * Add a log Handler to receive logging messages.
-         * <p>
+         *
          * By default, Loggers also send their output to their parent logger.
          * Typically the root Logger is configured with a set of Handlers
          * that essentially act as default handlers for all loggers.
          *
+         * The ownership of the given Handler is passed to the Logger and the
+         * Handler will be deleted when this Logger is destroyed unless the caller
+         * first calls removeHandler with the same pointer value as was originally
+         * given.
+         *
          * @param handler A Logging Handler
-         * @throws IllegalArgumentException
+         *
+         * @throws NullPointerException if the Handler given is NULL.
          */
-        virtual void addHandler( Handler* handler )
-            throw ( lang::exceptions::IllegalArgumentException );
+        void addHandler( Handler* handler )
+            throw ( lang::exceptions::NullPointerException );
 
         /**
-         * Removes the specified Handler and destroys it
-         * <p>
+         * Removes the specified Handler from this logger, ownership of the
+         * Handler pointer is returned to the caller.
+         *
          * Returns silently if the given Handler is not found.
+         *
          * @param handler The Handler to remove
          */
-        virtual void removeHandler( Handler* handler );
+        void removeHandler( Handler* handler );
 
         /**
          * Gets a vector containing all the handlers that this class
          * has been assigned to use.
          * @returns a list of handlers that are used by this logger
          */
-        // virtual const std::list<Handler*>& getHandlers() const;
+        const std::list<Handler*>& getHandlers() const;
 
         /**
          * Set a filter to control output on this Logger.
-         * <p>
+         *
          * After passing the initial "level" check, the Logger will call
          * this Filter to check if a log record should really be published.
-         * <p>
+         *
          * The caller releases ownership of this filter to this logger
-         * @param filter to use, can be null
+         *
+         * @param filter
+         *      The Filter to use, (can be NULL).
          */
-        virtual void setFilter( Filter* filter );
+        void setFilter( Filter* filter );
 
         /**
          * Gets the Filter object that this class is using.
-         * @return the Filter in use, can be null
+         * @return the Filter in use, (can be NULL).
          */
-        virtual const Filter* getFilter() const {
+        const Filter* getFilter() const {
             return filter;
         }
 
         /**
          * Get the log Level that has been specified for this Logger. The
-         * result may be the Null level, which means that this logger's
+         * result may be the INHERIT level, which means that this logger's
          * effective level will be inherited from its parent.
+         *
          * @return the level that is currently set
          */
-        virtual Levels getLevel() const {
+        Level getLevel() const {
             return level;
         }
 
         /**
          * Set the log level specifying which message levels will be logged
          * by this logger. Message levels lower than this value will be
-         * discarded. The level value Level.OFF can be used to turn off
+         * discarded. The level value Level::OFF can be used to turn off
          * logging.
-         * <p>
-         * If the new level is the Null Level, it means that this node
+         *
+         * If the new level is the INHERIT Level, it means that this node
          * should inherit its level from its nearest ancestor with a
-         * specific (non-null) level value.
-         * @param level new Level value
+         * specific (non-INHERIT) level value.
+         *
+         * @param level
+         *      The new Level value to use when logging.
          */
-        virtual void setLevel( Levels level ) {
+        void setLevel( const Level& level ) {
             this->level = level;
         }
 
@@ -157,76 +244,113 @@
          * its parent logger.
          * @return true if using Parent Handlers
          */
-        virtual bool getUseParentHandlers() const {
+        bool getUseParentHandlers() const {
             return useParentHandlers;
         }
 
         /**
-         * pecify whether or not this logger should send its output to it's
+         * Specify whether or not this logger should send its output to it's
          * parent Logger. This means that any LogRecords will also be
          * written to the parent's Handlers, and potentially to its parent,
          * recursively up the namespace.
-         * @param value True is output is to be writen to the parent
+         *
+         * @param value
+         *      True is output is to be written to the parent
          */
-        virtual void setUseParentHandlers( bool value ) {
+        void setUseParentHandlers( bool value ) {
             this->useParentHandlers = value;
         }
 
+    public:   // Logging Methods.
+
         /**
          * Logs an Block Enter message
-         * <p>
-         * This is a convenience method that is used to tag a block enter, a
-         * log record with the class name function name and the string
-         * Entering is logged at the DEBUG log level.
-         * @param blockName source block name
-         * @param file source file name
-         * @param line source line name
-         */
-        virtual void entry( const std::string& blockName,
-                            const std::string& file,
-                            const int line );
+         *
+         * This is a convenience method that is used to tag a block enter, a log record
+         * with the given information is logged at the Level::FINER log level.
+         *
+         * @param blockName
+         *      The source block name, (usually ClassName::MethodName, or MethodName).
+         * @param file
+         *      The source file name where this method was called from.
+         * @param line
+         *      The source line number where this method was called from.
+         */
+        virtual void entering( const std::string& blockName,
+                               const std::string& file,
+                               const int line );
 
         /**
          * Logs an Block Exit message
-         * <p>
-         * This is a convenience method that is used to tag a block exit, a
-         * log record with the class name function name and the string
-         * Exiting is logged at the DEBUG log level.
-         * @param blockName source block name
-         * @param file source file name
-         * @param line source line name
-         */
-        virtual void exit( const std::string& blockName,
-                           const std::string& file,
-                           const int line );
+         *
+         * This is a convenience method that is used to tag a block enter, a log record
+         * with the given information is logged at the Level::FINER log level.
+         *
+         * @param blockName
+         *      The source block name, (usually ClassName::MethodName, or MethodName).
+         * @param file
+         *      The source file name where this method was called from.
+         * @param line
+         *      The source line number where this method was called from.
+         */
+        virtual void exiting( const std::string& blockName,
+                              const std::string& file,
+                              const int line );
 
         /**
-         * Log a Debug Level Log
-         * <p>
-         * If the logger is currently enabled for the DEBUG message level
-         * then the given message is forwarded to all the registered output
-         * Handler objects.
-         * @param file the file name where the log was generated
-         * @param line the line number where the log was generated
-         * @param functionName name of the function that logged this
-         * @param message the message to log
-         */
-        virtual void debug( const std::string& file,
-                            const int line,
-                            const std::string functionName,
-                            const std::string& message );
+         * Log a SEVERE Level Log
+         *
+         * If the logger is currently enabled for the SEVERE message level then the
+         * given message is forwarded to all the registered output Handler objects.
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param message
+         *      The message to log at this Level.
+         */
+        virtual void severe( const std::string& file,
+                             const int line,
+                             const std::string functionName,
+                             const std::string& message );
 
         /**
-         * Log a info Level Log
-         * <p>
-         * If the logger is currently enabled for the info message level
-         * then the given message is forwarded to all the registered output
-         * Handler objects.
+         * Log a WARN Level Log
          *
-         * @param file the file name where the log was generated
-         * @param line the line number where the log was generated
-         * @param functionName name of the function that logged this
-         * @param message the message to log
+         * If the logger is currently enabled for the WARN message level then the
+         * given message is forwarded to all the registered output Handler objects.
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param message
+         *      The message to log at this Level.
+         */
+        virtual void warning( const std::string& file,
+                              const int line,
+                              const std::string functionName,
+                              const std::string& message );
+
+        /**
+         * Log a INFO Level Log
+         *
+         * If the logger is currently enabled for the INFO message level then the
+         * given message is forwarded to all the registered output Handler objects.
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param message
+         *      The message to log at this Level.
          */
         virtual void info( const std::string& file,
                            const int line,
@@ -234,68 +358,128 @@
                            const std::string& message );
 
         /**
-         * Log a warn Level Log
-         * <p>
-         * If the logger is currently enabled for the warn message level
-         * then the given message is forwarded to all the registered output
-         * Handler objects.
-         * @param file the file name where the log was generated
-         * @param line the line number where the log was generated
-         * @param functionName name of the function that logged this
-         * @param message the message to log
+         * Log a DEBUG Level Log
+         *
+         * If the logger is currently enabled for the DEBUG message level then the
+         * given message is forwarded to all the registered output Handler objects.
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param message
+         *      The message to log at this Level.
+         */
+        virtual void debug( const std::string& file,
+                            const int line,
+                            const std::string functionName,
+                            const std::string& message );
+
+        /**
+         * Log a CONFIG Level Log
+         *
+         * If the logger is currently enabled for the CONFIG message level then the
+         * given message is forwarded to all the registered output Handler objects.
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param message
+         *      The message to log at this Level.
+         */
+        virtual void config( const std::string& file,
+                             const int line,
+                             const std::string functionName,
+                             const std::string& message );
+
+        /**
+         * Log a FINE Level Log
+         *
+         * If the logger is currently enabled for the FINE message level then the
+         * given message is forwarded to all the registered output Handler objects.
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param message
+         *      The message to log at this Level.
          */
-        virtual void warn( const std::string& file,
+        virtual void fine( const std::string& file,
                            const int line,
                            const std::string functionName,
                            const std::string& message );
 
         /**
-         * Log a error Level Log
-         * <p>
-         * If the logger is currently enabled for the error message level
-         * then the given message is forwarded to all the registered output
-         * Handler objects.
-         * @param file the file name where the log was generated
-         * @param line the line number where the log was generated
-         * @param fnctionName name of the function that logged this
-         * @param message the message to log
+         * Log a FINER Level Log
+         *
+         * If the logger is currently enabled for the FINER message level then the
+         * given message is forwarded to all the registered output Handler objects.
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param message
+         *      The message to log at this Level.
          */
-        virtual void error( const std::string& file,
+        virtual void finer( const std::string& file,
                             const int line,
-                            const std::string fnctionName,
+                            const std::string functionName,
                             const std::string& message );
 
         /**
-         * Log a fatal Level Log
-         * <p>
-         * If the logger is currently enabled for the fatal message level
-         * then the given message is forwarded to all the registered output
-         * Handler objects.
-         * @param file the file name where the log was generated
-         * @param line the line number where the log was generated
-         * @param functionName name of the function that logged this
-         * @param message the message to log
-         */
-        virtual void fatal( const std::string& file,
-                            const int line,
-                            const std::string functionName,
-                            const std::string& message );
+         * Log a FINEST Level Log
+         *
+         * If the logger is currently enabled for the FINEST message level then the
+         * given message is forwarded to all the registered output Handler objects.
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param message
+         *      The message to log at this Level.
+         */
+        virtual void finest( const std::string& file,
+                             const int line,
+                             const std::string functionName,
+                             const std::string& message );
 
         /**
-         * Log a Throw Message
-         * <p>
-         * If the logger is currently enabled for the Throwing message level
-         * then the given message is forwarded to all the registered output
-         * Handler objects.
-         * @param file the file name where the log was generated
-         * @param line the line number where the log was generated
-         * @param functionName name of the function that logged this
-         * @param message the message to log
+         * Log throwing an exception.
+         *
+         * This is a convenience method to log that a method is terminating by throwing an
+         * exception. The logging is done using the FINER level.
+         *
+         * If the logger is currently enabled for the given message level then the given
+         * arguments are stored in a LogRecord which is forwarded to all registered output
+         * handlers. The LogRecord's message is set to "THROW".
+         *
+         * @param file
+         *      The file name where the log was generated.
+         * @param line
+         *      The line number where the log was generated.
+         * @param functionName
+         *      The name of the function that logged this.
+         * @param thrown
+         *      The Throwable that will be thrown, will be cloned.
+         */
         virtual void throwing( const std::string& file,
                                const int line,
                                const std::string functionName,
-                               const std::string& message );
-         */
+                               const decaf::lang::Throwable& thrown );
 
         /**
          * Check if a message of the given level would actually be logged
@@ -304,7 +488,7 @@
          * @param level - a message logging level
          * @returns true if the given message level is currently being logged.
          */
-        virtual bool isLoggable( Levels level ) const;
+        virtual bool isLoggable( const Level& level ) const;
 
         /**
          * Log a LogRecord.
@@ -324,7 +508,7 @@
          * @param level the Level to log at
          * @param message the message to log
          */
-        virtual void log( Levels level, const std::string& message );
+        virtual void log( const Level& level, const std::string& message );
 
         /**
          * Log a message, with the list of params that is formatted into
@@ -338,7 +522,7 @@
          * @param line the line in the file
          * @param ... variable length argument to format the message string.
          */
-        virtual void log( Levels levels,
+        virtual void log( const Level& levels,
                           const std::string& file,
                           const int line,
                           const std::string& message, ... );
@@ -358,7 +542,7 @@
          * @param message the message to log.
          * @param ex the Exception to log
          */
-        virtual void log( Levels level,
+        virtual void log( const Level& level,
                           const std::string& file,
                           const int line,
                           const std::string& message,



Mime
View raw message