Example usage for org.eclipse.jdt.core IPackageFragmentRoot getPath

List of usage examples for org.eclipse.jdt.core IPackageFragmentRoot getPath

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IPackageFragmentRoot
  6. getPath

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IPackageFragmentRoot getPath.

Prototype

IPath getPath();

Source Link

Document

Returns the path to the innermost resource enclosing this element.

Usage

From source file:eu.artist.migration.modernization.uml2java.repackaged.gen.java.services.WorkspaceServices.java

License:Open Source License

/**
 * Creates a project from scratch in the workspace.
 * /*from  w w w  .j  a v  a 2s.  com*/
 * @param eObject
 *            The model element
 */
public void createDefaultProject(EObject eObject) {
    if (!EMFPlugin.IS_ECLIPSE_RUNNING) {
        return;
    }

    IProgressMonitor monitor = new NullProgressMonitor();
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    try {
        IWorkspaceRoot workspaceRoot = workspace.getRoot();

        String projectName = UML2JavaConfigurationHolder.getDefaultProjectName(eObject);
        IProject project = workspaceRoot.getProject(projectName);

        if (project.exists() && project.isAccessible()) {
            if (!project.isOpen()) {
                project.open(monitor);
            }
        } else {
            project.create(new NullProgressMonitor());
            project.open(new NullProgressMonitor());

            IContainer intputContainer = project;

            String sourceFolderName = UML2JavaConfigurationHolder.getSourceFolderPath(eObject);
            StringTokenizer stringTokenizer = new StringTokenizer(sourceFolderName, "/");
            while (stringTokenizer.hasMoreTokens()) {
                String token = stringTokenizer.nextToken();
                IFolder src = intputContainer.getFolder(new Path(token));
                if (!src.exists()) {
                    src.create(true, true, monitor);
                }

                intputContainer = src;
            }

            IContainer outputContainer = project;

            String outputFolderName = UML2JavaConfigurationHolder.getOutputFolderPath(eObject);
            stringTokenizer = new StringTokenizer(outputFolderName, "/");
            while (stringTokenizer.hasMoreTokens()) {
                String token = stringTokenizer.nextToken();
                IFolder out = outputContainer.getFolder(new Path(token));
                if (!out.exists()) {
                    out.create(true, true, monitor);
                }

                outputContainer = out;
            }

            IProjectDescription description = project.getDescription();
            String[] natures = new String[] {};
            if (IUML2JavaConstants.Default.DEFAULT_COMPONENT_ARTIFACTS_TYPE_OSGI
                    .equals(UML2JavaConfigurationHolder.getComponentBasedArchitecture(eObject))
                    || IUML2JavaConstants.Default.DEFAULT_COMPONENT_ARTIFACTS_TYPE_ECLIPSE
                            .equals(UML2JavaConfigurationHolder.getComponentBasedArchitecture(eObject))) {
                natures = new String[] { JavaCore.NATURE_ID, IUML2JavaConstants.PDE_PLUGIN_NATURE_ID };
            } else {
                natures = new String[] { JavaCore.NATURE_ID, };
            }
            description.setNatureIds(natures);
            project.setDescription(description, monitor);

            IJavaProject javaProject = JavaCore.create(project);

            List<IClasspathEntry> entries = new ArrayList<IClasspathEntry>();
            IExecutionEnvironmentsManager executionEnvironmentsManager = JavaRuntime
                    .getExecutionEnvironmentsManager();
            IExecutionEnvironment[] executionEnvironments = executionEnvironmentsManager
                    .getExecutionEnvironments();

            String defaultJREExecutionEnvironment = UML2JavaConfigurationHolder
                    .getJREExecutionEnvironment(eObject);
            for (IExecutionEnvironment iExecutionEnvironment : executionEnvironments) {
                if (defaultJREExecutionEnvironment.equals(iExecutionEnvironment.getId())) {
                    entries.add(
                            JavaCore.newContainerEntry(JavaRuntime.newJREContainerPath(iExecutionEnvironment)));
                    break;
                }
            }

            javaProject.setRawClasspath(entries.toArray(new IClasspathEntry[entries.size()]), null);

            IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
            IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1];
            System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);

            javaProject.setOutputLocation(outputContainer.getFullPath(), monitor);

            IPackageFragmentRoot packageRoot = javaProject
                    .getPackageFragmentRoot(intputContainer.getFullPath().toString());
            newEntries[oldEntries.length] = JavaCore.newSourceEntry(packageRoot.getPath(), new Path[] {},
                    new Path[] {}, outputContainer.getFullPath());

            javaProject.setRawClasspath(newEntries, null);

            IFile buildPropertiesFile = project.getFile("build.properties");
            if (!buildPropertiesFile.exists()) {
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.append(
                        "#################################################################################"
                                + System.getProperty("line.separator"));
                stringBuilder.append("## " + UML2JavaConfigurationHolder.getCopyrightAndLicense(eObject)
                        + System.getProperty("line.separator"));
                stringBuilder.append(
                        "#################################################################################"
                                + System.getProperty("line.separator"));
                stringBuilder.append("source.. = " + UML2JavaConfigurationHolder.getSourceFolderPath(eObject)
                        + System.getProperty("line.separator"));
                stringBuilder.append("output.. = " + UML2JavaConfigurationHolder.getOutputFolderPath(eObject)
                        + System.getProperty("line.separator"));
                stringBuilder.append("" + System.getProperty("line.separator"));
                buildPropertiesFile.create(new ByteArrayInputStream(stringBuilder.toString().getBytes()), true,
                        monitor);
            }
        }
    } catch (CoreException coreException) {
        AcceleoEnginePlugin.log(coreException, true);
    }
}

