propertyconfigurator.cpp

log4cxx 0.10 unix下编译包

                static const LogString INTERNAL_ROOT_NAME(LOG4CXX_STR("root"));
                parseLogger(props, root, effectiveFrefix, INTERNAL_ROOT_NAME, value);
        }
}

void PropertyConfigurator::parseCatsAndRenderers(helpers::Properties& props,
                        spi::LoggerRepositoryPtr& hierarchy)
{
        static const LogString CATEGORY_PREFIX(LOG4CXX_STR("log4j.category."));
        static const LogString LOGGER_PREFIX(LOG4CXX_STR("log4j.logger."));

        std::vector<LogString> names = props.propertyNames();

        std::vector<LogString>::iterator it = names.begin();
        std::vector<LogString>::iterator itEnd = names.end();
        while (it != itEnd)
        {
                LogString key = *it++;

                if (key.find(CATEGORY_PREFIX) == 0 || key.find(LOGGER_PREFIX) == 0)
                {
                        LogString loggerName;

                        if (key.find(CATEGORY_PREFIX) == 0)
                        {
                                loggerName = key.substr(CATEGORY_PREFIX.length());
                        }
                        else if (key.find(LOGGER_PREFIX) == 0)
                        {
                                loggerName = key.substr(LOGGER_PREFIX.length());
                        }

                        LogString value = OptionConverter::findAndSubst(key, props);
                        LoggerPtr logger = hierarchy->getLogger(loggerName, loggerFactory);

                        synchronized sync(logger->getMutex());
                        parseLogger(props, logger, key, loggerName, value);
                        parseAdditivityForLogger(props, logger, loggerName);
                }
        }
}

void PropertyConfigurator::parseAdditivityForLogger(helpers::Properties& props,
        LoggerPtr& cat, const LogString& loggerName)
{

     static const LogString ADDITIVITY_PREFIX(LOG4CXX_STR("log4j.additivity."));



        LogString value(OptionConverter::findAndSubst(ADDITIVITY_PREFIX + loggerName, props));
        LogLog::debug((LogString) LOG4CXX_STR("Handling ") + ADDITIVITY_PREFIX
           + loggerName + LOG4CXX_STR("=[") +  value + LOG4CXX_STR("]"));

        // touch additivity only if necessary
        if (!value.empty())
        {
                bool additivity = OptionConverter::toBoolean(value, true);
                LogLog::debug(((LogString) LOG4CXX_STR("Setting additivity for \""))
                    + loggerName
                    + ((additivity) ?  LOG4CXX_STR("\" to true") :
                                  LOG4CXX_STR("\" to false")));
                cat->setAdditivity(additivity);
        }
}

