Code coverage report for src/Subscription.ts

Statements: 95.92% (47 / 49)      Branches: 93.94% (31 / 33)      Functions: 100% (7 / 7)      Lines: 95.83% (46 / 48)      Ignored: none     

All files » src/ » Subscription.ts
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 1031   1 1 1 1     26832       1 7662     1 26831 2682       1   12146 73     12073   12073 12073   12073   12073 10383     12073 3957 3957   3957 9281         1         13552     2381     11171   11171   8   11171 201 10970 55   10915 10915   10970           1           1252           1252   1252 1198 1198 836       1  
import {noop} from './util/noop';
 
export class Subscription<T> {
  public static EMPTY: Subscription<void> = (function(empty){
    empty.isUnsubscribed = true;
    return empty;
  }(new Subscription<void>()));
 
  isUnsubscribed: boolean = false;
 
  _subscriptions: Subscription<any>[];
 
  _unsubscribe(): void {
    noop();
  }
 
  constructor(_unsubscribe?: () => void) {
    if (_unsubscribe) {
      this._unsubscribe = _unsubscribe;
    }
  }
 
  unsubscribe(): void {
 
    if (this.isUnsubscribed) {
      return;
    }
 
    this.isUnsubscribed = true;
 
    const unsubscribe = this._unsubscribe;
    const subscriptions = this._subscriptions;
 
    this._subscriptions = void 0;
 
    if (unsubscribe) {
      unsubscribe.call(this);
    }
 
    if (subscriptions != null) {
      let index = -1;
      const len = subscriptions.length;
 
      while (++index < len) {
        subscriptions[index].unsubscribe();
      }
    }
  }
 
  add(subscription: Subscription<T>|Function|void): void {
    // return early if:
    //  1. the subscription is null
    //  2. we're attempting to add our this
    //  3. we're attempting to add the static `empty` Subscription
    if (!subscription || (
        subscription === this) || (
        subscription === Subscription.EMPTY)) {
      return;
    }
 
    let sub = (<Subscription<T>> subscription);
 
    switch (typeof subscription) {
      case 'function':
        sub = new Subscription<void>(<(() => void) > subscription);
      case 'object':
        if (sub.isUnsubscribed || typeof sub.unsubscribe !== 'function') {
          break;
        } else if (this.isUnsubscribed) {
            sub.unsubscribe();
        } else {
          const subscriptions = this._subscriptions || (this._subscriptions = []);
          subscriptions.push(sub);
        }
        break;
      default:
        throw new Error('Unrecognized subscription ' + subscription + ' added to Subscription.');
    }
  }
 
  remove(subscription: Subscription<T>): void {
 
    // return early if:
    //  1. the subscription is null
    //  2. we're attempting to remove ourthis
    //  3. we're attempting to remove the static `empty` Subscription
    Iif (subscription == null   || (
        subscription === this) || (
        subscription === Subscription.EMPTY)) {
      return;
    }
 
    const subscriptions = this._subscriptions;
 
    if (subscriptions) {
      const subscriptionIndex = subscriptions.indexOf(subscription);
      if (subscriptionIndex !== -1) {
        subscriptions.splice(subscriptionIndex, 1);
      }
    }
  }
}