OLD | NEW |
| (Empty) |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 part of core; | |
6 | |
7 class MojoResult { | |
8 static const int kOk = 0; | |
9 static const int kCancelled = 1; | |
10 static const int kUnknown = 2; | |
11 static const int kInvalidArgument = 3; | |
12 static const int kDeadlineExceeded = 4; | |
13 static const int kNotFound = 5; | |
14 static const int kAlreadyExists = 6; | |
15 static const int kPermissionDenied = 7; | |
16 static const int kResourceExhausted = 8; | |
17 static const int kFailedPrecondition = 9; | |
18 static const int kAborted = 10; | |
19 static const int kOutOfRange = 11; | |
20 static const int kUnimplemented = 12; | |
21 static const int kInternal = 13; | |
22 static const int kUnavailable = 14; | |
23 static const int kDataLoss = 15; | |
24 static const int kBusy = 16; | |
25 static const int kShouldWait = 17; | |
26 | |
27 static const OK = const MojoResult._(kOk); | |
28 static const CANCELLED = const MojoResult._(kCancelled); | |
29 static const UNKNOWN = const MojoResult._(kUnknown); | |
30 static const INVALID_ARGUMENT = const MojoResult._(kInvalidArgument); | |
31 static const DEADLINE_EXCEEDED = const MojoResult._(kDeadlineExceeded); | |
32 static const NOT_FOUND = const MojoResult._(kNotFound); | |
33 static const ALREADY_EXISTS = const MojoResult._(kAlreadyExists); | |
34 static const PERMISSION_DENIED = const MojoResult._(kPermissionDenied); | |
35 static const RESOURCE_EXHAUSTED = const MojoResult._(kResourceExhausted); | |
36 static const FAILED_PRECONDITION = const MojoResult._(kFailedPrecondition); | |
37 static const ABORTED = const MojoResult._(kAborted); | |
38 static const OUT_OF_RANGE = const MojoResult._(kOutOfRange); | |
39 static const UNIMPLEMENTED = const MojoResult._(kUnimplemented); | |
40 static const INTERNAL = const MojoResult._(kInternal); | |
41 static const UNAVAILABLE = const MojoResult._(kUnavailable); | |
42 static const DATA_LOSS = const MojoResult._(kDataLoss); | |
43 static const BUSY = const MojoResult._(kBusy); | |
44 static const SHOULD_WAIT = const MojoResult._(kShouldWait); | |
45 | |
46 final int value; | |
47 | |
48 const MojoResult._(this.value); | |
49 | |
50 factory MojoResult(int value) { | |
51 switch (value) { | |
52 case kOk: | |
53 return OK; | |
54 case kCancelled: | |
55 return CANCELLED; | |
56 case kUnknown: | |
57 return UNKNOWN; | |
58 case kInvalidArgument: | |
59 return INVALID_ARGUMENT; | |
60 case kDeadlineExceeded: | |
61 return DEADLINE_EXCEEDED; | |
62 case kNotFound: | |
63 return NOT_FOUND; | |
64 case kAlreadyExists: | |
65 return ALREADY_EXISTS; | |
66 case kPermissionDenied: | |
67 return PERMISSION_DENIED; | |
68 case kResourceExhausted: | |
69 return RESOURCE_EXHAUSTED; | |
70 case kFailedPrecondition: | |
71 return FAILED_PRECONDITION; | |
72 case kAborted: | |
73 return ABORTED; | |
74 case kOutOfRange: | |
75 return OUT_OF_RANGE; | |
76 case kUnimplemented: | |
77 return UNIMPLEMENTED; | |
78 case kInternal: | |
79 return INTERNAL; | |
80 case kUnavailable: | |
81 return UNAVAILABLE; | |
82 case kDataLoss: | |
83 return DATA_LOSS; | |
84 case kBusy: | |
85 return BUSY; | |
86 case kShouldWait: | |
87 return SHOULD_WAIT; | |
88 default: | |
89 throw 'Invalid Mojo result'; | |
90 } | |
91 } | |
92 | |
93 bool get isOk => (this == OK); | |
94 bool get isCancelled => (this == CANCELLED); | |
95 bool get isUnknown => (this == UNKNOWN); | |
96 bool get isInvalidArgument => (this == INVALID_ARGUMENT); | |
97 bool get isDeadlineExceeded => (this == DEADLINE_EXCEEDED); | |
98 bool get isNotFound => (this == NOT_FOUND); | |
99 bool get isAlreadExists => (this == ALREADY_EXISTS); | |
100 bool get isPermissionDenied => (this == PERMISSION_DENIED); | |
101 bool get isResourceExhausted => (this == RESOURCE_EXHAUSTED); | |
102 bool get isFailedPrecondition => (this == FAILED_PRECONDITION); | |
103 bool get isAborted => (this == ABORTED); | |
104 bool get isOutOfRange => (this == OUT_OF_RANGE); | |
105 bool get isUnimplemented => (this == UNIMPLEMENTED); | |
106 bool get isInternal => (this == INTERNAL); | |
107 bool get isUnavailable => (this == UNAVAILABLE); | |
108 bool get isDataLoss => (this == DATA_LOSS); | |
109 bool get isBusy => (this == BUSY); | |
110 bool get isShouldWait => (this == SHOULD_WAIT); | |
111 | |
112 String toString() { | |
113 switch (value) { | |
114 case kOk: | |
115 return "OK"; | |
116 case kCancelled: | |
117 return "CANCELLED"; | |
118 case kUnknown: | |
119 return "UNKNOWN"; | |
120 case kInvalidArgument: | |
121 return "INVALID_ARGUMENT"; | |
122 case kDeadlineExceeded: | |
123 return "DEADLINE_EXCEEDED"; | |
124 case kNotFound: | |
125 return "NOT_FOUND"; | |
126 case kAlreadyExists: | |
127 return "ALREADY_EXISTS"; | |
128 case kPermissionDenied: | |
129 return "PERMISSION_DENIED"; | |
130 case kResourceExhausted: | |
131 return "RESOURCE_EXHAUSTED"; | |
132 case kFailedPrecondition: | |
133 return "FAILED_PRECONDITION"; | |
134 case kAborted: | |
135 return "ABORTED"; | |
136 case kOutOfRange: | |
137 return "OUT_OF_RANGE"; | |
138 case kUnimplemented: | |
139 return "UNIMPLEMENTED"; | |
140 case kInternal: | |
141 return "INTERNAL"; | |
142 case kUnavailable: | |
143 return "UNAVAILABLE"; | |
144 case kDataLoss: | |
145 return "DATA_LOSS"; | |
146 case kBusy: | |
147 return "BUSY"; | |
148 case kShouldWait: | |
149 return "SHOULD_WAIT"; | |
150 default: | |
151 return "<invalid result>"; | |
152 } | |
153 } | |
154 } | |
155 | |
156 class MojoHandleSignals { | |
157 static const int kNone = 0; | |
158 static const int kReadable = 1 << 0; | |
159 static const int kWritable = 1 << 1; | |
160 static const int kPeerClosed = 1 << 2; | |
161 static const int kReadWrite = kReadable | kWritable; | |
162 static const int kAll = kReadable | kWritable | kPeerClosed; | |
163 static const int kBitfieldSize = 3; | |
164 | |
165 static const NONE = const MojoHandleSignals._(kNone); | |
166 static const READABLE = const MojoHandleSignals._(kReadable); | |
167 static const WRITABLE = const MojoHandleSignals._(kWritable); | |
168 static const PEER_CLOSED = const MojoHandleSignals._(kPeerClosed); | |
169 static const PEER_CLOSED_READABLE = | |
170 const MojoHandleSignals._(kPeerClosed | kReadable); | |
171 static const READWRITE = const MojoHandleSignals._(kReadWrite); | |
172 static const PEER_CLOSED_WRITABLE = | |
173 const MojoHandleSignals._(kPeerClosed | kWritable); | |
174 static const ALL = const MojoHandleSignals._(kAll); | |
175 | |
176 | |
177 final int value; | |
178 | |
179 const MojoHandleSignals._(this.value); | |
180 | |
181 factory MojoHandleSignals(int value) { | |
182 switch (value) { | |
183 case kNone: | |
184 return NONE; | |
185 case kReadable: | |
186 return READABLE; | |
187 case kWritable: | |
188 return WRITABLE; | |
189 case kPeerClosed: | |
190 return PEER_CLOSED; | |
191 case kReadWrite: | |
192 return READWRITE; | |
193 case kPeerClosed | kReadable: | |
194 return PEER_CLOSED_READABLE; | |
195 case kPeerClosed | kWritable: | |
196 return PEER_CLOSED_WRITABLE; | |
197 case kAll: | |
198 return ALL; | |
199 default: | |
200 throw 'Invalid handle signal: $value'; | |
201 } | |
202 } | |
203 | |
204 bool get isNone => (this == NONE); | |
205 bool get isReadable => (value & kReadable) == kReadable; | |
206 bool get isWritable => (value & kWritable) == kWritable; | |
207 bool get isPeerClosed => (value & kPeerClosed) == kPeerClosed; | |
208 bool get isReadWrite => (value & kReadWrite) == kReadWrite; | |
209 bool get isAll => (this == ALL); | |
210 bool get isValid => (value & kAll) == value; | |
211 | |
212 MojoHandleSignals operator +(MojoHandleSignals other) { | |
213 return new MojoHandleSignals(value | other.value); | |
214 } | |
215 | |
216 MojoHandleSignals operator -(MojoHandleSignals other) { | |
217 return new MojoHandleSignals(value & ~other.value); | |
218 } | |
219 | |
220 String toString() { | |
221 if (isNone) { | |
222 return "(None)"; | |
223 } | |
224 if (!isValid) { | |
225 return "(INVALID)"; | |
226 } | |
227 List<String> signals = []; | |
228 if (isReadable) signals.add("Readable"); | |
229 if (isWritable) signals.add("Writable"); | |
230 if (isPeerClosed) signals.add("PeerClosed"); | |
231 return "(" + signals.join(", ") + ")"; | |
232 } | |
233 } | |
234 | |
235 class MojoHandleSignalsState { | |
236 MojoHandleSignalsState(this.satisfied_signals, this.satisfiable_signals); | |
237 final int satisfied_signals; | |
238 final int satisfiable_signals; | |
239 String toString() => (new MojoHandleSignals(satisfied_signals)).toString(); | |
240 } | |
241 | |
242 class MojoWaitResult { | |
243 MojoWaitResult(this.result, this.state); | |
244 final MojoResult result; | |
245 MojoHandleSignalsState state; | |
246 String toString() => "MojoWaitResult(result: $result, state: $state)"; | |
247 } | |
248 | |
249 class MojoWaitManyResult { | |
250 MojoWaitManyResult(this.result, this.index, this.states); | |
251 final MojoResult result; | |
252 final int index; | |
253 List<MojoHandleSignalsState> states; | |
254 | |
255 bool get isIndexValid => (this.index != null); | |
256 bool get areSignalStatesValid => (this.states != null); | |
257 | |
258 String toString() => | |
259 "MojoWaitManyResult(" "result: $result, idx: $index, state: ${states[index
]})"; | |
260 } | |
OLD | NEW |