Merge branch 'master' into next

Conflicts: gr-audio/lib/CMakeLists.txt gr-blocks/include/blocks/CMakeLists.txt gr-blocks/include/blocks/socket_pdu.h gr-blocks/lib/CMakeLists.txt gr-blocks/swig/blocks_swig.i gr-comedi/src/CMakeLists.txt gr-howto-write-a-block/lib/CMakeLists.txt gr-noaa/lib/CMakeLists.txt gr-qtgui/lib/CMakeLists.txt gr-uhd/lib/CMakeLists.txt gr-vocoder/lib/CMakeLists.txt gr-wavelet/lib/CMakeLists.txt
author: Tom Rondeau <trondeau@vt.edu> 2013-03-13 18:02:42 -0400
committer: Tom Rondeau <trondeau@vt.edu> 2013-03-13 18:02:42 -0400
commit: 1c9d67fc220737873728310bd679d9e9cfab470a (patch)
tree: 5fbf8c157da3e938d9b90ebe720f3efbcef39215 /gnuradio-core/src/lib
parent: 1d8d1f111c41862d877686a89344a4a74f146cee (diff)
parent: 1bacc04f7a8f2f9c868a9934624683c7cefb2300 (diff)
7 files changed, 432 insertions, 337 deletions
diff --git a/gnuradio-core/src/lib/CMakeLists.txt b/gnuradio-core/src/lib/CMakeLists.txt
index 89371a8b80..72b9f9bdeb 100644
--- a/gnuradio-core/src/lib/CMakeLists.txt
+++ b/gnuradio-core/src/lib/CMakeLists.txt
@@ -66,25 +66,25 @@ link_directories(
 	${FFTW3F_LIBRARY_DIRS}
 )
 
-include_directories(${LOG4CXX_INCLUDE_DIRS})
-link_directories(${LOG4CXX_LIBRARY_DIRS})
+include_directories(${LOG4CPP_INCLUDE_DIRS})
+link_directories(${LOG4CPP_LIBRARY_DIRS})
 
 ########################################################################
 # Setup library
 ########################################################################
 
-# Only use if log4cxx is installed
+# Only use if log4cpp is installed
 # Define ENABLE_GR_LOG so .h and .cc files can turn actual
 # logging and insert dummy functions.
-#if(LOG4CXX_FOUND)
+#if(LOG4CPP_FOUND)
 #    add_definitions(-DENABLE_GR_LOG)
-#endif(LOG4CXX_FOUND)
+#endif(LOG4CPP_FOUND)
 
 list(APPEND gnuradio_core_libs
     gruel
     ${Boost_LIBRARIES}
     ${FFTW3F_LIBRARIES}
-    ${LOG4CXX_LIBRARIES}
+    ${LOG4CPP_LIBRARIES}
 )
 
 if(FFTW3F_THREADS_LIBRARIES)
@@ -161,6 +161,6 @@ include_directories(${CPPUNIT_INCLUDE_DIRS})
 link_directories(${CPPUNIT_LIBRARY_DIRS})
 
 add_library(test-gnuradio-core SHARED ${test_gnuradio_core_sources})
-target_link_libraries(test-gnuradio-core gnuradio-core ${CPPUNIT_LIBRARIES} ${Boost_LIBRARIES} ${LOG4CXX_LIBRARIES})
+target_link_libraries(test-gnuradio-core gnuradio-core ${CPPUNIT_LIBRARIES} ${Boost_LIBRARIES} ${LOG4CPP_LIBRARIES})
 
 endif(ENABLE_TESTING)
diff --git a/gnuradio-core/src/lib/runtime/gr_block.cc b/gnuradio-core/src/lib/runtime/gr_block.cc
index 2ff9cfb750..cb38df27a8 100644
--- a/gnuradio-core/src/lib/runtime/gr_block.cc
+++ b/gnuradio-core/src/lib/runtime/gr_block.cc
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2004,2009,2010 Free Software Foundation, Inc.
+ * Copyright 2004,2009,2010,2013 Free Software Foundation, Inc.
  *
  * This file is part of GNU Radio
  *
@@ -53,7 +53,7 @@ gr_block::gr_block (const std::string &name,
     global_block_registry.register_primitive(alias(), this);
 
 #ifdef ENABLE_GR_LOG
-#ifdef HAVE_LOG4CXX
+#ifdef HAVE_LOG4CPP
     gr_prefs *p = gr_prefs::singleton();
     std::string config_file = p->get_string("LOG", "log_config", "");
     std::string log_level = p->get_string("LOG", "log_level", "off");
@@ -67,13 +67,13 @@ gr_block::gr_block (const std::string &name,
     GR_LOG_SET_LEVEL(LOG, log_level);
     if(log_file.size() > 0) {
       if(log_file == "stdout") {
-        GR_LOG_ADD_CONSOLE_APPENDER(LOG, "gr::log :%p: %c{1} - %m%n", "System.out");
+        GR_LOG_ADD_CONSOLE_APPENDER(LOG, "cout","gr::log :%p: %c{1} - %m%n");
       }
       else if(log_file == "stderr") {
-        GR_LOG_ADD_CONSOLE_APPENDER(LOG, "gr::log :%p: %c{1} - %m%n", "System.err");
+        GR_LOG_ADD_CONSOLE_APPENDER(LOG, "cerr","gr::log :%p: %c{1} - %m%n");
       }
       else {
-        GR_LOG_ADD_FILE_APPENDER(LOG, "%r :%p: %c{1} - %m%n", log_file, "");
+        GR_LOG_ADD_FILE_APPENDER(LOG, log_file , true,"%r :%p: %c{1} - %m%n");
       }
     }
     d_logger = LOG;
@@ -82,17 +82,17 @@ gr_block::gr_block (const std::string &name,
     GR_LOG_SET_LEVEL(DLOG, debug_level);
     if(debug_file.size() > 0) {
       if(debug_file == "stdout") {
-        GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "gr::debug :%p: %c{1} - %m%n", "System.out");
+        GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "cout","gr::debug :%p: %c{1} - %m%n");
       }
       else if(debug_file == "stderr") {
-        GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "gr::debug :%p: %c{1} - %m%n", "System.err");
+        GR_LOG_ADD_CONSOLE_APPENDER(DLOG, "cerr", "gr::debug :%p: %c{1} - %m%n");
       }
       else {
-        GR_LOG_ADD_FILE_APPENDER(DLOG, "%r :%p: %c{1} - %m%n", debug_file, "");
+        GR_LOG_ADD_FILE_APPENDER(DLOG, debug_file, true, "%r :%p: %c{1} - %m%n");
       }
     }
     d_debug_logger = DLOG;
-#endif /* HAVE_LOG4CXX */
+#endif /* HAVE_LOG4CPP */
 #else /* ENABLE_GR_LOG */
     d_logger = NULL;
     d_debug_logger = NULL;
diff --git a/gnuradio-core/src/lib/runtime/gr_logger.cc b/gnuradio-core/src/lib/runtime/gr_logger.cc
index e337920a33..530c66f964 100644
--- a/gnuradio-core/src/lib/runtime/gr_logger.cc
+++ b/gnuradio-core/src/lib/runtime/gr_logger.cc
@@ -21,63 +21,70 @@
  */
 
 /*******************************************************************************
-* Copyright 2011 Johns Hopkins University Applied Physics Lab
 * Author: Mark Plett 
 * Description:
-*   The gr_log module wraps the log4cxx library for logging in gnuradio.
+*   The gr_log module wraps the log4cpp library for logging in gnuradio.
 *******************************************************************************/
 
