/home/raskolnikov/dev/psynth/trunk/src/psynth/base/tree.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2008, 2009 Juan Pedro Bolívar Puente
 *  
 *  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 GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef PSYNTH_TREE_H
#define PSYNTH_TREE_H

#include <map>
#include <unordered_map>
#include <typeinfo>

#include <psynth/base/iterator.hpp>
#include <psynth/base/pointer.hpp>
#include <psynth/base/exception.hpp>
#include <psynth/base/threads.hpp>

namespace psynth
{
namespace base
{

template <typename Key>
struct tree_node_traits
{
    typedef typename Key::value_type value_type;

    static const value_type separator = value_type ();
};

template <>
struct tree_node_traits<std::string>
{
    typedef char value_type;
    static const char separator = '.';
};

PSYNTH_DECLARE_ERROR(error, tree_node_error);

template <class Node,
          class Key = std::string,
          class Traits = tree_node_traits<Key>,
          class ThreadingPolicy = PSYNTH_DEFAULT_THREADING <Node> >
class tree_node
{   
public:
    typedef std::unique_ptr<Node> node_ptr;
    
    typedef ptr_iterator<map_iterator<Key, node_ptr > > iterator;

    typedef ptr_const_iterator<map_const_iterator<Key, std::unique_ptr<Node> > >
    const_iterator;

    typedef Traits traits;
    
    tree_node () :
        _parent(NULL), _isinit(false)
    {
    };

    ~tree_node ();

    iterator begin ()
    {
        return _childs.begin();
    }

    const_iterator begin () const
    {
        return _childs.begin ();
    }
    
    iterator end ()
    {
        return _childs.end ();
    }

    const_iterator end () const
    {
        return _childs.end ();
    }
    
    const Node* parent () const
    {
        tree_lock lock (this);
        return _parent;
    }

    Node* parent ()
    {
        tree_lock lock (this);
        return _parent;
    }
    
    const Key& name () const
    {
        tree_lock lock (this);
        return _name;
    }
   
    iterator find_child (const Key& name)
    {
        tree_lock lock (this);
        return _childs.find (name);
    }
 
    const_iterator find_child (const Key& name) const
    {
        tree_lock lock (this);
        return _childs.find (name);
    }

    node_ptr detach (const Key& name)
    {
        tree_lock lock (this);
        return detach (_childs.find (name));
    }

    iterator remove_child (const Key& name)
    {
        tree_lock lock (this);
        return remove_child (_childs.find (name));
    }

    bool attach (const Key& name, node_ptr node);
    
    node_ptr detach (iterator iter);
    
    Key path_name () const;
    
    iterator remove_child (iterator iter);

    void clear_childs ();
    
    Node& child (const Key& name);

    Node& existing_child (const Key& name);


    const Node& existing_child (const Key& name) const;
    
    Node& path (const Key& name);
    
    Node& existing_path (const Key& name);

    const Node& existing_path (const Key& name) const;

protected:    
    virtual void on_new_child (Node& node) {}
    virtual void on_remove_child (Node& node) {}
    virtual void on_init () {}
    virtual void on_uninit () {}
    
private:
    typedef std::map<Key, std::unique_ptr<Node>> child_map;

    child_map   _childs;
    Node*       _parent;
    Key         _name;
    bool        _isinit;

    template <typename InputIterator>
    static void find_base (InputIterator& base_b, InputIterator& base_e);

    const Node&
    existing_path (typename Key::const_iterator begin,
                       typename Key::const_iterator end) const;

    Node&
    existing_path (typename Key::const_iterator begin,
                       typename Key::const_iterator end);

    Node& path (typename Key::const_iterator begin,
                    typename Key::const_iterator end);
    
    void path_name (Key& prefix) const;

    bool is_init() const
    {
        return _isinit;
    }

    void init (const Key& name, Node* parent)
    {
        _isinit = true;
        _name = name;
        _parent = parent;
        on_init ();
    }

    void uninit ()
    {
        if (_isinit) {
            _isinit = false;
            _name = Key ();
            _parent = 0;
            on_uninit ();
        }
    }

    struct tree_lock : public ThreadingPolicy::lock
    {
        tree_lock (const tree_node* self)
            : ThreadingPolicy::lock (dynamic_cast<const Node*> (self))
        {}
    };
};

} /* namespace base */
} /* namespace psynth */

#endif /* PSYNTH_TREE_H  */