Database.hh

Go to the documentation of this file.

#ifndef CASM_Database
#define CASM_Database
 
#include <algorithm>
#include <boost/iterator/iterator_facade.hpp>
#include <iterator>
#include <map>
#include <memory>
 
#include "casm/clex/HasPrimClex.hh"
#include "casm/database/Selection_impl.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/cloneable_ptr.hh"
 
namespace CASM {
 
class PrimClex;
 
namespace DB {
 
template <typename ObjType>
class Selection;
 
class DatabaseBase : public HasPrimClex<CRTPBase<DatabaseBase>> {
 public:
  DatabaseBase(const PrimClex &_primclex) : m_primclex(&_primclex) {}
 
  virtual ~DatabaseBase() {}
 
  virtual DatabaseBase &open() = 0;
  virtual void commit() = 0;
  virtual void close() = 0;
 
  const PrimClex &primclex() const { return *m_primclex; }
 
 private:
  const PrimClex *m_primclex;
};
 
template <typename ValueType>
class DatabaseIterator;
 
template <typename ValueType>
class DatabaseIteratorBase {
  friend DatabaseIterator<ValueType>;
 
 public:
  typedef ValueType value_type;
  typedef const value_type &reference;
 
  DatabaseIteratorBase() {}
  virtual ~DatabaseIteratorBase() {}
 
  virtual std::string name() const = 0;
 
  std::unique_ptr<DatabaseIteratorBase> clone() const {
    return std::unique_ptr<DatabaseIteratorBase>(this->_clone());
  }
 
 private:
  virtual void increment() = 0;
 
  virtual reference dereference() const = 0;
 
  virtual bool equal(const DatabaseIteratorBase<ValueType> &other) const = 0;
 
  virtual DatabaseIteratorBase *_clone() const = 0;
 
  /* Do not implement this
  virtual long distance_to(const DatabaseIteratorBase<ValueType> &other) const =
  0;
  */
};
 
 
template <typename ValueType>
class DatabaseIterator :
 
    public boost::iterator_facade<DatabaseIterator<ValueType>, ValueType,
                                  std::forward_iterator_tag, const ValueType &,
                                  long> {
 public:
  DatabaseIterator() {}
 
  DatabaseIterator(const DatabaseIteratorBase<ValueType> &it)
      : m_ptr(notstd::clone(it)) {}
 
  std::string name() const { return m_ptr->name(); }
 
  DatabaseIteratorBase<ValueType> *get() const { return m_ptr.unique().get(); }
 
 private:
  friend boost::iterator_core_access;
 
  void increment() { m_ptr->increment(); }
 
  const ValueType &dereference() const { return m_ptr->dereference(); }
 
  bool equal(const DatabaseIterator &B) const {
    return m_ptr->equal(*(B.m_ptr));
  }
 
  /*
  long distance_to(const DatabaseIterator &B) const {
    Do not define this or boost::iterator_range<T>::size will compile but
    cause runtime errors. Use boost::distance instead.
  }
  */
 
  notstd::cloneable_ptr<DatabaseIteratorBase<ValueType>> m_ptr;
};
 
template <typename ValueType>
class ValDatabase : public DatabaseBase {
 public:
  typedef DatabaseIterator<ValueType> iterator;
  typedef ValueType value_type;
  typedef Index size_type;
 
  ValDatabase(const PrimClex &_primclex) : DatabaseBase(_primclex) {}
 
  virtual ~ValDatabase() {}
 
  virtual iterator begin() const = 0;
 
  virtual iterator end() const = 0;
 
  virtual size_type size() const = 0;
  bool empty() const { return this->size() == 0; }
 
  std::pair<iterator, bool> set_alias(const std::string &name_or_alias,
                                      const std::string &alias);
 
  std::string name(const std::string &name_or_alias) const;
 
  std::string alias(const std::string &name_or_alias) const;
 
  virtual std::pair<iterator, bool> insert(const ValueType &obj) = 0;
  virtual std::pair<iterator, bool> insert(const ValueType &&obj) = 0;
 
  template <typename InputIt>
  void insert(InputIt first, InputIt last) {
    std::for_each(first, last,
                  [&](const ValueType &obj) { this->insert(obj); });
  }
 
  virtual iterator erase(iterator pos) = 0;
  size_type erase(const std::string &name_or_alias) {
    this->erase(this->find(name_or_alias));
    return 1;
  }
  size_type erase(const ValueType &obj) { return this->erase(obj.name()); }
 
  virtual size_type count(const std::string &name_or_alias) const {
    if (this->find(name_or_alias) != this->end()) {
      return 1;
    }
    return 0;
  }
 
  virtual iterator find(const std::string &name_or_alias) const = 0;
 
  /* Don't do this, it's confusing. Use find(obj.name) or insert(obj):
  iterator find(const ValueType &obj) const {
    return find(obj.name());
  }
  */
 
  virtual void commit() = 0;
 
  Selection<ValueType> &master_selection() { return m_master_selection; }
 
  const Selection<ValueType> &master_selection() const {
    return m_master_selection;
  }
 
 protected:
  void read_aliases();
 
  void write_aliases();
 
  template <typename _ValueType>
  void clear_name(const _ValueType &obj) const {
    obj.clear_name();
  }
 
  template <typename _ValueType>
  void set_id(const _ValueType &obj, Index id) const {
    obj.set_id(id);
  }
 
  template <typename _ValueType>
  void set_id(const _ValueType &obj, std::string id) const {
    obj.set_id(id);
  }
 
 private:
  // enable lookup of name -> alias
  std::map<std::string, std::string> m_name_to_alias;
 
  // enable lookup of alias -> name
  std::map<std::string, std::string> m_alias_to_name;
 
  // Master selection to update upon insertion or removal.
  Selection<ValueType> m_master_selection;
};
 
template <typename ValueType>
class Database;
 
}  // namespace DB
}  // namespace CASM
 
#endif