blob: 85c34f8c59dfcfa8f7c7280d26d064cf07628444 (
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
88
89
90
91
92
93
94
95
96
97
98
|
/*
* Copyright 2018 Google
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_EXECUTOR_LIBDISPATCH_H_
#define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_EXECUTOR_LIBDISPATCH_H_
#include <chrono> // NOLINT(build/c++11)
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "dispatch/dispatch.h"
#include "Firestore/core/src/firebase/firestore/util/executor.h"
#include "Firestore/core/src/firebase/firestore/util/firebase_assert.h"
#include "absl/strings/string_view.h"
#if !defined(__OBJC__)
// `dispatch_queue_t` gets defined to different types when compiled in C++ or
// Objective-C mode. Source files including this header should all be compiled
// in the same mode to avoid linker errors.
#error "This header only supports Objective-C++ (see comment for more info)."
#endif // !defined(__OBJC__)
namespace firebase {
namespace firestore {
namespace util {
namespace internal {
// Generic wrapper over `dispatch_async_f`, providing `dispatch_async`-like
// interface: accepts an arbitrary invocable object in place of an Objective-C
// block.
void DispatchAsync(const dispatch_queue_t queue, std::function<void()>&& work);
// Similar to `DispatchAsync` but wraps `dispatch_sync_f`.
void DispatchSync(const dispatch_queue_t queue, std::function<void()> work);
class TimeSlot;
// A serial queue built on top of libdispatch. The operations are run on
// a dedicated serial dispatch queue.
class ExecutorLibdispatch : public Executor {
public:
ExecutorLibdispatch();
explicit ExecutorLibdispatch(dispatch_queue_t dispatch_queue);
~ExecutorLibdispatch();
bool IsCurrentExecutor() const override;
std::string CurrentExecutorName() const override;
std::string Name() const override;
void Execute(Operation&& operation) override;
void ExecuteBlocking(Operation&& operation) override;
DelayedOperation Schedule(Milliseconds delay,
TaggedOperation&& operation) override;
void RemoveFromSchedule(const TimeSlot* to_remove);
bool IsScheduled(Tag tag) const override;
absl::optional<TaggedOperation> PopFromSchedule() override;
dispatch_queue_t dispatch_queue() const {
return dispatch_queue_;
}
private:
// GetLabel functions are guaranteed to never return a "null" string_view
// (i.e. data() != nullptr).
absl::string_view GetCurrentQueueLabel() const;
absl::string_view GetTargetQueueLabel() const;
dispatch_queue_t dispatch_queue_;
// Stores non-owned pointers to `TimeSlot`s.
// Invariant: if a `TimeSlot` is in `schedule_`, it's a valid pointer.
std::vector<TimeSlot*> schedule_;
};
} // namespace internal
} // namespace util
} // namespace firestore
} // namespace firebase
#endif // FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_UTIL_EXECUTOR_LIBDISPATCH_H_
|
