events_handler nodiscard fixed, hash changed

Author: MAIPA01

include/events/mstd/event_handler.hpp

@@ -32,15 +32,15 @@ namespace mstd {
 #else
 		template<class F, std::enable_if_t<mstd::is_same_function_v<F, event_action_type>, bool> = true>
 #endif
-		[[nodiscard]] constexpr id_type add_callback(const F& callback) {
+		constexpr id_type add_callback(const F& callback) {
 			id_type id = _ids.get_next_id();
 			if (id == id_manager_type::bad_id()) return id;
 
 			_events[id] = callback;
 			return id;
 		}
 
-		[[nodiscard]] constexpr bool remove_callback(const id_type& callbackId) {
+		constexpr bool remove_callback(const id_type& callbackId) {
 			auto itr = _events.find(callbackId);
 			if (itr == _events.end()) {
 				return false;
@@ -66,11 +66,11 @@ namespace mstd {
 #else
 		template<class F, std::enable_if_t<mstd::is_same_function_v<F, event_action_type>, bool> = true>
 #endif
-		[[nodiscard]] constexpr id_type operator+=(const F& callback) {
+		constexpr id_type operator+=(const F& callback) {
 			return add_callback(callback);
 		}
 
-		[[nodiscard]] constexpr bool operator-=(id_type callbackId) {
+		constexpr bool operator-=(id_type callbackId) {
 			return remove_callback(callbackId);
 		}
 

include/utils/mstd/hash.hpp

@@ -11,21 +11,26 @@
 #include "utils_libs.hpp"
 
 namespace mstd {
-	template<class T>
-	void hash_combine(size_t& seed, const T& value) {
-		seed ^= std::hash<T>()(value) + 0x9e3779b9
-			+ (seed << 6) + (seed >> 2);
+	template<class T, class... Ts>
+	void hash_append(size_t& hash_value, const T& value, const Ts&... values) {
+		hash_value ^= std::hash<T>()(value) + 0x9e3779b9 + (hash_value << 6) + (hash_value >> 2);
+
+		if constexpr (sizeof...(Ts) != 0) {
+			hash_append(hash_value, values...);
+		}
 	}
 
-	template<class... Ts>
-	void hash_combine(size_t& seed, const Ts&... values) {
-		(hash_combine(seed, values), ...);
+	template<class T0, class T1, class... Ts>
+	size_t hash_combine(const T0& value0, const T1& value1, const Ts&... values) {
+		size_t hash_value = 0;
+		hash_append(hash_value, value0, value1, values...);
+		return hash_value;
 	}
 
 	template<class Iter>
-	void hash_combine(size_t& seed, const Iter& begin, const Iter& end) {
-		for (const Iter& i = begin; i != end; ++i) {
-			hash_combine(seed, *i);
+	void hash_range(size_t& seed, const Iter& begin, const Iter& end) {
+		for (Iter i = begin; i != end; ++i) {
+			hash_append(seed, *i);
 		}
 	}
 }