init

Telegram/lib_crl/crl/dispatch/crl_dispatch_async.cpp

@@ -0,0 +1,45 @@
+// 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
+//
+#include <crl/dispatch/crl_dispatch_async.h>
+
+#ifdef CRL_USE_DISPATCH
+
+#include <dispatch/dispatch.h>
+
+namespace crl::details {
+
+void empty_main_wrapper(void (*callable)(void*), void *argument) {
+	callable(argument);
+}
+
+main_queue_wrapper _main_wrapper = &empty_main_wrapper;
+
+void *background_queue_dispatch() {
+	return dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+}
+
+void *main_queue_dispatch() {
+	return dispatch_get_main_queue();
+}
+
+void on_queue_async(void *queue, void (*callable)(void*), void *argument) {
+	dispatch_async_f(
+		static_cast<dispatch_queue_t>(queue),
+		argument,
+		callable);
+}
+
+void on_queue_sync(void *queue, void (*callable)(void*), void *argument) {
+	dispatch_sync_f(
+		static_cast<dispatch_queue_t>(queue),
+		argument,
+		callable);
+}
+
+} // namespace crl::details
+
+#endif // CRL_USE_DISPATCH

Telegram/lib_crl/crl/dispatch/crl_dispatch_async.h

@@ -0,0 +1,93 @@
+// 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>
+
+#ifdef CRL_USE_DISPATCH
+
+#include <crl/common/crl_common_utils.h>
+#include <type_traits>
+
+namespace crl::details {
+
+void *background_queue_dispatch();
+void *main_queue_dispatch();
+
+void on_queue_async(void *queue, void (*callable)(void*), void *argument);
+void on_queue_sync(void *queue, void (*callable)(void*), void *argument);
+
+template <
+	typename Wrapper,
+	typename Invoker,
+	typename Callable,
+	typename Return = decltype(std::declval<Callable>()())>
+inline void on_queue_invoke(
+		void *queue,
+		Invoker invoker,
+		Callable &&callable) {
+	using Function = std::decay_t<Callable>;
+
+	if constexpr (details::is_plain_function_v<Function, Return>) {
+		using Plain = Return(*)();
+		static_assert(sizeof(Plain) <= sizeof(void*));
+		const auto copy = static_cast<Plain>(callable);
+		invoker(queue, [](void *passed) {
+			Wrapper::Invoke([](void *passed) {
+				const auto callable = reinterpret_cast<Plain>(passed);
+				(*callable)();
+			}, passed);
+		}, reinterpret_cast<void*>(copy));
+	} else {
+		const auto copy = new Function(std::forward<Callable>(callable));
+		invoker(queue, [](void *passed) {
+			Wrapper::Invoke([](void *passed) {
+				const auto callable = static_cast<Function*>(passed);
+				const auto guard = details::finally([=] { delete callable; });
+				(*callable)();
+			}, passed);
+		}, static_cast<void*>(copy));
+	}
+}
+
+struct EmptyWrapper {
+	template <typename Callable>
+	static inline void Invoke(Callable &&callable, void *argument) {
+		callable(argument);
+	}
+};
+
+inline void async_plain(void (*callable)(void*), void *argument) {
+	return on_queue_async(
+		background_queue_dispatch(),
+		callable,
+		argument);
+}
+
+} // namespace crl::details
+
+namespace crl {
+
+template <typename Callable>
+inline void async(Callable &&callable) {
+	return details::on_queue_invoke<details::EmptyWrapper>(
+		details::background_queue_dispatch(),
+		details::on_queue_async,
+		std::forward<Callable>(callable));
+}
+
+template <typename Callable>
+inline void sync(Callable &&callable) {
+	return details::on_queue_invoke<details::EmptyWrapper>(
+		details::background_queue_dispatch(),
+		details::on_queue_sync,
+		std::forward<Callable>(callable));
+}
+
+} // namespace crl
+
+#endif // CRL_USE_DISPATCH

Telegram/lib_crl/crl/dispatch/crl_dispatch_on_main.h

