FileEnumerator.hh

Go to the documentation of this file.

#ifndef CASM_FileEnumerator
#define CASM_FileEnumerator
 
#include <boost/filesystem.hpp>
 
#include "casm/app/DirectoryStructure.hh"
#include "casm/app/ProjectSettings.hh"
#include "casm/clex/PrimClex.hh"
#include "casm/clex/Supercell.hh"
#include "casm/database/DatabaseTypes_impl.hh"
 
namespace CASM {
 
// -- Get lists of files -----------------------------
 
class FileEnumerator {
 public:
  FileEnumerator(const PrimClex &_primclex, bool _all_settings = false,
                 bool _relative = false);
 
  template <typename OutputIterator>
  OutputIterator basic_files(OutputIterator result);
 
  template <typename OutputIterator>
  OutputIterator bset_files(OutputIterator result);
 
  template <typename OutputIterator>
  OutputIterator reference_files(OutputIterator result);
 
  template <typename OutputIterator>
  OutputIterator eci_files(OutputIterator result);
 
  template <typename OutputIterator>
  OutputIterator calc_settings_files(OutputIterator result);
 
  template <typename OutputIterator>
  OutputIterator calc_status_files(OutputIterator result);
 
  template <typename OutputIterator>
  OutputIterator all_calc_files(OutputIterator result);
 
 private:
  fs::path _if_relative(fs::path path);
 
  template <typename OutputIterator>
  OutputIterator _if_exists(OutputIterator result, fs::path path);
 
  template <typename OutputIterator>
  OutputIterator _all_that_exist(OutputIterator result, fs::path location);
 
  const PrimClex &m_primclex;
  DirectoryStructure m_dir;
  ProjectSettings m_set;
  bool m_all_settings;
  bool m_relative;
 
  std::vector<std::string> m_all_bset;
  std::vector<std::string> m_all_calctype;
  std::vector<std::string> m_all_property;
};
 
FileEnumerator::FileEnumerator(const PrimClex &_primclex, bool _all_settings,
                               bool _relative)
    :
 
