activemq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chir...@apache.org
Subject svn commit: r419365 [14/25] - in /incubator/activemq/trunk: activemq-core/src/main/java/org/apache/activemq/thread/ activemq-core/src/test/java/org/apache/activemq/openwire/v1/ activemq-cpp/src/main/activemq/concurrent/ activemq-cpp/src/main/activemq/c...
Date Wed, 05 Jul 2006 22:27:47 GMT
Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/ConsoleHandler.h
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/ConsoleHandler.h?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/ConsoleHandler.h (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/ConsoleHandler.h Wed Jul  5 15:27:34 2006
@@ -1,87 +1,87 @@
-/*
- * Copyright 2006 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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 _ACTIVEMQ_LOGGER_CONSOLEHANDLER_H_
-#define _ACTIVEMQ_LOGGER_CONSOLEHANDLER_H_
-
-#include <activemq/logger/StreamHandler.h>
-#include <activemq/io/StandardErrorOutputStream.h>
-
-namespace activemq{
-namespace logger{
-
-   /**
-    * This Handler publishes log records to System.err. By default the
-    * SimpleFormatter is used to generate brief summaries.
-    * 
-    * Configuration: By default each ConsoleHandler is initialized using 
-    * the following LogManager configuration properties. If properties are
-    * not defined (or have invalid values) then the specified default 
-    * values are used.
-    *
-    * ConsoleHandler.level specifies the default level for the Handler 
-    *  (defaults to Level.INFO).
-    * ConsoleHandler.filter specifies the name of a Filter class to use 
-    *  (defaults to no Filter).
-    * ConsoleHandler.formatter specifies the name of a Formatter class to 
-    *  use (defaults to SimpleFormatter).
-    */
-   class ConsoleHandler
-   {
-   private:
-   
-      // The Standard Error Stream to log to
-      io::StandardErrorOutputStream stream;
-      
-      // The default Simple Formatter
-      SimpleFormatter formatter;
-   
-   public:
-   
-      /**
-       * Constructor
-       */
-      ConsoleHandler(void) : StreamHandler(&stream, &formatter)
-      {
-         // Defaults level to Info
-         setLevel(Level.INFO);
-      }
-      
-      /**
-       * Destructor
-       */
-      virtual ~ConsoleHandler(void) {}
-      
-      /**
-       * Close the current output stream.
-       * <p>
-       * Override the StreamHandler close to flush the Std Err stream
-       * but doesn't close.
-       * @throw CMSException
-       */
-      virtual void close(void) throw ( cms::CMSException )
-      {
-         if(getOutputStream())
-         {
-            getOutputStream->flush();
-         }
-      }      
-
-   };
-
-}}
-
-#endif /*_ACTIVEMQ_LOGGER_CONSOLEHANDLER_H_*/
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed 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 _ACTIVEMQ_LOGGER_CONSOLEHANDLER_H_
+#define _ACTIVEMQ_LOGGER_CONSOLEHANDLER_H_
+
+#include <activemq/logger/StreamHandler.h>
+#include <activemq/io/StandardErrorOutputStream.h>
+
+namespace activemq{
+namespace logger{
+
+   /**
+    * This Handler publishes log records to System.err. By default the
+    * SimpleFormatter is used to generate brief summaries.
+    * 
+    * Configuration: By default each ConsoleHandler is initialized using 
+    * the following LogManager configuration properties. If properties are
+    * not defined (or have invalid values) then the specified default 
+    * values are used.
+    *
+    * ConsoleHandler.level specifies the default level for the Handler 
+    *  (defaults to Level.INFO).
+    * ConsoleHandler.filter specifies the name of a Filter class to use 
+    *  (defaults to no Filter).
+    * ConsoleHandler.formatter specifies the name of a Formatter class to 
+    *  use (defaults to SimpleFormatter).
+    */
+   class ConsoleHandler
+   {
+   private:
+   
+      // The Standard Error Stream to log to
+      io::StandardErrorOutputStream stream;
+      
+      // The default Simple Formatter
+      SimpleFormatter formatter;
+   
+   public:
+   
+      /**
+       * Constructor
+       */
+      ConsoleHandler(void) : StreamHandler(&stream, &formatter)
+      {
+         // Defaults level to Info
+         setLevel(Level.INFO);
+      }
+      
+      /**
+       * Destructor
+       */
+      virtual ~ConsoleHandler(void) {}
+      
+      /**
+       * Close the current output stream.
+       * <p>
+       * Override the StreamHandler close to flush the Std Err stream
+       * but doesn't close.
+       * @throw CMSException
+       */
+      virtual void close(void) throw ( cms::CMSException )
+      {
+         if(getOutputStream())
+         {
+            getOutputStream->flush();
+         }
+      }      
+
+   };
+
+}}
+
+#endif /*_ACTIVEMQ_LOGGER_CONSOLEHANDLER_H_*/

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/ConsoleHandler.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Filter.h
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Filter.h?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Filter.h (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Filter.h Wed Jul  5 15:27:34 2006
@@ -1,53 +1,53 @@
-/*
- * Copyright 2006 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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 _ACTIVEMQ_LOGGER_FILTER_H_
-#define _ACTIVEMQ_LOGGER_FILTER_H_
-
-#include <activemq/logger/LogRecord.h>
-
-namespace activemq{
-namespace logger{
-   
-   /**
-    * A Filter can be used to provide fine grain control over what is 
-    * logged, beyond the control provided by log levels.
-    * 
-    * Each Logger and each Handler can have a filter associated with it. 
-    * The Logger or Handler will call the isLoggable method to check if a 
-    * given LogRecord should be published. If isLoggable returns false, 
-    * the LogRecord will be discarded. 
-    */
-   class Filter
-   {
-   public:
-
-      /**
-       * Destructor
-       */
-   	virtual ~Filter(void) {}
-      
-      /**
-       * Check if a given log record should be published.
-       * @param the <code>LogRecord</code> to check.
-       */
-      virtual bool isLoggable(const LogRecord& record) const = 0;
-
-   };
-
-}}
-
-#endif /*_ACTIVEMQ_LOGGER_FILTER_H_*/
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed 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 _ACTIVEMQ_LOGGER_FILTER_H_
+#define _ACTIVEMQ_LOGGER_FILTER_H_
+
+#include <activemq/logger/LogRecord.h>
+
+namespace activemq{
+namespace logger{
+   
+   /**
+    * A Filter can be used to provide fine grain control over what is 
+    * logged, beyond the control provided by log levels.
+    * 
+    * Each Logger and each Handler can have a filter associated with it. 
+    * The Logger or Handler will call the isLoggable method to check if a 
+    * given LogRecord should be published. If isLoggable returns false, 
+    * the LogRecord will be discarded. 
+    */
+   class Filter
+   {
+   public:
+
+      /**
+       * Destructor
+       */
+   	virtual ~Filter(void) {}
+      
+      /**
+       * Check if a given log record should be published.
+       * @param the <code>LogRecord</code> to check.
+       */
+      virtual bool isLoggable(const LogRecord& record) const = 0;
+
+   };
+
+}}
+
+#endif /*_ACTIVEMQ_LOGGER_FILTER_H_*/

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Filter.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Formatter.h
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Formatter.h?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Formatter.h (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Formatter.h Wed Jul  5 15:27:34 2006
@@ -1,74 +1,74 @@
-/*
- * Copyright 2006 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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 _ACTIVEMQ_LOGGER_FORMATTER_H_
-#define _ACTIVEMQ_LOGGER_FORMATTER_H_
-
-namespace activemq{
-namespace logger{
-
-   /**
-    * A Formatter provides support for formatting LogRecords.
-    *
-    * Typically each logging Handler will have a Formatter associated with 
-    * it. The Formatter takes a LogRecord and converts it to a string.
-    *
-    * Some formatters (such as the XMLFormatter) need to wrap head and 
-    * tail strings around a set of formatted records. The getHeader and 
-    * getTail methods can be used to obtain these strings.
-    */
-   class Formatter
-   {
-   public:
-
-      /**
-       * Destrcutor
-       */
-   	virtual ~Formatter(void) {}
-
-      /**
-       * Format the given log record and return the formatted string.
-       * @param The Log Record to Format
-       */
-      virtual std::string format(const LogRecord& record) const = 0;
-      
-      /**
-       * Format the message string from a log record.
-       * @param The Log Record to Format
-       */
-      virtual std::string formatMessage(const LogRecord& record) const = 0;
-      
-      /**
-       * Return the header string for a set of formatted records.  In the
-       * default implementation this method should return empty string
-       * @param the target handler, can be null
-       * @return the head string
-       */
-      virtual std::string getHead(const Handler* handler) = 0;
-
-      /**
-       * Return the tail string for a set of formatted records.  In the
-       * default implementation this method should return empty string
-       * @param the target handler, can be null
-       * @return the tail string
-       */
-      virtual std::string getTail(const Handler* handler) = 0;
-
-   };
-
-}}
-
-#endif /*_ACTIVEMQ_LOGGER_FORMATTER_H_*/
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed 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 _ACTIVEMQ_LOGGER_FORMATTER_H_
+#define _ACTIVEMQ_LOGGER_FORMATTER_H_
+
+namespace activemq{
+namespace logger{
+
+   /**
+    * A Formatter provides support for formatting LogRecords.
+    *
+    * Typically each logging Handler will have a Formatter associated with 
+    * it. The Formatter takes a LogRecord and converts it to a string.
+    *
+    * Some formatters (such as the XMLFormatter) need to wrap head and 
+    * tail strings around a set of formatted records. The getHeader and 
+    * getTail methods can be used to obtain these strings.
+    */
+   class Formatter
+   {
+   public:
+
+      /**
+       * Destrcutor
+       */
+   	virtual ~Formatter(void) {}
+
+      /**
+       * Format the given log record and return the formatted string.
+       * @param The Log Record to Format
+       */
+      virtual std::string format(const LogRecord& record) const = 0;
+      
+      /**
+       * Format the message string from a log record.
+       * @param The Log Record to Format
+       */
+      virtual std::string formatMessage(const LogRecord& record) const = 0;
+      
+      /**
+       * Return the header string for a set of formatted records.  In the
+       * default implementation this method should return empty string
+       * @param the target handler, can be null
+       * @return the head string
+       */
+      virtual std::string getHead(const Handler* handler) = 0;
+
+      /**
+       * Return the tail string for a set of formatted records.  In the
+       * default implementation this method should return empty string
+       * @param the target handler, can be null
+       * @return the tail string
+       */
+      virtual std::string getTail(const Handler* handler) = 0;
+
+   };
+
+}}
+
+#endif /*_ACTIVEMQ_LOGGER_FORMATTER_H_*/

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Formatter.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Handler.h
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Handler.h?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Handler.h (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Handler.h Wed Jul  5 15:27:34 2006
@@ -1,125 +1,125 @@
-/*
- * Copyright 2006 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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 _ACTIVEMQ_LOGGER_HANDLER_H_
-#define _ACTIVEMQ_LOGGER_HANDLER_H_
-
-#include <cms/Closeable.h>
-#include <activemq/logger/LogRecord.h>
-
-namespace activemq{
-namespace logger{
-
-   class Filter;
-   class Formatter;
-   
-   /**
-    * A Handler object takes log messages from a Logger and exports them. 
-    * It might for example, write them to a console or write them to a file, 
-    * or send them to a network logging service, or forward them to an OS 
-    * log, or whatever.
-    * 
-    * A Handler can be disabled by doing a setLevel(Level.OFF) and can be 
-    * re-enabled by doing a setLevel with an appropriate level.
-    * 
-    * Handler classes typically use LogManager properties to set default 
-    * values for the Handler's Filter, Formatter, and Level. See the 
-    * specific documentation for each concrete Handler class. 
-    */
-   class Handler : public cms::Closeable
-   {
-   public:
-   
-      /**
-       * Destructor
-       */
-      virtual ~Handler(void) {}
-      
-      /**
-       * Flush the Handler's output, clears any buffers.
-       */
-      virtual void flush(void) = 0;
-      
-      /**
-       * Publish the Log Record to this Handler
-       * @param The Log Record to Publish
-       */
-      virtual void publish(const LogRecord& record) = 0;
-      
-      /**
-       * Check if this Handler would actually log a given LogRecord.
-       * <p>
-       * This method checks if the LogRecord has an appropriate Level and 
-       * whether it satisfies any Filter. It also may make other Handler 
-       * specific checks that might prevent a handler from logging the 
-       * LogRecord.
-       * @param <code>LogRecord</code> to check
-       */
-      virtual void isLoggable(const LogRecord& record) = 0;
-      
-      /**
-       * Sets the Filter that this Handler uses to filter Log Records
-       * <p>
-       * For each call of publish the Handler will call this Filter (if it 
-       * is non-null) to check if the LogRecord should be published or 
-       * discarded.
-       * @param <code>Filter</code> derived instance
-       */
-      virtual void setFilter(const Filter* filter) = 0;
-      
-      /**
-       * Gets the Filter that this Handler uses to filter Log Records
-       * @param <code>Filter</code> derived instance
-       */
-      virtual const Filter* getFilter(void) = 0;
-      
-      /**
-       * Set the log level specifying which message levels will be logged 
-       * by this Handler.
-       * <p>
-       * The intention is to allow developers to turn on voluminous logging, 
-       * but to limit the messages that are sent to certain Handlers.
-       * @param Level enumeration value
-       */
-      virtual void setLevel(Level value) = 0;
-      
-      /**
-       * Get the log level specifying which message levels will be logged 
-       * by this Handler.
-       * @param Level enumeration value
-       */
-      virtual Level getLevel(void) = 0;
-      
-      /**
-       * Sets the <code>Formatter</code> used by this Handler
-       * <p>
-       * Some Handlers may not use Formatters, in which case the 
-       * Formatter will be remembered, but not used.
-       * @param <code>Filter</code> derived instance
-       */
-      virtual void setFormatter(const Formatter* formatter) = 0;
-      
-      /**
-       * Gets the <code>Formatter</code> used by this Handler
-       * @param <code>Filter</code> derived instance
-       */
-      virtual const Formatter* getFormatter(void) = 0;
-
-   };
-
-}}
-
-#endif /*_ACTIVEMQ_LOGGER_HANDLER_H_*/
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed 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 _ACTIVEMQ_LOGGER_HANDLER_H_
+#define _ACTIVEMQ_LOGGER_HANDLER_H_
+
+#include <cms/Closeable.h>
+#include <activemq/logger/LogRecord.h>
+
+namespace activemq{
+namespace logger{
+
+   class Filter;
+   class Formatter;
+   
+   /**
+    * A Handler object takes log messages from a Logger and exports them. 
+    * It might for example, write them to a console or write them to a file, 
+    * or send them to a network logging service, or forward them to an OS 
+    * log, or whatever.
+    * 
+    * A Handler can be disabled by doing a setLevel(Level.OFF) and can be 
+    * re-enabled by doing a setLevel with an appropriate level.
+    * 
+    * Handler classes typically use LogManager properties to set default 
+    * values for the Handler's Filter, Formatter, and Level. See the 
+    * specific documentation for each concrete Handler class. 
+    */
+   class Handler : public cms::Closeable
+   {
+   public:
+   
+      /**
+       * Destructor
+       */
+      virtual ~Handler(void) {}
+      
+      /**
+       * Flush the Handler's output, clears any buffers.
+       */
+      virtual void flush(void) = 0;
+      
+      /**
+       * Publish the Log Record to this Handler
+       * @param The Log Record to Publish
+       */
+      virtual void publish(const LogRecord& record) = 0;
+      
+      /**
+       * Check if this Handler would actually log a given LogRecord.
+       * <p>
+       * This method checks if the LogRecord has an appropriate Level and 
+       * whether it satisfies any Filter. It also may make other Handler 
+       * specific checks that might prevent a handler from logging the 
+       * LogRecord.
+       * @param <code>LogRecord</code> to check
+       */
+      virtual void isLoggable(const LogRecord& record) = 0;
+      
+      /**
+       * Sets the Filter that this Handler uses to filter Log Records
+       * <p>
+       * For each call of publish the Handler will call this Filter (if it 
+       * is non-null) to check if the LogRecord should be published or 
+       * discarded.
+       * @param <code>Filter</code> derived instance
+       */
+      virtual void setFilter(const Filter* filter) = 0;
+      
+      /**
+       * Gets the Filter that this Handler uses to filter Log Records
+       * @param <code>Filter</code> derived instance
+       */
+      virtual const Filter* getFilter(void) = 0;
+      
+      /**
+       * Set the log level specifying which message levels will be logged 
+       * by this Handler.
+       * <p>
+       * The intention is to allow developers to turn on voluminous logging, 
+       * but to limit the messages that are sent to certain Handlers.
+       * @param Level enumeration value
+       */
+      virtual void setLevel(Level value) = 0;
+      
+      /**
+       * Get the log level specifying which message levels will be logged 
+       * by this Handler.
+       * @param Level enumeration value
+       */
+      virtual Level getLevel(void) = 0;
+      
+      /**
+       * Sets the <code>Formatter</code> used by this Handler
+       * <p>
+       * Some Handlers may not use Formatters, in which case the 
+       * Formatter will be remembered, but not used.
+       * @param <code>Filter</code> derived instance
+       */
+      virtual void setFormatter(const Formatter* formatter) = 0;
+      
+      /**
+       * Gets the <code>Formatter</code> used by this Handler
+       * @param <code>Filter</code> derived instance
+       */
+      virtual const Formatter* getFormatter(void) = 0;
+
+   };
+
+}}
+
+#endif /*_ACTIVEMQ_LOGGER_HANDLER_H_*/

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Handler.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.cpp
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.cpp?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.cpp (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.cpp Wed Jul  5 15:27:34 2006
@@ -1,129 +1,129 @@
-/*
-* Copyright 2006 The Apache Software Foundation or its licensors, as
-* applicable.
-*
-* Licensed 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.
-*/
-#include "LogManager.h"
-
-#include <activemq/logger/PropertiesChangeListener.h>
-#include <activemq/concurrent/Concurrent.h>
-
-#include <algorithm>
-
-using namespace activemq;
-using namespace activemq::logger;
-using namespace activemq::util;
-using namespace std;
-
-////////////////////////////////////////////////////////////////////////////////
-concurrent::Mutex LogManager::mutex;
-LogManager* LogManager::instance = NULL;
-unsigned int LogManager::refCount = 0;
-
-////////////////////////////////////////////////////////////////////////////////
-LogManager::~LogManager( void )
-{
-    // TODO - Delete all the loggers.
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void LogManager::setProperties( const Properties* properties )
-{
-    // Copy the properties
-    this->properties.copy(properties);
-    
-    // Update the configuration of the loggers.
-    // TODO
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void LogManager::addPropertyChangeListener( 
-    PropertyChangeListener* listener )
-{
-    if(find(listeners.begin(), listeners.end(), listener) == listeners.end())
-    {
-        listeners.push_back(listener);
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void LogManager::removePropertyChangeListener( 
-    PropertyChangeListener* listener )
-{
-    listeners.remove(listener);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-Logger* LogManager::getLogger( const std::string& name )
-{
-    return NULL;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-int LogManager::getLoggerNames( const std::vector<std::string>& names )
-{
-    return 0;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-LogManager* LogManager::getInstance( void )
-{
-    synchronized( &mutex )
-    {
-        if( instance == NULL )
-        {
-            instance = new LogManager();
-        }
-
-        refCount++;
-
-        return instance;
-    }
-    
-    return NULL;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void LogManager::returnInstance( void )
-{
-    synchronized( &mutex )
-    {
-        if( refCount == 0 )
-        {
-            return ;
-        }
-
-        refCount--;
-
-        if( refCount == 0 )
-        {
-            delete instance;
-            instance = NULL;
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void LogManager::destroy( void )
-{
-    if( instance != NULL )
-    {
-        synchronized( &mutex )
-        {
-            delete instance;
-            instance = NULL;
-            refCount = 0;
-        }
-    }
-}
+/*
+* Copyright 2006 The Apache Software Foundation or its licensors, as
+* applicable.
+*
+* Licensed 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.
+*/
+#include "LogManager.h"
+
+#include <activemq/logger/PropertiesChangeListener.h>
+#include <activemq/concurrent/Concurrent.h>
+
+#include <algorithm>
+
+using namespace activemq;
+using namespace activemq::logger;
+using namespace activemq::util;
+using namespace std;
+
+////////////////////////////////////////////////////////////////////////////////
+concurrent::Mutex LogManager::mutex;
+LogManager* LogManager::instance = NULL;
+unsigned int LogManager::refCount = 0;
+
+////////////////////////////////////////////////////////////////////////////////
+LogManager::~LogManager( void )
+{
+    // TODO - Delete all the loggers.
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void LogManager::setProperties( const Properties* properties )
+{
+    // Copy the properties
+    this->properties.copy(properties);
+    
+    // Update the configuration of the loggers.
+    // TODO
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void LogManager::addPropertyChangeListener( 
+    PropertyChangeListener* listener )
+{
+    if(find(listeners.begin(), listeners.end(), listener) == listeners.end())
+    {
+        listeners.push_back(listener);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void LogManager::removePropertyChangeListener( 
+    PropertyChangeListener* listener )
+{
+    listeners.remove(listener);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Logger* LogManager::getLogger( const std::string& name )
+{
+    return NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+int LogManager::getLoggerNames( const std::vector<std::string>& names )
+{
+    return 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+LogManager* LogManager::getInstance( void )
+{
+    synchronized( &mutex )
+    {
+        if( instance == NULL )
+        {
+            instance = new LogManager();
+        }
+
+        refCount++;
+
+        return instance;
+    }
+    
+    return NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void LogManager::returnInstance( void )
+{
+    synchronized( &mutex )
+    {
+        if( refCount == 0 )
+        {
+            return ;
+        }
+
+        refCount--;
+
+        if( refCount == 0 )
+        {
+            delete instance;
+            instance = NULL;
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void LogManager::destroy( void )
+{
+    if( instance != NULL )
+    {
+        synchronized( &mutex )
+        {
+            delete instance;
+            instance = NULL;
+            refCount = 0;
+        }
+    }
+}

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.h
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.h?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.h (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.h Wed Jul  5 15:27:34 2006
@@ -1,252 +1,252 @@
-/*
-* Copyright 2006 The Apache Software Foundation or its licensors, as
-* applicable.
-*
-* Licensed 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 _ACTIVEMQ_LOGGER_LOGMANAGER_H_
-#define _ACTIVEMQ_LOGGER_LOGMANAGER_H_
-
-#include <map>
-#include <list>
-#include <string>
-#include <vector>
-
-#include <activemq/util/SimpleProperties.h>
-#include <activemq/concurrent/Mutex.h>
-
-namespace activemq{
-namespace logger{
-
-    class Logger;
-    class PropertyChangeListener;
-
-    /**
-     * There is a single global LogManager object that is used to maintain 
-     * a set of shared state about Loggers and log services.
-     *
-     * This LogManager object:
-     *
-     *   * Manages a hierarchical namespace of Logger objects. All named 
-     *     Loggers are stored in this namespace.
-     *   * Manages a set of logging control properties. These are simple 
-     *     key-value pairs that can be used by Handlers and other logging 
-     *     objects to configure themselves. 
-     *
-     * The global LogManager object can be retrieved using 
-     * LogManager.getLogManager(). The LogManager object is created during 
-     * class initialization and cannot subsequently be changed.
-     *
-     * ***TODO****
-     * By default, the LogManager reads its initial configuration from a 
-     * properties file "lib/logging.properties" in the JRE directory. If 
-     * you edit that property file you can change the default logging 
-     * configuration for all uses of that JRE.
-     *
-     * In addition, the LogManager uses two optional system properties that 
-     * allow more control over reading the initial configuration:
-     *
-     *    * "decaf.logger.config.class"
-     *    * "decaf.logger.config.file" 
-     *
-     * These two properties may be set via the Preferences API, or as 
-     * command line property definitions to the "java" command, or as 
-     * system property definitions passed to JNI_CreateJavaVM.
-     *
-     * If the "java.util.logging.config.class" property is set, then the 
-     * property value is treated as a class name. The given class will be 
-     * loaded, an object will be instantiated, and that object's constructor 
-     * is responsible for reading in the initial configuration. (That object 
-     * may use other system properties to control its configuration.) The 
-     * alternate configuration class can use readConfiguration(InputStream) 
-     * to define properties in the LogManager.
-     *
-     * If "java.util.logging.config.class" property is not set, then the 
-     * "java.util.logging.config.file" system property can be used to specify
-     * a properties file (in java.util.Properties format). The initial
-     * logging configuration will be read from this file.
-     *
-     * If neither of these properties is defined then, as described above, 
-     * the LogManager will read its initial configuration from a properties 
-     * file "lib/logging.properties" in the JRE directory.
-     *
-     * The properties for loggers and Handlers will have names starting with
-     * the dot-separated name for the handler or logger.
-     * ***TODO****
-     *
-     * The global logging properties may include:
-     *
-     *    * A property "handlers". This defines a whitespace separated 
-     *      list of class names for handler classes to load and register as 
-     *      handlers on the root Logger (the Logger named ""). Each class
-     *      name must be for a Handler class which has a default constructor.
-     *      Note that these Handlers may be created lazily, when they are 
-     *      first used.
-     *    * A property "<logger>.handlers". This defines a whitespace or 
-     *      comma separated list of class names for handlers classes to load
-     *      and register as handlers to the specified logger. Each class name 
-     *      must be for a Handler class which has a default constructor. Note 
-     *      that these Handlers may be created lazily, when they are first 
-     *      used.
-     *    * A property "<logger>.useParentHandlers". This defines a boolean
-     *      value. By default every logger calls its parent in addition to 
-     *      handling the logging message itself, this often result in 
-     *      messages being handled by the root logger as well. When setting
-     *      this property to false a Handler needs to be configured for this
-     *      logger otherwise no logging messages are delivered.
-     *    * A property "config". This property is intended to allow arbitrary
-     *      configuration code to be run. The property defines a whitespace 
-     *      separated list of class names. A new instance will be created for 
-     *      each named class. The default constructor of each class may 
-     *      execute arbitrary code to update the logging configuration, such 
-     *      as setting logger levels, adding handlers, adding filters, etc. 
-     *
-     * Loggers are organized into a naming hierarchy based on their dot 
-     * separated names. Thus "a.b.c" is a child of "a.b", but "a.b1" and 
-     * a.b2" are peers.
-     *
-     * All properties whose names end with ".level" are assumed to define
-     * log levels for Loggers. Thus "foo.level" defines a log level for
-     * the logger called "foo" and (recursively) for any of its children 
-     * in the naming hierarchy. Log Levels are applied in the order they
-     * are defined in the properties file. Thus level settings for child 
-     * nodes in the tree should come after settings for their parents. The 
-     * property name ".level" can be used to set the level for the root of 
-     * the tree.
-     *
-     * All methods on the LogManager object are multi-thread safe. 
-     */
-    class LogManager
-    {
-    private:
-    
-        // Change listener on this class's Properties
-        std::list<PropertyChangeListener*> listeners;
-        
-        // Properties of the Log Manager
-        util::SimpleProperties properties;
-
-    public:
-
-        /**
-         * Destructor
-         */
-        virtual ~LogManager();
-
-        /**
-         * 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
-         */
-        virtual void setProperties( const util::Properties* properties );
-
-        /**
-         * Gets a reference to the Logging Properties used by this
-         * logger.
-         * @returns The Logger Properties Pointer
-         */
-        virtual const util::Properties& getProperties( void ) const {
-            return properties;
-        }
-
-        /**
-         * Gets the value of a named property of this LogManager
-         * @param Name of the Property to retrieve
-         * @return the value of the property
-         */
-        virtual std::string getProperty( const std::string& name ) {
-            return properties.getProperty( name );
-        }
-
-        /**
-         * Adds a change listener for LogManager Properties, adding the same
-         * instance of a change event listener does nothing.
-         * @param PropertyChangeListener
-         */
-        virtual void addPropertyChangeListener( 
-            PropertyChangeListener* listener );
-
-        /**
-         * Removes a properties change listener from the LogManager.
-         */
-        virtual void removePropertyChangeListener(
-            PropertyChangeListener* listener );
-
-        /**
-         * Retrieves or creates a new Logger using the name specified
-         * a new logger inherits the configuration of the logger's 
-         * parent if there is no configuration data for the logger.
-         * @param The name of the Logger.
-         */
-        virtual Logger* getLogger( const std::string& name );
-
-        /**
-         * Gets a list of known Logger Names from this Manager
-         * @param STL Vector to hold string logger names
-         * @return count of how many loggers were inserted
-         */
-        virtual int getLoggerNames( const std::vector<std::string>& names );
-
-    public:     // Static Singleton Methods.
-
-        /**
-         * Get the singleton instance
-         * @return Pointer to an instance of the Log Manager
-         */
-        static LogManager* getInstance( void );
-
-        /**
-         * Returns a Checked out instance of this Manager
-         */
-        static void returnInstance( void );
-
-        /**
-         * Forcefully Delete the Instance of this LogManager
-         * even if there are outstanding references.
-         */
-        static void destroy( void );
-
-    protected:
-
-        /**
-         * Constructor, hidden to protect against direct instantiation
-         */
-        LogManager( void )
-        {}
-
-        /**
-         * Copy Constructo
-         */
-        LogManager( const LogManager& manager );
-
-        /**
-         * Assignment operator
-         */
-        void operator=( const LogManager& manager );
-
-    private:
-
-        // Static mutex to protect the singleton methods
-        static concurrent::Mutex mutex;
-
-        // Static pointer to the one and only instance.
-        static LogManager* instance;
-
-        // Static counter for number of outstanding references
-        static unsigned int refCount;
-
-    };
-
-}}
-
-#endif /*_ACTIVEMQ_LOGGER_LOGMANAGER_H_*/
+/*
+* Copyright 2006 The Apache Software Foundation or its licensors, as
+* applicable.
+*
+* Licensed 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 _ACTIVEMQ_LOGGER_LOGMANAGER_H_
+#define _ACTIVEMQ_LOGGER_LOGMANAGER_H_
+
+#include <map>
+#include <list>
+#include <string>
+#include <vector>
+
+#include <activemq/util/SimpleProperties.h>
+#include <activemq/concurrent/Mutex.h>
+
+namespace activemq{
+namespace logger{
+
+    class Logger;
+    class PropertyChangeListener;
+
+    /**
+     * There is a single global LogManager object that is used to maintain 
+     * a set of shared state about Loggers and log services.
+     *
+     * This LogManager object:
+     *
+     *   * Manages a hierarchical namespace of Logger objects. All named 
+     *     Loggers are stored in this namespace.
+     *   * Manages a set of logging control properties. These are simple 
+     *     key-value pairs that can be used by Handlers and other logging 
+     *     objects to configure themselves. 
+     *
+     * The global LogManager object can be retrieved using 
+     * LogManager.getLogManager(). The LogManager object is created during 
+     * class initialization and cannot subsequently be changed.
+     *
+     * ***TODO****
+     * By default, the LogManager reads its initial configuration from a 
+     * properties file "lib/logging.properties" in the JRE directory. If 
+     * you edit that property file you can change the default logging 
+     * configuration for all uses of that JRE.
+     *
+     * In addition, the LogManager uses two optional system properties that 
+     * allow more control over reading the initial configuration:
+     *
+     *    * "decaf.logger.config.class"
+     *    * "decaf.logger.config.file" 
+     *
+     * These two properties may be set via the Preferences API, or as 
+     * command line property definitions to the "java" command, or as 
+     * system property definitions passed to JNI_CreateJavaVM.
+     *
+     * If the "java.util.logging.config.class" property is set, then the 
+     * property value is treated as a class name. The given class will be 
+     * loaded, an object will be instantiated, and that object's constructor 
+     * is responsible for reading in the initial configuration. (That object 
+     * may use other system properties to control its configuration.) The 
+     * alternate configuration class can use readConfiguration(InputStream) 
+     * to define properties in the LogManager.
+     *
+     * If "java.util.logging.config.class" property is not set, then the 
+     * "java.util.logging.config.file" system property can be used to specify
+     * a properties file (in java.util.Properties format). The initial
+     * logging configuration will be read from this file.
+     *
+     * If neither of these properties is defined then, as described above, 
+     * the LogManager will read its initial configuration from a properties 
+     * file "lib/logging.properties" in the JRE directory.
+     *
+     * The properties for loggers and Handlers will have names starting with
+     * the dot-separated name for the handler or logger.
+     * ***TODO****
+     *
+     * The global logging properties may include:
+     *
+     *    * A property "handlers". This defines a whitespace separated 
+     *      list of class names for handler classes to load and register as 
+     *      handlers on the root Logger (the Logger named ""). Each class
+     *      name must be for a Handler class which has a default constructor.
+     *      Note that these Handlers may be created lazily, when they are 
+     *      first used.
+     *    * A property "<logger>.handlers". This defines a whitespace or 
+     *      comma separated list of class names for handlers classes to load
+     *      and register as handlers to the specified logger. Each class name 
+     *      must be for a Handler class which has a default constructor. Note 
+     *      that these Handlers may be created lazily, when they are first 
+     *      used.
+     *    * A property "<logger>.useParentHandlers". This defines a boolean
+     *      value. By default every logger calls its parent in addition to 
+     *      handling the logging message itself, this often result in 
+     *      messages being handled by the root logger as well. When setting
+     *      this property to false a Handler needs to be configured for this
+     *      logger otherwise no logging messages are delivered.
+     *    * A property "config". This property is intended to allow arbitrary
+     *      configuration code to be run. The property defines a whitespace 
+     *      separated list of class names. A new instance will be created for 
+     *      each named class. The default constructor of each class may 
+     *      execute arbitrary code to update the logging configuration, such 
+     *      as setting logger levels, adding handlers, adding filters, etc. 
+     *
+     * Loggers are organized into a naming hierarchy based on their dot 
+     * separated names. Thus "a.b.c" is a child of "a.b", but "a.b1" and 
+     * a.b2" are peers.
+     *
+     * All properties whose names end with ".level" are assumed to define
+     * log levels for Loggers. Thus "foo.level" defines a log level for
+     * the logger called "foo" and (recursively) for any of its children 
+     * in the naming hierarchy. Log Levels are applied in the order they
+     * are defined in the properties file. Thus level settings for child 
+     * nodes in the tree should come after settings for their parents. The 
+     * property name ".level" can be used to set the level for the root of 
+     * the tree.
+     *
+     * All methods on the LogManager object are multi-thread safe. 
+     */
+    class LogManager
+    {
+    private:
+    
+        // Change listener on this class's Properties
+        std::list<PropertyChangeListener*> listeners;
+        
+        // Properties of the Log Manager
+        util::SimpleProperties properties;
+
+    public:
+
+        /**
+         * Destructor
+         */
+        virtual ~LogManager();
+
+        /**
+         * 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
+         */
+        virtual void setProperties( const util::Properties* properties );
+
+        /**
+         * Gets a reference to the Logging Properties used by this
+         * logger.
+         * @returns The Logger Properties Pointer
+         */
+        virtual const util::Properties& getProperties( void ) const {
+            return properties;
+        }
+
+        /**
+         * Gets the value of a named property of this LogManager
+         * @param Name of the Property to retrieve
+         * @return the value of the property
+         */
+        virtual std::string getProperty( const std::string& name ) {
+            return properties.getProperty( name );
+        }
+
+        /**
+         * Adds a change listener for LogManager Properties, adding the same
+         * instance of a change event listener does nothing.
+         * @param PropertyChangeListener
+         */
+        virtual void addPropertyChangeListener( 
+            PropertyChangeListener* listener );
+
+        /**
+         * Removes a properties change listener from the LogManager.
+         */
+        virtual void removePropertyChangeListener(
+            PropertyChangeListener* listener );
+
+        /**
+         * Retrieves or creates a new Logger using the name specified
+         * a new logger inherits the configuration of the logger's 
+         * parent if there is no configuration data for the logger.
+         * @param The name of the Logger.
+         */
+        virtual Logger* getLogger( const std::string& name );
+
+        /**
+         * Gets a list of known Logger Names from this Manager
+         * @param STL Vector to hold string logger names
+         * @return count of how many loggers were inserted
+         */
+        virtual int getLoggerNames( const std::vector<std::string>& names );
+
+    public:     // Static Singleton Methods.
+
+        /**
+         * Get the singleton instance
+         * @return Pointer to an instance of the Log Manager
+         */
+        static LogManager* getInstance( void );
+
+        /**
+         * Returns a Checked out instance of this Manager
+         */
+        static void returnInstance( void );
+
+        /**
+         * Forcefully Delete the Instance of this LogManager
+         * even if there are outstanding references.
+         */
+        static void destroy( void );
+
+    protected:
+
+        /**
+         * Constructor, hidden to protect against direct instantiation
+         */
+        LogManager( void )
+        {}
+
+        /**
+         * Copy Constructo
+         */
+        LogManager( const LogManager& manager );
+
+        /**
+         * Assignment operator
+         */
+        void operator=( const LogManager& manager );
+
+    private:
+
+        // Static mutex to protect the singleton methods
+        static concurrent::Mutex mutex;
+
+        // Static pointer to the one and only instance.
+        static LogManager* instance;
+
+        // Static counter for number of outstanding references
+        static unsigned int refCount;
+
+    };
+
+}}
+
+#endif /*_ACTIVEMQ_LOGGER_LOGMANAGER_H_*/

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogManager.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogRecord.h
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogRecord.h?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogRecord.h (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogRecord.h Wed Jul  5 15:27:34 2006
@@ -1,180 +1,180 @@
-/*
- * Copyright 2006 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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 _ACTIVEMQ_LOGGER_LOGRECORD_H_
-#define _ACTIVEMQ_LOGGER_LOGRECORD_H_
-
-#include <activemq/logger/LoggerCommon.h>
-
-#include <string>
-
-namespace activemq{
-namespace logger{
-
-   class LogRecord
-   {
-   private:
-   
-      // Level of this Record
-      Level level;
-      
-      // Name of the source Logger
-      std::string loggerName;
-      
-      // Name of the File that originated the Log
-      std::string sourceFile;
-      
-      // Line in the source file where log occured
-      unsigned long sourceLine;
-      
-      // The message to Log.
-      std::string message;
-      
-      // The function Name where the log occured
-      std::string functionName;
-      
-      // Time in Mills since UTC that this Record was logged
-      unsigned long timeStamp;
-      
-      // Thread Id of the Thread that logged this Record
-      unsigned long threadId;
-
-   public:
-
-      /**
-       * Constructor
-       */
-      LogRecord() {}
-      
-      /**
-       * Destructor
-       */
-      virtual ~LogRecord() {}
-      
-      /**
-       * Get Level of this log record
-       * @return Level enumeration value.
-       */
-      Level getLevel(void) const { return level; };
-      
-      /**
-       * Set the Level of this Log Record
-       * @param Level Enumeration Value
-       */
-      void setLevel(Level value) { level = value; };
-      
-      /**
-       * Gets the Source Logger's Name
-       * @return the source loggers name
-       */
-      const std::string& getLoggerName(void) const { return loggerName; };
-      
-      /**
-       * Sets the Source Logger's Name
-       * @param the source loggers name
-       */
-      void setLoggerName(const std::string& loggerName) { 
-         this->loggerName = loggerName;
-      };
-      
-      /**
-       * Gets the Source Log File name
-       * @return the source loggers name
-       */
-      const std::string& getSourceFile(void) const { return sourceFile; };
-      
-      /**
-       * Sets the Source Log File Name
-       * @param the source loggers name
-       */
-      void setSourceFile(const std::string& loggerName) { 
-         this->sourceFile = sourceFile;
-      };
-
-      /**
-       * Gets the Source Log line number
-       * @return the source loggers line number
-       */
-      unsigned long getSourceLine(void) const { return sourceLine; };
-      
-      /**
-       * Sets the Source Log line number
-       * @param the source logger's line number
-       */
-      void setSourceLine(long sourceLine) { 
-         this->sourceLine = sourceLine;
-      };
-
-      /**
-       * Gets the Message to be Logged
-       * @return the source logger's message
-       */
-      const std::string& getMessage(void) const { return message; };
-      
-      /**
-       * Sets the Message to be Logged
-       * @param the source loggers message
-       */
-      void setMessage(const std::string& message) { 
-         this->message = message;
-      };
-      
-      /**
-       * Gets the name of the function where this log was logged
-       * @return the source logger's message
-       */
-      const std::string& getSourceFunction(void) const { return functionName; };
-      
-      /**
-       * Sets the name of the function where this log was logged
-       * @param the source loggers message
-       */
-      void setSourceFunction(const std::string& functionName) { 
-         this->functionName = functionName;
-      };
-
-      /**
-       * Gets the time in mills that this message was logged.
-       * @return UTC time in milliseconds
-       */
-      unsigned long getTimestamp(void) const { return timeStamp; };
-      
-      /**
-       * Sets the time in mills that this message was logged.
-       * @param UTC Time in Milliseconds.
-       */
-      void setTimestamp(long timeStamp) { 
-         this->timeStamp = timeStamp;
-      };
-
-      /**
-       * Gets the Thread Id where this Log was created
-       * @return the source loggers line number
-       */
-      unsigned long getTreadId(void) const { return threadId; };
-      
-      /**
-       * Sets the Thread Id where this Log was created
-       * @param the source logger's line number
-       */
-      void setTreadId(long threadId) { 
-         this->threadId = threadId;
-      };
-   };
-
-}}
-
-#endif /*_ACTIVEMQ_LOGGER_LOGRECORD_H_*/
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed 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 _ACTIVEMQ_LOGGER_LOGRECORD_H_
+#define _ACTIVEMQ_LOGGER_LOGRECORD_H_
+
+#include <activemq/logger/LoggerCommon.h>
+
+#include <string>
+
+namespace activemq{
+namespace logger{
+
+   class LogRecord
+   {
+   private:
+   
+      // Level of this Record
+      Level level;
+      
+      // Name of the source Logger
+      std::string loggerName;
+      
+      // Name of the File that originated the Log
+      std::string sourceFile;
+      
+      // Line in the source file where log occured
+      unsigned long sourceLine;
+      
+      // The message to Log.
+      std::string message;
+      
+      // The function Name where the log occured
+      std::string functionName;
+      
+      // Time in Mills since UTC that this Record was logged
+      unsigned long timeStamp;
+      
+      // Thread Id of the Thread that logged this Record
+      unsigned long threadId;
+
+   public:
+
+      /**
+       * Constructor
+       */
+      LogRecord() {}
+      
+      /**
+       * Destructor
+       */
+      virtual ~LogRecord() {}
+      
+      /**
+       * Get Level of this log record
+       * @return Level enumeration value.
+       */
+      Level getLevel(void) const { return level; };
+      
+      /**
+       * Set the Level of this Log Record
+       * @param Level Enumeration Value
+       */
+      void setLevel(Level value) { level = value; };
+      
+      /**
+       * Gets the Source Logger's Name
+       * @return the source loggers name
+       */
+      const std::string& getLoggerName(void) const { return loggerName; };
+      
+      /**
+       * Sets the Source Logger's Name
+       * @param the source loggers name
+       */
+      void setLoggerName(const std::string& loggerName) { 
+         this->loggerName = loggerName;
+      };
+      
+      /**
+       * Gets the Source Log File name
+       * @return the source loggers name
+       */
+      const std::string& getSourceFile(void) const { return sourceFile; };
+      
+      /**
+       * Sets the Source Log File Name
+       * @param the source loggers name
+       */
+      void setSourceFile(const std::string& loggerName) { 
+         this->sourceFile = sourceFile;
+      };
+
+      /**
+       * Gets the Source Log line number
+       * @return the source loggers line number
+       */
+      unsigned long getSourceLine(void) const { return sourceLine; };
+      
+      /**
+       * Sets the Source Log line number
+       * @param the source logger's line number
+       */
+      void setSourceLine(long sourceLine) { 
+         this->sourceLine = sourceLine;
+      };
+
+      /**
+       * Gets the Message to be Logged
+       * @return the source logger's message
+       */
+      const std::string& getMessage(void) const { return message; };
+      
+      /**
+       * Sets the Message to be Logged
+       * @param the source loggers message
+       */
+      void setMessage(const std::string& message) { 
+         this->message = message;
+      };
+      
+      /**
+       * Gets the name of the function where this log was logged
+       * @return the source logger's message
+       */
+      const std::string& getSourceFunction(void) const { return functionName; };
+      
+      /**
+       * Sets the name of the function where this log was logged
+       * @param the source loggers message
+       */
+      void setSourceFunction(const std::string& functionName) { 
+         this->functionName = functionName;
+      };
+
+      /**
+       * Gets the time in mills that this message was logged.
+       * @return UTC time in milliseconds
+       */
+      unsigned long getTimestamp(void) const { return timeStamp; };
+      
+      /**
+       * Sets the time in mills that this message was logged.
+       * @param UTC Time in Milliseconds.
+       */
+      void setTimestamp(long timeStamp) { 
+         this->timeStamp = timeStamp;
+      };
+
+      /**
+       * Gets the Thread Id where this Log was created
+       * @return the source loggers line number
+       */
+      unsigned long getTreadId(void) const { return threadId; };
+      
+      /**
+       * Sets the Thread Id where this Log was created
+       * @param the source logger's line number
+       */
+      void setTreadId(long threadId) { 
+         this->threadId = threadId;
+      };
+   };
+
+}}
+
+#endif /*_ACTIVEMQ_LOGGER_LOGRECORD_H_*/

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogRecord.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.cpp
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.cpp?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.cpp (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.cpp Wed Jul  5 15:27:34 2006
@@ -1,72 +1,72 @@
-/*
- * Copyright 2006 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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.
- */
-#include "LogWriter.h"
-
-#include <iostream>
-#include <activemq/concurrent/Thread.h>
-#include <activemq/concurrent/Concurrent.h>
-#include <activemq/concurrent/Mutex.h>
-
-using namespace activemq;
-using namespace activemq::logger;
-using namespace activemq::concurrent;
-using namespace std;
-
-////////////////////////////////////////////////////////////////////////////////
-concurrent::Mutex LogWriter::mutex;
-
-////////////////////////////////////////////////////////////////////////////////
-LogWriter::LogWriter(void)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-LogWriter::~LogWriter(void)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void LogWriter::log(const std::string& file,
-                    const int          line,
-                    const std::string& prefix,
-                    const std::string& message)
-{
-   synchronized(&mutex)
-   {
-      cout << prefix  << " "
-           << message << " - tid: " << Thread::getId() << endl;   
-   }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void LogWriter::log(const std::string& message)
-{
-   synchronized(&mutex)
-   {
-      cout << message << " - tid: " << Thread::getId() << endl;   
-   }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-LogWriter& LogWriter::getInstance(void)
-{
-    // This one instance
-    static LogWriter instance;
-      
-    return instance;
-}
-
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed 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.
+ */
+#include "LogWriter.h"
+
+#include <iostream>
+#include <activemq/concurrent/Thread.h>
+#include <activemq/concurrent/Concurrent.h>
+#include <activemq/concurrent/Mutex.h>
+
+using namespace activemq;
+using namespace activemq::logger;
+using namespace activemq::concurrent;
+using namespace std;
+
+////////////////////////////////////////////////////////////////////////////////
+concurrent::Mutex LogWriter::mutex;
+
+////////////////////////////////////////////////////////////////////////////////
+LogWriter::LogWriter(void)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+LogWriter::~LogWriter(void)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void LogWriter::log(const std::string& file,
+                    const int          line,
+                    const std::string& prefix,
+                    const std::string& message)
+{
+   synchronized(&mutex)
+   {
+      cout << prefix  << " "
+           << message << " - tid: " << Thread::getId() << endl;   
+   }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void LogWriter::log(const std::string& message)
+{
+   synchronized(&mutex)
+   {
+      cout << message << " - tid: " << Thread::getId() << endl;   
+   }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+LogWriter& LogWriter::getInstance(void)
+{
+    // This one instance
+    static LogWriter instance;
+      
+    return instance;
+}
+

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.h
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.h?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.h (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.h Wed Jul  5 15:27:34 2006
@@ -1,81 +1,81 @@
-/*
- * Copyright 2006 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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 _ACTIVEMQ_LOGGER_LOGWRITER_H_
-#define _ACTIVEMQ_LOGGER_LOGWRITER_H_
-
-//#pragma comment(linker,"/include:activemq::logger::LogWriter::mutex")
-
-#include <activemq/concurrent/Mutex.h>
-
-namespace activemq{
-namespace logger{
-
-   class LogWriter
-   {
-   public:
-      
-      /**
-       * Constructor
-       */
-      LogWriter(void);
-      
-      /**
-       * Destructor
-       */
-      virtual ~LogWriter(void);
-
-      /**
-       * Writes a message to the output destination
-       */
-      virtual void log(const std::string& file,
-                       const int          line,
-                       const std::string& prefix,
-                       const std::string& message);
-      
-      /**
-       * Writes a message to the output destination
-       */
-      virtual void log(const std::string& message);
-
-   public:    // Static methods
-   
-      /**
-       * Get the singleton instance
-       */
-      static LogWriter& getInstance(void);
-      
-      /**
-       * Returns a Checked out instance of this Writer
-       */
-      static void returnInstance(void);
-      
-      /**
-       * Forcefully Delete the Instance of this LogWriter
-       * even if there are outstanding references.
-       */
-      static void destroy(void);
-
-   private:
-   
-      // Syncronization mutex
-      static concurrent::Mutex mutex;
-
-   };
-
-}}
-
-#endif /*_ACTIVEMQ_LOGGER_LOGWRITER_H_*/
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed 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 _ACTIVEMQ_LOGGER_LOGWRITER_H_
+#define _ACTIVEMQ_LOGGER_LOGWRITER_H_
+
+//#pragma comment(linker,"/include:activemq::logger::LogWriter::mutex")
+
+#include <activemq/concurrent/Mutex.h>
+
+namespace activemq{
+namespace logger{
+
+   class LogWriter
+   {
+   public:
+      
+      /**
+       * Constructor
+       */
+      LogWriter(void);
+      
+      /**
+       * Destructor
+       */
+      virtual ~LogWriter(void);
+
+      /**
+       * Writes a message to the output destination
+       */
+      virtual void log(const std::string& file,
+                       const int          line,
+                       const std::string& prefix,
+                       const std::string& message);
+      
+      /**
+       * Writes a message to the output destination
+       */
+      virtual void log(const std::string& message);
+
+   public:    // Static methods
+   
+      /**
+       * Get the singleton instance
+       */
+      static LogWriter& getInstance(void);
+      
+      /**
+       * Returns a Checked out instance of this Writer
+       */
+      static void returnInstance(void);
+      
+      /**
+       * Forcefully Delete the Instance of this LogWriter
+       * even if there are outstanding references.
+       */
+      static void destroy(void);
+
+   private:
+   
+      // Syncronization mutex
+      static concurrent::Mutex mutex;
+
+   };
+
+}}
+
+#endif /*_ACTIVEMQ_LOGGER_LOGWRITER_H_*/

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/LogWriter.h
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Logger.cpp
URL: http://svn.apache.org/viewvc/incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Logger.cpp?rev=419365&r1=419364&r2=419365&view=diff
==============================================================================
--- incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Logger.cpp (original)
+++ incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Logger.cpp Wed Jul  5 15:27:34 2006
@@ -1,169 +1,169 @@
-/*
- * Copyright 2006 The Apache Software Foundation or its licensors, as
- * applicable.
- *
- * Licensed 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.
- */
-#include "Logger.h"
-
-#include <activemq/logger/Handler.h>
-#include <algorithm>
-
-using namespace std;
-using namespace activemq;
-using namespace activemq::logger;
-using namespace activemq::exceptions;
-
-////////////////////////////////////////////////////////////////////////////////
-Logger::Logger(const std::string& name, Logger* parent)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-Logger::~Logger(void)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::addHandler(Handler* handler) throw ( IllegalArgumentException )
-{
-    if(handler == NULL)
-    {
-        IllegalArgumentException(
-            __FILE__, __LINE__, 
-            "Logger::addHandler - HAndler cannot be null");
-    }
-    
-    if(find(handlers.begin(), handlers.end(), handler) != handlers.end())
-    {
-        handlers.push_back(handler);
-    }
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::removeHandler(Handler* handler)
-{
-    list<Handler*>::iterator itr = 
-        find(handlers.begin(), handlers.end(), handler);
-
-    if(itr != handlers.end())
-    {
-        delete *itr;
-        handlers.erase(itr);
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::setFilter(Filter* filter)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-bool Logger::isLoggable(Level level) const
-{
-    return false;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::entry(const std::string& blockName, 
-                   const std::string& file, 
-                   const int line)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::exit(const std::string& blockName, 
-                  const std::string& file, 
-                  const int line)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::debug(const std::string& file, 
-                   const int line, 
-                   const std::string fnctionName, 
-                   const std::string& message)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::info(const std::string& file, 
-                  const int line, 
-                  const std::string fnctionName, 
-                  const std::string& message)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::error(const std::string& file, 
-                   const int line, 
-                   const std::string fnctionName,
-                   const std::string& message)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::warn(const std::string& file, 
-                  const int line, 
-                  const std::string fnctionName, 
-                  const std::string& message)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::fatal(const std::string& file, 
-                   const int line, 
-                   const std::string fnctionName, 
-                   const std::string& message)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::log(Level level, const std::string& message)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::log(Level level, 
-                 const std::string& file, 
-                 const int line, 
-                 const std::string& message, 
-                 cms::CMSException& ex)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::log(Level level, 
-                 const std::string& file, 
-                 const int line, 
-                 const std::string& message, ...)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void Logger::log(LogRecord& record)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-Logger* Logger::getLogger(const std::string& name)
-{
-    return NULL;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-Logger* Logger::getAnonymousLogger(void)
-{
-    return NULL;
-}
+/*
+ * Copyright 2006 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed 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.
+ */
+#include "Logger.h"
+
+#include <activemq/logger/Handler.h>
+#include <algorithm>
+
+using namespace std;
+using namespace activemq;
+using namespace activemq::logger;
+using namespace activemq::exceptions;
+
+////////////////////////////////////////////////////////////////////////////////
+Logger::Logger(const std::string& name, Logger* parent)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Logger::~Logger(void)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::addHandler(Handler* handler) throw ( IllegalArgumentException )
+{
+    if(handler == NULL)
+    {
+        IllegalArgumentException(
+            __FILE__, __LINE__, 
+            "Logger::addHandler - HAndler cannot be null");
+    }
+    
+    if(find(handlers.begin(), handlers.end(), handler) != handlers.end())
+    {
+        handlers.push_back(handler);
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::removeHandler(Handler* handler)
+{
+    list<Handler*>::iterator itr = 
+        find(handlers.begin(), handlers.end(), handler);
+
+    if(itr != handlers.end())
+    {
+        delete *itr;
+        handlers.erase(itr);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::setFilter(Filter* filter)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+bool Logger::isLoggable(Level level) const
+{
+    return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::entry(const std::string& blockName, 
+                   const std::string& file, 
+                   const int line)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::exit(const std::string& blockName, 
+                  const std::string& file, 
+                  const int line)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::debug(const std::string& file, 
+                   const int line, 
+                   const std::string fnctionName, 
+                   const std::string& message)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::info(const std::string& file, 
+                  const int line, 
+                  const std::string fnctionName, 
+                  const std::string& message)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::error(const std::string& file, 
+                   const int line, 
+                   const std::string fnctionName,
+                   const std::string& message)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::warn(const std::string& file, 
+                  const int line, 
+                  const std::string fnctionName, 
+                  const std::string& message)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::fatal(const std::string& file, 
+                   const int line, 
+                   const std::string fnctionName, 
+                   const std::string& message)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::log(Level level, const std::string& message)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::log(Level level, 
+                 const std::string& file, 
+                 const int line, 
+                 const std::string& message, 
+                 cms::CMSException& ex)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::log(Level level, 
+                 const std::string& file, 
+                 const int line, 
+                 const std::string& message, ...)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+void Logger::log(LogRecord& record)
+{
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Logger* Logger::getLogger(const std::string& name)
+{
+    return NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Logger* Logger::getAnonymousLogger(void)
+{
+    return NULL;
+}

Propchange: incubator/activemq/trunk/activemq-cpp/src/main/activemq/logger/Logger.cpp
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message