Format

Author: taehyounpark

extensions/queryosity/hist.h

@@ -113,7 +113,7 @@ queryosity::hist::hist<Vals...>::merge(
     std::vector<std::shared_ptr<hist_t>> const &results) const {
   auto sum = std::make_shared<hist_t>(*results[0]);
   sum->reset();
-  for (const auto &result : results) {
+  for (auto const &result : results) {
     *sum += *result;
   }
   return sum;

include/queryosity/dataset_loaded.h

@@ -5,33 +5,33 @@
 #include "dataflow.h"
 #include "systematic.h"
 
-namespace queryosity
-{
+namespace queryosity {
 
-namespace dataset
-{
+namespace dataset {
 
-template <typename DS> class loaded
-{
+template <typename DS> class loaded {
 
-  public:
-    loaded(dataflow &df, DS &ds);
-    ~loaded() = default;
+public:
+  loaded(dataflow &df, DS &ds);
+  ~loaded() = default;
 
-    template <typename Val> auto _read(const std::string &name)
-    {
-        return m_df->_read<DS, Val>(*m_ds, name);
-    }
+  template <typename Val> auto _read(const std::string &name) {
+    return m_df->_read<DS, Val>(*m_ds, name);
+  }
 
-    template <typename Val> auto read(dataset::column<Val> const &col) -> lazy<queryosity::column::valued<Val>>;
+  template <typename Val>
+  auto read(dataset::column<Val> const &col)
+      -> lazy<queryosity::column::valued<Val>>;
 
-    template <typename... Vals> auto read(dataset::column<Vals> const &...cols);
+  template <typename... Vals> auto read(dataset::column<Vals> const &...cols);
 
-    template <typename Val> auto vary(dataset::column<Val> const &col, std::map<std::string, std::string> const &vars);
+  template <typename Val>
+  auto vary(dataset::column<Val> const &col,
+            std::map<std::string, std::string> const &vars);
 
-  protected:
-    dataflow *m_df;
-    dataset::reader<DS> *m_ds;
+protected:
+  dataflow *m_df;
+  dataset::reader<DS> *m_ds;
 };
 
 } // namespace dataset
@@ -43,34 +43,34 @@ template <typename DS> class loaded
 #include "lazy_varied.h"
 #include "systematic_variation.h"
 
-template <typename DS> queryosity::dataset::loaded<DS>::loaded(queryosity::dataflow &df, DS &ds) : m_df(&df), m_ds(&ds)
-{
-}
+template <typename DS>
+queryosity::dataset::loaded<DS>::loaded(queryosity::dataflow &df, DS &ds)
+    : m_df(&df), m_ds(&ds) {}
 
 template <typename DS>
 template <typename Val>
-auto queryosity::dataset::loaded<DS>::read(dataset::column<Val> const &col) -> lazy<queryosity::column::valued<Val>>
-{
-    return col.template _read(*this);
+auto queryosity::dataset::loaded<DS>::read(dataset::column<Val> const &col)
+    -> lazy<queryosity::column::valued<Val>> {
+  return col.template _read(*this);
 }
 
 template <typename DS>
 template <typename... Vals>
-auto queryosity::dataset::loaded<DS>::read(dataset::column<Vals> const &...cols)
-{
-    return std::make_tuple(cols.template _read(*this)...);
+auto queryosity::dataset::loaded<DS>::read(
+    dataset::column<Vals> const &...cols) {
+  return std::make_tuple(cols.template _read(*this)...);
 }
 
 template <typename DS>
 template <typename Val>
-auto queryosity::dataset::loaded<DS>::vary(dataset::column<Val> const &col,
-                                           std::map<std::string, std::string> const &vars)
-{
-    auto nom = this->read(col);
-    typename decltype(nom)::varied varied_column(std::move(nom));
-    for (auto const &var : vars)
-    {
-        varied_column.set_variation(var.first, this->read(dataset::column<Val>(var.second)));
-    }
-    return varied_column;
+auto queryosity::dataset::loaded<DS>::vary(
+    dataset::column<Val> const &col,
+    std::map<std::string, std::string> const &vars) {
+  auto nom = this->read(col);
+  typename decltype(nom)::varied varied_column(std::move(nom));
+  for (auto const &var : vars) {
+    varied_column.set_variation(var.first,
+                                this->read(dataset::column<Val>(var.second)));
+  }
+  return varied_column;
 }

include/queryosity/dataset_partition.h

@@ -40,10 +40,10 @@ inline queryosity::dataset::partition_t queryosity::dataset::partition::align(
   const unsigned int num_vectors = partitions.size();
 
   // Count appearances of each edge
-  for (const auto &vec : partitions) {
+  for (auto const &vec : partitions) {
     std::map<entry_t, bool>
         seen_edges; // Ensure each edge is only counted once per vector
-    for (const auto &p : vec) {
+    for (auto const &p : vec) {
       if (seen_edges.find(p.first) == seen_edges.end()) {
         edge_counts[p.first]++;
         seen_edges[p.first] = true;
@@ -57,7 +57,7 @@ inline queryosity::dataset::partition_t queryosity::dataset::partition::align(
 
   // Filter edges that appear in all vectors
   std::vector<entry_t> aligned_edges;
-  for (const auto &pair : edge_counts) {
+  for (auto const &pair : edge_counts) {
     if (pair.second == num_vectors) {
       aligned_edges.push_back(pair.first);
     }
@@ -80,7 +80,7 @@ queryosity::dataset::partition::truncate(
 
   partition_t parts_truncated;
 
-  for (const auto &part : parts) {
+  for (auto const &part : parts) {
     auto part_end = nentries_max >= 0
                         ? std::min(part.first + nentries_max, part.second)
                         : part.second;

include/queryosity/lazy.h

@@ -22,7 +22,7 @@ template <typename Action>
 class lazy : public dataflow::node,
              public ensemble::slotted<Action>,
              public systematic::resolver<lazy<Action>>,
-             public query::result_if_aggregation<Action> {
+             public query::result_of<Action> {
 
 public:
   class varied;

include/queryosity/lazy_varied.h

@@ -37,10 +37,9 @@ class lazy<Act>::varied : public dataflow::node,
   varied(varied &&) = default;
   varied &operator=(varied &&) = default;
 
+  template <typename Derived> varied(typename lazy<Derived>::varied const &);
   template <typename Derived>
-  varied(typename lazy<Derived>::varied const&);
-  template <typename Derived>
-  varied& operator=(typename lazy<Derived>::varied const&);
+  varied &operator=(typename lazy<Derived>::varied const &);
 
   virtual void set_variation(const std::string &var_name, lazy var) override;
 
@@ -132,20 +131,23 @@ queryosity::lazy<Act>::varied::varied(lazy<Act> nom)
 
 template <typename Act>
 template <typename Derived>
-queryosity::lazy<Act>::varied::varied(typename lazy<Derived>::varied const& other) {
+queryosity::lazy<Act>::varied::varied(
+    typename lazy<Derived>::varied const &other) {
   this->m_df = other.m_df;
   this->m_var_names = other.m_var_names;
-  for (auto const& var : other.m_var_map) {
+  for (auto const &var : other.m_var_map) {
     m_var_map.insert(var);
   }
 }
 
 template <typename Act>
 template <typename Derived>
-typename queryosity::lazy<Act>::varied& queryosity::lazy<Act>::varied::operator=(typename lazy<Derived>::varied const& other) {
+typename queryosity::lazy<Act>::varied &
+queryosity::lazy<Act>::varied::operator=(
+    typename lazy<Derived>::varied const &other) {
   this->m_df = other.m_df;
   this->m_var_names = other.m_var_names;
-  for (auto const& var : other.m_var_map) {
+  for (auto const &var : other.m_var_map) {
     m_var_map.insert(var);
   }
   return *this;