object Containing
Companion object for Containing that provides implicit implementations for the following types:
scala.collection.GenTraversableStringArrayscala.Optionjava.util.Collectionjava.util.Map
- Source
 - Containing.scala
 
- Alphabetic
 - By Inheritance
 
- Containing
 - AnyRef
 - Any
 
- Hide All
 - Show All
 
- Public
 - All
 
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
 
 - 
      
      
      
        
      
    
      
        final 
        def
      
      
        asInstanceOf[T0]: T0
      
      
      
- Definition Classes
 - Any
 
 - 
      
      
      
        
      
    
      
        
        def
      
      
        clone(): AnyRef
      
      
      
- Attributes
 - protected[java.lang]
 - Definition Classes
 - AnyRef
 - Annotations
 - @native() @throws( ... )
 
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        containingNatureOfArray[E](implicit equality: Equality[E]): Containing[Array[E]]
      
      
      
Implicit to support
Containingnature ofArray.Implicit to support
Containingnature ofArray.- E
 the type of the element in the
Array- equality
 Equalitytype class that is used to check equality of element in theArray- returns
 Containing[Array[E]]that supportsArrayin relevantcontainsyntax
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        containingNatureOfEvery[E](implicit equality: Equality[E]): Containing[Every[E]]
      
      
      
Implicit to support
Containingnature ofEvery.Implicit to support
Containingnature ofEvery.- E
 the type of the element in the
Every- equality
 Equalitytype class that is used to check equality of element in theEvery- returns
 Containing[Every[E]]that supportsEveryin relevantcontainsyntax
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        containingNatureOfGenTraversable[E, TRAV[e] <: GenTraversable[e]](implicit equality: Equality[E]): Containing[TRAV[E]]
      
      
      
Implicit to support
Containingnature ofGenTraversable.Implicit to support
Containingnature 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
 Containing[TRAV[E]]that supportsGenTraversablein relevantcontainsyntax
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        containingNatureOfJavaCollection[E, JCOL[e] <: Collection[e]](implicit equality: Equality[E]): Containing[JCOL[E]]
      
      
      
Implicit to support
Containingnature ofjava.util.Collection.Implicit to support
Containingnature 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
 Containing[JCOL[E]]that supportsjava.util.Collectionin relevantcontainsyntax
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        containingNatureOfJavaMap[K, V, JMAP[k, v] <: Map[k, v]](implicit equality: Equality[java.util.Map.Entry[K, V]]): Containing[JMAP[K, V]]
      
      
      
Implicit to support
Containingnature ofjava.util.Map.Implicit to support
Containingnature 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
 Containing[JMAP[K, V]]that supportsjava.util.Mapin relevantcontainsyntax
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        containingNatureOfOption[E, OPT[e] <: Option[e]](implicit equality: Equality[E]): Containing[OPT[E]]
      
      
      
Implicit to support
Containingnature ofscala.Option.Implicit to support
Containingnature ofscala.Option.- E
 the type of the element in the
scala.Option- OPT
 any subtype of
scala.Option- equality
 Equalitytype class that is used to check equality of element in theOption- returns
 Containing[OPT[E]]that supportsscala.Optionin relevantcontainsyntax
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        containingNatureOfString(implicit equality: Equality[Char]): Containing[String]
      
      
      
Implicit to support
Containingnature ofString.Implicit to support
Containingnature ofString.- equality
 Equalitytype class that is used to check equality ofCharin theString- returns
 Containing[String]that supportsStringin relevantcontainsyntax
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        convertEqualityToArrayContaining[E](equality: Equality[E]): Containing[Array[E]]
      
      
      
