xml_utils.hpp

#ifndef XML_UTILS_HPP
#define XML_UTILS_HPP

#include"shared_ptr.hpp"
#include <vector>
#include <list>
#include <utility>

class loadable_Object;
typedef STD_TR1::shared_ptr<loadable_Object> loadable_Object_ref;

class xml_chain{
public:
    xml_chain(const std::string& s, loadable_Object_ref head);

    static std::string parse_first( const std::string& );

    size_t length() { return chain_data.size();};
    loadable_Object_ref last();

    loadable_Object_ref operator[](size_t i);
    const std::string& name(size_t i);
private:
    std::vector<std::pair<std::string, loadable_Object_ref> > chain_data;

};

/*
   component_range will pass components enumerated 
   by e.g. job_0, job_1, job_2, ....
*/
template <class container_type>

class component_range{
public:

    typedef typename container_type::value_type container_element;
    typedef typename container_element::element_type T;

    typedef STD_TR1::shared_ptr< container_type > return_type;
    
    
    static return_type parse(const std::string&, STD_TR1::shared_ptr<loadable_Object>);
    static return_type parse(const std::string&, STD_TR1::shared_ptr<const loadable_Object>);
private:

    component_range();
    
    static return_type create_single(const std::string&, STD_TR1::shared_ptr<loadable_Object>);
    static return_type create_single(const std::string&, STD_TR1::shared_ptr<const loadable_Object>);
    static return_type create_aufzaehlung(const std::string&, STD_TR1::shared_ptr<loadable_Object>);    
    static return_type create_aufzaehlung(const std::string&, STD_TR1::shared_ptr<const loadable_Object>);    
};

/*
   param_range will pass parameters (either double, int, or std::string) enumerated 
   by e.g. var_0, var_1, var_2, ...., or by  var_N, var_min, var_step, ...,
   for details see \ref Enumeration.
   It returns a std::vector of parsed values.
   You will not need to instantiate any object, just use the static 
   parse function, e.g.

   param_range<double>::return_type energies(param_range<double>::parse("EF",get_ref()));
   to init a vector of energies determined by EF_0,..., EF_min,... or EF_rand_min,...
*/
template <class T>
class param_range{
public:
    typedef std::vector<T> container_type;
    typedef STD_TR1::shared_ptr< container_type > return_type;

    static return_type parse(const std::string&,STD_TR1::shared_ptr<loadable_Object>);
private:

    bool check_exist(const std::string&);
    
    const std::string& param;
    STD_TR1::shared_ptr<loadable_Object> my_obj;

    param_range();
    param_range(const param_range&);

    param_range(const std::string&, STD_TR1::shared_ptr<loadable_Object>);

    return_type create_single();
    return_type create_continuum();
    return_type create_random();
    return_type create_aufzaehlung();    
    
};

#include "xml_utils.tpp"
#endif