path:         root,
		knownFormats: formats,
		options:      options,
	})
}

var _ validate.ValueValidator = (&ratchetingValueValidator{})

func (r ratchetingValueValidator) SetPath(path string) {
	// Do nothing
	// Unused by kube-openapi
}

func (r ratchetingValueValidator) Applies(source interface{}, valueKind reflect.Kind) bool {
	return true
}

        server.allowGetOrHead(getPath(), file)
    }

    @Override
    void expectGet() {
        server.expectGet(getPath(), file)
    }

    void allowGetOrHead(String userName, String password) {
        server.allowGetOrHead(getPath(), userName, password, file)
    }

    void expectGet(String userName, String password) {
        server.expectGet(getPath(), userName, password, file)
    }

        return getPath("WEB-INF/", "view", names);
    }

    public static Path getDictionaryPath(final String... names) {
        return getPath("WEB-INF/", "dict", names);
    }

    public static Path getThumbnailPath(final String... names) {
        return getPath("WEB-INF/", "thumbnails", names);
    }

    public static Path getSitePath(final String... names) {
        return getPath("WEB-INF/", "site", names);

        if(uri.getPath() == null){
            uri = new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), "/", uri.getQuery(), uri.getFragment());
        }else if (!uri.getPath().endsWith("/") && !uri.getPath().endsWith(".html")) {
            uri = new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), uri.getPath() + "/", uri.getQuery(), uri.getFragment());

        }

        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()));

    @Override
    public void addProject(T project) {
        T previous = projects.put(project.getPath(), project);
        if (previous != null) {
            throw new IllegalArgumentException(String.format("Multiple projects registered for path '%s'.", project.getPath()));
        }
        subProjects.put(project.getPath(), new HashSet<T>());
        addProjectToParentSubProjects(project);
    }

        }
        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;

        assertSame(expectedGetProject, projectRegistry.getProject(project.getPath()));
        assertEquals(expectedAllProjects, projectRegistry.getAllProjects(project.getPath()));
        assertEquals(expectedSubProjects, projectRegistry.getSubProjects(project.getPath()));
        assertSame(expectedGetProject, projectRegistry.getProject(project.getProjectDir()));

                    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();
    }