Implement loop over Values and Generic lists

Author: flexferrum

include/jinja2cpp/reflected_value.h

@@ -6,6 +6,9 @@
 namespace jinja2
 {
 
+template<typename T>
+Value Reflect(T&& val);
+
 #if 0
 template<typename Derived>
 class ReflectedMapImplBase : public ReflectedMap::ItemAccessor
@@ -73,7 +76,9 @@ struct ContainerReflector
         }
         Value GetValueByIndex(int64_t idx) const override
         {
-            return Reflect(m_value.begin() + idx);
+            auto p = m_value.begin();
+            std::advance(p, idx);
+            return Reflect(*p);
         }
     };
 
@@ -99,7 +104,7 @@ struct ContainerReflector
     };
 
     template<typename T>
-    static Value CreateFromPtr(T&& cont)
+    static Value CreateFromValue(T&& cont)
     {
         return GenericList([accessor = ValueItemAccessor<T>(std::move(cont))]() {return &accessor;});
     }
@@ -116,7 +121,7 @@ struct Reflector<std::set<T>>
 {
     static auto Create(std::set<T> val)
     {
-        return ContainerReflector::Create(std::move(val));
+        return ContainerReflector::CreateFromValue(std::move(val));
     }
     static auto CreateFromPtr(const std::set<T>* val)
     {
@@ -129,7 +134,7 @@ struct Reflector<std::vector<T>>
 {
     static auto Create(std::vector<T> val)
     {
-        return ContainerReflector::Create(std::move(val));
+        return ContainerReflector::CreateFromValue(std::move(val));
     }
     static auto CreateFromPtr(const std::vector<T>* val)
     {
@@ -176,6 +181,19 @@ struct Reflector<std::string>
         return Value(*str);
     }
 };
+
+template<>
+struct Reflector<int64_t>
+{
+    static auto Create(int64_t val)
+    {
+        return Value(val);
+    }
+    static auto CreateFromPtr(const int64_t* val)
+    {
+        return Value(*val);
+    }
+};
 } // detail
 
 template<typename T>

include/jinja2cpp/value.h

@@ -69,6 +69,11 @@ class GenericList
     }
 
     Value GetValueByIndex(int64_t idx) const;
+    
+    auto GetAccessor() const
+    {
+        return m_accessor();
+    }
 
     std::function<const ListItemAccessor* ()> m_accessor;
 };

src/statements.cpp

@@ -3,6 +3,40 @@
 
 namespace jinja2
 {
+    
+struct ValuesListAdaptorCreator : public boost::static_visitor<std::function<const ListItemAccessor* ()>>
+{
+    struct Adaptor : public ListItemAccessor
+    {
+        Adaptor(const ValuesList* list)
+            : m_list(list)
+        {
+        }
+
+        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
+    {
+        return [adaptor = Adaptor(&values)]() {return &adaptor;};
+    }
+
+    std::function<const ListItemAccessor* ()> operator() (const GenericList& values) const
+    {
+        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)
 {
@@ -13,15 +47,11 @@ void ForStatement::Render(OutStream& os, RenderContext& values)
     context["loop"] = ValuesMap();
     auto& loopVar = context["loop"].asMap();
 
-    ValuesList* loopItems = nullptr;
-    ValuesList fakeItems;
-
-    if (loopVal.isEmpty() || !loopVal.isList())
-        loopItems = &fakeItems;
-    else
-        loopItems = &loopVal.asList();
+    auto loopItems = boost::apply_visitor(ValuesListAdaptorCreator(), loopVal.data());
+    if (!loopItems())
+        return;
 
-    int64_t itemsNum = static_cast<int64_t>(loopItems->size());
+    int64_t itemsNum = static_cast<int64_t>(loopItems()->GetSize());
     loopVar["length"] = Value(itemsNum);
     bool loopRendered = false;
     for (int64_t itemIdx = 0; itemIdx != itemsNum; ++ itemIdx)
@@ -32,13 +62,13 @@ void ForStatement::Render(OutStream& os, RenderContext& values)
         loopVar["first"] = Value(itemIdx == 0);
         loopVar["last"] = Value(itemIdx == itemsNum - 1);
         if (itemIdx != 0)
-            loopVar["previtem"] = (*loopItems)[static_cast<size_t>(itemIdx - 1)];
+            loopVar["previtem"] = loopItems()->GetValueByIndex(static_cast<size_t>(itemIdx - 1));
         if (itemIdx != itemsNum - 1)
-            loopVar["nextitem"] = (*loopItems)[static_cast<size_t>(itemIdx + 1)];
+            loopVar["nextitem"] = loopItems()->GetValueByIndex(static_cast<size_t>(itemIdx + 1));
         else
             loopVar.erase("nextitem");
 
-        auto& curValue = (*loopItems)[static_cast<size_t>(itemIdx)];
+        const auto& curValue = loopItems()->GetValueByIndex(static_cast<size_t>(itemIdx));
         if (m_vars.size() > 1 && curValue.isMap())
         {
             for (auto& varName : m_vars)

test/forloop_test.cpp

@@ -4,6 +4,7 @@
 #include "gtest/gtest.h"
 
 #include "jinja2cpp/template.h"
+#include "jinja2cpp/reflected_value.h"
 
 using namespace jinja2;
 
@@ -56,6 +57,31 @@ a[2] = image[2];
     EXPECT_EQ(expectedResult, result);
 }
 
+TEST(ForLoopTest, ReflectedIntegersLoop)
+{
+    std::string source = R"(
+{% for i in its %}
+a[{{i}}] = image[{{i}}];
+{% endfor %}
+)";
+
+    Template tpl;
+    ASSERT_TRUE(tpl.Load(source));
+
+    ValuesMap params = {
+        {"its", Reflect(std::vector<int64_t>{0, 1, 2} ) }
+    };
+
+    std::string result = tpl.RenderAsString(params);
+    std::cout << result << std::endl;
+    std::string expectedResult = R"(
+a[0] = image[0];
+a[1] = image[1];
+a[2] = image[2];
+)";
+    EXPECT_EQ(expectedResult, result);
+}
+
 TEST(ForLoopTest, LoopVariable)
 {
     std::string source = R"(
@@ -146,3 +172,5 @@ b[1] = image[1];
 
     EXPECT_EQ(expectedResult, result);
 }
+
+