-#ifdef HAVE_CONFIG_H
-#include "config.h" 
-#endif
+//#ifdef HAVE_CONFIG_H
+//#include "config.h" 
+//#endif
 
 #include <gr_logger.h>
 #include <stdexcept>
 #include <algorithm>
 
 #ifdef ENABLE_GR_LOG
-#ifdef HAVE_LOG4CXX 
+#ifdef HAVE_LOG4CPP 
 
 bool gr_logger_configured(false);
 
 void
 logger_load_config(const std::string &config_filename)
 {
-  if(!gr_logger_configured) {
+  if(!gr_logger_configured){
     gr_logger_configured = true;
-    if(config_filename.size() > 0) {
-      if(config_filename.find(".xml") != std::string::npos) {
-        log4cxx::xml::DOMConfigurator::configure(config_filename);
-      }
-      else {
-        log4cxx::PropertyConfigurator::configure(config_filename);
-      }
-    }
-  }
+    if(config_filename.size() != 0) {
+       try
+       {
+         log4cpp::PropertyConfigurator::configure(config_filename);
+       }
+       catch( log4cpp::ConfigureFailure &e )
+       {
+         std::cout << "Logger config failed :" << e.what() << std::endl;
+       }
+    };
+  };
 }
 
 void
 logger_load_config_and_watch(const std::string &config_filename,
                              unsigned int watch_period)
 {
-  if(!gr_logger_configured) {
+// NOTE:: NEEDS CODE TO WATCH FILE HERE
+  if(!gr_logger_configured){
     gr_logger_configured = true;
-    if(config_filename.size() > 0) {
-      if(config_filename.find(".xml") != std::string::npos) {
-        log4cxx::xml::DOMConfigurator::configureAndWatch(config_filename, watch_period);
-      }
-      else {
-        log4cxx::PropertyConfigurator::configureAndWatch(config_filename, watch_period);
-      }
-    }
-  }
+    if(config_filename.size() != 0) {
+       try
+       {
+         log4cpp::PropertyConfigurator::configure(config_filename);
+       }
+       catch( log4cpp::ConfigureFailure &e )
+       {
+         std::cout << "Logger config failed :" << e.what() << std::endl;
+       }
+    };
+  };
 }
 
 void 
