Author: carnold
Date: Tue Feb 12 23:09:46 2008
New Revision: 627293

URL: http://svn.apache.org/viewvc?rev=627293&view=rev
Log:
LOGCXX-239: Inconsistent const qualification on logging methods

Modified:
    logging/log4cxx/trunk/src/main/cpp/logger.cpp
    logging/log4cxx/trunk/src/main/include/log4cxx/logger.h

Modified: logging/log4cxx/trunk/src/main/cpp/logger.cpp
URL: 
http://svn.apache.org/viewvc/logging/log4cxx/trunk/src/main/cpp/logger.cpp?rev=627293&r1=627292&r2=627293&view=diff
==============================================================================
--- logging/log4cxx/trunk/src/main/cpp/logger.cpp (original)
+++ logging/log4cxx/trunk/src/main/cpp/logger.cpp Tue Feb 12 23:09:46 2008
@@ -210,7 +210,7 @@
 }
 
 
-LogString Logger::getResourceBundleString(const LogString& key) 
+LogString Logger::getResourceBundleString(const LogString& key) const 
 {
         ResourceBundlePtr rb = getResourceBundle();
 
@@ -359,7 +359,7 @@
 
 
 void Logger::l7dlog(const LevelPtr& level1, const LogString& key,
-                    const LocationInfo& location, const 
std::vector<LogString>& params)
+                    const LocationInfo& location, const 
std::vector<LogString>& params) const
 {
         if (repository == 0 || repository->isDisabled(level1->toInt()))
         {
@@ -385,7 +385,7 @@
 }
 
 void Logger::l7dlog(const LevelPtr& level1, const std::string& key,
-                    const LocationInfo& location) {
+                    const LocationInfo& location) const {
   LOG4CXX_DECODE_CHAR(lkey, key);
 
   std::vector<LogString> values(0);
@@ -393,7 +393,7 @@
 }
 
 void Logger::l7dlog(const LevelPtr& level1, const std::string& key,
-                    const LocationInfo& location, const std::string& val1) {
+                    const LocationInfo& location, const std::string& val1) 
const {
   LOG4CXX_DECODE_CHAR(lkey, key);
   LOG4CXX_DECODE_CHAR(lval1, val1);
 
@@ -404,7 +404,7 @@
 
 void Logger::l7dlog(const LevelPtr& level1, const std::string& key,
                     const LocationInfo& location, 
-                    const std::string& val1, const std::string& val2) {
+                    const std::string& val1, const std::string& val2) const {
   LOG4CXX_DECODE_CHAR(lkey, key);
   LOG4CXX_DECODE_CHAR(lval1, val1);
   LOG4CXX_DECODE_CHAR(lval2, val2);
@@ -417,7 +417,7 @@
 
 void Logger::l7dlog(const LevelPtr& level1, const std::string& key,
                     const LocationInfo& location, 
-                    const std::string& val1, const std::string& val2, const 
std::string& val3) {
+                    const std::string& val1, const std::string& val2, const 
std::string& val3) const {
   LOG4CXX_DECODE_CHAR(lkey, key);
   LOG4CXX_DECODE_CHAR(lval1, val1);
   LOG4CXX_DECODE_CHAR(lval2, val2);
@@ -513,33 +513,33 @@
 }
 
 
-void Logger::trace(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) { 
+void Logger::trace(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const { 
   if (isTraceEnabled()) { 
     forcedLog(log4cxx::Level::getTrace(), msg, location); 
   } 
 } 
 
 
-void Logger::trace(const std::string& msg) { 
+void Logger::trace(const std::string& msg) const { 
   if (isTraceEnabled()) { 
     forcedLog(log4cxx::Level::getTrace(), msg); 
   } 
 } 
 
-void Logger::debug(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::debug(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isDebugEnabled()) {
     forcedLog(log4cxx::Level::getDebug(), msg, location);
   }
 }
 
-void Logger::debug(const std::string& msg) {
+void Logger::debug(const std::string& msg) const {
   if (isDebugEnabled()) {
     forcedLog(log4cxx::Level::getDebug(), msg);
   }
 }
 
 
-void Logger::error(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::error(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isErrorEnabled()) {
      forcedLog(log4cxx::Level::getError(), msg, location);
   }
@@ -552,57 +552,57 @@
   }
 }
 
-void Logger::fatal(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::fatal(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isFatalEnabled()) {
     forcedLog(log4cxx::Level::getFatal(), msg, location);
   }
 }
 
-void Logger::fatal(const std::string& msg) {
+void Logger::fatal(const std::string& msg) const {
   if (isFatalEnabled()) {
     forcedLog(log4cxx::Level::getFatal(), msg);
   }
 }
 
-void Logger::info(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::info(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isInfoEnabled()) {
     forcedLog(log4cxx::Level::getInfo(), msg, location);
   }
 }
 
-void Logger::info(const std::string& msg) {
+void Logger::info(const std::string& msg) const {
   if (isInfoEnabled()) {
     forcedLog(log4cxx::Level::getInfo(), msg);
   }
 }
 
 void Logger::log(const LevelPtr& level1, const std::string& message,
-    const log4cxx::spi::LocationInfo& location) {
+    const log4cxx::spi::LocationInfo& location) const {
     if (isEnabledFor(level1)) {
       forcedLog(level1, message, location);
     }
 }
 
-void Logger::log(const LevelPtr& level1, const std::string& message) {
+void Logger::log(const LevelPtr& level1, const std::string& message) const {
     if (isEnabledFor(level1)) {
       forcedLog(level1, message);
     }
 }
 
 void Logger::logLS(const LevelPtr& level1, const LogString& message,
-    const log4cxx::spi::LocationInfo& location) {
+    const log4cxx::spi::LocationInfo& location) const {
     if (isEnabledFor(level1)) {
       forcedLogLS(level1, message, location);
     }
 }
 
-void Logger::warn(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::warn(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isWarnEnabled()) {
     forcedLog(log4cxx::Level::getWarn(), msg, location);
   }
 }
 
-void Logger::warn(const std::string& msg) {
+void Logger::warn(const std::string& msg) const {
   if (isWarnEnabled()) {
     forcedLog(log4cxx::Level::getWarn(), msg);
   }
@@ -617,11 +617,11 @@
 
 #if LOG4CXX_WCHAR_T_API
 void Logger::forcedLog(const LevelPtr& level1, const std::wstring& message,
-        const LocationInfo& location)
+        const LocationInfo& location) const
 {
         Pool p;
         LOG4CXX_DECODE_WCHAR(msg, message);
-        LoggingEventPtr event(new LoggingEvent(this, level1, msg, location));
+        LoggingEventPtr event(new LoggingEvent(const_cast<Logger*>(this), 
level1, msg, location));
         callAppenders(event, p);
 }
 
@@ -648,32 +648,32 @@
         return LogManager::getLogger(name);
 }
 
-void Logger::trace(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) { 
+void Logger::trace(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const { 
   if (isTraceEnabled()) { 
     forcedLog(log4cxx::Level::getTrace(), msg, location); 
   } 
 } 
 
 
-void Logger::trace(const std::wstring& msg) { 
+void Logger::trace(const std::wstring& msg) const { 
   if (isTraceEnabled()) { 
     forcedLog(log4cxx::Level::getTrace(), msg); 
   } 
 } 
 
-void Logger::debug(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::debug(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isDebugEnabled()) {
     forcedLog(log4cxx::Level::getDebug(), msg, location);
   }
 }
 
-void Logger::debug(const std::wstring& msg) {
+void Logger::debug(const std::wstring& msg) const {
   if (isDebugEnabled()) {
     forcedLog(log4cxx::Level::getDebug(), msg);
   }
 }
 
-void Logger::error(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::error(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isErrorEnabled()) {
      forcedLog(log4cxx::Level::getError(), msg, location);
   }
@@ -685,50 +685,50 @@
   }
 }
 
-void Logger::fatal(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::fatal(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isFatalEnabled()) {
     forcedLog(log4cxx::Level::getFatal(), msg, location);
   }
 }
 
-void Logger::fatal(const std::wstring& msg) {
+void Logger::fatal(const std::wstring& msg) const {
   if (isFatalEnabled()) {
     forcedLog(log4cxx::Level::getFatal(), msg);
   }
 }
 
-void Logger::info(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::info(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isInfoEnabled()) {
     forcedLog(log4cxx::Level::getInfo(), msg, location);
   }
 }
 
-void Logger::info(const std::wstring& msg) {
+void Logger::info(const std::wstring& msg) const {
   if (isInfoEnabled()) {
     forcedLog(log4cxx::Level::getInfo(), msg);
   }
 }
 
 void Logger::log(const LevelPtr& level1, const std::wstring& message,
-    const log4cxx::spi::LocationInfo& location) {
+    const log4cxx::spi::LocationInfo& location) const {
     if (isEnabledFor(level1)) {
       forcedLog(level1, message, location);
     }
 }
 
-void Logger::log(const LevelPtr& level1, const std::wstring& message) {
+void Logger::log(const LevelPtr& level1, const std::wstring& message) const {
     if (isEnabledFor(level1)) {
       forcedLog(level1, message);
     }
 }
 
-void Logger::warn(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::warn(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isWarnEnabled()) {
     forcedLog(log4cxx::Level::getWarn(), msg, location);
   }
 }
 
-void Logger::warn(const std::wstring& msg) {
+void Logger::warn(const std::wstring& msg) const {
   if (isWarnEnabled()) {
     forcedLog(log4cxx::Level::getWarn(), msg);
   }
@@ -739,11 +739,11 @@
 
 #if LOG4CXX_UNICHAR_API || LOG4CXX_CFSTRING_API
 void Logger::forcedLog(const LevelPtr& level1, const 
std::basic_string<UniChar>& message,
-        const LocationInfo& location)
+        const LocationInfo& location) const
 {
         Pool p;
         LOG4CXX_DECODE_UNICHAR(msg, message);
-        LoggingEventPtr event(new LoggingEvent(this, level1, msg, location));
+        LoggingEventPtr event(new LoggingEvent(const_cast<Logger*>(this), 
level1, msg, location));
         callAppenders(event, p);
 }
 
@@ -751,7 +751,7 @@
 {
         Pool p;
         LOG4CXX_DECODE_UNICHAR(msg, message);
-        LoggingEventPtr event(new LoggingEvent(this, level1, msg,
+        LoggingEventPtr event(new LoggingEvent(const_cast<Logger*>(this), 
level1, msg,
            LocationInfo::getLocationUnavailable()));
         callAppenders(event, p);
 }
@@ -767,87 +767,87 @@
         return LogManager::getLogger(name);
 }
 
-void Logger::trace(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) { 
+void Logger::trace(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const { 
   if (isTraceEnabled()) { 
     forcedLog(log4cxx::Level::getTrace(), msg, location); 
   } 
 } 
 
 
-void Logger::trace(const std::basic_string<UniChar>& msg) { 
+void Logger::trace(const std::basic_string<UniChar>& msg) const { 
   if (isTraceEnabled()) { 
     forcedLog(log4cxx::Level::getTrace(), msg); 
   } 
 } 
 
-void Logger::debug(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) {
+void Logger::debug(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const {
   if (isDebugEnabled()) {
     forcedLog(log4cxx::Level::getDebug(), msg, location);
   }
 }
 
-void Logger::debug(const std::basic_string<UniChar>& msg) {
+void Logger::debug(const std::basic_string<UniChar>& msg) const {
   if (isDebugEnabled()) {
     forcedLog(log4cxx::Level::getDebug(), msg);
   }
 }
 
-void Logger::error(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) {
+void Logger::error(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const {
   if (isErrorEnabled()) {
      forcedLog(log4cxx::Level::getError(), msg, location);
   }
 }
 
-void Logger::error(const std::basic_string<UniChar>& msg)  {
+void Logger::error(const std::basic_string<UniChar>& msg) const {
   if (isErrorEnabled()) {
      forcedLog(log4cxx::Level::getError(), msg);
   }
 }
 
-void Logger::fatal(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) {
+void Logger::fatal(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const {
   if (isFatalEnabled()) {
     forcedLog(log4cxx::Level::getFatal(), msg, location);
   }
 }
 
-void Logger::fatal(const std::basic_string<UniChar>& msg) {
+void Logger::fatal(const std::basic_string<UniChar>& msg) const {
   if (isFatalEnabled()) {
     forcedLog(log4cxx::Level::getFatal(), msg);
   }
 }
 
-void Logger::info(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) {
+void Logger::info(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const {
   if (isInfoEnabled()) {
     forcedLog(log4cxx::Level::getInfo(), msg, location);
   }
 }
 
-void Logger::info(const std::basic_string<UniChar>& msg) {
+void Logger::info(const std::basic_string<UniChar>& msg) const {
   if (isInfoEnabled()) {
     forcedLog(log4cxx::Level::getInfo(), msg);
   }
 }
 
 void Logger::log(const LevelPtr& level1, const std::basic_string<UniChar>& 
message,
-    const log4cxx::spi::LocationInfo& location) {
+    const log4cxx::spi::LocationInfo& location) const {
     if (isEnabledFor(level1)) {
       forcedLog(level1, message, location);
     }
 }
 
-void Logger::log(const LevelPtr& level1, const std::basic_string<UniChar>& 
message) {
+void Logger::log(const LevelPtr& level1, const std::basic_string<UniChar>& 
message) const {
     if (isEnabledFor(level1)) {
       forcedLog(level1, message);
     }
 }
 
-void Logger::warn(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) {
+void Logger::warn(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const {
   if (isWarnEnabled()) {
     forcedLog(log4cxx::Level::getWarn(), msg, location);
   }
 }
 
-void Logger::warn(const std::basic_string<UniChar>& msg) {
+void Logger::warn(const std::basic_string<UniChar>& msg) const {
   if (isWarnEnabled()) {
     forcedLog(log4cxx::Level::getWarn(), msg);
   }
@@ -858,11 +858,11 @@
 
 #if LOG4CXX_CFSTRING_API
 void Logger::forcedLog(const LevelPtr& level1, const CFStringRef& message,
-        const LocationInfo& location)
+        const LocationInfo& location) const
 {
         Pool p;
         LOG4CXX_DECODE_CFSTRING(msg, message);
-        LoggingEventPtr event(new LoggingEvent(this, level1, msg, location));
+        LoggingEventPtr event(new LoggingEvent(const_cast<Logger*>(this), 
level1, msg, location));
         callAppenders(event, p);
 }
 
@@ -870,7 +870,7 @@
 {
         Pool p;
         LOG4CXX_DECODE_CFSTRING(msg, message);
-        LoggingEventPtr event(new LoggingEvent(this, level1, msg,
+        LoggingEventPtr event(new LoggingEvent(const_cast<Logger*>(this), 
level1, msg,
            LocationInfo::getLocationUnavailable()));
         callAppenders(event, p);
 }
@@ -884,87 +884,87 @@
         return LogManager::getLogger(name);
 }
 
-void Logger::trace(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) { 
+void Logger::trace(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const { 
   if (isTraceEnabled()) { 
     forcedLog(log4cxx::Level::getTrace(), msg, location); 
   } 
 } 
 
 
-void Logger::trace(const CFStringRef& msg) { 
+void Logger::trace(const CFStringRef& msg) const { 
   if (isTraceEnabled()) { 
     forcedLog(log4cxx::Level::getTrace(), msg); 
   } 
 } 
 
-void Logger::debug(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::debug(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isDebugEnabled()) {
     forcedLog(log4cxx::Level::getDebug(), msg, location);
   }
 }
 
-void Logger::debug(const CFStringRef& msg) {
+void Logger::debug(const CFStringRef& msg) const {
   if (isDebugEnabled()) {
     forcedLog(log4cxx::Level::getDebug(), msg);
   }
 }
 
-void Logger::error(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::error(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isErrorEnabled()) {
      forcedLog(log4cxx::Level::getError(), msg, location);
   }
 }
 
-void Logger::error(const CFStringRef& msg)  {
+void Logger::error(const CFStringRef& msg) const {
   if (isErrorEnabled()) {
      forcedLog(log4cxx::Level::getError(), msg);
   }
 }
 
-void Logger::fatal(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::fatal(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isFatalEnabled()) {
     forcedLog(log4cxx::Level::getFatal(), msg, location);
   }
 }
 
-void Logger::fatal(const CFStringRef& msg) {
+void Logger::fatal(const CFStringRef& msg) const {
   if (isFatalEnabled()) {
     forcedLog(log4cxx::Level::getFatal(), msg);
   }
 }
 
-void Logger::info(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::info(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isInfoEnabled()) {
     forcedLog(log4cxx::Level::getInfo(), msg, location);
   }
 }
 
-void Logger::info(const CFStringRef& msg) {
+void Logger::info(const CFStringRef& msg) const {
   if (isInfoEnabled()) {
     forcedLog(log4cxx::Level::getInfo(), msg);
   }
 }
 
 void Logger::log(const LevelPtr& level1, const CFStringRef& message,
-    const log4cxx::spi::LocationInfo& location) {
+    const log4cxx::spi::LocationInfo& location) const {
     if (isEnabledFor(level1)) {
       forcedLog(level1, message, location);
     }
 }
 
-void Logger::log(const LevelPtr& level1, const CFStringRef& message) {
+void Logger::log(const LevelPtr& level1, const CFStringRef& message) const {
     if (isEnabledFor(level1)) {
       forcedLog(level1, message);
     }
 }
 
-void Logger::warn(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) {
+void Logger::warn(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const {
   if (isWarnEnabled()) {
     forcedLog(log4cxx::Level::getWarn(), msg, location);
   }
 }
 
-void Logger::warn(const CFStringRef& msg) {
+void Logger::warn(const CFStringRef& msg) const {
   if (isWarnEnabled()) {
     forcedLog(log4cxx::Level::getWarn(), msg);
   }

Modified: logging/log4cxx/trunk/src/main/include/log4cxx/logger.h
URL: 
http://svn.apache.org/viewvc/logging/log4cxx/trunk/src/main/include/log4cxx/logger.h?rev=627293&r1=627292&r2=627293&view=diff
==============================================================================
--- logging/log4cxx/trunk/src/main/include/log4cxx/logger.h (original)
+++ logging/log4cxx/trunk/src/main/include/log4cxx/logger.h Tue Feb 12 23:09:46 
2008
@@ -175,19 +175,19 @@
         @param file the file where the log statement was written.
         @param line the line where the log statement was written.
         */
-        void debug(const std::string& msg, const log4cxx::spi::LocationInfo& 
location);
-        void debug(const std::string& msg);
+        void debug(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void debug(const std::string& msg) const;
 #if LOG4CXX_WCHAR_T_API
-        void debug(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location);
-        void debug(const std::wstring& msg);
+        void debug(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void debug(const std::wstring& msg) const;
 #endif
 #if LOG4CXX_UNICHAR_API
-        void debug(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location);
-        void debug(const std::basic_string<UniChar>& msg);
+        void debug(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const;
+        void debug(const std::basic_string<UniChar>& msg) const;
 #endif
 #if LOG4CXX_CFSTRING_API
-        void debug(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location);
-        void debug(const CFStringRef& msg);
+        void debug(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void debug(const CFStringRef& msg) const;
 #endif
 
         /**
@@ -204,19 +204,19 @@
         @param file the file where the log statement was written.
         @param line the line where the log statement was written.
         */
-        void error(const std::string& msg, const log4cxx::spi::LocationInfo& 
location);
+        void error(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const;
         void error(const std::string& msg) const;
 #if LOG4CXX_WCHAR_T_API
         void error(const std::wstring& msg) const;
-        void error(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location);
+        void error(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const;
 #endif
 #if LOG4CXX_UNICHAR_API
-        void error(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location);
-        void error(const std::basic_string<UniChar>& msg);
+        void error(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const;
+        void error(const std::basic_string<UniChar>& msg) const;
 #endif
 #if LOG4CXX_CFSTRING_API
-        void error(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location);
-        void error(const CFStringRef& msg);
+        void error(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void error(const CFStringRef& msg) const;
 #endif
 
         /**
@@ -233,19 +233,19 @@
         @param file the file where the log statement was written.
         @param line the line where the log statement was written.
         */
-        void fatal(const std::string& msg, const log4cxx::spi::LocationInfo& 
location);
-        void fatal(const std::string& msg);
+        void fatal(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void fatal(const std::string& msg) const;
 #if LOG4CXX_WCHAR_T_API
-        void fatal(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location);
-        void fatal(const std::wstring& msg);
+        void fatal(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void fatal(const std::wstring& msg) const;
 #endif
 #if LOG4CXX_UNICHAR_API
-        void fatal(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location);
-        void fatal(const std::basic_string<UniChar>& msg);
+        void fatal(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const;
+        void fatal(const std::basic_string<UniChar>& msg) const;
 #endif
 #if LOG4CXX_CFSTRING_API
-        void fatal(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location);
-        void fatal(const CFStringRef& msg);
+        void fatal(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void fatal(const CFStringRef& msg) const;
 #endif
         /**
         This method creates a new logging event and logs the event
@@ -260,7 +260,7 @@
 
 #if LOG4CXX_WCHAR_T_API
         void forcedLog(const LevelPtr& level, const std::wstring& message,
-                        const log4cxx::spi::LocationInfo& location);
+                        const log4cxx::spi::LocationInfo& location) const;
         void forcedLog(const LevelPtr& level, const std::wstring& message) 
const;
 #endif
 #if LOG4CXX_UNICHAR_API || LOG4CXX_CFSTRING_API
@@ -422,7 +422,7 @@
 
         @see #getResourceBundle.
         */
-        LogString getResourceBundleString(const LogString& key) /* const */;
+        LogString getResourceBundleString(const LogString& key) const;
 
         public:
         /**
@@ -439,19 +439,19 @@
                 @param file the file where the log statement was written.
                 @param line the line where the log statement was written.
                 */
-       void info(const std::string& msg, const log4cxx::spi::LocationInfo& 
location);
-       void info(const std::string& msg);
+       void info(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const;
+       void info(const std::string& msg) const;
 #if LOG4CXX_WCHAR_T_API
-       void info(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location);
-       void info(const std::wstring& msg);
+       void info(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const;
+       void info(const std::wstring& msg) const;
 #endif
 #if LOG4CXX_UNICHAR_API
-        void info(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location);
-        void info(const std::basic_string<UniChar>& msg);
+        void info(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const;
+        void info(const std::basic_string<UniChar>& msg) const;
 #endif
 #if LOG4CXX_CFSTRING_API
-        void info(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location);
-        void info(const CFStringRef& msg);
+        void info(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void info(const CFStringRef& msg) const;
 #endif
 
         /**
@@ -569,59 +569,59 @@
         */
         void l7dlog(const LevelPtr& level, const LogString& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::vector<LogString>& values);
+                    const std::vector<LogString>& values) const;
         void l7dlog(const LevelPtr& level, const std::string& key,
-                    const log4cxx::spi::LocationInfo& locationInfo);
+                    const log4cxx::spi::LocationInfo& locationInfo) const;
         void l7dlog(const LevelPtr& level, const std::string& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::string& val1);
+                    const std::string& val1) const;
         void l7dlog(const LevelPtr& level, const std::string& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::string& val1, const std::string& val2);
+                    const std::string& val1, const std::string& val2) const;
         void l7dlog(const LevelPtr& level, const std::string& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::string& val1, const std::string& val2, const 
std::string& val3);
+                    const std::string& val1, const std::string& val2, const 
std::string& val3) const;
 
 #if LOG4CXX_WCHAR_T_API
         void l7dlog(const LevelPtr& level, const std::wstring& key,
-                    const log4cxx::spi::LocationInfo& locationInfo);
+                    const log4cxx::spi::LocationInfo& locationInfo) const;
         void l7dlog(const LevelPtr& level, const std::wstring& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::wstring& val1);
+                    const std::wstring& val1) const;
         void l7dlog(const LevelPtr& level, const std::wstring& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::wstring& val1, const std::wstring& val2);
+                    const std::wstring& val1, const std::wstring& val2) const;
         void l7dlog(const LevelPtr& level, const std::wstring& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::wstring& val1, const std::wstring& val2, const 
std::wstring& val3);
+                    const std::wstring& val1, const std::wstring& val2, const 
std::wstring& val3) const;
 #endif
 #if LOG4CXX_UNICHAR_API
         void l7dlog(const LevelPtr& level, const std::basic_string<UniChar>& 
key,
-                    const log4cxx::spi::LocationInfo& locationInfo);
+                    const log4cxx::spi::LocationInfo& locationInfo) const;
         void l7dlog(const LevelPtr& level, const std::basic_string<UniChar>& 
key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::basic_string<UniChar>& val1);
+                    const std::basic_string<UniChar>& val1) const;
         void l7dlog(const LevelPtr& level, const std::basic_string<UniChar>& 
key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const std::basic_string<UniChar>& val1, const 
std::basic_string<UniChar>& val2);
+                    const std::basic_string<UniChar>& val1, const 
std::basic_string<UniChar>& val2) const;
         void l7dlog(const LevelPtr& level, const std::basic_string<UniChar>& 
key,
                     const log4cxx::spi::LocationInfo& locationInfo,
                     const std::basic_string<UniChar>& val1, const 
std::basic_string<UniChar>& val2, 
-                    const std::basic_string<UniChar>& val3);
+                    const std::basic_string<UniChar>& val3) const;
 #endif
 #if LOG4CXX_CFSTRING_API
         void l7dlog(const LevelPtr& level, const CFStringRef& key,
-                    const log4cxx::spi::LocationInfo& locationInfo);
+                    const log4cxx::spi::LocationInfo& locationInfo) const;
         void l7dlog(const LevelPtr& level, const CFStringRef& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const CFStringRef& val1);
+                    const CFStringRef& val1) const;
         void l7dlog(const LevelPtr& level, const CFStringRef& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
-                    const CFStringRef& val1, const CFStringRef& val2);
+                    const CFStringRef& val1, const CFStringRef& val2) const;
         void l7dlog(const LevelPtr& level, const CFStringRef& key,
                     const log4cxx::spi::LocationInfo& locationInfo,
                     const CFStringRef& val1, const CFStringRef& val2, 
-                    const CFStringRef& val3);
+                    const CFStringRef& val3) const;
 #endif
 
           /**
@@ -632,25 +632,25 @@
         @param message The message of the logging request.
         @param location The source file of the logging request, may be null. */
         void log(const LevelPtr& level, const std::string& message,
-            const log4cxx::spi::LocationInfo& location);
-        void log(const LevelPtr& level, const std::string& message);
+            const log4cxx::spi::LocationInfo& location) const;
+        void log(const LevelPtr& level, const std::string& message) const;
 #if LOG4CXX_WCHAR_T_API
         void log(const LevelPtr& level, const std::wstring& message,
-            const log4cxx::spi::LocationInfo& location);
-        void log(const LevelPtr& level, const std::wstring& message);
+            const log4cxx::spi::LocationInfo& location) const;
+        void log(const LevelPtr& level, const std::wstring& message) const;
 #endif
 #if LOG4CXX_UNICHAR_API
         void log(const LevelPtr& level, const std::basic_string<UniChar>& 
message,
-            const log4cxx::spi::LocationInfo& location);
-        void log(const LevelPtr& level, const std::basic_string<UniChar>& 
message);
+            const log4cxx::spi::LocationInfo& location) const;
+        void log(const LevelPtr& level, const std::basic_string<UniChar>& 
message) const;
 #endif
 #if LOG4CXX_CFSTRING_API
         void log(const LevelPtr& level, const CFStringRef& message,
-            const log4cxx::spi::LocationInfo& location);
-        void log(const LevelPtr& level, const CFStringRef& message);
+            const log4cxx::spi::LocationInfo& location) const;
+        void log(const LevelPtr& level, const CFStringRef& message) const;
 #endif
         void logLS(const LevelPtr& level, const LogString& message,
-            const log4cxx::spi::LocationInfo& location);
+            const log4cxx::spi::LocationInfo& location) const;
 
 
 
@@ -713,19 +713,19 @@
         @param line the line where the log statement was written.
         */
 #if LOG4CXX_WCHAR_T_API
-        void warn(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location);
-        void warn(const std::wstring& msg);
+        void warn(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void warn(const std::wstring& msg) const;
 #endif
 #if LOG4CXX_UNICHAR_API
-        void warn(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location);
-        void warn(const std::basic_string<UniChar>& msg);
+        void warn(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const;
+        void warn(const std::basic_string<UniChar>& msg) const;
 #endif
 #if LOG4CXX_CFSTRING_API
-        void warn(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location);
-        void warn(const CFStringRef& msg);
+        void warn(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void warn(const CFStringRef& msg) const;
 #endif
-        void warn(const std::string& msg, const log4cxx::spi::LocationInfo& 
location);
-        void warn(const std::string& msg);
+        void warn(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void warn(const std::string& msg) const;
 
         /**
         Log a message string with the [EMAIL PROTECTED] Level#TRACE TRACE} 
level.
@@ -742,19 +742,19 @@
         @param line the line where the log statement was written.
         */
 #if LOG4CXX_WCHAR_T_API
-        void trace(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location);
-        void trace(const std::wstring& msg);
+        void trace(const std::wstring& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void trace(const std::wstring& msg) const;
 #endif
 #if LOG4CXX_UNICHAR_API
-        void trace(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location);
-        void trace(const std::basic_string<UniChar>& msg);
+        void trace(const std::basic_string<UniChar>& msg, const 
log4cxx::spi::LocationInfo& location) const;
+        void trace(const std::basic_string<UniChar>& msg) const;
 #endif
 #if LOG4CXX_CFSTRING_API
-        void trace(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location);
-        void trace(const CFStringRef& msg);
+        void trace(const CFStringRef& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void trace(const CFStringRef& msg) const;
 #endif
-        void trace(const std::string& msg, const log4cxx::spi::LocationInfo& 
location);
-        void trace(const std::string& msg);
+        void trace(const std::string& msg, const log4cxx::spi::LocationInfo& 
location) const;
+        void trace(const std::string& msg) const;
 
         inline const log4cxx::helpers::Mutex& getMutex() const { return mutex; 
}
 


Reply via email to