dictionary.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_DICTIONARY_HPP_e15039548f43464996cad06f9c8a3220
#define ALPS_PARAMS_DICTIONARY_HPP_e15039548f43464996cad06f9c8a3220

#include <alps/config.hpp>
#include <map>
#include "./params/dict_value.hpp"

namespace alps {
    namespace params_ns {

        class dictionary {
          public:
            typedef dict_value value_type;

          private:
            typedef std::map<std::string, value_type> map_type;
            map_type map_;

          public:
            typedef map_type::const_iterator const_iterator;

            const_iterator begin() const { return map_.begin(); }

            const_iterator end() const { return map_.end(); }

            virtual ~dictionary() {}

            bool empty() const { return map_.empty(); }

            std::size_t size() const { return map_.size(); }

            void erase(const std::string& key) { map_.erase(key); }

            value_type& operator[](const std::string& key);

            const value_type& operator[](const std::string& key) const;

            const_iterator find(const std::string& key) const {
                return map_.find(key);
            }

          private:
            map_type::const_iterator find_nonempty_(const std::string& key) const;

          public:

            bool exists(const std::string& key) const {
                return find_nonempty_(key)!=map_.end();
            }

            template <typename T>
            bool exists(const std::string& key) const {
                map_type::const_iterator it=find_nonempty_(key);
                return it!=map_.end() && (it->second).isType<T>();
            }

            friend void swap(dictionary& d1, dictionary& d2) { using std::swap; swap(d1.map_, d2.map_); }

            bool equals(const dictionary& rhs) const;

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

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

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

#ifdef ALPS_HAVE_MPI
            void broadcast(const alps::mpi::communicator& comm, int root);
#endif
        };

        inline bool operator==(const dictionary& lhs, const dictionary& rhs) {
            return lhs.equals(rhs);
        }

        inline bool operator!=(const dictionary& lhs, const dictionary& rhs) {
            return !(lhs==rhs);
        }


        template <typename F>
        inline typename F::result_type apply_visitor(F& visitor, dictionary::const_iterator it) {
            return boost::apply_visitor(visitor, it->second);
        }


        template <typename F>
        inline typename F::result_type apply_visitor(const F& visitor, dictionary::const_iterator it) {
            return boost::apply_visitor(visitor, it->second);
        }

    } // params_ns::
} // alps::


#endif /* ALPS_PARAMS_DICTIONARY_HPP_e15039548f43464996cad06f9c8a3220 */