lsst::pex::logging::Component Class Reference

Create a component in the verbosity tree (deprecated). More...

#include <Component.h>

Public Types
enum	{ INHERIT_VERBOSITY = -9999 }

Public Member Functions
	Component (const std::string &name=".", int verbosity=INHERIT_VERBOSITY)
	~Component ()
void	add (const std::string &name, int verbosity, const std::string &separator)
int	getVerbosity (const std::string &name, const std::string &separator)
int	highestVerbosity (int highest=0)
void	printVerbosity (std::ostream &fp, int depth=0)
void	setVerbosity (int verbosity)

Private Types
typedef boost::tokenizer < boost::char_separator< char > >	tokenizer
typedef std::map< const std::string, Component * >	comp_map

Private Member Functions
void	add (tokenizer::iterator token, const tokenizer::iterator end, int verbosity)
int	getVerbosity (tokenizer::iterator token, const tokenizer::iterator end, int defaultVerbosity)

Private Attributes
std::string *	_name
int	_verbosity
comp_map &	_subcomp

Detailed Description

Create a component in the verbosity tree (deprecated).

Deprecated:

threshold::Memory class now provides this functionality.

A name is a string of the form aaa.bbb.ccc, and may itself contain further subcomponents. The Component structure doesn't in fact contain its full name, but only the first part.

The reason for this is inheritance — verbosity is inherited, but may be overriden. For example, if "foo" is at level 2 then "foo.goo.hoo" is taken to be at level 2 unless set specifically – but this inheritance is dynamic (so changing "foo" to 3 changes "foo.goo.hoo" too). However, I may also set "foo.goo.hoo" explicitly, in which case "foo"'s value is irrelevant — but "foo.goo" continues to inherit it.

Definition at line 62 of file Component.h.

Member Typedef Documentation

typedef std::map<const std::string, Component *> lsst::pex::logging::Component::comp_map

private

Definition at line 79 of file Component.h.

typedef boost::tokenizer<boost::char_separator<char> > lsst::pex::logging::Component::tokenizer

private

Definition at line 78 of file Component.h.

Member Enumeration Documentation

anonymous enum

Enumerator
INHERIT_VERBOSITY

Definition at line 64 of file Component.h.

{ INHERIT_VERBOSITY = -9999};  

Constructor & Destructor Documentation

Component::Component	(	const std::string &	name = ".",
		int	verbosity = INHERIT_VERBOSITY
	)

Initialize the component structure.

Parameters

name	component's name
verbosity	component's verbosity

Definition at line 45 of file Component.cc.

                      : _name(new std::string(name)),
                        _verbosity(verbosity),
                        _subcomp(*new(comp_map)) {
}

Component::~Component

(

)

Destroy the component structure.

Definition at line 54 of file Component.cc.

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

Member Function Documentation

void Component::add	(	const std::string &	name,
		int	verbosity,
		const std::string &	separator
	)

Add a new component to the tree

Parameters

name	component's name
verbosity	component's verbosity
separator	path separator

Definition at line 62 of file Component.cc.

                            {
    //
    // 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  )

private

Add a new component to the tree

Parameters

token	parts of name
end	end of name
verbosity	component's verbosity

Definition at line 83 of file Component.cc.

                       {
    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::getVerbosity	(	const std::string &	name,
		const std::string &	separator
	)

Return a component's verbosity, from the perspective of "this".

See Also

Component::getVerbosity

< Return a component's verbosity

< Return a component's verbosity

Parameters

name	component of interest
separator	path separator

Definition at line 179 of file Component.cc.

                              {
    //
    // 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); 
}

int Component::getVerbosity ( tokenizer::iterator  token, const tokenizer::iterator  end, int  defaultVerbosity  )

private

Return a trace verbosity given a name

< Return trace verbosity given name

< Return trace verbosity given name

Parameters

token	parts of name
end	end of name
defaultVerbosity	default verbosity

Definition at line 146 of file Component.cc.

                              {
    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::highestVerbosity

(

int

highest = 0

)

Return the highest verbosity rooted at comp

< return highest verbosity rooted at comp

Parameters

highest

minimum verbosity to return

Definition at line 129 of file Component.cc.

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

    return highest;                     
}

void Component::printVerbosity	(	std::ostream &	fp,
		int	depth = 0
	)

Print all the trace verbosities rooted at "this"

Parameters

fp	Output stream
depth	Tree depth to recurse

Definition at line 198 of file Component.cc.

                                 {
    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);
    }
}

void lsst::pex::logging::Component::setVerbosity ( int  verbosity )

inline

Definition at line 75 of file Component.h.

{ _verbosity = verbosity; }

Member Data Documentation

std::string* lsst::pex::logging::Component::_name

private

Definition at line 81 of file Component.h.

comp_map& lsst::pex::logging::Component::_subcomp

private

Definition at line 83 of file Component.h.

int lsst::pex::logging::Component::_verbosity

private

Definition at line 82 of file Component.h.

---

The documentation for this class was generated from the following files:

• /home/lsstsw/stack/Linux64/pex_logging/11.0+1/include/lsst/pex/logging/Component.h
• /home/lsstsw/stack/Linux64/pex_logging/11.0+1/src/Component.cc