-logger_reset_config(void)
-{
-  log4cxx::LogManager::resetConfiguration();
-  gr_logger_configured=false;
+logger_reset_config(void){
+  std::vector<log4cpp::Category*> *loggers = log4cpp::Category::getCurrentCategories();
+  std::vector<log4cpp::Category*>::iterator logger = loggers->begin();
+// We can't destroy categories but we can neuter them by removing all appenders.
+  for (;logger!=loggers->end();logger++){
+    (*logger)->removeAllAppenders();
+  };
 }
 
 void
@@ -85,105 +92,113 @@ logger_set_level(gr_logger_ptr logger, const std::string &level)
 {
   std::string nocase = level;
   std::transform(level.begin(), level.end(), nocase.begin(), ::tolower);
-  
-  if(nocase == "off")
-    logger_set_level(logger, log4cxx::Level::getOff());
-  else if(nocase == "all")
-    logger_set_level(logger, log4cxx::Level::getAll());
-  else if(nocase == "trace")
-    logger_set_level(logger, log4cxx::Level::getTrace());
+
+  if(nocase == "off" || nocase == "notset")
+    logger_set_level(logger, log4cpp::Priority::NOTSET);
   else if(nocase == "debug")
-    logger_set_level(logger, log4cxx::Level::getDebug());
+    logger_set_level(logger, log4cpp::Priority::DEBUG);
   else if(nocase == "info")
-    logger_set_level(logger, log4cxx::Level::getInfo());
+    logger_set_level(logger, log4cpp::Priority::INFO);
+  else if(nocase == "notice")
+    logger_set_level(logger, log4cpp::Priority::NOTICE);
   else if(nocase == "warn")
-    logger_set_level(logger, log4cxx::Level::getWarn());
+    logger_set_level(logger, log4cpp::Priority::WARN);
   else if(nocase == "error")
-    logger_set_level(logger, log4cxx::Level::getError());
-  else if(nocase == "fatal")
-    logger_set_level(logger, log4cxx::Level::getFatal());
+    logger_set_level(logger, log4cpp::Priority::ERROR);
+  else if(nocase == "crit")
+    logger_set_level(logger, log4cpp::Priority::CRIT);
+  else if(nocase == "alert")
+    logger_set_level(logger, log4cpp::Priority::ALERT);
+ else if(nocase=="fatal")
+    logger_set_level(logger, log4cpp::Priority::FATAL);
+  else if(nocase == "all" || nocase == "emerg")
+    logger_set_level(logger, log4cpp::Priority::EMERG);
   else
     throw std::runtime_error("logger_set_level: Bad level type.\n");
 }
 
 void
-logger_set_level(gr_logger_ptr logger, log4cxx::LevelPtr level)
+logger_set_level(gr_logger_ptr logger, log4cpp::Priority::Value level)
 {
-  logger->setLevel(level);
+  logger->setPriority(level);
 }
 
 void 
 logger_get_level(gr_logger_ptr logger, std::string &level)
 {
-  log4cxx::LevelPtr levelPtr = logger->getLevel();
-  if(levelPtr == log4cxx::Level::getOff()) level = "off";
-  if(levelPtr == log4cxx::Level::getAll()) level = "all";
-  if(levelPtr == log4cxx::Level::getTrace()) level = "trace";
-  if(levelPtr == log4cxx::Level::getDebug()) level = "debug";
-  if(levelPtr == log4cxx::Level::getInfo()) level = "info";
-  if(levelPtr == log4cxx::Level::getWarn()) level = "warn";
-  if(levelPtr == log4cxx::Level::getError()) level = "error";
-  if(levelPtr == log4cxx::Level::getFatal()) level = "fatal";
+  log4cpp::Priority::Value levelPtr = logger->getPriority();
+  if(levelPtr == log4cpp::Priority::NOTSET) level = "noset";
+  if(levelPtr == log4cpp::Priority::DEBUG) level = "debug";
+  if(levelPtr == log4cpp::Priority::INFO) level = "info";
+  if(levelPtr == log4cpp::Priority::NOTICE) level = "notice";
+  if(levelPtr == log4cpp::Priority::WARN) level = "warn";
+  if(levelPtr == log4cpp::Priority::ERROR) level = "error";
+  if(levelPtr == log4cpp::Priority::CRIT) level = "crit";
+  if(levelPtr == log4cpp::Priority::ALERT) level = "alert";
+  if(levelPtr == log4cpp::Priority::FATAL) level = "fatal";
+  if(levelPtr == log4cpp::Priority::EMERG) level = "emerg";
 };
 
 void 
-logger_get_level(gr_logger_ptr logger, log4cxx::LevelPtr level)
+logger_get_level(gr_logger_ptr logger,log4cpp::Priority::Value level)
 {
-  level = logger->getLevel();
+  level = logger->getPriority();
 }
 
 void 
-logger_add_console_appender(gr_logger_ptr logger, std::string layout,
-                            std::string target)
+logger_add_console_appender(gr_logger_ptr logger,std::string target,std::string pattern)
 {
-  log4cxx::PatternLayout *playout =
-    new log4cxx::PatternLayout(layout);
-  log4cxx::ConsoleAppender *appender =
-    new log4cxx::ConsoleAppender(log4cxx::LayoutPtr(playout), target);
-  log4cxx::helpers::Pool p;
-  appender->activateOptions(p);
-  logger->addAppender(appender);
+
+  log4cpp::PatternLayout* layout = new log4cpp::PatternLayout();
+  log4cpp::Appender* app;
+  if(target=="cout")
+    app = new log4cpp::OstreamAppender("ConsoleAppender::",&std::cout);
+  else
+	  app = new log4cpp::OstreamAppender("ConsoleAppender::",&std::cerr);
+
+  layout->setConversionPattern(pattern);
+	app->setLayout(layout);
+  logger->setAppender(app);
+
 }
 
 void
-logger_add_file_appender(gr_logger_ptr logger, std::string layout,
-                         std::string filename, bool append)
+logger_add_file_appender(gr_logger_ptr logger,std::string filename,bool append,std::string pattern)
 {
-  log4cxx::PatternLayout *playout =
-    new log4cxx::PatternLayout(layout);
-  log4cxx::FileAppender *appender =
-    new log4cxx::FileAppender(log4cxx::LayoutPtr(playout), filename, append);
-  log4cxx::helpers::Pool p;
-  appender->activateOptions(p);
-  logger->addAppender(appender);
+
+  log4cpp::PatternLayout* layout = new log4cpp::PatternLayout();
+	log4cpp::Appender* app = new 
+              log4cpp::FileAppender("FileAppender::"+filename,
+              filename);
+  layout->setConversionPattern(pattern);
+	app->setLayout(layout);
+  logger->setAppender(app);
+
 }
 
 void 
-logger_add_rollingfile_appender(gr_logger_ptr logger, std::string layout,
-                                std::string filename, bool append,
-                                int bkup_index, std::string filesize)
+logger_add_rollingfile_appender(gr_logger_ptr logger,std::string filename,
+            size_t filesize,int bkup_index,bool append,mode_t mode,std::string pattern)
 {
-  log4cxx::PatternLayout *playout =
-    new log4cxx::PatternLayout(layout);
-  log4cxx::RollingFileAppender *appender = 
-    new log4cxx::RollingFileAppender(log4cxx::LayoutPtr(playout), filename, append);
-  appender->setMaxBackupIndex(bkup_index);
-  appender->setMaxFileSize(filesize);
-  log4cxx::helpers::Pool p; 
-  appender->activateOptions(p);
-  logger->addAppender(appender);
+  log4cpp::PatternLayout* layout = new log4cpp::PatternLayout();
+  log4cpp::Appender* app = new 
+              log4cpp::RollingFileAppender("RollFileAppender::"+filename,filename,filesize,bkup_index,append,mode);
+  layout->setConversionPattern(pattern);
+  app->setLayout(layout);
+  logger->setAppender(app);
 }
 
 void
-logger_get_logger_names(std::vector<std::string>& names)
-{
-  log4cxx::LoggerList list = log4cxx::LogManager::getCurrentLoggers();
-  log4cxx::LoggerList::iterator logger = list.begin();
+logger_get_logger_names(std::vector<std::string>& names){
+  std::vector<log4cpp::Category*> *loggers = log4cpp::Category::getCurrentCategories();
+  std::vector<log4cpp::Category*>::iterator logger = loggers->begin();
+
   names.clear();
-  for(; logger != list.end(); logger++) {
+  for (;logger!=loggers->end();logger++){
     names.push_back((*logger)->getName());
-  }
+  };
+  
 }
 
-#endif /* HAVE_LOG4CXX */
+#endif /* HAVE_LOG4CPP */
 #endif /* ENABLE_GR_LOGGER */
diff --git a/gnuradio-core/src/lib/runtime/gr_logger.h b/gnuradio-core/src/lib/runtime/gr_logger.h
index 40684ec9d0..13f31d60b8 100644
--- a/gnuradio-core/src/lib/runtime/gr_logger.h
+++ b/gnuradio-core/src/lib/runtime/gr_logger.h
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2012 Free Software Foundation, Inc.
+ * Copyright 2012-2013 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio
  * 
@@ -21,10 +21,9 @@
  */
 
 /*******************************************************************************
-* Copyright 2011 Johns Hopkins University Applied Physics Lab
 * Author: Mark Plett
 * Description:
-*   The gr_logger module wraps the log4cxx library for logging in gnuradio
+*   The gr_logger module wraps the log4cpp library for logging in gnuradio
 *******************************************************************************/
 
 #ifndef INCLUDED_GR_LOGGER_H
@@ -33,18 +32,30 @@
 /*!
 * \file gr_logger.h
 * \ingroup logging
-* \brief GNURADIO logging wrapper for log4cxx library (C++ port of log4j)
+* \brief GNURADIO logging wrapper for log4cpp library (C++ port of log4j)
 *
 */
 
+#ifndef ENABLE_GR_LOG
+#include "config.h"
+//#define GR_LOG_CONFIG_H
+#endif
+
 #include <gr_core_api.h>
 #include <assert.h>
 #include <iostream>
 
+//#ifndef ENABLE_GR_LOG
+//#define ENABLE_GR_LOG 1
+//#endif
+//#ifndef HAVE_LOG4CPP
+//#define HAVE_LOG4CPP 2
+//#endif
+
 #ifdef ENABLE_GR_LOG
 
 // We have three configurations... first logging to stdout/stderr
-#ifndef HAVE_LOG4CXX
+#ifndef HAVE_LOG4CPP
 //#warning GR logging Enabled and using std::cout
 
 typedef std::string gr_logger_ptr;
@@ -52,69 +63,70 @@ typedef std::string gr_logger_ptr;
 #define GR_LOG_DECLARE_LOGPTR(logger)
 #define GR_LOG_ASSIGN_LOGPTR(logger,name)
 #define GR_CONFIG_LOGGER(config)
-#define GR_CONFIG_AND_WATCH_LOGGER(config)
+#define GR_CONFIG_AND_WATCH_LOGGER(config,period)
 #define GR_LOG_GETLOGGER(logger, name) 
 #define GR_SET_LEVEL(name, level)
 #define GR_LOG_SET_LEVEL(logger, level) 
 #define GR_GET_LEVEL(name, level)
 #define GR_LOG_GET_LEVEL(logger, level)
-#define GR_ADD_CONSOLE_APPENDER(logger,layout)
-#define GR_LOG_ADD_CONSOLE_APPENDER(logger,layout)
-#define GR_ADD_FILE_APPENDER(logger,layout,filename,append)
-#define GR_LOG_ADD_FILE_APPENDER(logger,layout,filename,append)
-#define GR_ADD_ROLLINGFILE_APPENDER(logger,layout,filename,append,bkup_index,filesize)
-#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,layout,filename,append,bkup_index,filesize)
+#define GR_ADD_CONSOLE_APPENDER(logger,target,pattern)
+#define GR_LOG_ADD_CONSOLE_APPENDER(logger,target,pattern)
+#define GR_ADD_FILE_APPENDER(name,filename,append,pattern)
+#define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern)
+#define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern)
+#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern)
 #define GR_GET_LOGGER_NAMES(names)
 #define GR_RESET_CONFIGURATION()
-#define GR_TRACE(name, msg) std::cout<<"TRACE:"<<msg<<std::endl
-#define GR_DEBUG(name, msg) std::cout<<"DEBUG:"<<msg<<std::endl
-#define GR_INFO(name, msg) std::cout<<"INFO:"<<msg<<std::endl
-#define GR_WARN(name, msg) std::cerr<<"WARN:"<<msg<<std::endl
-#define GR_ERROR(name, msg) std::cerr<<"ERROR:"<<msg<<std::endl
-#define GR_FATAL(name, msg) std::cerr<<"FATAL:"<<msg<<std::endl
-#define GR_ERRORIF(name, cond, msg) if((cond)) std::cerr<<"ERROR:"<<msg<<std::endl
-#define GR_ASSERT(name, cond, msg) std::cerr<<"ERROR:"<<msg<<std::endl; assert(cond)
-#define GR_LOG_SET_LEVEL(logger, level)
-#define GR_LOG_GET_LEVEL(logger, level)
-#define GR_LOG_TRACE(logger, msg) std::cout<<"TRACE:"<<msg<<std::endl
-#define GR_LOG_DEBUG(logger, msg) std::cout<<"DEBUG:"<<msg<<std::endl
-#define GR_LOG_INFO(logger, msg) std::cout<<"INFO:"<<msg<<std::endl
-#define GR_LOG_WARN(logger, msg) std::cerr<<"WARN:"<<msg<<std::endl
-#define GR_LOG_ERROR(logger, msg) std::cerr<<"ERROR:"<<msg<<std::endl
-#define GR_LOG_FATAL(logger, msg) std::cerr<<"FATAL:"<<msg<<std::endl
-#define GR_LOG_ERRORIF(logger, cond, msg) if((cond)) std::cerr<<"ERROR:"<<msg<<std::endl
-#define GR_LOG_ASSERT(logger, cond, msg) std::cerr<<"ERROR:"<<msg<<std::endl; assert(cond)
-
-#else /* HAVE_LOG4CXX */
-// Second configuration...logging to log4cxx
-//#warning GR logging Enabled and using LOG4CXX
-
-#include <log4cxx/logger.h>
-#include <log4cxx/logmanager.h>
-#include <log4cxx/basicconfigurator.h>
-#include <log4cxx/xml/domconfigurator.h>
-#include <log4cxx/propertyconfigurator.h>
-#include <log4cxx/helpers/pool.h>
-#include <log4cxx/fileappender.h>
-#include <log4cxx/rollingfileappender.h>
-#include <log4cxx/consoleappender.h>
-#include <log4cxx/patternlayout.h>
+#define GR_DEBUG(name, msg) std::cout<<"DEBUG: "<<msg<<std::endl
+#define GR_INFO(name, msg) std::cout<<"INFO: "<<msg<<std::endl
+#define GR_NOTICE(name, msg) std::cout<<"NOTICE: "<<msg<<std::endl
+#define GR_WARN(name, msg) std::cerr<<"WARN: "<<msg<<std::endl
+#define GR_ERROR(name, msg) std::cerr<<"ERROR: "<<msg<<std::endl
+#define GR_ALERT(name, msg) std::cerr<<"ERROR: "<<msg<<std::endl
+#define GR_CRIT(name, msg) std::cerr<<"ERROR: "<<msg<<std::endl
+#define GR_FATAL(name, msg) std::cerr<<"FATAL: "<<msg<<std::endl
+#define GR_EMERG(name, msg) std::cerr<<"EMERG: "<<msg<<std::endl
+#define GR_ERRORIF(name, cond, msg) if((cond)) std::cerr<<"ERROR: "<<msg<<std::endl
+#define GR_ASSERT(name, cond, msg) if(!(cond)) std::cerr<<"ERROR: "<<msg<<std::endl; assert(cond)
+#define GR_LOG_DEBUG(logger, msg) std::cout<<"DEBUG: "<<msg<<std::endl
+#define GR_LOG_INFO(logger, msg) std::cout<<"INFO: "<<msg<<std::endl
+#define GR_LOG_NOTICE(logger, msg) std::cout<<"NOTICE: "<<msg<<std::endl
+#define GR_LOG_WARN(logger, msg) std::cerr<<"WARN: "<<msg<<std::endl
+#define GR_LOG_ERROR(logger, msg) std::cerr<<"ERROR: "<<msg<<std::endl
+#define GR_LOG_ALERT(logger, msg) std::cerr<<"ALERT: "<<msg<<std::endl
+#define GR_LOG_CRIT(logger, msg) std::cerr<<"CRIT: "<<msg<<std::endl
+#define GR_LOG_FATAL(logger, msg) std::cerr<<"FATAL: "<<msg<<std::endl
+#define GR_LOG_EMERG(logger, msg) std::cerr<<"EMERG: "<<msg<<std::endl
+#define GR_LOG_ERRORIF(logger, cond, msg) if((cond)) std::cerr<<"ERROR: "<<msg<<std::endl
+#define GR_LOG_ASSERT(logger, cond, msg) std::cerr<<"ERROR: "<<msg<<std::endl; assert(cond)
+
+#else /* HAVE_LOG4CPP */
+// Second configuration...logging to log4cpp
+
+#include <log4cpp/Category.hh>
+#include <log4cpp/PropertyConfigurator.hh>
+#include <log4cpp/FileAppender.hh>
+#include <log4cpp/RollingFileAppender.hh>
+#include <log4cpp/OstreamAppender.hh>
+#include <log4cpp/PatternLayout.hh>
 
 /*!
  * \brief GR_LOG macros
  * \ingroup logging
  *
- * These macros wrap the standard LOG4CXX_LEVEL macros.  The availablie macros
+ * These macros wrap the standard LOG4CPP_LEVEL macros.  The availablie macros
  * are:
- *  GR_LOG_TRACE
  *  GR_LOG_DEBUG
  *  GR_LOG_INFO
  *  GR_LOG_WARN
+ *  GR_LOG_TRACE
  *  GR_LOG_ERROR
+ *  GR_LOG_ALERT
+ *  GR_LOG_CRIT
  *  GR_LOG_FATAL
+ *  GR_LOG_EMERG
  */
-
-typedef log4cxx::LoggerPtr gr_logger_ptr;
+typedef log4cpp::Category* gr_logger_ptr;
 
 /* Macros for Programmatic Configuration */
 #define GR_LOG_DECLARE_LOGPTR(logger) \
@@ -130,42 +142,42 @@ typedef log4cxx::LoggerPtr gr_logger_ptr;
   logger_load_config_and_watch(config,period)
 
 #define GR_LOG_GETLOGGER(logger, name) \
-  log4cxx::LoggerPtr logger = gr_logger::getLogger(name);
+  gr_logger_ptr logger = gr_logger::getLogger(name);
 
 #define GR_SET_LEVEL(name, level){ \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  logger_set_level(logger, level);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  logger_set_level(logger,level);}
 
 #define GR_LOG_SET_LEVEL(logger, level) \
   logger_set_level(logger, level);
 
 #define GR_GET_LEVEL(name, level){ \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
   logger_get_level(logger,level);}
 
 #define GR_LOG_GET_LEVEL(logger, level) \
   logger_get_level(logger,level);
 
-#define GR_ADD_CONSOLE_APPENDER(name,layout,terget){d      \
-  gr_logger_ptr logger = log4cxx::Logger::getLogger(name); \
-  logger_add_console_appender(logger,layout, target);}
+#define GR_ADD_CONSOLE_APPENDER(name,target,pattern){\
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  logger_add_console_appender(logger,target,pattern);}
 