Implicit conversion that converts an
Equalityof typeEintoContainingof typeArray[E].Implicit conversion that converts an
Equalityof typeEintoContainingof typeArray[E]. This is required to support the explicitEqualitysyntax, for example:(Array("hi") should contain oneOf ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoContaining[Array[String]].- E
 type of elements in the
Array- equality
 Equalityof typeE- returns
 Containingof typeArray[E]
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        convertEqualityToEveryContaining[E](equality: Equality[E]): Containing[Every[E]]
      
      
      
Implicit conversion that converts an
Equalityof typeEintoContainingof typeEvery[E].Implicit conversion that converts an
Equalityof typeEintoContainingof typeEvery[E]. This is required to support the explicitEqualitysyntax, for example:(Every("hi", "he", "ho") should contain oneOf ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoContaining[Every[String]].- E
 type of elements in the
Every- equality
 Equalityof typeE- returns
 Containingof typeEvery[E]
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        convertEqualityToGenTraversableContaining[E, TRAV[e] <: GenTraversable[e]](equality: Equality[E]): Containing[TRAV[E]]
      
      
      
Implicit conversion that converts an
Equalityof typeEintoContainingof typeTRAV[E], whereTRAVis a subtype ofGenTraversable.Implicit conversion that converts an
Equalityof typeEintoContainingof typeTRAV[E], whereTRAVis a subtype ofGenTraversable. This is required to support the explicitEqualitysyntax, for example:(List("hi") should contain oneOf ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoContaining[List[String]].- E
 type of elements in the
GenTraversable- TRAV
 subtype of
GenTraversable- equality
 Equalityof typeE- returns
 Containingof typeTRAV[E]
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        convertEqualityToJavaCollectionContaining[E, JCOL[e] <: Collection[e]](equality: Equality[E]): Containing[JCOL[E]]
      
      
      
Implicit conversion that converts an
Equalityof typeEintoContainingof typeJCOL[E], whereJCOLis a subtype ofjava.util.Collection.Implicit conversion that converts an
Equalityof typeEintoContainingof 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 oneOf ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoContaining[java.util.ArrayList[String]].- E
 type of elements in the
java.util.Collection- JCOL
 subtype of
java.util.Collection- equality
 Equalityof typeE- returns
 Containingof typeJCOL[E]
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        convertEqualityToJavaMapContaining[K, V, JMAP[k, v] <: Map[k, v]](equality: Equality[java.util.Map.Entry[K, V]]): Containing[JMAP[K, V]]
      
      
      
Implicit conversion that converts an
Equalityof typejava.util.Map.Entry[K, V]intoContainingof typeJMAP[K, V], whereJMAPis a subtype ofjava.util.Map.Implicit conversion that converts an
Equalityof typejava.util.Map.Entry[K, V]intoContainingof 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 intoContaining[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
 Containingof typeJMAP[K, V]
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        convertEqualityToOptionContaining[E, OPT[e] <: Option[e]](equality: Equality[E]): Containing[OPT[E]]
      
      
      
Implicit conversion that converts an
Equalityof typeEintoContainingof typeOPT[E], whereOPTis a subtype ofscala.Option.Implicit conversion that converts an
Equalityof typeEintoContainingof typeOPT[E], whereOPTis a subtype ofscala.Option. This is required to support the explicitEqualitysyntax, for example:(Some("hi") should contain oneOf ("HI")) (after being lowerCased)
(after being lowerCased)will returns anEquality[String]and this implicit conversion will convert it intoContaining[Some[String]].- E
 type of elements in the
scala.Option- OPT
 subtype of
scala.Option- equality
 Equalityof typeE- returns
 Containingof typeOPT[E]
 - 
      
      
      
        
      
    
      
        implicit 
        def
      
      
        convertEqualityToStringContaining(equality: Equality[Char]): Containing[String]
      
      
      
Implicit conversion that converts an
Equalityof typeCharintoContainingof typeString.Implicit conversion that converts an
Equalityof typeCharintoContainingof typeString. This is required to support the explicitEqualitysyntax, for example:// lowerCased needs to be implemented as Normalization[Char] ("hi hello" should contain oneOf ('E')) (after being lowerCased)
(after being lowerCased)will returns anEquality[Char]and this implicit conversion will convert it intoContaining[String].- equality
 Equalityof typeChar- returns
 Containingof typeString
 - 
      
      
      
        
      
    
      
        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( classOf[java.lang.Throwable] )
 
 - 
      
      
      
        
      
    
      
        final 
        def
      
      
        getClass(): Class[_]
      
      
      
- 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( ... )
 
 - 
      
      
      
        
      
    
      
        final 
        def
      
      
        wait(arg0: Long, arg1: Int): Unit
      
      
      
- Definition Classes
 - AnyRef
 - Annotations
 - @throws( ... )
 
 - 
      
      
      
        
      
    
      
        final 
        def
      
      
        wait(arg0: Long): Unit
      
      
      
- Definition Classes
 - AnyRef
 - Annotations
 - @native() @throws( ... )