params.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2018 ALPS Collaboration. See COPYRIGHT.TXT
 * All rights reserved. Use is subject to license terms. See LICENSE.TXT
 * For use in publications, see ACKNOWLEDGE.TXT
 */

#ifndef ALPS_PARAMS_HPP_INCLUDED_00f672a032d949a7aa0e760a6b6f0602
#define ALPS_PARAMS_HPP_INCLUDED_00f672a032d949a7aa0e760a6b6f0602

#include "alps/config.hpp"
#include "alps/hdf5/archive.hpp"
#include <alps/utilities/deprecated.hpp>


#ifdef ALPS_HAVE_MPI
#include <alps/utilities/mpi.hpp>
#include <alps/utilities/mpi_pair.hpp>
#endif

#include <map>
#include <iosfwd>

#include "./dictionary.hpp"

namespace alps {
    namespace params_ns {

        namespace detail {
            struct make_typestr : public boost::static_visitor<std::string> {
                template <typename T>
                std::string operator()(const T&) const { return apply<T>(); }

                template <typename T>
                static std::string apply() { return detail::type_info<T>::pretty_name(); }
            };

            struct td_type {
                std::string typestr_;
                std::string descr_;
                int defnumber_;
                std::string& typestr() { return typestr_; }
                const std::string& typestr() const { return typestr_; }
                std::string& descr() { return descr_; }
                const std::string& descr() const { return descr_; }
                int defnumber() const { return defnumber_; }
                int& defnumber() { return defnumber_; }
                td_type(const std::string& t, const std::string& d, int n) : typestr_(t), descr_(d), defnumber_(n) {}
                template <typename T>
                static td_type make_pair(const std::string& d, int n) { return td_type(make_typestr::apply<T>(), d, n); }
                td_type() : typestr_(), descr_(), defnumber_(-1) {}
                bool operator==(const td_type& rhs) const {
                    return typestr_==rhs.typestr_ &&
                           descr_==rhs.descr_ &&
                           defnumber_==rhs.defnumber_;
                }
            };
        } // detail::



        class params : public dictionary {
          private:
            typedef std::map<std::string,std::string> strmap;
            typedef std::vector<std::string> strvec;

            // Small inner class to keep "origins" together
            struct origins_type {
                enum {
                    ARGV0=0,
                    ARCHNAME=1,
                    INIFILES=2
                };

                strvec data_;
                origins_type(): data_(INIFILES) {}
                strvec& data() { return data_; }
                const strvec& data() const { return data_; }
                void check() {
                    if (data_.size()<INIFILES)
                        throw std::logic_error("params::origins_type invariants violation");
                }
            };

            typedef std::map<std::string, detail::td_type> td_map_type;

            strmap raw_kv_content_;
            td_map_type td_map_;
            strvec err_status_;
            origins_type origins_;
            std::string help_header_;

            void read_ini_file_(const std::string& inifile);
            void initialize_(int argc, const char* const* argv, const char* hdf5_path);

            template <typename T>
            bool assign_to_name_(const std::string& name, const std::string& strval);

            bool has_unused_(std::ostream& out, const std::string* prefix_ptr) const;

            template <typename T>
            bool define_(const std::string& name, const std::string& descr);

          public:
            params() : dictionary(), raw_kv_content_(), td_map_(), err_status_(), origins_(), help_header_() {}


            params(const std::string& inifile);


            params(int argc, const char* const* argv, const char* hdf5_path="/parameters");

            std::string get_argv0() const;

            std::string get_ini_name(int n) const;

            int get_ini_name_count() const;



            std::string get_origin_name() const ALPS_DEPRECATED;

            // FIXME: 1) Make these exception types derived from some `params::exception`;
            //        2) Define them ouside and typedef here.

            struct not_restored : public std::runtime_error {
                not_restored(const std::string& a_what)
                    : std::runtime_error(a_what) {}
            };

            class archive_conflict : public std::runtime_error {
                std::vector<std::string> fnames_;
              public:
                archive_conflict(const std::string& a_what, const std::string& fname1, const std::string& fname2)
                    : std::runtime_error(a_what+"; name1='"+fname1+"' name2='"+fname2+"'"),
                      fnames_({fname1, fname2})
                { }

                const std::string& get_name(unsigned int i) const {
                    return fnames_[i % fnames_.size()];
                }

                const std::vector<std::string>& get_names() const {
                    return fnames_;
                }
            };

            bool is_restored() const { return !origins_.data()[origins_type::ARCHNAME].empty(); }

            std::string get_archive_name() const;

            bool ok() const { return err_status_.empty(); }

            bool has_missing() const { return !ok(); }

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

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

            bool has_unused(std::ostream& out) const;


            bool has_unused(std::ostream& out, const std::string& subsection) const;

            bool has_missing(std::ostream& out) const;

            bool help_requested() const;

            bool help_requested(std::ostream&) const;

            std::ostream& print_help(std::ostream&) const;

            bool operator==(const params& rhs) const;


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

            template<typename T>
            params& define(const std::string& name, const std::string& descr);

            template<typename T>
            params& define(const std::string& name, const T& defval, const std::string& descr);

            params& define(const std::string& name, const std::string& descr) {
                return define<bool>(name, false, descr);
            }

            params& description(const std::string& message);

            const std::string get_descr(const std::string& name) const;

            friend void swap(params& p1, params& p2);

            void save(alps::hdf5::archive&) const;

            void load(alps::hdf5::archive&);

            friend
            std::ostream& operator<<(std::ostream&, const params&);

#ifdef ALPS_HAVE_MPI
            // FIXME: should it be virtual?
            void broadcast(const alps::mpi::communicator& comm, int root);


            params(int argc, const char* const* argv, const alps::mpi::communicator& comm, int root=0, const char* hdf5_path="/parameters")
                : dictionary(),
                  raw_kv_content_(),
                  td_map_(),
                  err_status_(),
                  origins_(),
                  help_header_()

            {
                initialize_(argc,argv,hdf5_path);
                broadcast(comm, root);
            }
#endif
        };


        std::string origin_name(const params& p);

    } // params_ns::
    typedef params_ns::params params;

#ifdef ALPS_HAVE_MPI
    namespace mpi {

        inline void broadcast(const alps::mpi::communicator& comm, alps::params_ns::detail::td_type& td, int root) {
            broadcast(comm, td.typestr_, root);
            broadcast(comm, td.descr_, root);
            broadcast(comm, td.defnumber_, root);
        }

        inline void broadcast(const alps::mpi::communicator &comm, alps::params_ns::dictionary& dict, int root) {
            dict.broadcast(comm, root);
        }

        inline void broadcast(const alps::mpi::communicator &comm, alps::params_ns::params& p, int root) {
            p.broadcast(comm, root);
        }
    } // mpi::
#endif

} // alps::

#include "./params/params_impl.hpp"


#endif /* ALPS_PARAMS_HPP_INCLUDED_00f672a032d949a7aa0e760a6b6f0602 */