-#define GR_LOG_ADD_CONSOLE_APPENDER(logger,layout,target){      \
-  logger_add_console_appender(logger,layout,target);}
+#define GR_LOG_ADD_CONSOLE_APPENDER(logger,target,pattern){\
+  logger_add_console_appender(logger,target,pattern);}
 
-#define GR_ADD_FILE_APPENDER(name,layout,filename,append){\
-  gr_logger_ptr logger = log4cxx::Logger::getLogger(name); \
-  logger_add_file_appender(logger,layout,filename,append);}
+#define GR_ADD_FILE_APPENDER(name,filename,append,pattern){\
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  logger_add_file_appender(logger,filename,append,pattern);}
 
-#define GR_LOG_ADD_FILE_APPENDER(logger,layout,filename,append){\
-  logger_add_file_appender(logger,layout,filename,append);}
+#define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern){\
+  logger_add_file_appender(logger,filename,append,pattern);}
 
-#define GR_ADD_ROLLINGFILE_APPENDER(name,layout,filename,append,bkup_index,filesize){\
-  gr_logger_ptr logger = log4cxx::Logger::getLogger(name); \
-  logger_add_rollingfile_appender(logger,layout,filename,append,bkup_index,filesize);}
+#define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern){\
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  logger_add_rollingfile_appender(logger,filename,filesize,bkup_index,append,mode,pattern);}
 
