summaryrefslogtreecommitdiff
path: root/src/mbgl/actor
diff options
context:
space:
mode:
authorThiago Marcos P. Santos <tmpsantos@gmail.com>2017-06-21 17:29:05 +0300
committerThiago Marcos P. Santos <tmpsantos@gmail.com>2017-06-26 16:32:21 +0300
commit54c3ccc37d4534f699437f9c1854d8f5a857069e (patch)
treee033ecbe2c2978a547d0d097818764063a4ac1b8 /src/mbgl/actor
parent19e872b15c1fb9852b53ffb7e2850d2a2a7763da (diff)
downloadqtlocation-mapboxgl-54c3ccc37d4534f699437f9c1854d8f5a857069e.tar.gz
[core] Make the mbgl/actor headers public
They will be needed by the DefaultFileSource, something that we also export as public.
Diffstat (limited to 'src/mbgl/actor')
-rw-r--r--src/mbgl/actor/actor.hpp77
-rw-r--r--src/mbgl/actor/actor_ref.hpp43
-rw-r--r--src/mbgl/actor/message.hpp48
3 files changed, 0 insertions, 168 deletions
diff --git a/src/mbgl/actor/actor.hpp b/src/mbgl/actor/actor.hpp
deleted file mode 100644
index 810114c513..0000000000
--- a/src/mbgl/actor/actor.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma once
-
-#include <mbgl/actor/mailbox.hpp>
-#include <mbgl/actor/message.hpp>
-#include <mbgl/actor/actor_ref.hpp>
-#include <mbgl/util/noncopyable.hpp>
-
-#include <memory>
-
-namespace mbgl {
-
-/*
- An `Actor<O>` is an owning reference to an asynchronous object of type `O`: an "actor".
- Communication with an actor happens via message passing: you send a message to the object
- (using `invoke`), passing a pointer to the member function to call and arguments which
- are then forwarded to the actor.
-
- The actor receives messages sent to it asynchronously, in a manner defined its `Scheduler`.
- To store incoming messages before their receipt, each actor has a `Mailbox`, which acts as
- a FIFO queue. Messages sent from actor S to actor R are guaranteed to be processed in the
- order sent. However, relative order of messages sent by two *different* actors S1 and S2
- to R is *not* guaranteed (and can't be: S1 and S2 may be acting asynchronously with respect
- to each other).
-
- An `Actor<O>` can be converted to an `ActorRef<O>`, a non-owning value object representing
- a (weak) reference to the actor. Messages can be sent via the `Ref` as well.
-
- It's safe -- and encouraged -- to pass `Ref`s between actors via messages. This is how two-way
- communication and other forms of collaboration between multiple actors is accomplished.
-
- It's safe for a `Ref` to outlive its `Actor` -- the reference is "weak", and does not extend
- the lifetime of the owning Actor, and sending a message to a `Ref` whose `Actor` has died is
- a no-op. (In the future, a dead-letters queue or log may be implemented.)
-
- Construction and destruction of an actor is currently synchronous: the corresponding `O`
- object is constructed synchronously by the `Actor` constructor, and destructed synchronously
- by the `~Actor` destructor, after ensuring that the `O` is not currently receiving an
- asynchronous message. (Construction and destruction may change to be asynchronous in the
- future.) The constructor of `O` is passed an `ActorRef<O>` referring to itself (which it
- can use to self-send messages), followed by the forwarded arguments passed to `Actor<O>`.
-
- Please don't send messages that contain shared pointers or references. That subverts the
- purpose of the actor model: prohibiting direct concurrent access to shared state.
-*/
-
-template <class Object>
-class Actor : public util::noncopyable {
-public:
- template <class... Args>
- Actor(Scheduler& scheduler, Args&&... args_)
- : mailbox(std::make_shared<Mailbox>(scheduler)),
- object(self(), std::forward<Args>(args_)...) {
- }
-
- ~Actor() {
- mailbox->close();
- }
-
- template <typename Fn, class... Args>
- void invoke(Fn fn, Args&&... args) {
- mailbox->push(actor::makeMessage(object, fn, std::forward<Args>(args)...));
- }
-
- ActorRef<std::decay_t<Object>> self() {
- return ActorRef<std::decay_t<Object>>(object, mailbox);
- }
-
- operator ActorRef<std::decay_t<Object>>() {
- return self();
- }
-
-private:
- std::shared_ptr<Mailbox> mailbox;
- Object object;
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/actor/actor_ref.hpp b/src/mbgl/actor/actor_ref.hpp
deleted file mode 100644
index 9d858d823f..0000000000
--- a/src/mbgl/actor/actor_ref.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include <mbgl/actor/mailbox.hpp>
-#include <mbgl/actor/message.hpp>
-
-#include <memory>
-
-namespace mbgl {
-
-/*
- An `ActorRef<O>` is a *non*-owning, weak reference to an actor of type `O`. You can send it
- messages just like an `Actor<O>`. It's a value object: safe to copy and pass between actors
- via messages.
-
- An `ActorRef<O>` does not extend the lifetime of the corresponding `Actor<O>`. That's determined
- entirely by whichever object owns the `Actor<O>` -- the actor's "supervisor".
-
- It's safe for a `Ref` to outlive its `Actor` -- the reference is "weak", and does not extend
- the lifetime of the owning Actor, and sending a message to a `Ref` whose `Actor` has died is
- a no-op. (In the future, a dead-letters queue or log may be implemented.)
-*/
-
-template <class Object>
-class ActorRef {
-public:
- ActorRef(Object& object_, std::weak_ptr<Mailbox> weakMailbox_)
- : object(object_),
- weakMailbox(std::move(weakMailbox_)) {
- }
-
- template <typename Fn, class... Args>
- void invoke(Fn fn, Args&&... args) {
- if (auto mailbox = weakMailbox.lock()) {
- mailbox->push(actor::makeMessage(object, fn, std::forward<Args>(args)...));
- }
- }
-
-private:
- Object& object;
- std::weak_ptr<Mailbox> weakMailbox;
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/actor/message.hpp b/src/mbgl/actor/message.hpp
deleted file mode 100644
index cf071d4933..0000000000
--- a/src/mbgl/actor/message.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-#include <utility>
-
-namespace mbgl {
-
-// A movable type-erasing function wrapper. This allows to store arbitrary invokable
-// things (like std::function<>, or the result of a movable-only std::bind()) in the queue.
-// Source: http://stackoverflow.com/a/29642072/331379
-class Message {
-public:
- virtual ~Message() = default;
- virtual void operator()() = 0;
-};
-
-template <class Object, class MemberFn, class ArgsTuple>
-class MessageImpl : public Message {
-public:
- MessageImpl(Object& object_, MemberFn memberFn_, ArgsTuple argsTuple_)
- : object(object_),
- memberFn(memberFn_),
- argsTuple(std::move(argsTuple_)) {
- }
-
- void operator()() override {
- invoke(std::make_index_sequence<std::tuple_size<ArgsTuple>::value>());
- }
-
- template <std::size_t... I>
- void invoke(std::index_sequence<I...>) {
- (object.*memberFn)(std::move(std::get<I>(argsTuple))...);
- }
-
- Object& object;
- MemberFn memberFn;
- ArgsTuple argsTuple;
-};
-
-namespace actor {
-
-template <class Object, class MemberFn, class... Args>
-std::unique_ptr<Message> makeMessage(Object& object, MemberFn memberFn, Args&&... args) {
- auto tuple = std::make_tuple(std::forward<Args>(args)...);
- return std::make_unique<MessageImpl<Object, MemberFn, decltype(tuple)>>(object, memberFn, std::move(tuple));
-}
-
-} // namespace actor
-} // namespace mbgl