*/
    @CheckReturnValue
    public VersionHierarchyRoot updateVersion(String location) {
        long newVersion = rootNode.getMaxVersionInHierarchy() + 1;
        VfsRelativePath relativePath = VfsRelativePath.of(location);
        VersionHierarchy newRootNode = relativePath.isEmpty()
            ? VersionHierarchy.empty(newVersion)
            : rootNode.updateVersion(relativePath, newVersion, caseSensitivity);

     *
     * @param newVersion The new version. Must be bigger than the current maximum version in this hierarchy.
     */
    @CheckReturnValue
    public VersionHierarchy updateVersion(VfsRelativePath relativePath, long newVersion, CaseSensitivity caseSensitivity) {
        ChildMap<VersionHierarchy> newChildren = children.store(relativePath, caseSensitivity, new ChildMap.StoreHandler<VersionHierarchy>() {

    /** {@inheritDoc} */
    public ArtifactRepository getRepository() {
        return artifact.getRepository();
    }

    /** {@inheritDoc} */
    public void updateVersion(String version, ArtifactRepository localRepository) {
        artifact.updateVersion(version, localRepository);
    }

    /** {@inheritDoc} */
    public String getDownloadUrl() {
        return artifact.getDownloadUrl();
    }

            .inits().collect { "/${it.join('/')}".toString() }
    }

    private void updateVersions(String... locations) {
        VersionHierarchyRoot newVersionHierarchyRoot = versionHierarchyRoot
        for (location in locations) {
            newVersionHierarchyRoot = newVersionHierarchyRoot.updateVersion(location)
        }
        versionHierarchyRoot = newVersionHierarchyRoot
    }

                    throw new ArtifactNotFoundException("Unable to determine the latest version", artifact);
                }

                artifact.setBaseVersion(version);
                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

                    throw new ArtifactNotFoundException("Unable to determine the release version", artifact);
                }

                artifact.setBaseVersion(version);
                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

                result = updateNotifyingListeners(diffListener -> currentRoot.invalidate(location, diffListener));
                newVersionHierarchyRoot = newVersionHierarchyRoot.updateVersion(location);
            }
            versionHierarchyRoot = newVersionHierarchyRoot;
            return result;
        });
    }

    @Override
    public void invalidateAll() {

    Collection<ArtifactMetadata> getMetadataList();

    void setRepository(ArtifactRepository remoteRepository);

    ArtifactRepository getRepository();

    void updateVersion(String version, ArtifactRepository localRepository);

    String getDownloadUrl();

    void setDownloadUrl(String downloadUrl);

    ArtifactFilter getDependencyFilter();

        if (artifact.isSnapshot() && artifact.getBaseVersion().equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);
                artifact.updateVersion(version, request.getLocalRepository());
            } catch (RepositoryMetadataResolutionException e) {
                throw new ArtifactResolutionException(e.getMessage(), artifact, e);
            }
        }
    }

                    }
                }
            }
        }
        return result;
    }

    @Override
    public void updateVersion(String version, ArtifactRepository localRepository) {
        setResolvedVersion(version);
        setFile(new File(localRepository.getBasedir(), localRepository.pathOf(this)));
    }

    @Override