Skip to content

Commit 8b87325

Browse files
taehyounparktaehyounpark
committed
Streamline systematic variations API
1 parent 6ad70a0 commit 8b87325

File tree

5 files changed

+166
-150
lines changed

5 files changed

+166
-150
lines changed

‎include/queryosity/dataflow.h

Lines changed: 24 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -247,9 +247,9 @@ class dataflow
247247
*/
248248
template <typename Qry> auto make(query::plan<Qry> const &plan) -> todo<query::booker<Qry>>;
249249

250-
template <typename Val, typename... Vars> auto vary(column::constant<Val> const &nom, Vars const &...vars);
250+
template <typename Val> auto vary(column::constant<Val> const &cnst, std::map<std::string, Val> vars);
251251

252-
template <typename Fn, typename... Vars> auto vary(column::expression<Fn> const &expr, Vars const &...vars);
252+
template <typename Fn> auto vary(column::expression<Fn> const &expr, std::map<std::string, typename column::expression<Fn>::function_type> const & vars);
253253

254254
template <typename Defn, typename... Vars> auto vary(column::definition<Defn> const &defn, Vars const &...vars);
255255

@@ -425,40 +425,40 @@ auto queryosity::dataflow::read(queryosity::dataset::input<DS> in, queryosity::d
425425
}
426426

427427
template <typename Val>
428-
auto queryosity::dataflow::define(queryosity::column::constant<Val> const &cnst) -> lazy<column::fixed<Val>>
428+
auto queryosity::dataflow::define(column::constant<Val> const &cnst) -> lazy<column::fixed<Val>>
429429
{
430430
return cnst._assign(*this);
431431
}
432432

