LoggerTreeNode.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of the RSC project.
 *
 * Copyright (C) 2011 by Johannes Wienke <jwienke at techfak dot uni-bielefeld dot de>
 *
 * This file may be licensed under the terms of the
 * GNU Lesser General Public License Version 3 (the ``LGPL''),
 * or (at your option) any later version.
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the LGPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the LGPL along with this
 * program. If not, go to http://www.gnu.org/licenses/lgpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The development of this software was supported by:
 *   CoR-Lab, Research Institute for Cognition and Robotics
 *     Bielefeld University
 *
 * ============================================================ */

#pragma once

#include <map>
#include <string>
#include <vector>

#include <boost/enable_shared_from_this.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>

#include "LoggerProxy.h"

namespace rsc {
namespace logging {

class LoggerTreeNode;
typedef boost::shared_ptr<LoggerTreeNode> LoggerTreeNodePtr;
typedef boost::weak_ptr<LoggerTreeNode> LoggerTreeNodeWeakPtr;

class LoggerTreeNode: public boost::enable_shared_from_this<LoggerTreeNode> {
public:

    typedef std::vector<std::string> NamePath;

    LoggerTreeNode(const std::string& name, LoggerTreeNodeWeakPtr parent);

    LoggerTreeNode(const std::string& name, LoggerProxyPtr loggerProxy,
            LoggerTreeNodeWeakPtr parent);

    LoggerTreeNodePtr getParent() const;

    std::string getName() const;

    LoggerProxyPtr getLoggerProxy() const;

    void setLoggerProxy(LoggerProxyPtr loggerProxy);

    bool addChild(LoggerTreeNodePtr child);

    typedef boost::function<
            LoggerProxyPtr(const NamePath& name, LoggerTreeNodePtr node)> CreateFunction;

    LoggerTreeNodePtr addChildren(const NamePath& path,
            CreateFunction createFn, const NamePath &processedPath = NamePath());

    class Visitor {
    public:
        virtual ~Visitor();

        virtual bool visit(const NamePath& path, LoggerTreeNodePtr node, const Logger::Level& parentLevel) = 0;

    };
    typedef boost::shared_ptr<Visitor> VisitorPtr;

    void visit(VisitorPtr visitor, const NamePath& thisPath = NamePath());

    bool hasChild(const std::string& name) const;

    bool hasChild(const NamePath& path) const;

    LoggerTreeNodePtr getChild(const std::string& name) const;

    LoggerTreeNodePtr getChild(const NamePath& path) const;

    void clearChildren();

    static NamePath nameToPath(const std::string& name);
    static std::string pathToName(const NamePath& path);

    boost::shared_ptr<Logger::Level> getAssignedLevel() const;
    void setAssignedLevel(boost::shared_ptr<Logger::Level> level);
    void setAssignedLevel(const Logger::Level& level);
    bool hasAssignedLevel() const;

private:

    std::string name;
    LoggerProxyPtr loggerProxy;

    LoggerTreeNodeWeakPtr parent;
    std::map<std::string, LoggerTreeNodePtr> children;

    boost::shared_ptr<Logger::Level> assignedLevel;

};

}
}