8000 Merge pull request #11 from flexferrum/filters_impl · jinja2cpp/Jinja2Cpp@ca29192 · GitHub
[go: up one dir, main page]
Skip to content

Commit ca29192

Browse files
flexferrumflexferrum
authored
Merge pull request #11 from flexferrum/filters_impl
'default', 'min', 'max', 'first', 'last', 'sum', 'reserve' and 'unique' filters implementation
2 parents 6f72d72 + 893e8b4 commit ca29192

23 files changed

+1730
-327
lines changed

‎include/jinja2cpp/value.h

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -50,6 +50,10 @@ class GenericMap
5050
return m_accessor()->GetSize();
5151
}
5252
Value GetValueByIndex(int64_t index) const;
53+
auto GetKeys() const
54+
{
55+
return m_accessor()->GetKeys();
56+
}
5357

5458
std::function<const MapItemAccessor* ()> m_accessor;
5559
};
@@ -69,12 +73,17 @@ class GenericList
6973
}
7074

7175
Value GetValueByIndex(int64_t idx) const;
72-
76+
7377
auto GetAccessor() const
7478
{
7579
return m_accessor();
7680
}
7781

82+
bool IsValid() const
83+
{
84+
return !(!m_accessor);
85+
}
86+
7887
std::function<const ListItemAccessor* ()> m_accessor;
7988
};
8089