@@ -0,0 +1,54 @@
+// 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>
+
+#if defined CRL_USE_DISPATCH && !defined CRL_FORCE_COMMON_QUEUE
+
+#include <crl/dispatch/crl_dispatch_async.h>
+#include <crl/common/crl_common_utils.h>
+
+namespace crl {
+namespace details {
+
+extern main_queue_wrapper _main_wrapper;
+
+struct MainQueueWrapper {
+	static inline void Invoke(void (*callable)(void*), void *argument) {
+		_main_wrapper(callable, argument);
+	}
+};
+
+} // namespace details
+
+inline void init_main_queue(main_queue_processor processor) {
+}
+
+inline void wrap_main_queue(main_queue_wrapper wrapper) {
+	details::_main_wrapper = wrapper;
+}
+
+template <typename Callable>
+inline void on_main(Callable &&callable) {
+	return details::on_queue_invoke<details::MainQueueWrapper>(
+		details::main_queue_dispatch(),
+		details::on_queue_async,
+		std::forward<Callable>(callable));
+}
+
+template <typename Callable>
+inline void on_main_sync(Callable &&callable) {
+	return details::on_queue_invoke<details::MainQueueWrapper>(
+		details::main_queue_dispatch(),
+		details::on_queue_sync,
+		std::forward<Callable>(callable));
+}
+
+} // namespace crl
+
+#endif // CRL_USE_DISPATCH && !CRL_FORCE_COMMON_QUEUE

Telegram/lib_crl/crl/dispatch/crl_dispatch_queue.cpp

@@ -0,0 +1,56 @@
+// 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
+//
+#include <crl/dispatch/crl_dispatch_queue.h>
+
+#if defined CRL_USE_DISPATCH && !defined CRL_FORCE_COMMON_QUEUE
+
+#include <dispatch/dispatch.h>
+#include <exception>
+
+namespace crl {
+namespace {
+
+dispatch_queue_t Unwrap(void *value) {
+	return static_cast<dispatch_queue_t>(value);
+}
+
+} // namespace
+
+auto queue::implementation::create() -> pointer {
+	auto result = dispatch_queue_create(nullptr, DISPATCH_QUEUE_SERIAL);
+	if (!result) {
+		std::terminate();
+	}
+	return result;
+}
+
+void queue::implementation::operator()(pointer value) {
+	if (value) {
+		dispatch_release(Unwrap(value));
+	}
+};
+
+queue::queue() : _handle(implementation::create()) {
+}
+
+void queue::async_plain(void (*callable)(void*), void *argument) {
+	dispatch_async_f(
+		Unwrap(_handle.get()),
+		argument,
+		callable);
+}
+
+void queue::sync_plain(void (*callable)(void*), void *argument) {
+	dispatch_sync_f(
+		Unwrap(_handle.get()),
+		argument,
+		callable);
+}
+
+} // namespace crl
+
+#endif // CRL_USE_DISPATCH && !CRL_FORCE_COMMON_QUEUE

Telegram/lib_crl/crl/dispatch/crl_dispatch_queue.h

