init

Telegram/lib_crl/crl/common/crl_common_object_async.h

@@ -0,0 +1,474 @@
+// This file is part of Desktop App Toolkit,
+// a set of libraries for developing nice desktop applications.
+//
+// For license and copyright information please follow this link:
+// https://github.com/desktop-app/legal/blob/master/LEGAL
+//
+#pragma once
+
+#include <crl/common/crl_common_config.h>
+#include <crl/crl_on_main.h>
+#include <crl/crl_semaphore.h>
+#include <memory>
+#include <tuple>
+
+#ifdef CRL_ENABLE_RPL_INTEGRATION
+#include <rpl/producer.h>
+#endif // CRL_ENABLE_RPL_INTEGRATION
+
+namespace crl::details {
+
+template <typename Policy>
+class object_async_base
+	: public std::enable_shared_from_this<object_async_base<Policy>>
+	, private Policy {
+public:
+	template <
+		typename Value,
+		typename = std::enable_if_t<!std::is_reference_v<Value>>>
+	void destroy(Value &&value) const;
+
+protected:
+	template <typename Callable>
+	void async(Callable &&callable) const;
+
+	template <typename Callable>
+	void sync(Callable &&callable) const;
+
+	~object_async_base() = default;
+
+};
+
+template <typename Type>
+class object_async_storage {
+protected:
+	Type &value();
+	const Type &value() const;
+
+	~object_async_storage();
+
+private:
+	std::aligned_storage_t<sizeof(Type), alignof(Type)> _storage;
+
+};
+
+template <typename Policy, typename Type>
+class object_async_data final
+	: private object_async_storage<Type>
+	, public object_async_base<Policy> {
+public:
+	using Object = Type;
+
+	template <typename ...Args>
+	void construct(Args &&...args);
+
+	template <typename Method>
+	void with(Method &&method);
+
+	template <typename Method>
+	void with(Method &&method) const;
+
+	template <typename Method>
+	void with_sync(Method &&method);
+
+	template <typename Method>
+	void with_sync(Method &&method) const;
+
+};
+
+template <typename Policy, typename Type>
+class weak_async final {
+	using data = details::object_async_data<
+		Policy,
+		std::remove_const_t<Type>>;
+	using my_data = std::conditional_t<
+		std::is_const_v<Type>,
+		const data,
+		data>;
+
+public:
+	weak_async() = default;
+	weak_async(const std::shared_ptr<data> &strong);
+	weak_async(const weak_async &other) = default;
+	weak_async(weak_async &&other) = default;
+	weak_async &operator=(const weak_async &other) = default;
+	weak_async &operator=(weak_async &&other) = default;
+
+	template <typename Method>
+	void with(Method &&method) const;
+
+	template <typename Method>
+	void with_sync(Method &&method) const;
+
+	template <
+		typename Value,
+		typename = std::enable_if_t<!std::is_reference_v<Value>>>
+	void destroy(Value &&value) const;
+
+	// Returns a lambda that runs arbitrary callable on the objects queue.
+	// const auto r = runner(); r([] { make_some_work_on_queue(); });
+	auto runner() const {
+		return [weak = *this](auto &&method) {
+			weak.with([
+				method = std::forward<decltype(method)>(method)
+			](Type&) mutable {
+				std::move(method)();
+			});
+		};
+	}
+
+#ifdef CRL_ENABLE_RPL_INTEGRATION
+	template <
+		typename Method,
+		typename Invoke,
+		typename Result = decltype(
+			std::declval<Method>()(std::declval<Type&>()))>
+	Result producer(Method &&method, Invoke &&invoke) const;
+
+	template <
+		typename Method,
+		typename Result = decltype(
+			std::declval<Method>()(std::declval<Type&>()))>
+	Result producer_on_main(Method &&method) const;
+#endif // CRL_ENABLE_RPL_INTEGRATION
+
+private:
+	std::weak_ptr<my_data> _weak;
+
+};
+
+template <typename Policy, typename Type>
+class object_async final {
+public:
+	template <typename ...Args>
+	object_async(Args &&...args);
+
+	object_async(const object_async &other) = delete;
+	object_async &operator=(const object_async &other) = delete;
+
+	template <typename Method>
+	void with(Method &&method);
+
+	template <typename Method>
+	void with(Method &&method) const;
+
+	template <typename Method>
+	void with_sync(Method &&method);
+
+	template <typename Method>
+	void with_sync(Method &&method) const;
+
+	template <
+		typename Value,
+		typename = std::enable_if_t<!std::is_reference_v<Value>>>
+	void destroy(Value &&value) const;
+
+#ifdef CRL_ENABLE_RPL_INTEGRATION
+	template <
+		typename Method,
+		typename Invoke,
+		typename Result = decltype(
+			std::declval<Method>()(std::declval<Type&>()))>
+	Result producer(Method &&method, Invoke &&invoke) const;
+
+	template <
+		typename Method,
+		typename Result = decltype(
+			std::declval<Method>()(std::declval<Type&>()))>
+	Result producer_on_main(Method &&method) const;
+#endif // CRL_ENABLE_RPL_INTEGRATION
+
+	weak_async<Policy, Type> weak();
+	weak_async<Policy, const Type> weak() const;
+
+	~object_async();
+
+private:
+	using Data = details::object_async_data<Policy, Type>;
+	std::shared_ptr<Data> _data;
+
+};
+
+template <typename Policy>
+template <typename Callable>
+void object_async_base<Policy>::async(Callable &&callable) const {
+	Policy::async_plain([
+		that = this->shared_from_this(),
+		what = std::forward<Callable>(callable)
+	]() mutable {
+		std::move(what)();
+	});
+}
+
+template <typename Policy>
+template <typename Callable>
+void object_async_base<Policy>::sync(Callable &&callable) const {
+	semaphore waiter;
+	Policy::async_plain([&] {
+		const auto guard = details::finally([&] { waiter.release(); });
+		callable();
+	});
+	waiter.acquire();
+}
+
+template <typename Policy>
+template <typename Value, typename>
+void object_async_base<Policy>::destroy(Value &&value) const {
+	Policy::async_plain([moved = std::move(value)]{});
+}
+
+template <typename Type>
+Type &object_async_storage<Type>::value() {
+	return *reinterpret_cast<Type*>(&_storage);
+}
+
+template <typename Type>
+const Type &object_async_storage<Type>::value() const {
+	return *reinterpret_cast<const Type*>(&_storage);
+}
+
+template <typename Type>
+object_async_storage<Type>::~object_async_storage() {
+	value().~Type();
+}
+
+template <typename Policy, typename Type>
+template <typename ...Args>
+void object_async_data<Policy, Type>::construct(Args &&...args) {
+	object_async_base<Policy>::async([arguments = std::make_tuple(
+		&object_async_storage<Type>::value(),
+		std::forward<Args>(args)...
+	)]() mutable {
+		const auto create = [](void *storage, Args &&...args) {
+			new (storage) Type(std::forward<Args>(args)...);
+		};
+		std::apply(create, std::move(arguments));
+	});
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void object_async_data<Policy, Type>::with(Method &&method) {
+	object_async_base<Policy>::async([
+		=,
+		method = std::forward<Method>(method)
+	]() mutable {
+		std::move(method)(object_async_storage<Type>::value());
+	});
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void object_async_data<Policy, Type>::with(Method &&method) const {
+	object_async_base<Policy>::async([
+		=,
+		method = std::forward<Method>(method)
+	]() mutable {
+		std::move(method)(object_async_storage<Type>::value());
+	});
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void object_async_data<Policy, Type>::with_sync(Method &&method) {
+	object_async_base<Policy>::sync([
+		=,
+		method = std::forward<Method>(method)
+	]() mutable {
+		std::move(method)(object_async_storage<Type>::value());
+	});
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void object_async_data<Policy, Type>::with_sync(Method &&method) const {
+	object_async_base<Policy>::sync([
+		=,
+		method = std::forward<Method>(method)
+	]() mutable {
+		std::move(method)(object_async_storage<Type>::value());
+	});
+}
+
+template <typename Policy, typename Type>
+weak_async<Policy, Type>::weak_async(const std::shared_ptr<data> &strong)
+: _weak(strong) {
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void weak_async<Policy, Type>::with(Method &&method) const {
+	if (auto strong = _weak.lock()) {
+		const auto raw = strong.get();
+		raw->with(std::move(method));
+		raw->destroy(std::move(strong));
+	}
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void weak_async<Policy, Type>::with_sync(Method &&method) const {
+	if (auto strong = _weak.lock()) {
+		const auto raw = strong.get();
+		raw->with_sync(std::move(method));
+		raw->destroy(std::move(strong));
+	}
+}
+
+template <typename Policy, typename Type>
+template <typename Value, typename>
+void weak_async<Policy, Type>::destroy(Value &&value) const {
+	if (auto strong = _weak.lock()) {
+		const auto raw = strong.get();
+		raw->destroy(std::move(value));
+		raw->destroy(std::move(strong));
+	} else {
+		[[maybe_unused]] const auto moved = std::move(value);
+	}
+}
+
+#ifdef CRL_ENABLE_RPL_INTEGRATION
+template <typename Policy, typename Type>
+template <typename Method, typename Invoke, typename Result>
+Result weak_async<Policy, Type>::producer(
+		Method &&method,
+		Invoke &&invoke) const {
+	return [
+		weak = *this,
+		method = std::forward<Method>(method),
+		invoke = std::forward<Invoke>(invoke)
+	](auto consumer) mutable {
+		auto lifetime_on_queue = std::make_shared<rpl::lifetime>();
+		weak.with([
+			method = std::move(method),
+			invoke = std::move(invoke),
+			consumer = std::move(consumer),
+			lifetime_on_queue
+		](const Type &that) mutable {
+			method(
+				that
+			) | rpl::on_next_error_done([=](auto &&value) {
+				invoke([
+					consumer,
+					value = std::forward<decltype(value)>(value)
+				]() mutable {
+					consumer.put_next(std::move(value));
+				});
+			}, [=](auto &&error) {
+				invoke([
+					consumer,
+					error = std::forward<decltype(error)>(error)
+				]() mutable {
+					consumer.put_error(std::move(error));
+				});
+			}, [=] {
+				invoke([=] {
+					consumer.put_done();
+				});
+			}, *lifetime_on_queue);
+		});
+		return rpl::lifetime([
+			lifetime_on_queue = std::move(lifetime_on_queue),
+			weak = std::move(weak)
+		]() mutable {
+			weak.destroy(std::move(lifetime_on_queue));
+		});
+	};
+}
+
+template <typename Policy, typename Type>
+template <typename Method, typename Result>
+Result weak_async<Policy, Type>::producer_on_main(Method &&method) const {
+	return producer(std::forward<Method>(method), [](auto &&callback) {
+		crl::on_main(std::forward<decltype(callback)>(callback));
+	});
+}
+#endif // CRL_ENABLE_RPL_INTEGRATION
+
+template <typename Policy, typename Type>
+template <typename ...Args>
+object_async<Policy, Type>::object_async(Args &&...args)
+: _data(std::make_shared<Data>()) {
+	constexpr auto plain_construct = std::is_constructible_v<
+		Type,
+		Args...>;
+	[[maybe_unused]] constexpr auto with_weak_construct = std::is_constructible_v<
+		Type,
+		weak_async<Policy, Type>,
+		Args...>;
+	if constexpr (plain_construct) {
+		_data->construct(std::forward<Args>(args)...);
+	} else if constexpr (with_weak_construct) {
+		_data->construct(weak(), std::forward<Args>(args)...);
+	} else {
+		static_assert(false_t(args...), "Could not find a constructor.");
+	}
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void object_async<Policy, Type>::with(Method &&method) {
+	_data->with(std::forward<Method>(method));
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void object_async<Policy, Type>::with(Method &&method) const {
+	const auto data = static_cast<const Data*>(_data.get());
+	data->with(std::forward<Method>(method));
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void object_async<Policy, Type>::with_sync(Method &&method) {
+	_data->with_sync(std::forward<Method>(method));
+}
+
+template <typename Policy, typename Type>
+template <typename Method>
+void object_async<Policy, Type>::with_sync(Method &&method) const {
+	const auto data = static_cast<const Data*>(_data.get());
+	data->with_sync(std::forward<Method>(method));
+}
+
+template <typename Policy, typename Type>
+template <typename Value, typename>
+void object_async<Policy, Type>::destroy(Value &&value) const {
+	_data->destroy(std::move(value));
+}
+
+#ifdef CRL_ENABLE_RPL_INTEGRATION
+template <typename Policy, typename Type>
+template <typename Method, typename Callback, typename Result>
+Result object_async<Policy, Type>::producer(
+		Method &&method,
+		Callback &&callback) const {
+	return weak().producer(
+		std::forward<Method>(method),
+		std::forward<Callback>(callback));
+}
+
+template <typename Policy, typename Type>
+template <typename Method, typename Result>
+Result object_async<Policy, Type>::producer_on_main(Method &&method) const {
+	return weak().producer_on_main(std::forward<Method>(method));
+}
+#endif // CRL_ENABLE_RPL_INTEGRATION
+
+template <typename Policy, typename Type>
+auto object_async<Policy, Type>::weak() -> weak_async<Policy, Type> {
+	return { _data };
+}
+
+template <typename Policy, typename Type>
+auto object_async<Policy, Type>::weak() const
+-> weak_async<Policy, const Type> {
+	return { _data };
+}
+
+template <typename Policy, typename Type>
+object_async<Policy, Type>::~object_async() {
+	_data->destroy(std::move(_data));
+}
+
+} // namespace crl::details