PropertiesDatabase.hh

Go to the documentation of this file.

#ifndef CASM_PropertiesDatabase
#define CASM_PropertiesDatabase
 
#include <boost/iterator/iterator_facade.hpp>
#include <set>
#include <string>
 
#include "casm/clex/MappedProperties.hh"
#include "casm/database/Database.hh"
 
namespace CASM {
struct MappedProperties;
 
namespace DB {
 
class PropertiesDatabaseIterator;
 
class PropertiesDatabaseIteratorBase {
  friend PropertiesDatabaseIterator;
 
 public:
  typedef MappedProperties value_type;
  typedef const value_type &reference;
 
  PropertiesDatabaseIteratorBase() {}
  virtual ~PropertiesDatabaseIteratorBase() {}
 
  std::unique_ptr<PropertiesDatabaseIteratorBase> clone() const {
    return std::unique_ptr<PropertiesDatabaseIteratorBase>(this->_clone());
  }
 
 private:
  virtual void increment() = 0;
 
  virtual reference dereference() const = 0;
 
  virtual bool equal(const PropertiesDatabaseIteratorBase &other) const = 0;
 
  virtual PropertiesDatabaseIteratorBase *_clone() const = 0;
 
  virtual long distance_to(
      const PropertiesDatabaseIteratorBase &other) const = 0;
};
 
 
class PropertiesDatabaseIterator :
 
    public boost::iterator_facade<PropertiesDatabaseIterator, MappedProperties,
                                  std::forward_iterator_tag,
                                  const MappedProperties &, long> {
 public:
  PropertiesDatabaseIterator() {}
 
  PropertiesDatabaseIterator(const PropertiesDatabaseIteratorBase &it)
      : m_ptr(notstd::clone(it)) {}
 
  PropertiesDatabaseIteratorBase *get() const { return m_ptr.unique().get(); }
 
 private:
  friend boost::iterator_core_access;
 
  void increment() { m_ptr->increment(); }
 
  const MappedProperties &dereference() const { return m_ptr->dereference(); }
 
  bool equal(const PropertiesDatabaseIterator &B) const {
    return m_ptr->equal(*(B.m_ptr));
  }
 
  long distance_to(const PropertiesDatabaseIterator &B) const {
    return m_ptr->distance_to(*(B.m_ptr));
  }
 
  notstd::cloneable_ptr<PropertiesDatabaseIteratorBase> m_ptr;
};
 
class PropertiesDatabase : public DatabaseBase {
 public:
  class Compare {
   public:
    Compare(const PropertiesDatabase *_map, std::string _to_configname,
            const ScoreMappedProperties &_score)
        : m_map(_map), m_to(_to_configname), m_score(_score) {}
 
    bool operator()(const std::string &origin_A,
                    const std::string &origin_B) const;
 
    const ScoreMappedProperties &score_method() const { return m_score; }
 
   private:
    const PropertiesDatabase *m_map;
    std::string m_to;
    ScoreMappedProperties m_score;
  };
 
  typedef MappedProperties value_type;
  typedef PropertiesDatabaseIterator iterator;
  typedef Index size_type;
 
  PropertiesDatabase(const PrimClex &_primclex) : DatabaseBase(_primclex) {}
 
  virtual iterator begin() const = 0;
 
  virtual iterator end() const = 0;
 
  virtual size_type size() const = 0;
  bool empty() const { return this->size() == 0; }
 
  virtual iterator find_via_to(std::string to_configname) const = 0;
 
  virtual iterator find_via_origin(std::string origin) const = 0;
 
  virtual std::set<std::string, Compare> all_origins(
      std::string to_configname) const = 0;
 
  virtual void set_score_method(std::string to_configname,
                                const ScoreMappedProperties &score) = 0;
 
  ScoreMappedProperties score_method(std::string to_configname) const {
    return all_origins(to_configname).value_comp().score_method();
  }
 
  double best_score(std::string to_configname) const {
    return score(*find_via_to(to_configname));
  }
 
  double score(std::string origin) const {
    return score(*find_via_origin(origin));
  }
 
  double score(const MappedProperties &value) const {
    return score_method(value.to)(value);
  }
 
  std::pair<iterator, bool> insert(const MappedProperties &value);
 
  iterator erase(iterator pos);
 
  size_type erase_via_origin(std::string origin) {
    auto it = find_via_origin(origin);
    if (it == end()) {
      return 0;
    }
    erase(it);
    return 1;
  }
 
 private:
  virtual std::pair<iterator, bool> _insert(const MappedProperties &value) = 0;
 
  virtual iterator _erase(iterator pos) = 0;
 
  virtual void _set_all_origins(std::string to_configname,
                                const std::set<std::string, Compare> &_set) = 0;
};
 
}  // namespace DB
}  // namespace CASM
 
#endif