Use (non)std variant instead boost::variant (#43)

* Switch on actual Martin's Moene 'variant-lite'

* boost::variant -> nonstd::variant (2)

* boost::variant -> nonstd::variant (3)

* boost::variant -> nonstd::variant (4)

* boost::variant -> nonstd::variant (4)

* Performance improvement

* martinmoene/value-ptr-lite -> flexferrum/value-ptr-lite

* Fix map retrival from jinja2::Value

* Fix crash

* Fix stream operator application

* Completely remove boost from public headers

Author: flexferrum

.gitmodules

@@ -1,9 +1,12 @@
 [submodule "thirdparty/gtest"]
-	path = thirdparty/gtest
-	url = https://github.com/google/googletest.git
+        path = thirdparty/gtest
+        url = https://github.com/google/googletest.git
 [submodule "thirdparty/nonstd/variant-light"]
-	path = thirdparty/nonstd/variant-light
-	url = https://github.com/flexferrum/variant-lite.git
+        path = thirdparty/nonstd/variant-light
+        url = https://github.com/martinmoene/variant-lite.git
 [submodule "thirdparty/nonstd/expected-light"]
-	path = thirdparty/nonstd/expected-light
-	url = https://github.com/martinmoene/expected-lite.git
+        path = thirdparty/nonstd/expected-light
+        url = https://github.com/martinmoene/expected-lite.git
+[submodule "thirdparty/nonstd/value-ptr-lite"]
+        path = thirdparty/nonstd/value-ptr-lite
+        url = https://github.com/flexferrum/value-ptr-lite.git

CMakeLists.txt

@@ -173,6 +173,8 @@ install(TARGETS ${LIB_TARGET_NAME}
 
 install (DIRECTORY include/ DESTINATION include)
 install (DIRECTORY thirdparty/nonstd/expected-light/include/ DESTINATION include)
+install (DIRECTORY thirdparty/nonstd/variant-light/include/ DESTINATION include)
+install (DIRECTORY thirdparty/nonstd/value-ptr-light/include/ DESTINATION include)
 install (FILES cmake/public/FindJinja2Cpp.cmake DESTINATION cmake)
 
 add_test(NAME jinja2cpp_tests COMMAND jinja2cpp_tests)

include/jinja2cpp/error_info.h

@@ -3,7 +3,7 @@
 
 #include "value.h"
 
-#include <boost/optional.hpp>
+#include <nonstd/optional.hpp>
 
 #include <iostream>
 #include <vector>

include/jinja2cpp/filesystem_handler.h

@@ -1,7 +1,7 @@
 #ifndef JINJA2CPP_FILESYSTEM_HANDLER_H
 #define JINJA2CPP_FILESYSTEM_HANDLER_H
 
-#include <boost/variant.hpp>
+#include <nonstd/variant.hpp>
 
 #include <iostream>
 #include <memory>
@@ -37,7 +37,7 @@ class MemoryFileSystem : public IFilesystemHandler
     WCharFileStreamPtr OpenWStream(const std::string& name) const override;
 
 private:
-    using FileContent = boost::variant<std::string, std::wstring>;
+    using FileContent = nonstd::variant<std::string, std::wstring>;
     std::unordered_map<std::string, FileContent> m_filesMap;
 };
 

include/jinja2cpp/value.h

@@ -7,7 +7,8 @@
 #include <unordered_map>
 #include <string>
 #include <functional>
-#include <boost/variant.hpp>
+#include <nonstd/variant.hpp>
+#include <nonstd/value_ptr.hpp>
 
 namespace jinja2
 {
@@ -34,6 +35,7 @@ class GenericMap
 {
 public:
     GenericMap() = default;
+
     GenericMap(std::function<const MapItemAccessor* ()> accessor)
         : m_accessor(std::move(accessor))
     {
@@ -89,13 +91,20 @@ class GenericList
 
 using ValuesList = std::vector<Value>;
 using ValuesMap = std::unordered_map<std::string, Value>;
-using ValueData = boost::variant<EmptyValue, bool, std::string, std::wstring, int64_t, double, boost::recursive_wrapper<ValuesList>, boost::recursive_wrapper<ValuesMap>, GenericList, GenericMap>;
+struct FunctionCallParams;
+
+using UserFunction = std::function<Value (const FunctionCallParams&)>;
+
+template<typename T>
+using RecWrapper = nonstd::value_ptr<T>;
 
 class Value {
 public:
+    using ValueData = nonstd::variant<EmptyValue, bool, std::string, std::wstring, int64_t, double, RecWrapper<ValuesList>, RecWrapper<ValuesMap>, GenericList, GenericMap, UserFunction>;
+
     Value() = default;
     template<typename T>
-    Value(T&& val, typename std::enable_if<!std::is_same<std::decay_t<T>, Value>::value>::type* = nullptr)
+    Value(T&& val, typename std::enable_if<!std::is_same<std::decay_t<T>, Value>::value && !std::is_same<std::decay_t<T>, ValuesList>::value>::type* = nullptr)
         : m_data(std::forward<T>(val))
     {
     }
@@ -112,51 +121,67 @@ class Value {
         : m_data(static_cast<int64_t>(val))
     {
     }
+    Value(const ValuesList& list)
+        : m_data(RecWrapper<ValuesList>(list))
+    {
+    }
+    Value(const ValuesMap& map)
+        : m_data(RecWrapper<ValuesMap>(map))
+    {
+    }
+    Value(ValuesList&& list) noexcept
+        : m_data(RecWrapper<ValuesList>(std::move(list)))
+    {
+    }
+    Value(ValuesMap&& map) noexcept
+        : m_data(RecWrapper<ValuesMap>(std::move(map)))
+    {
+    }
 
     const ValueData& data() const {return m_data;}
 
     ValueData& data() {return m_data;}
 
     bool isString() const
     {
-        return boost::get<std::string>(&m_data) != nullptr;
+        return nonstd::get_if<std::string>(&m_data) != nullptr;
     }
     auto& asString()
     {
-        return boost::get<std::string>(m_data);
+        return nonstd::get<std::string>(m_data);
     }
     auto& asString() const
     {
-        return boost::get<std::string>(m_data);
+        return nonstd::get<std::string>(m_data);
     }
 
     bool isList() const
     {
-        return boost::get<ValuesList>(&m_data) != nullptr || boost::get<GenericList>(&m_data) != nullptr;
+        return nonstd::get_if<RecWrapper<ValuesList>>(&m_data) != nullptr || nonstd::get_if<GenericList>(&m_data) != nullptr;
     }
     auto& asList()
     {
-        return boost::get<ValuesList>(m_data);
+        return *nonstd::get<RecWrapper<ValuesList>>(m_data).get();
     }
     auto& asList() const
     {
-        return boost::get<ValuesList>(m_data);
+        return *nonstd::get<RecWrapper<ValuesList>>(m_data).get();
     }
     bool isMap() const
     {
-        return boost::get<ValuesMap>(&m_data) != nullptr || boost::get<GenericMap>(&m_data) != nullptr;
+        return nonstd::get_if<RecWrapper<ValuesMap>>(&m_data) != nullptr || nonstd::get_if<GenericMap>(&m_data) != nullptr;
     }
     auto& asMap()
     {
-        return boost::get<ValuesMap>(m_data);
+        return *nonstd::get<RecWrapper<ValuesMap>>(m_data).get();
     }
     auto& asMap() const
     {
-        return boost::get<ValuesMap>(m_data);
+        return *nonstd::get<RecWrapper<ValuesMap>>(m_data).get();
     }
     bool isEmpty() const
     {
-        return boost::get<EmptyValue>(&m_data) != nullptr;
+        return nonstd::get_if<EmptyValue>(&m_data) != nullptr;
     }
 
     Value subscript(const Value& index) const;
@@ -165,6 +190,12 @@ class Value {
     ValueData m_data;
 };
 
+struct FunctionCallParams
+{
+    ValuesMap kwParams;
+    ValuesList posParams;
+};
+
 inline Value GenericMap::GetValueByName(const std::string& name) const
 {
     return m_accessor()->GetValueByName(name);

src/error_info.cpp

@@ -7,7 +7,7 @@ namespace jinja2
 namespace
 {
 template<typename CharT>
-struct ValueRenderer : boost::static_visitor<void>
+struct ValueRenderer
 {
     std::basic_ostream<CharT>& os;
 
@@ -37,7 +37,7 @@ struct ValueRenderer : boost::static_visitor<void>
             else
                 os << UNIVERSAL_STR(", ");
 
-            boost::apply_visitor(ValueRenderer<CharT>(os), val.data());
+            nonstd::visit(ValueRenderer<CharT>(os), val.data());
         }
         os << '}';
     }
@@ -54,12 +54,19 @@ struct ValueRenderer : boost::static_visitor<void>
                 os << UNIVERSAL_STR(", ");
 
             os << '{' << '"' << ConvertString<std::basic_string<CharT>>(val.first) << '"' << ',';
-            boost::apply_visitor(ValueRenderer<CharT>(os), val.second.data());
+            nonstd::visit(ValueRenderer<CharT>(os), val.second.data());
             os << '}';
         }
         os << '}';
     }
 
+
+    template<typename T>
+    void operator()(const RecWrapper<T>& val) const
+    {
+        return this->operator()(const_cast<const T&>(*val.get()));
+    }
+
     void operator() (const GenericMap& /*val*/) const
     {
     }
@@ -68,6 +75,11 @@ struct ValueRenderer : boost::static_visitor<void>
     {
     }
 
+
+    void operator() (const UserFunction& val) const
+    {
+    }
+
     template<typename T>
     void operator() (const T& val) const
     {
@@ -78,7 +90,7 @@ struct ValueRenderer : boost::static_visitor<void>
 template<typename CharT>
 std::basic_ostream<CharT>& operator << (std::basic_ostream<CharT>& os, Value val)
 {
-    boost::apply_visitor(ValueRenderer<CharT>(os), val.data());
+    nonstd::visit(ValueRenderer<CharT>(os), val.data());
     return os;
 }
 }

src/expression_evaluator.cpp

@@ -89,15 +89,15 @@ InternalValue BinaryExpression::Evaluate(RenderContext& context)
         bool left = ConvertToBool(leftVal);
         if (left)
             left = ConvertToBool(rightVal);
-        result = left;
+        result = static_cast<bool>(left);
         break;
     }
     case jinja2::BinaryExpression::LogicalOr:
     {
         bool left = ConvertToBool(leftVal);
         if (!left)
             left = ConvertToBool(rightVal);
-        result = left;
+        result = static_cast<bool>(left);
         break;
     }
     case jinja2::BinaryExpression::LogicalEq:
@@ -125,16 +125,16 @@ InternalValue BinaryExpression::Evaluate(RenderContext& context)
         auto leftStr = context.GetRendererCallback()->GetAsTargetString(leftVal);
         auto rightStr = context.GetRendererCallback()->GetAsTargetString(rightVal);
         TargetString resultStr;
-        std::string* nleftStr = boost::get<std::string>(&leftStr);
+        std::string* nleftStr = GetIf<std::string>(&leftStr);
         if (nleftStr != nullptr)
         {
-            auto* nrightStr = boost::get<std::string>(&rightStr);
+            auto* nrightStr = GetIf<std::string>(&rightStr);
             resultStr = *nleftStr + *nrightStr;
         }
         else
         {
-            auto* wleftStr = boost::get<std::wstring>(&leftStr);
-            auto* wrightStr = boost::get<std::wstring>(&rightStr);
+            auto* wleftStr = GetIf<std::wstring>(&leftStr);
+            auto* wrightStr = GetIf<std::wstring>(&rightStr);
             resultStr = *wleftStr + *wrightStr;
         }
         result = InternalValue(std::move(resultStr));
@@ -252,11 +252,11 @@ InternalValue CallExpression::Evaluate(RenderContext& values)
 void CallExpression::Render(OutStream& stream, RenderContext& values)
 {
     auto fnVal = m_valueRef->Evaluate(values);
-    Callable* callable = boost::get<Callable>(&fnVal);
+    Callable* callable = GetIf<Callable>(&fnVal);
     if (callable == nullptr)
     {
         fnVal = Subscript(fnVal, std::string("operator()"));
-        callable = boost::get<Callable>(&fnVal);
+        callable = GetIf<Callable>(&fnVal);
         if (callable == nullptr)
         {
             Expression::Render(stream, values);
@@ -342,7 +342,7 @@ InternalValue CallExpression::CallLoopCycle(RenderContext& values)
     if (!loopFound)
         return InternalValue();
 
-    auto loop = boost::get<MapAdapter>(&loopValP->second);
+    auto loop = GetIf<MapAdapter>(&loopValP->second);
     int64_t baseIdx = Apply<visitors::IntegerEvaluator>(loop->GetValueByName("index0"));
     auto idx = static_cast<size_t>(baseIdx % m_params.posParams.size());
     return m_params.posParams[idx]->Evaluate(values);

src/filesystem_handler.cpp

@@ -8,9 +8,9 @@
 namespace jinja2
 {
 
-using TargetFileStream = boost::variant<CharFileStreamPtr*, WCharFileStreamPtr*>;
+using TargetFileStream = nonstd::variant<CharFileStreamPtr*, WCharFileStreamPtr*>;
 
-struct FileContentConverter : public boost::static_visitor<void>
+struct FileContentConverter
 {
     void operator() (const std::string& content, CharFileStreamPtr* sPtr) const
     {
@@ -52,7 +52,7 @@ CharFileStreamPtr MemoryFileSystem::OpenStream(const std::string& name) const
         return result;
 
     TargetFileStream targetStream(&result);
-    boost::apply_visitor(FileContentConverter(), p->second, targetStream);
+    visit(FileContentConverter(), p->second, targetStream);
 
     return result;
 }
@@ -65,7 +65,7 @@ WCharFileStreamPtr MemoryFileSystem::OpenWStream(const std::string& name) const
         return result;
 
     TargetFileStream targetStream(&result);
-    boost::apply_visitor(FileContentConverter(), p->second, targetStream);
+    visit(FileContentConverter(), p->second, targetStream);
 
     return result;
 }