@@ -106,6 +115,8 @@ class Value {
106115

107116
const ValueData& data() const {return m_data;}
108117

118+
ValueData& data() {return m_data;}
119+
109120
bool isString() const
110121
{
111122
return boost::get<std::string>(&m_data) != nullptr;

‎src/expression_evaluator.cpp

Lines changed: 49 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
#include "expression_evaluator.h"
22
#include "filters.h"
3+
#include "internal_value.h"
34
#include "testers.h"
45
#include "value_visitors.h"
56

@@ -17,6 +18,7 @@ std::unordered_map<std::string, ExpressionFilter::FilterFactoryFn> ExpressionFil
1718
{"camelize", FilterFactory<filters::StringConverter>::MakeCreator(filters::StringConverter::CamelMode)},
1819
{"capitalize", FilterFactory<filters::StringConverter>::MakeCreator(filters::StringConverter::CapitalMode)},
1920
{"default", &FilterFactory<filters::Default>::Create},
21+
{"d", &FilterFactory<filters::Default>::Create},
2022
{"dictsort", &FilterFactory<filters::DictSort>::Create},
2123
{"escape", FilterFactory<filters::StringConverter>::MakeCreator(filters::StringConverter::EscapeHtmlMode)},
2224
{"escapecpp", FilterFactory<filters::StringConverter>::MakeCreator(filters::StringConverter::EscapeCppMode)},
@@ -61,12 +63,12 @@ std::unordered_map<std::string, IsExpression::TesterFactoryFn> IsExpression::s_t
6163
{"startsWith", &TesterFactory<testers::StartsWith>::Create},
6264
};
6365

64-
Value FullExpressionEvaluator::Evaluate(RenderContext& values)
66+
InternalValue FullExpressionEvaluator::Evaluate(RenderContext& values)
6567
{
6668
if (!m_expression)
67-
return Value();
69+
return InternalValue();
6870

69-
Value origVal = m_expression->Evaluate(values);
71+
InternalValue origVal = m_expression->Evaluate(values);
7072
if (m_filter)
7173
origVal = m_filter->Evaluate(origVal, values);
7274

@@ -76,31 +78,31 @@ Value FullExpressionEvaluator::Evaluate(RenderContext& values)
7678
return origVal;
7779
}
7880

79-
Value ValueRefExpression::Evaluate(RenderContext& values)
81+
InternalValue ValueRefExpression::Evaluate(RenderContext& values)
8082
{
8183
bool found = false;
8284
auto p = values.FindValue(m_valueName, found);
8385
if (found)
8486
return p->second;
8587

86-
return Value();
88+
return InternalValue();
8789
}
8890

89-
Value SubscriptExpression::Evaluate(RenderContext& values)
91+
InternalValue SubscriptExpression::Evaluate(RenderContext& values)
9092
{
91-
return m_value->Evaluate(values).subscript(m_subscriptExpr->Evaluate(values));
93+
return Subscript(m_value->Evaluate(values), m_subscriptExpr->Evaluate(values));
9294
}
9395

94-
Value UnaryExpression::Evaluate(RenderContext& values)
96+
InternalValue UnaryExpression::Evaluate(RenderContext& values)
9597
{
96-
return boost::apply_visitor(visitors::UnaryOperation(m_oper), m_expr->Evaluate(values).data());
98+
return Apply<visitors::UnaryOperation>(m_expr->Evaluate(values), m_oper);
9799
}
98100

99-
Value BinaryExpression::Evaluate(RenderContext& context)
101+
InternalValue BinaryExpression::Evaluate(RenderContext& context)
100102
{
101-
Value leftVal = m_leftExpr->Evaluate(context);
102-
Value rightVal = m_rightExpr->Evaluate(context);
103-
Value result;
103+
InternalValue leftVal = m_leftExpr->Evaluate(context);
104+
InternalValue rightVal = m_rightExpr->Evaluate(context);
105+
InternalValue result;
104106

105107
switch (m_oper)
106108
{
@@ -121,7 +123,7 @@ Value BinaryExpression::Evaluate(RenderContext& context)
121123
case jinja2::BinaryExpression::DivReminder:
122124
case jinja2::BinaryExpression::DivInteger:
123125
case jinja2::BinaryExpression::Pow:
124-
result = boost::apply_visitor(visitors::BinaryMathOperation(m_oper), leftVal.data(), rightVal.data());
126+
result = Apply2<visitors::BinaryMathOperation>(leftVal, rightVal, m_oper);
125127
break;
126128
case jinja2::BinaryExpression::StringConcat:
127129
default:
@@ -130,26 +132,26 @@ Value BinaryExpression::Evaluate(RenderContext& context)
130132
return result;
131133
}
132134

133-
Value TupleCreator::Evaluate(RenderContext& context)
135+
InternalValue TupleCreator::Evaluate(RenderContext& context)
134136
{
135-
ValuesList result;
137+
InternalValueList result;
136138
for (auto& e : m_exprs)
137139
{
138140
result.push_back(e->Evaluate(context));
139141
}
140142

141-
return Value(result);
143+
return ListAdapter::CreateAdapter(std::move(result));
142144
}
143145

144-
Value DictCreator::Evaluate(RenderContext& context)
146+
InternalValue DictCreator::Evaluate(RenderContext& context)
145147
{
146-
ValuesMap result;
148+
InternalValueMap result;
147149
for (auto& e : m_exprs)
148150
{
149151
result[e.first] = e.second->Evaluate(context);
150152
}
151153

152-
return Value(result);
154+
return MapAdapter::CreateAdapter(std::move(result));;
153155
}
154156

155157
ExpressionFilter::ExpressionFilter(std::string filterName, CallParams params)
@@ -161,7 +163,7 @@ ExpressionFilter::ExpressionFilter(std::string filterName, CallParams params)
161163
m_filter = p->second(std::move(params));
162164
}
163165

164-
Value ExpressionFilter::Evaluate(const Value& baseVal, RenderContext& context)
166+
InternalValue ExpressionFilter::Evaluate(const InternalValue& baseVal, RenderContext& context)
165167
{
166168
if (m_parentFilter)
167169
return m_filter->Filter(m_parentFilter->Evaluate(baseVal, context), context);
@@ -179,22 +181,23 @@ IsExpression::IsExpression(ExpressionEvaluatorPtr<> value, std::string tester, C
179181
m_tester = p->second(std::move(params));
180182
}
181183

182-
Value IsExpression::Evaluate(RenderContext& context)
184+
InternalValue IsExpression::Evaluate(RenderContext& context)
183185
{
184186
return m_tester->Test(m_value->Evaluate(context), context);
185187
}
186188

187189
bool IfExpression::Evaluate(RenderContext& context)
188190
{
189-
return boost::apply_visitor(visitors::BooleanEvaluator(), m_testExpr->Evaluate(context).data());
191+
return ConvertToBool(m_testExpr->Evaluate(context));
190192
}
191193

192-
Value IfExpression::EvaluateAltValue(RenderContext& context)
194+
InternalValue IfExpression::EvaluateAltValue(RenderContext& context)
193195
{
194-
return m_altValue ? m_altValue->Evaluate(context) : Value();
196+
return m_altValue ? m_altValue->Evaluate(context) : InternalValue();
195197
}
196198

197-
Value DictionaryCreator::Evaluate(RenderContext& context)
199+
/*
200+
InternalValue DictionaryCreator::Evaluate(RenderContext& context)
198201
{
199202
ValuesMap result;
200203
for (auto& i : m_items)
@@ -203,9 +206,9 @@ Value DictionaryCreator::Evaluate(RenderContext& context)
203206
}
204207
205208
return result;
206-
}
209+
}*/
207210

208-
Value CallExpression::Evaluate(RenderContext& values)
211+
InternalValue CallExpression::Evaluate(RenderContext& values)
209212
{
210213
std::string valueRef = boost::algorithm::join(m_valueRef, ".");
211214

@@ -214,29 +217,29 @@ Value CallExpression::Evaluate(RenderContext& values)
214217
else if (valueRef == "loop.cycle")
215218
return CallLoopCycle(values);
216219

217-
return Value();
220+
return InternalValue();
218221
}
219222

220-
Value CallExpression::CallGlobalRange(RenderContext& values)
223+
InternalValue CallExpression::CallGlobalRange(RenderContext& values)
221224
{
222225
bool isArgsParsed = true;
223226

224227
auto args = helpers::ParseCallParams({{"start"}, {"stop", true}, {"step"}}, m_params, isArgsParsed);
225228
if (!isArgsParsed)
226-
return Value();
229+
return InternalValue();
227230

228231

229232
auto startExpr = args["start"];
230233
auto stopExpr = args["stop"];
231234
auto stepExpr = args["step"];
232235

233-
Value startVal = startExpr ? startExpr->Evaluate(values) : Value();
234-
Value stopVal = stopExpr ? stopExpr->Evaluate(values) : Value();
235-
Value stepVal = stepExpr ? stepExpr->Evaluate(values) : Value();
236+
InternalValue startVal = startExpr ? startExpr->Evaluate(values) : InternalValue();
237+
InternalValue stopVal = stopExpr ? stopExpr->Evaluate(values) : InternalValue();
238+
InternalValue stepVal = stepExpr ? stepExpr->Evaluate(values) : InternalValue();
236239

237-
int64_t start = boost::apply_visitor(visitors::IntegerEvaluator(), startVal.data());
238-
int64_t stop = boost::apply_visitor(visitors::IntegerEvaluator(), stopVal.data());
239-
int64_t step = boost::apply_visitor(visitors::IntegerEvaluator(), stepVal.data());
240+
int64_t start = Apply<visitors::IntegerEvaluator>(startVal);
241+
int64_t stop = Apply<visitors::IntegerEvaluator>(stopVal);
242+
int64_t step = Apply<visitors::IntegerEvaluator>(stepVal);
240243

241244
if (!stepExpr)
242245
{
@@ -245,10 +248,10 @@ Value CallExpression::CallGlobalRange(RenderContext& values)
245248
else
246249
{
247250
if (step == 0)
248-
return Value();
251+
return InternalValue();
249252
}
250253

251-
class RangeGenerator : public ListItemAccessor
254+
class RangeGenerator : public IListAccessor
252255
{
253256
public:
254257
RangeGenerator(int64_t start, int64_t stop, int64_t step)
@@ -264,7 +267,7 @@ Value CallExpression::CallGlobalRange(RenderContext& values)
264267
auto count = distance / m_step;
265268
return count < 0 ? 0 : static_cast<size_t>(count);
266269
}
267-
Value GetValueByIndex(int64_t idx) const override
270+
InternalValue GetValueByIndex(int64_t idx) const override
268271
{
269272
return m_start + m_step * idx;
270273
}
@@ -275,18 +278,18 @@ Value CallExpression::CallGlobalRange(RenderContext& values)
275278
int64_t m_step;
276279
};
277280

278-
return GenericList([accessor = RangeGenerator(start, stop, step)]() -> const ListItemAccessor* {return &accessor;});
281+
return ListAdapter([accessor = RangeGenerator(start, stop, step)]() -> const IListAccessor* {return &accessor;});
279282
}
280283

281-
Value CallExpression::CallLoopCycle(RenderContext& values)
284+
InternalValue CallExpression::CallLoopCycle(RenderContext& values)
282285
{
283286
bool loopFound = false;
284287
auto loopValP = values.FindValue("loop", loopFound);
285288
if (!loopFound)
286-
return Value();
289+
return InternalValue();
287290

288-
const ValuesMap* loop = boost::get<ValuesMap>(&loopValP->second.data());
289-
int64_t baseIdx = boost::apply_visitor(visitors::IntegerEvaluator(), (*loop).at("index0").data());
291+
auto loop = boost::get<MapAdapter>(&loopValP->second);
292+
int64_t baseIdx = Apply<visitors::IntegerEvaluator>(loop->GetValueByName("index0"));
290293
auto idx = static_cast<size_t>(baseIdx % m_params.posParams.size());
291294
return m_params.posParams[idx]->Evaluate(values);
292295
}
@@ -421,7 +424,7 @@ ParsedArguments ParseCallParams(const std::initializer_list<ArgumentInfo>& args,
421424
continue;
422425
case NotFound:
423426
{
424-
if (!argInfo.info->defaultVal.isEmpty())
427+
if (!IsEmpty(argInfo.info->defaultVal))
425428
result.args[argInfo.info->name] = std::make_shared<ConstantExpression>(argInfo.info->defaultVal);
426429
break;
427430
}

0 commit comments

Comments
 (0)
0