summaryrefslogtreecommitdiff
path: root/include/mbgl
diff options
context:
space:
mode:
authorJohn Firebaugh <john.firebaugh@gmail.com>2017-02-21 13:57:20 -0800
committerKonstantin Käfer <mail@kkaefer.com>2017-03-28 13:53:19 +0200
commit099a1cb9f10d5b615b115583be147656f2c2cd43 (patch)
treec20529ad5b89d39da48c8c3eee648d91ce018812 /include/mbgl
parent54cbdc4812c52894b1dbb34c786769e852f84f8c (diff)
downloadqtlocation-mapboxgl-099a1cb9f10d5b615b115583be147656f2c2cd43.tar.gz
[core] Move actor/{mailbox,scheduler}.hpp to public include directory
Map constructor takes Scheduler&, and consumers are expected to define an implementation. Therefore the interface must be public.
Diffstat (limited to 'include/mbgl')
-rw-r--r--include/mbgl/actor/mailbox.hpp33
-rw-r--r--include/mbgl/actor/scheduler.hpp38
2 files changed, 71 insertions, 0 deletions
diff --git a/include/mbgl/actor/mailbox.hpp b/include/mbgl/actor/mailbox.hpp
new file mode 100644
index 0000000000..cff0de243a
--- /dev/null
+++ b/include/mbgl/actor/mailbox.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <queue>
+
+namespace mbgl {
+
+class Scheduler;
+class Message;
+
+class Mailbox : public std::enable_shared_from_this<Mailbox> {
+public:
+ Mailbox(Scheduler&);
+
+ void push(std::unique_ptr<Message>);
+
+ void close();
+ void receive();
+
+ static void maybeReceive(std::weak_ptr<Mailbox>);
+
+private:
+ Scheduler& scheduler;
+
+ std::mutex closingMutex;
+ bool closing { false };
+
+ std::mutex queueMutex;
+ std::queue<std::unique_ptr<Message>> queue;
+};
+
+} // namespace mbgl
diff --git a/include/mbgl/actor/scheduler.hpp b/include/mbgl/actor/scheduler.hpp
new file mode 100644
index 0000000000..83689c3348
--- /dev/null
+++ b/include/mbgl/actor/scheduler.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+
+namespace mbgl {
+
+class Mailbox;
+
+/*
+ A `Scheduler` is responsible for coordinating the processing of messages by
+ one or more actors via their mailboxes. It's an abstract interface. Currently,
+ the following concrete implementations exist:
+
+ * `ThreadPool` can coordinate an unlimited number of actors over any number of
+ threads via a pool, preserving the following behaviors:
+
+ - Messages from each individual mailbox are processed in order
+ - Only a single message from a mailbox is processed at a time; there is no
+ concurrency within a mailbox
+
+ Subject to these constraints, processing can happen on whatever thread in the
+ pool is available.
+
+ * `RunLoop` is a `Scheduler` that is typically used to create a mailbox and
+ `ActorRef` for an object that lives on the main thread and is not itself wrapped
+ as an `Actor`:
+
+ auto mailbox = std::make_shared<Mailbox>(*util::RunLoop::Get());
+ Actor<Worker> worker(threadPool, ActorRef<Foo>(*this, mailbox));
+*/
+
+class Scheduler {
+public:
+ virtual ~Scheduler() = default;
+ virtual void schedule(std::weak_ptr<Mailbox>) = 0;
+};
+
+} // namespace mbgl