object Aggregating extends AggregatingHighPriorityImplicits
Companion object for Aggregating that provides implicit implementations for the following types:
scala.collection.GenTraversableStringArrayjava.util.Collectionjava.util.Map
- Source
 - Aggregating.scala
 
- Alphabetic
 - By Inheritance
 
- Aggregating
 - AggregatingHighPriorityImplicits
 - AggregatingStandardImplicits
 - AggregatingJavaImplicits
 - AggregatingImpls
 - AnyRef
 - Any
 
- Hide All
 - Show All
 
- Public
 - Protected
 
Value Members
-   final  def !=(arg0: Any): Boolean
- Definition Classes
 - AnyRef → Any
 
 -   final  def ##: Int
- Definition Classes
 - AnyRef → Any
 
 -   final  def ==(arg0: Any): Boolean
- Definition Classes
 - AnyRef → Any
 
 -   implicit  def aggregatingNatureOfArray[E](implicit equality: Equality[E]): Aggregating[Array[E]]
Implicit to support
Aggregatingnature ofArray.Implicit to support
Aggregatingnature ofArray.- E
 the type of the element in the
Array- equality
 Equalitytype class that is used to check equality of element in theArray- returns
 Aggregating[Array[E]]that supportsArrayin relevantcontainsyntax
- Definition Classes
 - AggregatingStandardImplicits
 
 -   implicit  def aggregatingNatureOfEvery[E](implicit equality: Equality[E]): Aggregating[Every[E]]
Implicit to support
Aggregatingnature ofEvery.Implicit to support
Aggregatingnature ofEvery.- E
 the type of the element in the
Every- equality
 Equalitytype class that is used to check equality of element in theEvery- returns
 Aggregating[Every[E]]that supportsEveryin relevantcontainsyntax
- Definition Classes
 - AggregatingStandardImplicits
 
 -   implicit  def aggregatingNatureOfGenTraversable[E, TRAV[e] <: GenTraversable[e]](implicit equality: Equality[E]): Aggregating[TRAV[E]]
Implicit to support
Aggregatingnature ofGenTraversable.Implicit to support
Aggregatingnature ofGenTraversable.- E
 the type of the element in the
GenTraversable- TRAV
 any subtype of
GenTraversable- equality
 Equalitytype class that is used to check equality of element in theGenTraversable- returns
 Aggregating[TRAV[E]]that supportsGenTraversablein relevantcontainsyntax
- Definition Classes
 - AggregatingStandardImplicits
 
 -   implicit  def aggregatingNatureOfJavaCollection[E, JCOL[e] <: Collection[e]](implicit equality: Equality[E]): Aggregating[JCOL[E]]
Implicit to support
Aggregatingnature ofjava.util.Collection.Implicit to support
Aggregatingnature ofjava.util.Collection.- E
 the type of the element in the
java.util.Collection- JCOL
 any subtype of
java.util.Collection- equality
 Equalitytype class that is used to check equality of element in thejava.util.Collection- returns
 Aggregating[JCOL[E]]that supportsjava.util.Collectionin relevantcontainsyntax
- Definition Classes
 - AggregatingJavaImplicits
 
 -   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
Aggregatingnature ofjava.util.Map.Implicit to support
Aggregatingnature ofjava.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
 Equalitytype class that is used to check equality of entry in thejava.util.Map- returns
 Aggregating[JMAP[K, V]]that supportsjava.util.Mapin relevantcontainsyntax
- Definition Classes
 - AggregatingJavaImplicits
 
 -   implicit  def aggregatingNatureOfMap[K, V, MAP[k, v] <: GenMap[k, v]](implicit equality: Equality[(K, V)]): Aggregating[MAP[K, V]]
Implicit to support
Aggregatingnature ofscala.collection.GenMap.Implicit to support
Aggregatingnature ofscala.collection.GenMap.- K
 the type of the key in the
scala.collection.GenMap- V
 the type of the value in the
scala.collection.GenMap- MAP
 any subtype of
