Aggregating

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
implicit def aggregatingNatureOfArray[E](implicit equality: Equality[E]): Aggregating[Array[E]]

Implicit to support Aggregating nature of Array.
Implicit to support Aggregating nature of Array.
E
the type of the element in the Array
equality
Equality type class that is used to check equality of element in the Array
returns
Aggregating[Array[E]] that supports Array in relevant contain syntax
implicit def aggregatingNatureOfGenTraversable[E, TRAV[e] <: GenTraversable[e]](implicit equality: Equality[E]): Aggregating[TRAV[E]]

Implicit to support Aggregating nature of GenTraversable.
Implicit to support Aggregating nature of GenTraversable.
E
the type of the element in the GenTraversable
TRAV
any subtype of GenTraversable
equality
Equality type class that is used to check equality of element in the GenTraversable
returns
Aggregating[TRAV[E]] that supports GenTraversable in relevant contain syntax
implicit def aggregatingNatureOfJavaCollection[E, JCOL[e] <: Collection[e]](implicit equality: Equality[E]): Aggregating[JCOL[E]]

Implicit to support Aggregating nature of java.util.Collection.
Implicit to support Aggregating nature of java.util.Collection.
E
the type of the element in the java.util.Collection
JCOL
any subtype of java.util.Collection
equality
Equality type class that is used to check equality of element in the java.util.Collection
returns
Aggregating[JCOL[E]] that supports java.util.Collection in relevant contain syntax
implicit def aggregatingNatureOfJavaMap[K, V, JMAP[k, v] <: Map[k, v]](implicit equality: Equality[java.util.Map.Entry[K, V]]): Aggregating[JMAP[K, V]]

Implicit to support Aggregating nature of java.util.Map.
Implicit to support Aggregating nature of java.util.Map.
K
the type of the key in the java.util.Map
V
the type of the value in the java.util.Map
JMAP
any subtype of java.util.Map
equality
Equality type class that is used to check equality of entry in the java.util.Map
returns
Aggregating[JMAP[K, V]] that supports java.util.Map in relevant contain syntax
implicit def aggregatingNatureOfString(implicit equality: Equality[Char]): Aggregating[String]

Implicit to support Aggregating nature of String.
Implicit to support Aggregating nature of String.
equality
Equality type class that is used to check equality of Char in the String
returns
Aggregating[String] that supports String in relevant contain syntax
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
implicit def convertEqualityToArrayAggregating[E](equality: Equality[E]): Aggregating[Array[E]]

