Merge pull request #56 from flexferrum/boost_submodule

Make boost dependency as submodule

Author: flexferrum

.gitmodules

@@ -10,3 +10,7 @@
 [submodule "thirdparty/nonstd/value-ptr-lite"]
         path = thirdparty/nonstd/value-ptr-lite
         url = https://github.com/flexferrum/value-ptr-lite.git
+[submodule "thirdparty/boost"]
+	path = thirdparty/boost
+	url = https://github.com/Manu343726/boost-cmake.git
+	branch = master

CMakeLists.txt

@@ -1,158 +1,92 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.0.2)
 project(Jinja2Cpp VERSION 0.5.0)
 
-list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
-if(CMAKE_COMPILER_IS_GNUCXX AND COVERAGE_ENABLED)
-    message (STATUS "This is DEBUG build with enabled Code Coverage")
-    set (CMAKE_BUILD_TYPE Debug)
-    include(code_coverage)
-    setup_target_for_coverage(${PROJECT_NAME}_coverage jinja2cpp_tests coverage)
-endif()
-
-set(GTEST_ROOT $ENV{GTEST_DIR} CACHE PATH "Path to GTest/GMock library root")
-if (NOT UNIX)
-    set(BOOST_ROOT $ENV{BOOST_DIR} CACHE PATH "Path to boost library root")
-    set(LIBRARY_TYPE STATIC CACHE PATH "Library link type")
-else ()
-    set(BOOST_ROOT "/usr" CACHE PATH "Path to boost library root")
-    set(LIBRARY_TYPE SHARED CACHE PATH "Library link type")
-endif ()
-
-if (NOT DEFINED WITH_TESTS)
-    set (WITH_TESTS TRUE)
-endif ()
-
-set (EXTRA_TEST_LIBS "")
-set (CMAKE_CXX_STANDARD 14)
-set (CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 if (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang" OR ${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
     if (NOT UNIX)
-        set (EXTRA_TEST_LIBS "stdc++")
         set (CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} "-Wa,-mbig-obj")
-    else ()
-        include(CMakeFindDependencyMacro)
-        find_dependency(Threads)
-        set (EXTRA_TEST_LIBS Threads::Threads)
     endif ()
 else ()
+    set (COMMON_MSVC_OPTS "/wd4503 /DBOOST_ALL_NO_LIB")
+
     # MSVC
-    if (NOT DEFINED Boost_USE_STATIC_LIBS)
-        set (Boost_USE_STATIC_LIBS ON)
-    endif ()
     if (NOT DEFINED MSVC_RUNTIME_TYPE)
         set (MSVC_RUNTIME_TYPE "/MD")
+        set (gtest_force_shared_crt ON CACHE BOOL "" FORCE)
     endif ()
     if (CMAKE_BUILD_TYPE MATCHES "Debug")
-        message("#######>>>>>>>>>>!!!!!!!!!!!!!! AAAAAAAAAAAAAAAAAAAAAAAAAAAA")
-        set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MSVC_RUNTIME_TYPE}d")
+        set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${MSVC_RUNTIME_TYPE}d ${COMMON_MSVC_OPTS}")
         set (Boost_USE_DEBUG_RUNTIME ON)
     else ()
-        set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MSVC_RUNTIME_TYPE}")
-        set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${MSVC_RUNTIME_TYPE}")
+        set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${MSVC_RUNTIME_TYPE}  ${COMMON_MSVC_OPTS}")
+        set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${MSVC_RUNTIME_TYPE} ${COMMON_MSVC_OPTS}")
         set (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "/PROFILE")
         set (Boost_USE_DEBUG_RUNTIME OFF)
     endif ()
-endif()
 
-if("${GTEST_ROOT}" STREQUAL "" AND WITH_TESTS)
-    set (THIRDPARTY_TARGETS ${THIRDPARTY_TARGETS} gtest)
 endif()
 
-if(NOT "${BOOST_ROOT}" STREQUAL "")
-    list (APPEND CMAKE_PREFIX_PATH ${BOOST_ROOT})
-    set (Boost_DIR ${BOOST_ROOT})
-endif()
-
-make_directory (${CMAKE_CURRENT_BINARY_DIR}/thirdparty)
-execute_process (
-    COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/thirdparty
-    RESULT_VARIABLE THIRDPARTY_BUILD_RESULT
-    )
-
-if (THIRDPARTY_BUILD_RESULT EQUAL 0 AND THIRDPARTY_TARGETS)
-    execute_process (
-        COMMAND ${CMAKE_COMMAND} --build . --target ${THIRDPARTY_TARGETS}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/thirdparty
-        RESULT_VARIABLE THIRDPARTY_BUILD_RESULT
-        )
-endif ()
-
-if (NOT THIRDPARTY_BUILD_RESULT EQUAL 0)
-    message (FATAL_ERROR "Can't build thirdparty libraries")
-endif ()
-
-if("${GTEST_ROOT}" STREQUAL "" AND WITH_TESTS)
-    set (GTEST_ROOT ${CMAKE_CURRENT_BINARY_DIR}/thirdparty/gtest/install)
-    set (GTEST_SELF_BUILD ON)
-endif ()
+set(BOOST_CMAKE_LIBRARIES filesystem algorithm variant optional CACHE INTERNAL "")
+add_subdirectory(thirdparty/boost EXCLUDE_FROM_ALL)
+add_subdirectory(thirdparty/nonstd EXCLUDE_FROM_ALL)
 