scala.collection.GenMap- equality
 Equalitytype class that is used to check equality of entry in thescala.collection.GenMap- returns
 Aggregating[MAP[K, V]]that supportsscala.collection.GenMapin relevantcontainsyntax
- Definition Classes
 - AggregatingHighPriorityImplicits
 
 -   implicit  def aggregatingNatureOfString(implicit equality: Equality[Char]): Aggregating[String]
Implicit to support
Aggregatingnature ofString.Implicit to support
Aggregatingnature ofString.- equality
 Equalitytype class that is used to check equality ofCharin theString- returns
 Aggregating[String]that supportsStringin relevantcontainsyntax
- Definition Classes
 - AggregatingStandardImplicits
 
 -   final  def asInstanceOf[T0]: T0
- Definition Classes
 - Any
 
 -    def clone(): AnyRef
- Attributes
 - protected[lang]
 - Definition Classes
 - AnyRef
 - Annotations
 - @throws(classOf[java.lang.CloneNotSupportedException]) @native()
 
 -   implicit  def convertEqualityToArrayAggregating[E](equality: Equality[E]): Aggregating[Array[E]]
Implicit conversion that converts an
Equalityof typeEintoAggregatingof typeArray[E].Implicit conversion that converts an
Equalityof typeEintoAggregatingof typeArray[E]. This is required to support the explicitEqualitysyntax, for example:(Array("hi") should contain ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoAggregating[Array[String]].- E
 type of elements in the
Array- equality
 Equalityof typeE- returns
 Aggregatingof typeArray[E]
- Definition Classes
 - AggregatingStandardImplicits
 
 -   implicit  def convertEqualityToEveryAggregating[E](equality: Equality[E]): Aggregating[Every[E]]
Implicit conversion that converts an
Equalityof typeEintoAggregatingof typeEvery[E].Implicit conversion that converts an
Equalityof typeEintoAggregatingof typeEvery[E]. This is required to support the explicitEqualitysyntax, for example:(Every("hi") should contain ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoAggregating[Every[String]].- E
 type of elements in the
Every- equality
 Equalityof typeE- returns
 Aggregatingof typeEvery[E]
- Definition Classes
 - AggregatingStandardImplicits
 
 -   implicit  def convertEqualityToGenTraversableAggregating[E, TRAV[e] <: GenTraversable[e]](equality: Equality[E]): Aggregating[TRAV[E]]
Implicit conversion that converts an
Equalityof typeEintoAggregatingof typeTRAV[E], whereTRAVis a subtype ofGenTraversable.Implicit conversion that converts an
Equalityof typeEintoAggregatingof typeTRAV[E], whereTRAVis a subtype ofGenTraversable. This is required to support the explicitEqualitysyntax, for example:(List("hi") should contain ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoAggregating[List[String]].- E
 type of elements in the
GenTraversable- TRAV
 subtype of
GenTraversable- equality
 Equalityof typeE- returns
 Aggregatingof typeTRAV[E]
- Definition Classes
 - AggregatingStandardImplicits
 
 -   implicit  def convertEqualityToJavaCollectionAggregating[E, JCOL[e] <: Collection[e]](equality: Equality[E]): Aggregating[JCOL[E]]
Implicit conversion that converts an
Equalityof typeEintoAggregatingof typeJCOL[E], whereJCOLis a subtype ofjava.util.Collection.Implicit conversion that converts an
Equalityof typeEintoAggregatingof typeJCOL[E], whereJCOLis a subtype ofjava.util.Collection. This is required to support the explicitEqualitysyntax, for example:val javaList = new java.util.ArrayList[String]() javaList.add("hi") (javaList should contain ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoAggregating[java.util.ArrayList[String]].- E
 type of elements in the
java.util.Collection- JCOL
 subtype of
java.util.Collection- equality
 Equalityof typeE- returns
 Aggregatingof typeJCOL[E]
- Definition Classes
 - AggregatingJavaImplicits
 
 -   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
Equalityof typejava.util.Map.Entry[K, V]intoAggregatingof typeJMAP[K, V], whereJMAPis a subtype ofjava.util.Map.Implicit conversion that converts an
Equalityof typejava.util.Map.Entry[K, V]intoAggregatingof typeJMAP[K, V], whereJMAPis a subtype ofjava.util.Map. This is required to support the explicitEqualitysyntax, 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 anjava.util.Map.Entry[Int, String]and this implicit conversion will convert it intoAggregating[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
 Equalityof typejava.util.Map.Entry[K, V]- returns
 Aggregatingof typeJMAP[K, V]
- Definition Classes
 - AggregatingJavaImplicits
 
 -   implicit  def convertEqualityToMapAggregating[K, V, MAP[k, v] <: GenMap[k, v]](equality: Equality[(K, V)]): Aggregating[GenMap[K, V]]
Implicit conversion that converts an
Equalityof typeTuple2[K, V]intoAggregatingof typeMAP[K, V], whereMAPis a subtype ofscala.collection.GenMap.Implicit conversion that converts an
Equalityof typeTuple2[K, V]intoAggregatingof typeMAP[K, V], whereMAPis a subtype ofscala.collection.GenMap. This is required to support the explicitEqualitysyntax, for example:val map = Map(1 -> "one") // lowerCased needs to be implemented as Normalization[Tuple2[K, V]] (map should contain ((1, "ONE"))) (after being lowerCased)
(after being lowerCased)will returns anTuple2[Int, String]and this implicit conversion will convert it intoAggregating[scala.collection.GenMap[Int, String]].- K
 the type of the key in the
scala.collection.GenMap- V
 the type of the value in the
scala.collection.GenMap- MAP
 any subtype of
scala.collection.GenMap- equality
 Equalityof typeTuple2[K, V]- returns
 Aggregatingof typeMAP[K, V]
- Definition Classes
 - AggregatingHighPriorityImplicits
 
 -   implicit  def convertEqualityToStringAggregating(equality: Equality[Char]): Aggregating[String]
Implicit conversion that converts an
Equalityof typeCharintoAggregatingof typeString.Implicit conversion that converts an
Equalityof typeCharintoAggregatingof typeString. This is required to support the explicitEqualitysyntax, for example:// lowerCased needs to be implemented as Normalization[Char] ("hi hello" should contain ('E')) (after being lowerCased)
(after being lowerCased)will returns anEquality[Char]and this implicit conversion will convert it intoAggregating[String].- equality
 Equalityof typeChar- returns
 Aggregatingof typeString
- Definition Classes
 - AggregatingStandardImplicits
 
 -   final  def eq(arg0: AnyRef): Boolean
- Definition Classes
 - AnyRef
 
 -    def equals(arg0: AnyRef): Boolean
- Definition Classes
 - AnyRef → Any
 
 -    def finalize(): Unit
- Attributes
 - protected[lang]
 - Definition Classes
 - AnyRef
 - Annotations
 - @throws(classOf[java.lang.Throwable])
 
 -   final  def getClass(): Class[_ <: AnyRef]
- Definition Classes
 - AnyRef → Any
 - Annotations
 - @native()
 
 -    def hashCode(): Int
- Definition Classes
 - AnyRef → Any
 - Annotations
 - @native()
 
 -   final  def isInstanceOf[T0]: Boolean
- Definition Classes
 - Any
 
 -   final  def ne(arg0: AnyRef): Boolean
- Definition Classes
 - AnyRef
 
 -   final  def notify(): Unit
- Definition Classes
 - AnyRef
 - Annotations
 - @native()
 
 -   final  def notifyAll(): Unit
- Definition Classes
 - AnyRef
 - Annotations
 - @native()
 
 -   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(classOf[java.lang.InterruptedException])
 
 -   final  def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
 - AnyRef
 - Annotations
 - @throws(classOf[java.lang.InterruptedException])
 
 -   final  def wait(arg0: Long): Unit
- Definition Classes
 - AnyRef
 - Annotations
 - @throws(classOf[java.lang.InterruptedException]) @native()