SimpleFormatterDict.hh

Go to the documentation of this file.

namespace CASM {
namespace simpleformatter {
 
// want to construct DataFormatter from query string:
//
//     DataFormatterOptions options {
//       ... stream? file? json? csv? sep? width? etc. ...
//     }
//
//     std::string query_string {"name1(args) name2(args) name3(args)"};
//
//     std::unique_ptr<DataFormatter<DataObject>> =
//     make_data_formatter<DataFormatter<DataObject>>(
//       DataFormatterDict<DataObject> const &dict,
//       DataFormatterOptions const &options,
//       std::string query_string);
//
 
template <typename ObjectType>
using EvaluatorPtrType = std::unique_ptr<BaseDatumEvaluator<ObjectType>>;
 
template <typename ObjectType, typename InputType>
using MakeEvaluatorPtrFunction =
    std::function<EvaluatorPtrType<ObjectType>(InputType const &)>;
 
template <typename ObjectType, typename InputType>
class DatumEvaluatorEntry {
 public:
  DatumEvaluatorEntry(
      std::string _name, std::string _description,
      MakeEvaluatorPtrFunction<ObjectType, InputType> _make_evaluator_ptr_f)
      : m_name(_name),
        m_description(_description),
        m_make_evaluator_f(_make_evaluator_f) {}
 
  std::string name() const { return m_name; }
 
  std::string description() const { return m_description; }
 
  std::unique_ptr<BaseDatumFormatter<ObjectType>> make(
      InputType const &input) const {
    return m_make_evaluator_f(input);
  }
 
 private:
  std::string m_name;
  std::string m_description;
  MakeEvaluatorPtrFunction<ObjectType, InputType> make_evaluator_f;
};
 
std::unique_ptr<DatumEvaluatorDictEntry<DataObject>> make_dict_entry_ptr(
    std::string _name, std::string _description,
    MakeEvaluatorPtrFunction<ObjectType> _make_evaluator_f);
 
template <typename ObjectType>
class DatumEvaluatorDictionary {
 public:
  typedef std::map<std::string, DatumEvaluatorEntry<ObjectType>> map_type;
  typedef map_type::const_iterator const_iterator;
 
  DatumEvaluatorDictionary(){};
 
  template <typename... Args>
  DatumEvaluatorDictionary(Args &&...args) {
    insert(std::forward<Args>(args)...);
  };
 
  void insert(std::unique_ptr<DatumEvaluatorDictEntry<ObjectType>> entry_ptr) {
    std::string name = entry_ptr->name();
    m_evaluators.emplace(name, std::move(entry_ptr));
  }
 
  template <typename... Args>
  void insert(std::unique_ptr<DatumEvaluatorDictEntry<ObjectType>> entry_ptr,
              Args &&...args) {
    insert(std::move(entry_ptr));
    insert(std::forward<Args>(args)...);
  }
 
  const_iterator find(std::string const &name) const {
    return m_evaluators.find(name);
  }
 
  size_type count(std::string const &name) const {
    return m_evaluators.count(name);
  }
 
  const_iterator begin() const { return m_evaluators.begin(); }
 
  const_iterator end() const { return m_evaluators.end(); }
 
 private:
  std::map<std::string, DatumEvaluatorDictEntry<ObjectType>> m_evaluators;
  map_type m_evaluators;
};
 
template <typename ObjectType>
DatumEvaluatorDictEntry<ObjectType>::DatumEvaluatorDictEntry(
    std::string _name, std::string _description,
    MakeEvaluatorPtrFunction<ObjectType> _make_evaluator_ptr_f)
    : m_name(_name),
      m_description(_description),
      m_make_evaluator_f(_make_evaluator_f) {}
 
template <typename ObjectType>
std::string DatumEvaluatorDictEntry<ObjectType>::name() const {
  return m_name;
}
 
template <typename ObjectType>
std::string DatumEvaluatorDictEntry<ObjectType>::description() const {
  return m_description;
}
 
template <typename ObjectType>
std::unique_ptr<BaseDatumFormatter<ObjectType>>
DatumEvaluatorDictEntry<ObjectType>::make(
    std::vector<std::string> const &args) const {
  return m_make_evaluator_f(args);
}
 
}  // namespace simpleformatter
}  // namespace CASM
 
#endif