@@ -0,0 +1,86 @@
+// 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>
+
+#if defined CRL_USE_DISPATCH && !defined CRL_FORCE_COMMON_QUEUE
+
+#include <crl/common/crl_common_utils.h>
+#include <memory>
+#include <atomic>
+
+namespace crl {
+
+class queue {
+public:
+	queue();
+
+	template <
+		typename Callable,
+		typename Return = decltype(std::declval<Callable>()())>
+	void async(Callable &&callable) {
+		using Function = std::decay_t<Callable>;
+
+		if constexpr (details::is_plain_function_v<Function, Return>) {
+			using Plain = Return(*)();
+			const auto copy = static_cast<Plain>(callable);
+			async_plain([](void *passed) {
+				const auto callable = reinterpret_cast<Plain>(passed);
+				(*callable)();
+			}, reinterpret_cast<void*>(copy));
+		} else {
+			const auto copy = new Function(std::forward<Callable>(callable));
+			async_plain([](void *passed) {
+				const auto callable = static_cast<Function*>(passed);
+				const auto guard = details::finally([=] { delete callable; });
+				(*callable)();
+			}, static_cast<void*>(copy));
+		}
+	}
+
+	template <
+		typename Callable,
+		typename Return = decltype(std::declval<Callable>()())>
+	void sync(Callable &&callable) {
+		using Function = std::decay_t<Callable>;
+
+		if constexpr (details::is_plain_function_v<Function, Return>) {
+			using Plain = Return(*)();
+			const auto copy = static_cast<Plain>(callable);
+			sync_plain([](void *passed) {
+				const auto callable = reinterpret_cast<Plain>(passed);
+				(*callable)();
+			}, reinterpret_cast<void*>(copy));
+		} else {
+			const auto copy = new Function(std::forward<Callable>(callable));
+			sync_plain([](void *passed) {
+				const auto callable = static_cast<Function*>(passed);
+				const auto guard = details::finally([=] { delete callable; });
+				(*callable)();
+			}, static_cast<void*>(copy));
+		}
+	}
+
+private:
+	// Hide dispatch_queue_t
+	struct implementation {
+		using pointer = void*;
+		static pointer create();
+		void operator()(pointer value);
+	};
+
+	void async_plain(void (*callable)(void*), void *argument);
+	void sync_plain(void (*callable)(void*), void *argument);
+
+	std::unique_ptr<implementation::pointer, implementation> _handle;
+
+};
+
+} // namespace crl
+
+#endif // CRL_USE_DISPATCH && !CRL_FORCE_COMMON_QUEUE

Telegram/lib_crl/crl/dispatch/crl_dispatch_semaphore.cpp

@@ -0,0 +1,47 @@
+// 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
+//
+#include <crl/dispatch/crl_dispatch_semaphore.h>
+
+#ifdef CRL_USE_DISPATCH
+
+#include <dispatch/dispatch.h>
+#include <exception>
+
+namespace crl {
+namespace {
+
+dispatch_semaphore_t Unwrap(void *value) {
+	return static_cast<dispatch_semaphore_t>(value);
+}
+
+} // namespace
+
+auto semaphore::implementation::create() -> pointer {
+	auto result = dispatch_semaphore_create(0);
+	if (!result) {
+		std::terminate();
+	}
+	return result;
+}
+
+void semaphore::implementation::operator()(pointer value) {
+	if (value) {
+		dispatch_release(Unwrap(value));
+	}
+};
+
+void semaphore::acquire() {
+	dispatch_semaphore_wait(Unwrap(_handle.get()), DISPATCH_TIME_FOREVER);
+}
+
+void semaphore::release() {
+	dispatch_semaphore_signal(Unwrap(_handle.get()));
+}
+
+} // namespace crl
+
+#endif // CRL_USE_DISPATCH

Telegram/lib_crl/crl/dispatch/crl_dispatch_semaphore.h

@@ -0,0 +1,47 @@
+// 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>
+
+#ifdef CRL_USE_DISPATCH
+
+#include <memory>
+
+namespace crl {
+
+class semaphore {
+public:
+	semaphore() : _handle(implementation::create()) {
+	}
+	semaphore(const semaphore &other) = delete;
+	semaphore &operator=(const semaphore &other) = delete;
+	semaphore(semaphore &&other) noexcept
+	: _handle(std::move(other._handle)) {
+	}
+	semaphore &operator=(semaphore &&other) noexcept {
+		_handle = std::move(other._handle);
+		return *this;
+	}
+
+	void acquire();
+	void release();
+
+private:
+	// Hide dispatch_semaphore_t
+	struct implementation {
+		using pointer = void*;
+		static pointer create();
+		void operator()(pointer value);
+	};
+	std::unique_ptr<implementation::pointer, implementation> _handle;
+
+};
+
+} // namespace crl
+
+#endif // CRL_USE_DISPATCH