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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2002-2010, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala
/** Class `Any` is the root of the Scala class hierarchy. Every class in a Scala
* execution environment inherits directly or indirectly from this class.
*/
abstract class Any {
/** Compares the receiver object (`this`) with the argument object (`that`) for equivalence.
*
* The default implementations of this method is an [[http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation]]:
*
* - It is reflexive: for any instance `x` of type `Any`, `x.equals(x)` should return `true`.
* - It is symmetric: for any instances `x` and `y` of type `Any`, `x.equals(y)` should return `true` if and
* only if `y.equals(x)` returns `true`.
* - It is transitive: for any instances `x`, `y`, and `z` of type `AnyRef` if `x.equals(y)` returns `true` and
* `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`.
*
* If you override this method, you should verify that your implementation remains an equivalence relation.
* Additionally, when overriding this method it is usually necessary to override `hashCode` to ensure that
* objects which are "equal" (`o1.equals(o2)` returns `true`) hash to the same [[scala.Int]].
* (`o1.hashCode.equals(o2.hashCode)`).
*
* @param that the object to compare against this object for equality.
* @return `true` if the receiver object is equivalent to the argument; `false` otherwise.
*/
def equals(that: Any): Boolean
/** Calculate a hash code value for the object.
*
* The default hashing algorithm is platform dependent.
*
* Note that it is allowed for two objects to have identical hash codes (`o1.hashCode.equals(o2.hashCode)`) yet
* not be equal (`o1.equals(o2)` returns `false`). A degenerate implementation could always return `0`.
* However, it is required that if two objects are equal (`o1.equals(o2)` returns `true`) that they have
* identical hash codes (`o1.hashCode.equals(o2.hashCode)`). Therefore, when overriding this method, be sure
* to verify that the behavior is consistent with the `equals` method.
*
* @return the hash code value for this object.
*/
def hashCode: Int
/** Returns a string representation of the object.
*
* The default representation is platform dependent.
*
* @return a string representation of the object.
*/
def toString: String
/** Test two objects for equality.
*
* @param that the object to compare against this object for equality.
* @return `true` if the receiver object is equivalent to the argument; `false` otherwise.
*/
final def ==(that: Any): Boolean = this equals that
/** Test two objects for inequality.
*
* @param that the object to compare against this object for equality.
* @return `true` if !(this == that), false otherwise.
*/
final def != (that: Any): Boolean = !(this == that)
/** Equivalent to `x.hashCode` except for boxed numeric types.
* For numerics, it returns a hash value which is consistent
* with value equality: if two value type instances compare
* as true, then ## will produce the same hash value for each
* of them.
*
* @return a hash value consistent with ==
*/
final def ## : Int = sys.error("##")
/** Test whether the dynamic type of the receiver object is `T0`.
*
* Note that the result of the test is modulo Scala's erasure semantics.
* Therefore the expression `1.isInstanceOf[String]` will return `false`, while the
* expression `List(1).isInstanceOf[List[String]]` will return `true`.
* In the latter example, because the type argument is erased as part of compilation it is
* not possible to check whether the contents of the list are of the specified type.
*
* @return `true` if the receiver object is an instance of erasure of type `T0`; `false` otherwise.
*/
def isInstanceOf[T0]: Boolean = sys.error("isInstanceOf")
/** Cast the receiver object to be of type `T0`.
*
* Note that the success of a cast at runtime is modulo Scala's erasure semantics.
* Therefore the expression `1.asInstanceOf[String]` will throw a `ClassCastException` at
* runtime, while the expression `List(1).asInstanceOf[List[String]]` will not.
* In the latter example, because the type argument is erased as part of compilation it is
* not possible to check whether the contents of the list are of the requested type.
*
* @throws ClassCastException if the receiver object is not an instance of the erasure of type `T0`.
* @return the receiver object.
*/
def asInstanceOf[T0]: T0 = sys.error("asInstanceOf")
}
|
