blob: 7615965b147162a3a6cd6477dcaa357574d83ce4 (
plain) (
blame)
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
#pragma once
#include "operation_cancelled_exception.h"
#include <library/cpp/threading/future/future.h>
#include <util/generic/ptr.h>
#include <util/generic/singleton.h>
namespace NThreading {
class TCancellationTokenSource;
//! A cancellation token could be passed to an async or long running operation to perform a cooperative operation cancel
class TCancellationToken {
private:
TFuture<void> Future_;
TInstant Deadline_ = TInstant::Max();
public:
TCancellationToken() = delete;
TCancellationToken(const TCancellationToken&) noexcept = default;
TCancellationToken(TCancellationToken&&) noexcept = default;
TCancellationToken& operator = (const TCancellationToken&) noexcept = default;
TCancellationToken& operator = (TCancellationToken&&) noexcept = default;
//! Shows whether a cancellation has been requested
bool IsCancellationRequested() const {
return Future_.HasValue();
}
//! Shows whether a cancellation has been requested
bool IsDeadlineReached() const {
return TInstant::Now() > Deadline_;
}
//! Throws the TOperationCancelledException if a cancellation has been requested
void ThrowIfCancellationRequested() const {
if (IsCancellationRequested()) {
ythrow TOperationCancelledException();
}
}
//! Throws the TOperationCancelledException if the Deadline_ has been reached
void ThrowIfDeadlineReached() const {
if (IsDeadlineReached()) {
ythrow TOperationCancelledException();
}
}
//! Throws the TOperationCancelledException if a cancellation has been requested
// or reached the Deadline_
void ThrowIfTokenCancelled() const {
ThrowIfCancellationRequested();
ThrowIfDeadlineReached();
}
//! Waits for a cancellation
bool Wait(TDuration duration) const {
return Future_.Wait(duration);
}
bool Wait(TInstant deadline) const {
return Future_.Wait(deadline);
}
void Wait() const {
return Future_.Wait();
}
//! Returns a future that could be used for waiting for a cancellation
TFuture<void> const& Future() const noexcept {
return Future_;
}
//! The default cancellation token that cannot be cancelled
static TCancellationToken const& Default() {
return *SingletonWithPriority<TCancellationToken, 0>(NewPromise());
}
void SetDeadline(TInstant deadline) {
Deadline_ = deadline;
}
TInstant GetDeadline() const {
return Deadline_;
}
private:
TCancellationToken(TFuture<void> future)
: Future_(std::move(future))
{
}
private:
friend class TCancellationTokenSource;
Y_DECLARE_SINGLETON_FRIEND();
};
//! A cancellation token source produces cancellation tokens to be passed to cancellable operations
class TCancellationTokenSource {
private:
TPromise<void> Promise;
public:
TCancellationTokenSource()
: Promise(NewPromise())
{
}
TCancellationTokenSource(TCancellationTokenSource const&) = delete;
TCancellationTokenSource(TCancellationTokenSource&&) = delete;
TCancellationTokenSource& operator=(TCancellationTokenSource const&) = delete;
TCancellationTokenSource& operator=(TCancellationTokenSource&&) = delete;
//! Shows whether a cancellation has been requested
bool IsCancellationRequested() const noexcept {
return Promise.HasValue();
}
//! Produces a cancellation token
TCancellationToken Token() const {
return TCancellationToken(Promise.GetFuture());
}
//! Propagates a cancel request to all produced tokens
void Cancel() noexcept {
Promise.TrySetValue();
}
};
}
|
