2010-11-20 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>

	Made LogFactory::logger_ as SharedHandle<Logger> to make dtor of
	Logger called at the program exit.  Rewritten A2_LOG_* macro and
	moved them to LogFactory.h
	* src/LogFactory.cc
	* src/LogFactory.h
	* src/Logger.cc
	* src/Logger.h

ChangeLog

@@ -1,3 +1,13 @@
+2010-11-20  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
+
+	Made LogFactory::logger_ as SharedHandle<Logger> to make dtor of
+	Logger called at the program exit.  Rewritten A2_LOG_* macro and
+	moved them to LogFactory.h
+	* src/LogFactory.cc
+	* src/LogFactory.h
+	* src/Logger.cc
+	* src/Logger.h
+
 2010-11-20  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
 
 	Renamed cuid as cuid_t in DefaultBtMessageDispatcher.

src/LogFactory.cc

@@ -40,11 +40,11 @@
 namespace aria2 {
 
 std::string LogFactory::filename_ = DEV_NULL;
-Logger* LogFactory::logger_ = 0;
+SharedHandle<Logger> LogFactory::logger_;
 bool LogFactory::consoleOutput_ = true;
 Logger::LEVEL LogFactory::logLevel_ = Logger::A2_DEBUG;
 
-void LogFactory::openLogger(Logger* logger)
+void LogFactory::openLogger(const SharedHandle<Logger>& logger)
 {
   if(filename_ != DEV_NULL) {
     // don't open file DEV_NULL for performance sake.
@@ -67,21 +67,17 @@ void LogFactory::reconfigure()
   }
 }
 
-Logger* LogFactory::getInstance() {
+const SharedHandle<Logger>& LogFactory::getInstance()
+{
   if(!logger_) {
-    Logger* slogger = new Logger();
-    try {
-      openLogger(slogger);
-    } catch(RecoverableException& e) {
-      delete slogger;
-      throw;
-    }
+    SharedHandle<Logger> slogger(new Logger());
+    openLogger(slogger);
     if(consoleOutput_) {
       slogger->setStdoutLogLevel(Logger::A2_NOTICE, true);
       slogger->setStdoutLogLevel(Logger::A2_WARN, true);
       slogger->setStdoutLogLevel(Logger::A2_ERROR, true);
     }
-    logger_ = slogger;
+    logger_.swap(slogger);
   }
   return logger_;
 }
@@ -118,8 +114,7 @@ void LogFactory::setLogLevel(const std::string& level)
 }
 
 void LogFactory::release() {
-  delete logger_;
-  logger_ = 0;
+  logger_.reset();
 }
 
 } // namespace aria2

src/LogFactory.h

@@ -40,24 +40,26 @@
 #include <string>
 
 #include "Logger.h"
