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

Go to the documentation of this file.

/*
 *  Copyright (C) 2007, 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_BASE_CONFIG_H
#define PSYNTH_BASE_CONFIG_H

#include <list>
#include <map>
#include <iostream>
#include <typeinfo>

#include <boost/any.hpp>

#include <psynth/base/tree.hpp>
#include <psynth/base/misc.hpp>
#include <psynth/base/singleton.hpp>
#include <psynth/base/exception.hpp>
#include <psynth/base/observer.hpp>

#include <psynth/base/config_fwd.hpp>

namespace psynth
{
namespace base
{

PSYNTH_DECLARE_ERROR (error,        config_error);
PSYNTH_DECLARE_ERROR (config_error, config_type_error);
PSYNTH_DECLARE_ERROR (config_error, config_backend_error);

class conf_node;

class conf_listener : public listener_base
{
public:
    virtual void handle_conf_change (conf_node& c)    = 0;

    virtual void handle_conf_nudge (conf_node& c)     = 0;

    virtual void handle_conf_add_child (conf_node& c) = 0;

    virtual void handle_conf_del_child (conf_node& c) = 0;
};

class conf_subject : public subject_base <conf_listener>
{
public:
    typedef boost::signal <void (conf_node&)> signal;
    //typedef psynth::base::signal <void, conf_node&> signal;
    
    signal on_change;
    
    signal on_nudge;

    signal on_add_child;

    signal on_del_child;

    void add_listener (conf_listener& l);

    void del_listener (conf_listener& l);
};

class conf_backend : public conf_listener
{
public:
    virtual ~conf_backend() {}

    virtual void attach (conf_node& node) = 0;

    virtual void datach (conf_node& node) = 0;

    virtual void save (conf_node& node) = 0;

    virtual void load (conf_node& node) = 0;

    virtual void def_load (conf_node& node) = 0;
};

class conf_node : public conf_subject,
                  public tree_node <conf_node>,
                  public PSYNTH_DEFAULT_THREADING <conf_node>
{
public:
    const std::type_info& type () const
    {
        lock lock (this);
        return _element.type ();
    }

    bool empty () const
    {
        lock lock (this);
        return _element.empty ();
    }

    void nudge ()
    {
        on_nudge (*this);
    }
    
    template<class T>
    void set (const T& val)
    {
        lock lock (this);
        _element = val;
        on_change (*this);
    }

    template<class T>
    void set (const T& val, bool overwrite);
    
    template<class T>
    void def (const T& val);
    
    template<class T>
    void get (T& data) const;

    template<class T>
    T get () const;
    
    void save ();

    void load ();

    void def_load ();
    
    void set_backend (conf_backend_ptr backend);

    void unset_backend ();
    
private:
    boost::any       _element;
    conf_backend_ptr _backend;

    void on_init ()
    {
        _backend.reset ();
        if (parent ())
            _backend = parent ()->_backend;
    }

    void on_uninit ()
    {
        _backend.reset ();
    }
};

struct config : public singleton_holder <conf_node> {};

template<class T>
void conf_node::get (T& data) const
{
    lock lock (this);
    
    try {
        data = boost::any_cast<T> (_element);
    } catch (boost::bad_any_cast&) {
        throw config_type_error ();
    }
}

template<class T>
T conf_node::get () const
{
    lock lock (this);
    T ret;
    
    try {
        ret = boost::any_cast<T> (_element);
    } catch (boost::bad_any_cast&) {
        throw config_type_error ();
    }

    return ret;
}


template<class T>
void conf_node::def (const T& val)
{
    lock lock (this);
    
    if (_element.empty ()) {
        _element = val;
        on_change (*this);
    }
}

template<class T>
void conf_node::set (const T& val, bool overwrite)
{
    lock lock (this);
    
    if (overwrite || _element.empty ()) {
        _element = val;
        on_change (*this);
    }
}

extern template class subject_base <conf_listener>;
extern template class singleton_holder <conf_node>;
extern template class tree_node <conf_node>;
extern template class PSYNTH_DEFAULT_THREADING <conf_node>;

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

#endif /* PSYNTH_BASE_CONFIG_H */