Skip to content

Instantly share code, notes, and snippets.

@soc

soc/gist:2f348784e13a65f208585a09d6a94f48 Secret

Last active May 6, 2016 22:10
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save soc/2f348784e13a65f208585a09d6a94f48 to your computer and use it in GitHub Desktop.
Save soc/2f348784e13a65f208585a09d6a94f48 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gistfile1.txt
Searching 748 files for ""Use"
/home/soc/Entwicklung/scala/src/library/scala/Console.scala:
170 protected def setInDirect(in: BufferedReader): Unit
171
172: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readBoolean(): Boolean = StdIn.readBoolean()
173: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readByte(): Byte = StdIn.readByte()
174: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readChar(): Char = StdIn.readChar()
175: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readDouble(): Double = StdIn.readDouble()
176: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readFloat(): Float = StdIn.readFloat()
177: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readInt(): Int = StdIn.readInt()
178: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readLine(): String = StdIn.readLine()
179: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readLine(text: String, args: Any*): String = StdIn.readLine(text, args: _*)
180: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readLong(): Long = StdIn.readLong()
181: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readShort(): Short = StdIn.readShort()
182: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readf(format: String): List[Any] = StdIn.readf(format)
183: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readf1(format: String): Any = StdIn.readf1(format)
184: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readf2(format: String): (Any, Any) = StdIn.readf2(format)
185: @deprecated("Use the method in scala.io.StdIn", "2.11.0") def readf3(format: String): (Any, Any, Any) = StdIn.readf3(format)
186
187 /** Sets the default output stream.
...
189 * @param out the new output stream.
190 */
191: @deprecated("Use withOut", "2.11.0") def setOut(out: PrintStream): Unit = setOutDirect(out)
192
193 /** Sets the default output stream.
...
195 * @param out the new output stream.
196 */
197: @deprecated("Use withOut", "2.11.0") def setOut(out: OutputStream): Unit = setOutDirect(new PrintStream(out))
198
199 /** Sets the default error stream.
...
201 * @param err the new error stream.
202 */
203: @deprecated("Use withErr", "2.11.0") def setErr(err: PrintStream): Unit = setErrDirect(err)
204
205 /** Sets the default error stream.
...
207 * @param err the new error stream.
208 */
209: @deprecated("Use withErr", "2.11.0") def setErr(err: OutputStream): Unit = setErrDirect(new PrintStream(err))
210
211 /** Sets the default input stream.
...
213 * @param reader specifies the new input stream.
214 */
215: @deprecated("Use withIn", "2.11.0") def setIn(reader: Reader): Unit = setInDirect(new BufferedReader(reader))
216
217 /** Sets the default input stream.
...
219 * @param in the new input stream.
220 */
221: @deprecated("Use withIn", "2.11.0") def setIn(in: InputStream): Unit = setInDirect(new BufferedReader(new InputStreamReader(in)))
222 }
223
/home/soc/Entwicklung/scala/src/library/scala/Function.scala:
73 * hold pending superior type inference for tupling anonymous functions.
74 */
75: // @deprecated("Use `f.tupled` instead")
76 def tupled[a1, a2, b](f: (a1, a2) => b): Tuple2[a1, a2] => b = {
77 case Tuple2(x1, x2) => f(x1, x2)
..
81 * of arity 3 into a unary function that takes a triple of arguments.
82 */
83: // @deprecated("Use `f.tupled` instead")
84 def tupled[a1, a2, a3, b](f: (a1, a2, a3) => b): Tuple3[a1, a2, a3] => b = {
85 case Tuple3(x1, x2, x3) => f(x1, x2, x3)
..
89 * of arity 4 into a unary function that takes a 4-tuple of arguments.
90 */
91: // @deprecated("Use `f.tupled` instead")
92 def tupled[a1, a2, a3, a4, b](f: (a1, a2, a3, a4) => b): Tuple4[a1, a2, a3, a4] => b = {
93 case Tuple4(x1, x2, x3, x4) => f(x1, x2, x3, x4)
..
97 * of arity 5 into a unary function that takes a 5-tuple of arguments.
98 */
99: // @deprecated("Use `f.tupled` instead")
100 def tupled[a1, a2, a3, a4, a5, b](f: (a1, a2, a3, a4, a5) => b): Tuple5[a1, a2, a3, a4, a5] => b = {
101 case Tuple5(x1, x2, x3, x4, x5) => f(x1, x2, x3, x4, x5)
/home/soc/Entwicklung/scala/src/library/scala/Predef.scala:
154 // Manifest types, companions, and incantations for summoning
155 @annotation.implicitNotFound(msg = "No ClassManifest available for ${T}.")
156: @deprecated("Use `scala.reflect.ClassTag` instead", "2.10.0")
157 type ClassManifest[T] = scala.reflect.ClassManifest[T]
158 // TODO undeprecated until Scala reflection becomes non-experimental
...
161 @annotation.implicitNotFound(msg = "No Manifest available for ${T}.")
162 // TODO undeprecated until Scala reflection becomes non-experimental
163: // @deprecated("Use `scala.reflect.ClassTag` (to capture erasures) or scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
164 type Manifest[T] = scala.reflect.Manifest[T]
165: @deprecated("Use `scala.reflect.ClassTag` instead", "2.10.0")
166 val ClassManifest = scala.reflect.ClassManifest
167 // TODO undeprecated until Scala reflection becomes non-experimental
168: // @deprecated("Use `scala.reflect.ClassTag` (to capture erasures) or scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
169 val Manifest = scala.reflect.Manifest
170 // TODO undeprecated until Scala reflection becomes non-experimental
...
173
174 // TODO undeprecated until Scala reflection becomes non-experimental
175: // @deprecated("Use scala.reflect.classTag[T] and scala.reflect.runtime.universe.typeTag[T] instead", "2.10.0")
176 def manifest[T](implicit m: Manifest[T]) = m
177: @deprecated("Use scala.reflect.classTag[T] instead", "2.10.0")
178 def classManifest[T](implicit m: ClassManifest[T]) = m
179 // TODO undeprecated until Scala reflection becomes non-experimental
...
286 // tupling ------------------------------------------------------------
287
288: @deprecated("Use built-in tuple syntax or Tuple2 instead", "2.11.0")
289 type Pair[+A, +B] = Tuple2[A, B]
290: @deprecated("Use built-in tuple syntax or Tuple2 instead", "2.11.0")
291 object Pair {
292 def apply[A, B](x: A, y: B) = Tuple2(x, y)
...
294 }
295
296: @deprecated("Use built-in tuple syntax or Tuple3 instead", "2.11.0")
297 type Triple[+A, +B, +C] = Tuple3[A, B, C]
298: @deprecated("Use built-in tuple syntax or Tuple3 instead", "2.11.0")
299 object Triple {
300 def apply[A, B, C](x: A, y: B, z: C) = Tuple3(x, y, z)
...
335 implicit final class RichException(private val self: Throwable) extends AnyVal {
336 import scala.compat.Platform.EOL
337: @deprecated("Use Throwable#getStackTrace", "2.11.0") def getStackTraceString = self.getStackTrace().mkString("", EOL, EOL)
338 }
339
...
510 implicit def $conforms[A]: A <:< A = singleton_<:<.asInstanceOf[A <:< A]
511
512: @deprecated("Use `implicitly[T <:< U]` or `identity` instead.", "2.11.0")
513 def conforms[A]: A <:< A = $conforms[A]
514
...
544
545 // Deprecated stubs for any who may have been calling these methods directly.
546: @deprecated("Use `ArrowAssoc`", "2.11.0") def any2ArrowAssoc[A](x: A): ArrowAssoc[A] = new ArrowAssoc(x)
547: @deprecated("Use `Ensuring`", "2.11.0") def any2Ensuring[A](x: A): Ensuring[A] = new Ensuring(x)
548: @deprecated("Use `StringFormat`", "2.11.0") def any2stringfmt(x: Any): StringFormat[Any] = new StringFormat(x)
549: @deprecated("Use `Throwable` directly", "2.11.0") def exceptionWrapper(exc: Throwable) = new RichException(exc)
550: @deprecated("Use `SeqCharSequence`", "2.11.0") def seqToCharSequence(xs: scala.collection.IndexedSeq[Char]): CharSequence = new SeqCharSequence(xs)
551: @deprecated("Use `ArrayCharSequence`", "2.11.0") def arrayToCharSequence(xs: Array[Char]): CharSequence = new ArrayCharSequence(xs)
552
553: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readLine(): String = StdIn.readLine()
554: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readLine(text: String, args: Any*) = StdIn.readLine(text, args: _*)
555: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readBoolean() = StdIn.readBoolean()
556: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readByte() = StdIn.readByte()
557: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readShort() = StdIn.readShort()
558: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readChar() = StdIn.readChar()
559: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readInt() = StdIn.readInt()
560: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readLong() = StdIn.readLong()
561: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readFloat() = StdIn.readFloat()
562: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readDouble() = StdIn.readDouble()
563: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readf(format: String) = StdIn.readf(format)
564: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readf1(format: String) = StdIn.readf1(format)
565: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readf2(format: String) = StdIn.readf2(format)
566: @deprecated("Use the method in `scala.io.StdIn`", "2.11.0") def readf3(format: String) = StdIn.readf3(format)
567 }
568
/home/soc/Entwicklung/scala/src/library/scala/collection/generic/GenericClassTagTraversableTemplate.scala:
26 def classTagCompanion: GenericClassTagCompanion[CC]
27 def genericClassTagBuilder[B](implicit tag: ClassTag[B]): Builder[B, CC[B]] = classTagCompanion.newBuilder[B]
28: @deprecated("use classTagCompanion instead", "2.10.0")
29 def classManifestCompanion: GenericClassManifestCompanion[CC] = classTagCompanion
30: @deprecated("use genericClassTagBuilder instead", "2.10.0")
31 def genericClassManifestBuilder[B](implicit manifest: ClassManifest[B]): Builder[B, CC[B]] = genericClassTagBuilder[B](manifest)
32 }
/home/soc/Entwicklung/scala/src/library/scala/collection/generic/package.scala:
7 type CanBuild[-Elem, +To] = CanBuildFrom[Nothing, Elem, To]
8
9: @deprecated("use ClassTagTraversableFactory instead", "2.10.0")
10 type ClassManifestTraversableFactory[CC[X] <: Traversable[X] with GenericClassManifestTraversableTemplate[X, CC]] = ClassTagTraversableFactory[CC]
11
12: @deprecated("use GenericClassTagCompanion instead", "2.10.0")
13 type GenericClassManifestCompanion[+CC[X] <: Traversable[X]] = GenericClassTagCompanion[CC]
14
15: @deprecated("use GenericClassTagTraversableTemplate instead", "2.10.0")
16 type GenericClassManifestTraversableTemplate[+A, +CC[X] <: Traversable[X]] = GenericClassTagTraversableTemplate[A, CC]
17 }
/home/soc/Entwicklung/scala/src/library/scala/collection/immutable/StringLike.scala:
132 * returned by `linesWithSeparators`.
133 */
134: @deprecated("Use `lines` instead.","2.11.0")
135 def linesIterator: Iterator[String] =
136 linesWithSeparators map (line => new WrappedString(line).stripLineEnd)
/home/soc/Entwicklung/scala/src/library/scala/collection/mutable/WrappedArray.scala:
46 def elemTag: ClassTag[T]
47
48: @deprecated("use elemTag instead", "2.10.0")
49 def elemManifest: ClassManifest[T] = ClassManifest.fromClass[T](arrayElementClass(elemTag).asInstanceOf[Class[T]])
50
/home/soc/Entwicklung/scala/src/library/scala/collection/mutable/WrappedArrayBuilder.scala:
27 class WrappedArrayBuilder[A](tag: ClassTag[A]) extends ReusableBuilder[A, WrappedArray[A]] {
28
29: @deprecated("use tag instead", "2.10.0")
30 val manifest: ClassTag[A] = tag
31
/home/soc/Entwicklung/scala/src/library/scala/collection/parallel/ParIterableLike.scala:
843 }
844
845: @deprecated("Use .seq.view instead", "2.11.0")
846 def view = seq.view
847
/home/soc/Entwicklung/scala/src/library/scala/collection/parallel/ParSeqLike.scala:
324 override def toSeq = this.asInstanceOf[ParSeq[T]]
325
326: @deprecated("use .seq.view", "2.11.0")
327 override def view = seq.view
328
/home/soc/Entwicklung/scala/src/library/scala/collection/parallel/TaskSupport.scala:
61 * @see [[scala.collection.parallel.TaskSupport]] for more information.
62 */
63: @deprecated("Use `ForkJoinTaskSupport` instead.", "2.11.0")
64 class ThreadPoolTaskSupport(val environment: ThreadPoolExecutor = ThreadPoolTasks.defaultThreadPool)
65 extends TaskSupport with AdaptiveWorkStealingThreadPoolTasks
/home/soc/Entwicklung/scala/src/library/scala/collection/parallel/Tasks.scala:
209
210 /** An implementation of tasks objects based on the Java thread pooling API. */
211: @deprecated("Use `ForkJoinTasks` instead.", "2.11.0")
212 trait ThreadPoolTasks extends Tasks {
213 import java.util.concurrent._
...
318 }
319
320: @deprecated("Use `ForkJoinTasks` instead.", "2.11.0")
321 object ThreadPoolTasks {
322 import java.util.concurrent._
...
446 }
447
448: @deprecated("Use `AdaptiveWorkStealingForkJoinTasks` instead.", "2.11.0")
449 trait AdaptiveWorkStealingThreadPoolTasks extends ThreadPoolTasks with AdaptiveWorkStealingTasks {
450
/home/soc/Entwicklung/scala/src/library/scala/concurrent/Future.scala:
106 * $callbackInContext
107 */
108: @deprecated("use `foreach` or `onComplete` instead (keep in mind that they take total rather than partial functions)", "2.12")
109 def onSuccess[U](pf: PartialFunction[T, U])(implicit executor: ExecutionContext): Unit = onComplete {
110 case Success(v) =>
...
127 * $callbackInContext
128 */
129: @deprecated("use `onComplete` or `failed.foreach` instead (keep in mind that they take total rather than partial functions)", "2.12")
130 def onFailure[U](@deprecatedName('callback) pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Unit = onComplete {
131 case Failure(t) =>
...
645 * @return the `Future` holding the optional result of the search
646 */
647: @deprecated("Use the overloaded version of this method that takes a scala.collection.immutable.Iterable instead", "2.12")
648 def find[T](@deprecatedName('futurestravonce) futures: TraversableOnce[Future[T]])(@deprecatedName('predicate) p: T => Boolean)(implicit executor: ExecutionContext): Future[Option[T]] = {
649 val futuresBuffer = futures.toBuffer
...
732 * @return the `Future` holding the result of the fold
733 */
734: @deprecated("Use Future.foldLeft instead", "2.12")
735 def fold[T, R](futures: TraversableOnce[Future[T]])(zero: R)(@deprecatedName('foldFun) op: (R, T) => R)(implicit executor: ExecutionContext): Future[R] = {
736 if (futures.isEmpty) successful(zero)
...
751 * @return the `Future` holding the result of the reduce
752 */
753: @deprecated("Use Future.reduceLeft instead", "2.12")
754 def reduce[T, R >: T](futures: TraversableOnce[Future[T]])(op: (R, T) => R)(implicit executor: ExecutionContext): Future[R] = {
755 if (futures.isEmpty) failed(new NoSuchElementException("reduce attempted on empty collection"))
/home/soc/Entwicklung/scala/src/library/scala/concurrent/Lock.scala:
16 * @version 1.0, 10/03/2003
17 */
18: @deprecated("Use java.util.concurrent.locks.Lock", "2.11.2")
19 class Lock {
20 var available = true
/home/soc/Entwicklung/scala/src/library/scala/concurrent/SyncVar.scala:
92 // whether or not the SyncVar is already defined. So, set has been
93 // deprecated in order to eventually be able to make "setting" private
94: @deprecated("Use `put` instead, as `set` is potentially error-prone", "2.10.0")
95 // NOTE: Used by SBT 0.13.0-M2 and below
96 def set(x: A): Unit = setVal(x)
..
112 // whether or not the SyncVar is already defined. So, unset has been
113 // deprecated in order to eventually be able to make "unsetting" private
114: @deprecated("Use `take` instead, as `unset` is potentially error-prone", "2.10.0")
115 // NOTE: Used by SBT 0.13.0-M2 and below
116 def unset(): Unit = synchronized {
/home/soc/Entwicklung/scala/src/library/scala/concurrent/forkjoin/package.scala:
12
13 package object forkjoin {
14: @deprecated("Use java.util.concurrent.ForkJoinPool directly, instead of this alias.", "2.12.0")
15 type ForkJoinPool = juc.ForkJoinPool
16: @deprecated("Use java.util.concurrent.ForkJoinPool directly, instead of this alias.", "2.12.0")
17 object ForkJoinPool {
18 type ForkJoinWorkerThreadFactory = juc.ForkJoinPool.ForkJoinWorkerThreadFactory
..
23 }
24
25: @deprecated("Use java.util.concurrent.ForkJoinTask directly, instead of this alias.", "2.12.0")
26 type ForkJoinTask[T] = juc.ForkJoinTask[T]
27: @deprecated("Use java.util.concurrent.ForkJoinTask directly, instead of this alias.", "2.12.0")
28 object ForkJoinTask {
29 def adapt(runnable: Runnable): ForkJoinTask[_] = juc.ForkJoinTask.adapt(runnable)
..
40 }
41
42: @deprecated("Use java.util.concurrent.ForkJoinWorkerThread directly, instead of this alias.", "2.12.0")
43 type ForkJoinWorkerThread = juc.ForkJoinWorkerThread
44: @deprecated("Use java.util.concurrent.LinkedTransferQueue directly, instead of this alias.", "2.12.0")
45 type LinkedTransferQueue[T] = juc.LinkedTransferQueue[T]
46: @deprecated("Use java.util.concurrent.RecursiveAction directly, instead of this alias.", "2.12.0")
47 type RecursiveAction = juc.RecursiveAction
48: @deprecated("Use java.util.concurrent.RecursiveTask directly, instead of this alias.", "2.12.0")
49 type RecursiveTask[T] = juc.RecursiveTask[T]
50
51: @deprecated("Use java.util.concurrent.ThreadLocalRandom directly, instead of this alias.", "2.12.0")
52 type ThreadLocalRandom = juc.ThreadLocalRandom
53: @deprecated("Use java.util.concurrent.ThreadLocalRandom directly, instead of this alias.", "2.12.0")
54 object ThreadLocalRandom {
55 // For source compatibility, current must declare the empty argument list.
/home/soc/Entwicklung/scala/src/library/scala/concurrent/package.scala:
97 * @return the `Future` holding the result of the computation
98 */
99: @deprecated("Use `Future { ... }` instead.", "2.11.0")
100 // removal planned for 2.13.0
101 def future[T](body: =>T)(implicit @deprecatedName('execctx) executor: ExecutionContext): Future[T] = Future[T](body)
...
106 * @return the newly created `Promise` object
107 */
108: @deprecated("Use `Promise[T]()` instead.", "2.11.0")
109 // removal planned for 2.13.0
110 def promise[T](): Promise[T] = Promise[T]()
/home/soc/Entwicklung/scala/src/library/scala/reflect/ClassManifestDeprecatedApis.scala:
13 import java.lang.{ Class => jClass }
14
15: @deprecated("Use scala.reflect.ClassTag instead", "2.10.0")
16 trait ClassManifestDeprecatedApis[T] extends OptManifest[T] {
17 self: ClassManifest[T] =>
18
19 // Still in use in target test.junit.comp.
20: @deprecated("Use runtimeClass instead", "2.10.0")
21 def erasure: jClass[_] = runtimeClass
22
..
45 * described in the header.
46 */
47: @deprecated("Use scala.reflect.runtime.universe.TypeTag for subtype checking instead", "2.10.0")
48 def <:<(that: ClassManifest[_]): Boolean = {
49 // All types which could conform to these types will override <:<.
..
79 * described in the header.
80 */
81: @deprecated("Use scala.reflect.runtime.universe.TypeTag for subtype checking instead", "2.10.0")
82 def >:>(that: ClassManifest[_]): Boolean =
83 that <:< this
..
91 java.lang.reflect.Array.newInstance(tp, 0).getClass.asInstanceOf[jClass[Array[T]]]
92
93: @deprecated("Use wrap instead", "2.10.0")
94 def arrayManifest: ClassManifest[Array[T]] =
95 ClassManifest.classType[Array[T]](arrayClass[T](runtimeClass), this)
..
98 java.lang.reflect.Array.newInstance(runtimeClass, len).asInstanceOf[Array[T]]
99
100: @deprecated("Use wrap.newArray instead", "2.10.0")
101 def newArray2(len: Int): Array[Array[T]] =
102 java.lang.reflect.Array.newInstance(arrayClass[T](runtimeClass), len)
103 .asInstanceOf[Array[Array[T]]]
104
105: @deprecated("Use wrap.wrap.newArray instead", "2.10.0")
106 def newArray3(len: Int): Array[Array[Array[T]]] =
107 java.lang.reflect.Array.newInstance(arrayClass[Array[T]](arrayClass[T](runtimeClass)), len)
108 .asInstanceOf[Array[Array[Array[T]]]]
109
110: @deprecated("Use wrap.wrap.wrap.newArray instead", "2.10.0")
111 def newArray4(len: Int): Array[Array[Array[Array[T]]]] =
112 java.lang.reflect.Array.newInstance(arrayClass[Array[Array[T]]](arrayClass[Array[T]](arrayClass[T](runtimeClass))), len)
113 .asInstanceOf[Array[Array[Array[Array[T]]]]]
114
115: @deprecated("Use wrap.wrap.wrap.wrap.newArray instead", "2.10.0")
116 def newArray5(len: Int): Array[Array[Array[Array[Array[T]]]]] =
117 java.lang.reflect.Array.newInstance(arrayClass[Array[Array[Array[T]]]](arrayClass[Array[Array[T]]](arrayClass[Array[T]](arrayClass[T](runtimeClass)))), len)
...
123 new WrappedArray.ofRef[T with AnyRef](newArray(len).asInstanceOf[Array[T with AnyRef]]).asInstanceOf[WrappedArray[T]]
124
125: @deprecated("Use ArrayBuilder.make(this) instead", "2.10.0")
126 def newArrayBuilder(): ArrayBuilder[T] =
127 // it's safe to assume T <: AnyRef here because the method is overridden for all value type manifests
128 new ArrayBuilder.ofRef[T with AnyRef]()(this.asInstanceOf[ClassManifest[T with AnyRef]]).asInstanceOf[ArrayBuilder[T]]
129
130: @deprecated("Use scala.reflect.runtime.universe.TypeTag to capture type structure instead", "2.10.0")
131 def typeArguments: List[OptManifest[_]] = List()
132
/home/soc/Entwicklung/scala/src/library/scala/reflect/Manifest.scala:
42 @scala.annotation.implicitNotFound(msg = "No Manifest available for ${T}.")
43 // TODO undeprecated until Scala reflection becomes non-experimental
44: // @deprecated("Use scala.reflect.ClassTag (to capture erasures) or scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
45 trait Manifest[T] extends ClassManifest[T] with Equals {
46 override def typeArguments: List[Manifest[_]] = Nil
..
64
65 // TODO undeprecated until Scala reflection becomes non-experimental
66: // @deprecated("Use type tags and manually check the corresponding class or type instead", "2.10.0")
67 @SerialVersionUID(1L)
68 abstract class AnyValManifest[T <: AnyVal](override val toString: String) extends Manifest[T] with Equals {
/home/soc/Entwicklung/scala/src/library/scala/reflect/package.scala:
26 * number of type arguments than a supertype.
27 */
28: @deprecated("Use scala.reflect.ClassTag instead", "2.10.0")
29 @annotation.implicitNotFound(msg = "No ClassManifest available for ${T}.")
30 type ClassManifest[T] = scala.reflect.ClassTag[T]
..
33 * It is intended for use by the compiler and should not be used in client code.
34 */
35: @deprecated("Use scala.reflect.ClassTag instead", "2.10.0")
36 val ClassManifest = ClassManifestFactory
37
..
40 */
41 // TODO undeprecated until Scala reflection becomes non-experimental
42: // @deprecated("Use scala.reflect.ClassTag (to capture erasures), scala.reflect.runtime.universe.TypeTag (to capture types) or both instead", "2.10.0")
43 val Manifest = ManifestFactory
44
/home/soc/Entwicklung/scala/src/library/scala/runtime/RichException.scala:
12 import scala.compat.Platform.EOL
13
14: @deprecated("Use Throwable#getStackTrace", "2.11.0")
15 final class RichException(exc: Throwable) {
16 def getStackTraceString = exc.getStackTrace().mkString("", EOL, EOL)
/home/soc/Entwicklung/scala/src/library/scala/runtime/SeqCharSequence.scala:
10 package runtime
11
12: @deprecated("Use Predef.SeqCharSequence", "2.11.0")
13 final class SeqCharSequence(val xs: scala.collection.IndexedSeq[Char]) extends CharSequence {
14 def length: Int = xs.length
/home/soc/Entwicklung/scala/src/library/scala/runtime/StringAdd.scala:
12
13 /** A wrapper class that adds string concatenation `+` to any value */
14: @deprecated("Use Predef.StringAdd", "2.11.0")
15 final class StringAdd(val self: Any) extends AnyVal {
16 def +(other: String) = String.valueOf(self) + other
/home/soc/Entwicklung/scala/src/library/scala/runtime/StringFormat.scala:
13 /** A wrapper class that adds a `formatted` operation to any value
14 */
15: @deprecated("Use Predef.StringFormat", "2.11.0")
16 final class StringFormat(val self: Any) extends AnyVal {
17 /** Returns string formatted according to given `format` string.
/home/soc/Entwicklung/scala/src/library/scala/sys/SystemProperties.scala:
88 lazy val preferIPv6Addresses: BooleanProp = BooleanProp.keyExists(PreferIPv6AddressesKey)
89 lazy val noTraceSuppression: BooleanProp = BooleanProp.valueIsTrue(NoTraceSuppressionKey)
90: @deprecated("Use noTraceSuppression", "2.12.0")
91 def noTraceSupression = noTraceSuppression
92 }
/home/soc/Entwicklung/scala/src/library/scala/sys/process/Process.scala:
111 *
112 * @example {{{
113: * apply((new java.lang.ProcessBuilder("ls", "-l")) directory new java.io.File(System.getProperty("user.home")))
114 * }}}
115 */
/home/soc/Entwicklung/scala/src/library/scala/sys/process/ProcessBuilder.scala:
175
176 /** Deprecated (renamed). Use `lineStream` instead. */
177: @deprecated("Use lineStream instead.", "2.11.0")
178 def lines: Stream[String] = lineStream
179
...
187
188 /** Deprecated (renamed). Use `lineStream(log: ProcessLogger)` instead. */
189: @deprecated("Use stream instead.", "2.11.0")
190 def lines(log: ProcessLogger): Stream[String] = lineStream(log)
191
...
199
200 /** Deprecated (renamed). Use `lineStream_!` instead. */
201: @deprecated("Use lineStream_! instead.", "2.11.0")
202 def lines_! : Stream[String] = lineStream_!
203
...
211
212 /** Deprecated (renamed). Use `lineStream_!(log: ProcessLogger)` instead. */
213: @deprecated("Use stream_! instead.", "2.11.0")
214 def lines_!(log: ProcessLogger): Stream[String] = lineStream_!(log)
215
/home/soc/Entwicklung/scala/src/library/scala/util/MurmurHash.scala:
29 * set equal to the hash code of whatever it is hashing.
30 */
31: @deprecated("Use the object MurmurHash3 instead.", "2.10.0")
32 class MurmurHash[@specialized(Int,Long,Float,Double) T](seed: Int) extends (T => Unit) {
33 import MurmurHash._
..
82 * needs to be called to finalize the hash.
83 */
84: @deprecated("Use the object MurmurHash3 instead.", "2.10.0")
85 // NOTE: Used by SBT 0.13.0-M2 and below
86 object MurmurHash {
/home/soc/Entwicklung/scala/src/library/scala/util/Properties.scala:
138 def scalaHome = propOrEmpty("scala.home")
139 def tmpDir = propOrEmpty("java.io.tmpdir")
140: def userDir = propOrEmpty("user.dir")
141: def userHome = propOrEmpty("user.home")
142: def userName = propOrEmpty("user.name")
143
144 /* Some derived values. */
121 matches across 29 files
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment