scala-stm/scala.concurrent.stm.skel/AtomicArray

AtomicArray

object AtomicArray extends StrictOptimizedClassTagSeqFactory[[T] =>> AtomicArray[T]]
Companion
class
trait StrictOptimizedClassTagSeqFactory[[T] =>> AtomicArray[T]]
trait ClassTagSeqFactory[[T] =>> AtomicArray[T]]
trait ClassTagIterableFactory[[T] =>> AtomicArray[T]]
trait EvidenceIterableFactory[[T] =>> AtomicArray[T], [T] =>> ClassTag[T]]
trait Serializable
class Object
trait Matchable
class Any

Type members

Classlikes

final class ofBoolean(elems: AtomicIntegerArray) extends AtomicArray[Boolean]
final class ofByte(elems: AtomicIntegerArray) extends AtomicArray[Byte]
final class ofChar(elems: AtomicIntegerArray) extends AtomicArray[Char]
final class ofDouble(elems: AtomicLongArray) extends AtomicArray[Double]
final class ofFloat(elems: AtomicIntegerArray) extends AtomicArray[Float]
final class ofInt(elems: AtomicIntegerArray) extends AtomicArray[Int]
final class ofLong(elems: AtomicLongArray) extends AtomicArray[Long]
final class ofRef[T <: AnyRef](elems: AtomicReferenceArray[T]) extends AtomicArray[T]
final class ofShort(elems: AtomicIntegerArray) extends AtomicArray[Short]
final class ofUnit(val length: Int) extends AtomicArray[Unit]

Value members

Concrete methods

def apply[T](size: Int)(m: ClassTag[T]): AtomicArray[T]
def apply(elems: Array[Boolean]): ofBoolean
def apply(elems: Array[Byte]): ofByte
def apply(elems: Array[Short]): ofShort
def apply(elems: Array[Char]): ofChar
def apply(elems: Array[Int]): ofInt
def apply(elems: Array[Float]): ofFloat
def apply(elems: Array[Long]): ofLong
def apply(elems: Array[Double]): ofDouble
def apply(elems: Array[Unit]): ofUnit
def apply[T <: AnyRef](elems: Array[T]): ofRef[T]
def apply[T](elems: IterableOnce[T])(m: ClassTag[T]): AtomicArray[T]
def empty[T](m: ClassTag[T]): AtomicArray[T]
def from[T](it: IterableOnce[T])(m: ClassTag[T]): AtomicArray[T]
def newBuilder[T](m: ClassTag[T]): Builder[T, AtomicArray[T]]

Inherited methods

def apply[A](xs: A*)(Ev[A]): AtomicArray[A]
Inherited from
EvidenceIterableFactory
override def fill[A](n: Int)(elem: => A)(ClassTag[A]): AtomicArray[A]
Definition Classes
StrictOptimizedClassTagSeqFactory -> EvidenceIterableFactory
Inherited from
StrictOptimizedClassTagSeqFactory
def fill[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => A)(ClassTag[A]): AtomicArray[AtomicArray[AtomicArray[AtomicArray[AtomicArray[A]]]]]
Inherited from
ClassTagIterableFactory
def fill[A](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => A)(ClassTag[A]): AtomicArray[AtomicArray[AtomicArray[AtomicArray[A]]]]
Inherited from
ClassTagIterableFactory
def fill[A](n1: Int, n2: Int, n3: Int)(elem: => A)(ClassTag[A]): AtomicArray[AtomicArray[AtomicArray[A]]]
Inherited from
ClassTagIterableFactory
def fill[A](n1: Int, n2: Int)(elem: => A)(ClassTag[A]): AtomicArray[AtomicArray[A]]
Inherited from
ClassTagIterableFactory
def iterate[A](start: A, len: Int)(f: A => A)(Ev[A]): AtomicArray[A]
Inherited from
EvidenceIterableFactory
def range[A](start: A, end: A, step: A)(Integral[A], ClassTag[A]): AtomicArray[A]
Inherited from
ClassTagIterableFactory
def range[A](start: A, end: A)(Integral[A], ClassTag[A]): AtomicArray[A]
Inherited from
ClassTagIterableFactory
override def tabulate[A](n: Int)(f: Int => A)(ClassTag[A]): AtomicArray[A]
Definition Classes
StrictOptimizedClassTagSeqFactory -> EvidenceIterableFactory
Inherited from
StrictOptimizedClassTagSeqFactory
def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => A)(ClassTag[A]): AtomicArray[AtomicArray[AtomicArray[AtomicArray[AtomicArray[A]]]]]
Inherited from
ClassTagIterableFactory
def tabulate[A](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => A)(ClassTag[A]): AtomicArray[AtomicArray[AtomicArray[AtomicArray[A]]]]
Inherited from
ClassTagIterableFactory
def tabulate[A](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => A)(ClassTag[A]): AtomicArray[AtomicArray[AtomicArray[A]]]
Inherited from
ClassTagIterableFactory
def tabulate[A](n1: Int, n2: Int)(f: (Int, Int) => A)(ClassTag[A]): AtomicArray[AtomicArray[A]]
Inherited from
ClassTagIterableFactory
final def unapplySeq[A](x: AtomicArray[A]): UnapplySeqWrapper[A]
Inherited from
ClassTagSeqFactory
def unfold[A, S](init: S)(f: S => Option[(A, S)])(Ev[A]): AtomicArray[A]
Inherited from
EvidenceIterableFactory

Concrete fields

val untagged: SeqFactory[[T] =>> AtomicArray[T]]

Implicits

Inherited implicits

implicit def evidenceIterableFactory[A](Ev[A]): Factory[A, AtomicArray[A]]
Inherited from
EvidenceIterableFactory