flattened.put(node.getPath(), node);
        if (node.isAtLeast(ModelNode.State.Discovered)) {
            doNotify(node);
        }
    }

    private void doNotify(ModelNodeInternal node) {
        notifying = true;
        try {
            notifyListeners(node, pathListeners.get(node.getPath()));
            notifyListeners(node, parentListeners.get(node.getPath().getParent()));

        }
        if (LOGGER.isDebugEnabled()) {
            String targetPath = target == null ? null : "'" + target.getPath() + "'";
            LOGGER.debug("Project {} - Setting the target of model element '{}' to point at {}.",
                modelRegistry.getProjectPath(), getPath(), targetPath);
        }
        this.target = (ModelNodeInternal) target;

                    throw new DictionaryException("Failed to update " + dictFile.getPath());
                }
            } catch (final IOException e) {
                throw new DictionaryException("Failed to update " + dictFile.getPath(), e);
            }

        }).orElse(() -> {
            throw new DictionaryException(dictFile.getPath() + " does not exist.");
        });
    }

        if (!FileModelSource.class.equals(obj.getClass())) {
            return false;
        }
        FileModelSource other = (FileModelSource) obj;
        return getPath().equals(other.getPath());
    }

    @Override
    public int hashCode() {
        return getPath().hashCode();
    }

        when:
        def file = ClasspathUtil.getClasspathForResource(jarUrlWithResourceName, "Test.class")

        then:
        FILE.getPath() == file.getPath()
    }

    @Issue("https://github.com/gradle/gradle/issues/23625")
    def "getClasspathForResource for jar scheme with prefix resource name"() {
        given:

        scopeReferences.addNodeToScope(node.getPath(), node);
        scopeReferences.addNodeToScope(node.getPath().getParent(), node);
    }

    private void bound(Reference reference, ModelNodeInternal node) {
        ModelBinding binding = reference.binding;
        binding.onBind(node);
        reference.index.put(new NodeAtState(node.getPath(), binding.predicate.getState()), reference.owner);
    }

	err := validation.ValidatePathNoBacksteps(b.GetPath())
	if err != nil {
		return fmt.Errorf("invalid HostPath `%s`: %v", b.GetPath(), err)
	}

	if *b.pathType == v1.HostPathUnset {
		return nil
	}
	if b.noTypeChecker {
		return nil
	} else {
		return checkType(b.GetPath(), b.pathType, b.hu)
	}
}

        Map<String, String> attributes = toAttributes(module, artifact);
        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override
    public ExternalResourceName toModulePath(ModuleIdentifier module) {
        String pattern = getBase().getPath();
        if (!pattern.endsWith(MavenPattern.M2_PATTERN)) {

    private static final Comparator<Provider> PROVIDER_COMPARATOR = new Comparator<Provider>() {
        @Override
        public int compare(Provider o1, Provider o2) {
            return o1.getPath().compareTo(o2.getPath());
        }
    };

    private final String referenceType;
    private final String referenceDescription;
    private final List<Provider> providers;

    public static class Provider {

        return InstanceModelView.of(modelNode.getPath(), MODEL_ELEMENT_MODEL_TYPE, new ModelElement() {
            @Override
            public String toString() {
                return getDisplayName();
            }

            @Override
            public String getName() {
                return modelNode.getPath().getName();
            }

            @Override