-if(NOT "${GTEST_ROOT}" STREQUAL "" AND WITH_TESTS)
-    list (APPEND CMAKE_PREFIX_PATH ${GTEST_ROOT})
-    set (Gtest_DIR ${GTEST_ROOT})
-    message(STATUS "GTest library search path: ${Gtest_DIR}")
-    if (NOT GTEST_SELF_BUILD)
-        find_package(GTest)
-    else ()
-        set (Gtest_DIR ${GTEST_ROOT})
-        find_package(GTest)
-    endif ()
-    if (NOT GTEST_INCLUDE_DIRS)
-        if (MSVC AND NOT GTEST_INCLUDE_DIRS)
-            set (GTEST_MSVC_SEARCH "MT")
-            find_package(GTest)
-        else ()
-            set (GTEST_BOTH_LIBRARIES "optimized;${GTEST_ROOT}/lib/libgtest.a;debug;${GTEST_ROOT}/lib/libgtestd.a;optimized;${GTEST_ROOT}/lib/libgtest_main.a;debug;${GTEST_ROOT}/lib/libgtest_maind.a")
-            set (GTEST_INCLUDE_DIRS ${GTEST_ROOT}/include)
-        endif ()
-    endif ()
+if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
+    set(JINJA2CPP_IS_MAIN_PROEJCT TRUE)
+else()
+    set(JINJA2CPP_IS_MAIN_PROEJCT FALSE)
 endif()
 
-if (WITH_TESTS)
-    find_package(Boost COMPONENTS system filesystem REQUIRED)
-else ()
-    find_package(Boost)
-endif ()
-
-add_subdirectory (thirdparty/nonstd)
+option(JINJA2CPP_BUILD_TESTS "Build Jinja2Cpp unit tests" ${JINJA2CPP_IS_MAIN_PROEJCT})
 
 include(collect_sources)
 
-include_directories(
-    ${CMAKE_CURRENT_SOURCE_DIR}/include
-    )
-
 set (LIB_TARGET_NAME jinja2cpp)
 
 CollectSources(Sources Headers ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/src)
 CollectSources(PublicSources PublicHeaders ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/include)
 
-if(CMAKE_COMPILER_IS_GNUCXX AND COVERAGE_ENABLED)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
-endif()
-
 add_library(${LIB_TARGET_NAME} STATIC
     ${Sources}
     ${Headers}
     ${PublicHeaders}
     )
 