From source file:eu.cloudwave.wp5.feedback.eclipse.tests.fixtures.base.JavaProjectFixture.java

License:Apache License

private IPackageFragmentRoot createSourceFolder() throws CoreException {
    final IFolder folder = project.getFolder("src");
    folder.create(false, true, null);//from  w ww .  j av a  2 s . co  m
    final IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(folder);
    final IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
    final IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1];
    System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
    newEntries[oldEntries.length] = JavaCore.newSourceEntry(root.getPath());
    javaProject.setRawClasspath(newEntries, null);
    return root;
}

From source file:fr.inria.diverse.trace.benchmark.EngineHelper.java

License:Open Source License

public void prepareEngine(URI model, IDebuggerHelper debugger, Language language)
        throws CoreException, EngineContextException {

    IRunConfiguration runConfiguration = new BenchmarkRunConfiguration(debugger, language, model);

    // We don't want to debug actually, ie we don't want the animator
    ExecutionMode executionMode = ExecutionMode.Run;

    // In this construction, the addons are created and loaded as well
    executionContext = new ModelExecutionContext(runConfiguration, executionMode);

    String className = executionContext.getRunConfiguration().getExecutionEntryPoint();
    SearchPattern pattern = SearchPattern.createPattern(className, IJavaSearchConstants.CLASS,
            IJavaSearchConstants.DECLARATIONS, SearchPattern.R_EXACT_MATCH);
    IJavaSearchScope scope = SearchEngine.createWorkspaceScope();
    DefaultSearchRequestor requestor = new DefaultSearchRequestor();
    SearchEngine engine = new SearchEngine();

    engine.search(pattern, new SearchParticipant[] { SearchEngine.getDefaultSearchParticipant() }, scope,
            requestor, null);/*  w  ww .  j av  a  2  s .c o m*/

    IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) requestor._binaryType.getPackageFragment()
            .getParent();

    parameters = new ArrayList<>();
    parameters.add(executionContext.getResourceModel().getContents().get(0));
    String bundleName = null;
    bundleName = packageFragmentRoot.getPath().removeLastSegments(1).lastSegment().toString();

    Class<?> c = null;

    Bundle bundle = Platform.getBundle(bundleName);

    // If not found, we try again with projects
    if (bundle == null) {

        String projectName = requestor._binaryType.getJavaProject().getElementName();
        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
        if (project != null && project.exists()
                && !project.getFullPath().equals(executionContext.getWorkspace().getProjectPath())) {
            Provisionner p = new Provisionner();
            IStatus status = p.provisionFromProject(project, null);
            if (!status.isOK()) {
                throw new CoreException(new Status(1, "EngineHelper", "couldn't provision project :("));
            }
        }
        bundleName = project.getName();
        bundle = Platform.getBundle(bundleName);

    }

    try {
        c = bundle.loadClass(executionContext.getRunConfiguration().getExecutionEntryPoint());
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
        throw new CoreException(new Status(1, "EngineHelper", "couldn't load Main class"));
    }
    method = null;
    try {
        method = c.getMethod("main", parameters.get(0).getClass().getInterfaces()[0]);
    } catch (Exception e) {
        e.printStackTrace();
        throw new CoreException(new Status(1, "EngineHelper", "couldn't find main method"));
    }
    o = null;
    try {
        o = c.newInstance();
    } catch (Exception e) {
        e.printStackTrace();
        throw new CoreException(new Status(1, "EngineHelper", "couldn't create Main object"));
    }

    _executionEngine = new PlainK3ExecutionEngine(executionContext, o, method, parameters);
    debugger.setExecutionEngine(_executionEngine);

}

