DataFormatter.hh

Go to the documentation of this file.

#ifndef CASM_DataFormatter
#define CASM_DataFormatter
 
#include <functional>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
#include "casm/casm_io/FormatFlag.hh"
#include "casm/casm_io/dataformatter/DataFormatterDecl.hh"
#include "casm/casm_io/dataformatter/DataStream.hh"
#include "casm/casm_io/json/jsonParser.hh"
#include "casm/container/multivector.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/CASM_math.hh"
#include "casm/misc/unique_cloneable_map.hh"
 
namespace CASM {
 
 
 
// Given multi-dimensional index expression string such as
//   "3:7, :, 5"
// splits expresion and returns a pair of vectors containing lower and upper
// bounds that can be counted over to expand index expression into a set of
// indices. a standalone ':' character is converted to the special index value
// of -1 to indicate that all indices are to be counted over in that dimension
// The result for the example case yields the pair
//   {{3, -1, 5}, {7, -1 5}}
// commas must be present as delimitters between expressions. Whitespace is
// ignored.
std::pair<std::vector<long>, std::vector<long> > index_expression_to_bounds(
    const std::string &_expr);
 
// Given expression string
//   "subexpr1 subexpr2(subsub1) subexpr3(subsub2(subsubsub1))"
// splits expresion so that
//    tag_names = {"subexpr1", "subexpr2", "subexpr3"}
//    sub_exprs = {"","subsub1", "subsub2(subsubsub1)"}
// whitespace and commas are ignored
void split_formatter_expression(const std::string &input_expr,
                                std::vector<std::string> &tag_names,
                                std::vector<std::string> &sub_exprs);
 
// Given expression string
//   "subexpr1 subexpr2(subsub1) subexpr3(subsub2(subsubsub1))"
// splits expresion so that
//    tag_names = {"subexpr1", "subexpr2", "subexpr3"}
//    sub_exprs = {"","subsub1", "subsub2(subsubsub1)"}
// whitespace and commas are ignored
void split_formatter_expression(const std::string &input_expr,
                                std::vector<std::string> &tag_names,
                                std::vector<std::string> &sub_exprs);
 
template <typename _DataObject>
class DataFormatter {
  // These are private classes that sweeten the I/O syntax
  // they have to be forward declared ahead of DataFormatter::operator()
  template <typename IteratorType>
  class FormattedIteratorPair;
 
  class FormattedObject;
 
 public:
  typedef _DataObject DataObject;
 
  DataFormatter(int _sep = 4, int _precision = 12, std::string _comment = "#")
      : m_initialized(false),
        m_prec(_precision),
        m_sep(_sep),
        m_indent(0),
        m_comment(_comment) {
    m_data_formatters.reserve(100);
  }
 
  template <typename... Args>
  DataFormatter(const Args &... formatters) : DataFormatter() {
    push_back(formatters...);
  }
 
  bool empty() const { return m_data_formatters.size() == 0; }
 
  void clear() { m_data_formatters.clear(); }
 
  template <typename IteratorType>
  FormattedIteratorPair<IteratorType> operator()(IteratorType begin,
                                                 IteratorType end) const {
    return FormattedIteratorPair<IteratorType>(this, begin, end);
  }
 
  void set_indent(int _indent) {
    if (m_col_width.size() == 0) return;
    m_col_width[0] += _indent;
    m_col_sep[0] += _indent;
    // m_indent=_indent;
  }
 
  FormattedObject operator()(const DataObject &data_obj) const {
    return FormattedObject(this, data_obj);
  }
 
  bool validate(const DataObject &_obj) const;
 
  void inject(const DataObject &_obj, DataStream &_stream) const;
 
  template <typename ValueType>
  ValueType evaluate_as_scalar(const DataObject &_obj) const;
 
  template <typename ValueType>
  std::vector<ValueType> evaluate_as_vector(const DataObject &_obj) const;
 
  Eigen::MatrixXd evaluate_as_matrix(const DataObject &_obj) const;
 
  template <typename ValueType, typename IteratorType>
  std::vector<ValueType> evaluate_as_vector(IteratorType begin,
                                            IteratorType end) const;
 
  template <typename IteratorType>
  Eigen::MatrixXd evaluate_as_matrix(IteratorType begin,
                                     IteratorType end) const;
 
