src/decaf/src/main/decaf/util/logging/Logger.h - activemq-cpp - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #ifndef _DECAF_UTIL_LOGGING_LOGGER_H_
 #define _DECAF_UTIL_LOGGING_LOGGER_H_

 #include <decaf/util/logging/LoggerCommon.h>
 #include <decaf/util/logging/LogRecord.h>
 #include <decaf/lang/exceptions/IllegalArgumentException.h>
 #include <decaf/util/Config.h>

 #include <list>
 #include <string>
 #include <stdarg.h>

 namespace decaf{
 namespace util{
 namespace logging{

     class Handler;
     class Filter;

     class DECAF_API Logger
     {
     private:

         // The name of this Logger
         std::string name;

         // The Parent of this Logger
         Logger* parent;

         // list of Handlers owned by this logger
         std::list<Handler*> handlers;

         // Filter used by this Logger
         Filter* filter;

         // The Log Level of this Logger
         Level level;

         // Using Parent Handlers?
         bool useParentHandlers;

     public:

         /**
          * Creates a new instance of the Logger with the given name
          * and assign it the given parent logger.
          * <p>
          * 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
          */
         Logger( const std::string& name, Logger* parent );

         virtual ~Logger();

         /**
          * Gets the name of this Logger
          * @return logger name
          */
         virtual const std::string& getName(void) const {
             return name;
         }

         /**
          * 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.
          *
          * @param handler A Logging Handler
          * #throws IllegalArgumentException
          */
         virtual void addHandler( Handler* handler )
             throw ( lang::exceptions::IllegalArgumentException );

         /**
          * Removes the specified Handler and destroys it
          * <p>
          * Returns silently if the given Handler is not found.
          * @param handler The Handler to remove
          */
         virtual 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(void) 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
          */
         virtual void setFilter( Filter* filter );

         /**
          * Gets the Filter object that this class is using.
          * @return the Filter in use, can be null
          */
         virtual 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
          * effective level will be inherited from its parent.
          * @return the level that is currently set
          */
         virtual 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
          * logging.
          * <p>
          * If the new level is the Null 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
          */
         virtual void setLevel( Level level ) {
             this->level = level;
         }

         /**
          * Discover whether or not this logger is sending its output to
          * its parent logger.
          * @return true if using Parent Handlers
          */
         virtual bool getUseParentHandlers() const {
             return useParentHandlers;
         }

         /**
          * pecify 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
          */
         virtual void setUseParentHandlers( bool value ) {
             this->useParentHandlers = value;
         }

         /**
          * 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 );

         /**
          * 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 );

         /**
          * 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 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.
          *
          * @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 info( const std::string& file,
                            const int line,
                            const std::string functionName,
                            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
          */
         virtual void warn( 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
          */
         virtual void error( const std::string& file,
                             const int line,
                             const std::string fnctionName,
                             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 fnctionName 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 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 fnctionName name of the function that logged this
          * @param message the message to log
         virtual void throwing( const std::string& file,
                                const int line,
                                const std::string fnctionName,
                                const std::string& message );
          */

         /**
          * Check if a message of the given level would actually be logged
          * by this logger. This check is based on the Loggers effective
          * level, which may be inherited from its parent.
          * @param level - a message logging level
          * @returns true if the given message level is currently being logged.
          */
         virtual bool isLoggable( Level level ) const;

         /**
          * Log a LogRecord.
          * All the other logging methods in this class call through this
          * method to actually perform any logging. Subclasses can override
          * this single method to capture all log activity.
          * @param record - the LogRecord to be published
          */
         virtual void log( LogRecord& record );

         /**
          * Log a message, with no arguments.
          * <p>
          * If the logger is currently enabled for the given message level
          * then the given message is forwarded to all the registered output
          * Handler objects
          * @param level the Level to log at
          * @param message the message to log
          */
         virtual void log( Level level, const std::string& message );

         /**
          * Log a message, with the list of params that is formatted into
          * the message string.
          * <p>
          * If the logger is currently enabled for the given message level
          * then the given message is forwarded to all the registered output
          * Handler objects
          * @param level the Level to log at
          * @param file the message to log
          * @param line the line in the file
          * @param variable length arguement to format the message string.
          */
         virtual void log( Level level,
                           const std::string& file,
                           const int line,
                           const std::string& message, ... );

         /**
          * Log a message, with associated Throwable information.
          * 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.
          * Note that the thrown argument is stored in the LogRecord thrown
          * property, rather than the LogRecord parameters property. Thus is
          * it processed specially by output Formatters and is not treated
          * as a formatting parameter to the LogRecord message property.
          * @param level the Level to log at
          * @param file File that the message was logged in
          * @param line the line number where the message was logged at.
          * @param ex the Exception to log
          */
         virtual void log( Level level,
                           const std::string& file,
                           const int line,
                           const std::string& message,
                           lang::Exception& ex );

     public:

         /**
          * Creates an anonymous logger
          * <p>
          * The newly created Logger is not registered in the LogManager
          * namespace. There will be no access checks on updates to the
          * logger.
          * Even although the new logger is anonymous, it is configured to
          * have the root logger ("") as its parent. This means that by
          * default it inherits its effective level and handlers from the
          * root logger.
          * <p>
          * The caller is responsible for destroying the returned logger.
          * @return Newly created anonymous logger
          */
         static Logger* getAnonymousLogger();

         /**
          * Find or create a logger for a named subsystem. If a logger has
          * already been created with the given name it is returned.
          * Otherwise a new logger is created.
          * <p>
          * If a new logger is created its log level will be configured based
          * on the LogManager and it will configured to also send logging
          * output to its parent loggers Handlers. It will be registered in
          * the LogManager global namespace.
          * @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 cms or
          * activemq.core.ActiveMQConnection
          * @return a suitable logger.
          */
         static Logger* getLogger( const std::string& name );

     };

 }}}

 #endif /*_DECAF_UTIL_LOGGING_LOGGER_H_*/
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#ifndef _DECAF_UTIL_LOGGING_LOGGER_H_
	#define _DECAF_UTIL_LOGGING_LOGGER_H_

	#include <decaf/util/logging/LoggerCommon.h>
	#include <decaf/util/logging/LogRecord.h>
	#include <decaf/lang/exceptions/IllegalArgumentException.h>
	#include <decaf/util/Config.h>

	#include <list>
	#include <string>
	#include <stdarg.h>

	namespace decaf{
	namespace util{
	namespace logging{

	class Handler;
	class Filter;

	class DECAF_API Logger
	{
	private:

	// The name of this Logger
	std::string name;

	// The Parent of this Logger
	Logger* parent;

	// list of Handlers owned by this logger
	std::list<Handler*> handlers;

	// Filter used by this Logger
	Filter* filter;

	// The Log Level of this Logger
	Level level;

	// Using Parent Handlers?
	bool useParentHandlers;

	public:

	/**
	* Creates a new instance of the Logger with the given name
	* and assign it the given parent logger.
	* <p>
	* 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
	*/
	Logger( const std::string& name, Logger* parent );

	virtual ~Logger();

	/**
	* Gets the name of this Logger
	* @return logger name
	*/
	virtual const std::string& getName(void) const {
	return name;
	}

	/**
	* 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.
	*
	* @param handler A Logging Handler
	* #throws IllegalArgumentException
	*/
	virtual void addHandler( Handler* handler )
	throw ( lang::exceptions::IllegalArgumentException );

	/**
	* Removes the specified Handler and destroys it
	* <p>
	* Returns silently if the given Handler is not found.
	* @param handler The Handler to remove
	*/
	virtual 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(void) 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
	*/
	virtual void setFilter( Filter* filter );

	/**
	* Gets the Filter object that this class is using.
	* @return the Filter in use, can be null
	*/
	virtual 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
	* effective level will be inherited from its parent.
	* @return the level that is currently set
	*/
	virtual 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
	* logging.
	* <p>
	* If the new level is the Null 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
	*/
	virtual void setLevel( Level level ) {
	this->level = level;
	}

	/**
	* Discover whether or not this logger is sending its output to
	* its parent logger.
	* @return true if using Parent Handlers
	*/
	virtual bool getUseParentHandlers() const {
	return useParentHandlers;
	}

	/**
	* pecify 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
	*/
	virtual void setUseParentHandlers( bool value ) {
	this->useParentHandlers = value;
	}

	/**
	* 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 );

	/**
	* 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 );

	/**
	* 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 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.
	*
	* @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 info( const std::string& file,
	const int line,
	const std::string functionName,
	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
	*/
	virtual void warn( 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
	*/
	virtual void error( const std::string& file,
	const int line,
	const std::string fnctionName,
	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 fnctionName 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 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 fnctionName name of the function that logged this
	* @param message the message to log
	virtual void throwing( const std::string& file,
	const int line,
	const std::string fnctionName,
	const std::string& message );
	*/

	/**
	* Check if a message of the given level would actually be logged
	* by this logger. This check is based on the Loggers effective
	* level, which may be inherited from its parent.
	* @param level - a message logging level
	* @returns true if the given message level is currently being logged.
	*/
	virtual bool isLoggable( Level level ) const;

	/**
	* Log a LogRecord.
	* All the other logging methods in this class call through this
	* method to actually perform any logging. Subclasses can override
	* this single method to capture all log activity.
	* @param record - the LogRecord to be published
	*/
	virtual void log( LogRecord& record );

	/**
	* Log a message, with no arguments.
	* <p>
	* If the logger is currently enabled for the given message level
	* then the given message is forwarded to all the registered output
	* Handler objects
	* @param level the Level to log at
	* @param message the message to log
	*/
	virtual void log( Level level, const std::string& message );

	/**
	* Log a message, with the list of params that is formatted into
	* the message string.
	* <p>
	* If the logger is currently enabled for the given message level
	* then the given message is forwarded to all the registered output
	* Handler objects
	* @param level the Level to log at
	* @param file the message to log
	* @param line the line in the file
	* @param variable length arguement to format the message string.
	*/
	virtual void log( Level level,
	const std::string& file,
	const int line,
	const std::string& message, ... );

	/**
	* Log a message, with associated Throwable information.
	* 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.
	* Note that the thrown argument is stored in the LogRecord thrown
	* property, rather than the LogRecord parameters property. Thus is
	* it processed specially by output Formatters and is not treated
	* as a formatting parameter to the LogRecord message property.
	* @param level the Level to log at
	* @param file File that the message was logged in
	* @param line the line number where the message was logged at.
	* @param ex the Exception to log
	*/
	virtual void log( Level level,
	const std::string& file,
	const int line,
	const std::string& message,
	lang::Exception& ex );

	public:

	/**
	* Creates an anonymous logger
	* <p>
	* The newly created Logger is not registered in the LogManager
	* namespace. There will be no access checks on updates to the
	* logger.
	* Even although the new logger is anonymous, it is configured to
	* have the root logger ("") as its parent. This means that by
	* default it inherits its effective level and handlers from the
	* root logger.
	* <p>
	* The caller is responsible for destroying the returned logger.
	* @return Newly created anonymous logger
	*/
	static Logger* getAnonymousLogger();

	/**
	* Find or create a logger for a named subsystem. If a logger has
	* already been created with the given name it is returned.
	* Otherwise a new logger is created.
	* <p>
	* If a new logger is created its log level will be configured based
	* on the LogManager and it will configured to also send logging
	* output to its parent loggers Handlers. It will be registered in
	* the LogManager global namespace.
	* @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 cms or
	* activemq.core.ActiveMQConnection
	* @return a suitable logger.
	*/
	static Logger* getLogger( const std::string& name );

	};

	}}}

	#endif /_DECAF_UTIL_LOGGING_LOGGER_H_/