Add reflection and 'sort' filter

Author: flexferrum

include/jinja2cpp/reflected_value.h

@@ -9,22 +9,60 @@ namespace jinja2
 template<typename T>
 Value Reflect(T&& val);
 
-#if 0
+template<typename T, bool val>
+struct TypeReflectedImpl : std::integral_constant<bool, val>
+{
+};
+
+template<typename T>
+struct TypeReflected : TypeReflectedImpl<T, true>
+{
+    using FieldAccessor = std::function<Value (const T& value)>;
+};
+
+
+
+template<typename T>
+struct TypeReflection : TypeReflectedImpl<T, false>
+{
+};
+
 template<typename Derived>
-class ReflectedMapImplBase : public ReflectedMap::ItemAccessor
+class ReflectedMapImplBase : public MapItemAccessor
 {
 public:
     bool HasValue(const std::string& name) const override
     {
         return Derived::GetAccessors().count(name) != 0;
     }
-    Value GetValue(const std::string& name) const override
+    Value GetValueByName(const std::string& name) const override
     {
         auto& accessors = Derived::GetAccessors();
         auto p = accessors.find(name);
         if (p == accessors.end())
             throw std::runtime_error("Invalid field access");
 
+        return static_cast<const Derived*>(this)->GetField(p->second);
+    }
+    std::vector<std::string> GetKeys() const
+    {
+        std::vector<std::string> result;
+        auto& accessors = Derived::GetAccessors();
+        for (auto& i : accessors)
+            result.push_back(i.first);
+
+        return result;
+    }
+    size_t GetSize() const override
+    {
+        return Derived::GetAccessors().size();
+    }
+    virtual Value GetValueByIndex(int64_t idx) const
+    {
+        auto& accessors = Derived::GetAccessors();
+        auto p = accessors.begin();
+        std::advance(p, idx);
+
         return static_cast<const Derived*>(this)->GetField(p->second);
     }
 };
@@ -34,30 +72,31 @@ class ReflectedMapImpl : public ReflectedMapImplBase<ReflectedMapImpl<T>>
 {
 public:
     ReflectedMapImpl(T val) : m_value(val) {}
-    using FieldAccessor = std::function<Value (const T& value)>;
+    ReflectedMapImpl(const T* val) : m_valuePtr(val) {}
 
-    static auto& GetAccessors();
-    static std::string ToString(const T& value);
+    static auto GetAccessors() {return TypeReflection<T>::GetAccessors();}
     template<typename Fn>
     Value GetField(Fn&& accessor) const
     {
-        return accessor(m_value);
+        return accessor(m_valuePtr ? *m_valuePtr : m_value);
     }
 
-    std::string ToString() const override
-    {
-        return ToString(m_value);
-    }
 private:
     T m_value;
+    const T* m_valuePtr = nullptr;
 };
-#endif
 
 namespace detail
 {
 template<typename T, typename Tag = void>
 struct Reflector;
 
+template<typename T>
+using IsReflectedType = std::enable_if_t<TypeReflection<T>::value>;
+
+// using IsReflectedType = std::enable_if_t<std::is_same<decltype(ReflectedMapImpl<T>::GetAccessors())::key_type, std::string>::value>;
+// using IsReflectedType = typename Type2Void<typename Type2TypeT<decltype(TypeReflection<T>::GetAccessors())>::key_type>::type;
+
 struct ContainerReflector
 {
     template<typename T>
@@ -136,9 +175,29 @@ struct Reflector<std::vector<T>>
     {
         return ContainerReflector::CreateFromValue(std::move(val));
     }
-    static auto CreateFromPtr(const std::vector<T>* val)
+    template<typename U>
+    static auto CreateFromPtr(U&& val)
     {
-        return ContainerReflector::CreateFromPtr(val);
+        return ContainerReflector::CreateFromPtr(std::forward<U>(val));
+    }
+};
+
+template<typename T>
+struct Reflector<T, IsReflectedType<T>>
+{
+    static auto Create(const T& val)
+    {
+        return GenericMap([accessor = ReflectedMapImpl<T>(val)]() {return &accessor;});
+    }
+
+    static auto CreateFromPtr(const T* val)
+    {
+        return GenericMap([accessor = ReflectedMapImpl<T>(static_cast<const T*>(val))]() {return &accessor;});
+    }
+
+    static auto CreateFromPtr(std::shared_ptr<T> val)
+    {
+        return GenericMap([accessor = ReflectedMapImpl<T>(val.get())]() {return &accessor;});
     }
 };
 
@@ -151,6 +210,15 @@ struct Reflector<const T&>
     }
 };
 
+template<typename T>
+struct Reflector<T&>
+{
+    static auto Create(T& val)
+    {
+        return Reflector<T>::Create(val);
+    }
+};
+
 template<typename T>
 struct Reflector<const T*>
 {
@@ -169,6 +237,15 @@ struct Reflector<T*>
     }
 };
 
