input_file.hpp

#ifndef INPUT_G_H
#define INPUT_G_H

#include <iostream>
#include <fstream>
#include <map>
#include <set>
#include <list>
#include <memory>


#include "exceptions.hpp"
#include "singleton.hpp"

#ifdef USE_ABSTRACT_FUNCTIONS
#define D_ABSTRACT(X) = 0
#else
#define D_ABSTRACT(X) { throw(E_real_virtual_function(" X ",class_Name()));}
#endif

const char* const TRUE_TYPE_NAME = "true_type_name";

/*!****************************
 *
 *  Abstract base clase for observer objects,
 *  These are signaled by Loadable_Object (see below) to 
 *  report a state change
 *
 *******************************/

class Observer{

public:
    typedef STD_TR1::shared_ptr< Observer > ref;

    virtual ~Observer() throw() {};

    void notify(){ notified_();};

private:
    virtual void notified_() = 0;

};



class loadable_Object{
public:
    typedef STD_TR1::shared_ptr<       loadable_Object > ref;
    typedef STD_TR1::shared_ptr< const loadable_Object > const_ref;

    typedef std::pair<std::string, ref> ref_pair;

    typedef STD_TR1::weak_ptr<       loadable_Object > link;
    typedef STD_TR1::weak_ptr< const loadable_Object > const_link;

    void write_xml(std::ostream&) const;

    loadable_Object():ready(false), written(false) {};
    virtual ~loadable_Object() throw();

    const char* class_Name() const { return name();};

    bool get_param(const std::string& s, double& v) const;
    bool get_param(const std::string& s, int& v) const;
    bool get_param(const std::string& s, std::string& v) const;

    double      get_double_param(const std::string& s) const;
    int         get_int_param(const std::string& s) const;
    std::string get_string_param(const std::string& s) const;

    void set_param(const std::string& s, double v);    
    void set_param(const std::string& s, int v);
    void set_param(const std::string& s, std::string v);    
    bool get_bool(const std::string& s, const bool def) const;

    void acquire_params(const const_ref&);

    void insert_object(const std::string& s, ref o){ 
    components[s] = o; 
        component_list.push_back(ref_pair(s,o));};

    void link_object(const std::string& s, ref o){ links[s] = o;};

    bool get_component(const std::string& s, const_ref&) const;
    bool get_component(const std::string& s, ref&);
    
    const_ref get_component(const std::string& s) const;
    ref get_component(const std::string& s);    


    template <typename T>
    STD_TR1::shared_ptr<T> get_dynamic_component(const std::string& s);

    template <typename T>
    STD_TR1::shared_ptr<const T> get_dynamic_component(const std::string& s) const;
    

    ref get_ref(){ return ref(my_reference);};
    const_ref get_ref() const { return const_ref(my_reference);};


    template <typename T>
    STD_TR1::shared_ptr<T> get_dynamic_ref();
    template <typename T>
    STD_TR1::shared_ptr<const T> get_dynamic_ref() const;


    void initialize(ref me);
    

    void set_correct_ref(ref me);

    bool is_initialized() const { return ready;};

    void require_initialized() const { if (!ready) throw (E_Not_ready(class_Name()));};
    void force_reinit();
    void register_Observer( Observer::ref );
    void unregister_Observer( Observer::ref );

    size_t nparams() const { 
        return params.size();};

    ref clone() const;

    template <class T>
    static
    STD_TR1::shared_ptr<const T> clone( const STD_TR1::shared_ptr<const T> r) {
    ref o(r->clone());
    STD_TR1::shared_ptr<T> result =
        STD_TR1::dynamic_pointer_cast<T>(o);
    return result;
    }

    template <class T>
    static
    STD_TR1::shared_ptr<T> clone( STD_TR1::shared_ptr<T> r) {
    ref o(r->clone());
    STD_TR1::shared_ptr<T> result =
        STD_TR1::dynamic_pointer_cast<T>(o);
    return result;
    }

    virtual size_t verbosity() {return 10;}
private:
    int ready;
    mutable bool written;

    struct paramstruct{
        std::string s;
        int i;
        double d;       
                
                enum {a_str, an_int, a_double} status;
    };


    std::map<std::string, paramstruct> params;

    std::set< Observer::ref > observers;

    std::map<std::string, ref > components;
    std::list< ref_pair > component_list;

    std::map<std::string, link> links;

    void notify_Observers();

    void finnish_writing() const;

    typedef std::map< const_ref, ref> ref_map;

    ref clone(ref_map& ) const;

    void clone_component( ref, const std::string&, ref, ref_map& ) const;
    void clone_link( ref, const std::string&, ref, ref_map& ) const;

    void initialize_from_clone( ref , const_ref );

    virtual const char* name() const { return "root";};
    virtual void init() D_ABSTRACT(init);
    virtual void init_from_clone( const_ref );
    

    STD_TR1::weak_ptr<loadable_Object> my_reference;

    void write_xml_(std::ostream& os, int indent) const;

};

class Parameters: public loadable_Object{
public:
    virtual ~Parameters() throw() {};

private:
    const char* name() const { return "Parameters";};
    void init();
};

template <typename T>
class unknown_type_policy_throw{
public:
    static T exec(const std::string& name){
    throw (E_unknown_typename(name));
    };
};

template <class T>
class unknown_type_policy_create_base{
public:
    static T exec(const std::string& name){
        std::cerr << "Warning: " << name << " not registered. Reverting to Parameter\n";
    T t(new typename T::element_type);
    t->set_param(TRUE_TYPE_NAME,name);
    return t;
    };
};

#include "input_file.tpp"

typedef manage_Loadable<loadable_Object, 
            unknown_type_policy_create_base<
                STD_TR1::shared_ptr<Parameters> 
                > 
            >
effective_manage_Loadable;

#endif