} else if (output.getPath().startsWith(outputDirPrefix)) {
                String relativePath = RelativePath.parse(true, output.getPath().substring(outputDirPrefix.length())).getPathString();
                delegate.addProducedOutput(relativePath);
                workspaceAction.accept(output);
            } else if (output.getPath().startsWith(inputArtifactPrefix)) {

        lock.lock();
        try {
            return started;
        } finally {
            lock.unlock();
        }
    }

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

    @Override
    public String getMethod() {
        return handler.getMethod();
    }

    @Override
    public void assertCanWait() throws IllegalStateException {

        long now = clock.getCurrentTime();
        buildProfile.getProjectProfile(project.getPath()).getConfigurationOperation().setStart(now);
    }

    @Override
    public void afterEvaluate(Project project, ProjectState state) {
        long now = clock.getCurrentTime();
        ProjectProfile projectProfile = buildProfile.getProjectProfile(project.getPath());
        projectProfile.getConfigurationOperation().setFinish(now);
    }

        return origin;
    }

    /**
     * A string representing the path of this {@link ClassLoaderScope} in the {@link ClassLoaderScope} graph.
     */
    public String getPath() {
        return id.getPath();
    }

    @Override
    public ClassLoaderScope local(ClassPath classPath) {
        return immutable();
    }

    @Override
    public ClassLoaderScope export(ClassPath classPath) {

     * Called for each root of the current property.
     * <p>
     * {@link VisitState#getName()} and {@link VisitState#getPath()} may be called during.
     */
    void preRoot(VisitState state);

    /**
     * Called before entering a directory.
     * <p>
     * {@link VisitState#getName()} and {@link VisitState#getPath()} may be called during.
     */
    void preDirectory(VisitState state);

    /**

	}
	klog.Infof("Portworx Volume %s setup at %s", b.volumeID, dir)
	return nil
}

func (pwx *portworxVolume) GetPath() string {
	return getPath(pwx.podUID, pwx.volName, pwx.plugin.host)
}

type portworxVolumeUnmounter struct {
	*portworxVolume
}

var _ volume.Unmounter = &portworxVolumeUnmounter{}

        final PathInfo pi = convertToItem(id);
        if (StringUtil.isEmpty(pi.getPath()) && StringUtil.isEmpty(pi.getName())) {
            return StringUtil.EMPTY;
        }
        if (StringUtil.isEmpty(pi.getPath())) {
            return pi.getName();
        }
        return pi.getPath() + "/" + pi.getName();
    }

    public static PathInfo convertToItem(final String id) {

	volName string
	podUID  types.UID
	plugin  *secretPlugin
	mounter mount.Interface
	volume.MetricsProvider
}

var _ volume.Volume = &secretVolume{}

func (sv *secretVolume) GetPath() string {
	return getPath(sv.podUID, sv.volName, sv.plugin.host)
}

// secretVolumeMounter handles retrieving secrets from the API server
// and placing them into the volume on the host.
type secretVolumeMounter struct {

        Path path = getPath(name, level);
        Files.write(path, bytes, StandardOpenOption.CREATE_NEW);
        return new Source(path);
    }

    @Override
    public DataTarget createTarget(String name, Level level) {
        return new Target(getPath(name, level));
    }

    private Path getPath(String name, Level level) {

             * The path of the project.
             *
             * See {@code org.gradle.api.Project#getPath()}.
             */
            String getPath();

            /**
             * The path of the project within the entire build execution.
             * For top-level builds this will be the same as {@link #getPath()}.
             * For nested builds the project path will be prefixed with a build path.
             *