vanja/yabridge
1
0
Fork 0
mirror of https://github.com/robbert-vdh/yabridge.git synced 2026-05-07 03:50:11 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove old todos

Browse Source
This commit is contained in:
Robbert van der Helm
2022-10-29 16:13:23 +02:00
parent 324b658fb4
commit 90a41287be
2 changed files with 0 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/plugin/bridges/clap.h
-50
View File
@@ -141,47 +141,6 @@ class ClapPluginBridge : PluginBridge<ClapSockets<std::jthread>> {
std::pair<ClapLogger&, bool>(logger_, true));
}
// TODO: Do we need this for CLAP? If we do, update the docstring
// /**
// * Send a message, and allow other threads to call functions on _this
// * thread_ while we're waiting for a response. This lets us execute
// * functions from the host's GUI thread while it is also calling
// functions
// * from that same thread. Because of that, we also know that while this
// * function is being called the host won't be able to handle any
// `IRunLoop`
// * events. We need this to support REAPER, because REAPER requires
// function
// * calls involving the GUI to be run from the GUI thread. Grep for
// * `run_gui_task` for instances of this.
// *
// * We use the same trick in `ClapBridge`.
// */
// template <typename T>
// typename T::Response send_mutually_recursive_message(const T& object) {
// return mutual_recursion_.fork([&]() { return send_message(object);
// });
// }
// /**
// * If `send_mutually_recursive_message()` is currently being called, then
// * run `fn` on the thread that's currently calling that function and
// return
// * the result of the call. If there's currently no mutually recursive
// * function call going on, this will return an `std::nullopt`, and the
// * caller should call `fn` itself.
// *
// * @return The result of calling `fn`, if `fn` was called.
// *
// * @see ClapPlugViewProxyImpl::run_gui_task
// */
// template <std::invocable F>
// std::optional<std::invoke_result_t<F>>
// maybe_run_on_mutual_recursion_thread(
// F&& fn) {
// return mutual_recursion_.maybe_handle(std::forward<F>(fn));
// }
/**
* The logging facility used for this instance of yabridge. Wraps around
* `PluginBridge::generic_logger`.
@@ -229,13 +188,4 @@ class ClapPluginBridge : PluginBridge<ClapSockets<std::jthread>> {
* processing, but it's still something we should avoid at all costs.
*/
std::shared_mutex plugin_proxies_mutex_;
// TODO: Do we need this in CLAP?
// /**
// * Used in `ClapBridge::send_mutually_recursive_message()` to be able to
// * execute functions from that same calling thread while we're waiting
// for a
// * response. This is used in `ClapPlugViewProxyImpl::run_loop_tasks()`.
// */
// MutualRecursionHelper<std::jthread> mutual_recursion_;
};
src/wine-host/bridges/clap.h
-2
View File
@@ -327,8 +327,6 @@ class ClapBridge : public HostBridge {
*
* This only has to be used instead of directly writing to `std::cerr` when
* the message should be hidden on lower verbosity levels.
*
* TODO: Actually use this
*/
ClapLogger logger_;