From source file:hydrograph.ui.expression.editor.buttons.ValidateExpressionToolButton.java

License:Apache License

public static Object[] getBuildPathForMethodInvocation() throws JavaModelException, MalformedURLException {
    String transfromJarPath = null;
    Object[] returnObj = new Object[3];
    IJavaProject iJavaProject = JavaCore
            .create(BuildExpressionEditorDataSturcture.INSTANCE.getCurrentProject());
    List<URL> urlList = new ArrayList<>();
    Properties properties = ConfigFileReader.INSTANCE.getCommonConfigurations();
    for (IPackageFragmentRoot iPackageFragmentRoot : iJavaProject.getAllPackageFragmentRoots()) {
        if (!iPackageFragmentRoot.isExternal()
                || StringUtils.contains(iPackageFragmentRoot.getElementName(),
                        properties.getProperty(Constants.KEY_TRANSFORMATION_JAR))
                || StringUtils.contains(iPackageFragmentRoot.getElementName(), Constants.ANTLR_JAR_FILE_NAME)
                || StringUtils.contains(iPackageFragmentRoot.getElementName(),
                        Constants.BEAN_SHELLJAR_FILE_NAME)
                || StringUtils.contains(iPackageFragmentRoot.getElementName(), Constants.SL4JLOG)
                || StringUtils.contains(iPackageFragmentRoot.getElementName(),
                        properties.getProperty(Constants.KEY_EXPRESSION_JAR))) {
            URL url = null;/*from w w w  .j  a v  a2s. c  o  m*/
            if (!iPackageFragmentRoot.isExternal()) {
                url = BuildExpressionEditorDataSturcture.INSTANCE.getCurrentProject()
                        .getFile(iPackageFragmentRoot.getPath().removeFirstSegments(1)).getLocation().toFile()
                        .toURI().toURL();
                urlList.add(url);
            } else {
                url = iPackageFragmentRoot.getPath().toFile().toURI().toURL();
                urlList.add(url);
            }

            if (!iPackageFragmentRoot.isExternal()
                    || StringUtils.contains(iPackageFragmentRoot.getElementName(),
                            properties.getProperty(Constants.KEY_TRANSFORMATION_JAR))) {
                if (transfromJarPath == null) {
                    if (OSValidator.isMac() || OSValidator.isUnix())
                        transfromJarPath = url.getPath() + Constants.COLON;
                    else
                        transfromJarPath = url.getPath() + Constants.SEMICOLON;
                } else {
                    if (OSValidator.isMac() || OSValidator.isUnix())
                        transfromJarPath = transfromJarPath + url.getPath() + Constants.COLON;
                    else
                        transfromJarPath = transfromJarPath + url.getPath() + Constants.SEMICOLON;
                }
            }
        }
    }

    returnObj[0] = urlList;
    returnObj[1] = transfromJarPath;
    returnObj[2] = getPropertyFilePath(iJavaProject);
    iJavaProject.close();
    return returnObj;
}

From source file:hydrograph.ui.expression.editor.composites.CategoriesDialogSourceComposite.java

License:Apache License