  void print(const DataObject &_obj, std::ostream &_stream) const;
 
  jsonParser &to_json(const DataObject &_obj, jsonParser &json) const;
 
  jsonParser &to_json_arrays(const DataObject &_obj, jsonParser &json) const;
 
  void print_header(const DataObject &_tmplt_obj, std::ostream &_stream) const;
 
  std::vector<std::string> col_header(const DataObject &_template_obj) const;
 
  void push_back(const BaseDatumFormatter<DataObject> &new_formatter,
                 const std::string &args) {
    // //If the last formatter matches new_formatter, try to parse the new
    // arguments into it if(m_data_formatters.size() > 0 &&
    // m_data_formatters.back()->name() == new_formatter.name()) {
    //   if(m_data_formatters.back()->parse_args(args)) {
    //     return;
    //   }
    // }
 
    m_data_formatters.emplace_back(new_formatter.clone());
    m_col_sep.push_back(0);
    m_col_width.push_back(0);
    m_data_formatters.back()->parse_args(args);
  }
 
  void push_back(const BaseDatumFormatter<DataObject> &new_formatter) {
    m_data_formatters.emplace_back(new_formatter.clone());
    m_col_sep.push_back(0);
    m_col_width.push_back(0);
  }
 
  template <typename... Args>
  void push_back(const BaseDatumFormatter<DataObject> &new_formatter,
                 const Args &... formatters) {
    push_back(new_formatter);
    push_back(formatters...);
  }
 
  void append(const DataFormatter<DataObject> &_tail) {
    for (const auto &frmtr : _tail.m_data_formatters) push_back(*frmtr);
  }
 
  DataFormatter<DataObject> &operator<<(
      const BaseDatumFormatter<DataObject> &new_formatter) {
    push_back(new_formatter);
    return *this;
  }
 
  void set_header_prefix(const std::string &_prefix) { m_comment += _prefix; }
 
  bool initialize(const DataObject &_tmplt) const;
 
 private:
  mutable bool m_initialized;
  // List of all the ConfigFormatter objects you want outputted
  std::vector<notstd::cloneable_ptr<BaseDatumFormatter<DataObject> > >
      m_data_formatters;
  mutable std::vector<Index> m_col_sep;
  mutable std::vector<Index> m_col_width;
  // Decimal precision
  int m_prec;
  // number of spaces between columns
  int m_sep;
 
  int m_indent;
  // comment prefix -- default to "#"
  std::string m_comment;
};
 
enum class DatumFormatterClass { Property, Operator };
 
template <typename _DataObject>
class BaseDatumFormatter {
 public:
  typedef _DataObject DataObject;
  typedef long difference_type;
  typedef DataFormatterDictionary<DataObject, BaseDatumFormatter<DataObject> >
      DictType;
 
  BaseDatumFormatter(const std::string &_init_name, const std::string &_desc)
      : m_name(_init_name), m_description(_desc) {}
 
  virtual ~BaseDatumFormatter(){};
 
  const std::string &name() const { return m_name; }
 
  const std::string &description() const { return m_description; }
 
  virtual DatumFormatterClass type() const {
    return DatumFormatterClass::Property;
  }
 
  const DictType &home() const { return *m_home; }
 
  void set_home(const DictType &home) const { m_home = &home; }
 
  std::unique_ptr<BaseDatumFormatter<DataObject> > clone() const {
    return std::unique_ptr<BaseDatumFormatter<DataObject> >(this->_clone());
  }
 
  virtual bool init(const DataObject &_template_obj) const { return true; };
 
  virtual bool validate(const DataObject &_data_obj) const { return true; }
 
  virtual std::vector<std::string> col_header(
      const DataObject &_template_obj) const {
    return std::vector<std::string>{this->short_header(_template_obj)};
  }
 
  virtual std::string long_header(const DataObject &_template_obj) const {
    auto _col = col_header(_template_obj);
    if (_col.size() == 1) {
      return _col[0];
    }
 
    std::stringstream t_ss;
    for (Index i = 0; i < _col.size(); i++) {
      t_ss << "       " << _col[i];
    }
 
    return t_ss.str();
  }
 
  virtual std::string short_header(const DataObject &_template_obj) const {
    return name();
  };
 
