blob: 91e90c149991f618ac889d3d87d271297fa31adb (
plain) (
blame)
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
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2011, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.collection
/** A template trait for sets which may possibly
* have their operations implemented in parallel.
*
* @author Martin Odersky
* @author Aleksandar Prokopec
* @since 2.9
*/
trait GenSetLike[A, +Repr] extends GenIterableLike[A, Repr] with (A => Boolean) with Equals with Parallelizable[A, parallel.ParSet[A]] {
def seq: Set[A]
def contains(elem: A): Boolean
def +(elem: A): Repr
def -(elem: A): Repr
/** Tests if some element is contained in this set.
*
* This method is equivalent to `contains`. It allows sets to be interpreted as predicates.
* @param elem the element to test for membership.
* @return `true` if `elem` is contained in this set, `false` otherwise.
*/
def apply(elem: A): Boolean = this contains elem
/** Computes the intersection between this set and another set.
*
* @param that the set to intersect with.
* @return a new set consisting of all elements that are both in this
* set and in the given set `that`.
*/
def intersect(that: GenSet[A]): Repr = this filter that
/** Computes the intersection between this set and another set.
*
* '''Note:''' Same as `intersect`.
* @param that the set to intersect with.
* @return a new set consisting of all elements that are both in this
* set and in the given set `that`.
*/
def &(that: GenSet[A]): Repr = this intersect that
/** Computes the union between of set and another set.
*
* @param that the set to form the union with.
* @return a new set consisting of all elements that are in this
* set or in the given set `that`.
*/
def union(that: GenSet[A]): Repr
/** Computes the union between this set and another set.
*
* '''Note:''' Same as `union`.
* @param that the set to form the union with.
* @return a new set consisting of all elements that are in this
* set or in the given set `that`.
*/
def | (that: GenSet[A]): Repr = this union that
/** Computes the difference of this set and another set.
*
* @param that the set of elements to exclude.
* @return a set containing those elements of this
* set that are not also contained in the given set `that`.
*/
def diff(that: GenSet[A]): Repr
/** The difference of this set and another set.
*
* '''Note:''' Same as `diff`.
* @param that the set of elements to exclude.
* @return a set containing those elements of this
* set that are not also contained in the given set `that`.
*/
def &~(that: GenSet[A]): Repr = this diff that
/** Tests whether this set is a subset of another set.
*
* @param that the set to test.
* @return `true` if this set is a subset of `that`, i.e. if
* every element of this set is also an element of `that`.
*/
def subsetOf(that: GenSet[A]): Boolean = this forall that
/** Compares this set with another object for equality.
*
* '''Note:''' This operation contains an unchecked cast: if `that`
* is a set, it will assume with an unchecked cast
* that it has the same element type as this set.
* Any subsequent ClassCastException is treated as a `false` result.
* @param that the other object
* @return `true` if `that` is a set which contains the same elements
* as this set.
*/
override def equals(that: Any): Boolean = that match {
case that: GenSet[_] =>
(this eq that) ||
(that canEqual this) &&
(this.size == that.size) &&
(try this subsetOf that.asInstanceOf[GenSet[A]]
catch { case ex: ClassCastException => false })
case _ =>
false
}
// Careful! Don't write a Set's hashCode like:
// override def hashCode() = this map (_.hashCode) sum
// Calling map on a set drops duplicates: any hashcode collisions would
// then be dropped before they can be added.
// Hash should be symmetric in set entries, but without trivial collisions.
override def hashCode() = util.MurmurHash.symmetricHash(seq, Set.hashSeed)
}
|