Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/AddRef.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Reactive.Disposables;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class AddRef<TSource> : Producer<TSource>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly RefCountDisposable _refCount;
+
+        public AddRef(IObservable<TSource> source, RefCountDisposable refCount)
+        {
+            _source = source;
+            _refCount = refCount;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var d = new CompositeDisposable(_refCount.GetDisposable(), cancel);
+
+            var sink = new _(observer, d);
+            setSink(sink);
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<TSource>, IObserver<TSource>
+        {
+            public _(IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+            }
+
+            public void OnNext(TSource value)
+            {
+                base._observer.OnNext(value);
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Aggregate.cs

@@ -0,0 +1,158 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Aggregate<TSource, TAccumulate, TResult> : Producer<TResult>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly TAccumulate _seed;
+        private readonly Func<TAccumulate, TSource, TAccumulate> _accumulator;
+        private readonly Func<TAccumulate, TResult> _resultSelector;
+
+        public Aggregate(IObservable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> accumulator, Func<TAccumulate, TResult> resultSelector)
+        {
+            _source = source;
+            _seed = seed;
+            _accumulator = accumulator;
+            _resultSelector = resultSelector;
+        }
+
+        protected override IDisposable Run(IObserver<TResult> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<TResult>, IObserver<TSource>
+        {
+            private readonly Aggregate<TSource, TAccumulate, TResult> _parent;
+            private TAccumulate _accumulation;
+
+            public _(Aggregate<TSource, TAccumulate, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+                _accumulation = _parent._seed;
+            }
+
+            public void OnNext(TSource value)
+            {
+                try
+                {
+                    _accumulation = _parent._accumulator(_accumulation, value);
+                }
+                catch (Exception exception)
+                {
+                    base._observer.OnError(exception);
+                    base.Dispose();
+                }
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                var result = default(TResult);
+                try
+                {
+                    result = _parent._resultSelector(_accumulation);
+                }
+                catch (Exception exception)
+                {
+                    base._observer.OnError(exception);
+                    base.Dispose();
+                    return;
+                }
+
+                base._observer.OnNext(result);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+
+    class Aggregate<TSource> : Producer<TSource>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly Func<TSource, TSource, TSource> _accumulator;
+
+        public Aggregate(IObservable<TSource> source, Func<TSource, TSource, TSource> accumulator)
+        {
+            _source = source;
+            _accumulator = accumulator;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<TSource>, IObserver<TSource>
+        {
+            private readonly Aggregate<TSource> _parent;
+            private TSource _accumulation;
+            private bool _hasAccumulation;
+
+            public _(Aggregate<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+                _accumulation = default(TSource);
+                _hasAccumulation = false;
+            }
+
+            public void OnNext(TSource value)
+            {
+                if (!_hasAccumulation)
+                {
+                    _accumulation = value;
+                    _hasAccumulation = true;
+                }
+                else
+                {
+                    try
+                    {
+                        _accumulation = _parent._accumulator(_accumulation, value);
+                    }
+                    catch (Exception exception)
+                    {
+                        base._observer.OnError(exception);
+                        base.Dispose();
+                    }
+                }
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                if (!_hasAccumulation)
+                {
+                    base._observer.OnError(new InvalidOperationException(Strings_Linq.NO_ELEMENTS));
+                    base.Dispose();
+                }
+                else
+                {
+                    base._observer.OnNext(_accumulation);
+                    base._observer.OnCompleted();
+                    base.Dispose();
+                }
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/All.cs

@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class All<TSource> : Producer<bool>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly Func<TSource, bool> _predicate;
+
+        public All(IObservable<TSource> source, Func<TSource, bool> predicate)
+        {
+            _source = source;
+            _predicate = predicate;
+        }
+
+        protected override IDisposable Run(IObserver<bool> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<bool>, IObserver<TSource>
+        {
+            private readonly All<TSource> _parent;
+
+            public _(All<TSource> parent, IObserver<bool> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+            }
+
+            public void OnNext(TSource value)
+            {
+                var res = false;
+                try
+                {
+                    res = _parent._predicate(value);
+                }
+                catch (Exception ex)
+                {
+                    base._observer.OnError(ex);
+                    base.Dispose();
+                    return;
+                }
+
+                if (!res)
+                {
+                    base._observer.OnNext(false);
+                    base._observer.OnCompleted();
+                    base.Dispose();
+                }
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnNext(true);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Amb.cs

@@ -0,0 +1,173 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Reactive.Disposables;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Amb<TSource> : Producer<TSource>
+    {
+        private readonly IObservable<TSource> _left;
+        private readonly IObservable<TSource> _right;
+
+        public Amb(IObservable<TSource> left, IObservable<TSource> right)
+        {
+            _left = left;
+            _right = right;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return sink.Run();
+        }
+
+        class _ : Sink<TSource>
+        {
+            private readonly Amb<TSource> _parent;
+
+            public _(Amb<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+            }
+
+            private AmbState _choice;
+
+            public IDisposable Run()
+            {
+                var ls = new SingleAssignmentDisposable();
+                var rs = new SingleAssignmentDisposable();
+                var d = new CompositeDisposable(ls, rs);
+
+                var gate = new object();
+
+                var lo = new AmbObserver();
+                lo._disposable = d;
+                lo._target = new DecisionObserver(this, gate, AmbState.Left, ls, rs, lo);
+
+                var ro = new AmbObserver();
+                ro._disposable = d;
+                ro._target = new DecisionObserver(this, gate, AmbState.Right, rs, ls, ro);
+
+                _choice = AmbState.Neither;
+
+                ls.Disposable = _parent._left.SubscribeSafe(lo);
+                rs.Disposable = _parent._right.SubscribeSafe(ro);
+
+                return d;
+            }
+
+            class DecisionObserver : IObserver<TSource>
+            {
+                private readonly _ _parent;
+                private readonly AmbState _me;
+                private readonly IDisposable _subscription;
+                private readonly IDisposable _otherSubscription;
+                private readonly object _gate;
+                private readonly AmbObserver _observer;
+
+                public DecisionObserver(_ parent, object gate, AmbState me, IDisposable subscription, IDisposable otherSubscription, AmbObserver observer)
+                {
+                    _parent = parent;
+                    _gate = gate;
+                    _me = me;
+                    _subscription = subscription;
+                    _otherSubscription = otherSubscription;
+                    _observer = observer;
+                }
+
+                public void OnNext(TSource value)
+                {
+                    lock (_gate)
+                    {
+                        if (_parent._choice == AmbState.Neither)
+                        {
+                            _parent._choice = _me;
+                            _otherSubscription.Dispose();
+                            _observer._disposable = _subscription;
+                            _observer._target = _parent._observer;
+                        }
+
+                        if (_parent._choice == _me)
+                            _parent._observer.OnNext(value);
+                    }
+                }
+
+                public void OnError(Exception error)
+                {
+                    lock (_gate)
+                    {
+                        if (_parent._choice == AmbState.Neither)
+                        {
+                            _parent._choice = _me;
+                            _otherSubscription.Dispose();
+                            _observer._disposable = _subscription;
+                            _observer._target = _parent._observer;
+                        }
+
+                        if (_parent._choice == _me)
+                        {
+                            _parent._observer.OnError(error);
+                            _parent.Dispose();
+                        }
+                    }
+                }
+
+                public void OnCompleted()
+                {
+                    lock (_gate)
+                    {
+                        if (_parent._choice == AmbState.Neither)
+                        {
+                            _parent._choice = _me;
+                            _otherSubscription.Dispose();
+                            _observer._disposable = _subscription;
+                            _observer._target = _parent._observer;
+                        }
+
+                        if (_parent._choice == _me)
+                        {
+                            _parent._observer.OnCompleted();
+                            _parent.Dispose();
+                        }
+                    }
+                }
+            }
+
+            class AmbObserver : IObserver<TSource>
+            {
+                public IObserver<TSource> _target;
+
+                public IDisposable _disposable;
+
+                public void OnNext(TSource value)
+                {
+                    _target.OnNext(value);
+                }
+
+                public void OnError(Exception error)
+                {
+                    _target.OnError(error);
+                    _disposable.Dispose();
+                }
+
+                public void OnCompleted()
+                {
+                    _target.OnCompleted();
+                    _disposable.Dispose();
+                }
+            }
+
+            enum AmbState
+            {
+                Left,
+                Right,
+                Neither
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Any.cs

@@ -0,0 +1,115 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Any<TSource> : Producer<bool>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly Func<TSource, bool> _predicate;
+
+        public Any(IObservable<TSource> source)
+        {
+            _source = source;
+        }
+
+        public Any(IObservable<TSource> source, Func<TSource, bool> predicate)
+        {
+            _source = source;
+            _predicate = predicate;
+        }
+
+        protected override IDisposable Run(IObserver<bool> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            if (_predicate != null)
+            {
+                var sink = new AnyImpl(this, observer, cancel);
+                setSink(sink);
+                return _source.SubscribeSafe(sink);
+            }
+            else
+            {
+                var sink = new _(observer, cancel);
+                setSink(sink);
+                return _source.SubscribeSafe(sink);
+            }
+        }
+
+        class _ : Sink<bool>, IObserver<TSource>
+        {
+            public _(IObserver<bool> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+            }
+
+            public void OnNext(TSource value)
+            {
+                base._observer.OnNext(true);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnNext(false);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+
+        class AnyImpl : Sink<bool>, IObserver<TSource>
+        {
+            private readonly Any<TSource> _parent;
+
+            public AnyImpl(Any<TSource> parent, IObserver<bool> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+            }
+
+            public void OnNext(TSource value)
+            {
+                var res = false;
+                try
+                {
+                    res = _parent._predicate(value);
+                }
+                catch (Exception ex)
+                {
+                    base._observer.OnError(ex);
+                    base.Dispose();
+                    return;
+                }
+
+                if (res)
+                {
+                    base._observer.OnNext(true);
+                    base._observer.OnCompleted();
+                    base.Dispose();
+                }
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnNext(false);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/AsObservable.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class AsObservable<TSource> : Producer<TSource>, IEvaluatableObservable<TSource>
+    {
+        private readonly IObservable<TSource> _source;
+
+        public AsObservable(IObservable<TSource> source)
+        {
+            _source = source;
+        }
+
+        public IObservable<TSource> Omega()
+        {
+            return this;
+        }
+
+        public IObservable<TSource> Eval()
+        {
+            return _source;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(observer, cancel);
+            setSink(sink);
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<TSource>, IObserver<TSource>
+        {
+            public _(IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+            }
+
+            public void OnNext(TSource value)
+            {
+                base._observer.OnNext(value);
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Case.cs

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Collections.Generic;
+using System.Reactive.Disposables;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Case<TValue, TResult> : Producer<TResult>, IEvaluatableObservable<TResult>
+    {
+        private readonly Func<TValue> _selector;
+        private readonly IDictionary<TValue, IObservable<TResult>> _sources;
+        private readonly IObservable<TResult> _defaultSource;
+
+        public Case(Func<TValue> selector, IDictionary<TValue, IObservable<TResult>> sources, IObservable<TResult> defaultSource)
+        {
+            _selector = selector;
+            _sources = sources;
+            _defaultSource = defaultSource;
+        }
+
+        public IObservable<TResult> Eval()
+        {
+            var res = default(IObservable<TResult>);
+            if (_sources.TryGetValue(_selector(), out res))
+                return res;
+
+            return _defaultSource;
+        }
+
+        protected override IDisposable Run(IObserver<TResult> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return sink.Run();
+        }
+
+        class _ : Sink<TResult>, IObserver<TResult>
+        {
+            private readonly Case<TValue, TResult> _parent;
+
+            public _(Case<TValue, TResult> parent, IObserver<TResult> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+            }
+
+            public IDisposable Run()
+            {
+                var result = default(IObservable<TResult>);
+                try
+                {
+                    result = _parent.Eval();
+                }
+                catch (Exception exception)
+                {
+                    base._observer.OnError(exception);
+                    base.Dispose();
+                    return Disposable.Empty;
+                }
+
+                return result.SubscribeSafe(this);
+            }
+
+            public void OnNext(TResult value)
+            {
+                base._observer.OnNext(value);
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Cast.cs

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Cast<TSource, TResult> : Producer<TResult> /* Could optimize further by deriving from Select<TResult> and providing Omega<TResult2>. We're not doing this (yet) for debuggability. */
+    {
+        private readonly IObservable<TSource> _source;
+
+        public Cast(IObservable<TSource> source)
+        {
+            _source = source;
+        }
+
+        protected override IDisposable Run(IObserver<TResult> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(observer, cancel);
+            setSink(sink);
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<TResult>, IObserver<TSource>
+        {
+            public _(IObserver<TResult> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+            }
+
+            public void OnNext(TSource value)
+            {
+                var result = default(TResult);
+                try
+                {
+                    result = (TResult)(object)value;
+                }
+                catch (Exception exception)
+                {
+                    base._observer.OnError(exception);
+                    base.Dispose();
+                    return;
+                }
+
+                base._observer.OnNext(result);
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Catch.cs

@@ -0,0 +1,183 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Collections.Generic;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Catch<TSource> : Producer<TSource>
+    {
+        private readonly IEnumerable<IObservable<TSource>> _sources;
+
+        public Catch(IEnumerable<IObservable<TSource>> sources)
+        {
+            _sources = sources;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(observer, cancel);
+            setSink(sink);
+            return sink.Run(_sources);
+        }
+
+        class _ : TailRecursiveSink<TSource>
+        {
+            public _(IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+            }
+
+            protected override IEnumerable<IObservable<TSource>> Extract(IObservable<TSource> source)
+            {
+                var @catch = source as Catch<TSource>;
+                if (@catch != null)
+                    return @catch._sources;
+
+                return null;
+            }
+
+            public override void OnNext(TSource value)
+            {
+                base._observer.OnNext(value);
+            }
+
+            private Exception _lastException;
+
+            public override void OnError(Exception error)
+            {
+                _lastException = error;
+                _recurse();
+            }
+
+            public override void OnCompleted()
+            {
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+
+            protected override void Done()
+            {
+                if (_lastException != null)
+                    base._observer.OnError(_lastException);
+                else
+                    base._observer.OnCompleted();
+
+                base.Dispose();
+            }
+        }
+    }
+
+    class Catch<TSource, TException> : Producer<TSource> where TException : Exception
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly Func<TException, IObservable<TSource>> _handler;
+
+        public Catch(IObservable<TSource> source, Func<TException, IObservable<TSource>> handler)
+        {
+            _source = source;
+            _handler = handler;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return sink.Run();
+        }
+
+        class _ : Sink<TSource>, IObserver<TSource>
+        {
+            private readonly Catch<TSource, TException> _parent;
+
+            public _(Catch<TSource, TException> parent, IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+            }
+
+            private SerialDisposable _subscription;
+
+            public IDisposable Run()
+            {
+                _subscription = new SerialDisposable();
+
+                var d1 = new SingleAssignmentDisposable();
+                _subscription.Disposable = d1;
+                d1.Disposable = _parent._source.SubscribeSafe(this);
+
+                return _subscription;
+            }
+
+            public void OnNext(TSource value)
+            {
+                base._observer.OnNext(value);
+            }
+
+            public void OnError(Exception error)
+            {
+                var e = error as TException;
+                if (e != null)
+                {
+                    var result = default(IObservable<TSource>);
+                    try
+                    {
+                        result = _parent._handler(e);
+                    }
+                    catch (Exception ex)
+                    {
+                        base._observer.OnError(ex);
+                        base.Dispose();
+                        return;
+                    }
+
+                    var d = new SingleAssignmentDisposable();
+                    _subscription.Disposable = d;
+                    d.Disposable = result.SubscribeSafe(new Impl(this));
+                }
+                else
+                {
+                    base._observer.OnError(error);
+                    base.Dispose();
+                }
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+
+            class Impl : IObserver<TSource>
+            {
+                private readonly _ _parent;
+
+                public Impl(_ parent)
+                {
+                    _parent = parent;
+                }
+
+                public void OnNext(TSource value)
+                {
+                    _parent._observer.OnNext(value);
+                }
+
+                public void OnError(Exception error)
+                {
+                    _parent._observer.OnError(error);
+                    _parent.Dispose();
+                }
+
+                public void OnCompleted()
+                {
+                    _parent._observer.OnCompleted();
+                    _parent.Dispose();
+                }
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Collect.cs

@@ -0,0 +1,139 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Collections.Generic;
+using System.Reactive;
+using System.Reactive.Threading;
+using System.Threading;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Collect<TSource, TResult> : PushToPullAdapter<TSource, TResult>
+    {
+        private readonly Func<TResult> _getInitialCollector;
+        private readonly Func<TResult, TSource, TResult> _merge;
+        private readonly Func<TResult, TResult> _getNewCollector;
+
+        public Collect(IObservable<TSource> source, Func<TResult> getInitialCollector, Func<TResult, TSource, TResult> merge, Func<TResult, TResult> getNewCollector)
+            : base(source)
+        {
+            _getInitialCollector = getInitialCollector;
+            _merge = merge;
+            _getNewCollector = getNewCollector;
+        }
+
+        protected override PushToPullSink<TSource, TResult> Run(IDisposable subscription)
+        {
+            var sink = new _(this, subscription);
+            sink.Initialize();
+            return sink;
+        }
+
+        class _ : PushToPullSink<TSource, TResult>
+        {
+            private readonly Collect<TSource, TResult> _parent;
+
+            public _(Collect<TSource, TResult> parent, IDisposable subscription)
+                : base(subscription)
+            {
+                _parent = parent;
+            }
+
+            private object _gate;
+            private TResult _collector;
+            private bool _hasFailed;
+            private Exception _error;
+            private bool _hasCompleted;
+            private bool _done;
+
+            public void Initialize()
+            {
+                _gate = new object();
+                _collector = _parent._getInitialCollector();
+            }
+
+            public override void OnNext(TSource value)
+            {
+                lock (_gate)
+                {
+                    try
+                    {
+                        _collector = _parent._merge(_collector, value);
+                    }
+                    catch (Exception ex)
+                    {
+                        _error = ex;
+                        _hasFailed = true;
+
+                        base.Dispose();
+                    }
+                }
+            }
+
+            public override void OnError(Exception error)
+            {
+                base.Dispose();
+
+                lock (_gate)
+                {
+                    _error = error;
+                    _hasFailed = true;
+                }
+            }
+
+            public override void OnCompleted()
+            {
+                base.Dispose();
+
+                lock (_gate)
+                {
+                    _hasCompleted = true;
+                }
+            }
+
+            public override bool TryMoveNext(out TResult current)
+            {
+                lock (_gate)
+                {
+                    if (_hasFailed)
+                    {
+                        current = default(TResult);
+                        _error.Throw();
+                    }
+                    else
+                    {
+                        if (_hasCompleted)
+                        {
+                            if (_done)
+                            {
+                                current = default(TResult);
+                                return false;
+                            }
+
+                            current = _collector;
+                            _done = true;
+                        }
+                        else
+                        {
+                            current = _collector;
+
+                            try
+                            {
+                                _collector = _parent._getNewCollector(current);
+                            }
+                            catch
+                            {
+                                base.Dispose();
+                                throw;
+                            }
+                        }
+                    }
+
+                    return true;
+                }
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Concat.cs

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Collections.Generic;
+using System.Reactive.Concurrency;
+using System.Reactive.Disposables;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Concat<TSource> : Producer<TSource>, IConcatenatable<TSource>
+    {
+        private readonly IEnumerable<IObservable<TSource>> _sources;
+
+        public Concat(IEnumerable<IObservable<TSource>> sources)
+        {
+            _sources = sources;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(observer, cancel);
+            setSink(sink);
+            return sink.Run(_sources);
+        }
+
+        public IEnumerable<IObservable<TSource>> GetSources()
+        {
+            return _sources;
+        }
+
+        class _ : ConcatSink<TSource>
+        {
+            public _(IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+            }
+
+            public override void OnNext(TSource value)
+            {
+                base._observer.OnNext(value);
+            }
+
+            public override void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Contains.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Collections.Generic;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Contains<TSource> : Producer<bool>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly TSource _value;
+        private readonly IEqualityComparer<TSource> _comparer;
+
+        public Contains(IObservable<TSource> source, TSource value, IEqualityComparer<TSource> comparer)
+        {
+            _source = source;
+            _value = value;
+            _comparer = comparer;
+        }
+
+        protected override IDisposable Run(IObserver<bool> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<bool>, IObserver<TSource>
+        {
+            private readonly Contains<TSource> _parent;
+
+            public _(Contains<TSource> parent, IObserver<bool> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+            }
+
+            public void OnNext(TSource value)
+            {
+                var res = false;
+                try
+                {
+                    res = _parent._comparer.Equals(value, _parent._value);
+                }
+                catch (Exception ex)
+                {
+                    base._observer.OnError(ex);
+                    base.Dispose();
+                    return;
+                }
+
+                if (res)
+                {
+                    base._observer.OnNext(true);
+                    base._observer.OnCompleted();
+                    base.Dispose();
+                }
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnNext(false);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Count.cs

@@ -0,0 +1,124 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Count<TSource> : Producer<int>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly Func<TSource, bool> _predicate;
+
+        public Count(IObservable<TSource> source)
+        {
+            _source = source;
+        }
+
+        public Count(IObservable<TSource> source, Func<TSource, bool> predicate)
+        {
+            _source = source;
+            _predicate = predicate;
+        }
+
+        protected override IDisposable Run(IObserver<int> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            if (_predicate == null)
+            {
+                var sink = new _(observer, cancel);
+                setSink(sink);
+                return _source.SubscribeSafe(sink);
+            }
+            else
+            {
+                var sink = new CountImpl(this, observer, cancel);
+                setSink(sink);
+                return _source.SubscribeSafe(sink);
+            }
+        }
+
+        class _ : Sink<int>, IObserver<TSource>
+        {
+            private int _count;
+
+            public _(IObserver<int> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _count = 0;
+            }
+
+            public void OnNext(TSource value)
+            {
+                try
+                {
+                    checked
+                    {
+                        _count++;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    base._observer.OnError(ex);
+                    base.Dispose();
+                }
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnNext(_count);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+
+        class CountImpl : Sink<int>, IObserver<TSource>
+        {
+            private readonly Count<TSource> _parent;
+            private int _count;
+
+            public CountImpl(Count<TSource> parent, IObserver<int> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+                _count = 0;
+            }
+
+            public void OnNext(TSource value)
+            {
+                try
+                {
+                    checked
+                    {
+                        if (_parent._predicate(value))
+                            _count++;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    base._observer.OnError(ex);
+                    base.Dispose();
+                }
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnNext(_count);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/DefaultIfEmpty.cs

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class DefaultIfEmpty<TSource> : Producer<TSource>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly TSource _defaultValue;
+
+        public DefaultIfEmpty(IObservable<TSource> source, TSource defaultValue)
+        {
+            _source = source;
+            _defaultValue = defaultValue;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<TSource>, IObserver<TSource>
+        {
+            private readonly DefaultIfEmpty<TSource> _parent;
+            private bool _found;
+
+            public _(DefaultIfEmpty<TSource> parent, IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+                _found = false;
+            }
+
+            public void OnNext(TSource value)
+            {
+                _found = true;
+                base._observer.OnNext(value);
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                if (!_found)
+                    base._observer.OnNext(_parent._defaultValue);
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/Defer.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Reactive.Disposables;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class Defer<TValue> : Producer<TValue>, IEvaluatableObservable<TValue>
+    {
+        private readonly Func<IObservable<TValue>> _observableFactory;
+
+        public Defer(Func<IObservable<TValue>> observableFactory)
+        {
+            _observableFactory = observableFactory;
+        }
+
+        protected override IDisposable Run(IObserver<TValue> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(this, observer, cancel);
+            setSink(sink);
+            return sink.Run();
+        }
+
+        public IObservable<TValue> Eval()
+        {
+            return _observableFactory();
+        }
+
+        class _ : Sink<TValue>, IObserver<TValue>
+        {
+            private readonly Defer<TValue> _parent;
+
+            public _(Defer<TValue> parent, IObserver<TValue> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+                _parent = parent;
+            }
+
+            public IDisposable Run()
+            {
+                var result = default(IObservable<TValue>);
+                try
+                {
+                    result = _parent.Eval();
+                }
+                catch (Exception exception)
+                {
+                    base._observer.OnError(exception);
+                    base.Dispose();
+                    return Disposable.Empty;
+                }
+
+                return result.SubscribeSafe(this);
+            }
+
+            public void OnNext(TValue value)
+            {
+                base._observer.OnNext(value);
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif

external/rx/Rx/NET/Source/System.Reactive.Linq/Reactive/Linq/Observable/DelaySubscription.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+#if !NO_PERF
+using System;
+using System.Reactive.Concurrency;
+
+namespace System.Reactive.Linq.ObservableImpl
+{
+    class DelaySubscription<TSource> : Producer<TSource>
+    {
+        private readonly IObservable<TSource> _source;
+        private readonly DateTimeOffset? _dueTimeA;
+        private readonly TimeSpan? _dueTimeR;
+        private readonly IScheduler _scheduler;
+
+        public DelaySubscription(IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler)
+        {
+            _source = source;
+            _dueTimeA = dueTime;
+            _scheduler = scheduler;
+        }
+
+        public DelaySubscription(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler)
+        {
+            _source = source;
+            _dueTimeR = dueTime;
+            _scheduler = scheduler;
+        }
+
+        protected override IDisposable Run(IObserver<TSource> observer, IDisposable cancel, Action<IDisposable> setSink)
+        {
+            var sink = new _(observer, cancel);
+            setSink(sink);
+
+            if (_dueTimeA.HasValue)
+            {
+                return _scheduler.Schedule(sink, _dueTimeA.Value, Subscribe);
+            }
+            else
+            {
+                return _scheduler.Schedule(sink, _dueTimeR.Value, Subscribe);
+            }
+        }
+
+        private IDisposable Subscribe(IScheduler _, _ sink)
+        {
+            return _source.SubscribeSafe(sink);
+        }
+
+        class _ : Sink<TSource>, IObserver<TSource>
+        {
+            public _(IObserver<TSource> observer, IDisposable cancel)
+                : base(observer, cancel)
+            {
+            }
+
+            public void OnNext(TSource value)
+            {
+                base._observer.OnNext(value);
+            }
+
+            public void OnError(Exception error)
+            {
+                base._observer.OnError(error);
+                base.Dispose();
+            }
+
+            public void OnCompleted()
+            {
+                base._observer.OnCompleted();
+                base.Dispose();
+            }
+        }
+    }
+}
+#endif