-target_link_libraries(${LIB_TARGET_NAME} PUBLIC ThirdParty::nonstd Boost::boost) # Boost::system Boost::filesystem)
+target_link_libraries(${LIB_TARGET_NAME} PUBLIC ThirdParty::nonstd boost_variant boost_filesystem boost_algorithm)
 
 target_include_directories(${LIB_TARGET_NAME}
-    INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+    PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+
+if(NOT MSVC)
+    # Enable -Werror and -Wall on jinja2cpp target, ignoring warning errors from thirdparty libs
+    include(CheckCXXCompilerFlag)
+    check_cxx_compiler_flag(-Wno-error=parentheses COMPILER_HAS_WNO_ERROR_PARENTHESES_FLAG)
+    check_cxx_compiler_flag(-Wno-error=deprecated-declarations COMPILER_HAS_WNO_ERROR_DEPRECATED_DECLARATIONS_FLAG)
+    check_cxx_compiler_flag(-Wno-error=maybe-uninitialized COMPILER_HAS_WNO_ERROR_MAYBE_UNINITIALIZED_FLAG)
+
+    if(COMPILER_HAS_WNO_ERROR_PARENTHESES_FLAG)
+        target_compile_options(boost_assert INTERFACE -Wno-error=parentheses)
+    endif()
+    if(COMPILER_HAS_WNO_ERROR_DEPRECATED_DECLARATIONS_FLAG)
+        target_compile_options(boost_filesystem PRIVATE -Wno-error=deprecated-declarations)
+    endif()
+    if(COMPILER_HAS_WNO_ERROR_MAYBE_UNINITIALIZED_FLAG)
+        target_compile_options(boost_variant INTERFACE -Wno-error=maybe-uninitialized)
+    endif()
+
+    target_compile_options(${LIB_TARGET_NAME} PRIVATE -Wall -Werror)
+endif()
 
-if (WITH_TESTS)
+if (JINJA2CPP_BUILD_TESTS)
     enable_testing()
-
-    include_directories(
-        ${GTEST_INCLUDE_DIRS}
-        )
+    add_subdirectory(thirdparty/gtest)
 
     CollectSources(TestSources TestHeaders ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/test)
     add_executable(jinja2cpp_tests ${TestSources} ${TestHeaders})
-    target_link_libraries(jinja2cpp_tests ${GTEST_BOTH_LIBRARIES} ${LIB_TARGET_NAME} ${EXTRA_TEST_LIBS} ${Boost_LIBRARIES})
+    target_link_libraries(jinja2cpp_tests gtest gtest_main ${LIB_TARGET_NAME} ${EXTRA_TEST_LIBS})
 
     add_custom_command(
         OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/test_data/simple_template1.j2tpl
@@ -164,6 +98,8 @@ if (WITH_TESTS)
     add_custom_target(CopyTestData ALL
         DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/test_data/simple_template1.j2tpl
         )
+
+    add_test(NAME jinja2cpp_tests COMMAND jinja2cpp_tests)
 endif ()
 
 install(TARGETS ${LIB_TARGET_NAME}
@@ -176,5 +112,3 @@ 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/reflected_value.h

@@ -2,6 +2,12 @@
 #define JINJA2_REFLECTED_VALUE_H
 
 #include "value.h"
+#include <vector>
+#include <set>
+#include <cstddef>
+#include <string>
+#include <type_traits>
+#include <memory>
 
 namespace jinja2
 {
@@ -14,15 +20,18 @@ struct TypeReflectedImpl : std::integral_constant<bool, val>
 {
 };
 
+template<typename T>
+using FieldAccessor = std::function<Value(const T&)>;
+
 template<typename T>
 struct TypeReflected : TypeReflectedImpl<T, true>
 {
-    using FieldAccessor = std::function<Value (const T& value)>;
+    using FieldAccessor = jinja2::FieldAccessor<T>;
 };
 
 
 
-template<typename T>
+template<typename T, typename = void>
 struct TypeReflection : TypeReflectedImpl<T, false>
 {
 };

src/error_info.cpp

@@ -140,7 +140,7 @@ void RenderErrorInfo(std::basic_ostream<CharT>& os, const ErrorInfoTpl<CharT>& e
         if (extraParams.size() > 1)
         {
             os << UNIVERSAL_STR(". Expected: ");
-            for (int i = 1; i < extraParams.size(); ++ i)
+            for (std::size_t i = 1; i < extraParams.size(); ++ i)
             {
                 if (i != 1)
                     os << UNIVERSAL_STR(", ");

src/expression_evaluator.cpp

@@ -425,9 +425,9 @@ ParsedArguments ParseCallParamsImpl(const T& args, const CallParams& params, boo
         ++ argIdx;
     }
 
-    int startPosArg = firstMandatoryIdx == -1 ? 0 : firstMandatoryIdx;
-    int curPosArg = startPosArg;
-    int eatenPosArgs = 0;
+    std::size_t startPosArg = firstMandatoryIdx == -1 ? 0 : firstMandatoryIdx;
+    std::size_t curPosArg = startPosArg;
+    std::size_t eatenPosArgs = 0;
 
     // Determine the range for positional arguments scanning
     bool isFirstTime = true;
@@ -445,7 +445,7 @@ ParsedArguments ParseCallParamsImpl(const T& args, const CallParams& params, boo
         int prevNotFound = argsInfo[startPosArg].prevNotFound;
         if (prevNotFound != -1)
         {
-            startPosArg = prevNotFound;
+            startPosArg = static_cast<std::size_t>(prevNotFound);
         }
         else if (curPosArg == args.size())
         {
@@ -456,20 +456,20 @@ ParsedArguments ParseCallParamsImpl(const T& args, const CallParams& params, boo
             int nextPosArg = argsInfo[curPosArg].nextNotFound;
             if (nextPosArg == -1)
                 break;
-            curPosArg = nextPosArg;
+            curPosArg = static_cast<std::size_t>(nextPosArg);
         }
     }
 
     // Map positional params to the desired arguments
-    int curArg = startPosArg;
-    for (int idx = 0; idx < eatenPosArgs && curArg != -1; ++ idx, curArg = argsInfo[curArg].nextNotFound)
+    auto curArg = static_cast<int>(startPosArg);
+    for (std::size_t idx = 0; idx < eatenPosArgs && curArg != -1; ++ idx, curArg = argsInfo[curArg].nextNotFound)
     {
         result.args[argsInfo[curArg].info->name] = params.posParams[idx];
         argsInfo[curArg].state = Positional;
     }
 
     // Fill default arguments (if missing) and check for mandatory
-    for (int idx = 0; idx < argsInfo.size(); ++ idx)
+    for (std::size_t idx = 0; idx < argsInfo.size(); ++ idx)
     {
         auto& argInfo = argsInfo[idx];
         switch (argInfo.state)

src/filters.cpp

@@ -244,9 +244,9 @@ InternalValue DictSort::Filter(const InternalValue& baseVal, RenderContext& cont
 
     std::vector<KeyValuePair> tempVector;
     tempVector.reserve(map->GetSize());
-    for (int64_t idx = 0; idx < map->GetSize(); ++ idx)
+    for (std::size_t idx = 0; idx < map->GetSize(); ++ idx)
     {
-        auto val = map->GetValueByIndex(idx);
+        auto val = map->GetValueByIndex(static_cast<std::int64_t>(idx));
         auto kvVal = Get<KeyValuePair>(val);
         tempVector.push_back(std::move(kvVal));
     }
@@ -569,17 +569,6 @@ InternalValue SequenceAccessor::Filter(const InternalValue& baseVal, RenderConte
         return ConvertToBool(cmpRes);
     };
 
-    auto equalComparator = [&attrName, &compType](auto& val1, auto& val2) {
-        InternalValue cmpRes;
-
-        if (IsEmpty(attrName))
-            cmpRes = Apply2<visitors::BinaryMathOperation>(val1, val2, BinaryExpression::LogicalEq, compType);
-        else
-            cmpRes = Apply2<visitors::BinaryMathOperation>(Subscript(val1, attrName), Subscript(val2, attrName), BinaryExpression::LogicalEq, compType);
-
-        return ConvertToBool(cmpRes);
-    };
-
     switch (m_mode)
     {
     case FirstItemMode:
@@ -618,7 +607,7 @@ InternalValue SequenceAccessor::Filter(const InternalValue& baseVal, RenderConte
     case ReverseMode:
     {
         InternalValueList resultList(list.GetSize());
-        for (int n = 0; n < list.GetSize(); ++ n)
+        for (std::size_t n = 0; n < list.GetSize(); ++ n)
             resultList[list.GetSize() - n - 1] = list.GetValueByIndex(n);
 
         result = ListAdapter::CreateAdapter(std::move(resultList));
@@ -661,7 +650,7 @@ InternalValue SequenceAccessor::Filter(const InternalValue& baseVal, RenderConte
 
         int idx = 0;
         for (auto& v : list)
-            items.push_back(std::move(Item{IsEmpty(attrName) ? v : Subscript(v, attrName), idx ++}));
+            items.push_back(Item{IsEmpty(attrName) ? v : Subscript(v, attrName), idx ++});
 
         std::sort(items.begin(), items.end(), [&compType](auto& i1, auto& i2) {
             auto cmpRes = Apply2<visitors::BinaryMathOperation>(i1.val, i2.val, BinaryExpression::LogicalLt, compType);
@@ -676,7 +665,7 @@ InternalValue SequenceAccessor::Filter(const InternalValue& baseVal, RenderConte
         });
         items.erase(end, items.end());
 
-        std::sort(items.begin(), items.end(), [&compType](auto& i1, auto& i2) {
+        std::sort(items.begin(), items.end(), [](auto& i1, auto& i2) {
             return i1.idx < i2.idx;
         });
 
@@ -830,7 +819,7 @@ struct ValueConverterImpl : visitors::BaseVisitor<>
             result = InternalValue(static_cast<double>(val));
             break;
         case ValueConverter::AbsMode:
-            result = InternalValue(static_cast<int64_t>(abs(val)));
+            result = InternalValue(static_cast<int64_t>(std::abs(val)));
             break;
         case ValueConverter::ToIntMode:
         case ValueConverter::RoundMode:

src/internal_value.h

@@ -294,7 +294,7 @@ class ListAdapter::Iterator
     void increment()
     {
         ++ m_current;
-        m_currentVal = m_current == m_list->GetSize() ? InternalValue() : m_list->GetValueByIndex(m_current);
+        m_currentVal = m_current == static_cast<int64_t>(m_list->GetSize()) ? InternalValue() : m_list->GetValueByIndex(m_current);
     }
 
     bool equal(const Iterator& other) const
@@ -303,7 +303,7 @@ class ListAdapter::Iterator
             return other.m_list == nullptr ? true : other.equal(*this);
 
         if (other.m_list == nullptr)
-            return m_current == m_list->GetSize();
+            return m_current == static_cast<int64_t>(m_list->GetSize());
 
         return this->m_list == other.m_list && this->m_current == other.m_current;
     }