DatabaseTypes.hh

Go to the documentation of this file.

#ifndef CASM_DatabaseTypes
#define CASM_DatabaseTypes
 
#include <boost/preprocessor/seq/enum.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <set>
 
#include "casm/database/DatabaseTypesTraits.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/CASM_TMP.hh"
 
// 1) add Database types here
#define CASM_DB_NONCONFIG_TYPES (Supercell)
#define CASM_DB_CONFIG_TYPES (Configuration)
 
// 2) add #include locations as appropriate to:
//    DatabaseTypeDefs.hh, DatabaseTypeTraits.hh,
//    ConfigTypeDefs.hh, ConfigTypeTraits.hh
 
// --- the rest works based on ^ -----------------------------------------------
 
#define CASM_DB_TYPES CASM_DB_NONCONFIG_TYPES CASM_DB_CONFIG_TYPES
 
namespace CASM {
 
class PrimClex;
 
namespace DB {
 
// List of all types stored in a Database
typedef std::tuple<BOOST_PP_SEQ_ENUM(CASM_DB_TYPES)> DataObjectTypeTuple;
 
// List of all configtypes which have calculations stored in a
// PropertiesDatabase
typedef std::tuple<BOOST_PP_SEQ_ENUM(CASM_DB_CONFIG_TYPES)> ConfigTypeTuple;
 
// -- SFINAE helper --
 
template <typename T>
using IfConfigType =
    std::enable_if<CASM_TMP::has_type<T, ConfigTypeTuple>::value, T>;
 
template <typename T>
using IfNotConfigType =
    std::enable_if<!CASM_TMP::has_type<T, ConfigTypeTuple>::value, T>;
 
// -- List of Database DataObject and ConfigType --
 
template <typename F>
void for_each_type(F f) {
  return CASM_TMP::for_each_type<DataObjectTypeTuple, F>(f);
}
 
template <typename F>
void for_type(std::string name, F f) {
  return CASM_TMP::for_type<DataObjectTypeTuple, F>(name, f);
}
 
template <typename F>
void for_type_short(std::string short_name, F f) {
  return CASM_TMP::for_type_short<DataObjectTypeTuple, F>(short_name, f);
}
 
const std::set<std::string> &types();
 
const std::set<std::string> &types_short();
 
template <typename F>
void for_each_config_type(F f) {
  return CASM_TMP::for_each_type<ConfigTypeTuple, F>(f);
}
 
template <typename F>
void for_config_type(std::string name, F f) {
  return CASM_TMP::for_type<ConfigTypeTuple, F>(name, f);
}
 
template <typename F>
void for_config_type_short(std::string short_name, F f) {
  return CASM_TMP::for_type_short<ConfigTypeTuple, F>(short_name, f);
}
 
const std::set<std::string> &config_types();
 
const std::set<std::string> &config_types_short();
 
Index config_count(std::string scelname, const PrimClex &primclex);
 
Index config_count(std::string configtype, std::string scelname,
                   const PrimClex &primclex);
 
Index config_calculated_count(std::string scelname, const PrimClex &primclex);
 
Index config_calculated_count(std::string configtype, std::string scelname,
                              const PrimClex &primclex);
 
Index config_data_count(std::string scelname, const PrimClex &primclex);
 
Index config_data_count(std::string configtype, std::string scelname,
                        const PrimClex &primclex);
 
}  // namespace DB
}  // namespace CASM
 
#endif