DataFormatter.hh

Go to the documentation of this file.

#ifndef DATAFORMATTER_HH
#define DATAFORMATTER_HH

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <functional>
#include "casm/external/boost.hh"
#include "casm/CASM_global_definitions.hh"
#include "casm/container/multivector.hh"
#include "casm/misc/CASM_math.hh"
#include "casm/misc/unique_cloneable_map.hh"
#include "casm/casm_io/jsonParser.hh"
#include "casm/casm_io/DataStream.hh"
#include "casm/casm_io/FormatFlag.hh"


namespace CASM {





  class DataStream;

  template<typename DataObject>
  class BaseDatumFormatter;

  template<typename DataObject, typename DatumFormatterType>
  class DataFormatterDictionary;

  // 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);
      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);
      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;
    }
  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;

    void _initialize(const DataObject &_tmplt) const;
  };

  template<typename _DataObject>
  class BaseDatumFormatter {
  public:

    typedef _DataObject DataObject;
    enum FormatterType {Property, Operator};
    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 FormatterType type() const {
      return 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 void init(const DataObject &_template_obj) const {

    };

    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;
  };

  template<typename T>
  bool always_true(const T &) {
    return true;
  };


  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  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>(static_cast<formatter *>(value.clone().release()));
    }

  };

  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);
    }

  };


  template<typename _DataObject, typename _DatumFormatterType = 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,
                    typename BaseDatumFormatter<DataObject>::FormatterType 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;

  };


  // ******************************************************************************

  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;
  }


}

#include "casm/casm_io/DataFormatter_impl.hh"

#endif