@SuppressWarnings("restriction")
private void loadComboJarListFromBuildPath(Combo comboJarList, String newJarName) {
    comboJarList.removeAll();/* w w w  .j a  va2 s.  co  m*/
    IProject iProject = BuildExpressionEditorDataSturcture.INSTANCE.getCurrentProject();
    IJavaProject iJavaProject = null;
    try {
        iJavaProject = JavaCore.create(iProject);
        PackageFragmentRoot srcfragmentRoot = BuildExpressionEditorDataSturcture.INSTANCE
                .getSrcPackageFragment(iJavaProject);
        comboJarList.add(hydrograph.ui.common.util.Constants.ProjectSupport_SRC);
        comboJarList.setData(String.valueOf(comboJarList.getItemCount() - 1), srcfragmentRoot);

        for (IPackageFragmentRoot iPackageFragmentRoot : iJavaProject.getAllPackageFragmentRoots()) {
            if (isJarPresentInLibFolder(iPackageFragmentRoot.getPath())
                    && iPackageFragmentRoot.getKind() != IPackageFragmentRoot.K_SOURCE) {
                comboJarList.add(iPackageFragmentRoot.getElementName());
                comboJarList.setData(String.valueOf(comboJarList.getItemCount() - 1), iPackageFragmentRoot);
            }
        }
        selectAndLoadJarData(newJarName);
    } catch (JavaModelException javaModelException) {
        LOGGER.error("Error occurred while loading engines-transform jar", javaModelException);
    } finally {
        if (iJavaProject != null) {
            try {
                iJavaProject.close();
            } catch (JavaModelException e) {
                LOGGER.warn("JavaModelException occurred while closing java-project" + e);
            }
        }
    }

}

From source file:hydrograph.ui.expression.editor.sourceviewer.SourceViewer.java

License:Apache License

public SourceViewer(Composite parent, IVerticalRuler verticalRuler, IOverviewRuler overviewRuler,
        boolean showAnnotationsOverview, int styles, IAnnotationAccess annotationAccess,
        ISharedTextColors sharedColors, IDocument document) {
    super(parent, verticalRuler, overviewRuler, showAnnotationsOverview, SWT.BOLD);
    int id = currentId++;
    filename = VIEWER_CLASS_NAME + id++ + ".java";
    this.sharedColors = sharedColors;
    this.annotationAccess = annotationAccess;
    this.fOverviewRuler = overviewRuler;
    oldAnnotations = new HashMap<ProjectionAnnotation, Position>();

    IJavaProject javaProject = JavaCore.create(BuildExpressionEditorDataSturcture.INSTANCE.getCurrentProject());
    try {//from   w  ww  . j  ava 2s . c o  m
        IPackageFragmentRoot[] ipackageFragmentRootList = javaProject.getPackageFragmentRoots();
        IPackageFragmentRoot ipackageFragmentRoot = null;
        for (IPackageFragmentRoot tempIpackageFragmentRoot : ipackageFragmentRootList) {
            if (tempIpackageFragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE
                    && StringUtils.equals(PathConstant.TEMP_BUILD_PATH_SETTINGS_FOLDER,
                            tempIpackageFragmentRoot.getPath().removeFirstSegments(1).toString())) {
                ipackageFragmentRoot = tempIpackageFragmentRoot;
                break;
            }
        }

        IPackageFragment compilationUnitPackage = ipackageFragmentRoot
                .createPackageFragment(HYDROGRAPH_COMPILATIONUNIT_PACKAGE, true, new NullProgressMonitor());
        compilatioUnit = compilationUnitPackage.createCompilationUnit(filename, document.get(), true,
                new NullProgressMonitor());
    } catch (Exception exception) {
        LOGGER.warn("Exception occurred while initializing source viewer", exception);
    } finally {
        if (javaProject != null) {
            try {
                javaProject.close();
            } catch (JavaModelException javaModelException) {
                LOGGER.warn("Exception occurred while closing java-project", javaModelException);
            }
        }
    }
    initializeViewer(document);
    updateContents();
}

From source file:hydrograph.ui.project.structure.wizard.ProjectStructureCreator.java

License:Apache License

/**
 * Sets the <b>src</b> folder as the source folder in project
 * @param project/*from   ww  w .  ja  va  2  s. c o  m*/
 * @param javaProject
 * @return IClasspathEntry[]
 * @throws JavaModelException
 */
private IClasspathEntry[] setSourceFolderInClassPath(IProject project, IJavaProject javaProject)
        throws JavaModelException {
    IFolder sourceFolder = project.getFolder(Constants.ProjectSupport_SRC); //$NON-NLS-1$
    IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(sourceFolder);
    IClasspathEntry[] oldEntries = javaProject.getRawClasspath();
    IClasspathEntry[] newEntries = new IClasspathEntry[oldEntries.length + 1];
    System.arraycopy(oldEntries, 0, newEntries, 0, oldEntries.length);
    newEntries[oldEntries.length] = JavaCore.newSourceEntry(root.getPath());
    return newEntries;
}

