gets all the Term Lists.

@throws IllegalArgumentException thrown if parameters fail the validation
@return the observable to the List&lt;TermList&gt; object
329584
public Observable<List<TermList>> getAllTermListsAsync() {
        return getAllTermListsWithServiceResponseAsync().map(new Func1<ServiceResponse<List<TermList>>, List<TermList>>() {
            @Override
            public List<TermList> call(ServiceResponse<List<TermList>> response) {
                return response.body();
            }
        });
    }
158860
public Observable<OperationListResultInner> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<OperationListResultInner>, OperationListResultInner>() {
            @Override
            public OperationListResultInner call(ServiceResponse<OperationListResultInner> response) {
                return response.body();
            }
        });
    }
400915
public Observable<Page<TenantIdDescriptionInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<TenantIdDescriptionInner>>, Page<TenantIdDescriptionInner>>() {
                @Override
                public Page<TenantIdDescriptionInner> call(ServiceResponse<Page<TenantIdDescriptionInner>> response) {
                    return response.body();
                }
            });
    }
259227
public List<SyntacticCategory> getArgumentList() {
    if (isAtomic()) {
      return Lists.newArrayList();
    } else {
      List<SyntacticCategory> args = getReturn().getArgumentList();
      args.add(getArgument());
      return args;
    }
  }
13982
public Observable<Page<JobInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<JobInner>>, Page<JobInner>>() {
                @Override
                public Page<JobInner> call(ServiceResponse<Page<JobInner>> response) {
                    return response.body();
                }
            });
    }
1057505
List<Message> getList() {
        if (mode == StorageMode.MAP) {
            synchronized (this) {
                if (mode == StorageMode.MAP) {
                    listData = convertMapToList(mapData);
                    mode = StorageMode.BOTH;
                }
            }
        }
        return Collections.unmodifiableList(listData);
    }
1116348
public Observable<Page<NamespaceResourceInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<NamespaceResourceInner>>, Page<NamespaceResourceInner>>() {
                @Override
                public Page<NamespaceResourceInner> call(ServiceResponse<Page<NamespaceResourceInner>> response) {
                    return response.body();
                }
            });
    }
988761
public Observable<Page<ServiceEndpointPolicyInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ServiceEndpointPolicyInner>>, Page<ServiceEndpointPolicyInner>>() {
                @Override
                public Page<ServiceEndpointPolicyInner> call(ServiceResponse<Page<ServiceEndpointPolicyInner>> response) {
                    return response.body();
                }
            });
    }
377317
public List<Object> getEntities() {
		List<Object> entitiesList = new LinkedList<Object>();

		for (Result result : results) {
			entitiesList.add(result.getObject());
		}

		return entitiesList;
	}
878722
public Observable<Page<TagDetailsInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<TagDetailsInner>>, Page<TagDetailsInner>>() {
                @Override
                public Page<TagDetailsInner> call(ServiceResponse<Page<TagDetailsInner>> response) {
                    return response.body();
                }
            });
    }
134259
public List<Term> getAllTerms() {
        List<Term> ret = new ArrayList<Term>();
        ret.add(subject);

        List<Term> subjectTerms = subject.getTerms();
        if (subjectTerms != null) {
            ret.addAll(subjectTerms);
            for (final Term term : subjectTerms) {
                ret.addAll(term.getAllTerms());
            }
        }

        if (object != null) {
            ret.addAll(object.getAllTerms());
        }
        return ret;
    }
489360
public List<T> toList() {
		final String sourceMethod = "toList"; //$NON-NLS-1$
		SignalUtil.lock(rwl.readLock(), sourceClass, sourceMethod);
		List<T> result = null;
		try {
			result = Arrays.asList(Arrays.copyOf(items, index.get()));
		} finally {
			rwl.readLock().unlock();
		}
		return result;
	}
774833
public Observable<Page<ResourceGroupInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<ResourceGroupInner>>, Page<ResourceGroupInner>>() {
                @Override
                public Page<ResourceGroupInner> call(ServiceResponse<Page<ResourceGroupInner>> response) {
                    return response.body();
                }
            });
    }
982279
public Observable<Page<PolicyDefinitionInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<PolicyDefinitionInner>>, Page<PolicyDefinitionInner>>() {
                @Override
                public Page<PolicyDefinitionInner> call(ServiceResponse<Page<PolicyDefinitionInner>> response) {
                    return response.body();
                }
            });
    }
716318
public java.util.List<Tag> getTagsList() {
        if (tagsList == null) {
            tagsList = new com.amazonaws.internal.SdkInternalList<Tag>();
        }
        return tagsList;
    }
1200776
public Observable<Page<IotHubDescriptionInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<IotHubDescriptionInner>>, Page<IotHubDescriptionInner>>() {
                @Override
                public Page<IotHubDescriptionInner> call(ServiceResponse<Page<IotHubDescriptionInner>> response) {
                    return response.body();
                }
            });
    }
740921
public Observable<ServiceResponse<Page<ApplicationGatewayInner>>> listAllSinglePageAsync() {
        if (this.client.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionId() is required and cannot be null.");
        }
        final String apiVersion = "2017-10-01";
        return service.listAll(this.client.subscriptionId(), apiVersion, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Page<ApplicationGatewayInner>>>>() {
                @Override
                public Observable<ServiceResponse<Page<ApplicationGatewayInner>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<PageImpl<ApplicationGatewayInner>> result = listAllDelegate(response);
                        return Observable.just(new ServiceResponse<Page<ApplicationGatewayInner>>(result.body(), result.response()));
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }