SimpleFormatter.hh

Go to the documentation of this file.

#include <functional>
#include <string>
#include <vector>
 
namespace CASM {
 
namespace simpleformatter {
 
template <typename ObjectType>
class DataFormatter;
 
struct DatumFormatterOptions {
  int width = 12;
  int precision = 8;
  bool boolalpha = true;
};
 
template <typename ObjectType>
class BaseDatumEvaluator : public Cloneable {
 public:
  virtual std::string const &name() const = 0;
 
  virtual void format_value(DataFormatter<ObjectType> &formatter,
                            ObjectType const &object) const = 0;
 
  virtual bool is_vector() const = 0;
 
  virtual bool is_fixed_size() const = 0;
 
  virtual std::vector<std::string> const &component_names() const = 0;
 
  virtual void format_vectorized_value(DataFormatter<ObjectType> &formatter,
                                       ObjectType const &object) const = 0;
 
  virtual bool is_map() const = 0;
 
  virtual void format_mapped_value(DataFormatter<ObjectType> &formatter,
                                   ObjectType const &object) const = 0;
};
 
template <typename ObjectType, typename ValueType>
class DatumEvaluator : public BaseDatumEvaluator<ObjectType> {
  CLONEABLE(DatumEvaluator<ObjectType, ValueType>)
 public:
  typedef std::function<ValueType(ObjectType const &object)> ValueF;
 
  DatumEvaluator(std::string _name, ValueF _value_f);
 
  std::string const &name() const override;
 
  ValueType value(ObjectType const &object) const;
 
  void format_value(DataFormatter<ObjectType> &formatter,
                    ObjectType const &object) const override;
 
  bool may_be_vectorized() const override { return false; }
 
  bool is_fixed_size() const override {
    throw std::runtime_error{"DatumEvaluator::is_fixed_size: Not implemented"};
  }
 
  std::vector<std::string> const &component_names() const override {
    throw std::runtime_error{
        "DatumEvaluator::component_names: Not implemented"};
  }
 
  void format_vectorized_value(DataFormatter<ObjectType> &formatter,
                               ObjectType const &object) const override {
    throw std::runtime_error{
        "DatumEvaluator::format_vectorized_value: Not implemented"};
  }
 
 private:
  std::string m_name;
  ValueF m_value_f;
};
 
template <typename ObjectType, typename VectorizedValueType>
class VectorizedDatumEvaluator : public BaseDatumEvaluator<ObjectType> {
  CLONEABLE(DatumEvaluator<ObjectType, VectorizedValueType>)
 
 public:
  typedef std::function<VectorizedValueType(ObjectType const &)>
      FixedVectorizedValueF;
 
  typedef std::function<VectorizedValueType(ObjectType const &,
                                            std::vector<std::string> &)>
      DynamicVectorizedValueF;
 
  VectorizedDatumEvaluator(DynamicVectorizedValueF _dynamic_vectorized_value_f);
 
  VectorizedDatumEvaluator(std::vector<std::string> _component_names,
                           FixedVectorizedValueF _vectorized_value_f);
 
  bool may_be_vectorized() const override { return true; }
 
  bool is_fixed_size() const override { return m_is_fixed_size; }
 
  VectorizedValueType vectorized_value(ObjectType const &object) const;
 
  std::vector<std::string> const &component_names() const override {
    return m_component_names;
  }
 
  void format_vectorized_value(DataFormatter<ObjectType> &formatter,
                               ObjectType const &object) const override;
 
 private:
  DynamicVectorizedValueF m_dynamic_vectorized_value_f;
  FixedVectorizedValueF m_fixed_vectorized_value_f;
  bool m_is_fixed_size;
  mutable std::vector<std::string> m_component_names;
};
 
// /// Make argument expression of form "(arg1, arg2, ..)"
// std::string make_args_expression(std::vector<std::string> args) {
//   std::stringstream ss;
//   for(Index i=0; i<args.size(); ++i) {
//     if(i==0) { ss << "(";}
//     ss << args[i];
//     if(i+1==args.size()) { ss << ")";}
//     else {ss << ", ";}
//   }
//   return ss.str();
// }
//
// /// Make index expression of form "(i)"
// std::string make_index_expression(Index i) {
//   return std::string {"("} + std::to_string(i) + ")";
// }
//
// /// Make value_names (copy exactly)
// std::function<std::vector<std::string> (ValuesType const &)>
// make_value_names(std::vector<std::string> value_names) {
//   return [=](ValuesType const &values) {return value_names;};
// }
//
// /// Make scalar value_names (name -> {name})
// std::function<std::vector<std::string> (ValuesType const &)>
// make_scalar_value_names(std::string name) {
//   return [=](ValuesType const &values) {return std::vector<std::string>(1,
//   name);};
// }
//
// /// Make vector value_names (name -> {name(0), name(1), ...,
// name(values.size()-1)}) std::function<std::vector<std::string> (ValuesType
// const &)> make_vector_value_names(std::string name) {
//   return [=](ValuesType const &values) {
//     std::vector<std::string> value_names;
//     for(Index i=0; i<values.size(); ++i) {
//       std::stringstream ss;
//       ss << name << make_index_expression(i);
//       value_names.push_back(ss.str());
//     }
//     return value_names;
//   };
// }
//
// /// Make value_names by combining name and each element of args:
// ///
// /// Ex: "name" + {"Au", "Ag", ...} -> {"name(Au)", "name(Ag)", ...}
// std::function<std::vector<std::string> (ValuesType const &)>
// make_arg_value_names(
//   std::string name,
//   std::vector<std::string> const &args) {
//   std::vector<std::string> value_names;
//   for(auto const &arg : args) {
//     value_names.push_back(name + "(" + arg + ")");
//   }
//   return make_value_names(value_names);
// }
//
//
// /// Collect information during `enumerate_configurations` function for
// optional output struct ConfigQueryData {
//
//   ConfigQueryData(PrimClex const &_primclex,
//                   Configuration const &_configuration):
//     primclex(_primclex),
//     configuration(_configuration) {}
//
//   PrimClex const &primclex;
//   Configuration const &configuration;
// };
//
// /// Pass data and query expression for construction of DatumEvaluator from
// DatumEvaluatorDictionary
// ///
// /// For input `name(args[0], args[1], ...)(index_expression)`
// /// - args (comma delimited, excluding leading and trailing whitespace)
// /// - acceptable index expressions (begin with 0):
// ///   - single integer
// ///   - ranges (Python slice style):
// ///     - "3:5", position 3 (included) to position 5 (excluded)
// ///     - ":5", beginning to position 5 (excluded)
// ///     - "4:", position 4 (inclued) to end
// ///     - "-2:", second-last position (included) to end
// ///   - comma-separated integers or ranges (excluding leading and trailing
// whitespace):
// ///     - "1, 3:5, 8:", position 1, 3, 4, 5, and 8 to the end
// ///
// struct ConfigQueryInputData {
//
//   PrimClex const &primclex;
//
//   std::string expression;           // entire query expression
//   `name(args)(index_expression)` std::string name;                 // name
//   parsed from expression std::vector<std::string> args;    // args (comma
//   delimited, excluding leading and trailing whitespace) std::set<Index>
//   indices;          // indices parsed from index_expression
// };
//
// std::set<Index> molecule_name_to_indices(std::string name,
// std::vector<std::string> const &molecule_names) {
//   auto it = std::find(molecule_names.begin(), molecule_names.end(),
//   input.args[0]); if(it == molecule_names.end()) {
//     std::stringstream msg;
//     msg << "Error parsing '" << input.expression << "': Invalid molecule
//     name. "
//       << "Expected one of '" << molecule_names << "'." << std::endl;
//     throw std::runtime_error(msg.str());
//   }
//   std::set<Index> indices;
//   indices.push_back(std::distance(molecule_names.begin(), it));
//   return indices;
// }
//
// comp_n_name()
//
// comp_n_description()
//
// std::unique_ptr<DatumEvaluator<Configuration, Eigen::VectorXd>>
// make_comp_n_evaluator(
//   ConfigQueryInputType const &input) {
//
//   auto molecule_names =
//   xtal::struc_molecule_name(input.primclex.prim().structure());
//   if(input.args.size() == 0) {
//     return notstd::make_unique<DatumEvaluator<Configuration,
//     Eigen::VectorXd>>(
//       make_arg_vector_names("comp_n", molecule_names),
//       comp_n);
//   }
//   else if(input.args.size() == 1) {
//     return notstd::make_unique<DatumEvaluator<Configuration,
//     Eigen::VectorXd>>(
//       make_arg_vector_names("comp_n", molecule_names),
//       comp_n,
//       molecule_name_to_indices(input.args[0], molecule_names));
//   }
//   else {
//     std::stringstream msg;
//     msg << "Error parsing '" << input.expression << "': Expected args.size()
//     <= 1"; throw std::runtime_error(msg.str());
//   }
// }
//
// notstd::make_unique<DatumEvaluator<Configuration, Eigen::VectorXd>>(
//   comp_n
//
//
 
template <typename ObjectType>
class DataFormatter {
 public:
  DataFormatter() {}
 