-#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,layout,filename,append,bkup_index,filesize){\
-  logger_add_rollingfile_appender(logger,layout,filename,append,bkup_index,filesize);}
+#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern){\
+  logger_add_rollingfile_appender(logger,filename,filesize,bkup_index,append,mode,pattern);}
 
 #define GR_GET_LOGGER_NAMES(names){ \
   logger_get_logger_names(names);}
@@ -174,64 +186,94 @@ typedef log4cxx::LoggerPtr gr_logger_ptr;
   logger_reset_config();}
 
 /* Logger name referenced macros */
-#define GR_TRACE(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_TRACE(logger, msg);}
-
 #define GR_DEBUG(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_DEBUG(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::DEBUG << msg << log4cpp::eol;}
 
 #define GR_INFO(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_INFO(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::INFO << msg << log4cpp::eol;}
+
+#define GR_NOTICE(name, msg) { \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger << log4cpp::Priority::NOTICE << msg;}
 
 #define GR_WARN(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_WARN(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::WARN << msg << log4cpp::eol;}
 
 #define GR_ERROR(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_ERROR(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;}
+
+#define GR_CRIT(name, msg) { \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::CRIT << msg << log4cpp::eol;}
+
+#define GR_ALERT(name, msg) { \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::ALERT << msg << log4cpp::eol;}
 
 #define GR_FATAL(name, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_FATAL(logger, msg);}
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::FATAL << msg << log4cpp::eol;}
+
+#define GR_EMERG(name, msg) { \
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;}
 
 #define GR_ERRORIF(name, cond, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_ASSERT(logger, !(cond), msg);}
+if((cond)){\
+  gr_logger_ptr logger = gr_logger::getLogger(name);\
+  *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;};\
+};
 
 #define GR_ASSERT(name, cond, msg) { \
-  log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name); \
-  LOG4CXX_ASSERT(logger, (cond), msg); \
-  assert((cond));}
+if((!cond)){\
+    gr_logger_ptr logger = gr_logger::getLogger(name);\
+    *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;};\
+    assert(0);\
+};
 
 /* LoggerPtr Referenced Macros */
-#define GR_LOG_TRACE(logger, msg) { \
-  LOG4CXX_TRACE(logger, msg);}
-
 #define GR_LOG_DEBUG(logger, msg) { \
-  LOG4CXX_DEBUG(logger, msg);}
+  *logger << log4cpp::Priority::DEBUG << msg << log4cpp::eol;}
 
 #define GR_LOG_INFO(logger, msg) { \
-  LOG4CXX_INFO(logger, msg);}
+  *logger << log4cpp::Priority::INFO << msg << log4cpp::eol;}
+
+#define GR_LOG_NOTICE(logger, msg) { \
+  *logger << log4cpp::Priority::NOTICE << msg << log4cpp::eol;}
 
 #define GR_LOG_WARN(logger, msg) { \
-  LOG4CXX_WARN(logger, msg);}
+  *logger << log4cpp::Priority::WARN << msg << log4cpp::eol;}
 
 #define GR_LOG_ERROR(logger, msg) { \
-  LOG4CXX_ERROR(logger, msg);}
+  *logger << log4cpp::Priority::ERROR << msg << log4cpp::eol;}
+
+#define GR_LOG_CRIT(logger, msg) { \
+  *logger << log4cpp::Priority::CRIT << msg << log4cpp::eol;}
+
+#define GR_LOG_ALERT(logger, msg) { \
+  *logger << log4cpp::Priority::ALERT << msg << log4cpp::eol;}
 
 #define GR_LOG_FATAL(logger, msg) { \
-  LOG4CXX_FATAL(logger, msg);}
+  *logger << log4cpp::Priority::FATAL << msg << log4cpp::eol;}
+
+#define GR_LOG_EMERG(logger, msg) { \
+  *logger << log4cpp::Priority::EMERG << msg << log4cpp::eol;}
 
 #define GR_LOG_ERRORIF(logger,cond, msg) { \
-  LOG4CXX_ASSERT(logger, !(cond), msg);}
+if((!cond)){\
+    *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;};\
+    assert(0);\
+};
 
 #define GR_LOG_ASSERT(logger, cond, msg) { \
-  LOG4CXX_ASSERT(logger, (cond), msg); \
-  assert((cond));}
+if((!cond)){\
+    *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;};\
+    assert(0);\
+};
 
 /*!
  * \brief Load logger's configuration file.
@@ -256,14 +298,16 @@ GR_CORE_API void logger_reset_config(void);
  * Sets the level of the logger. This takes a string that is
  * translated to the standard levels and can be (case insensitive):
  *
- * \li off
- * \li all
- * \li trace
+ * \li off , notset
  * \li debug
  * \li info
+ * \li notice
  * \li warn
  * \li error
+ * \li crit
+ * \li alert
  * \li fatal
+ * \li emerg
  *
  * \param logger the logger to set the level of.
  * \param level  string to set the level to.
@@ -273,22 +317,24 @@ GR_CORE_API void logger_set_level(gr_logger_ptr logger, const std::string &level
 /*!
  * \brief Set the logger's output level.
  *
- * Sets the level of the logger. This takes the actual Log4cxx::Level
+ * Sets the level of the logger. This takes the actual Log4cpp::Priority
  * data type, which can be:
  *
- * \li log4cxx::Level::getOff()
- * \li log4cxx::Level::getAll()
- * \li log4cxx::Level::getTrace()
- * \li log4cxx::Level::getDebug()
- * \li log4cxx::Level::getInfo()
- * \li log4cxx::Level::getWarn()
- * \li log4cxx::Level::getError()
- * \li log4cxx::Level::getFatal()
+ * \li log4cpp::Priority::NOTSET
+ * \li log4cpp::Priority::DEBUG
+ * \li log4cpp::Priority::INFO
+ * \li log4cpp::Priority::NOTICE
+ * \li log4cpp::Priority::WARN
+ * \li log4cpp::Priority::ERROR
+ * \li log4cpp::Priority::CRIT
+ * \li log4cpp::Priority::ALERT
+ * \li log4cpp::Priority::FATAL
+ * \li log4cpp::Priority::EMERG
  *
  * \param logger the logger to set the level of.
- * \param level  new logger level of type Log4cxx::Level
+ * \param level  new logger level of type Log4cpp::Priority
  */