From source file:icy.icy4eclipse.core.Icy4EclipsePlugin.java

License:Open Source License

private void startIcyInternal(boolean debug, boolean bypassJarclassloader) throws CoreException {
    logInfo("Starting Icy - (debug = " + debug + ") (disableJCL = " + bypassJarclassloader + ")");

    // Check parameters
    try {//from ww  w  .j  a  v  a  2  s  .  c om
        checkIcyConfiguration();
    } catch (Icy4EclipseException e) {
        logException(e);
        return;
    }

    String hd = getIcyHomeDir();
    File pluginsDirectory = new File(hd, ICY_PLUGINS_DIR);
    List<IcyProject> icyProjects = computeOpenIcyProjectsList();
    List<String> classpath = new ArrayList<String>();

    // Add Icy jars to system class loader if needed
    if (loadIcyJar()) {
        for (String s : ICY_JARS) {
            classpath.add(hd + File.separator + s);
        }
    }

    if (bypassJarclassloader) {
        // Add Eclipse Icy projects to system class loader
        for (IcyProject p : icyProjects) {
            IJavaProject project = p.getJavaProject();
            for (String s : JavaRuntime.computeDefaultRuntimeClassPath(project)) {
                classpath.add(s);
            }
        }

        // Add plugins jars to system class loader
        IPreferenceStore pref = getPreferenceStore();
        String bypassJars = pref.getString(ICY4ECLIPSE_PREF_BYPASS_JARS_KEY);
        List<Pattern> bypassRegexp = null;
        if (bypassJars != null) {
            bypassJars = bypassJars.trim();
            if (bypassJars.length() > 0) {
                String[] bypass = bypassJars.split(":");
                bypassRegexp = new ArrayList<Pattern>();
                for (String r : bypass) {
                    bypassRegexp.add(Pattern.compile("^(.*)" + r + "$", Pattern.CASE_INSENSITIVE));
                }
            }
        }

        if (pluginsDirectory.exists()) {
            List<File> jars = getAllJarFiles(pluginsDirectory);
            for (File f : jars) {
                boolean add = true;
                String path = f.getAbsolutePath();
                if (bypassRegexp != null) {
                    for (Pattern p : bypassRegexp) {
                        Matcher m = p.matcher(path);
                        if (m.matches()) {
                            logInfo(" - bypassing jar : " + p.pattern() + " -> " + path);
                            add = false;
                            break;
                        }
                    }
                }

                if (add) {
                    classpath.add(path);
                }
            }
        }
    }

    // Other launch arguments
    StringBuffer programArguments = new StringBuffer();
    for (String arg : ICY_PRG_ARGS) {
        programArguments.append(" " + arg);
    }
    if (bypassJarclassloader) {
        programArguments.append(" " + ICY_BYPASS_JARCLASSLOADER_ARG);
    }

    StringBuffer jvmArguments = new StringBuffer();
    for (String arg : ICY_VM_MANDATORY_ARGS) {
        jvmArguments.append(" " + arg);
    }
    jvmArguments.append(" -Xmx" + getIcyMemory() + "m");
    jvmArguments.append(" " + getOtherJVMArgs());

    // Launching the JVM
    ILaunchConfigurationType launchType = DebugPlugin.getDefault().getLaunchManager()
            .getLaunchConfigurationType("org.eclipse.jdt.launching.localJavaApplication");
    ILaunchConfigurationWorkingCopy config = launchType.newInstance(null, ICY4ECLIPSE_LABEL);
    config.setAttribute(IDebugUIConstants.ATTR_PRIVATE, false);
    config.setAttribute(ILaunchConfiguration.ATTR_SOURCE_LOCATOR_ID,
            "org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector");

    if (bypassJarclassloader) {
        ISourceLookupDirector sourceLocator = new JavaSourceLookupDirector();
        ISourcePathComputer computer = DebugPlugin.getDefault().getLaunchManager()
                .getSourcePathComputer("org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer");
        sourceLocator.setSourcePathComputer(computer);

        ArrayList<ISourceContainer> sourceContainers = new ArrayList<ISourceContainer>();

        if (!icyProjects.isEmpty()) {
            for (IcyProject ip : icyProjects) {
                IJavaProject project = ip.getJavaProject();
                sourceContainers.add(new JavaProjectSourceContainer(project));
            }

            Set<IPath> external = new HashSet<IPath>();

            for (IcyProject ip : icyProjects) {
                IJavaProject project = ip.getJavaProject();

                IPackageFragmentRoot[] roots = project.getPackageFragmentRoots();
                for (int ri = 0; ri < roots.length; ri++) {
                    IPackageFragmentRoot root = roots[ri];
                    if (root.isExternal()) {
                        IPath location = root.getPath();
                        if (external.contains(location)) {
                            continue;
                        }
                        external.add(location);
                    }
                    sourceContainers.add(new PackageFragmentRootSourceContainer(root));
                }
            }
        }

        sourceContainers.add(new DefaultSourceContainer());

        sourceLocator.setSourceContainers(
                (ISourceContainer[]) sourceContainers.toArray(new ISourceContainer[sourceContainers.size()]));
        sourceLocator.initializeParticipants();
        config.setAttribute(ILaunchConfiguration.ATTR_SOURCE_LOCATOR_MEMENTO, sourceLocator.getMemento());
    }

    ArrayList<String> classpathMementos = new ArrayList<String>();
    for (String s : classpath) {
        IRuntimeClasspathEntry cpEntry = JavaRuntime.newArchiveRuntimeClasspathEntry(new Path(s));
        cpEntry.setClasspathProperty(IRuntimeClasspathEntry.USER_CLASSES);
        classpathMementos.add(cpEntry.getMemento());
    }

    IPath path = new Path(JavaRuntime.JRE_CONTAINER);
    try {
        IClasspathEntry cpEntry = JavaCore.newContainerEntry(path);
        IRuntimeClasspathEntry rcpEntry = JavaRuntime.newRuntimeContainerClasspathEntry(cpEntry.getPath(),
                IRuntimeClasspathEntry.STANDARD_CLASSES);
        classpathMementos.add(rcpEntry.getMemento());
    } catch (CoreException ex) {
        logException(ex);
    }

    config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH, false);
    config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_CLASSPATH, classpathMementos);
    config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, programArguments.toString());
    config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, jvmArguments.toString());
    config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, getIcyMainClass());
    config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, getIcyHomeDir());

    logInfo(" - home dir   : " + getIcyHomeDir());
    logInfo(" - main class : " + getIcyMainClass());
    logInfo(" - prog args  : " + programArguments);
    logInfo(" - jvm args   : " + jvmArguments);
    logInfo(" - classpath  : " + classpath);

    config.launch(debug ? ILaunchManager.DEBUG_MODE : ILaunchManager.RUN_MODE, null);

}