  virtual ~DataFormatter() {}
 
  virtual std::string formatter_type() const = 0;
 
  // --- Setup DataFormatter by inserting DatumEvaluators &
  // DatumFormatterOptions ---
 
  // /// Push back BaseDatumEvaluator<DataObject>
  // /// - Will be evaluated sequentially by `operator()`.
  // /// - Will be given default formatter options
  // void push_back(BaseDatumEvaluatorPtr evaluator_ptr);
  //
  // /// Push back BaseDatumEvaluator<DataObject>
  // /// - Will be evaluated sequentially by `operator()`.
  // /// - Will be given default formatter options
  // void push_back(std::pair<BaseDatumEvaluatorPtr, DatumFormatterOptions>
  // evstd::unique_ptr<BaseDatumEvaluator<ObjectType>> evaluator_ptr);
  //
  // /// Push back BaseDatumEvaluator<DataObject>. Will be evaluated
  // sequentially by `operator()`. template<typename ...Args> void
  // push_back(std::unique_ptr<BaseDatumEvaluator<ObjectType>> evaluator_ptr,
  // Args &&... args);
 
  virtual void init() = 0;
 
  // --- Specialize these to control how a formatter formats data ---
 
  virtual void format(std::string const &value_name, bool const &value) = 0;
  virtual void format(std::string const &value_name, long const &value) = 0;
  virtual void format(std::string const &value_name, double const &value) = 0;
  virtual void format(std::string const &value_name,
                      std::string const &value) = 0;
  virtual void format(std::string const &value_name,
                      Eigen::MatrixXl const &value) = 0;
  virtual void format(std::string const &value_name,
                      Eigen::MatrixXd const &value) = 0;
  virtual void format(std::string const &value_name,
                      jsonParser const &value) = 0;
 
  virtual void operator()(ObjectType const &object) = 0;
 
  // --- Error handling ---
 
  std::vector<std::string> const &errors() const;
 
  int insert_error(std::string what);
 
