| 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 |
|---|
Chromium Code Reviews
Issue 1132063007:
Rationalize Dart mojo and sky package structure (Closed)
Base URL: https://github.com/domokit/mojo.git@master