Implicit conversion that converts an Equality of type E into Aggregating of type Array[E].
Implicit conversion that converts an Equality of type E into Aggregating of type Array[E]. This is required to support the explicit Equality syntax, for example:
```
(Array("hi") should contain ("HI")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Aggregating[Array[String]].
E
type of elements in the Array
equality
Equality of type E
returns
Aggregating of type Array[E]
implicit def convertEqualityToGenTraversableAggregating[E, TRAV[e] <: GenTraversable[e]](equality: Equality[E]): Aggregating[TRAV[E]]

Implicit conversion that converts an Equality of type E into Aggregating of type TRAV[E], where TRAV is a subtype of GenTraversable.
Implicit conversion that converts an Equality of type E into Aggregating of type TRAV[E], where TRAV is a subtype of GenTraversable. This is required to support the explicit Equality syntax, for example:
```
(List("hi") should contain ("HI")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Aggregating[List[String]].
E
type of elements in the GenTraversable
TRAV
subtype of GenTraversable
equality
Equality of type E
returns
Aggregating of type TRAV[E]
implicit def convertEqualityToJavaCollectionAggregating[E, JCOL[e] <: Collection[e]](equality: Equality[E]): Aggregating[JCOL[E]]

Implicit conversion that converts an Equality of type E into Aggregating of type JCOL[E], where JCOL is a subtype of java.util.Collection.
Implicit conversion that converts an Equality of type E into Aggregating of type JCOL[E], where JCOL is a subtype of java.util.Collection. This is required to support the explicit Equality syntax, for example:
```
val javaList = new java.util.ArrayList[String]()
javaList.add("hi")
(javaList should contain ("HI")) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[String] and this implicit conversion will convert it into Aggregating[java.util.ArrayList[String]].
E
type of elements in the java.util.Collection
JCOL
subtype of java.util.Collection
equality
Equality of type E
returns
Aggregating of type JCOL[E]
implicit def convertEqualityToJavaMapAggregating[K, V, JMAP[k, v] <: Map[k, v]](equality: Equality[java.util.Map.Entry[K, V]]): Aggregating[JMAP[K, V]]

Implicit conversion that converts an Equality of type java.util.Map.Entry[K, V] into Aggregating of type JMAP[K, V], where JMAP is a subtype of java.util.Map.
Implicit conversion that converts an Equality of type java.util.Map.Entry[K, V] into Aggregating of type JMAP[K, V], where JMAP is a subtype of java.util.Map. This is required to support the explicit Equality syntax, for example:
```
val javaMap = new java.util.HashMap[Int, String]()
javaMap.put(1, "one")
// lowerCased needs to be implemented as Normalization[java.util.Map.Entry[K, V]]
(javaMap should contain (Entry(1, "ONE"))) (after being lowerCased)
```
(after being lowerCased) will returns an java.util.Map.Entry[Int, String] and this implicit conversion will convert it into Aggregating[java.util.HashMap[Int, String]].
K
the type of the key in the java.util.Map
V
the type of the value in the java.util.Map
JMAP
any subtype of java.util.Map
equality
Equality of type java.util.Map.Entry[K, V]
returns
Aggregating of type JMAP[K, V]
implicit def convertEqualityToStringAggregating(equality: Equality[Char]): Aggregating[String]

Implicit conversion that converts an Equality of type Char into Aggregating of type String.
Implicit conversion that converts an Equality of type Char into Aggregating of type String. This is required to support the explicit Equality syntax, for example:
```
// lowerCased needs to be implemented as Normalization[Char]
("hi hello" should contain ('E')) (after being lowerCased)
```
(after being lowerCased) will returns an Equality[Char] and this implicit conversion will convert it into Aggregating[String].
equality
Equality of type Char
returns
Aggregating of type String
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()

object Aggregating

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

implicit def aggregatingNatureOfArray[E](implicit equality: Equality[E]): Aggregating[Array[E]]

implicit def aggregatingNatureOfGenTraversable[E, TRAV[e] <: GenTraversable[e]](implicit equality: Equality[E]): Aggregating[TRAV[E]]

implicit def aggregatingNatureOfJavaCollection[E, JCOL[e] <: Collection[e]](implicit equality: Equality[E]): Aggregating[JCOL[E]]

implicit def aggregatingNatureOfJavaMap[K, V, JMAP[k, v] <: Map[k, v]](implicit equality: Equality[java.util.Map.Entry[K, V]]): Aggregating[JMAP[K, V]]

implicit def aggregatingNatureOfString(implicit equality: Equality[Char]): Aggregating[String]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit def convertEqualityToArrayAggregating[E](equality: Equality[E]): Aggregating[Array[E]]

implicit def convertEqualityToGenTraversableAggregating[E, TRAV[e] <: GenTraversable[e]](equality: Equality[E]): Aggregating[TRAV[E]]

implicit def convertEqualityToJavaCollectionAggregating[E, JCOL[e] <: Collection[e]](equality: Equality[E]): Aggregating[JCOL[E]]

implicit def convertEqualityToJavaMapAggregating[K, V, JMAP[k, v] <: Map[k, v]](equality: Equality[java.util.Map.Entry[K, V]]): Aggregating[JMAP[K, V]]

implicit def convertEqualityToStringAggregating(equality: Equality[Char]): Aggregating[String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped