avoiding some synchronization on combineLatest
Merge branch 'master' into combineLatest
Merge branch 'master' into combineLatest
handled combine functions that throw exceptions and added a test against this case
added combineLatest static methods to Observable
Got rid of the last remnants of synchronization in favor of a concurrent map.
Fixed a javadoc parameter.
improved generics for combineLatest (PECS principle)
Tried to adapt according to Ben's review comments.
adding several marble diagrams

several new marble diagrams for previously undiagrammed methods
Merge pull request #279 from DavidMGross/master

Adding marble diagrams
Diagrams and some new docs for Observable subclasses

Some marble or marblish diagrams and a bit of new documentation for the
BlockingObservable and ConnectableObservable subclasses.
Merge pull request #280 from DavidMGross/master

Diagrams and some new javadoc content for Observable subclasses
Add to marble diagrams

Add several new or more-specific marble diagrams, correct two bad image
links, correct some typos
Commentary on constructing an Observable

- I would like to remove the no-arg constructor but not ready to pull the trigger
Prevent direct instantiation of BlockingObservable via no-arg constructor

- also questioning why to allow extending this and would like to make it a private constructor
Common approach for IllegalArgumentException on subscribe methods

As brought up in https://github.com/Netflix/RxJava/issues/278 there were inconsistencies in how arguments were being validated on subscribe methods.

All arguments to subscribe are now validated correctly at the beginning of method invocation and IllegalArgumentException thrown if null arguments are injected.

According to Rx Guideline 6.5 a null argument is considered "a catastrophic error occurs that should bring down the whole program anyway" and thus we immediately throw. A null argument should be caught immediately in development and has nothing to do with subscribe invocation which is what guideline 6.5 is talking about (since a null Observer can't have onError called on it anyways).
Throw if no onError handler specified

https://github.com/Netflix/RxJava/issues/198

As per Rx Design Guidelines 5.2:

 "when calling the Subscribe method that only has an onNext argument, the OnError behavior will be
 to rethrow the exception on the thread that the message comes out from the observable sequence.
 The OnCompleted behavior in this case is to do nothing."

A new OnErrorNotImplementedException was created so it is explicit as to where the exception is coming from and why.
Merge pull request #285 from DavidMGross/master

Several new or more-precise marble diagrams
Fix PublishSubject non-deterministic behavior on concurrent modification

- changed to take snapshot of observers.values() before iterating in onNext/onError/onCompleted so that nested subscriptions that add to observers can't change the values() iteration
- single-threaded nested subscriptions are now deterministic
- multi-threaded subscriptions will no longer be allowed to race to get into an interating onNext/onError/onCompleted loop, they will always wait until the next
- also improved terminal state behavior when subscribing to a PublishSubject that has already received onError/onCompleted

https://github.com/Netflix/RxJava/issues/282