(et, vl) -> ((ThumbnailQueue) et).setGenerator(DfTypeUtil.toString(vl)), "generator");
        setupEpg(_epgMap, et -> ((ThumbnailQueue) et).getPath(), (et, vl) -> ((ThumbnailQueue) et).setPath(DfTypeUtil.toString(vl)),
                "path");
        setupEpg(_epgMap, et -> ((ThumbnailQueue) et).getTarget(), (et, vl) -> ((ThumbnailQueue) et).setTarget(DfTypeUtil.toString(vl)),

     * @return a URI guaranteed to have a trailing slash in the path
     */
    private static URI withTrailingSlash(URI uri) {
        if (uri.getPath().endsWith("/")) {
            return uri;
        }
        try {
            return new URIBuilder(uri).setPath(uri.getPath() + "/").build();
        } catch (URISyntaxException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

                // I want to restore it before retrying. request.reset()
                // restores almost everything that was modified, except the path.
                rpath.setPath(savedPath);
                rpath.setFullUNCPath(rpath.getDomain(), rpath.getServer(), savedFullPath);
            }
            if ( response != null ) {
                response.reset();
            }

        this.relativePath = path;
    }

    @Override
    public void setName(String name) {
        relativePath = getRelativePath().replaceLastName(name);
    }

    @Override
    public void setPath(String path) {
        relativePath = RelativePath.parse(getRelativePath().isFile(), path);
    }

    boolean isExcluded() {
        return excluded;
    }

    @Override
    public void exclude() {

        }

        @Override
        public void setName(String name) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void setPath(String path) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void setRelativePath(RelativePath path) {
            throw new UnsupportedOperationException();

        this.exported = false;
        this.accessRules = new LinkedHashSet<>();
        this.entryAttributes = new LinkedHashMap<>();
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public boolean isExported() {
        return exported;
    }

    public void setExported(boolean exported) {

        cookie.setHttpOnly(httpOnly);
        if (StringUtil.isNotBlank(cookieDomain)) {
            cookie.setDomain(cookieDomain);
        }
        if (StringUtil.isNotBlank(cookiePath)) {
            cookie.setPath(cookiePath);
        }
        if (cookieSecure != null) {
            cookie.setSecure(cookieSecure);
        }
        LaResponseUtil.getResponse().addCookie(cookie);
    }

            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setGenerator(DfTypeUtil.toString(source.get("generator")));
            result.setPath(DfTypeUtil.toString(source.get("path")));
            result.setTarget(DfTypeUtil.toString(source.get("target")));
            result.setThumbnailId(DfTypeUtil.toString(source.get("thumbnail_id")));

		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
}

            private final Map<Artifact, Path> paths = new ConcurrentHashMap<>();

            @Override
            public Optional<Path> getPath(Artifact artifact) {
                return Optional.ofNullable(paths.get(artifact));
            }

            @Override
            public void setPath(Artifact artifact, Path path) {
                paths.put(artifact, path);
            }
        };
    }

    @Provides