}
        return toProjection();
    }

    public ModelAdapter getAdapter() {
        if (!state.isAtLeast(State.Created)) {
            throw new IllegalStateException(String.format("Cannot get adapter for '%s' in state %s.", getPath(), state));
        }
        return toProjection();
    }

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

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

	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 {

    private static final Comparator<File> FILE_SEGMENT_COMPARATOR = new Comparator<File>() {
        @Override
        public int compare(File left, File right) {
            String leftPath = left.getPath();
            String rightPath = right.getPath();

            int len1 = leftPath.length();
            int len2 = rightPath.length();
            int lim = Math.min(len1, len2);

            int k = 0;
            while (k < lim) {

    }

    private RuntimeException throwTaskSelectionException(SelectionContext context, ProjectState targetProject, String taskName, boolean includeSubprojects, NameMatcher matcher) {
        String searchContext = getSearchContext(targetProject, includeSubprojects);

        if (context.getOriginalPath().getPath().equals(taskName)) {

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/kubernetes/pkg/volume"
	"k8s.io/kubernetes/pkg/volume/util"
	"k8s.io/kubernetes/pkg/volume/util/recyclerclient"
)

func getPath(uid types.UID, volName string, host volume.VolumeHost) string {
	return host.GetPodVolumeDir(uid, utilstrings.EscapeQualifiedName(nfsPluginName), volName)
}

// ProbeVolumePlugins is the primary entrypoint for volume plugins.

            if (outputFiles.getIfPresent(currentFile.getPath()) == OutputKind.OUTPUT) {
                return true;
            }
            currentFile = currentFile.getParentFile();
        }
        return false;
    }

    private boolean containsFilesGeneratedByGradle(File absoluteFile) {
        return outputFiles.getIfPresent(absoluteFile.getPath()) != null;
    }

    @Override

        this.rootProject = rootProject;
    }

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

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

    @Override
    public String getBuildTreePath() {
        return project.getBuildTreePath();
    }

    @Override
    public Directory getProjectDirectory() {

)

// downwardAPIPlugin implements the VolumePlugin interface.
type downwardAPIPlugin struct {
	host volume.VolumeHost
}

var _ volume.VolumePlugin = &downwardAPIPlugin{}

func getPath(uid types.UID, volName string, host volume.VolumeHost) string {
	return host.GetPodVolumeDir(uid, utilstrings.EscapeQualifiedName(downwardAPIPluginName), volName)
}

func wrappedVolumeSpec() volume.Spec {
	return volume.Spec{