-GR_CORE_API void logger_set_level(gr_logger_ptr logger, log4cxx::LevelPtr level);
+void logger_set_level(gr_logger_ptr logger, log4cpp::Priority::Value level);
 
 
 /*!
@@ -297,14 +343,16 @@ GR_CORE_API void logger_set_level(gr_logger_ptr logger, log4cxx::LevelPtr level)
  * Gets the level of the logger. This returns a string that
  * corresponds to the standard levels and can be (case insensitive):
  *
- * \li off
- * \li all
- * \li trace
+ * \li notset
  * \li debug
  * \li info
+ * \li notice
  * \li warn
  * \li error
+ * \li crit
+ * \li alert
  * \li fatal
+ * \li emerg
  *
  * \param logger the logger to get the level of.
  * \param level  string to get the level into.
@@ -314,32 +362,31 @@ GR_CORE_API void logger_get_level(gr_logger_ptr logger, std::string &level);
 /*!
  * \brief Get the logger's output level.
  *
- * Gets the level of the logger. This returns the actual Log4cxx::Level
+ * Gets the level of the logger. This returns the actual Log4cpp::Level
  * data type, which can be:
  *
- * \li log4cxx::Level::getOff()
- * \li log4cxx::Level::getAll()
- * \li log4cxx::Level::getTrace()
- * \li log4cxx::Level::getDebug()
- * \li log4cxx::Level::getInfo()
- * \li log4cxx::Level::getWarn()
- * \li log4cxx::Level::getError()
- * \li log4cxx::Level::getFatal()
+ * \li log4cpp::Priority::NOTSET
+ * \li log4cpp::Priority::DEBUG
+ * \li log4cpp::Priority::INFO
+ * \li log4cpp::Priority::NOTICE
+ * \li log4cpp::Priority::WARN
+ * \li log4cpp::Priority::ERROR
+ * \li log4cpp::Priority::CRIT
+ * \li log4cpp::Priority::ALERT
+ * \li log4cpp::Priority::FATAL
+ * \li log4cpp::Priority::EMERG
  *
  * \param logger the logger to get the level of.
+ * \param level of the logger.
  */
-GR_CORE_API void logger_get_level(gr_logger_ptr logger, log4cxx::LevelPtr level);
+GR_CORE_API void logger_get_level(gr_logger_ptr logger, log4cpp::Priority::Value &level);
 
+GR_CORE_API void logger_add_console_appender(gr_logger_ptr logger,std::string target,std::string pattern);
 
-GR_CORE_API void logger_add_console_appender(gr_logger_ptr logger, std::string layout,
-                                             std::string target);
+GR_CORE_API void logger_add_file_appender(gr_logger_ptr logger,std::string filename,bool append,std::string pattern);
 
-GR_CORE_API void logger_add_file_appender(gr_logger_ptr logger, std::string layout,
-                                          std::string filename, bool append);
-
-GR_CORE_API void logger_add_rollingfile_appender(gr_logger_ptr logger, std::string layout,
-                                                 std::string filename, bool append,
-                                                 int bkup_index, std::string filesize);
+GR_CORE_API void logger_add_rollingfile_appender(gr_logger_ptr logger,std::string filename,
+                    size_t filesize,int bkup_index,bool append,mode_t mode,std::string pattern);
 
 GR_CORE_API void logger_get_logger_names(std::vector<std::string>& names);
 
@@ -366,25 +413,22 @@ class gr_logger
   gr_logger(std::string config_filename, int watchPeriodSec)
   {
     // Load configuration file
-    if(config_filename.find(".xml")!=std::string::npos) {
-      log4cxx::xml::DOMConfigurator::configureAndWatch(config_filename, watchPeriodSec);
-    }
-    else {
-      log4cxx::PropertyConfigurator::configureAndWatch(config_filename, watchPeriodSec);
-    }
+    logger_load_config_and_watch(config_filename,watchPeriodSec);
+
   };
 
-  static log4cxx::LoggerPtr getLogger(std::string name)
+  static gr_logger_ptr getLogger(std::string name)
   {
-    if(log4cxx::LogManager::exists(name)) {
-      log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name);
-      return logger;
-    }
-    else {
-      log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger(name);
-      logger->setLevel(log4cxx::Level::getOff());
-      return logger;
-    };
+      if(log4cpp::Category::exists(name)){
+        gr_logger_ptr logger = &log4cpp::Category::getInstance(name);
+        return logger;
+      }
+      else
+      {
+        gr_logger_ptr logger = &log4cpp::Category::getInstance(name);
+        logger->setPriority(log4cpp::Priority::NOTSET);
+        return logger;
+      };
   };
 
   // Wrappers for logging macros
@@ -394,64 +438,82 @@ class gr_logger
   /*! \brief inline function, wrapper to get the logger level */
   void get_level(std::string name,std::string &level){GR_GET_LEVEL(name,level);}
 