+#include "SharedHandle.h"
 
 namespace aria2 {
 
 class LogFactory {
 private:
   static std::string filename_;
-  // TODO consider SharedHandle
-  static Logger* logger_;
+  static SharedHandle<Logger> logger_;
   static bool consoleOutput_;
   static Logger::LEVEL logLevel_;
 
-  static void openLogger(Logger* logger);
+  static void openLogger(const SharedHandle<Logger>& logger);
+
+  LogFactory();
 public:
   /**
    * Get logger instance. Returned logger is singleton.
    * This function is not thread-safe.
    */
-  static Logger* getInstance();
+  static const SharedHandle<Logger>& getInstance();
 
   /**
    * Set a filename to write log. If name is "-", log is written to
@@ -69,7 +71,8 @@ public:
    * Set flag whether the log is printed in console.
    * If f is false, log is not printed in console.
    */
-  static void setConsoleOutput(bool f) {
+  static void setConsoleOutput(bool f)
+  {
     consoleOutput_ = f;
   }
 
@@ -92,6 +95,39 @@ public:
   static void reconfigure();
 };
 
+#define A2_LOG_DEBUG_ENABLED                                            \
+  aria2::LogFactory::getInstance()->levelEnabled(Logger::A2_DEBUG)
+
+#define A2_LOG(level, msg)                                              \
+  {                                                                     \
+    const aria2::SharedHandle<aria2::Logger>& logger =                  \
+      aria2::LogFactory::getInstance();                                 \
+    if(logger->levelEnabled(level))                                     \
+      logger->log(level, __FILE__, __LINE__, msg);                      \
+  }
+#define A2_LOG_EX(level, msg, ex)                                       \
+  {                                                                     \
+    const aria2::SharedHandle<aria2::Logger>& logger =                  \
+      aria2::LogFactory::getInstance();                                 \
+    if(logger->levelEnabled(level))                                     \
+      logger->log(level, __FILE__, __LINE__, msg, ex);                  \
+  }
+
+#define A2_LOG_DEBUG(msg) A2_LOG(Logger::A2_DEBUG, msg)
+#define A2_LOG_DEBUG_EX(msg, ex) A2_LOG_EX(Logger::A2_DEBUG, msg, ex)
+
+#define A2_LOG_INFO(msg) A2_LOG(Logger::A2_INFO, msg)
+#define A2_LOG_INFO_EX(msg, ex) A2_LOG_EX(Logger::A2_INFO, msg, ex)
+
+#define A2_LOG_NOTICE(msg) A2_LOG(Logger::A2_NOTICE, msg)
+#define A2_LOG_NOTICE_EX(msg, ex) A2_LOG_EX(Logger::A2_NOTICE, msg, ex)
+
+#define A2_LOG_WARN(msg) A2_LOG(Logger::A2_WARN, msg)
+#define A2_LOG_WARN_EX(msg, ex) A2_LOG_EX(Logger::A2_WARN, msg, ex)
+
+#define A2_LOG_ERROR(msg) A2_LOG(Logger::A2_ERROR, msg)
+#define A2_LOG_ERROR_EX(msg, ex) A2_LOG_EX(Logger::A2_ERROR, msg, ex)
+
 } // namespace aria2
 
 #endif // D_LOG_FACTORY_H

src/Logger.cc

@@ -62,10 +62,7 @@ Logger::Logger()
     stdoutField_(0)
 {}
 
-Logger::~Logger()
-{
-  closeFile();
-}
+Logger::~Logger() {}
 
 void Logger::openFile(const std::string& filename)
 {
@@ -77,8 +74,6 @@ void Logger::openFile(const std::string& filename)
 
 void Logger::closeFile()
 {
-  std::cerr << "Closing log file" << std::endl;
-  // TODO Do we need file_.is_open()?
   if(file_.is_open()) {
     file_.close();
   }

src/Logger.h

@@ -56,7 +56,10 @@ public:
 private:
   LEVEL logLevel_;
   std::ofstream file_;
-  int stdoutField_;  
+  int stdoutField_;
+  // Don't allow copying
+  Logger(const Logger&);
+  Logger& operator=(const Logger&);
 public:
   Logger();
 
@@ -104,70 +107,6 @@ public:
   bool levelEnabled(LEVEL level);
 };
 
-#define A2_LOG_DEBUG_ENABLED                                            \
-  aria2::LogFactory::getInstance()->levelEnabled(Logger::A2_DEBUG)
-
-#define A2_LOG_DEBUG(msg)                                               \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_DEBUG))                          \
-      logger->log(Logger::A2_DEBUG, __FILE__, __LINE__, msg);           \
-  }
-#define A2_LOG_DEBUG_EX(msg, ex)                                        \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_DEBUG))                          \
-      logger->log(Logger::A2_DEBUG, __FILE__, __LINE__, msg, ex);      \
-  }
-#define A2_LOG_INFO(msg)                                                \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_INFO))                           \
-      logger->log(Logger::A2_INFO, __FILE__, __LINE__, msg);            \
-  }
-#define A2_LOG_INFO_EX(msg, ex)                                         \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_INFO))                           \
-      logger->log(Logger::A2_INFO, __FILE__, __LINE__, msg, ex);       \
-  }
-#define A2_LOG_NOTICE(msg)                                              \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_NOTICE))                         \
-      logger->log(Logger::A2_NOTICE, __FILE__, __LINE__, msg);          \
-  }
-#define A2_LOG_NOTICE_EX(msg, ex)                                       \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_NOTICE))                         \
-      logger->log(Logger::A2_NOTICE, __FILE__, __LINE__, msg, ex);     \
-  }
-#define A2_LOG_WARN(msg)                                                \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_WARN))                           \
-      logger->log(Logger::A2_WARN, __FILE__, __LINE__, msg);            \
-  }
-#define A2_LOG_WARN_EX(msg, ex)                                         \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_WARN))                           \
-      logger->log(Logger::A2_WARN, __FILE__, __LINE__, msg, ex);        \
-  }
-#define A2_LOG_ERROR(msg)                                               \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_ERROR))                          \
-      logger->log(Logger::A2_ERROR, __FILE__, __LINE__, msg);           \
-  }
-#define A2_LOG_ERROR_EX(msg, ex)                                        \
-  {                                                                     \
-    aria2::Logger* logger = aria2::LogFactory::getInstance();           \
-    if(logger->levelEnabled(Logger::A2_ERROR))                          \
-      logger->log(Logger::A2_ERROR, __FILE__, __LINE__, msg, ex);      \
-  }
-
 } // namespace aria2
 
 #endif // D_LOGGER_H