docs: @Override
      @Trivial
      public InputStream getInputStream(ZipFile useZipFile, ZipEntry zipEntry) throws IOException {
          String methodName = "getInputStream";
          String entryName = zipEntry.getName();
  
          if ( zipEntry.isDirectory() ) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() ) {
                  debug(methodName, "Entry [ " + entryName + " ] [ null ] (Not using cache: Directory entry)");
              }
              return null;
          }
  
          long entrySize = zipEntry.getSize();
          if ( entrySize == 0 ) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() ) {
                  debug(methodName, "Entry [ " + entryName + " ] [ empty stream ] (Not using cache: Empty entry)");
              }
              return EMPTY_STREAM;
          }
  
          boolean doNotCache;
          String doNotCacheReason;
          if ( zipEntries == null ) { // No entry cache.
              doNotCache = true;
              doNotCacheReason = "Do not cache: Entry cache disabled";
          } else if ( entrySize > ZipCachingProperties.ZIP_CACHE_ENTRY_LIMIT) { // Too big for the cache
              doNotCache = true;
              doNotCacheReason = "Do not cache: Too big";
          } else if ( entryName.equals("META-INF/MANIFEST.MF") ) {
              doNotCache = false;
              doNotCacheReason = "Cache META-INF/MANIFEST.MF";
          } else if ( entryName.endsWith(".class") ) {
              doNotCache = false;
              doNotCacheReason = "Cache .class resources";
          } else {
              doNotCache = true;
              doNotCacheReason = "Do not cache: Not manifest or class resource";
          }
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() ) {
              debug(methodName, "Entry [ " + entryName + " ] [ non-null ] [ " + doNotCacheReason + " ]");
          }
  
          if ( doNotCache ) {
              return useZipFile.getInputStream(zipEntry); // throws IOException
          }
  
          // The addition of ":::" *seems* to allow for non-unique cache keys.  Duplicate
          // keys *are not* possible because the CRC and last-modified values are numeric.
          // Duplicate keys would be possible of the CRC or last-modified values, when
          // converted to strings, could contain ":::" character sequences.
  
          String entryCacheKey =
                 entryName +
                 ":::" + Long.toString( zipEntry.getCrc() ) +
                 ":::" + Long.toString( getLastModified() );
  
          // Note that only the individual gets and puts are protected.
          //
          // That means that simultaneous get misses are possible, which
          // will result in double reads and double puts.
          //
          // That is unfortunate, but is harmless.
          //
          // The simultaneous puts are allowed because they should be very
          // rare.
          //
          // They are allowed because blocking entry gets while waiting for
          // reads could create large delays.
  
          byte[] entryBytes;
          synchronized( zipEntriesLock ) {
              entryBytes = zipEntries.get(entryCacheKey);
          }
  
          if ( entryBytes == null ) {
              InputStream inputStream = useZipFile.getInputStream(zipEntry); // throws IOException
              try {
                  entryBytes = read(inputStream, (int) entrySize, entryName); // throws IOException
              } finally {
                  inputStream.close(); // throws IOException
              }
  
              synchronized( zipEntriesLock ) {
                  zipEntries.put(entryCacheKey, entryBytes);
              }
          }
  
          return new ByteArrayInputStream(entryBytes);
      }