Gets the {@link ObservableSUL}.

@return the {@link ObservableSUL}.
160837
public ObservableSUL<S, I, O> getSul() {
        if (sul.canFork()) {
            return localSul.get();
        } else {
            return sul;
        }
    }
1310040
protected Subscriber<? super R> getSubscriber() {
        Subscriber<? super R> subscriber = this.subscriber.get();
        verifyState(subscriber);
        return subscriber;
    }
429332
public Map<String, Object> getObserver() {
        TreeMap<String, Object> map = new TreeMap<String, Object>();
        synchronized (eventMap) {
            for (Entry<String, Object> entry : eventMap.entrySet()) {
                if (entry.getKey().startsWith(OBSERVER))
                    map.put(entry.getKey(), entry.getValue());
            }
        }
        return map;
    }
1334407
public Observable<SkuInfosInner> listSkusAsync() {
        return listSkusWithServiceResponseAsync().map(new Func1<ServiceResponse<SkuInfosInner>, SkuInfosInner>() {
            @Override
            public SkuInfosInner call(ServiceResponse<SkuInfosInner> response) {
                return response.body();
            }
        });
    }
1335883
public Observable<Page<CognitiveServicesAccountInner>> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<List<CognitiveServicesAccountInner>>, Page<CognitiveServicesAccountInner>>() {
            @Override
            public Page<CognitiveServicesAccountInner> call(ServiceResponse<List<CognitiveServicesAccountInner>> response) {
                PageImpl<CognitiveServicesAccountInner> page = new PageImpl<>();
                page.setItems(response.body());
                return page;
            }
        });
    }
18570
public Observable<Page<SignalRResourceInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<SignalRResourceInner>>, Page<SignalRResourceInner>>() {
                @Override
                public Page<SignalRResourceInner> call(ServiceResponse<Page<SignalRResourceInner>> response) {
                    return response.body();
                }
            });
    }
992251
public Observable<Page<SubscriptionInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<SubscriptionInner>>, Page<SubscriptionInner>>() {
                @Override
                public Page<SubscriptionInner> call(ServiceResponse<Page<SubscriptionInner>> response) {
                    return response.body();
                }
            });
    }
935706
public Observable<DeploymentLocationsInner> getSubscriptionDeploymentLocationsAsync() {
        return getSubscriptionDeploymentLocationsWithServiceResponseAsync().map(new Func1<ServiceResponse<DeploymentLocationsInner>, DeploymentLocationsInner>() {
            @Override
            public DeploymentLocationsInner call(ServiceResponse<DeploymentLocationsInner> response) {
                return response.body();
            }
        });
    }
285995
public static ObservableExecutor getInstance() {

        return new ObservableExecutor() {

            @Override
            public <T> void execute(final Observable<T> obs) {
                obs.subscribeOn(Schedulers.io())
                        .observeOn(Schedulers.io())
                        .subscribe(new Subscriber<T>() {
                            @Override
                            public void onCompleted() {
                                // Completed, will unsubscribe automatically
                            }

                            @Override
                            public void onError(Throwable e) {
                                // Report errors in doOnError
                            }

                            @Override
                            public void onNext(T t) {
                                // Ignore result
                            }
                        });
            }
        };
    }
1152125
public Observable<List<String>> listDomainsAsync() {
        return listDomainsWithServiceResponseAsync().map(new Func1<ServiceResponse<List<String>>, List<String>>() {
            @Override
            public List<String> call(ServiceResponse<List<String>> response) {
                return response.body();
            }
        });
    }
305964
public Observable<List<TopicTypeInfoInner>> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<List<TopicTypeInfoInner>>, List<TopicTypeInfoInner>>() {
            @Override
            public List<TopicTypeInfoInner> call(ServiceResponse<List<TopicTypeInfoInner>> response) {
                return response.body();
            }
        });
    }
445697
Observable<ChatResult> getPreviousMessages(final String conversationId) {

        return persistenceController.getConversation(conversationId)
                .map(conversation -> conversation != null ? conversation.getFirstLocalEventId() : null)
                .flatMap(from -> {

                    final Long queryFrom;

                    if (from != null) {

                        if (from == 0) {
                            return Observable.fromCallable(() -> new ChatResult(true, null));
                        } else if (from > 0) {
                            queryFrom = from - 1;
                        } else {
                            queryFrom = null;
                        }
                    } else {
                        queryFrom = null;
                    }

                    return checkState().flatMap(client -> client.service().messaging().queryMessages(conversationId, queryFrom, messagesPerQuery))
                            .flatMap(result -> persistenceController.processMessageQueryResponse(conversationId, result))
                            .flatMap(result -> persistenceController.processOrphanedEvents(result, orphanedEventsToRemoveListener))
                            .flatMap((Func1<ComapiResult<MessagesQueryResponse>, Observable<ChatResult>>) result -> (result.isSuccessful() && result.getResult().getMessages().isEmpty() && result.getResult().getEarliestEventId() > 0) ?
                                    getPreviousMessages(conversationId) :
                                    Observable.fromCallable(() -> new ChatResult(result.isSuccessful(), result.isSuccessful() ? null : new ChatResult.Error(result))));
                });
    }
347390
public Observable<Page<UserSubscriptionQuotaInner>> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<List<UserSubscriptionQuotaInner>>, Page<UserSubscriptionQuotaInner>>() {
            @Override
            public Page<UserSubscriptionQuotaInner> call(ServiceResponse<List<UserSubscriptionQuotaInner>> response) {
                PageImpl1<UserSubscriptionQuotaInner> page = new PageImpl1<>();
                page.setItems(response.body());
                return page;
            }
        });
    }
633929
public TypeSerializer<T> getElementSerializer() {
		// call getSerializer() here to get the initialization check and proper error message
		final TypeSerializer<List<T>> rawSerializer = getSerializer();
		if (!(rawSerializer instanceof ListSerializer)) {
			throw new IllegalStateException();
		}

		return ((ListSerializer<T>) rawSerializer).getElementSerializer();
	}
178260
public java.util.List<OperatingSystem> getOperatingSystems() {
        if (operatingSystems == null) {
            operatingSystems = new com.amazonaws.internal.SdkInternalList<OperatingSystem>();
        }
        return operatingSystems;
    }
114496
function observable() {
	    var _ref;
	
	    var outerSubscribe = subscribe;
	    return _ref = {
	      /**
	       * The minimal observable subscription method.
	       * @param {Object} observer Any object that can be used as an observer.
	       * The observer object should have a `next` method.
	       * @returns {subscription} An object with an `unsubscribe` method that can
	       * be used to unsubscribe the observable from the store, and prevent further
	       * emission of values from the observable.
	       */
	      subscribe: function subscribe(observer) {
	        if (typeof observer !== 'object') {
	          throw new TypeError('Expected the observer to be an object.');
	        }
	
	        function observeState() {
	          if (observer.next) {
	            observer.next(getState());
	          }
	        }
	
	        observeState();
	        var unsubscribe = outerSubscribe(observeState);
	        return { unsubscribe: unsubscribe };
	      }
	    }, _ref[_symbolObservable2['default']] = function () {
	      return this;
	    }, _ref;
	  }
288389
public Observable<Page<AppServicePlanInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<AppServicePlanInner>>, Page<AppServicePlanInner>>() {
                @Override
                public Page<AppServicePlanInner> call(ServiceResponse<Page<AppServicePlanInner>> response) {
                    return response.body();
                }
            });
    }