433433
template <typename Def, typename... Cols>
434-
auto queryosity::dataflow::define(queryosity::column::definition<Def> const &defn,
434+
auto queryosity::dataflow::define(column::definition<Def> const &defn,
435435
lazy<Cols> const &...cols) -> lazy<Def>
436436
{
437437
return this->_define(defn).template evaluate(cols...);
438438
}
439439

440440
template <typename Def, typename... Cols>
441-
auto queryosity::dataflow::define(queryosity::column::definition<Def> const &defn, Cols const &...cols) ->
441+
auto queryosity::dataflow::define(column::definition<Def> const &defn, Cols const &...cols) ->
442442
typename lazy<Def>::varied
443443
{
444444
return this->_define(defn).template evaluate(cols...);
445445
}
446446

447447
template <typename Fn, typename... Cols>
448-
auto queryosity::dataflow::define(queryosity::column::expression<Fn> const &expr) -> lazy<column::equation_t<Fn>>
448+
auto queryosity::dataflow::define(column::expression<Fn> const &expr) -> lazy<column::equation_t<Fn>>
449449
{
450450
return this->_equate(expr).template evaluate();
451451
}
452452

453453
template <typename Fn, typename... Cols>
454-
auto queryosity::dataflow::define(queryosity::column::expression<Fn> const &expr,
454+
auto queryosity::dataflow::define(column::expression<Fn> const &expr,
455455
lazy<Cols> const &...cols) -> lazy<column::equation_t<Fn>>
456456
{
457457
return this->_equate(expr).template evaluate(cols...);
458458
}
459459

460460
template <typename Fn, typename... Cols>
461-
auto queryosity::dataflow::define(queryosity::column::expression<Fn> const &expr, Cols const &...cols) ->
461+
auto queryosity::dataflow::define(column::expression<Fn> const &expr, Cols const &...cols) ->
462462
typename lazy<column::equation_t<Fn>>::varied
463463
{
464464
return this->_equate(expr).template evaluate(cols...);
@@ -586,29 +586,33 @@ inline void queryosity::dataflow::reset()
586586
m_analyzed = false;
587587
}
588588

589-
template <typename Val, typename... Vars>
590-
auto queryosity::dataflow::vary(queryosity::column::constant<Val> const &cnst, Vars const &...vars)
589+
template <typename Val>
590+
auto queryosity::dataflow::vary(column::constant<Val> const &cnst, std::map<std::string, Val> vars)
591591
{
592592
auto nom = this->define(cnst);
593593
using varied_type = typename decltype(nom)::varied;
594594
varied_type syst(std::move(nom));
595-
((this->_vary(syst, vars.name(), column::constant<Val>(std::get<0>(vars.args())))), ...);
595+
for (auto const& var : vars) {
596+
this->_vary(syst, var.first, column::constant<Val>(var.second));
597+
}
596598
return syst;
597599
}
598600

599-
template <typename Fn, typename... Vars>
600-
auto queryosity::dataflow::vary(queryosity::column::expression<Fn> const &expr, Vars const &...vars)
601+
template <typename Fn>
602+
auto queryosity::dataflow::vary(column::expression<Fn> const &expr, std::map<std::string, typename column::expression<Fn>::function_type> const & vars)
601603
{
602604
auto nom = this->_equate(expr);
603605
using varied_type = typename decltype(nom)::varied;
604606
using function_type = typename column::expression<Fn>::function_type;
605607
varied_type syst(std::move(nom));
606-
((this->_vary(syst, vars.name(), vars.template _vary_arg<column::expression<function_type>>())), ...);
608+
for (auto const& var : vars) {
609+
this->_vary(syst, var.first, column::expression<function_type>(var.second));
610+
}
607611
return syst;
608612
}
609613

610614
template <typename Defn, typename... Vars>
611-
auto queryosity::dataflow::vary(queryosity::column::definition<Defn> const &defn, Vars const &...vars)
615+
auto queryosity::dataflow::vary(column::definition<Defn> const &defn, Vars const &...vars)
612616
{
613617
auto nom = this->_define(defn);
614618
using varied_type = typename decltype(nom)::varied;
@@ -626,7 +630,7 @@ auto queryosity::dataflow::_read(dataset::reader<DS> &ds,
626630
return lzy;
627631
}
628632

629-
template <typename Val> auto queryosity::dataflow::_assign(Val const &val) -> lazy<queryosity::column::fixed<Val>>
633+
template <typename Val> auto queryosity::dataflow::_assign(Val const &val) -> lazy<column::fixed<Val>>
630634
{
631635
auto act = ensemble::invoke([&val](dataset::player *plyr) { return plyr->template assign<Val>(val); },
632636
m_processor.get_slots());
@@ -636,7 +640,7 @@ template <typename Val> auto queryosity::dataflow::_assign(Val const &val) -> la
636640

637641
template <typename To, typename Col>
638642
auto queryosity::dataflow::_convert(lazy<Col> const &col)
639-
-> lazy<queryosity::column::conversion<To, queryosity::column::value_t<Col>>>
643+
-> lazy<column::conversion<To, column::value_t<Col>>>
640644
{
641645
auto act =
642646
ensemble::invoke([](dataset::player *plyr, Col const *from) { return plyr->template convert<To>(*from); },
@@ -647,15 +651,15 @@ auto queryosity::dataflow::_convert(lazy<Col> const &col)
647651

648652
template <typename Def, typename... Args> auto queryosity::dataflow::_define(Args &&...args)
649653
{
650-
return todo<queryosity::column::evaluator<Def>>(
654+
return todo<column::evaluator<Def>>(
651655
*this,
652656
ensemble::invoke(
653657
[&args...](dataset::player *plyr) { return plyr->template define<Def>(std::forward<Args>(args)...); },
654658
m_processor.get_slots()));
655659
}
656660

657661
template <typename Def>
658-
auto queryosity::dataflow::_define(queryosity::column::definition<Def> const &defn) -> todo<column::evaluator<Def>>
662+
auto queryosity::dataflow::_define(column::definition<Def> const &defn) -> todo<column::evaluator<Def>>
659663
{
660664
return defn._define(*this);
661665
}
@@ -668,7 +672,7 @@ template <typename Fn> auto queryosity::dataflow::_equate(Fn fn)
668672
}
669673

670674
template <typename Fn>
671-
auto queryosity::dataflow::_equate(queryosity::column::expression<Fn> const &expr)
675+
auto queryosity::dataflow::_equate(column::expression<Fn> const &expr)
672676
-> todo<column::evaluator<column::equation_t<Fn>>>
673677
{
674678
return expr._equate(*this);

‎include/queryosity/dataset_loaded.h

Lines changed: 38 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -5,36 +5,33 @@
55
#include "dataflow.h"
66
#include "systematic.h"
77

8-
namespace queryosity {
8+
namespace queryosity
9+
{
910

10-
namespace dataset {
11+
namespace dataset
12+
{
1113

12-
template <typename DS> class loaded {
14+
template <typename DS> class loaded
15+
{
1316

14-
public:
15-
loaded(dataflow &df, DS &ds);
16-
~loaded() = default;
17+
public:
18+
loaded(dataflow &df, DS &ds);
19+
~loaded() = default;
1720

18-
template <typename Val> auto _read(const std::string &name) {
19-
return m_df->_read<DS, Val>(*m_ds, name);
20-
}
21+
template <typename Val> auto _read(const std::string &name)
22+
{
23+
return m_df->_read<DS, Val>(*m_ds, name);
24+
}
2125

22-
template <typename Val>
23-
auto read(dataset::column<Val> const &col) -> lazy<read_column_t<DS, Val>>;
26+
template <typename Val> auto read(dataset::column<Val> const &col) -> lazy<read_column_t<DS, Val>>;
2427

25-
template <typename... Vals> auto read(dataset::column<Vals> const &... cols);
28+
template <typename... Vals> auto read(dataset::column<Vals> const &...cols);
2629

27-
template <typename Val>
28-
auto vary(dataset::column<Val> const &nom,
29-
systematic::variation<std::string> const &var);
30+
template <typename Val> auto vary(dataset::column<Val> const &col, std::map<std::string, std::string> const &vars);
3031

31-
template <typename Val, typename... Vars>
32-
auto vary(dataset::column<Val> const &nom,
33-
systematic::variation<Vars> const &...vars);
34-
35-
protected:
36-
dataflow *m_df;
37-
dataset::reader<DS> *m_ds;
32+
protected:
33+
dataflow *m_df;
34+
dataset::reader<DS> *m_ds;
3835
};
3936

4037
} // namespace dataset
@@ -46,45 +43,34 @@ template <typename DS> class loaded {
4643
#include "lazy_varied.h"
4744
#include "systematic_variation.h"
4845

49-
template <typename DS>
50-
queryosity::dataset::loaded<DS>::loaded(queryosity::dataflow &df, DS &ds)
51-
: m_df(&df), m_ds(&ds) {}
46+
template <typename DS> queryosity::dataset::loaded<DS>::loaded(queryosity::dataflow &df, DS &ds) : m_df(&df), m_ds(&ds)
47+
{
48+
}
5249

5350
template <typename DS>
5451
template <typename Val>
55-
auto queryosity::dataset::loaded<DS>::read(dataset::column<Val> const &col)
56-
-> lazy<read_column_t<DS, Val>> {
57-
return col.template _read(*this);
52+
auto queryosity::dataset::loaded<DS>::read(dataset::column<Val> const &col) -> lazy<read_column_t<DS, Val>>
53+
{
54+
return col.template _read(*this);
5855
}
5956

6057
template <typename DS>
6158
template <typename... Vals>
62-
auto queryosity::dataset::loaded<DS>::read(
63-
dataset::column<Vals> const &...cols) {
64-
return std::make_tuple(cols.template _read(*this)...);
59+
auto queryosity::dataset::loaded<DS>::read(dataset::column<Vals> const &...cols)
60+
{
61+
return std::make_tuple(cols.template _read(*this)...);
6562
}
6663

6764
template <typename DS>
6865
template <typename Val>
69-
auto queryosity::dataset::loaded<DS>::vary(
70-
dataset::column<Val> const &col,
71-
systematic::variation<std::string> const &var) {
72-
auto nom = this->read(col);
73-
typename decltype(nom)::varied varied_column(std::move(nom));
74-
varied_column.set_variation(
75-
var.name(), this->read(dataset::column<Val>(std::get<0>(var.args()))));
76-
return varied_column;
77-
}
78-
79-
template <typename DS>
80-
template <typename Val, typename... Vars>
81-
auto queryosity::dataset::loaded<DS>::vary(
82-
dataset::column<Val> const &col,
83-
systematic::variation<Vars> const &...vars) {
84-
auto nom = this->read(col);
85-
typename decltype(nom)::varied varied_column(std::move(nom));
86-
(varied_column.set_variation(
87-
vars.name(), this->read(dataset::column<Val>(std::get<0>(vars.args())))),
88-
...);
89-
return varied_column;
66+
auto queryosity::dataset::loaded<DS>::vary(dataset::column<Val> const &col,
67+
std::map<std::string, std::string> const &vars)
68+
{
69+
auto nom = this->read(col);
70+
typename decltype(nom)::varied varied_column(std::move(nom));
71+
for (auto const &var : vars)
72+
{
73+
varied_column.set_variation(var.first, this->read(dataset::column<Val>(var.second)));
74+
}
75+
return varied_column;
9076
}

‎include/queryosity/detail.h

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -117,9 +117,9 @@
117117
typename lazy<typename decltype(std::declval<lazy<Act>>().operator op_symbol( \
118118
b.nominal().template to<column::value_t<V>>()))::action_type>::varied \
119119
{ \
120-
auto syst = \
121-
typename lazy<typename decltype(std::declval<lazy<Act>>().operator op_symbol(b.nominal()))::action_type>:: \
122-
varied(this->nominal().operator op_symbol(b.nominal().template to<column::value_t<V>>())); \
120+
auto syst = typename lazy<typename decltype(std::declval<lazy<Act>>().operator op_symbol( \
121+
b.nominal().template to<column::value_t<V>>()))::action_type>:: \
122+
varied(this->nominal().operator op_symbol(b.nominal().template to<column::value_t<V>>())); \
123123
for (auto const &var_name : systematic::get_variation_names(*this, b)) \
124124
{ \
125125
syst.set_variation(var_name, variation(var_name).operator op_symbol( \
@@ -154,24 +154,24 @@ namespace queryosity
154154
template <typename T> class lazy;
155155
template <typename T> class todo;
156156

157-
template <typename U>
158-
static constexpr std::true_type check_lazy(lazy<U> const &);
159-
static constexpr std::false_type check_lazy(...) { return std::false_type{}; }
160-
template <typename U>
161-
static constexpr std::true_type check_todo(todo<U> const &);
162-
static constexpr std::false_type check_todo(...) { return std::false_type{}; }
157+
template <typename U> static constexpr std::true_type check_lazy(lazy<U> const &);
158+
static constexpr std::false_type check_lazy(...)
159+
{
160+
return std::false_type{};
161+
}
162+
template <typename U> static constexpr std::true_type check_todo(todo<U> const &);
163+
static constexpr std::false_type check_todo(...)
164+
{
165+
return std::false_type{};
166+
}
163167

164168
template <typename V>
165169
static constexpr bool is_nominal_v =
166-
(decltype(check_lazy(std::declval<V>()))::value ||
167-
decltype(check_todo(std::declval<V>()))::value);
170+
(decltype(check_lazy(std::declval<V>()))::value || decltype(check_todo(std::declval<V>()))::value);
168171
template <typename V> static constexpr bool is_varied_v = !is_nominal_v<V>;
169172

170-
template <typename... Args>
171-
static constexpr bool has_no_variation_v = (is_nominal_v<Args> && ...);
172-
template <typename... Args>
173-
static constexpr bool has_variation_v = (is_varied_v<Args> || ...);
174-
173+
template <typename... Args> static constexpr bool has_no_variation_v = (is_nominal_v<Args> && ...);
174+
template <typename... Args> static constexpr bool has_variation_v = (is_varied_v<Args> || ...);
175175

176176
namespace detail
177177
{

0 commit comments

Comments
 (0)