From cfdcb7c3c6f918753179c848e5d90f223116e38b Mon Sep 17 00:00:00 2001 From: Daniel Burrows Date: Wed, 21 Apr 2010 08:01:32 -0700 Subject: Rename the log4cxx namespace to logging. There are various problems with log4cxx, especially that it seems to be unreliable and leads to random crashes. It might be a good idea to eventually move to a different framework or roll our own. Decreasing the number of explicit dependencies on log4cxx is a good way to do that. --- src/generic/problemresolver/problemresolver.h | 22 +++++++------- src/generic/problemresolver/promotion_set.h | 42 +++++++++++++-------------- src/generic/problemresolver/search_graph.h | 2 +- src/generic/problemresolver/test.cc | 16 +++++----- 4 files changed, 41 insertions(+), 41 deletions(-) (limited to 'src/generic/problemresolver') diff --git a/src/generic/problemresolver/problemresolver.h b/src/generic/problemresolver/problemresolver.h index 6720a18b..7abebec8 100644 --- a/src/generic/problemresolver/problemresolver.h +++ b/src/generic/problemresolver/problemresolver.h @@ -560,8 +560,8 @@ public: }; private: - log4cxx::LoggerPtr logger; - log4cxx::AppenderPtr appender; // Used for the "default" appending behavior. + logging::LoggerPtr logger; + logging::AppenderPtr appender; // Used for the "default" appending behavior. search_graph graph; @@ -1873,10 +1873,10 @@ private: class do_drop_deps_solved_by { step &s; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; public: - do_drop_deps_solved_by(step &_s, const log4cxx::LoggerPtr &_logger) + do_drop_deps_solved_by(step &_s, const logging::LoggerPtr &_logger) : s(_s), logger(_logger) { } @@ -1963,14 +1963,14 @@ private: const choice_set &reasons; search_graph &graph; generic_problem_resolver &resolver; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; public: do_strike_choice(step &_s, const choice_set &_reasons, search_graph &_graph, generic_problem_resolver &_resolver, - const log4cxx::LoggerPtr &_logger) + const logging::LoggerPtr &_logger) : s(_s), reasons(_reasons), graph(_graph), @@ -3014,7 +3014,7 @@ private: const choice_set &new_choices; const cwidget::util::ref_ptr > &valid_condition; generic_problem_resolver &resolver; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; public: do_increase_solver_cost(step &_s, @@ -3022,7 +3022,7 @@ private: const choice_set &_new_choices, const cwidget::util::ref_ptr > &_valid_condition, generic_problem_resolver &_resolver, - const log4cxx::LoggerPtr &_logger) + const logging::LoggerPtr &_logger) : s(_s), new_cost(_new_cost), new_choices(_new_choices), @@ -3758,7 +3758,7 @@ public: const imm::map &_initial_state, const PackageUniverse &_universe) :logger(aptitude::Loggers::getAptitudeResolverSearch()), - appender(new log4cxx::ConsoleAppender(new log4cxx::PatternLayout("%m%n"))), + appender(new logging::ConsoleAppender(new logging::PatternLayout("%m%n"))), graph(promotions), initial_state(_initial_state, _universe.get_package_count()), weights(_step_score, _broken_score, _unfixed_soft_score, @@ -3860,12 +3860,12 @@ public: { if(new_debug) { - logger->setLevel(log4cxx::Level::getTrace()); + logger->setLevel(logging::Level::getTrace()); logger->addAppender(appender); } else { - logger->setLevel(log4cxx::Level::getOff()); + logger->setLevel(logging::Level::getOff()); logger->removeAppender(appender); } } diff --git a/src/generic/problemresolver/promotion_set.h b/src/generic/problemresolver/promotion_set.h index c37cdb1d..1b7030c9 100644 --- a/src/generic/problemresolver/promotion_set.h +++ b/src/generic/problemresolver/promotion_set.h @@ -303,7 +303,7 @@ public: typedef generic_promotion promotion; private: - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; promotion_set_callbacks &callbacks; struct entry; @@ -848,9 +848,9 @@ private: // counts. struct increment_entry_count_op { - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; - increment_entry_count_op(const log4cxx::LoggerPtr &_logger) + increment_entry_count_op(const logging::LoggerPtr &_logger) : logger(_logger) { } @@ -886,10 +886,10 @@ private: // The cost to return. mutable cost rval_cost; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; public: - find_entry_subset_op(const log4cxx::LoggerPtr &_logger) + find_entry_subset_op(const logging::LoggerPtr &_logger) : logger(_logger) { } @@ -965,7 +965,7 @@ private: // costs smaller than or equal to this limit are not // returned: cost maximum_cost; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; public: /** \brief Create a find-supersets operation. @@ -984,7 +984,7 @@ private: find_entry_supersets_op(std::vector &_output_entries, unsigned int _required_hits, const cost &_maximum_cost, - const log4cxx::LoggerPtr &_logger) + const logging::LoggerPtr &_logger) : output_entries(_output_entries), required_hits(_required_hits), maximum_cost(_maximum_cost), @@ -1135,13 +1135,13 @@ public: const generic_choice_indexed_map &output_domain; boost::unordered_map &output_incipient; maybe &output_non_incipient; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; public: find_incipient_entry_subset_op(const generic_choice_indexed_map &_output_domain, boost::unordered_map &_output_incipient, maybe &_output_non_incipient, - const log4cxx::LoggerPtr &_logger) + const logging::LoggerPtr &_logger) : output_domain(_output_domain), output_incipient(_output_incipient), output_non_incipient(_output_non_incipient), @@ -1310,11 +1310,11 @@ private: // Stores the set of broken soft dependencies. boost::unordered_set &broken_soft_deps; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; build_local_indices(boost::unordered_map &_choices_by_install_version, boost::unordered_set &_broken_soft_deps, - const log4cxx::LoggerPtr &_logger) + const logging::LoggerPtr &_logger) : choices_by_install_version(_choices_by_install_version), broken_soft_deps(_broken_soft_deps), logger(_logger) @@ -1374,11 +1374,11 @@ private: // Stores the set of broken soft dependencies. const boost::unordered_set &broken_soft_deps; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; check_choices_in_local_indices(const boost::unordered_map &_choices_by_install_version, const boost::unordered_set &_broken_soft_deps, - const log4cxx::LoggerPtr &_logger, + const logging::LoggerPtr &_logger, int &_num_mismatches, bool &_rval) : rval(_rval), @@ -1660,7 +1660,7 @@ private: static void collect_indexers(const choice &c, boost::unordered_set &installed_versions, boost::unordered_set &broken_soft_deps, - const log4cxx::LoggerPtr &logger) + const logging::LoggerPtr &logger) { switch(c.get_type()) { @@ -1687,11 +1687,11 @@ private: { boost::unordered_set &installed_versions; boost::unordered_set &broken_soft_deps; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; do_collect_indexers(boost::unordered_set &_installed_versions, boost::unordered_set &_broken_soft_deps, - const log4cxx::LoggerPtr &_logger) + const logging::LoggerPtr &_logger) : installed_versions(_installed_versions), broken_soft_deps(_broken_soft_deps), logger(_logger) @@ -1711,7 +1711,7 @@ private: static void collect_indexers(const entry &e, boost::unordered_set &installed_versions, boost::unordered_set &broken_soft_deps, - const log4cxx::LoggerPtr &logger) + const logging::LoggerPtr &logger) { e.p.get_choices().for_each(do_collect_indexers(installed_versions, broken_soft_deps, @@ -1724,7 +1724,7 @@ private: static void collect_indexers(const std::list &cost_entries, boost::unordered_set &installed_versions, boost::unordered_set &broken_soft_deps, - const log4cxx::LoggerPtr &logger) + const logging::LoggerPtr &logger) { for(typename std::list::const_iterator it = cost_entries.begin(); it != cost_entries.end(); ++it) @@ -1736,7 +1736,7 @@ private: */ template static void erase_vector_entries(std::vector &entries, - const log4cxx::LoggerPtr &logger, + const logging::LoggerPtr &logger, const Pred &pred) { if(LOG4CXX_UNLIKELY(logger->isTraceEnabled())) @@ -1838,12 +1838,12 @@ private: entry_ref new_entry; install_version_index_entry **install_version_index; boost::unordered_map &break_soft_dep_index; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; make_index_entries(entry_ref _new_entry, install_version_index_entry **_install_version_index, boost::unordered_map &_break_soft_dep_index, - const log4cxx::LoggerPtr &_logger) + const logging::LoggerPtr &_logger) : new_entry(_new_entry), install_version_index(_install_version_index), break_soft_dep_index(_break_soft_dep_index), diff --git a/src/generic/problemresolver/search_graph.h b/src/generic/problemresolver/search_graph.h index ebf1e1b9..5e239598 100644 --- a/src/generic/problemresolver/search_graph.h +++ b/src/generic/problemresolver/search_graph.h @@ -1052,7 +1052,7 @@ private: */ static const unsigned int max_propagated_promotions = 0; - log4cxx::LoggerPtr logger; + logging::LoggerPtr logger; // We keep a reference to the promotions set so that we can stuff // new promotions in during backpropagation. diff --git a/src/generic/problemresolver/test.cc b/src/generic/problemresolver/test.cc index b41a824e..a12cc6c6 100644 --- a/src/generic/problemresolver/test.cc +++ b/src/generic/problemresolver/test.cc @@ -42,24 +42,24 @@ namespace cw = cwidget; // This is a gross hack; without defining this here, we'd have to // somehow link in a higher-level library. -log4cxx::LoggerPtr aptitude::Loggers::getAptitudeResolver() +logging::LoggerPtr aptitude::Loggers::getAptitudeResolver() { - return log4cxx::Logger::getLogger("aptitude.resolver"); + return logging::Logger::getLogger("aptitude.resolver"); } -log4cxx::LoggerPtr aptitude::Loggers::getAptitudeResolverSearch() +logging::LoggerPtr aptitude::Loggers::getAptitudeResolverSearch() { - return log4cxx::Logger::getLogger("aptitude.resolver.search"); + return logging::Logger::getLogger("aptitude.resolver.search"); } -log4cxx::LoggerPtr aptitude::Loggers::getAptitudeResolverSearchGraph() +logging::LoggerPtr aptitude::Loggers::getAptitudeResolverSearchGraph() { - return log4cxx::Logger::getLogger("aptitude.resolver.search.graph"); + return logging::Logger::getLogger("aptitude.resolver.search.graph"); } -log4cxx::LoggerPtr aptitude::Loggers::getAptitudeResolverSearchCosts() +logging::LoggerPtr aptitude::Loggers::getAptitudeResolverSearchCosts() { - return log4cxx::Logger::getLogger("aptitude.resolver.search.costs"); + return logging::Logger::getLogger("aptitude.resolver.search.costs"); } // To make things easier, the tests are specified as plaintext files. -- cgit v1.2.3