property.h

Go to the documentation of this file.

/*
 * Copyright 2009-2020 The VOTCA Development Team (http://www.votca.org)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
 
#ifndef VOTCA_TOOLS_PROPERTY_H
#define VOTCA_TOOLS_PROPERTY_H
 
// Standard includes
#include <cstdlib>
#include <exception>
#include <iostream>
#include <list>
#include <map>
#include <stdexcept>
#include <string>
 
// Third party includes
#include <boost/algorithm/string/trim.hpp>
#include <boost/format.hpp>
#include <utility>
 
// Local VOTCA includes
#include "eigen.h"
#include "lexical_cast.h"
#include "tokenizer.h"
#include "types.h"
 
namespace votca {
namespace tools {
 
class Property {
 
  friend std::ostream &operator<<(std::ostream &out, const Property &p);
 
 public:
  Property() = default;
  Property(const std::string &name, const std::string &value,
           const std::string &path)
      : name_(name), value_(value), path_(path) {}
 
  Property &add(const std::string &key, const std::string &value);
 
  Property &add(const Property &other);
 
  Property &addTree(const std::string &key, const std::string &value);
  Property &addTree(const std::vector<std::string> &key,
                    const std::string &value);
 
  Property &set(const std::string &key, const std::string &value);
 
  Property &get(const std::string &key);
  const Property &get(const std::string &key) const;
 
  Property &getOradd(const std::string &key);
 
  bool exists(const std::string &key) const;
 
  template <typename T>
  T ifExistsReturnElseReturnDefault(const std::string &key,
                                    T defaultvalue) const;
 
  std::vector<Property *> Select(const std::string &filter);
  std::vector<const Property *> Select(const std::string &filter) const;
 
  std::string &value() { return value_; }
  const std::string &value() const { return value_; }
  std::string &name() { return name_; }
  const std::string &name() const { return name_; }
  std::string &path() { return path_; }
  const std::string &path() const { return path_; }
  template <typename T>
  T as() const;
 
  bool HasChildren() const { return !map_.empty(); }
 
  using iterator = std::vector<Property>::iterator;
  using const_iterator = std::vector<Property>::const_iterator;
  iterator begin() { return properties_.begin(); }
  const_iterator begin() const { return properties_.begin(); }
  iterator end() { return properties_.end(); }
  const_iterator end() const { return properties_.end(); }
  Index size() const { return Index(properties_.size()); }
 
  template <class cond>
  void deleteChildren(cond condition);
 
  template <typename T>
  T getAttribute(const std::string &attribute) const;
  template <typename T>
  void setAttribute(const std::string &attribute, const T &value);
 
  void deleteAttribute(const std::string &attribute);
  bool hasAttributes() const { return attributes_.size() > 0; }
  bool hasAttribute(const std::string &attribute) const;
  typedef std::map<std::string, std::string>::iterator AttributeIterator;
  typedef std::map<std::string, std::string>::const_iterator
      const_AttributeIterator;
  AttributeIterator findAttribute(const std::string &attribute) {
    return attributes_.find(attribute);
  }
  const_AttributeIterator findAttribute(const std::string &attribute) const {
    return attributes_.find(attribute);
  }
  AttributeIterator firstAttribute() { return attributes_.begin(); }
  const_AttributeIterator firstAttribute() const { return attributes_.begin(); }
  AttributeIterator lastAttribute() { return attributes_.end(); }
  const_AttributeIterator lastAttribute() const { return attributes_.end(); }
  template <typename T>
  T getAttribute(AttributeIterator it);
 
  template <typename T>
  T getAttribute(const_AttributeIterator it) const;
 
  void LoadFromXML(std::string filename);
 
  static Index getIOindex() { return IOindex; };
 
 private:
  std::map<std::string, std::vector<Index>> map_;
  std::map<std::string, std::string> attributes_;
  std::vector<Property> properties_;
 
  std::string name_ = "";
  std::string value_ = "";
  std::string path_ = "";
 
  static const Index IOindex;
};
 
template <typename T>
inline T Property::as() const {
  std::string trimmed = value_;
  boost::trim(trimmed);
  try {
    return convertFromString<T>(trimmed);
  } catch (std::runtime_error &e) {
    throw std::runtime_error("Property with name '" + name() + "' in path '" +
                             path() + "' and value :" + e.what());
  }
}
 
template <typename T>
inline T Property::getAttribute(
    std::map<std::string, std::string>::const_iterator it) const {
  if (it != attributes_.end()) {
    return convertFromString<T>(it->second);
  } else {
    std::stringstream s;
    s << *this << std::endl;
    throw std::runtime_error(s.str() + "attribute " + it->first +
                             " not found\n");
  }
}
 
template <typename T>
inline T Property::getAttribute(const std::string &attribute) const {
  std::map<std::string, std::string>::const_iterator it =
      attributes_.find(attribute);
  return getAttribute<T>(it);
}
template <typename T>
inline void Property::setAttribute(const std::string &attribute,
                                   const T &value) {
  attributes_[attribute] =
      lexical_cast<std::string>(value, "wrong type to set attribute");
}
 
template <typename T>
inline T Property::ifExistsReturnElseReturnDefault(const std::string &key,
                                                   T defaultvalue) const {
  T result;
  if (this->exists(key)) {
    result = this->get(key).as<T>();
  } else {
    result = defaultvalue;
  }
  return result;
}
 
template <>
inline std::string Property::ifExistsReturnElseReturnDefault(
    const std::string &key, std::string defaultvalue) const {
  std::string result;
  if (this->exists(key)) {
    result = this->get(key).as<std::string>();
    if (result.empty()) {
      result = defaultvalue;
    }
  } else {
    result = defaultvalue;
  }
  return result;
}
 
template <class cond>
void Property::deleteChildren(cond condition) {
 
  properties_.erase(
      std::remove_if(properties_.begin(), properties_.end(), condition),
      properties_.end());
 
  // rebuild map_
  map_.clear();
  Index index = 0;
  for (const auto &prop : properties_) {
    map_[prop.name()].push_back(index);
    index++;
  }
  return;
}
 
}  // namespace tools
}  // namespace votca
 
#endif  // VOTCA_TOOLS_PROPERTY_H