com.microsoft.rest.RestException Java Examples

/**
 * flatten the  child paged lists.
 *
 * @return the lazy flattened paged list from the child paged lists
 * @throws CloudException exceptions thrown from the cloud
 * @throws IOException exceptions thrown from serialization/deserialization
 */
public PagedList<ChildT> flatten() {
    this.currentChildList = nextChildList();
    if (this.currentChildList == null) {
        return emptyPagedList();
    }
    return new PagedList<ChildT>(childListPage(currentChildList.currentPage())) {
        @Override
        public Page<ChildT> nextPage(String nextPageLink) throws RestException, IOException {
            if (nextPageLink.equalsIgnoreCase(switchToCousin)) {
                // Reached end of current child paged list, make next child list(cousin) as current
                // paged list and return it's first page.
                currentChildList = nextChildList();
                return childListPage(currentChildList.currentPage());
            } else {
                currentChildList.loadNextPage();
                return childListPage(currentChildList.currentPage());
            }
        }
    };
}
 

/**
 * Util function to block on an observable and turn that to a paged list with one page.
 *
 * @param skuObservable the observable
 * @param <T> the item type
 * @return a paged list with items collected from the given observable
 */
private static <T> PagedList<T> toPagedList(final Observable<T> skuObservable) {
    Page<T> singlePage = new Page<T>() {
        @Override
        public List<T> items() {
            return Lists.newArrayList(skuObservable.toBlocking().toIterable());
        }

        @Override
        public String nextPageLink() {
            return null;
        }
    };
    return new PagedList<T>(singlePage) {
        @Override
        public Page<T> nextPage(String s) throws RestException, IOException {
            return null;
        }
    };
}
 

private PagedList<VirtualMachine> createPagedListWithOnePage() {
    PagedList<VirtualMachine> pagedList = new PagedList<>() {
        @Override
        public Page<VirtualMachine> nextPage(String nextPageLink) throws RestException {
            return null;
        }

        @Override
        public void loadNextPage() {
        }

        @Override
        public boolean hasNextPage() {
            return false;
        }
    };
    pagedList.add(createVirtualMachine(INSTANCE_1));
    return pagedList;
}
 

/**
 * @return an empty paged list
 */
private PagedList<ChildT> emptyPagedList() {
    return new PagedList<ChildT>(emptyPage()) {
        @Override
        public Page<ChildT> nextPage(String nextPageLink) throws RestException, IOException {
            return null;
        }
    };
}
 

private PagedList<VirtualMachine> createPagedList() {
    PagedList<VirtualMachine> pagedList = new PagedList<>() {
        @Override
        public Page<VirtualMachine> nextPage(String nextPageLink) throws RestException {
            return null;
        }
    };
    pagedList.add(createVirtualMachine(INSTANCE_1));
    pagedList.add(createVirtualMachine(INSTANCE_2));
    pagedList.add(createVirtualMachine(INSTANCE_3));
    return pagedList;
}
 

@Override
public Page<E> nextPage(String nextPageLink) throws RestException {
  return null;
}
 

@Override
public ResponseBuilder<T, E> registerError(Class<? extends RestException> type) {
    baseBuilder.registerError(type);
    return this;
}
 

@Override
public <T, E extends RestException> AzureResponseBuilder<T, E> newInstance(final SerializerAdapter<?> serializerAdapter) {
    return new AzureResponseBuilder<T, E>(serializerAdapter);
}
 

/**
 * Override this method to load the next page of items from a next page link.
 *
 * @param nextPageLink the link to get the next page of items.
 * @return the {@link Page} object storing a page of items and a link to the next page.
 * @throws RestException thrown if an error is raised from Azure.
 * @throws IOException thrown if there's any failure in deserialization.
 */
public abstract Page<E> nextPage(String nextPageLink) throws RestException, IOException;
 

/**
 * Register a destination type for errors with models.
 *
 * @param type the type to deserialize.
 * @return the same builder instance.
 */
ResponseBuilder<T, E> registerError(Class<? extends RestException> type);
 

/**
 * Returns a response builder instance. This can be created new or cached.
 *
 * @param <T> the type of the return object
 * @param <E> the type of the exception
 * @param serializerAdapter the serializer adapter to deserialize the response
 * @return a response builder instance
 */
<T, E extends RestException> ResponseBuilder<T, E> newInstance(SerializerAdapter<?> serializerAdapter);