Memory.h

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/>.
 */
 
#ifndef LSST_PEX_LOGGING_THRESHOLD_MEMORY_H
#define LSST_PEX_LOGGING_THRESHOLD_MEMORY_H

#include <string>
#include <map>
#include <ostream>
#include <boost/shared_ptr.hpp>
#include <boost/tokenizer.hpp>

#include "lsst/pex/logging/threshold/enum.h"

namespace lsst {
namespace pex {
namespace logging {
namespace threshold {

typedef boost::tokenizer<boost::char_separator<char> > tokenizer;

class Family {
public:

    Family(int defaultThreshold=INHERIT);

    ~Family();

    int getThreshold() { return _thresh; }
        
    void setThreshold(int threshold) { _thresh = threshold; }
        
    int getThresholdFor(tokenizer::iterator toptoken, 
                        const tokenizer::iterator& end) const
    {
        const Family *nfd = findDescendant(toptoken, end, true);
        if (nfd == 0 || nfd->_thresh == INHERIT) return _thresh;
        return nfd->_thresh;
    }

    void setThresholdFor(tokenizer::iterator toptoken, 
                         const tokenizer::iterator& end,
                         int threshold);

    void resetThresholdFor(tokenizer::iterator toptoken, 
                           const tokenizer::iterator& end);

    void printDescThresholds(std::ostream& out, 
                             const std::string& prefix) const;

    void deleteDescendants();

protected: 

    Family *ensureDescendant(tokenizer::iterator toptoken, 
                             const tokenizer::iterator& end);

    const Family *findDescendant(tokenizer::iterator toptoken, 
                                 const tokenizer::iterator& end,
                                 bool orNearest=false) const;

    Family *makeDescendants(tokenizer::iterator toptoken, 
                            const tokenizer::iterator& end);

private:
    typedef std::map<std::string, Family*> ChildMap;
    int _thresh;
    ChildMap *_children;
};

class Memory {
public:

    Memory(const std::string& delims=".");

    int getThresholdFor(const std::string& name) {
        if (name.length() == 0) return getRootThreshold();
        tokenizer fields(name, _sep);
        return _tree.getThresholdFor(fields.begin(), fields.end());
    }

    void setThresholdFor(const std::string& name, int threshold) {
        if (name.length() == 0) {
            setRootThreshold(threshold);
        }
        else {
            tokenizer fields(name, _sep);
            _tree.setThresholdFor(fields.begin(), fields.end(), threshold);
        }
    }

    int getRootThreshold() { return _tree.getThreshold(); }

    void setRootThreshold(int threshold) { _tree.setThreshold(threshold); }

    void forgetAllNames() { _tree.deleteDescendants(); }

    void printThresholds(std::ostream& out);


private:
    Family _tree;
    boost::char_separator<char> _sep;
};

}}}} // end lsst::pex::logging::threshold

#endif // end LSST_PEX_LOGGING_THRESHOLD_MEMORY_H