java-api 17.25.0__py2-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- java/__init__.py +0 -0
- java/awt/__init__.py +265 -0
- java/awt/event/__init__.py +184 -0
- java/awt/geom/__init__.py +116 -0
- java/awt/image/__init__.py +14 -0
- java/awt/print/__init__.py +93 -0
- java/beans/__init__.py +38 -0
- java/io/__init__.py +442 -0
- java/lang/__init__.py +868 -0
- java/lang/reflect/__init__.py +9 -0
- java/math/__init__.py +93 -0
- java/net/__init__.py +504 -0
- java/net/http/__init__.py +15 -0
- java/nio/__init__.py +667 -0
- java/nio/channels/__init__.py +352 -0
- java/nio/charset/__init__.py +146 -0
- java/nio/file/__init__.py +728 -0
- java/nio/file/attribute/__init__.py +141 -0
- java/org/__init__.py +0 -0
- java/org/jdesktop/__init__.py +0 -0
- java/org/jdesktop/core/__init__.py +0 -0
- java/org/jdesktop/core/animation/__init__.py +0 -0
- java/org/jdesktop/core/animation/timing/__init__.py +17 -0
- java/security/__init__.py +27 -0
- java/text/__init__.py +543 -0
- java/time/__init__.py +575 -0
- java/time/chrono/__init__.py +319 -0
- java/time/format/__init__.py +72 -0
- java/time/temporal/__init__.py +353 -0
- java/util/__init__.py +1479 -0
- java/util/concurrent/__init__.py +147 -0
- java/util/function/__init__.py +131 -0
- java/util/regex/__init__.py +197 -0
- java/util/stream/__init__.py +128 -0
- java_api-17.25.0.dist-info/LICENSE +21 -0
- java_api-17.25.0.dist-info/METADATA +150 -0
- java_api-17.25.0.dist-info/RECORD +46 -0
- java_api-17.25.0.dist-info/WHEEL +5 -0
- java_api-17.25.0.dist-info/top_level.txt +2 -0
- javax/__init__.py +0 -0
- javax/security/__init__.py +0 -0
- javax/security/auth/__init__.py +14 -0
- javax/swing/__init__.py +483 -0
- javax/swing/event/__init__.py +43 -0
- javax/swing/plaf/__init__.py +28 -0
- javax/swing/text/__init__.py +19 -0
java/util/__init__.py
ADDED
|
@@ -0,0 +1,1479 @@
|
|
|
1
|
+
"""Contains the collections framework, legacy collection classes, event
|
|
2
|
+
model, date and time facilities, internationalization, and miscellaneous
|
|
3
|
+
utility classes (a string tokenizer, a random-number generator, and a
|
|
4
|
+
bit array).
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
from __future__ import print_function
|
|
8
|
+
|
|
9
|
+
__all__ = [
|
|
10
|
+
"AbstractCollection",
|
|
11
|
+
"AbstractList",
|
|
12
|
+
"AbstractMap",
|
|
13
|
+
"ArrayList",
|
|
14
|
+
"Arrays",
|
|
15
|
+
"Base64",
|
|
16
|
+
"Calendar",
|
|
17
|
+
"Collection",
|
|
18
|
+
"Comparator",
|
|
19
|
+
"ConcurrentModificationException",
|
|
20
|
+
"Currency",
|
|
21
|
+
"Date",
|
|
22
|
+
"Dictionary",
|
|
23
|
+
"Enumeration",
|
|
24
|
+
"EventObject",
|
|
25
|
+
"GregorianCalendar",
|
|
26
|
+
"HashMap",
|
|
27
|
+
"Hashtable",
|
|
28
|
+
"Iterator",
|
|
29
|
+
"ListIterator",
|
|
30
|
+
"Locale",
|
|
31
|
+
"Map",
|
|
32
|
+
"Properties",
|
|
33
|
+
"Spliterator",
|
|
34
|
+
"Stream",
|
|
35
|
+
"TimeZone",
|
|
36
|
+
"UUID",
|
|
37
|
+
]
|
|
38
|
+
|
|
39
|
+
from typing import (
|
|
40
|
+
TYPE_CHECKING,
|
|
41
|
+
Any,
|
|
42
|
+
Dict,
|
|
43
|
+
Iterable,
|
|
44
|
+
List,
|
|
45
|
+
Mapping,
|
|
46
|
+
Optional,
|
|
47
|
+
Set,
|
|
48
|
+
Union,
|
|
49
|
+
)
|
|
50
|
+
|
|
51
|
+
from java.lang import Class, Object, RuntimeException, Throwable
|
|
52
|
+
from java.util.function import (
|
|
53
|
+
BiFunction,
|
|
54
|
+
Consumer,
|
|
55
|
+
Function,
|
|
56
|
+
Predicate,
|
|
57
|
+
Supplier,
|
|
58
|
+
ToDoubleFunction,
|
|
59
|
+
ToIntFunction,
|
|
60
|
+
ToLongFunction,
|
|
61
|
+
)
|
|
62
|
+
|
|
63
|
+
if TYPE_CHECKING:
|
|
64
|
+
from java.io import InputStream, OutputStream
|
|
65
|
+
from java.nio import ByteBuffer
|
|
66
|
+
from java.time import Instant, ZonedDateTime, ZoneId
|
|
67
|
+
|
|
68
|
+
|
|
69
|
+
class Collection(object):
|
|
70
|
+
|
|
71
|
+
def add(self, e):
|
|
72
|
+
# type: (Any) -> bool
|
|
73
|
+
raise NotImplementedError
|
|
74
|
+
|
|
75
|
+
def addAll(self, c):
|
|
76
|
+
# type: (Collection) -> bool
|
|
77
|
+
raise NotImplementedError
|
|
78
|
+
|
|
79
|
+
def clear(self):
|
|
80
|
+
# type: () -> None
|
|
81
|
+
raise NotImplementedError
|
|
82
|
+
|
|
83
|
+
def contains(self, o):
|
|
84
|
+
# type: (Object) -> bool
|
|
85
|
+
raise NotImplementedError
|
|
86
|
+
|
|
87
|
+
def containsAll(self, c):
|
|
88
|
+
# type: (Collection) -> bool
|
|
89
|
+
raise NotImplementedError
|
|
90
|
+
|
|
91
|
+
def equals(self, o):
|
|
92
|
+
# type: (Object) -> bool
|
|
93
|
+
raise NotImplementedError
|
|
94
|
+
|
|
95
|
+
def forEach(self, action):
|
|
96
|
+
# type: (Consumer) -> None
|
|
97
|
+
pass
|
|
98
|
+
|
|
99
|
+
def hashCode(self):
|
|
100
|
+
# type: () -> int
|
|
101
|
+
raise NotImplementedError
|
|
102
|
+
|
|
103
|
+
def isEmpty(self):
|
|
104
|
+
# type: () -> bool
|
|
105
|
+
raise NotImplementedError
|
|
106
|
+
|
|
107
|
+
def iterator(self):
|
|
108
|
+
# type: () -> Iterator
|
|
109
|
+
raise NotImplementedError
|
|
110
|
+
|
|
111
|
+
def parallelStream(self):
|
|
112
|
+
# type: () -> Stream
|
|
113
|
+
pass
|
|
114
|
+
|
|
115
|
+
def remove(self, o):
|
|
116
|
+
# type: (Object) -> bool
|
|
117
|
+
raise NotImplementedError
|
|
118
|
+
|
|
119
|
+
def removeAll(self, c):
|
|
120
|
+
# type: (Collection) -> bool
|
|
121
|
+
raise NotImplementedError
|
|
122
|
+
|
|
123
|
+
def removeIf(self, filter):
|
|
124
|
+
# type: (Predicate) -> bool
|
|
125
|
+
return True
|
|
126
|
+
|
|
127
|
+
def retainAll(self, v):
|
|
128
|
+
# type: (Collection) -> bool
|
|
129
|
+
raise NotImplementedError
|
|
130
|
+
|
|
131
|
+
def size(self):
|
|
132
|
+
# type: () -> int
|
|
133
|
+
raise NotImplementedError
|
|
134
|
+
|
|
135
|
+
def spliterator(self):
|
|
136
|
+
# type: () -> Spliterator
|
|
137
|
+
pass
|
|
138
|
+
|
|
139
|
+
def stream(self):
|
|
140
|
+
# type: () -> Stream
|
|
141
|
+
pass
|
|
142
|
+
|
|
143
|
+
def toArray(self, arg=None):
|
|
144
|
+
# type: (Optional[Any]) -> List[Object]
|
|
145
|
+
pass
|
|
146
|
+
|
|
147
|
+
def __getitem__(self, key):
|
|
148
|
+
# type: (Union[int, Any]) -> Any
|
|
149
|
+
pass
|
|
150
|
+
|
|
151
|
+
def __len__(self):
|
|
152
|
+
# type: () -> int
|
|
153
|
+
pass
|
|
154
|
+
|
|
155
|
+
|
|
156
|
+
class Comparator(object):
|
|
157
|
+
def compare(self, o1, o2):
|
|
158
|
+
# type: (Any, Any) -> int
|
|
159
|
+
raise NotImplementedError
|
|
160
|
+
|
|
161
|
+
@staticmethod
|
|
162
|
+
def comparing(keyExtractor, keyComparator):
|
|
163
|
+
# type: (Function, Comparator) -> Comparator
|
|
164
|
+
pass
|
|
165
|
+
|
|
166
|
+
@staticmethod
|
|
167
|
+
def comparingDouble(keyExtractor):
|
|
168
|
+
# type: (ToDoubleFunction) -> Comparator
|
|
169
|
+
pass
|
|
170
|
+
|
|
171
|
+
@staticmethod
|
|
172
|
+
def comparingInt(keyExtractor):
|
|
173
|
+
# type: (ToIntFunction) -> Comparator
|
|
174
|
+
pass
|
|
175
|
+
|
|
176
|
+
@staticmethod
|
|
177
|
+
def comparingLong(keyExtractor):
|
|
178
|
+
# type: (ToLongFunction) -> Comparator
|
|
179
|
+
pass
|
|
180
|
+
|
|
181
|
+
def equals(self, obj):
|
|
182
|
+
# type: (Object) -> bool
|
|
183
|
+
raise NotImplementedError
|
|
184
|
+
|
|
185
|
+
@staticmethod
|
|
186
|
+
def naturalOrder():
|
|
187
|
+
# type: () -> Comparator
|
|
188
|
+
pass
|
|
189
|
+
|
|
190
|
+
@staticmethod
|
|
191
|
+
def nullsFirst(comparator):
|
|
192
|
+
# type: (Comparator) -> Comparator
|
|
193
|
+
pass
|
|
194
|
+
|
|
195
|
+
@staticmethod
|
|
196
|
+
def nullsLast(comparator):
|
|
197
|
+
# type: (Comparator) -> Comparator
|
|
198
|
+
pass
|
|
199
|
+
|
|
200
|
+
def reversed(self):
|
|
201
|
+
# type: () -> Comparator
|
|
202
|
+
pass
|
|
203
|
+
|
|
204
|
+
@staticmethod
|
|
205
|
+
def reverseOrder():
|
|
206
|
+
# type: () -> Comparator
|
|
207
|
+
pass
|
|
208
|
+
|
|
209
|
+
def thenComparing(self, *args):
|
|
210
|
+
# type: (*Any) -> Comparator
|
|
211
|
+
pass
|
|
212
|
+
|
|
213
|
+
def thenComparingDouble(self, keyExtractor):
|
|
214
|
+
# type: (ToDoubleFunction) -> Comparator
|
|
215
|
+
pass
|
|
216
|
+
|
|
217
|
+
def thenComparingInt(self, keyExtractor):
|
|
218
|
+
# type: (ToIntFunction) -> Comparator
|
|
219
|
+
pass
|
|
220
|
+
|
|
221
|
+
def thenComparingLong(self, keyExtractor):
|
|
222
|
+
# type: (ToLongFunction) -> Comparator
|
|
223
|
+
pass
|
|
224
|
+
|
|
225
|
+
|
|
226
|
+
class Enumeration(object):
|
|
227
|
+
def asIterator(self):
|
|
228
|
+
# type: () -> Iterator
|
|
229
|
+
pass
|
|
230
|
+
|
|
231
|
+
def hasMoreElements(self):
|
|
232
|
+
# type: () -> bool
|
|
233
|
+
raise NotImplementedError
|
|
234
|
+
|
|
235
|
+
def nextElement(self):
|
|
236
|
+
# type: () -> Any
|
|
237
|
+
raise NotImplementedError
|
|
238
|
+
|
|
239
|
+
|
|
240
|
+
class Iterator(object):
|
|
241
|
+
def forEachRemaining(self, action):
|
|
242
|
+
# type: (Consumer) -> None
|
|
243
|
+
pass
|
|
244
|
+
|
|
245
|
+
def hasNext(self):
|
|
246
|
+
# type: () -> bool
|
|
247
|
+
raise NotImplementedError
|
|
248
|
+
|
|
249
|
+
def next(self):
|
|
250
|
+
# type: () -> Any
|
|
251
|
+
raise NotImplementedError
|
|
252
|
+
|
|
253
|
+
def remove(self):
|
|
254
|
+
# type: () -> bool
|
|
255
|
+
return True
|
|
256
|
+
|
|
257
|
+
|
|
258
|
+
class ListIterator(Iterator):
|
|
259
|
+
def add(self, e):
|
|
260
|
+
# type: (Any) -> None
|
|
261
|
+
raise NotImplementedError
|
|
262
|
+
|
|
263
|
+
def hasNext(self):
|
|
264
|
+
# type: () -> bool
|
|
265
|
+
raise NotImplementedError
|
|
266
|
+
|
|
267
|
+
def hasPrevious(self):
|
|
268
|
+
# type: () -> bool
|
|
269
|
+
raise NotImplementedError
|
|
270
|
+
|
|
271
|
+
def next(self):
|
|
272
|
+
# type: () -> Any
|
|
273
|
+
raise NotImplementedError
|
|
274
|
+
|
|
275
|
+
def nextIndex(self):
|
|
276
|
+
# type: () -> int
|
|
277
|
+
raise NotImplementedError
|
|
278
|
+
|
|
279
|
+
def previous(self):
|
|
280
|
+
# type: () -> Any
|
|
281
|
+
raise NotImplementedError
|
|
282
|
+
|
|
283
|
+
def previousIndex(self):
|
|
284
|
+
# type: () -> int
|
|
285
|
+
raise NotImplementedError
|
|
286
|
+
|
|
287
|
+
def set(self, e):
|
|
288
|
+
# type: (Any) -> None
|
|
289
|
+
raise NotImplementedError
|
|
290
|
+
|
|
291
|
+
|
|
292
|
+
class Map(object):
|
|
293
|
+
|
|
294
|
+
class Entry(object):
|
|
295
|
+
@staticmethod
|
|
296
|
+
def comparingByKey(cmp=None):
|
|
297
|
+
# type: (Optional[Comparator]) -> Any
|
|
298
|
+
pass
|
|
299
|
+
|
|
300
|
+
@staticmethod
|
|
301
|
+
def comparingByValue(cmp=None):
|
|
302
|
+
# type: (Optional[Comparator]) -> Any
|
|
303
|
+
pass
|
|
304
|
+
|
|
305
|
+
def getKey(self):
|
|
306
|
+
# type: () -> Any
|
|
307
|
+
raise NotImplementedError
|
|
308
|
+
|
|
309
|
+
def getValue(self):
|
|
310
|
+
# type: () -> Any
|
|
311
|
+
raise NotImplementedError
|
|
312
|
+
|
|
313
|
+
def hashCode(self):
|
|
314
|
+
# type: () -> int
|
|
315
|
+
raise NotImplementedError
|
|
316
|
+
|
|
317
|
+
def setValue(self, value):
|
|
318
|
+
# type: (Any) -> Any
|
|
319
|
+
raise NotImplementedError
|
|
320
|
+
|
|
321
|
+
def clear(self):
|
|
322
|
+
# type: () -> None
|
|
323
|
+
raise NotImplementedError
|
|
324
|
+
|
|
325
|
+
def compute(self, key, remappingFuntion):
|
|
326
|
+
# type: (Any, BiFunction) -> Any
|
|
327
|
+
pass
|
|
328
|
+
|
|
329
|
+
def computeIfAbsent(self, key, mappingFuntion):
|
|
330
|
+
# type: (Any, BiFunction) -> Any
|
|
331
|
+
pass
|
|
332
|
+
|
|
333
|
+
def computeIfPresent(self, key, remappingFuntion):
|
|
334
|
+
# type: (Any, BiFunction) -> Any
|
|
335
|
+
pass
|
|
336
|
+
|
|
337
|
+
def containsKey(self, key):
|
|
338
|
+
# type: (Object) -> bool
|
|
339
|
+
raise NotImplementedError
|
|
340
|
+
|
|
341
|
+
def containsValue(self, value):
|
|
342
|
+
# type: (Object) -> bool
|
|
343
|
+
raise NotImplementedError
|
|
344
|
+
|
|
345
|
+
@staticmethod
|
|
346
|
+
def copyOf(map):
|
|
347
|
+
# type: (Map) -> Map
|
|
348
|
+
pass
|
|
349
|
+
|
|
350
|
+
@staticmethod
|
|
351
|
+
def entry(k, v):
|
|
352
|
+
# type: (Any, Any) -> Map.Entry
|
|
353
|
+
pass
|
|
354
|
+
|
|
355
|
+
def entrySet(self):
|
|
356
|
+
# type: () -> Set[Map.Entry]
|
|
357
|
+
raise NotImplementedError
|
|
358
|
+
|
|
359
|
+
def forEach(self, action):
|
|
360
|
+
# type: (BiFunction) -> None
|
|
361
|
+
pass
|
|
362
|
+
|
|
363
|
+
def get(self, key):
|
|
364
|
+
# type: (Object) -> Any
|
|
365
|
+
raise NotImplementedError
|
|
366
|
+
|
|
367
|
+
def getOrDefault(self, key, defaultValue):
|
|
368
|
+
# type: (Object, Any) -> Any
|
|
369
|
+
pass
|
|
370
|
+
|
|
371
|
+
def isEmpty(self):
|
|
372
|
+
# type: () -> bool
|
|
373
|
+
raise NotImplementedError
|
|
374
|
+
|
|
375
|
+
def keySet(self):
|
|
376
|
+
# type: () -> Set[Any]
|
|
377
|
+
raise NotImplementedError
|
|
378
|
+
|
|
379
|
+
def merge(self, key, value, remappingFunction):
|
|
380
|
+
# type: (Any, Any, BiFunction) -> Any
|
|
381
|
+
pass
|
|
382
|
+
|
|
383
|
+
@staticmethod
|
|
384
|
+
def of(*args):
|
|
385
|
+
# type: (*Any) -> Map
|
|
386
|
+
pass
|
|
387
|
+
|
|
388
|
+
@staticmethod
|
|
389
|
+
def ofEntries(*entries):
|
|
390
|
+
# type: (*Map.Entry) -> Map
|
|
391
|
+
pass
|
|
392
|
+
|
|
393
|
+
def put(self, key, value):
|
|
394
|
+
# type: (Any, Any) -> Any
|
|
395
|
+
raise NotImplementedError
|
|
396
|
+
|
|
397
|
+
def putAll(self, m):
|
|
398
|
+
# type: (Mapping[Any, Any]) -> None
|
|
399
|
+
raise NotImplementedError
|
|
400
|
+
|
|
401
|
+
def putIfAbsent(self, key, value):
|
|
402
|
+
# type: (Any, Any) -> Any
|
|
403
|
+
pass
|
|
404
|
+
|
|
405
|
+
def remove(self, key):
|
|
406
|
+
# type: (Object) -> Any
|
|
407
|
+
pass
|
|
408
|
+
|
|
409
|
+
def replace(self, *args):
|
|
410
|
+
# type: (*Any) -> Union[Any, bool]
|
|
411
|
+
pass
|
|
412
|
+
|
|
413
|
+
def replaceAll(self, function):
|
|
414
|
+
# type: (BiFunction) -> None
|
|
415
|
+
pass
|
|
416
|
+
|
|
417
|
+
def size(self):
|
|
418
|
+
# type: () -> int
|
|
419
|
+
raise NotImplementedError
|
|
420
|
+
|
|
421
|
+
def values(self):
|
|
422
|
+
# type: () -> Collection
|
|
423
|
+
raise NotImplementedError
|
|
424
|
+
|
|
425
|
+
|
|
426
|
+
class Spliterator(object):
|
|
427
|
+
CONCURRENT = None # type: int
|
|
428
|
+
DISTINCT = None # type: int
|
|
429
|
+
IMMUTABLE = None # type: int
|
|
430
|
+
NONNULL = None # type: int
|
|
431
|
+
ORDERED = None # type: int
|
|
432
|
+
SIZED = None # type: int
|
|
433
|
+
SORTED = None # type: int
|
|
434
|
+
SUBSIZED = None # type: int
|
|
435
|
+
|
|
436
|
+
def characteristics(self):
|
|
437
|
+
# type: () -> int
|
|
438
|
+
raise NotImplementedError
|
|
439
|
+
|
|
440
|
+
def estimateSize(self):
|
|
441
|
+
# type: () -> long
|
|
442
|
+
raise NotImplementedError
|
|
443
|
+
|
|
444
|
+
def forEachRemaining(self, action):
|
|
445
|
+
# type: (Consumer) -> None
|
|
446
|
+
pass
|
|
447
|
+
|
|
448
|
+
def getComparator(self):
|
|
449
|
+
# type: () -> Comparator
|
|
450
|
+
pass
|
|
451
|
+
|
|
452
|
+
def getExactSizeIfKnown(self):
|
|
453
|
+
# type: () -> long
|
|
454
|
+
pass
|
|
455
|
+
|
|
456
|
+
def hasCharacteristics(self, characteristics):
|
|
457
|
+
# type: (int) -> bool
|
|
458
|
+
return True
|
|
459
|
+
|
|
460
|
+
def tryAdvance(self, action):
|
|
461
|
+
# type: (Consumer) -> bool
|
|
462
|
+
raise NotImplementedError
|
|
463
|
+
|
|
464
|
+
def trySplit(self):
|
|
465
|
+
# type: () -> Spliterator
|
|
466
|
+
raise NotImplementedError
|
|
467
|
+
|
|
468
|
+
|
|
469
|
+
class Stream(object):
|
|
470
|
+
|
|
471
|
+
class Builder(Consumer):
|
|
472
|
+
def accept(self, t):
|
|
473
|
+
# type: (Any) -> None
|
|
474
|
+
raise NotImplementedError
|
|
475
|
+
|
|
476
|
+
def add(self, t):
|
|
477
|
+
# type: (Any) -> Stream.Builder
|
|
478
|
+
pass
|
|
479
|
+
|
|
480
|
+
def build(self):
|
|
481
|
+
# type: () -> Stream
|
|
482
|
+
raise NotImplementedError
|
|
483
|
+
|
|
484
|
+
@staticmethod
|
|
485
|
+
def builder():
|
|
486
|
+
# type: () -> Builder
|
|
487
|
+
pass
|
|
488
|
+
|
|
489
|
+
@staticmethod
|
|
490
|
+
def concat(a, b):
|
|
491
|
+
# type: (Stream, Stream) -> Stream
|
|
492
|
+
pass
|
|
493
|
+
|
|
494
|
+
@staticmethod
|
|
495
|
+
def empty():
|
|
496
|
+
# type: () -> Stream
|
|
497
|
+
pass
|
|
498
|
+
|
|
499
|
+
@staticmethod
|
|
500
|
+
def generate(s):
|
|
501
|
+
# type: (Supplier) -> Stream
|
|
502
|
+
pass
|
|
503
|
+
|
|
504
|
+
@staticmethod
|
|
505
|
+
def iterate(*args):
|
|
506
|
+
# type: (*Any) -> Stream
|
|
507
|
+
pass
|
|
508
|
+
|
|
509
|
+
@staticmethod
|
|
510
|
+
def of(*args):
|
|
511
|
+
# type: (*Any) -> Stream
|
|
512
|
+
pass
|
|
513
|
+
|
|
514
|
+
@staticmethod
|
|
515
|
+
def ofNullable(t):
|
|
516
|
+
# type: (Any) -> Stream
|
|
517
|
+
pass
|
|
518
|
+
|
|
519
|
+
|
|
520
|
+
class Arrays(Object):
|
|
521
|
+
@staticmethod
|
|
522
|
+
def asList(a):
|
|
523
|
+
# type: (Any) -> List[Any]
|
|
524
|
+
pass
|
|
525
|
+
|
|
526
|
+
@staticmethod
|
|
527
|
+
def binarySearch(*args, **kwargs):
|
|
528
|
+
# type: (*Any, **Any) -> int
|
|
529
|
+
pass
|
|
530
|
+
|
|
531
|
+
@staticmethod
|
|
532
|
+
def compare(*args, **kwargs):
|
|
533
|
+
# type: (*Any, **Any) -> int
|
|
534
|
+
pass
|
|
535
|
+
|
|
536
|
+
@staticmethod
|
|
537
|
+
def compareUnsigned(*args, **kwargs):
|
|
538
|
+
# type: (*Any, **Any) -> int
|
|
539
|
+
pass
|
|
540
|
+
|
|
541
|
+
@staticmethod
|
|
542
|
+
def copyOf(original, newLength, newType=None):
|
|
543
|
+
# type: (List[Any], int, Optional[Class]) -> List[Any]
|
|
544
|
+
pass
|
|
545
|
+
|
|
546
|
+
@staticmethod
|
|
547
|
+
def copyOfRange(original, from_, to, newType=None):
|
|
548
|
+
# type: (List[Any], int, int, Optional[Class]) -> List[Any]
|
|
549
|
+
pass
|
|
550
|
+
|
|
551
|
+
@staticmethod
|
|
552
|
+
def deepEquals(a1, a2):
|
|
553
|
+
# type: (List[Object], List[Object]) -> bool
|
|
554
|
+
return True
|
|
555
|
+
|
|
556
|
+
@staticmethod
|
|
557
|
+
def equals(*args, **kwargs):
|
|
558
|
+
# type: (*Any, **Any) -> bool
|
|
559
|
+
return True
|
|
560
|
+
|
|
561
|
+
@staticmethod
|
|
562
|
+
def fill(a, *args):
|
|
563
|
+
# type: (List[Any], *Any) -> None
|
|
564
|
+
pass
|
|
565
|
+
|
|
566
|
+
@staticmethod
|
|
567
|
+
def mismatch(*args, **kwargs):
|
|
568
|
+
# type: (*Any, **Any) -> int
|
|
569
|
+
pass
|
|
570
|
+
|
|
571
|
+
@staticmethod
|
|
572
|
+
def parallelPrefix(*args, **kwargs):
|
|
573
|
+
# type: (*Any, **Any) -> None
|
|
574
|
+
pass
|
|
575
|
+
|
|
576
|
+
@staticmethod
|
|
577
|
+
def parallelSetAll(*args, **kwargs):
|
|
578
|
+
# type: (*Any, **Any) -> None
|
|
579
|
+
pass
|
|
580
|
+
|
|
581
|
+
@staticmethod
|
|
582
|
+
def parallelSort(*args, **kwargs):
|
|
583
|
+
# type: (*Any, **Any) -> None
|
|
584
|
+
pass
|
|
585
|
+
|
|
586
|
+
@staticmethod
|
|
587
|
+
def setAll(*args, **kwargs):
|
|
588
|
+
# type: (*Any, **Any) -> None
|
|
589
|
+
pass
|
|
590
|
+
|
|
591
|
+
@staticmethod
|
|
592
|
+
def sort(*args, **kwargs):
|
|
593
|
+
# type: (*Any, **Any) -> None
|
|
594
|
+
pass
|
|
595
|
+
|
|
596
|
+
@staticmethod
|
|
597
|
+
def spliterator(
|
|
598
|
+
array, # type: Iterable[Any]
|
|
599
|
+
startInclusive=None, # type: Optional[int]
|
|
600
|
+
endExclusive=None, # type: Optional[int]
|
|
601
|
+
):
|
|
602
|
+
# type: (...) -> Spliterator
|
|
603
|
+
pass
|
|
604
|
+
|
|
605
|
+
@staticmethod
|
|
606
|
+
def stream(array, startInclusive=None, endExclusive=None):
|
|
607
|
+
# type: (Iterable[Any], Optional[int], Optional[int]) -> Stream
|
|
608
|
+
pass
|
|
609
|
+
|
|
610
|
+
|
|
611
|
+
class AbstractCollection(Object, Collection):
|
|
612
|
+
def add(self, e):
|
|
613
|
+
# type: (Any) -> bool
|
|
614
|
+
return True
|
|
615
|
+
|
|
616
|
+
def addAll(self, c):
|
|
617
|
+
# type: (Collection) -> bool
|
|
618
|
+
return True
|
|
619
|
+
|
|
620
|
+
def clear(self):
|
|
621
|
+
# type: () -> None
|
|
622
|
+
pass
|
|
623
|
+
|
|
624
|
+
def contains(self, o):
|
|
625
|
+
# type: (Object) -> bool
|
|
626
|
+
return True
|
|
627
|
+
|
|
628
|
+
def containsAll(self, c):
|
|
629
|
+
# type: (Collection) -> bool
|
|
630
|
+
return True
|
|
631
|
+
|
|
632
|
+
def isEmpty(self):
|
|
633
|
+
# type: () -> bool
|
|
634
|
+
return True
|
|
635
|
+
|
|
636
|
+
def iterator(self):
|
|
637
|
+
# type: () -> Iterator
|
|
638
|
+
pass
|
|
639
|
+
|
|
640
|
+
def remove(self, o):
|
|
641
|
+
# type: (Object) -> bool
|
|
642
|
+
return True
|
|
643
|
+
|
|
644
|
+
def removeAll(self, c):
|
|
645
|
+
# type: (Collection) -> bool
|
|
646
|
+
return True
|
|
647
|
+
|
|
648
|
+
def retainAll(self, v):
|
|
649
|
+
# type: (Collection) -> bool
|
|
650
|
+
return True
|
|
651
|
+
|
|
652
|
+
def size(self):
|
|
653
|
+
# type: () -> int
|
|
654
|
+
pass
|
|
655
|
+
|
|
656
|
+
|
|
657
|
+
class AbstractList(AbstractCollection):
|
|
658
|
+
def indexOf(self, o):
|
|
659
|
+
# type: (Object) -> int
|
|
660
|
+
pass
|
|
661
|
+
|
|
662
|
+
def lastIndexOf(self, o):
|
|
663
|
+
# type: (Object) -> int
|
|
664
|
+
pass
|
|
665
|
+
|
|
666
|
+
def listIterator(self, index=None):
|
|
667
|
+
# type: (Optional[int]) -> ListIterator
|
|
668
|
+
pass
|
|
669
|
+
|
|
670
|
+
def set(self, index, element):
|
|
671
|
+
# type: (int, Any) -> Any
|
|
672
|
+
pass
|
|
673
|
+
|
|
674
|
+
def subList(self, fromIndex, toIndex):
|
|
675
|
+
# type: (int, int) -> List[Any]
|
|
676
|
+
pass
|
|
677
|
+
|
|
678
|
+
|
|
679
|
+
class AbstractMap(Object, Map):
|
|
680
|
+
def clear(self):
|
|
681
|
+
# type: () -> None
|
|
682
|
+
pass
|
|
683
|
+
|
|
684
|
+
def containsKey(self, key):
|
|
685
|
+
# type: (Object) -> bool
|
|
686
|
+
return True
|
|
687
|
+
|
|
688
|
+
def containsValue(self, value):
|
|
689
|
+
# type: (Object) -> bool
|
|
690
|
+
return True
|
|
691
|
+
|
|
692
|
+
def entrySet(self):
|
|
693
|
+
# type: () -> Set[Map.Entry]
|
|
694
|
+
raise NotImplementedError
|
|
695
|
+
|
|
696
|
+
def get(self, key):
|
|
697
|
+
# type: (Object) -> Any
|
|
698
|
+
pass
|
|
699
|
+
|
|
700
|
+
def isEmpty(self):
|
|
701
|
+
# type: () -> bool
|
|
702
|
+
return True
|
|
703
|
+
|
|
704
|
+
def keySet(self):
|
|
705
|
+
# type: () -> Set[Any]
|
|
706
|
+
pass
|
|
707
|
+
|
|
708
|
+
def put(self, key, value):
|
|
709
|
+
# type: (Any, Any) -> Any
|
|
710
|
+
pass
|
|
711
|
+
|
|
712
|
+
def putAll(self, m):
|
|
713
|
+
# type: (Mapping[Any, Any]) -> None
|
|
714
|
+
pass
|
|
715
|
+
|
|
716
|
+
def remove(self, key):
|
|
717
|
+
# type: (Object) -> Any
|
|
718
|
+
pass
|
|
719
|
+
|
|
720
|
+
def size(self):
|
|
721
|
+
# type: () -> int
|
|
722
|
+
pass
|
|
723
|
+
|
|
724
|
+
def values(self):
|
|
725
|
+
# type: () -> Collection
|
|
726
|
+
pass
|
|
727
|
+
|
|
728
|
+
|
|
729
|
+
class ArrayList(AbstractList):
|
|
730
|
+
def __init__(self, *args):
|
|
731
|
+
# type: (*Any) -> None
|
|
732
|
+
super(ArrayList, self).__init__()
|
|
733
|
+
print(args)
|
|
734
|
+
|
|
735
|
+
def ensureCapacity(self, minCapacity):
|
|
736
|
+
# type: (int) -> None
|
|
737
|
+
pass
|
|
738
|
+
|
|
739
|
+
def get(self, index):
|
|
740
|
+
# type: (int) -> Any
|
|
741
|
+
pass
|
|
742
|
+
|
|
743
|
+
def trimToSize(self):
|
|
744
|
+
# type: () -> None
|
|
745
|
+
pass
|
|
746
|
+
|
|
747
|
+
|
|
748
|
+
class Base64(Object):
|
|
749
|
+
class Decoder(Object):
|
|
750
|
+
def decode(
|
|
751
|
+
self,
|
|
752
|
+
arg, # type: Union[str, unicode, ByteBuffer, List[int]]
|
|
753
|
+
dst=None, # type: Optional[List[int]]
|
|
754
|
+
):
|
|
755
|
+
# type: (...) -> Union[ByteBuffer, int, List[int]]
|
|
756
|
+
pass
|
|
757
|
+
|
|
758
|
+
def wrap(self, is_):
|
|
759
|
+
# type: (InputStream) -> InputStream
|
|
760
|
+
pass
|
|
761
|
+
|
|
762
|
+
class Encoder(Object):
|
|
763
|
+
def encode(
|
|
764
|
+
self,
|
|
765
|
+
arg, # type: Union[ByteBuffer, List[int]]
|
|
766
|
+
dst=None, # type: Optional[List[int]]
|
|
767
|
+
):
|
|
768
|
+
# type: (...) -> Union[ByteBuffer, int, List[int]]
|
|
769
|
+
pass
|
|
770
|
+
|
|
771
|
+
def encodeToString(self, src):
|
|
772
|
+
# type: (List[int]) -> Union[str, unicode]
|
|
773
|
+
pass
|
|
774
|
+
|
|
775
|
+
def withoutPadding(self):
|
|
776
|
+
# type: () -> Base64.Encoder
|
|
777
|
+
pass
|
|
778
|
+
|
|
779
|
+
def wrap(self, os):
|
|
780
|
+
# type: (OutputStream) -> OutputStream
|
|
781
|
+
pass
|
|
782
|
+
|
|
783
|
+
@staticmethod
|
|
784
|
+
def getDecoder():
|
|
785
|
+
# type: () -> Base64.Decoder
|
|
786
|
+
pass
|
|
787
|
+
|
|
788
|
+
@staticmethod
|
|
789
|
+
def getEncoder():
|
|
790
|
+
# type: () -> Base64.Encoder
|
|
791
|
+
pass
|
|
792
|
+
|
|
793
|
+
@staticmethod
|
|
794
|
+
def getMimeDecoder():
|
|
795
|
+
# type: () -> Base64.Decoder
|
|
796
|
+
pass
|
|
797
|
+
|
|
798
|
+
@staticmethod
|
|
799
|
+
def getMimeEncoder(lineLength=None, lineSeparator=None):
|
|
800
|
+
# type: (Optional[int], Optional[List[int]]) -> Base64.Encoder
|
|
801
|
+
pass
|
|
802
|
+
|
|
803
|
+
@staticmethod
|
|
804
|
+
def getUrlDecoder():
|
|
805
|
+
# type: () -> Base64.Decoder
|
|
806
|
+
pass
|
|
807
|
+
|
|
808
|
+
@staticmethod
|
|
809
|
+
def getUrlEncoder():
|
|
810
|
+
# type: () -> Base64.Encoder
|
|
811
|
+
pass
|
|
812
|
+
|
|
813
|
+
|
|
814
|
+
class Calendar(Object):
|
|
815
|
+
ALL_STYLES = None # type: int
|
|
816
|
+
AM = None # type: int
|
|
817
|
+
AM_PM = None # type: int
|
|
818
|
+
APRIL = None # type: int
|
|
819
|
+
AUGUST = None # type: int
|
|
820
|
+
DATE = None # type: int
|
|
821
|
+
DAY_OF_MONTH = None # type: int
|
|
822
|
+
DAY_OF_WEEK = None # type: int
|
|
823
|
+
DAY_OF_WEEK_IN_MONTH = None # type: int
|
|
824
|
+
DAY_OF_YEAR = None # type: int
|
|
825
|
+
DECEMBER = None # type: int
|
|
826
|
+
DST_OFFSET = None # type: int
|
|
827
|
+
ERA = None # type: int
|
|
828
|
+
FEBRUARY = None # type: int
|
|
829
|
+
FIELD_COUNT = None # type: int
|
|
830
|
+
FRIDAY = None # type: int
|
|
831
|
+
HOUR = None # type: int
|
|
832
|
+
HOUR_OF_DAY = None # type: int
|
|
833
|
+
JANUARY = None # type: int
|
|
834
|
+
JULY = None # type: int
|
|
835
|
+
JUNE = None # type: int
|
|
836
|
+
LONG = None # type: int
|
|
837
|
+
LONG_FORMAT = None # type: int
|
|
838
|
+
LONG_STANDALONE = None # type: int
|
|
839
|
+
MARCH = None # type: int
|
|
840
|
+
MAY = None # type: int
|
|
841
|
+
MILLISECOND = None # type: int
|
|
842
|
+
MINUTE = None # type: int
|
|
843
|
+
MONDAY = None # type: int
|
|
844
|
+
MONTH = None # type: int
|
|
845
|
+
NARROW_FORMAT = None # type: int
|
|
846
|
+
NARROW_STANDALONE = None # type: int
|
|
847
|
+
NOVEMBER = None # type: int
|
|
848
|
+
OCTOBER = None # type: int
|
|
849
|
+
PM = None # type: int
|
|
850
|
+
SATURDAY = None # type: int
|
|
851
|
+
SECOND = None # type: int
|
|
852
|
+
SEPTEMBER = None # type: int
|
|
853
|
+
SHORT = None # type: int
|
|
854
|
+
SHORT_FORMAT = None # type: int
|
|
855
|
+
SHORT_STANDALONE = None # type: int
|
|
856
|
+
SUNDAY = None # type: int
|
|
857
|
+
THURSDAY = None # type: int
|
|
858
|
+
TUESDAY = None # type: int
|
|
859
|
+
UNDECIMBER = None # type: int
|
|
860
|
+
WEDNESDAY = None # type: int
|
|
861
|
+
WEEK_OF_MONTH = None # type: int
|
|
862
|
+
WEEK_OF_YEAR = None # type: int
|
|
863
|
+
YEAR = None # type: int
|
|
864
|
+
ZONE_OFFSET = None # type: int
|
|
865
|
+
|
|
866
|
+
def add(self, field, amount):
|
|
867
|
+
# type: (int, int) -> None
|
|
868
|
+
pass
|
|
869
|
+
|
|
870
|
+
def after(self, when):
|
|
871
|
+
# type: (Object) -> bool
|
|
872
|
+
return True
|
|
873
|
+
|
|
874
|
+
def before(self, when):
|
|
875
|
+
# type: (Object) -> bool
|
|
876
|
+
return True
|
|
877
|
+
|
|
878
|
+
def clear(self, field=None):
|
|
879
|
+
# type: (Optional[int]) -> None
|
|
880
|
+
pass
|
|
881
|
+
|
|
882
|
+
def clone(self):
|
|
883
|
+
# type: () -> Object
|
|
884
|
+
pass
|
|
885
|
+
|
|
886
|
+
def compareTo(self, anotherCalendar):
|
|
887
|
+
# type: (Calendar) -> int
|
|
888
|
+
pass
|
|
889
|
+
|
|
890
|
+
def get(self, field):
|
|
891
|
+
# type: (int) -> int
|
|
892
|
+
pass
|
|
893
|
+
|
|
894
|
+
def getActualMaximum(self, field):
|
|
895
|
+
# type: (int) -> int
|
|
896
|
+
pass
|
|
897
|
+
|
|
898
|
+
def getActualMinimum(self, field):
|
|
899
|
+
# type: (int) -> int
|
|
900
|
+
pass
|
|
901
|
+
|
|
902
|
+
@staticmethod
|
|
903
|
+
def getAvailableCalendarTypes():
|
|
904
|
+
# type: () -> Set[Union[str, unicode]]
|
|
905
|
+
pass
|
|
906
|
+
|
|
907
|
+
@staticmethod
|
|
908
|
+
def getAvailableLocales():
|
|
909
|
+
# type: () -> List[Locale]
|
|
910
|
+
pass
|
|
911
|
+
|
|
912
|
+
def getCalendarType(self):
|
|
913
|
+
# type: () -> Union[str, unicode]
|
|
914
|
+
pass
|
|
915
|
+
|
|
916
|
+
def getDisplayName(self, field, style, locale):
|
|
917
|
+
# type: (int, int, Locale) -> Union[str, unicode]
|
|
918
|
+
pass
|
|
919
|
+
|
|
920
|
+
def getDisplayNames(self, field, style, locale):
|
|
921
|
+
# type: (int, int, Locale) -> Dict[Union[str, unicode], int]
|
|
922
|
+
pass
|
|
923
|
+
|
|
924
|
+
def getFirstDayOfWeek(self):
|
|
925
|
+
# type: () -> int
|
|
926
|
+
pass
|
|
927
|
+
|
|
928
|
+
def getGreatestMinimum(self, field):
|
|
929
|
+
# type: (int) -> int
|
|
930
|
+
pass
|
|
931
|
+
|
|
932
|
+
@staticmethod
|
|
933
|
+
def getInstance(*args):
|
|
934
|
+
# type: (*Any) -> Calendar
|
|
935
|
+
pass
|
|
936
|
+
|
|
937
|
+
def getLeastMaximum(self, field):
|
|
938
|
+
# type: (int) -> int
|
|
939
|
+
pass
|
|
940
|
+
|
|
941
|
+
def getMaximum(self, field):
|
|
942
|
+
# type: (int) -> int
|
|
943
|
+
pass
|
|
944
|
+
|
|
945
|
+
def getMinimalDaysInFirstWeek(self):
|
|
946
|
+
# type: () -> int
|
|
947
|
+
pass
|
|
948
|
+
|
|
949
|
+
def getMinimum(self, field):
|
|
950
|
+
# type: (int) -> int
|
|
951
|
+
pass
|
|
952
|
+
|
|
953
|
+
def getTime(self):
|
|
954
|
+
# type: () -> Date
|
|
955
|
+
pass
|
|
956
|
+
|
|
957
|
+
def getTimeInMillis(self):
|
|
958
|
+
# type: () -> long
|
|
959
|
+
pass
|
|
960
|
+
|
|
961
|
+
def getTimeZone(self):
|
|
962
|
+
# type: () -> TimeZone
|
|
963
|
+
pass
|
|
964
|
+
|
|
965
|
+
def getWeeksInWeekYear(self):
|
|
966
|
+
# type: () -> int
|
|
967
|
+
pass
|
|
968
|
+
|
|
969
|
+
def getWeekYear(self):
|
|
970
|
+
# type: () -> int
|
|
971
|
+
pass
|
|
972
|
+
|
|
973
|
+
def isLenient(self):
|
|
974
|
+
# type: () -> bool
|
|
975
|
+
return True
|
|
976
|
+
|
|
977
|
+
def isSet(self, field):
|
|
978
|
+
# type: (int) -> bool
|
|
979
|
+
return True
|
|
980
|
+
|
|
981
|
+
def isWeekDateSUpported(self):
|
|
982
|
+
# type: () -> bool
|
|
983
|
+
return True
|
|
984
|
+
|
|
985
|
+
def roll(self, field, amount):
|
|
986
|
+
# type: (int, int) -> None
|
|
987
|
+
pass
|
|
988
|
+
|
|
989
|
+
def set(self, *args):
|
|
990
|
+
# type: (*int) -> None
|
|
991
|
+
pass
|
|
992
|
+
|
|
993
|
+
def setFirstDayOfWeek(self, value):
|
|
994
|
+
# type: (int) -> None
|
|
995
|
+
pass
|
|
996
|
+
|
|
997
|
+
def setLenient(self, lenient):
|
|
998
|
+
# type: (bool) -> None
|
|
999
|
+
pass
|
|
1000
|
+
|
|
1001
|
+
def setMinimalDaysInFirstWeek(self, value):
|
|
1002
|
+
# type: (int) -> None
|
|
1003
|
+
pass
|
|
1004
|
+
|
|
1005
|
+
def setTime(self, date):
|
|
1006
|
+
# type: (Date) -> None
|
|
1007
|
+
pass
|
|
1008
|
+
|
|
1009
|
+
def setTimeInMillis(self, millis):
|
|
1010
|
+
# type: (long) -> None
|
|
1011
|
+
pass
|
|
1012
|
+
|
|
1013
|
+
def setTimeZone(self, value):
|
|
1014
|
+
# type: (TimeZone) -> None
|
|
1015
|
+
pass
|
|
1016
|
+
|
|
1017
|
+
def setWeekDate(self, weekYear, weekOfYear, dayOfWeek):
|
|
1018
|
+
# type: (int, int, int) -> None
|
|
1019
|
+
pass
|
|
1020
|
+
|
|
1021
|
+
def toInstant(self):
|
|
1022
|
+
# type: () -> Instant
|
|
1023
|
+
pass
|
|
1024
|
+
|
|
1025
|
+
|
|
1026
|
+
class ConcurrentModificationException(RuntimeException):
|
|
1027
|
+
def __init__(self, message=None, cause=None):
|
|
1028
|
+
# type: (Optional[str], Optional[Throwable]) -> None
|
|
1029
|
+
super(ConcurrentModificationException, self).__init__(message, cause)
|
|
1030
|
+
|
|
1031
|
+
|
|
1032
|
+
class Currency(Object):
|
|
1033
|
+
@staticmethod
|
|
1034
|
+
def getAvailableCurrencies():
|
|
1035
|
+
# type: () -> Set[Currency]
|
|
1036
|
+
pass
|
|
1037
|
+
|
|
1038
|
+
def getCurrencyCode(self):
|
|
1039
|
+
# type: () -> Union[str, unicode]
|
|
1040
|
+
pass
|
|
1041
|
+
|
|
1042
|
+
def getDisplayName(self, locale=None):
|
|
1043
|
+
# type: (Optional[Locale]) -> Union[str, unicode]
|
|
1044
|
+
pass
|
|
1045
|
+
|
|
1046
|
+
@staticmethod
|
|
1047
|
+
def getInstance(arg):
|
|
1048
|
+
# type: (Union[str, unicode, Locale]) -> Currency
|
|
1049
|
+
pass
|
|
1050
|
+
|
|
1051
|
+
def getNumericCode(self):
|
|
1052
|
+
# type: () -> int
|
|
1053
|
+
pass
|
|
1054
|
+
|
|
1055
|
+
def getNumericCodeAsString(self):
|
|
1056
|
+
# type: () -> Union[str, unicode]
|
|
1057
|
+
pass
|
|
1058
|
+
|
|
1059
|
+
def getSymbol(self, locale=None):
|
|
1060
|
+
# type: (Optional[Locale]) -> Union[str, unicode]
|
|
1061
|
+
pass
|
|
1062
|
+
|
|
1063
|
+
|
|
1064
|
+
class Date(Object):
|
|
1065
|
+
"""The class Date represents a specific instant in time, with
|
|
1066
|
+
millisecond precision.
|
|
1067
|
+
"""
|
|
1068
|
+
|
|
1069
|
+
def __init__(self, date=None):
|
|
1070
|
+
# type: (Optional[long]) -> None
|
|
1071
|
+
super(Date, self).__init__()
|
|
1072
|
+
self._date = date
|
|
1073
|
+
|
|
1074
|
+
def after(self, when):
|
|
1075
|
+
# type: (Date) -> bool
|
|
1076
|
+
return True
|
|
1077
|
+
|
|
1078
|
+
def before(self, when):
|
|
1079
|
+
# type: (Date) -> bool
|
|
1080
|
+
return True
|
|
1081
|
+
|
|
1082
|
+
def compareTo(self, anotherDate):
|
|
1083
|
+
# type: (Date) -> int
|
|
1084
|
+
pass
|
|
1085
|
+
|
|
1086
|
+
def getTime(self):
|
|
1087
|
+
# type: () -> long
|
|
1088
|
+
pass
|
|
1089
|
+
|
|
1090
|
+
def setTime(self, time):
|
|
1091
|
+
# type: (long) -> None
|
|
1092
|
+
pass
|
|
1093
|
+
|
|
1094
|
+
|
|
1095
|
+
class Dictionary(Object):
|
|
1096
|
+
def __init__(self):
|
|
1097
|
+
# type: () -> None
|
|
1098
|
+
super(Dictionary, self).__init__()
|
|
1099
|
+
|
|
1100
|
+
def elements(self):
|
|
1101
|
+
# type: () -> Enumeration
|
|
1102
|
+
raise NotImplementedError
|
|
1103
|
+
|
|
1104
|
+
def get(self, key):
|
|
1105
|
+
# type: (Object) -> Any
|
|
1106
|
+
raise NotImplementedError
|
|
1107
|
+
|
|
1108
|
+
def isEmpty(self):
|
|
1109
|
+
# type: () -> bool
|
|
1110
|
+
raise NotImplementedError
|
|
1111
|
+
|
|
1112
|
+
def keys(self):
|
|
1113
|
+
# type: () -> Enumeration
|
|
1114
|
+
raise NotImplementedError
|
|
1115
|
+
|
|
1116
|
+
def put(self, key, value):
|
|
1117
|
+
# type: (Any, Any) -> Any
|
|
1118
|
+
raise NotImplementedError
|
|
1119
|
+
|
|
1120
|
+
def remove(self, key):
|
|
1121
|
+
# type: (Object) -> Any
|
|
1122
|
+
raise NotImplementedError
|
|
1123
|
+
|
|
1124
|
+
def size(self):
|
|
1125
|
+
# type: () -> int
|
|
1126
|
+
raise NotImplementedError
|
|
1127
|
+
|
|
1128
|
+
|
|
1129
|
+
class EventObject(Object):
|
|
1130
|
+
"""The root class from which all event state objects shall be
|
|
1131
|
+
derived.
|
|
1132
|
+
|
|
1133
|
+
All Events are constructed with a reference to the object, the
|
|
1134
|
+
"source", that is logically deemed to be the object upon which the
|
|
1135
|
+
Event in question initially occurred upon.
|
|
1136
|
+
"""
|
|
1137
|
+
|
|
1138
|
+
_source = None # type: Object
|
|
1139
|
+
|
|
1140
|
+
def __init__(self, source):
|
|
1141
|
+
# type: (Object) -> None
|
|
1142
|
+
super(EventObject, self).__init__()
|
|
1143
|
+
self._source = source
|
|
1144
|
+
|
|
1145
|
+
def getSource(self):
|
|
1146
|
+
# type: () -> Object
|
|
1147
|
+
return self._source
|
|
1148
|
+
|
|
1149
|
+
|
|
1150
|
+
class GregorianCalendar(Calendar):
|
|
1151
|
+
AD = None # type: int
|
|
1152
|
+
BC = None # type: int
|
|
1153
|
+
|
|
1154
|
+
def __init__(self, *args):
|
|
1155
|
+
# type: (*Any) -> None
|
|
1156
|
+
super(GregorianCalendar, self).__init__()
|
|
1157
|
+
print(args)
|
|
1158
|
+
|
|
1159
|
+
def getGregorianChange(self):
|
|
1160
|
+
# type: () -> Date
|
|
1161
|
+
pass
|
|
1162
|
+
|
|
1163
|
+
def isLeapYear(self, year):
|
|
1164
|
+
# type: (int) -> bool
|
|
1165
|
+
return True
|
|
1166
|
+
|
|
1167
|
+
def setGregorianChange(self, date):
|
|
1168
|
+
# type: (Date) -> None
|
|
1169
|
+
pass
|
|
1170
|
+
|
|
1171
|
+
def toZonedDatetime(self):
|
|
1172
|
+
# type: () -> ZonedDateTime
|
|
1173
|
+
pass
|
|
1174
|
+
|
|
1175
|
+
|
|
1176
|
+
class HashMap(AbstractMap, Map):
|
|
1177
|
+
def __init__(self, *args):
|
|
1178
|
+
# type: (*Any) -> None
|
|
1179
|
+
super(HashMap, self).__init__()
|
|
1180
|
+
print(args)
|
|
1181
|
+
|
|
1182
|
+
def entrySet(self):
|
|
1183
|
+
# type: () -> Set[Map.Entry]
|
|
1184
|
+
pass
|
|
1185
|
+
|
|
1186
|
+
|
|
1187
|
+
class Hashtable(Dictionary, Map):
|
|
1188
|
+
def __init__(self, *args):
|
|
1189
|
+
# type: (*Any) -> None
|
|
1190
|
+
super(Hashtable, self).__init__()
|
|
1191
|
+
print(args)
|
|
1192
|
+
|
|
1193
|
+
def clear(self):
|
|
1194
|
+
# type: () -> None
|
|
1195
|
+
pass
|
|
1196
|
+
|
|
1197
|
+
def clone(self):
|
|
1198
|
+
# type: () -> Object
|
|
1199
|
+
pass
|
|
1200
|
+
|
|
1201
|
+
def contains(self, value):
|
|
1202
|
+
# type: (Object) -> bool
|
|
1203
|
+
return True
|
|
1204
|
+
|
|
1205
|
+
def containsKey(self, key):
|
|
1206
|
+
# type: (Object) -> bool
|
|
1207
|
+
return True
|
|
1208
|
+
|
|
1209
|
+
def containsValue(self, value):
|
|
1210
|
+
# type: (Object) -> bool
|
|
1211
|
+
return True
|
|
1212
|
+
|
|
1213
|
+
def elements(self):
|
|
1214
|
+
# type: () -> Enumeration
|
|
1215
|
+
pass
|
|
1216
|
+
|
|
1217
|
+
def entrySet(self):
|
|
1218
|
+
# type: () -> Set[Map.Entry]
|
|
1219
|
+
pass
|
|
1220
|
+
|
|
1221
|
+
def get(self, key):
|
|
1222
|
+
# type: (Object) -> Any
|
|
1223
|
+
pass
|
|
1224
|
+
|
|
1225
|
+
def isEmpty(self):
|
|
1226
|
+
# type: () -> bool
|
|
1227
|
+
return True
|
|
1228
|
+
|
|
1229
|
+
def keySet(self):
|
|
1230
|
+
# type: () -> Set[Any]
|
|
1231
|
+
pass
|
|
1232
|
+
|
|
1233
|
+
def keys(self):
|
|
1234
|
+
# type: () -> Enumeration
|
|
1235
|
+
pass
|
|
1236
|
+
|
|
1237
|
+
def put(self, key, value):
|
|
1238
|
+
# type: (Any, Any) -> Any
|
|
1239
|
+
pass
|
|
1240
|
+
|
|
1241
|
+
def putAll(self, m):
|
|
1242
|
+
# type: (Mapping[Any, Any]) -> None
|
|
1243
|
+
pass
|
|
1244
|
+
|
|
1245
|
+
def remove(self, key):
|
|
1246
|
+
# type: (Object) -> Any
|
|
1247
|
+
pass
|
|
1248
|
+
|
|
1249
|
+
def size(self):
|
|
1250
|
+
# type: () -> int
|
|
1251
|
+
pass
|
|
1252
|
+
|
|
1253
|
+
def values(self):
|
|
1254
|
+
# type: () -> Collection
|
|
1255
|
+
pass
|
|
1256
|
+
|
|
1257
|
+
|
|
1258
|
+
class Locale(Object):
|
|
1259
|
+
"""A Locale object represents a specific geographical, political, or
|
|
1260
|
+
cultural region.
|
|
1261
|
+
|
|
1262
|
+
An operation that requires a Locale to perform its task is called
|
|
1263
|
+
locale-sensitive and uses the Locale to tailor information for the
|
|
1264
|
+
user. For example, displaying a number is a locale-sensitive
|
|
1265
|
+
operation; the number should be formatted according to the customs
|
|
1266
|
+
and conventions of the user's native country, region, or culture.
|
|
1267
|
+
"""
|
|
1268
|
+
|
|
1269
|
+
country = None # type: Optional[str]
|
|
1270
|
+
language = None # type: str
|
|
1271
|
+
variant = None # type: Optional[str]
|
|
1272
|
+
|
|
1273
|
+
# Class attribute constants
|
|
1274
|
+
CANADA = None # type: Locale
|
|
1275
|
+
CANADA_FRENCH = None # type: Locale
|
|
1276
|
+
CHINA = None # type: Locale
|
|
1277
|
+
CHINESE = None # type: Locale
|
|
1278
|
+
ENGLISH = None # type: Locale
|
|
1279
|
+
FRANCE = None # type: Locale
|
|
1280
|
+
FRENCH = None # type: Locale
|
|
1281
|
+
GERMAN = None # type: Locale
|
|
1282
|
+
GERMANY = None # type: Locale
|
|
1283
|
+
ITALIAN = None # type: Locale
|
|
1284
|
+
ITALY = None # type: Locale
|
|
1285
|
+
JAPAN = None # type: Locale
|
|
1286
|
+
JAPANESE = None # type: Locale
|
|
1287
|
+
KOREA = None # type: Locale
|
|
1288
|
+
KOREAN = None # type: Locale
|
|
1289
|
+
PRC = None # type: Locale
|
|
1290
|
+
SIMPLIFIED_CHINESE = None # type: Locale
|
|
1291
|
+
TAIWAN = None # type: Locale
|
|
1292
|
+
TRADITIONAL_CHINESE = None # type: Locale
|
|
1293
|
+
UK = None # type: Locale
|
|
1294
|
+
US = None # type: Locale
|
|
1295
|
+
|
|
1296
|
+
def __init__(self, language, country=None, variant=None):
|
|
1297
|
+
# type: (str, Optional[str], Optional[str]) -> None
|
|
1298
|
+
super(Locale, self).__init__()
|
|
1299
|
+
self.language = language
|
|
1300
|
+
self.country = country
|
|
1301
|
+
self.variant = variant
|
|
1302
|
+
|
|
1303
|
+
def __str__(self):
|
|
1304
|
+
# type: () -> str
|
|
1305
|
+
ret = self.language
|
|
1306
|
+
if self.country:
|
|
1307
|
+
ret += "_{}".format(self.country)
|
|
1308
|
+
if self.variant:
|
|
1309
|
+
ret += "_{}".format(self.variant)
|
|
1310
|
+
return ret
|
|
1311
|
+
|
|
1312
|
+
def __repr__(self):
|
|
1313
|
+
# type: () -> str
|
|
1314
|
+
return "{!r}".format(self.__str__())
|
|
1315
|
+
|
|
1316
|
+
|
|
1317
|
+
Locale.CANADA = Locale("en", "CA")
|
|
1318
|
+
Locale.CANADA_FRENCH = Locale("fr", "CA")
|
|
1319
|
+
Locale.CHINA = Locale("zh", "CN")
|
|
1320
|
+
Locale.CHINESE = Locale("zh")
|
|
1321
|
+
Locale.ENGLISH = Locale("en")
|
|
1322
|
+
Locale.FRANCE = Locale("fr", "FR")
|
|
1323
|
+
Locale.FRENCH = Locale("fr")
|
|
1324
|
+
Locale.GERMAN = Locale("de")
|
|
1325
|
+
Locale.GERMANY = Locale("de", "DE")
|
|
1326
|
+
Locale.ITALIAN = Locale("it")
|
|
1327
|
+
Locale.ITALY = Locale("it", "IT")
|
|
1328
|
+
Locale.JAPAN = Locale("ja", "JP")
|
|
1329
|
+
Locale.JAPANESE = Locale("ja")
|
|
1330
|
+
Locale.KOREA = Locale("ko", "KR")
|
|
1331
|
+
Locale.KOREAN = Locale("ko")
|
|
1332
|
+
Locale.PRC = Locale("zh", "CN")
|
|
1333
|
+
Locale.SIMPLIFIED_CHINESE = Locale("zh", "CN")
|
|
1334
|
+
Locale.TAIWAN = Locale("zh", "TW")
|
|
1335
|
+
Locale.TRADITIONAL_CHINESE = Locale("zh", "TW")
|
|
1336
|
+
Locale.UK = Locale("en", "GB")
|
|
1337
|
+
Locale.US = Locale("en", "US")
|
|
1338
|
+
|
|
1339
|
+
|
|
1340
|
+
class Properties(Hashtable):
|
|
1341
|
+
def __init__(self, *args):
|
|
1342
|
+
# type: (*Any) -> None
|
|
1343
|
+
super(Properties, self).__init__()
|
|
1344
|
+
|
|
1345
|
+
|
|
1346
|
+
class TimeZone(Object):
|
|
1347
|
+
LONG = None # type: int
|
|
1348
|
+
SHORT = None # type: int
|
|
1349
|
+
|
|
1350
|
+
def __init__(self):
|
|
1351
|
+
# type: () -> None
|
|
1352
|
+
super(TimeZone, self).__init__()
|
|
1353
|
+
|
|
1354
|
+
def clone(self):
|
|
1355
|
+
# type: () -> Object
|
|
1356
|
+
pass
|
|
1357
|
+
|
|
1358
|
+
@staticmethod
|
|
1359
|
+
def getAvailableIDs(rawOffset=None):
|
|
1360
|
+
# type: (Optional[int]) -> List[Union[str, unicode]]
|
|
1361
|
+
pass
|
|
1362
|
+
|
|
1363
|
+
@staticmethod
|
|
1364
|
+
def getDefault():
|
|
1365
|
+
# type: () -> TimeZone
|
|
1366
|
+
pass
|
|
1367
|
+
|
|
1368
|
+
def getDisplayName(self, *args):
|
|
1369
|
+
# type: (*Any) -> Union[str, unicode]
|
|
1370
|
+
pass
|
|
1371
|
+
|
|
1372
|
+
def getDSTSavings(self):
|
|
1373
|
+
# type: () -> int
|
|
1374
|
+
pass
|
|
1375
|
+
|
|
1376
|
+
def getID(self):
|
|
1377
|
+
# type: () -> Union[str, unicode]
|
|
1378
|
+
pass
|
|
1379
|
+
|
|
1380
|
+
def getOffset(self, *args):
|
|
1381
|
+
# type: (*Any) -> int
|
|
1382
|
+
pass
|
|
1383
|
+
|
|
1384
|
+
def getRawOffset(self):
|
|
1385
|
+
# type: () -> int
|
|
1386
|
+
raise NotImplementedError
|
|
1387
|
+
|
|
1388
|
+
@staticmethod
|
|
1389
|
+
def getTimeZone(arg):
|
|
1390
|
+
# type: (Union[str, unicode, ZoneId]) -> TimeZone
|
|
1391
|
+
pass
|
|
1392
|
+
|
|
1393
|
+
def hasSameRules(self, other):
|
|
1394
|
+
# type: (TimeZone) -> bool
|
|
1395
|
+
return True
|
|
1396
|
+
|
|
1397
|
+
def isDaylightTime(self, date):
|
|
1398
|
+
# type: (Date) -> bool
|
|
1399
|
+
raise NotImplementedError
|
|
1400
|
+
|
|
1401
|
+
def observesDaylightTime(self):
|
|
1402
|
+
# type: () -> bool
|
|
1403
|
+
return True
|
|
1404
|
+
|
|
1405
|
+
@staticmethod
|
|
1406
|
+
def setDefault(zone):
|
|
1407
|
+
# type: (TimeZone) -> None
|
|
1408
|
+
pass
|
|
1409
|
+
|
|
1410
|
+
def setID(self, ID):
|
|
1411
|
+
# type: (Union[str, unicode]) -> None
|
|
1412
|
+
pass
|
|
1413
|
+
|
|
1414
|
+
def setRawOffset(self, offsetMillis):
|
|
1415
|
+
# type: (int) -> None
|
|
1416
|
+
raise NotImplementedError
|
|
1417
|
+
|
|
1418
|
+
def toZoneId(self):
|
|
1419
|
+
# type: () -> ZoneId
|
|
1420
|
+
pass
|
|
1421
|
+
|
|
1422
|
+
def useDaylightTime(self):
|
|
1423
|
+
# type: () -> bool
|
|
1424
|
+
raise NotImplementedError
|
|
1425
|
+
|
|
1426
|
+
|
|
1427
|
+
class UUID(Object):
|
|
1428
|
+
def __init__(self, mostSigBits, leastSigBits):
|
|
1429
|
+
# type: (long, long) -> None
|
|
1430
|
+
super(UUID, self).__init__()
|
|
1431
|
+
self._leastSigbits = leastSigBits
|
|
1432
|
+
self._mostSigBits = mostSigBits
|
|
1433
|
+
|
|
1434
|
+
def clockSequence(self):
|
|
1435
|
+
# type: () -> int
|
|
1436
|
+
pass
|
|
1437
|
+
|
|
1438
|
+
def compareTo(self, val):
|
|
1439
|
+
# type: (UUID) -> int
|
|
1440
|
+
pass
|
|
1441
|
+
|
|
1442
|
+
@staticmethod
|
|
1443
|
+
def fromString(name):
|
|
1444
|
+
# type: (Union[str, unicode]) -> UUID
|
|
1445
|
+
pass
|
|
1446
|
+
|
|
1447
|
+
def getLeastSignificantBits(self):
|
|
1448
|
+
# type: () -> long
|
|
1449
|
+
return self._leastSigbits
|
|
1450
|
+
|
|
1451
|
+
def getMostSignificantBits(self):
|
|
1452
|
+
# type: () -> long
|
|
1453
|
+
return self._mostSigBits
|
|
1454
|
+
|
|
1455
|
+
@staticmethod
|
|
1456
|
+
def nameUUIDFromBytes(name):
|
|
1457
|
+
# type: (bytearray) -> UUID
|
|
1458
|
+
pass
|
|
1459
|
+
|
|
1460
|
+
def node(self):
|
|
1461
|
+
# type: () -> long
|
|
1462
|
+
pass
|
|
1463
|
+
|
|
1464
|
+
@staticmethod
|
|
1465
|
+
def randomUUID():
|
|
1466
|
+
# type: () -> UUID
|
|
1467
|
+
pass
|
|
1468
|
+
|
|
1469
|
+
def timestamp(self):
|
|
1470
|
+
# type: () -> long
|
|
1471
|
+
pass
|
|
1472
|
+
|
|
1473
|
+
def variant(self):
|
|
1474
|
+
# type: () -> int
|
|
1475
|
+
pass
|
|
1476
|
+
|
|
1477
|
+
def version(self):
|
|
1478
|
+
# type: () -> int
|
|
1479
|
+
pass
|