      m_primclex(_primclex),
      m_dir(m_primclex.dir()),
      m_set(m_primclex.settings()),
      m_all_settings(_all_settings),
      m_relative(_relative),
      m_all_bset(m_dir.all_bset()),
      m_all_calctype(m_dir.all_calctype()),
      m_all_property(m_dir.all_property()) {}
 
inline fs::path FileEnumerator::_if_relative(fs::path path) {
  if (m_relative) {
    auto a = m_primclex.dir().root_dir().string().size() + 1;
    auto b = path.string().size();
    return fs::path(path.string().substr(a, b));
  }
  return path;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::_if_exists(OutputIterator result,
                                          fs::path path) {
  if (fs::exists(path)) {
    *result++ = _if_relative(path);
  }
  return result;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::_all_that_exist(OutputIterator result,
                                               fs::path location) {
  std::vector<fs::path> all;
  std::string dir;
 
  // get all
  if (!fs::exists(location)) {
    return result;
  }
  fs::directory_iterator it(location);
  fs::directory_iterator end_it;
  for (; it != end_it; ++it) {
    if (fs::is_regular_file(*it)) {
      *result++ = _if_relative(it->path());
    }
  }
  return result;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::basic_files(OutputIterator result) {
  std::vector<fs::path> v{m_dir.prim(),  // m_dir.PRIM(),
                          m_dir.project_settings(),
                          m_dir.config_list(),
                          m_dir.SCEL(),
                          m_dir.lattice_point_group(),
                          m_dir.factor_group(),
                          m_dir.crystal_point_group()};
  for (auto it = v.begin(); it != v.end(); ++it) {
    result = _if_exists(result, *it);
  }
  result = _all_that_exist(result, m_dir.enumerator_plugins());
  return result;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::bset_files(OutputIterator result) {
  // bset dependent:
  for (auto bset : m_all_bset) {
    if (!m_all_settings && bset != m_set.default_clex().bset) {
      continue;
    }
    result = _if_exists(result, m_dir.bspecs(bset));
    result = _if_exists(result, m_dir.clust(bset));
    result = _if_exists(result, m_dir.basis(bset));
    result =
        _if_exists(result, m_dir.clexulator_src(m_set.project_name(), bset));
  }
  return result;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::reference_files(OutputIterator result) {
  // calctype / ref dependent
  for (auto calctype : m_all_calctype) {
    if (!m_all_settings && calctype != m_set.default_clex().calctype) {
      continue;
    }
    auto all_ref = m_dir.all_ref(calctype);
    for (auto ref : all_ref) {
      if (!m_all_settings && ref != m_set.default_clex().ref) {
        continue;
      }
      result = _if_exists(result, m_dir.composition_axes());
      result = _if_exists(result, m_dir.chemical_reference(calctype, ref));
    }
  }
  return result;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::eci_files(OutputIterator result) {
  // eci
  if (!m_all_settings) {
    result = _if_exists(
        result,
        m_dir.eci(m_set.default_clex().property, m_set.default_clex().calctype,
                  m_set.default_clex().ref, m_set.default_clex().bset,
                  m_set.default_clex().eci));
  } else {
    for (auto clex : m_all_property) {
      for (auto calctype : m_all_calctype) {
        auto all_ref = m_dir.all_ref(calctype);
        for (auto ref : all_ref) {
          for (auto bset : m_all_bset) {
            auto all_eci = m_dir.all_eci(clex, calctype, ref, bset);
            for (auto eci : all_eci) {
              result =
                  _if_exists(result, m_dir.eci(clex, calctype, ref, bset, eci));
            }
          }
        }
      }
    }
  }
  return result;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::calc_settings_files(OutputIterator result) {
  for (auto calctype : m_all_calctype) {
    if (!m_all_settings && calctype != m_set.default_clex().calctype) {
      continue;
    }
 
    // calculation settings: global
    result = _all_that_exist(result, m_dir.calc_settings_dir(calctype));
 
    // supercell level
    for (const auto &scel : m_primclex.db<Supercell>()) {
      result = _all_that_exist(
          result, m_dir.supercell_calc_settings_dir(scel.name(), calctype));
    }
 
    // configuration level
    for (const auto &config : m_primclex.db<Configuration>()) {
      result = _all_that_exist(result, m_dir.configuration_calc_settings_dir(
                                           config.name(), calctype));
    }
  }
  return result;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::calc_status_files(OutputIterator result) {
  for (auto calctype : m_all_calctype) {
    if (!m_all_settings && calctype != m_set.default_clex().calctype) {
      continue;
    }
 
    // calculation summaries: properties.calc.json, status.json
    for (const auto &config : m_primclex.db<Configuration>()) {
      result = _if_exists(result,
                          m_dir.calculated_properties(config.name(), calctype));
      result = _if_exists(result, m_dir.calc_status(config.name(), calctype));
    }
  }
  return result;
}
 
template <typename OutputIterator>
OutputIterator FileEnumerator::all_calc_files(OutputIterator result) {
  // get all files in 'training_data', recursively
  fs::recursive_directory_iterator it(m_dir.training_data()), end;
  std::string pattern = "calctype.";
  for (; it != end; ++it) {
    // if not requesting all settings
    if (!m_all_settings) {
      // avoid recursing into other calctypes
      if (fs::is_directory(*it)) {
        std::string dir = it->path().filename().string();
        if (dir.substr(0, pattern.size()) == pattern) {
          if (dir.substr(pattern.size(), dir.size()) !=
              m_set.default_clex().calctype) {
            it.no_push();
          }
        }
      }
    }
 
    if (fs::is_regular_file(*it)) {
      *result++ = _if_relative(it->path());
    }
  }
  return result;
}
 
}  // namespace CASM
 
#endif