Files.createDirectories(path.getParent());
                        Files.copy(zis, path, StandardCopyOption.REPLACE_EXISTING);
                    } else if ("css".equals(names[0])) {
                        names[0] = themeName;
                        final Path path = ResourceUtil.getCssPath(names);
                        Files.createDirectories(path.getParent());

                if (logger.isDebugEnabled()) {
                    logger.debug("Delete {}", path);
                }

                Path parent = path.getParent();
                while (deleteEmptyDirectory(parent)) {
                    parent = parent.getParent();
                }
            } catch (final IOException e) {
                logger.warn("Failed to delete {}", path, e);
            }
        }

    @Override
    public ClassLoader next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        final ClassLoader result = classLoader;
        classLoader = classLoader.getParent();
        return result;
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

     */
    public ParamMap(final Map<K, V> parent) {
        this.parent = parent;
    }

    /**
     * Gets the parent map.
     *
     * @return the parent map
     */
    public Map<K, V> getParent() {
        return parent;
    }

    /**
     * Converts a key to camelCase.
     *
     * @param key the key to convert
     * @return the converted key
     */

     */
    protected static Map<String, Object> getDataMap(final Map<String, Object> params) {
        if (params instanceof final ParamMap<String, Object> paramMap) {
            return paramMap.getParent();
        }
        return params;
    }

 *   <li>Supports a copy-free {@link #subArray} view, so methods that accept this type don't need to
 *       add overloads that accept start and end indexes.
 *   <li>Can be streamed without "breaking the chain": {@code foo.getBarInts().stream()...}.
 *   <li>Access to all collection-based utilities via {@link #asList} (though at the cost of
 *       allocating garbage).
 * </ul>
 *
 * <p>Disadvantages compared to {@code int[]}:
 *
 * <ul>

        .containsExactlyElementsIn(locations);
  }

  public void testLocationEquals() {
    ClassLoader child = getClass().getClassLoader();
    ClassLoader parent = child.getParent();
    new EqualsTester()
        .addEqualityGroup(
            new ClassPath.LocationInfo(new File("foo.jar"), child),
            new ClassPath.LocationInfo(new File("foo.jar"), child))

        /**
         * Gets the parent SearchRequestParams object that this wrapper delegates to.
         *
         * @return the parent SearchRequestParams instance
         */
        public SearchRequestParams getParent() {
            return parent;
        }

        @Override
        public String getQuery() {
            return parent.getQuery();
        }

        @Override