+template<typename T>
+struct Reflector<std::shared_ptr<T>>
+{
+    static auto Create(std::shared_ptr<T> val)
+    {
+        return Reflector<T>::CreateFromPtr(val);
+    }
+};
+
 template<>
 struct Reflector<std::string>
 {

src/expression_evaluator.cpp

@@ -10,6 +10,7 @@ namespace jinja2
 
 std::unordered_map<std::string, ExpressionFilter::FilterFactoryFn> ExpressionFilter::s_filters = {
     {"join", &FilterFactory<filters::Join>::Create},
+    {"sort", &FilterFactory<filters::Sort>::Create},
 };
 
 std::unordered_map<std::string, IsExpression::TesterFactoryFn> IsExpression::s_testers = {

src/filters.cpp

@@ -36,5 +36,70 @@ Value Join::Filter(const Value& baseVal, RenderContext& context)
     return result;
 }
 
+Sort::Sort(FilterParams params)
+{
+    helpers::FindParam(params, "", "attribute", m_attrNameEvaluator);
+}
+
+struct GetAsValuesListVisitor : boost::static_visitor<ValuesList>
+{
+    GetAsValuesListVisitor(Value attr = Value())
+        : m_attr(std::move(attr))
+    {}
+
+    ValuesList operator() (const ValuesList& values) const
+    {
+        if (m_attr.isEmpty())
+            return values;
+
+        ValuesList result;
+        std::transform(values.begin(), values.end(), std::back_inserter(result), [this](const Value& val) {return val.subscript(m_attr);});
+        return result;
+    }
+
+    ValuesList operator() (const GenericList& values) const
+    {
+        int64_t size = values.GetSize();
+
+        ValuesList result;
+        for (int64_t idx = 0; idx < size; ++ idx)
+        {
+            auto val = values.GetValueByIndex(idx);
+            if (!m_attr.isEmpty())
+                result.push_back(val.subscript(m_attr));
+            else
+                result.push_back(val);
+        }
+
+        return result;
+    }
+
+    template<typename U>
+    ValuesList operator() (U&&) const
+    {
+        return ValuesList();
+    }
+
+    Value m_attr;
+};
+
+Value Sort::Filter(const Value& baseVal, RenderContext& context)
+{
+    Value attrName = m_attrNameEvaluator->Evaluate(context);
+    ValuesList values = boost::apply_visitor(GetAsValuesListVisitor(), baseVal.data());
+
+    std::sort(values.begin(), values.end(), [&attrName](auto& val1, auto& val2) {
+        Value cmpRes;
+        if (attrName.isEmpty())
+            cmpRes = boost::apply_visitor(visitors::BinaryMathOperation(BinaryExpression::LogicalLt), val1.data(), val2.data());
+        else
+            cmpRes = boost::apply_visitor(visitors::BinaryMathOperation(BinaryExpression::LogicalLt), val1.subscript(attrName).data(), val2.subscript(attrName).data());
+
+        return boost::apply_visitor(visitors::BooleanEvaluator(), cmpRes.data());
+    });
+
+    return values;
+}
+
 } // filters
 } // jinja2

src/filters.h

@@ -35,6 +35,18 @@ class Join : public ExpressionFilter::IExpressionFilter
     ExpressionEvaluatorPtr<> m_delimiterEval;
     ExpressionEvaluatorPtr<> m_attribute;
 };
+
+class Sort : public ExpressionFilter::IExpressionFilter
+{
+public:
+    Sort(FilterParams params);
+
+    Value Filter(const Value& baseVal, RenderContext& context);
+
+private:
+    ExpressionEvaluatorPtr<> m_attrNameEvaluator;
+    ExpressionEvaluatorPtr<> m_descEvaluator;
+};
 } // filters
 } // jinja2
 

src/statements.cpp

@@ -3,7 +3,7 @@
 
 namespace jinja2
 {
-    
+
 struct ValuesListAdaptorCreator : public boost::static_visitor<std::function<const ListItemAccessor* ()>>
 {
     struct Adaptor : public ListItemAccessor
@@ -15,10 +15,10 @@ struct ValuesListAdaptorCreator : public boost::static_visitor<std::function<con
 
         size_t GetSize() const override {return m_list->size();}
         Value GetValueByIndex(int64_t idx) const override {return (*m_list)[idx];};
-      
+
         const ValuesList* m_list;
     };
-    
+
 
     std::function<const ListItemAccessor* ()> operator() (const ValuesList& values) const
     {
@@ -29,13 +29,13 @@ struct ValuesListAdaptorCreator : public boost::static_visitor<std::function<con
     {
         return [&values]() {return values.GetAccessor();};
     }
-    
+
     template<typename U>
     std::function<const ListItemAccessor* ()> operator() (U&&) const
     {
         return []() {return nullptr;};
     }
-    
+
 };
 
 void ForStatement::Render(OutStream& os, RenderContext& values)
@@ -80,7 +80,7 @@ void ForStatement::Render(OutStream& os, RenderContext& values)
         m_mainBody->Render(os, values);
     }
 
-    if (!loopRendered)
+    if (!loopRendered && m_elseBody)
         m_elseBody->Render(os, values);
 
     values.ExitScope();

test/forloop_test.cpp

@@ -57,6 +57,28 @@ a[2] = image[2];
     EXPECT_EQ(expectedResult, result);
 }
 
+TEST(ForLoopTest, EmptyLoop)
+{
+    std::string source = R"(
+{% for i in ints %}
+a[{{i}}] = image[{{i}}];
+{% endfor %}
+)";
+
+    Template tpl;
+    ASSERT_TRUE(tpl.Load(source));
+
+    ValuesMap params = {
+        {"ints", ValuesList()}
+    };
+
+    std::string result = tpl.RenderAsString(params);
+    std::cout << result << std::endl;
+    std::string expectedResult = R"(
+)";
+    EXPECT_EQ(expectedResult, result);
+}
+
 TEST(ForLoopTest, ReflectedIntegersLoop)
 {
     std::string source = R"(