Component.cc

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 
#include <map>
#include <boost/tokenizer.hpp>

#include "lsst/pex/logging/Component.h"

using namespace lsst::pex::logging;

/*****************************************************************************/
Component::Component(const std::string &name,   
                    int verbosity               
                    ) : _name(new std::string(name)),
                        _verbosity(verbosity),
                        _subcomp(*new(comp_map)) {
}

Component::~Component() {
    // Note from rlp:  memory leak!  map members not deleted.
    delete &_subcomp;
    delete _name;
}

void Component::add(const std::string &name,     
                    int verbosity,               
                    const std::string &separator 
                          ) {
    //
    // Prepare to parse name
    //
    boost::char_separator<char> sep(separator.c_str());
    tokenizer components(name, sep);
    tokenizer::iterator token = components.begin();
    const tokenizer::iterator end = components.end();

    if (token == end) {                 // "" or "."
        this->setVerbosity(verbosity);
    } else {
        add(token, end, verbosity);
    }
}

void Component::add(tokenizer::iterator token,     
                    const tokenizer::iterator end, 
                    int verbosity                  
                     ) {
    const std::string cpt0 = *token++;  // first component of name
    /*
     * Does first part of path match this verbosity?
     */
    if (*_name == cpt0) {               // a match
        if (token == end) {             // name has no more components
            _verbosity = verbosity;
        } else {
            add(token, end, verbosity);
        }
        
        return;
    }
    /*
    * Look for a match for cpt0 in this verbosity's subcomps
    */
    comp_map::iterator iter = _subcomp.find(cpt0);
    if (iter != _subcomp.end()) {
        if (token == end) {
            iter->second->_verbosity = verbosity;
        } else {
            iter->second->add(token, end, verbosity);
        }

        return;
    }
    /*
     * No match; add cpt0 to this verbosity
     */
    Component *fcpt0 = new Component(cpt0);
    _subcomp[*fcpt0->_name] = fcpt0;

    if (token == end) {
        fcpt0->_verbosity = verbosity;
    } else {
        fcpt0->add(token, end, verbosity);
    }
}

/*****************************************************************************/
int Component::highestVerbosity(int highest 
                           ) {
    if (_verbosity > highest) {
        highest = _verbosity;
    }
    
    for (comp_map::iterator iter = _subcomp.begin();
         iter != _subcomp.end(); iter++) {
        highest = iter->second->highestVerbosity(highest);
    }

    return highest;                     
}

/*****************************************************************************/
int Component::getVerbosity(tokenizer::iterator token,     
                            const tokenizer::iterator end, 
                            int defaultVerbosity           
                            ) {
    const std::string cpt0 = *token++;  // first component of name
    /*
     * Look for a match for cpt0 in this Component's subcomps
     */
    comp_map::iterator iter = _subcomp.find(cpt0);
    if (iter != _subcomp.end()) {
        int verbosity = iter->second->_verbosity;
        if (verbosity == INHERIT_VERBOSITY) {
            verbosity = defaultVerbosity;
        }

        if (token == end) {             // there was only one component
            ;                           // so save the function call
        } else {
            verbosity = iter->second->getVerbosity(token, end, verbosity);
        }

        return (verbosity == INHERIT_VERBOSITY) ? defaultVerbosity : verbosity; 
    }
    /*
     * No match. This is as far as she goes
     */
    return _verbosity;          
}

int Component::getVerbosity(const std::string &name,     
                            const std::string &separator 
                            ) {
    //
    // Prepare to parse name
    //
    boost::char_separator<char> sep(separator.c_str());
    tokenizer components(name, sep);
    tokenizer::iterator token = components.begin();

    if (token == components.end()) {
        return _verbosity;      
    }

    return getVerbosity(token, components.end(), _verbosity); 
}

void Component::printVerbosity(std::ostream &fp,    
                               int depth            
                               ) {
    if (_subcomp.empty() && _verbosity == INHERIT_VERBOSITY) {
        return;
    }
    //
    // Print this verbosity
    //
    for (int i = 0; i < depth; i++) {
        fp << ' ';
    }

    std::string &name = *_name;
    if (name.length() == 0) name = "(root)";
    fp << name;
    for (int i = 0; i < 20 - depth - static_cast<int>(name.size()); i++) {
        fp << ' ';
    }
    
    if (_verbosity != INHERIT_VERBOSITY) {
        fp << _verbosity;
    }
    fp << "\n";
    //
    // And other levels of the hierarchy too
    //
    for (comp_map::iterator iter = _subcomp.begin();
         iter != _subcomp.end(); iter++) {
        iter->second->printVerbosity(fp, depth + 1);
    }
}