writeAccessRules(entryNode);
        writeEntryAttributes(entryNode);
        return entryNode;
    }

    protected String normalizePath(String path) {
        return PathUtil.normalizePath(path);
    }

    private Set<AccessRule> readAccessRules(Node node) {
        Set<AccessRule> accessRules = new LinkedHashSet<>();

                    } else {
                        buf.append(split);
                    }
                    final String normalizePath = systemHelper.normalizeConfigPath(path);
                    if (StringUtil.isNotBlank(normalizePath)) {
                        buf.append(normalizePath);
                    }
                }
                this.includedPaths = Pattern.compile(buf.toString());
            }

func LocalEndpoint(path, file string) (string, error) {
	u := url.URL{
		Scheme: unixProtocol,
		Path:   path,
	}
	return filepath.Join(u.String(), file+".sock"), nil
}

// NormalizePath is a no-op for Linux for now
func NormalizePath(path string) string {
	return path

    }

    @Override
    public LocallyAvailableResource move(String key, File source) {
        return delegate.move(normalizePath(key), source);
    }

    protected String normalizePath(String path) {
        return path.replaceAll("[^\\d\\w\\./]", "_");
    }

    protected String normalizeSearchPath(String path) {

                int len = rootDirPath.length();
                path = entry.getKey() + filePath.substring(len);
                usedVar = true;
                break;
            }
        }
        path = PathUtil.normalizePath(path != null ? path : file.getAbsolutePath());
        return new FileReferenceImpl(file, path, usedVar);
    }

    /**
     * Creates a reference to the given path. Returns null for null path
     */

		return time.Time{}, err
	}
	return currentTime.Add(-time.Duration(output) * time.Millisecond).Truncate(time.Second), nil
}

// NormalizePath converts FS paths returned by certain go frameworks (like fsnotify)
// to native Windows paths that can be passed to Windows specific code
func NormalizePath(path string) string {
	path = strings.ReplaceAll(path, "/", "\\")
	if strings.HasPrefix(path, "\\") {
		path = "c:" + path
	}
	return path

    public WbResource(String deployPath, String sourcePath) {
        Preconditions.checkNotNull(deployPath);
        Preconditions.checkNotNull(sourcePath);
        this.deployPath = PathUtil.normalizePath(deployPath);
        this.sourcePath = PathUtil.normalizePath(sourcePath);
    }

    public String getDeployPath() {
        return deployPath;
    }

    public void setDeployPath(String deployPath) {

    private List<String> excludes;
    //optional
    private File dir;
    private String name;

    public SourceFolder(Node node) {
        super(node);
        this.output = normalizePath((String) node.attribute("output"));
        this.includes = parseNodeListAttribute(node, "including");
        this.excludes = parseNodeListAttribute(node, "excluding");
    }

    }

    private ExpectMethod doGet(String path) {
        return new ExpectMethod("GET", normalizePath(path), timeout, lock);
    }

    /**
     * Expect a PUT request to the given path, discard the request body
     */
    public ExpectedRequest put(String path) {
        return new ExpectMethodAndRunAction("PUT", normalizePath(path), new SendEmptyResponse());
    }

    /**

}

// MustAsString calls MustAsBytes and then converts to string.
func MustAsString(filename string) string {
	return string(MustAsBytes(filename))
}

// NormalizePath expands the homedir (~) and returns an error if the file doesn't exist.
func NormalizePath(originalPath string) (string, error) {
	if originalPath == "" {
		return "", nil
	}
	// trim leading/trailing spaces from the path and if it uses the homedir ~, expand it.