  virtual Index num_passes(const DataObject &_data_obj) const { return 1; }
 
  virtual void print(const DataObject &_data_obj, std::ostream &_stream,
                     Index pass_index = 0) const = 0;
 
  virtual void inject(const DataObject &_data_obj, DataStream &_stream,
                      Index pass_index = 0) const = 0;
 
  virtual jsonParser &to_json(const DataObject &_data_obj,
                              jsonParser &json) const = 0;
 
  virtual bool parse_args(const std::string &args) { return args.size() == 0; }
 
 protected:
  typedef multivector<Index>::X<2> IndexContainer;
 
  void _parse_index_expression(const std::string &_expr);
 
  void _add_rule(const std::vector<Index> &new_rule) const {
    m_index_rules.push_back(new_rule);
  }
 
  const IndexContainer &_index_rules() const { return m_index_rules; }
 
 private:
  virtual BaseDatumFormatter *_clone() const = 0;
  std::string m_name;
  std::string m_description;
  mutable IndexContainer m_index_rules;
  mutable const DictType *m_home;
};
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class FormattedPrintable {
  // Couldn't figure out how to get compiler to correctly substitute names
  // virtual "FormattedPrintable" class is a workaround
 
 public:
  virtual ~FormattedPrintable() {}
  virtual void inject(DataStream &stream) const = 0;
  virtual void print(std::ostream &stream) const = 0;
  virtual jsonParser &to_json(jsonParser &json) const = 0;
};
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
template <typename DataObject>
template <typename IteratorType>
class DataFormatter<DataObject>::FormattedIteratorPair
    : public FormattedPrintable {
  DataFormatter<DataObject> const *m_formatter_ptr;
  IteratorType m_begin_it, m_end_it;
 
 public:
  FormattedIteratorPair(const DataFormatter<DataObject> *_formatter_ptr,
                        IteratorType _begin, IteratorType _end)
      : m_formatter_ptr(_formatter_ptr), m_begin_it(_begin), m_end_it(_end) {}
 
  void inject(DataStream &_stream) const {
    if (m_begin_it == m_end_it) return;
    // hack: always print header to initialize things, like Clexulator, but in
    // this case throw it away
    std::stringstream _ss;
    m_formatter_ptr->print_header(*m_begin_it, _ss);
    for (IteratorType it(m_begin_it); it != m_end_it; ++it)
      m_formatter_ptr->inject(*it, _stream);
  }
 
  void print(std::ostream &_stream) const {
    if (m_begin_it == m_end_it) return;
 
    FormatFlag format(_stream);
    if (format.print_header()) {
      m_formatter_ptr->print_header(*m_begin_it, _stream);
    } else {  // hack: always print header to initialize things, like
              // Clexulator, but in this case throw it away
      std::stringstream _ss;
      m_formatter_ptr->print_header(*m_begin_it, _ss);
    }
    format.print_header(false);
    _stream << format;
    for (IteratorType it(m_begin_it); it != m_end_it; ++it)
      m_formatter_ptr->print(*it, _stream);
  }
 
  jsonParser &to_json(jsonParser &json) const {
    json.put_array();
    for (IteratorType it(m_begin_it); it != m_end_it; ++it)
      json.push_back((*m_formatter_ptr)(*it));
    return json;
  }
 
  jsonParser &to_json_arrays(jsonParser &json) const {
    json = jsonParser::object();
    for (IteratorType it(m_begin_it); it != m_end_it; ++it)
      m_formatter_ptr->to_json_arrays(*it, json);
    return json;
  }
};
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
template <typename DataObject>
class DataFormatter<DataObject>::FormattedObject : public FormattedPrintable {
  DataFormatter<DataObject> const *m_formatter_ptr;
  DataObject const *m_obj_ptr;
 
 public:
  FormattedObject(const DataFormatter<DataObject> *_formatter_ptr,
                  const DataObject &_obj)
      : m_formatter_ptr(_formatter_ptr), m_obj_ptr(&_obj) {}
 
  void inject(DataStream &_stream) const {
    m_formatter_ptr->inject(*m_obj_ptr, _stream);
  }
 
  void print(std::ostream &_stream) const {
    FormatFlag format(_stream);
    if (format.print_header())
      m_formatter_ptr->print_header(*m_obj_ptr, _stream);
    format.print_header(false);
    _stream << format;
 
    m_formatter_ptr->print(*m_obj_ptr, _stream);
  }
 
