some cmake changes

.clang_complete

@@ -0,0 +1,2 @@
+-I
+velocypack/include

CMakeLists.txt

@@ -4,6 +4,7 @@ project(agency-node CXX C)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 add_subdirectory(velocypack)
 add_subdirectory(deserialize)

deserialize/CMakeLists.txt

@@ -1,8 +1,7 @@
-
+cmake_minimum_required(VERSION 3.15)
 project(vpack-deserializer CXX)
 
 add_library(deserializer-lib INTERFACE)
-
 target_include_directories(deserializer-lib INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
 
 add_subdirectory(test)

deserialize/conditional.h

@@ -122,7 +122,7 @@ template <std::size_t I, typename E>
 struct conditional_executor<I, E> {
   using R = typename E::variant_type;
   using unpack_result = result<R, deserialize_error>;
-  static auto unpack(::deserializer::slice_type s, ::deserializer::slice_type v)
+  static auto unpack(::deserializer::slice_type /*s*/, ::deserializer::slice_type v)
       -> unpack_result {
     using namespace std::string_literals;
     return unpack_result{deserialize_error{"unrecognized value `"s + v.toJson() + "`"}};
@@ -145,7 +145,7 @@ struct deserialize_plan_executor<conditional<CSs...>, H> {
   using variant_type = typename plan_result_tuple_type::variant;
   using unpack_result = result<unpack_tuple_type, deserialize_error>;
 
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints)
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/)
       -> unpack_result {
     /*
      * Select the sub deserializer depending on the value.

deserialize/errors.h

@@ -86,7 +86,7 @@ struct error {
   }
 
   operator std::string() const { return as_string(); }
-  [[nodiscard]] std::string as_string(bool detailed = false) const {
+  [[nodiscard]] std::string as_string(bool /*detailed*/ = false) const {
     using deserializer::detail::gadgets::visitor;
     std::string result;
     bool was_terminated = false;

deserialize/field-name-dependent.h

@@ -3,6 +3,7 @@
 #include "plan-executor.h"
 #include "types.h"
 #include "vpack-types.h"
+#include "deserialize-with.h"
 
 namespace deserializer {
 
@@ -51,7 +52,7 @@ struct field_name_dependent_executor<R, field_name_deserializer_pair<N, D>, fiel
 template <typename R>
 struct field_name_dependent_executor<R> {
   using unpack_result = result<R, deserialize_error>;
-  static auto unpack(::deserializer::slice_type s) -> unpack_result {
+  static auto unpack(::deserializer::slice_type /*s*/) -> unpack_result {
     using namespace std::string_literals;
     return unpack_result{deserialize_error{"format not recognized"}};
   }
@@ -74,7 +75,7 @@ struct deserialize_plan_executor<field_name_dependent<NDs...>, H> {
   using tuple_type = std::tuple<value_type>;
   using result_type = result<tuple_type, deserialize_error>;
 
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     return ::deserializer::detail::field_name_dependent_executor<variant_type, NDs...>::unpack(s)
         .visit(::deserializer::detail::gadgets::visitor{
             [](variant_type const& v) { return result_type{std::make_tuple(v)}; },

deserialize/field-value-dependent.h

@@ -112,7 +112,7 @@ struct deserialize_plan_executor<field_value_dependent<N, VSs...>, H> {
   using variant_type = typename plan_result_tuple_type::variant;
   using unpack_result = result<unpack_tuple_type, deserialize_error>;
   constexpr static auto name = N;
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints)
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/)
       -> unpack_result {
     /*
      * Select the sub deserializer depending on the value.
@@ -135,7 +135,7 @@ struct deserialize_plan_executor<field_value_dependent<N, VSs...>, H> {
 
 template <const char N[], typename H>
 struct deserialize_plan_executor<field_value_dependent<N>, H> {
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) {
+  static auto unpack(::deserializer::slice_type /*s*/, typename H::state_type /*hints*/) {
     /*
      * No matching type was found, we can not deserialize.
      */

deserialize/fixed-order.h

@@ -77,7 +77,7 @@ struct deserialize_plan_executor<fixed_order_deserializer<Ds...>, H> {
 
   constexpr static auto expected_array_length = sizeof...(Ds);
 
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     using namespace std::string_literals;
 
     if (!s.isArray()) {

deserialize/gadgets.h

@@ -2,6 +2,7 @@
 #define VELOCYPACK_GADGETS_H
 #include <cstddef>
 #include <tuple>
+#include <optional>
 
 namespace deserializer::detail::gadgets {
 namespace detail {

deserialize/map.h

@@ -1,8 +1,7 @@
 #ifndef VELOCYPACK_MAP_H
 #define VELOCYPACK_MAP_H
-#include "plan-executor.h"
-#include "utilities.h"
-#include "vpack-types.h"
+#include "deserialize-with.h"
+#include "value-reader.h"
 
 namespace deserializer {
 
@@ -40,7 +39,7 @@ struct deserialize_plan_executor<map_deserializer<D, C, K, F>, H> {
   using proxy_type = typename map_deserializer<D, C, K, F>::constructed_type;
   using tuple_type = std::tuple<proxy_type>;
   using result_type = result<tuple_type, deserialize_error>;
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     proxy_type result;
     using namespace std::string_literals;
 

deserialize/parameter-list.h

@@ -96,7 +96,7 @@ struct parameter_executor<factory_simple_parameter<N, T, required, default_v>, H
   using result_type = result<std::pair<T, bool>, deserialize_error>;
   constexpr static bool has_value = true;
 
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) {
     using namespace std::string_literals;
 
     auto value_slice = s.get(N);
@@ -124,7 +124,7 @@ struct parameter_executor<factory_optional_parameter<N, T>, H> {
   using result_type = result<std::pair<value_type, bool>, deserialize_error>;
   constexpr static bool has_value = true;
 
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     using namespace std::string_literals;
 
     auto value_slice = s.get(N);
@@ -149,7 +149,7 @@ struct parameter_executor<factory_deserialized_parameter<N, D, required>, H> {
   using result_type = result<std::pair<value_type, bool>, deserialize_error>;
   constexpr static bool has_value = true;
 
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     using namespace std::string_literals;
 
     auto value_slice = s.get(N);
@@ -178,7 +178,7 @@ struct parameter_executor<factory_slice_parameter<N, required>, H> {
   using result_type = result<std::pair<value_type, bool>, deserialize_error>;
   constexpr static bool has_value = true;
 
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     auto value_slice = s.get(N);
     if (!value_slice.isNone()) {
       return result_type{std::make_pair(value_slice, true)};
@@ -201,17 +201,17 @@ struct parameter_executor<expected_value<N, V>, H> {
   using result_type = result<std::pair<unit_type, bool>, deserialize_error>;
   constexpr static bool has_value = false;
 
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     values::ensure_value_comparator<V>{};
     if constexpr (!hints::hint_list_contains_v<hints::has_field_with_value<N, V>, H>) {
       auto value_slice = s.get(N);
       if (!values::value_comparator<V>::compare(value_slice)) {
         using namespace std::string_literals;
 
-        return result_type{std::move(deserialize_error{
+        return result_type{deserialize_error{
             "value at `"s + N + "` not as expected, found: `" +
             value_slice.toJson() + "`, expected: `" + to_string(V{}) + "`"}
-                                         .trace(N))};
+                                         .trace(N)};
       }
     }
 
@@ -269,7 +269,7 @@ struct parameter_list_executor<I, K, parameter_list<>, H> {
   using unpack_result = result<unit_type, deserialize_error>;
 
   template <typename T>
-  static auto unpack(T& t, ::deserializer::slice_type s, typename H::state_type hints)
+  static auto unpack(T& /*t*/, ::deserializer::slice_type s, typename H::state_type /*hints*/)
       -> unpack_result {
     if (s.length() != K) {
       return unpack_result{deserialize_error{

deserialize/plan-executor.h

@@ -1,6 +1,8 @@
 #ifndef VELOCYPACK_PLAN_EXECUTOR_H
 #define VELOCYPACK_PLAN_EXECUTOR_H
 
+#include <tuple>
+
 namespace deserializer::executor {
 
 /*

deserialize/test/CMakeLists.txt

@@ -1,6 +1,13 @@
 add_executable(deserializer-test test.cpp)
 
-target_link_libraries(deserializer-test deserializer-lib)
-target_link_libraries(deserializer-test velocypack)
+# why is there no error without this check in case
+# the velocypack target is not defined.
+if(NOT TARGET velocypack)
+    message(FATAL_ERROR "velocypack not found")
+endif()
 
+target_link_libraries(deserializer-test
+    deserializer-lib
+    velocypack
+)
 target_compile_options(deserializer-test PRIVATE "-ftemplate-backtrace-limit=0")

deserialize/try-alternatives.h

@@ -1,6 +1,7 @@
 #ifndef VELOCYPACK_TRY_ALTERNATIVES_H
 #define VELOCYPACK_TRY_ALTERNATIVES_H
 #include "utilities.h"
+#include "deserialize-with.h"
 
 namespace deserializer {
 namespace try_alternatives {
@@ -43,7 +44,7 @@ struct deserialize_plan_executor<try_alternatives::try_alternatives_deserializer
       typename try_alternatives::try_alternatives_deserializer<Ds...>::constructed_type;
   using tuple_type = std::tuple<value_type>;
   using result_type = result<tuple_type, deserialize_error>;
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     /*
      * Try one alternative after the other. Take the first that does not fail. If all fail, fail.
      */

deserialize/unpack-proxy.h

@@ -5,6 +5,10 @@
 #ifndef VELOCYPACK_UNPACK_PROXY_H
 #define VELOCYPACK_UNPACK_PROXY_H
 
+#include <memory>
+#include "deserialize-with.h"
+#include "utilities.h"
+
 namespace deserializer {
 template <typename D, typename P = D>
 struct unpack_proxy {

deserialize/utilities.h

@@ -1,5 +1,6 @@
 #ifndef VELOCYPACK_UTILITIES_H
 #define VELOCYPACK_UTILITIES_H
+#include <memory>
 #include "gadgets.h"
 
 namespace deserializer::utilities {

deserialize/values.h

@@ -126,7 +126,7 @@ struct deserialize_plan_executor<values::value_deserializer<T>, H> {
   using value_type = T;
   using tuple_type = std::tuple<value_type>;
   using result_type = result<tuple_type, deserialize_error>;
-  static auto unpack(::deserializer::slice_type s, typename H::state_type hints) -> result_type {
+  static auto unpack(::deserializer::slice_type s, typename H::state_type /*hints*/) -> result_type {
     ensure_value_reader<T>{};
     return value_reader<T>::read(s).map(
         [](T t) { return std::make_tuple(std::move(t)); });