Lists the usages for the specified location.

@param location The location to get capabilities for.
@throws IllegalArgumentException thrown if parameters fail the validation
@return the observable to the UsagesListResultInner object
547184
public Observable<UsagesListResultInner> listUsagesAsync(String location) {
        return listUsagesWithServiceResponseAsync(location).map(new Func1<ServiceResponse<UsagesListResultInner>, UsagesListResultInner>() {
            @Override
            public UsagesListResultInner call(ServiceResponse<UsagesListResultInner> response) {
                return response.body();
            }
        });
    }
304449
public static LocationEngineResult create(Location location) {
    checkNotNull(location, "location can't be null");
    List<Location> locations = new ArrayList<>();
    locations.add(location);
    return new LocationEngineResult(locations);
  }
520951
public GetAnyLocationsResponse getAnyLocations(String region) throws ApiException {
        ApiResponse<GetAnyLocationsResponse> resp = getAnyLocationsWithHttpInfo(region);
        return resp.getData();
    }
660495
public JCRPath getLocation() throws RepositoryException
   {
      if (this.location == null)
      {
         this.location = session.getLocationFactory().createJCRPath(qpath);
      }

      return this.location;
   }
473902
public function findByLocation(Location $location, array $orderBy = [],
        ?int $limit = null): array
    {
        $qb = $this->createQueryBuilder('su');
        $this->filterByLocation($qb, $location);
        $this->addOrderBy($qb, $orderBy);
        $this->addLimit($qb, $limit);

        return $qb->getQuery()->getResult();
    }
1126308
public ApiResponse<GetAnyLocationsResponse> getAnyLocationsWithHttpInfo(String region) throws ApiException {
        com.squareup.okhttp.Call call = getAnyLocationsValidateBeforeCall(region, null, null);
        Type localVarReturnType = new TypeToken<GetAnyLocationsResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
627987
public Observable<Page<GeoRegionInner>> listGeoRegionsAsync() {
        return listGeoRegionsWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<GeoRegionInner>>, Page<GeoRegionInner>>() {
                @Override
                public Page<GeoRegionInner> call(ServiceResponse<Page<GeoRegionInner>> response) {
                    return response.body();
                }
            });
    }
339427
public static AbstractResource getResourceFrom(final String location) throws IOException {
        val metadataLocationResource = getRawResourceFrom(location);
        if (!metadataLocationResource.exists() || !metadataLocationResource.isReadable()) {
            throw new FileNotFoundException("Resource " + location + " does not exist or is unreadable");
        }
        return metadataLocationResource;
    }
557652
public static TypeAnnotationPosition
        methodParameter(final List<TypePathEntry> location,
                        final int parameter_index) {
        return methodParameter(location, null, parameter_index, -1);
    }
1068659
public Observable<ServiceResponse<ImageList>> getDetailsWithServiceResponseAsync(String listId) {
        if (this.client.baseUrl() == null) {
            throw new IllegalArgumentException("Parameter this.client.baseUrl() is required and cannot be null.");
        }
        if (listId == null) {
            throw new IllegalArgumentException("Parameter listId is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{baseUrl}", this.client.baseUrl());
        return service.getDetails(listId, this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<ImageList>>>() {
                @Override
                public Observable<ServiceResponse<ImageList>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<ImageList> clientResponse = getDetailsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
909244
public static <T> GenericResponseBuilder<T> seeOther(URI location) {
    return GenericResponses.<T>status(Response.Status.SEE_OTHER).location(location);
  }
627314
public ApiResponse<DeleteMetadataResponse> deleteMetadataWithHttpInfo(String location) throws ApiException {
        com.squareup.okhttp.Call call = deleteMetadataValidateBeforeCall(location, null, null);
        Type localVarReturnType = new TypeToken<DeleteMetadataResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
1020556
protected String determineLocation(String location) {
        if (existsInDefaultLocation(location)) {
            return defaultFolder() + location;
        }

        if (!existsInGivenLocation(location)) {
            throw new InvalidResourceLocation("Unable to locate " + location + ". " +
                "File does not exist also in default location " + defaultLocation());
        }

        return location;
    }
71888
public static StashLocation getStashLocation(URI location) {
        checkArgument(getLocationType(location) == LocationType.STASH, "Not a stash location");

        String host, path;
        boolean useLatestDirectory;

        Matcher matcher = getLocatorMatcher(location);
        if (matcher.matches()) {
            // Stash is only available for the default group.  Make sure that's the case here
            String group = Objects.firstNonNull(matcher.group("group"), DEFAULT_GROUP);
            checkArgument(DEFAULT_GROUP.equals(group), "Stash not available for group: %s", group);

            // Stash it not available for local
            String universe = matcher.group("universe");
            checkArgument(universe != null, "Stash not available for local");

            Region region = getRegion(Objects.firstNonNull(matcher.group("region"), DEFAULT_REGION));

            host = getS3BucketForRegion(region);
            path = getS3PathForUniverse(universe);
            useLatestDirectory = true;
        } else {
            // The location refers to the actual S3 bucket and path
            host = location.getHost();
            path = location.getPath();
            // Stash paths don't have a leading slash
            if (path != null && path.startsWith("/")) {
                path = path.substring(1);
            }
            useLatestDirectory = false;
        }

        return new StashLocation(host, path, useLatestDirectory);
    }
628467
public com.google.privacy.dlp.v2.TransformationSummary.SummaryResultOrBuilder getResultsOrBuilder(
      int index) {
    return results_.get(index);
  }
467965
public static OutputSupplier<? extends OutputStream> newOutputSupplier(final Location location) {
    return new OutputSupplier<OutputStream>() {
      @Override
      public OutputStream getOutput() throws IOException {
        return location.getOutputStream();
      }
    };
  }
217060
public static Resource getResource(String location) {
        Resource resource = resolver.getResource(location);
        return resource.exists() ? resource : null;
    }