  jsonParser &to_json(jsonParser &json) const {
    m_formatter_ptr->to_json(*m_obj_ptr, json);
    return json;
  }
};
 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
template <typename DataObject, typename DatumFormatterType>
struct DictionaryConverter {
  typedef DatumFormatterType formatter;
 
  // performs a static_cast of value.clone().unique().release()
  // (i.e. a BaseDatumFormatter*) to formatter*
 
  notstd::cloneable_ptr<formatter> operator()(const formatter &value) {
    return notstd::cloneable_ptr<formatter>(value.clone());
  }
};
 
/*
template<typename DataObject>
struct DictionaryConverter<DataObject, BaseDatumFormatter<DataObject> > {
 
  typedef BaseDatumFormatter<DataObject> formatter;
 
  notstd::cloneable_ptr<formatter> operator()(const formatter &value) {
    return notstd::cloneable_ptr<formatter>(value.clone());
  }
 
};
*/
 
template <
    typename _DataObject,
    typename _DatumFormatterType /* note: = BaseDatumFormatter<_DataObject> */>
class DataFormatterDictionary
    : public notstd::unique_cloneable_map<std::string, _DatumFormatterType> {
 public:
  typedef _DataObject DataObject;
  typedef _DatumFormatterType DatumFormatterType;
  typedef notstd::unique_cloneable_map<std::string, DatumFormatterType>
      UniqueMapType;
  typedef typename UniqueMapType::key_type key_type;
  typedef typename UniqueMapType::value_type value_type;
  typedef typename UniqueMapType::size_type size_type;
  typedef typename UniqueMapType::iterator iterator;
  typedef typename UniqueMapType::const_iterator const_iterator;
 
  DataFormatterDictionary()
      : UniqueMapType(
            [](const value_type &value) -> std::string { return value.name(); },
            DictionaryConverter<DataObject, DatumFormatterType>()) {}
 
  /*
  explicit DataFormatterDictionary(const value_type& formatter) :
    DataFormatterDictionary() {
    insert(formatter);
  }
 
  template<typename... Formatters>
  explicit DataFormatterDictionary(const Formatters&... more) :
    DataFormatterDictionary() {
    insert(more...);
  }
 
  DataFormatterDictionary(const DataFormatterDictionary& dict) :
    UniqueMapType(dict) {
  }
 
  template<typename... Formatters>
  DataFormatterDictionary(const Formatters&... more) :
    DataFormatterDictionary() {
    insert(more...);
  }
  */
 
  using UniqueMapType::insert;
 
  const_iterator lookup(const key_type &_name) const;
 
  bool contains(const key_type &_name) const {
    return this->find(_name) != this->end();
  }
 
  void print_help(std::ostream &_stream, DatumFormatterClass ftype,
                  int width = 60, int separation = 8) const;
 
  DataFormatter<DataObject> parse(const std::string &input) const;
 
  DataFormatter<DataObject> parse(const std::vector<std::string> &input) const;
 
  DataFormatter<DataObject> parse(
      std::initializer_list<std::string> input) const;
};
 
// ******************************************************************************
 
template <typename DataObject>
DataFormatterDictionary<DataObject> make_attribute_dictionary();
 
template <typename DataObject>
DataFormatterDictionary<DataObject> make_operator_dictionary();
 
template <typename DataObject>
DataFormatterDictionary<DataObject> make_dictionary() {
  DataFormatterDictionary<DataObject> dict;
  dict.insert(make_attribute_dictionary<DataObject>(),
              make_operator_dictionary<DataObject>());
 
  return dict;
}
 
// ******************************************************************************
 
inline jsonParser &to_json(const FormattedPrintable &_obj, jsonParser &json) {
  return _obj.to_json(json);
}
 
// ******************************************************************************
inline std::ostream &operator<<(std::ostream &_stream,
                                const FormattedPrintable &_formatted) {
  _formatted.print(_stream);
  return _stream;
}
 
// ******************************************************************************
inline DataStream &operator<<(DataStream &_stream,
                              const FormattedPrintable &_formatted) {
  _formatted.inject(_stream);
  return _stream;
}
 
}  // namespace CASM
 
#endif