docs: public void doCached(final CacheRequest pRequest, final CacheResponse pResponse, final ResponseResolver pResolver) throws IOException, CacheException {
          // TODO: Expire cached items on PUT/POST/DELETE/PURGE
          // If not cachable request, resolve directly
          if (!isCacheable(pRequest)) {
              pResolver.resolve(pRequest, pResponse);
          }
          else {
              // Generate cacheURI
              String cacheURI = generateCacheURI(pRequest);
  //             System.out.println(" ## HTTPCache ## Request Id (cacheURI): " + cacheURI);
  
              // Get/create cached entity
              CachedEntity cached;
              synchronized (entityCache) {
                  cached = entityCache.get(cacheURI);
                  if (cached == null) {
                      cached = new CachedEntityImpl(cacheURI, this);
                      entityCache.put(cacheURI, cached);
                  }
              }
  
              // else if (not cached || stale), resolve through wrapped (caching) response
              // else render to response
  
              // TODO: This is a bottleneck for uncachable resources. Should not
              // synchronize, if we know (HOW?) the resource is not cachable.
              synchronized (cached) {
                  if (cached.isStale(pRequest) /* TODO: NOT CACHED?! */) {
                      // Go fetch...
                      WritableCachedResponse cachedResponse = cached.createCachedResponse();
                      pResolver.resolve(pRequest, cachedResponse);
  
                      if (isCachable(cachedResponse)) {
  //                        System.out.println("Registering content: " + cachedResponse.getCachedResponse());
                          registerContent(cacheURI, pRequest, cachedResponse.getCachedResponse());
                      }
                      else {
                          // TODO: What about non-cachable responses? We need to either remove them from cache, or mark them as stale...
                          // Best is probably to mark as non-cacheable for later, and NOT store content (performance)
  //                        System.out.println("Non-cacheable response: " + cachedResponse);
  
                          // TODO: Write, but should really do this unbuffered.... And some resolver might be able to do just that?
                          // Might need a resolver.isWriteThroughForUncachableResources() method...
                          pResponse.setStatus(cachedResponse.getStatus());
                          cachedResponse.writeHeadersTo(pResponse);
                          cachedResponse.writeContentsTo(pResponse.getOutputStream());
                          return;
                      }
                  }
              }
  
              cached.render(pRequest, pResponse);
          }
      }