Package rx.internal.operators

Class OperatorZip.Zip<R>

java.lang.Object

java.lang.Number

java.util.concurrent.atomic.AtomicLong

rx.internal.operators.OperatorZip.Zip<R>

All Implemented Interfaces:

java.io.Serializable

Enclosing class:

OperatorZip<R>

static final class OperatorZip.Zip<R>
extends java.util.concurrent.atomic.AtomicLong

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) class	OperatorZip.Zip.InnerSubscriber

Field Summary

Fields

Modifier and Type	Field	Description
(package private) Observer<? super R>	child
private CompositeSubscription	childSubscription
(package private) int	emitted
private java.util.concurrent.atomic.AtomicLong	requested
private static long	serialVersionUID
private java.lang.Object[]	subscribers
(package private) static int	THRESHOLD
private FuncN<? extends R>	zipFunction

Constructor Summary

Constructors

Constructor	Description
Zip(Subscriber<? super R> child, FuncN<? extends R> zipFunction)

Method Summary

Modifier and Type	Method	Description
void	start(Observable[] os, java.util.concurrent.atomic.AtomicLong requested)
(package private) void	tick()	check if we have values for each and emit if we do This will only allow one thread at a time to do the work, but ensures via `counter` increment/decrement that there is always once who acts on each `tick`.

Methods inherited from class java.util.concurrent.atomic.AtomicLong

accumulateAndGet, addAndGet, compareAndExchange, compareAndExchangeAcquire, compareAndExchangeRelease, compareAndSet, decrementAndGet, doubleValue, floatValue, get, getAcquire, getAndAccumulate, getAndAdd, getAndDecrement, getAndIncrement, getAndSet, getAndUpdate, getOpaque, getPlain, incrementAndGet, intValue, lazySet, longValue, set, setOpaque, setPlain, setRelease, toString, updateAndGet, weakCompareAndSet, weakCompareAndSetAcquire, weakCompareAndSetPlain, weakCompareAndSetRelease, weakCompareAndSetVolatile

Methods inherited from class java.lang.Number

byteValue, shortValue

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

serialVersionUID

private static final long serialVersionUID

See Also:

Constant Field Values

child

final Observer<? super R> child

zipFunction

private final FuncN<? extends R> zipFunction

childSubscription

private final CompositeSubscription childSubscription

THRESHOLD

static final int THRESHOLD

emitted

int emitted

subscribers

private volatile java.lang.Object[] subscribers

requested

private java.util.concurrent.atomic.AtomicLong requested

Constructor Detail

Zip

public Zip(Subscriber<? super R> child,
           FuncN<? extends R> zipFunction)

Method Detail

start

public void start(Observable[] os,
                  java.util.concurrent.atomic.AtomicLong requested)

tick

void tick()

check if we have values for each and emit if we do This will only allow one thread at a time to do the work, but ensures via `counter` increment/decrement that there is always once who acts on each `tick`. Same concept as used in OperationObserveOn.