final class Chars extends AnyVal with Idx.Immutable[Char]

Immutable Char Array Wrap

There is alias for this type at Scalqa root, so it can be universally used as scalqa.Chars

Ordering
  1. Alphabetic
Inherited
  1. Chars
  2. Idx.Immutable
  3. Idx
  4. ZZ.Array.Like.View
  5. Util.Able.Void
  6. scala.AnyVal
  7. scala.Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type

  1. type Chars.TYPE = Idx.Immutable.Chars
    Attributes
    protected
    Definition Classes
    Chars_Trait → View

Constant

  1. val base: Array[Char]
    Attributes
    protected
    Definition Classes
    Chars → View

Method

  1. def all: ~[Char]

    Returns a Stream of all elements

    Returns a Stream of all elements

    The element order is same as in the Idx.

    val idx: Idx[Char] = ('a' to 'g').all.to[Idx]
    
    println(idx.all) // Prints: ~(a, b, c, d, e, f, g)
    Definition Classes
    Chars_Trait
  2. def apply(i: Int): Char

    Returns element at position

    Returns element at position

    val idx : Idx[Char] = ('a' to 'z').all.to[Idx]
    
     println(idx(1)) // Prints: b
    
     println(idx(3)) // Prints: d
    Definition Classes
    Chars_Trait → View
  3. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  4. def contains(v: Char): Boolean

    Inclusion check

    Inclusion check

    Returns true if specified value is contained within

    Definition Classes
    _Trait → View
  5. def copy(start: Int = 0, end: Opt.Int = \/): Chars.TYPE

    Copy range

    Copy range

    Copies elements within the range specified

    val ii : Idx.Immutable[Char] = ('A' to 'Z').all.to[Idx.Immutable]
    
    ii.copy(3, 10).all      // Stream: ~(D, E, F, G, H, I, J, K)
    Definition Classes
    Chars → View
  6. def copyLast(number: Int): Chars.TYPE

    Copy end

    Copy end

    Copies specified number of elements at the end

    val ii : Idx.Immutable[Char] = ('A' to 'Z').all.to[Idx.Immutable]
    
    ii.copyLast(5).all       // Stream: ~(V, W, X, Y, Z)
    Definition Classes
    View
  7. def copyRemove(start: Int, end: Opt.Int = \/): Chars

    Copy without range

    Copy without range

    Copies elements outside the range specified

    val ii : Idx.Immutable[Char] = ('A' to 'Z').all.to[Idx.Immutable]
    
    ii.copyRemove(3, 21).all  // Stream: ~(A, B, C, V, W, X, Y, Z)
    Definition Classes
    Chars → View
  8. def copyShort(cnt: Int): Chars.TYPE

    Copy without end

    Copy without end

    Copies from the beginning, missing specified number of elements at the end

    val ii : Idx.Immutable[Char] = ('A' to 'Z').all.to[Idx.Immutable]
    
    ii.copyShort(20).all    // Stream: ~(A, B, C, D, E, F)
    Definition Classes
    View
  9. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  10. def isVoid: Boolean

    Void check

    Void check

    Returns true if this instance is void

    Definition Classes
    View → Void
  11. def make: (Array[Char]) ⇒ Chars
    Attributes
    protected
    Definition Classes
    Chars → View
  12. def size: Int

    Returns element count

    Returns element count

    val idx: Idx[Char] = ('a' to 'z').all.to[Idx]
    
    println(idx.size) // Prints: 26
    Definition Classes
    Chars_Trait → View
  13. def toArray(implicit t: ClassTag[Char]): Array[Char]

    Copy to Array

    Copy to Array

    Copies all elements to a new Array

    Definition Classes
    Chars → View
  14. final def toRaw[TRGT <: Idx.Immutable[Char]](implicit c: RawConverter[Char, TRGT]): TRGT

    To raw immutable

    To raw immutable

    Converts this Idx.Immutable or Refs to raw immutable

    Note. This method is inherited by raw immutables themselves (like Chars,Ints, etc.), where it does not make sense to use

    Supported targets are:

    val r: Refs[Int] = Refs.*(1, 2, 3, 4)
    
    val ints: Ints = r.toRaw[Ints]
    
    // ------------------------------------
    
    val ii: Idx.Immutable[Char] = ('a' to 'z').all.to[Idx.Immutable]
    
    val chars: Chars = ii.toRaw[Chars]
    Definition Classes
    _Trait
  15. def toString(): String

    Description

    Description

    Provides description of size and array type

    Definition Classes
    View → Any

Operator

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  2. final def ##(): Int
    Definition Classes
    Any
  3. def +(v: Char): Chars

    Plus

    Plus

    Creates a new instance with value added

    var ii: Idx.Immutable[Char] = Seq('a', 'b', 'c').all.to[Idx.Immutable]
    
    ii = ii + 'x' + 'y' + 'z'
    
    ii.all // Stream:  ~(a, b, c, x, y, z)
    Definition Classes
    Chars → View
  4. def +@(i: Int, v: Char): Chars

    Plus at position

    Plus at position

    Creates a new instance with specified value inserted at specified position

    var ii: Idx.Immutable[Char] = Seq('a', 'b', 'c').all.to[Idx.Immutable]
    
    ii = ii +@ (0, 'X') +@ (0, 'Y') +@ (0, 'Z')
    
    ii.all    // Stream: ~(Z, Y, X, a, b, c)
    Definition Classes
    Chars → View
  5. def +~(v: ~[Char]): Chars

    Plus all

    Plus all

    Creates a new instance with added stream of values

    var ii: Idx.Immutable[Char] = Seq('a', 'b', 'c').all.to[Idx.Immutable]
    
    ii = ii +~ Seq('x', 'y', 'z').all
    
    ii.all   // Stream:  ~(a, b, c, x, y, z)
    Definition Classes
    Chars → View
  6. def +~@(i: Int, v: ~[Char]): Chars

    Plus stream at position

    Plus stream at position

    Creates a new instance with stream values added at specified position

    var ii: Idx.Immutable[Char] = Seq('a', 'b', 'c').all.to[Idx.Immutable]
    
    ii = ii +~@ (1, Seq('X', 'Y', 'Z'))
    
    ii.all   // Stream: ~(a, X, Y, Z, b, c)
    Definition Classes
    Chars → View
  7. def -(v: Char): Chars

    Subtract value

    Subtract value

    Creates a new instance with all values equal to the specified removed

    var ii: Idx.Immutable[Char] = Seq('a', 'b', 'b', 'c').all.to[Idx.Immutable]
    
    ii = ii - 'b'
    
    ii.all   // Stream: ~(a, c)
    Definition Classes
    Chars → View
  8. def -~(v: ~[Char]): Chars

    Subtract all values

    Subtract all values

    Creates a new instance with all values equal to the specified removed

    var ii: Idx.Immutable[Char] = ('a' to 'z').all.to[Idx.Immutable]
    
    ii = ii -~ ('d' to 'x')
    
    ii.all    // Stream: ~(a, b, c, y, z)
    Definition Classes
    Chars → View
  9. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
Linear Supertypes
Idx.Immutable[Char], Idx[Char], View[Char], Util.Able.Void, AnyVal, Any
Source: Chars.scala