 private:
  std::vector<std::unique_ptr<BaseDatumEvaluator<ObjectType>>> m_evaluators;
  std::vector<std::string> m_errors;
};
 
template <typename ObjectType, typename ValueType>
DatumEvaluator<ObjectType, ValueType>::DatumEvaluator(std::string _name,
                                                      ValueF _value_f)
    : m_name(_name), m_value_f(_value_f) {}
 
template <typename ObjectType, typename ValueType>
std::string const &DatumEvaluator<ObjectType, ValueType>::name() const {
  return m_name;
}
 
template <typename ObjectType, typename ValueType>
ValueType DatumEvaluator<ObjectType, ValueType>::value(
    ObjectType const &object) const {
  return m_value_f(object);
}
 
template <typename ObjectType, typename ValueType>
void DatumEvaluator<ObjectType, ValueType>::format_value(
    DataFormatter<ObjectType> &formatter, ObjectType const &object) const {
  formatter.format(this->name(), this->value(object));
}
 
template <typename ObjectType, typename VectorizedValueType>
VectorizedDatumEvaluator<ObjectType, VectorizedValueType>::
    VectorizedDatumEvaluator(
        DynamicVectorizedValueF _dynamic_vectorized_value_f)
    : m_dynamic_vectorized_value_f(_dynamic_vectorized_value_f),
      m_is_fixed_size(false) {}
 
template <typename ObjectType, typename VectorizedValueType>
VectorizedDatumEvaluator<ObjectType, VectorizedValueType>::
    VectorizedDatumEvaluator(std::vector<std::string> _component_names,
                             VectorizedValueF _fixed_vectorized_value_f)
    : m_fixed_vectorized_value_f(_fixed_vectorized_value_f),
      m_is_fixed_size(true),
      m_component_names(_component_names) {}
 
template <typename ObjectType, typename ValueType, typename VectorizedValueType>
VectorizedValueType VectorizedDatumEvaluator<
    ObjectType, ValueType,
    VectorizedValueType>::vectorized_value(ObjectType const &object) const {
  if (this->is_fixed_size()) {
    return m_fixed_vectorized_value_f(object);
  } else {
    return m_vectorized_value_f(object, m_component_names);
  }
}
 
template <typename ObjectType, typename ValueType, typename VectorizedValueType>
void VectorizedDatumEvaluator<ObjectType, ValueType, VectorizedValueType>::
    format_vectorized_value(DataFormatter<ObjectType> &formatter,
                            ObjectType const &object) const {
  // these could throw:
  //   (reminder: if dynamic, also sets m_component_names)
  auto _vectorized_value = this->vectorized_value(object);
 
  if (_vectorized_value.size() != m_component_names.size()) {
    std::stringstream msg;
    msg << "Error in DatumEvaluator: component_names.size() != "
           "vectorized_value.size() ";
    msg << m_component_names.size() << " != " << _vectorized_value.size();
    throw std::runtime_error(msg.str());
  }
 
  // this should not throw:
  auto it = std::begin(_vectorized_value);
  auto end = std::end(_vectorized_value);
  auto name_it = m_component_names().begin();
  for (; it != end; ++it, ++name_it) {
    formatter.format(*name_it, *it);
  }
}
 
template <typename ObjectType>
void DataFormatter<ObjectType>::push_back(
    std::unique_ptr<BaseDatumEvaluator<ObjectType>> evaluator_ptr) {
  m_evaluators.push_back(std::move(evaluator_ptr));
}
 
template <typename ObjectType>
template <typename... Args>
void DataFormatter<ObjectType>::push_back(
    std::unique_ptr<BaseDatumEvaluator<ObjectType>> evaluator_ptr,
    Args &&...args) {
  push_back(std::move(evaluator_ptr));
  push_back(std::forward<Args>(args)...);
}
 
std::vector<std::string> const &errors() const { return m_errors; }
 
// template<typename ObjectType>
// void DataFormatter<ObjectType>::operator()(ObjectType const &object) {
//   for(auto const &evaluator_ptr : m_evaluators) {
//     try {
//         evaluator_ptr->format_value(*this, object);
//     }
//     catch (std::exception &e) {
//
//       int error_index = this->insert_error(e.what());
//       std::string error_key = "error_" + std::to_string(error_index);
//       this->format(_name, error_key);
//
//       auto value_names = evaluator_ptr->value_names();
//       for(auto const &_value_name : value_names) {
//         this->format(_value_name, error_key);
//       }
//     }
//   }
// }
 
// template<typename ObjectType>
// void DataFormatter<ObjectType>::operator()(ObjectType const &object) {
//   for(auto const &evaluator_ptr : m_evaluators) {
//     try {
//         evaluator_ptr->format_vectorized_value(*this, object);
//     }
//     catch (std::exception &e) {
//
//       int error_index = this->insert_error(e.what());
//       std::string error_key = "error_" + std::to_string(error_index);
//
//       auto _component_names = evaluator_ptr->component_names();
//       for(auto const &_component_name : _component_names) {
//         this->format(_component_name, error_key);
//       }
//     }
//   }
// }
 
int error_index insert_error(std::string what) {
  // handle errors by:
  // - catching exception
  // - insert error message into this->errors() (no duplicates)
  // - format a vector of string {"error_$i", "error_$i", ...}, where $i
  // indicates the
  //   position of the error message in this->errors() so error messages can be
  //   printed
 
  auto it = std::find(m_errors.begin(), m_errors.end(), what);
  int error_index{0};
  if (it == m_errors.end()) {
    error_index = m_errors.size();
    m_errors.push_back(what);
  } else {
    error_index = std::distance(m_errors.begin(), it);
  }
  return error_index;
}
 
}  // namespace simpleformatter
}  // namespace CASM