feat(options): Add strict option to return false if reaching the end of input early

include/alpaca/detail/from_bytes.h

@@ -83,8 +83,13 @@ from_bytes(T &value, Container &bytes, std::size_t &current_index,
     // default initialize the value
     value = T();
 
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   if constexpr (std::is_same_v<T, uint8_t> || std::is_same_v<T, int8_t>) {
@@ -136,8 +141,13 @@ from_bytes(T &value, Container &bytes, std::size_t &current_index,
     // default initialize the value
     value = T();
 
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   if constexpr (std::is_same_v<T, uint8_t> || std::is_same_v<T, int8_t>) {
@@ -189,8 +199,13 @@ from_bytes(T &value, Container &bytes, std::size_t &current_index,
     // default initialize the value
     value = T();
 
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   if constexpr (std::is_same_v<T, uint8_t> || std::is_same_v<T, int8_t>) {
@@ -232,16 +247,21 @@ typename std::enable_if<
          std::is_same_v<T, std::size_t>),
     bool>::type
 from_bytes(T &value, Container &bytes, std::size_t &current_index,
-           std::size_t &end_index, std::error_code &) {
+           std::size_t &end_index, std::error_code &error_code) {
 
   if (current_index >= end_index) {
     // end of input
 
     // default initialize the value
     value = T();
 
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   constexpr auto use_fixed_length_encoding = (
@@ -281,16 +301,21 @@ typename std::enable_if<
          std::is_same_v<T, std::size_t>),
     bool>::type
 from_bytes(T &value, Container &bytes, std::size_t &current_index,
-           std::size_t &end_index, std::error_code &) {
+           std::size_t &end_index, std::error_code &error_code) {
 
   if (current_index >= end_index) {
     // end of input
 
     // default initialize the value
     value = T();
 
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   constexpr auto use_fixed_length_encoding = (
@@ -330,16 +355,21 @@ typename std::enable_if<
          std::is_same_v<T, std::size_t>),
     bool>::type
 from_bytes(T &value, Container &bytes, std::size_t &current_index,
-           std::size_t &end_index, std::error_code &) {
+           std::size_t &end_index, std::error_code &error_code) {
 
   if (current_index >= end_index) {
     // end of input
 
     // default initialize the value
     value = T();
 
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   constexpr auto use_fixed_length_encoding = (
@@ -382,8 +412,13 @@ from_bytes(T &value, Container &bytes, std::size_t &current_index,
     // default initialize the value
     value = T();
 
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   using underlying_type = typename std::underlying_type<T>::type;
@@ -396,4 +431,4 @@ from_bytes(T &value, Container &bytes, std::size_t &current_index,
 
 } // namespace detail
 
-} // namespace alpaca
+} // namespace alpaca

include/alpaca/detail/options.h

@@ -10,6 +10,7 @@ enum class options {
   with_version = 4,
   with_checksum = 8,
   force_aligned_access = 16,
+  strict = 32,
 };
 
 template <typename E> struct enable_bitmask_operators {
@@ -58,10 +59,14 @@ template <options O> constexpr bool force_aligned_access() {
   return enum_has_flag<options, O, options::force_aligned_access>();
 }
 
+template <options O> constexpr bool strict() {
+  return enum_has_flag<options, O, options::strict>();
+}
+
 } // namespace detail
 
 template <> struct enable_bitmask_operators<options> {
   static constexpr bool enable = true;
 };
 
-} // namespace alpaca
+} // namespace alpaca

include/alpaca/detail/types/array.h

@@ -66,8 +66,13 @@ bool from_bytes(std::array<U, N> &output, Container &bytes,
 
   if (byte_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   from_bytes_to_array<O>(output, bytes, byte_index, end_index, error_code);
@@ -77,4 +82,4 @@ bool from_bytes(std::array<U, N> &output, Container &bytes,
 } // namespace detail
 
 } // namespace alpaca
-#endif
+#endif

include/alpaca/detail/types/bitset.h

@@ -58,8 +58,13 @@ bool from_bytes_to_bitset(std::bitset<N> &value, Container &bytes,
 
   if (current_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   // current byte is the size of the vector

include/alpaca/detail/types/deque.h

@@ -52,8 +52,13 @@ bool from_bytes_to_deque(std::deque<T> &value, Container &bytes,
 
   if (current_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   // current byte is the size of the vector
@@ -94,4 +99,4 @@ bool from_bytes(std::deque<T> &output, Container &bytes,
 } // namespace detail
 
 } // namespace alpaca
-#endif
+#endif

include/alpaca/detail/types/duration.h

@@ -44,8 +44,13 @@ bool from_bytes(std::chrono::duration<Rep, Period> &output, Container &bytes,
 
   if (byte_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   Rep count{0};
@@ -62,4 +67,4 @@ bool from_bytes(std::chrono::duration<Rep, Period> &output, Container &bytes,
 } // namespace detail
 
 } // namespace alpaca
-#endif
+#endif

include/alpaca/detail/types/filesystem_path.h

@@ -41,8 +41,13 @@ bool from_bytes(std::filesystem::path &value, Container &bytes,
 
   if (current_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   // current byte is the length of the string

include/alpaca/detail/types/list.h

@@ -52,8 +52,13 @@ bool from_bytes_to_list(std::list<T> &value, Container &bytes,
 
   if (current_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   // current byte is the size of the vector
@@ -93,4 +98,4 @@ bool from_bytes(std::list<T> &output, Container &bytes, std::size_t &byte_index,
 } // namespace detail
 
 } // namespace alpaca
-#endif
+#endif

include/alpaca/detail/types/map.h

@@ -116,8 +116,13 @@ bool from_bytes(std::map<K, V> &output, Container &bytes,
 
   if (byte_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   from_bytes_to_map<O>(output, bytes, byte_index, end_index, error_code);
@@ -133,8 +138,13 @@ bool from_bytes(std::unordered_map<K, V> &output, Container &bytes,
 
   if (byte_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   from_bytes_to_map<O>(output, bytes, byte_index, end_index, error_code);
@@ -144,4 +154,4 @@ bool from_bytes(std::unordered_map<K, V> &output, Container &bytes,
 
 } // namespace detail
 
-} // namespace alpaca
+} // namespace alpaca

include/alpaca/detail/types/optional.h

@@ -47,8 +47,13 @@ bool from_bytes(std::optional<T> &output, Container &bytes,
 
   if (byte_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   auto current_byte = bytes[byte_index];
@@ -78,4 +83,4 @@ bool from_bytes(std::optional<T> &output, Container &bytes,
 } // namespace detail
 
 } // namespace alpaca
-#endif
+#endif

include/alpaca/detail/types/pair.h

@@ -44,8 +44,13 @@ bool from_bytes(std::pair<T, U> &output, Container &bytes,
 
   if (byte_index >= end_index) {
     // end of input
-    // return true for forward compatibility
-    return true;
+    // return true for forward compatibility, unless strict mode is enabled
+    if constexpr (detail::strict<O>()) {
+      error_code = std::make_error_code(std::errc::bad_message);
+      return false;
+    } else {
+      return true;
+    }
   }
 
   from_bytes_router<O>(output.first, bytes, byte_index, end_index, error_code);
@@ -57,4 +62,4 @@ bool from_bytes(std::pair<T, U> &output, Container &bytes,
 } // namespace detail
 
 } // namespace alpaca
-#endif
+#endif