From source file:jmockit.assist.JunitLaunchListener.java

License:Open Source License

public boolean addJavaAgentVmArg(final ILaunchConfiguration conf) throws CoreException {
    boolean added = false;
    String vmargs = conf.getAttribute(JunitLaunchListener.VM_ARGS, "");
    String project = conf.getAttribute(JunitLaunchListener.PROJ_ATTR, "");

    IJavaModel javaModel = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot());
    IJavaProject jproj = javaModel.getJavaProject(project);

    IType mockitType = jproj.findType(MockUtil.MOCK);
    if (mockitType == null) {
        mockitType = jproj.findType(MockUtil.MOCKIT);
    }/*www  .  j a  v a2s . c  o m*/

    if (mockitType != null) {
        IPackageFragmentRoot root = (IPackageFragmentRoot) mockitType
                .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);

        if (root != null && root.isArchive()) // its a jar
        {
            String jarPath = root.getPath().toOSString();
            if (root.getResource() != null) {
                jarPath = root.getResource().getRawLocation().toString();
            }

            if (new File(jarPath).exists()) {
                String javaagentArg = "-javaagent:\"" + jarPath + "\"";
                setOrCreateVariable(javaagentArg);

                if (!vmargs.contains(JunitLaunchListener.JMOCKIT_VAR) && !vmargs.contains("-javaagent")) {
                    setRunConfVmArgs(conf, vmargs + " " + JunitLaunchListener.JMOCKIT_VAR);
                    added = true;
                }
            } else {
                Activator.log(new FileNotFoundException(jarPath));
            }
        }
    }

    return added;
}

From source file:kieker.develop.rl.ui.wizards.RecordLangNewWizardPage.java

License:Apache License

private String generatedLocalPath(final IPackageFragmentRoot fragmentRoot) {
    final IPath path = fragmentRoot.getPath();
    return path.removeFirstSegments(1).toString();
}