/**
        This method must work for the root logger as well.
*/
void PropertyConfigurator::parseLogger(
        helpers::Properties& props, LoggerPtr& logger, const LogString& /* optionKey */,
        const LogString& loggerName, const LogString& value)
{
        LogLog::debug(((LogString) LOG4CXX_STR("Parsing for ["))
            + loggerName
            + LOG4CXX_STR("] with value=[")
            + value + LOG4CXX_STR("]."));

        // We must skip over ',' but not white space
        StringTokenizer st(value, LOG4CXX_STR(","));

        // If value is not in the form ", appender.." or "", then we should set
        // the level of the logger.
        if (!(value.find(LOG4CXX_STR(",")) == 0 || value.empty()))
        {
                // just to be on the safe side...
                if (!st.hasMoreTokens())
                {
                        return;
                }

                LogString levelStr = st.nextToken();
                LogLog::debug((LogString) LOG4CXX_STR("Level token is [")
                    + levelStr +  LOG4CXX_STR("]."));


                // If the level value is inherited, set logger level value to
                // null. We also check that the user has not specified inherited for the
                // root logger.
                if (StringHelper::equalsIgnoreCase(levelStr, LOG4CXX_STR("INHERITED"), LOG4CXX_STR("inherited"))
                        || StringHelper::equalsIgnoreCase(levelStr, LOG4CXX_STR("NULL"), LOG4CXX_STR("null")))
                {
                        static const LogString INTERNAL_ROOT_NAME(LOG4CXX_STR("root"));
                        if (loggerName == INTERNAL_ROOT_NAME)
                        {
                                LogLog::warn(LOG4CXX_STR("The root logger cannot be set to null."));
                        }
                        else
                        {
                                logger->setLevel(0);
                                LogLog::debug((LogString) LOG4CXX_STR("Logger ")
                                    + loggerName + LOG4CXX_STR(" set to null"));
                        }
                }
                else
                {
                        logger->setLevel(OptionConverter::toLevel(levelStr, Level::getDebug()));

                        LogLog::debug((LogString) LOG4CXX_STR("Logger ")
                            + loggerName + LOG4CXX_STR(" set to ")
                            + logger->getLevel()->toString());
                }

        }

        // Begin by removing all existing appenders.
        logger->removeAllAppenders();

        AppenderPtr appender;
        LogString appenderName;

        while (st.hasMoreTokens())
        {
                appenderName = StringHelper::trim(st.nextToken());

                if (appenderName.empty() || appenderName == LOG4CXX_STR(","))
                {
                        continue;
                }

                LogLog::debug(LOG4CXX_STR("Parsing appender named ")
                      + appenderName + LOG4CXX_STR("\"."));
                appender = parseAppender(props, appenderName);

                if (appender != 0)
                {
                        logger->addAppender(appender);
                }
        }
}

AppenderPtr PropertyConfigurator::parseAppender(
        helpers::Properties& props, const LogString& appenderName)
{
        AppenderPtr appender = registryGet(appenderName);

        if (appender != 0)
        {
                LogLog::debug((LogString) LOG4CXX_STR("Appender \"")
                     + appenderName + LOG4CXX_STR("\" was already parsed."));

                return appender;
        }

        static const LogString APPENDER_PREFIX(LOG4CXX_STR("log4j.appender."));

        // Appender was not previously initialized.
        LogString prefix = APPENDER_PREFIX + appenderName;
        LogString layoutPrefix = prefix + LOG4CXX_STR(".layout");

        appender =
                OptionConverter::instantiateByKey(
                props, prefix, Appender::getStaticClass(), 0);

        if (appender == 0)
        {
                LogLog::error((LogString) LOG4CXX_STR("Could not instantiate appender named \"")
                    + appenderName + LOG4CXX_STR("\"."));
                return 0;
        }

        appender->setName(appenderName);

        if (appender->instanceof(OptionHandler::getStaticClass()))
        {
        Pool p;
                if (appender->requiresLayout())
                {
                        LayoutPtr layout =
                                OptionConverter::instantiateByKey(
                                props, layoutPrefix, Layout::getStaticClass(), 0);

                        if (layout != 0)
                        {
                                appender->setLayout(layout);
                                LogLog::debug((LogString) LOG4CXX_STR("Parsing layout options for \"")
                                    + appenderName + LOG4CXX_STR("\"."));

                                //configureOptionHandler(layout, layoutPrefix + ".", props);
                                PropertySetter::setProperties(layout, props, layoutPrefix + LOG4CXX_STR("."), p);
                LogLog::debug((LogString) LOG4CXX_STR("End of parsing for \"")
                    + appenderName +  LOG4CXX_STR("\"."));
                        }
                }

                //configureOptionHandler((OptionHandler) appender, prefix + _T("."), props);
                PropertySetter::setProperties(appender, props, prefix + LOG4CXX_STR("."), p);
        LogLog::debug((LogString) LOG4CXX_STR("Parsed \"")
             + appenderName + LOG4CXX_STR("\" options."));
        }

        registryPut(appender);

        return appender;
}

void PropertyConfigurator::registryPut(const AppenderPtr& appender)
{
        (*registry)[appender->getName()] = appender;
}

AppenderPtr PropertyConfigurator::registryGet(const LogString& name)
{
        return (*registry)[name];
}