/
Platform.scala
146 lines (134 loc) · 7.08 KB
/
Platform.scala
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
134
135
136
137
138
139
140
141
142
143
144
145
146
/*
* Scala (https://www.scala-lang.org)
*
* Copyright EPFL and Lightbend, Inc.
*
* Licensed under Apache License 2.0
* (http://www.apache.org/licenses/LICENSE-2.0).
*
* See the NOTICE file distributed with this work for
* additional information regarding copyright ownership.
*/
package scala
package compat
@deprecated("Will be removed in the future.", since = "2.13.0")
object Platform {
/** Thrown when a stack overflow occurs because a method or function recurses too deeply.
*
* On the JVM, this is a type alias for `java.lang.StackOverflowError`, which itself extends `java.lang.Error`.
* The same rules apply to catching a `java.lang.Error` as for Java, that it indicates a serious problem that a reasonable application should not try and catch.
*/
@deprecated("Use `java.lang.StackOverflowError` instead.", since = "2.13.0")
type StackOverflowError = java.lang.StackOverflowError
/** This is a type alias for `java.util.ConcurrentModificationException`,
* which may be thrown by methods that detect an invalid modification of an object.
* For example, many common collection types do not allow modifying a collection
* while it is being iterated over.
*/
@deprecated("Use `java.util.ConcurrentModificationException` instead.", since = "2.13.0")
type ConcurrentModificationException = java.util.ConcurrentModificationException
/** Copies `length` elements of array `src` starting at position `srcPos` to the
* array `dest` starting at position `destPos`. If `src`==`dest`, the copying will
* behave as if the elements copied from `src` were first copied to a temporary
* array before being copied back into the array at the destination positions.
*
* @param src A non-null array as source for the copy.
* @param srcPos The starting index in the source array.
* @param dest A non-null array as destination for the copy.
* @param destPos The starting index in the destination array.
* @param length The number of elements to be copied.
* @throws java.lang.NullPointerException If either `src` or `dest` are `null`.
* @throws java.lang.ArrayStoreException If either `src` or `dest` are not of type
* [java.lang.Array]; or if the element type of `src` is not
* compatible with that of `dest`.
* @throws java.lang.IndexOutOfBoundsException If either `srcPos` or `destPos` are
* outside of the bounds of their respective arrays; or if `length`
* is negative; or if there are less than `length` elements available
* after `srcPos` or `destPos` in `src` and `dest` respectively.
*/
@inline
@deprecated("Use `java.lang.System#arraycopy` instead.", since = "2.13.0")
def arraycopy(src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int): Unit = {
System.arraycopy(src, srcPos, dest, destPos, length)
}
/** Creates a new array of the specified type and given length.
*
* Note that if `elemClass` is a subclass of [[scala.AnyVal]] then the returned value is an Array of the corresponding java primitive type.
* For example, the following code `scala.compat.Platform.createArray(classOf[Int], 4)` returns an array of the java primitive type `int`.
*
* For a [[scala.AnyVal]] array, the values of the array are set to 0 for ''numeric value types'' ([[scala.Double]], [[scala.Float]], [[scala.Long]], [[scala.Int]], [[scala.Char]],
* [[scala.Short]], and [[scala.Byte]]), and `false` for [[scala.Boolean]]. Creation of an array of type [[scala.Unit]] is not possible.
*
* For subclasses of [[scala.AnyRef]], the values of the array are set to `null`.
*
* The caller must cast the returned value to the correct type.
*
* @example {{{
* val a = scala.compat.Platform.createArray(classOf[Int], 4).asInstanceOf[Array[Int]] // returns Array[Int](0, 0, 0, 0)
* }}}
*
* @param elemClass the `Class` object of the component type of the array
* @param length the length of the new array.
* @return an array of the given component type as an `AnyRef`.
* @throws java.lang.NullPointerException If `elemClass` is `null`.
* @throws java.lang.IllegalArgumentException if componentType is [[scala.Unit]] or `java.lang.Void.TYPE`
* @throws java.lang.NegativeArraySizeException if the specified length is negative
*/
@inline
@deprecated("Use `java.lang.reflect.Array#newInstance` instead.", since = "2.13.0")
def createArray(elemClass: Class[_], length: Int): AnyRef =
java.lang.reflect.Array.newInstance(elemClass, length)
/** Assigns the value of 0 to each element in the array.
* @param arr A non-null Array[Int].
* @throws java.lang.NullPointerException If `arr` is `null`.
*/
@inline
@deprecated("Use `java.util.Arrays#fill` instead.", since = "2.13.0")
def arrayclear(arr: Array[Int]): Unit = { java.util.Arrays.fill(arr, 0) }
/** Returns the `Class` object associated with the class or interface with the given string name using the current `ClassLoader`.
* On the JVM, invoking this method is equivalent to: `java.lang.Class.forName(name)`
*
* For more information, please see the Java documentation for [[java.lang.Class]].
*
* @param name the fully qualified name of the desired class.
* @return the `Class` object for the class with the specified name.
* @throws java.lang.LinkageError if the linkage fails
* @throws java.lang.ExceptionInInitializerError if the initialization provoked by this method fails
* @throws java.lang.ClassNotFoundException if the class cannot be located
* @example {{{
* val a = scala.compat.Platform.getClassForName("java.lang.Integer") // returns the Class[_] for java.lang.Integer
* }}}
*/
@inline
@deprecated("Use `java.lang.Class#forName` instead.", since = "2.13.0")
def getClassForName(name: String): Class[_] = java.lang.Class.forName(name)
/** The default line separator.
*
* On the JVM, this is equivalent to calling the method:
* `java.lang.System.lineSeparator`
*/
@deprecated("Use `java.lang.System#lineSeparator` instead.", since = "2.13.0")
val EOL: String = System.lineSeparator
/** The current time in milliseconds. The time is counted since 1 January 1970
* UTC.
*
* Note that the operating system timer used to obtain this value may be less
* precise than a millisecond.
*/
@inline
@deprecated("Use `java.lang.System#currentTimeMillis` instead.", since = "2.13.0")
def currentTime: Long = System.currentTimeMillis()
/** Runs the garbage collector.
*
* This is a request that the underlying JVM runs the garbage collector.
* The results of this call depends heavily on the JVM used.
* The underlying JVM is free to ignore this request.
*/
@inline
@deprecated("Use `java.lang.System#gc` instead.", since = "2.13.0")
def collectGarbage(): Unit = System.gc()
/** The name of the default character set encoding as a string */
@inline
@deprecated("Use `java.nio.charset.Charset.defaultCharset#name` instead.", since = "2.13.0")
def defaultCharsetName: String = java.nio.charset.Charset.defaultCharset.name
}