property_map.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/util/exception.hpp>
#include <kernel/util/dist.hpp>
 
// includes, system
#include <iostream>
#include <map>
#include <memory>
 
namespace FEAT
{
  class PropertyMap
  {
  public:
    typedef std::map<String, String, String::NoCaseLess> EntryMap;
    typedef std::map<String, std::shared_ptr<PropertyMap>, String::NoCaseLess> SectionMap;
 
    typedef EntryMap::iterator EntryIterator;
    typedef EntryMap::const_iterator ConstEntryIterator;
    typedef SectionMap::iterator SectionIterator;
    typedef SectionMap::const_iterator ConstSectionIterator;
 
  protected:
    PropertyMap* _parent;
 
    EntryMap _values;
 
    SectionMap _sections;
 
  public:
    explicit PropertyMap(PropertyMap* parent = nullptr);
    PropertyMap(const PropertyMap&) = delete;
    PropertyMap& operator=(const PropertyMap&) = delete;
 
    virtual ~PropertyMap();
 
    bool add_entry(String key, String value, bool replace = true);
 
    PropertyMap* add_section(String name);
 
    bool erase_entry(String key);
 
    bool erase_section(String name);
 
    std::pair<String, bool> query(String key_path) const;
 
    String query(String key_path, String default_value) const;
 
    PropertyMap* query_section(String sec_path);
 
    const PropertyMap* query_section(String sec_path) const;
 
    std::pair<String, bool> get_entry(String key) const;
 
    PropertyMap* get_sub_section(String name);
 
    const PropertyMap* get_sub_section(String name) const;
 
    template<typename T_>
    bool parse_entry(const String& key, T_& x, bool rtn_non_exist = true) const
    {
      std::pair<String, bool> it = this->get_entry(key);
      if(it.second)
        return it.first.parse(x);
      else
        return rtn_non_exist;
    }
 
    PropertyMap* get_parent()
    {
      return _parent;
    }
 
    const PropertyMap* get_parent() const
    {
      return _parent;
    }
 
    PropertyMap* get_root()
    {
      return (_parent != nullptr) ? _parent->get_root() : this;
    }
 
    const PropertyMap* get_root() const
    {
      return (_parent != nullptr) ? _parent->get_root() : this;
    }
 
    EntryMap& get_entry_map()
    {
      return _values;
    }
 
    const EntryMap& get_entry_map() const
    {
      return _values;
    }
 
    EntryIterator begin_entry()
    {
      return _values.begin();
    }
 
    ConstEntryIterator begin_entry() const
    {
      return _values.begin();
    }
 
    EntryIterator end_entry()
    {
      return _values.end();
    }
 
    ConstEntryIterator end_entry() const
    {
      return _values.end();
    }
 
    SectionIterator begin_section()
    {
      return _sections.begin();
    }
 
    ConstSectionIterator begin_section() const
    {
      return _sections.begin();
    }
 
    SectionIterator end_section()
    {
      return _sections.end();
    }
 
    ConstSectionIterator end_section() const
    {
      return _sections.end();
    }
 
    void merge(const PropertyMap& section, bool replace = true);
 
    void read(String filename, bool replace = true)
    {
      Dist::Comm comm(Dist::Comm::world());
      read(comm, filename, replace);
    }
 
    void read(const Dist::Comm& comm, String filename, bool replace = true);
 
    void read(std::istream& ifs, bool replace = true);
 
    void write(String filename) const
    {
      Dist::Comm comm(Dist::Comm::world());
      write(comm, filename);
    }
 
    void write(const Dist::Comm& comm, String filename) const;
 
    void write(std::ostream& os, String::size_type indent = 0) const;
 
    std::unique_ptr<PropertyMap> treeify_structures() const;
  }; // class PropertyMap
} // namespace FEAT