/**
   * Invokes all {@link ResourceProcessor} instances registered for the type of the given value and
   * reference type.
   *
   * @param value must not be {@literal null}.
   * @param referenceType must not be {@literal null}.
   * @return
   */
  @SuppressWarnings("unchecked")
  public <T extends ResourceSupport> T invokeProcessorsFor(T value, ResolvableType referenceType) {

    Assert.notNull(value, "Value must not be null!");
    Assert.notNull(referenceType, "Reference type must not be null!");

    // For Resources implementations, process elements first
    if (ResourceProcessorHandlerMethodReturnValueHandler.RESOURCES_TYPE.isAssignableFrom(
        referenceType)) {

      Resources<?> resources = (Resources<?>) value;
      ResolvableType elementTargetType =
          ResolvableType.forClass(Resources.class, referenceType.getRawClass()).getGeneric(0);
      List<Object> result = new ArrayList<Object>(resources.getContent().size());

      for (Object element : resources) {

        ResolvableType elementType = ResolvableType.forClass(element.getClass());

        if (!getRawType(elementTargetType).equals(elementType.getRawClass())) {
          elementTargetType = elementType;
        }

        result.add(invokeProcessorsFor(element, elementTargetType));
      }

      ReflectionUtils.setField(
          ResourceProcessorHandlerMethodReturnValueHandler.CONTENT_FIELD, resources, result);
    }

    return (T) invokeProcessorsFor((Object) value, referenceType);
  }
 protected void checkInventory(String productUri, String facilityUri, int quantity) {
   String url = facilityUri + "/inventoryItems?productId=" + getProductIdFromUri(productUri);
   ParameterizedTypeReference<Resources<InventoryItem>> responseType =
       new ParameterizedTypeReference<Resources<InventoryItem>>() {};
   Resources<InventoryItem> inventories =
       restTemplate.exchange(url, HttpMethod.GET, null, responseType).getBody();
   InventoryItem inventory = inventories.getContent().iterator().next();
   assertNotNull("environment", inventory);
   assertEquals("Inventory quantity", quantity, inventory.getQuantityOnHand().intValue());
 }
 // <3>
 @RequestMapping(method = RequestMethod.GET)
 ResponseEntity<Resources<Object>> root() {
   Resources<Object> objects = new Resources<>(Collections.emptyList());
   URI uri =
       MvcUriComponentsBuilder.fromMethodCall(
               MvcUriComponentsBuilder.on(getClass()).getCollection())
           .build()
           .toUri();
   Link link = new Link(uri.toString(), "customers");
   objects.add(link);
   return ResponseEntity.ok(objects);
 }
 private void refreshGalleryList(Resources resources) {
   if (resources != null) {
     List<GalleryResource> galleries = new ArrayList<GalleryResource>(resources.getContent());
     if (null != this.galleryListFragmentListener) {
       this.galleryListFragmentListener.onDownloadGalleriesComplete(galleries);
     }
     ListAdapter listAdapter = new GalleryListAdapter(getActivity(), galleries);
     setListAdapter(listAdapter);
   }
 }
  @Test
  public void accessServiceUsingRestTemplate() {

    // Access root resource

    URI uri = URI.create(String.format(SERVICE_URI, port));
    RequestEntity<Void> request = RequestEntity.get(uri).accept(HAL_JSON).build();
    Resource<Object> rootLinks =
        restOperations.exchange(request, new ResourceType<Object>() {}).getBody();
    Links links = new Links(rootLinks.getLinks());

    // Follow stores link

    Link storesLink = links.getLink("stores").expand();
    request = RequestEntity.get(URI.create(storesLink.getHref())).accept(HAL_JSON).build();
    Resources<Store> stores =
        restOperations.exchange(request, new ResourcesType<Store>() {}).getBody();

    stores.getContent().forEach(store -> log.info("{} - {}", store.name, store.address));
  }
    /**
     * Returns whether the given {@link Resources} instance matches the given {@link
     * ResolvableType}. We predict this by inspecting the first element of the content of the {@link
     * Resources}.
     *
     * @param resources the {@link Resources} to inspect.
     * @param target that target {@link ResolvableType}.
     * @return
     */
    static boolean isValueTypeMatch(Resources<?> resources, ResolvableType target) {

      if (resources == null) {
        return false;
      }

      Collection<?> content = resources.getContent();

      if (content.isEmpty()) {
        return false;
      }

      ResolvableType superType = null;

      for (Class<?> resourcesType :
          Arrays.<Class<?>>asList(resources.getClass(), Resources.class)) {

        superType = ResolvableType.forClass(resourcesType, getRawType(target));

        if (superType != null) {
          break;
        }
      }

      if (superType == null) {
        return false;
      }

      Object element = content.iterator().next();
      ResolvableType resourceType = superType.getGeneric(0);

      if (element instanceof Resource) {
        return ResourceProcessorWrapper.isValueTypeMatch((Resource<?>) element, resourceType);
      } else if (element instanceof EmbeddedWrapper) {
        return isRawTypeAssignable(resourceType, ((EmbeddedWrapper) element).getRelTargetType());
      }

      return false;
    }
 @RequestMapping(method = RequestMethod.GET)
 HttpEntity<Resources<Profile>> showCustomers() {
   Resources<Profile> resources = new Resources<Profile>(this.repository.findAll());
   resources.add(this.entityLinks.linkToCollectionResource(Profile.class));
   return new ResponseEntity<Resources<Profile>>(resources, HttpStatus.OK);
 }