blob: 5ce206996c22a18c9fd57e9eefd4de57c829b7ab (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
#include <mbgl/storage/base_request.hpp>
#include <mbgl/storage/response.hpp>
#include <mbgl/storage/request.hpp>
#include <mbgl/util/std.hpp>
#include <uv.h>
#include <cassert>
namespace mbgl {
template <typename T, typename ...Args>
void invoke(const std::forward_list<std::unique_ptr<Callback>> &list, Args&& ...args) {
for (const std::unique_ptr<Callback> &callback : list) {
assert(callback);
if (callback->is<T>()) {
callback->get<T>()(::std::forward<Args>(args)...);
}
}
}
BaseRequest::BaseRequest(const std::string &path_) : thread_id(std::this_thread::get_id()), path(path_) {
}
// A base request can only be "canceled" by destroying the object. In that case, we'll have to
// notify all cancel callbacks.
BaseRequest::~BaseRequest() {
assert(thread_id == std::this_thread::get_id());
notify();
}
void BaseRequest::retryImmediately() {
// no-op. override in child class.
}
void BaseRequest::notify() {
assert(thread_id == std::this_thread::get_id());
// The parameter exists solely so that any calls to ->remove()
// are not going to cause deallocation of this object while this call is in progress.
util::ptr<BaseRequest> retain = self;
// Swap the lists so that it's safe for callbacks to call ->cancel()
// on the request object, which would modify the list.
const std::forward_list<std::unique_ptr<Callback>> list = std::move(callbacks);
callbacks.clear();
if (response) {
invoke<CompletedCallback>(list, *response);
} else {
invoke<AbortedCallback>(list);
}
self.reset();
}
Callback *BaseRequest::add(Callback &&callback, const util::ptr<BaseRequest> &request) {
assert(thread_id == std::this_thread::get_id());
assert(this == request.get());
if (response) {
// We already have a response. Notify right away.
if (callback.is<CompletedCallback>()) {
callback.get<CompletedCallback>()(*response);
} else {
// We already know that this request was successful. The AbortedCallback will be discarded
// here since it would never be called.
}
return nullptr;
} else {
self = request;
callbacks.push_front(util::make_unique<Callback>(std::move(callback)));
return callbacks.front().get();
}
}
void BaseRequest::remove(Callback *callback) {
assert(thread_id == std::this_thread::get_id());
callbacks.remove_if([=](const std::unique_ptr<Callback> &cb) {
return cb.get() == callback;
});
if (callbacks.empty()) {
self.reset();
}
}
}
|
