Draft: Implementation of network handler

include/FlameIDE/CMakeLists.txt

@@ -8,6 +8,7 @@ set(HEADER_MODULES
 	${FLAME_INCLUDE_SUBMODLUES_PATH}/Common
 	${FLAME_INCLUDE_SUBMODLUES_PATH}/Constants
 	${FLAME_INCLUDE_SUBMODLUES_PATH}/Crypto
+	${FLAME_INCLUDE_SUBMODLUES_PATH}/Handler
 	${FLAME_INCLUDE_SUBMODLUES_PATH}/Os
 	${FLAME_INCLUDE_SUBMODLUES_PATH}/Others
 	# ${FLAME_INCLUDE_SUBMODLUES_PATH}/Streams

include/FlameIDE/Common/Expected.hpp

@@ -36,11 +36,17 @@ class Expected
 	template<typename Functor>
 	const Me &ifResult(Functor &&functor) const noexcept;
 
+	template<typename Functor>
+	Me &ifResultGet(Functor &&functor) noexcept;
+
 	template<typename Functor>
 	Me &ifError(Functor &&functor) noexcept;
 	template<typename Functor>
 	const Me &ifError(Functor &&functor) const noexcept;
 
+	template<typename Functor>
+	Me &ifErrorGet(Functor &&functor) noexcept;
+
 	void done() noexcept;
 	void done() const noexcept;
 
@@ -146,10 +152,10 @@ Expected<ResultType, ErrorType>::operator=(Me &&expected) noexcept
 {
 	expected.ifResult([this](ResultType &&result)
 			{
-				operator=(move(result));
+				this->operator=(move(result));
 			}).ifError([this](ErrorType &&error)
 					{
-						operator=(move(error));
+						this->operator=(move(error));
 					}).done();
 	return *this;
 }
@@ -221,6 +227,19 @@ Expected<ResultType, ErrorType>::ifResult(Functor &&functor) const noexcept
 	return *this;
 }
 
+template<typename ResultType, typename ErrorType>
+template<typename Functor>
+Expected<ResultType, ErrorType> &
+Expected<ResultType, ErrorType>::ifResultGet(Functor &&functor) noexcept
+{
+	if (State::RESULT != data.state)
+		return *this;
+
+	functor(data.result.value);
+
+	return *this;
+}
+
 template<typename ResultType, typename ErrorType>
 template<typename Functor>
 Expected<ResultType, ErrorType> &
@@ -248,6 +267,19 @@ Expected<ResultType, ErrorType>::ifError(Functor &&functor) const noexcept
 	return *this;
 }
 
+template<typename ResultType, typename ErrorType>
+template<typename Functor>
+Expected<ResultType, ErrorType> &
+Expected<ResultType, ErrorType>::ifErrorGet(Functor &&functor) noexcept
+{
+	if (State::ERROR != data.state)
+		return *this;
+
+	functor(data.error.value);
+
+	return *this;
+}
+
 template<typename ResultType, typename ErrorType>
 inline void Expected<ResultType, ErrorType>::done() noexcept
 {}

include/FlameIDE/Common/PrimitiveTypes.hpp

@@ -23,7 +23,6 @@ using long_t = ::int64_t;
 using float_t = float;
 using double_t = double;
 using ldouble_t = long double;
-
 using ptrint_t = ::intptr_t;
 using ptruint_t = ::uintptr_t;
 

include/FlameIDE/Common/ReferenceWrapper.hpp

@@ -13,9 +13,13 @@ template<typename T, typename Traits = ContainerTraits<T>>
 class ReferenceWrapper
 {
 public:
+	using Me = ReferenceWrapper<T, Traits>;
 	using Pointer = typename Traits::Pointer;
 	using Reference = typename Traits::Reference;
 
+	ReferenceWrapper(const Me &) noexcept = default;
+	ReferenceWrapper(Me &&) noexcept = default;
+
 	///
 	/// @brief ReferenceWrapper
 	/// @param initValue
@@ -28,6 +32,9 @@ class ReferenceWrapper
 	///
 	ReferenceWrapper(Reference initValue) noexcept;
 
+	Me &operator=(const Me &) noexcept = default;
+	Me &operator=(Me &&) noexcept = default;
+
 	///
 	/// @brief get
 	/// @return

include/FlameIDE/Common/Traits/Functional.hpp

@@ -342,6 +342,44 @@ struct DoSomeByIndex<T, SIZE, SIZE>
 	{}
 };
 
+///
+/// @brief The TypeMappingTrait class
+/// @tparam T1
+/// @tparam T2
+///
+template<typename T1, typename T2>
+struct TypeMappingTrait
+{
+	using Type1 = T1;
+	using Type2 = T2;
+};
+
+///
+/// @brief The TypeMapper class
+/// @tparam T
+/// @tparam TypeMappingTrait
+/// @tparam ENABLE_STATIC_ASSERT
+///
+template<typename T, typename TypeMappingTrait, bool ENABLE_STATIC_ASSERT = true>
+struct TypeMapper
+{
+	using Type = typename ChooseType<
+		ComparingTypes<T, typename TypeMappingTrait::Type1>::VALUE
+		, typename TypeMappingTrait::Type2
+		, typename ChooseType<
+			ComparingTypes<T, typename TypeMappingTrait::Type2>::VALUE
+			, typename TypeMappingTrait::Type1
+			, Empty
+		>::Type
+	>::Type;
+
+	static_assert(
+			!ENABLE_STATIC_ASSERT
+					|| ComparingTypes<Type, Empty>::VALUE == FalseType::VALUE
+			, "Type does not include in chosen TypeMatchingTrait"
+	);
+};
+
 }
 
 #endif // FLAMEIDE_COMMON_TRAITS_FUCTIONAL_HPP

include/FlameIDE/Handler/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.14)
+
+set(SOURCE_MODULES
+	${CMAKE_CURRENT_LIST_DIR}/Network
+)
+foreach(module ${SOURCE_MODULES})
+	add_subdirectory(${module})
+endforeach()

include/FlameIDE/Handler/Network/CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.14)
+
+set(NAME "Handler.Network")
+set(NAME_ALIAS "Handler::Network")
+set(LIBRARY_ALIAS_NAME ${FLAME_NAMESPACE}::${NAME_ALIAS}::Headers)
+set(DEPENDENCY_LIST
+	${FLAME_NAMESPACE}::Common::Headers
+	${FLAME_NAMESPACE}::Os::Headers
+	${FLAME_NAMESPACE}::Templates::Headers
+)
+
+get_sources(FILE_LIST)
+flame_header_library(
+	NAME                   "${NAME}"
+	LIBRARY_ALIAS_NAME     "${LIBRARY_ALIAS_NAME}"
+	HEADER_LIST            "${FILE_LIST}"
+	DEPENDENCY_TARGET_LIST "${DEPENDENCY_LIST}"
+	INCLUDE_PATHS          "${FLAME_INCLUDE_PATH}"
+	INSTALL_SUBDIR         "${FLAME_NAMESPACE}/${NAME}"
+)