-  /*! \brief inline function, wrapper for LOG4CXX_TRACE for TRACE message */
-  void trace(std::string name,std::string msg){GR_TRACE(name,msg);};
-
-  /*! \brief inline function, wrapper for LOG4CXX_DEBUG for DEBUG message */
+  /*! \brief inline function, wrapper for DEBUG message */
   void debug(std::string name,std::string msg){GR_DEBUG(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_INFO for INFO message */
+  /*! \brief inline function, wrapper for INFO message */
   void info(std::string name,std::string msg){GR_INFO(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_WARN for WARN message */
+  /*! \brief inline function, wrapper for NOTICE message */
+  void notice(std::string name,std::string msg){GR_NOTICE(name,msg);};
+
+  /*! \brief inline function, wrapper for WARN message */
   void warn(std::string name,std::string msg){GR_WARN(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_ERROR for ERROR message */
+  /*! \brief inline function, wrapper for ERROR message */
   void error(std::string name,std::string msg){GR_ERROR(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_FATAL for FATAL message */
+  /*! \brief inline function, wrapper for CRIT message */
+  void crit(std::string name,std::string msg){GR_CRIT(name,msg);};
+
+  /*! \brief inline function, wrapper for ALERT message */
+  void alert(std::string name,std::string msg){GR_ALERT(name,msg);};
+
+  /*! \brief inline function, wrapper for FATAL message */
   void fatal(std::string name,std::string msg){GR_FATAL(name,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_ASSERT for conditional ERROR message */
+  /*! \brief inline function, wrapper for EMERG message */
+  void emerg(std::string name,std::string msg){GR_EMERG(name,msg);};
+
+  /*! \brief inline function, wrapper for LOG4CPP_ASSERT for conditional ERROR message */
   void errorIF(std::string name,bool cond,std::string msg){GR_ERRORIF(name,cond,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_ASSERT for conditional ERROR message */
+  /*! \brief inline function, wrapper for LOG4CPP_ASSERT for conditional ERROR message */
   void gr_assert(std::string name,bool cond,std::string msg){GR_ASSERT(name,cond,msg);};
 
   // Wrappers for Logger Pointer referenced functions
   /*! \brief inline function, wrapper to set the logger level */
-  void set_log_level(log4cxx::LoggerPtr logger,std::string level){GR_LOG_SET_LEVEL(logger,level);}
+  void set_log_level(gr_logger_ptr logger,std::string level){GR_LOG_SET_LEVEL(logger,level);}
 
   /*! \brief inline function, wrapper to get the logger level */
-  void get_log_level(log4cxx::LoggerPtr logger,std::string &level){GR_LOG_GET_LEVEL(logger,level);}
+  void get_log_level(gr_logger_ptr logger,std::string &level){GR_LOG_GET_LEVEL(logger,level);}
+
+  /*! \brief inline function, wrapper for LOG4CPP_DEBUG for DEBUG message */
+  void log_debug(gr_logger_ptr logger,std::string msg){GR_LOG_DEBUG(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_TRACE for TRACE message */
-  void log_trace(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_TRACE(logger,msg);};
+  /*! \brief inline function, wrapper for LOG4CPP_INFO for INFO message */
+  void log_info(gr_logger_ptr logger,std::string msg){GR_LOG_INFO(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_DEBUG for DEBUG message */
-  void log_debug(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_DEBUG(logger,msg);};
+  /*! \brief inline function, wrapper for NOTICE message */
+  void log_notice(gr_logger_ptr logger,std::string msg){GR_LOG_NOTICE(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_INFO for INFO message */
-  void log_info(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_INFO(logger,msg);};
+  /*! \brief inline function, wrapper for LOG4CPP_WARN for WARN message */
+  void log_warn(gr_logger_ptr logger,std::string msg){GR_LOG_WARN(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_WARN for WARN message */
-  void log_warn(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_WARN(logger,msg);};
+  /*! \brief inline function, wrapper for LOG4CPP_ERROR for ERROR message */
+  void log_error(gr_logger_ptr logger,std::string msg){GR_LOG_ERROR(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_ERROR for ERROR message */
-  void log_error(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_ERROR(logger,msg);};
+  /*! \brief inline function, wrapper for NOTICE message */
+  void log_crit(gr_logger_ptr logger,std::string msg){GR_LOG_CRIT(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_FATAL for FATAL message */
-  void log_fatal(log4cxx::LoggerPtr logger,std::string msg){GR_LOG_FATAL(logger,msg);};
+  /*! \brief inline function, wrapper for ALERT message */
+  void log_alert(gr_logger_ptr logger,std::string msg){GR_LOG_ALERT(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_ASSERT for conditional ERROR message */
-  void log_errorIF(log4cxx::LoggerPtr logger,bool cond,std::string msg){GR_LOG_ERRORIF(logger,cond,msg);};
+  /*! \brief inline function, wrapper for FATAL message */
+  void log_fatal(gr_logger_ptr logger,std::string msg){GR_LOG_FATAL(logger,msg);};
 
-  /*! \brief inline function, wrapper for LOG4CXX_ASSERT for conditional ERROR message */
-  void log_assert(log4cxx::LoggerPtr logger,bool cond,std::string msg){GR_LOG_ASSERT(logger,cond,msg);};
+  /*! \brief inline function, wrapper for EMERG message */
+  void log_emerg(gr_logger_ptr logger,std::string msg){GR_LOG_EMERG(logger,msg);};
+
+  /*! \brief inline function, wrapper for LOG4CPP_ASSERT for conditional ERROR message */
+  void log_errorIF(gr_logger_ptr logger,bool cond,std::string msg){GR_LOG_ERRORIF(logger,cond,msg);};
+
+  /*! \brief inline function, wrapper for LOG4CPP_ASSERT for conditional ERROR message */
+  void log_assert(gr_logger_ptr logger,bool cond,std::string msg){GR_LOG_ASSERT(logger,cond,msg);};
 };
 
 
-#endif /* HAVE_LOG4CXX */
+#endif /* HAVE_LOG4CPP */
 
 // If Logger disable do nothing
 #else /* ENABLE_GR_LOG */
@@ -461,36 +523,40 @@ typedef void* gr_logger_ptr;
 #define GR_LOG_DECLARE_LOGPTR(logger)
 #define GR_LOG_ASSIGN_LOGPTR(logger,name)
 #define GR_CONFIG_LOGGER(config)
-#define GR_CONFIG_AND_WATCH_LOGGER(config)
+#define GR_CONFIG_AND_WATCH_LOGGER(config,period)
 #define GR_LOG_GETLOGGER(logger, name) 
 #define GR_SET_LEVEL(name, level)
 #define GR_LOG_SET_LEVEL(logger, level) 
 #define GR_GET_LEVEL(name, level)
 #define GR_LOG_GET_LEVEL(logger, level)
-#define GR_ADD_CONSOLE_APPENDER(logger,layout)
-#define GR_LOG_ADD_CONSOLE_APPENDER(logger,layout)
-#define GR_ADD_FILE_APPENDER(logger,layout,filename,append)
-#define GR_LOG_ADD_FILE_APPENDER(logger,layout)
-#define GR_ADD_ROLLINGFILE_APPENDER(logger,layout,filename,append,bkup_index,filesize)
-#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,layout)
+#define GR_ADD_CONSOLE_APPENDER(logger,target,pattern)
+#define GR_LOG_ADD_CONSOLE_APPENDER(logger,,target,pattern)
+#define GR_ADD_FILE_APPENDER(name,filename,append,pattern)
+#define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern)
+#define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern)
+#define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern)
 #define GR_GET_LOGGER_NAMES(names)
 #define GR_RESET_CONFIGURATION()
-#define GR_TRACE(name, msg)
 #define GR_DEBUG(name, msg)
 #define GR_INFO(name, msg)
-#define GR_WARN(name, msg) 
-#define GR_ERROR(name, msg) 
-#define GR_FATAL(name, msg) 
+#define GR_NOTICE(name, msg)
+#define GR_WARN(name, msg)
+#define GR_ERROR(name, msg)
+#define GR_ALERT(name, msg)
+#define GR_CRIT(name, msg)
+#define GR_FATAL(name, msg)
+#define GR_EMERG(name, msg)
 #define GR_ERRORIF(name, cond, msg)
 #define GR_ASSERT(name, cond, msg)
-#define GR_LOG_SET_LEVEL(logger, level)
-#define GR_LOG_GET_LEVEL(logger, level)
-#define GR_LOG_TRACE(logger, msg)
 #define GR_LOG_DEBUG(logger, msg)
-#define GR_LOG_INFO(logger, msg) 
-#define GR_LOG_WARN(logger, msg) 
-#define GR_LOG_ERROR(logger, msg) 
-#define GR_LOG_FATAL(logger, msg) 
+#define GR_LOG_INFO(logger, msg)
+#define GR_LOG_NOTICE(logger, msg)
+#define GR_LOG_WARN(logger, msg)
+#define GR_LOG_ERROR(logger, msg)
+#define GR_LOG_ALERT(logger, msg)
+#define GR_LOG_CRIT(logger, msg)
+#define GR_LOG_FATAL(logger, msg)
+#define GR_LOG_EMERG(logger, msg)
 #define GR_LOG_ERRORIF(logger, cond, msg)
 #define GR_LOG_ASSERT(logger, cond, msg)
 
diff --git a/gnuradio-core/src/lib/runtime/gr_logger.i b/gnuradio-core/src/lib/runtime/gr_logger.i
index 1eedf3d60d..70e50e02b3 100644
--- a/gnuradio-core/src/lib/runtime/gr_logger.i
+++ b/gnuradio-core/src/lib/runtime/gr_logger.i
@@ -23,7 +23,7 @@
 * Copyright 2011 Johns Hopkins University Applied Physics Lab
 * Author: Mark Plett
 * Description:
-*   SWIG interface generator file for gr_logger module.  gr_logger wraps log4cxx logging
+*   SWIG interface generator file for gr_logger module.  gr_logger wraps log4cpp logging
 *   for gnuradio.
 *******************************************************************************/
 
@@ -40,23 +40,22 @@
 //-----------------------------------
 
 #ifdef ENABLE_GR_LOG
-#ifdef HAVE_LOG4CXX
+#ifdef HAVE_LOG4CPP
 
 %{
 // The .h files
 #include <gr_logger.h>
-#include <log4cxx/logger.h>
-#include <log4cxx/logmanager.h>
+#include <log4cpp/Category.hh>
 %}
 
-namespace log4cxx{
+namespace log4cpp{
 class LoggerPtr {
 public:
  ~LoggerPtr();
 };
 };
 void logger_load_config(const std::string &config_filename);
-void logger_set_level(log4cxx::LoggerPtr logger, const std::string &level);
+void logger_set_level(log4cpp::LoggerPtr logger, const std::string &level);
 
 %rename(log) gr_logger;
 
@@ -69,28 +68,42 @@ public:
   gr_logger(std::string config_filename,int watchPeriodSec);
   void set_level(std::string name,std::string level);
   void get_level(std::string name,std::string &level);
-  void trace(std::string name,std::string msg);
+  void add_console_appender(std::string name,std::string target,std::string pattern);
+  void add_file_appender(std::string name,std::string filename,bool append,std::string patter);
+  void add_rollingfile_appender(std::string name,std::string filename,size_t filesize,int bkup_indx,bool append,mode_t mode,std::string pattern);
+
+  void notice(std::string name,std::string msg);
   void debug(std::string name,std::string msg);
   void info(std::string name,std::string msg);
   void warn(std::string name,std::string msg);
   void error(std::string name,std::string msg);
-  void fatal(std::string name,std::string msg);
+  void emerg(std::string name,std::string msg);
+  void crit(std::string name,std::string msg);
   void errorIF(std::string name,bool cond,std::string msg);
   void gr_assert(std::string name,bool cond,std::string msg);
 
-  static log4cxx::LoggerPtr getLogger(std::string name);
-
-  void set_log_level(log4cxx::LoggerPtr logger,std::string level);
-  void get_log_level(log4cxx::LoggerPtr logger,std::string &level);
-  void log_trace(log4cxx::LoggerPtr logger,std::string msg);
-  void log_debug(log4cxx::LoggerPtr logger,std::string msg);
-  void log_info(log4cxx::LoggerPtr logger,std::string msg);
-  void log_warn(log4cxx::LoggerPtr logger,std::string msg);
-  void log_error(log4cxx::LoggerPtr logger,std::string msg);
-  void log_fatal(log4cxx::LoggerPtr logger,std::string msg);
-  void log_errorIF(log4cxx::LoggerPtr logger,bool cond,std::string msg);
-  void log_assert(log4cxx::LoggerPtr logger,bool cond,std::string msg);
+  static gr_logger_ptr getLogger(std::string name);
+
+  void log_set_level(gr_logger_ptr logger,std::string level);
+  void log_get_level(gr_logger_ptr logger,std::string &level);
+  void log_add_console_appender(gr_logger_ptr logger,std::string target,std::string pattern);
+  void log_add_file_appender(gr_logger_ptr logger,std::string filename,bool append,std::string pattern);
+  void log_add_rollingfile_appender(gr_logger_ptr logger,std::string filename,size_t filesize,int bkup_index,bool append,mode_t mode,std::string pattern);
+
+  void log_notice(gr_logger_ptr logger,std::string msg);
+  void log_debug(gr_logger_ptr logger,std::string msg);
+  void log_info(gr_logger_ptr logger,std::string msg);
+  void log_warn(gr_logger_ptr logger,std::string msg);
+  void log_error(gr_logger_ptr logger,std::string msg);
+  void log_crit(gr_logger_ptr logger,std::string msg);
+  void log_emerg(gr_logger_ptr logger,std::string msg);
+  void log_errorIF(gr_logger_ptr logger,bool cond,std::string msg);
+  void log_assert(gr_logger_ptr logger,bool cond,std::string msg);
+
+  void get_logger_names(std::vector<std::string>& names);
+  void reset_configuration();
+
 };
 
-#endif /* HAVE_LOG4CXX */
+#endif /* HAVE_LOG4CPP */
 #endif /* ENABLE_GR_LOG */
diff --git a/gnuradio-core/src/lib/runtime/qa_gr_logger.cc b/gnuradio-core/src/lib/runtime/qa_gr_logger.cc
index 3d21c1f305..a8e4a1d766 100644
--- a/gnuradio-core/src/lib/runtime/qa_gr_logger.cc
+++ b/gnuradio-core/src/lib/runtime/qa_gr_logger.cc
@@ -38,14 +38,15 @@ qa_gr_logger::t1()
 #ifdef ENABLE_GR_LOG
   // This doesn't really test anything, more just
   // making sure nothing's gone horribly wrong.
-  GR_LOG_GETLOGGER(LOG,"errLoggerRoot");
-  GR_LOG_TRACE(LOG,"test from c++ 1");
-  GR_LOG_DEBUG(LOG,"test from c++ 1");
-  GR_LOG_INFO(LOG,"test from c++ 1");
-  GR_LOG_WARN(LOG,"test from c++ 1");
-  GR_LOG_ERROR(LOG,"test from c++ 1");
-  GR_LOG_FATAL(LOG,"test from c++ 1");
-  GR_LOG_ERRORIF(LOG,2>1,"test from c++ 1");
+
+  GR_LOG_GETLOGGER(LOG,"main");
+  GR_ADD_CONSOLE_APPENDER("main","cout","%d{%H:%M:%S} : %m%n");
+  GR_LOG_NOTICE(LOG,"test from c++ NOTICE");
+  GR_LOG_DEBUG(LOG,"test from c++ DEBUG");
+  GR_LOG_INFO(LOG,"test from c++ INFO");
+  GR_LOG_WARN(LOG,"test from c++ WARN");
+  GR_LOG_ERROR(LOG,"test from c++ ERROR");
+  GR_LOG_FATAL(LOG,"test from c++ FATAL");
   CPPUNIT_ASSERT(true);
 #endif
 }
diff --git a/gnuradio-core/src/lib/swig/CMakeLists.txt b/gnuradio-core/src/lib/swig/CMakeLists.txt
index 1be70f5c8f..2132e2ca09 100644
--- a/gnuradio-core/src/lib/swig/CMakeLists.txt
+++ b/gnuradio-core/src/lib/swig/CMakeLists.txt
@@ -25,15 +25,15 @@ set(GR_SWIG_INCLUDE_DIRS
     ${CMAKE_CURRENT_BINARY_DIR}
     ${GNURADIO_CORE_SWIG_INCLUDE_DIRS}
     ${GRUEL_INCLUDE_DIRS}
-    ${LOG4CXX_INCLUDE_DIRS}
+    ${LOG4CPP_INCLUDE_DIRS}
     ${Boost_INCLUDE_DIRS}
 )
 set(GR_SWIG_LIBRARIES
     gnuradio-core
-    ${LOG4CXX_LIBRARIES}
+    ${LOG4CPP_LIBRARIES}
 )
 
-# Only use if log4cxx is installed
+# Only use if log4cpp is installed
 # Define ENABLE_GR_LOG for the .i file to ignore it.
 if(ENABLE_GR_LOG)
      SET(GR_SWIG_FLAGS "-DENABLE_GR_LOG")
author	Tom Rondeau <trondeau@vt.edu>	2013-03-13 18:02:42 -0400
committer	Tom Rondeau <trondeau@vt.edu>	2013-03-13 18:02:42 -0400
commit	1c9d67fc220737873728310bd679d9e9cfab470a (patch)
tree	5fbf8c157da3e938d9b90ebe720f3efbcef39215 /gnuradio-core/src/lib
parent	1d8d1f111c41862d877686a89344a4a74f146cee (diff)
parent	1bacc04f7a8f2f9c868a9934624683c7cefb2300 (diff)