org.eclipse.core.runtime.QualifiedName Java Examples

private static boolean enableCpplint(IResource resource) {
	boolean enable = CppStyle.getDefault().getPreferenceStore()
			.getBoolean(CppStyleConstants.ENABLE_CPPLINT_ON_SAVE);

	try {
		IProject project = resource.getProject();
		String enableProjectSpecific = project
				.getPersistentProperty(new QualifiedName("", CppStyleConstants.PROJECTS_PECIFIC_PROPERTY));

		if (enableProjectSpecific != null && Boolean.parseBoolean(enableProjectSpecific)) {
			String value = project
					.getPersistentProperty(new QualifiedName("", CppStyleConstants.ENABLE_CPPLINT_PROPERTY));
			if (value != null) {
				return Boolean.parseBoolean(value);
			}

			return false;
		}
	} catch (CoreException e) {
		e.printStackTrace();
	}

	return enable;
}
 

public String getString(String name)
{
    String value = null;
    try
    {
        value = resource.getPersistentProperty(new QualifiedName(Activator.PLUGIN_ID, name));
        if (value == null) 
        {
            value = "";
        }
    } catch (CoreException e)
    {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return value;
}
 

public static String getAbsolutePathOfLinkedResource(IResource resource) {
  	try {
  		QualifiedName qn = ResourceUtils.createPersistentPropertyQualifiedName(IResourceAttributes.LINKED_RESOURCE_ORIGINAL_PATH_ATTR_NAME, resource.getFullPath().toOSString());
	IProject project = resource.getProject();
	if (project != null && project.isOpen()) {
		String path = project.getPersistentProperty(qn);
		if (path != null) {
			return getAbsolutePathAsInFS(path);
		}
	}
} catch (CoreException e) {
	LogHelper.logError(e);
}
  	
  	return null;
  }
 

/**
 * Set the show cheatsheet preference in workspace root. Used by wizards
 */
public static void writeCheatSheetPreference( boolean value )
{
	IWorkspace workspace = ResourcesPlugin.getWorkspace( );
	try
	{
		workspace.getRoot( )
				.setPersistentProperty( new QualifiedName( "org.eclipse.birt.property", //$NON-NLS-1$
						"showCheatSheet" ), //$NON-NLS-1$
						String.valueOf( value ) );
	}
	catch ( CoreException e )
	{
		logger.log( Level.SEVERE, e.getMessage( ), e );
	}
}
 

private void createCopyAndVerifyResource(String name, boolean isFile, boolean isAbsolute) throws CoreException {
    IResource resource = createAndVerifyResource(name, true);
    IPath newPath;
    if (isAbsolute) {
        newPath = resource.getParent().getFullPath().addTrailingSeparator().append(name + COPY_SUFFIX);
    } else {
        newPath = new Path ("..").append(resource.getParent().getName()).append(name + COPY_SUFFIX);
    }
    resource.setPersistentProperty(new QualifiedName(Activator.PLUGIN_ID, PROPERTY_KEY), PROPERTY_VALUE);
    IResource copyResource = ResourceUtil.copyResource(resource, newPath, IResource.FORCE, new NullProgressMonitor());
    assertNotNull(copyResource);
    Map<QualifiedName, String> persistentProperties = copyResource.getPersistentProperties();
    assertEquals(1, persistentProperties.size());
    for (Map.Entry<QualifiedName, String> entry: persistentProperties.entrySet()) {
        assertEquals(PROPERTY_KEY, entry.getKey().getLocalName());
        assertEquals(Activator.PLUGIN_ID, entry.getKey().getQualifier());
        assertEquals(PROPERTY_VALUE, entry.getValue());
    }
    resource.delete(true, null);
    copyResource.delete(true, null);
}
 

/**
 * @return the cheat sheet property preference, stored in the workbench root
 */
public static boolean readCheatSheetPreference( )
{
	IWorkspace workspace = ResourcesPlugin.getWorkspace( );
	try
	{
		String property = workspace.getRoot( )
				.getPersistentProperty( new QualifiedName( "org.eclipse.birt.property", //$NON-NLS-1$
						"showCheatSheet" ) ); //$NON-NLS-1$
		if ( property != null )
			return Boolean.valueOf( property ).booleanValue( );
	}
	catch ( CoreException e )
	{
		logger.log( Level.SEVERE, e.getMessage( ), e );
	}
	return true;
}
 

private boolean enableClangFormatOnSave(IResource resource) {
	boolean enable = CppStyle.getDefault().getPreferenceStore()
			.getBoolean(CppStyleConstants.ENABLE_CLANGFORMAT_ON_SAVE);

	try {
		IProject project = resource.getProject();
		String enableProjectSpecific = project
				.getPersistentProperty(new QualifiedName("", CppStyleConstants.PROJECTS_PECIFIC_PROPERTY));

		if (enableProjectSpecific != null && Boolean.parseBoolean(enableProjectSpecific)) {
			String value = project
					.getPersistentProperty(new QualifiedName("", CppStyleConstants.ENABLE_CLANGFORMAT_PROPERTY));
			if (value != null) {
				return Boolean.parseBoolean(value);
			}

			return false;
		}
	} catch (CoreException e) {
		CppStyle.log(e);
	}

	return enable;
}
 

@Before
public void setUp() throws Exception {
	this.id = SARLRuntime.createUniqueIdentifier();
	this.project = mock(IProject.class);
	when(this.project.getPersistentProperty(ArgumentMatchers.any(QualifiedName.class))).thenAnswer(new Answer() {
	@Override
		public Object answer(InvocationOnMock invocation) throws Throwable {
			QualifiedName qn = (QualifiedName) invocation.getArguments()[0];
			String sqn = qn.toString();
			switch (sqn) {
			case "io.sarl.eclipse.launch.SRE:HAS_PROJECT_SPECIFIC":
				return Boolean.TRUE.toString();
			case "io.sarl.eclipse.launch.SRE:USE_SYSTEM_WIDE_SRE":
				return Boolean.FALSE.toString();
			case "io.sarl.eclipse.launch.SRE:SRE_INSTALL_ID":
				return StandardProjectSREProviderTest.this.id;
			}
			return null;
		}
	});
	this.provider = new StandardProjectSREProvider(this.project);
}
 

private void restoreOldSettings() {
	if (isPropertyPage()) {
		QualifiedName oldKey = new QualifiedName(preferencesId(), useProjectSettingsPreferenceName());
		try {
			String oldValue = project.getPersistentProperty(oldKey);
			if (oldValue != null) {
				// remove old entry
				project.setPersistentProperty(oldKey, null);
				// if were true - save copy into project settings
				if (Boolean.valueOf(oldValue)) {
					saveUseProjectSettings(true);
				}
			}
		} catch (Exception e) {
		}
	}

}
 

private void restoreOldSettings() {
	if (isPropertyPage()) {
		QualifiedName oldKey = new QualifiedName(qualifiedName(), USE_PROJECT_SETTINGS);
		try {
			String oldValue = currentProject().getPersistentProperty(oldKey);
			if (oldValue != null) {
				//remove old entry
				currentProject().setPersistentProperty(oldKey, null);
				//if were true - save copy into project settings
				if (Boolean.valueOf(oldValue)) {
					saveUseProjectSettings(true);
				}
			}
		} catch (Exception e) {
			log.debug("Failed to read persistent property", e);
		}
	}

}
 

public static String formatProblem(IMarker problem) {
  StringBuilder sb = new StringBuilder();
  sb.append(problem.getResource().getFullPath());
  sb.append(':');
  sb.append(problem.getAttribute(IMarker.LINE_NUMBER, -1));
  sb.append(": ");
  sb.append(problem.getAttribute(IMarker.MESSAGE, ""));

  // Derived from
  // org.eclipse.wst.xml.ui.internal.validation.core.errorinfo.ReferencedFileErrorsHandler
  // ValidationMessage.ERROR_MESSAGE_MAP_QUALIFIED_NAME
  QualifiedName errorMessageMapName =
      new QualifiedName("org.eclipse.wst.xml.validation", "errorMessageMap");
  // map is list of file-URI -> ValidationMessage objects
  try {
    Map<?, ?> map = (Map<?, ?>) problem.getResource().getSessionProperty(errorMessageMapName);
    if (map != null) {
      for (Entry<?, ?> entry : map.entrySet()) {
        // show == false as the top message object is in the marker message
        appendValidationMessage(sb, entry.getValue(), 0, /* show */ false);
      }
    }
  } catch (CoreException ex) {
    /* ignore: not a validation problem */
  }
  return sb.toString();
}
 

/**
 * Read a session property.
 * 
 * @param project the current project
 * @param property the name of the property
 * @return the value of session property or null if the property is not found
 */
public static Object getSessionProperty(IResource project, String property) {
    Object value = null;
    try {
        value = project.getSessionProperty(new QualifiedName(TexlipseProperties.PACKAGE_NAME, property));
    } catch (CoreException e) {
        // do nothing
    }
    return value;
}
 

@Override
public String getPersistentProperty(QualifiedName key) throws CoreException {
    if (key.getLocalName().equals("PYTHON_PROJECT_VERSION")) {
        // TODO the comment below says "always the latests", but it isn't!
        return IPythonNature.PYTHON_VERSION_2_5;//for tests, always the latest version
    }
    //this is just for backward-compatibility
    if (key.getLocalName().equals("PROJECT_SOURCE_PATH")) {
        return "/test";
    }
    if (key.getLocalName().equals("PROJECT_EXTERNAL_SOURCE_PATH")) {
        return "";
    }
    throw new RuntimeException(key.getLocalName());
}
 

/**
 * Read a project property.
 * 
 * @param project the current project
 * @param property the name of the property
 * @return the value of the named project property or null if the property is not found
 */
public static String getProjectProperty(IResource project, String property) {
    String value = null;
    try {
        value = project.getPersistentProperty(new QualifiedName(TexlipseProperties.PACKAGE_NAME, property));
    } catch (CoreException e) {
        // do nothing
    }
    return value;
}
 

@Override
public void setPersistentProperty(QualifiedName key, String value) throws CoreException {
    if (value == null) {
        return;
    }
    throw new RuntimeException("not expected");
}
 

public void save(IProject project) throws CoreException {
		
		project.setPersistentProperty(new QualifiedName (
			CommonNames.UI_PATH, DSPORT), Integer.toString(port));
		project.setPersistentProperty(new QualifiedName (
			CommonNames.UI_PATH, DSHOST), host);
		project.setPersistentProperty(new QualifiedName (
			CommonNames.UI_PATH, DS_SYS_HOME), systemHome);
//		project.setPersistentProperty(new QualifiedName (
//				CommonNames.UI_PATH, DS_RUNNING_PORT), Integer.toString(runningPort));
	}
 

/**
 * Gets the import by default.
 *
 * @param project the project
 * @return the import by default
 */
public static String getImportByDefault(IProject project) {
  String byDefault;
  try {
    byDefault = project.getPersistentProperty(new QualifiedName("", BY_DEFAULT_PROPERTY_KEY));
  } catch (CoreException e) {
    byDefault = "";
  }
  if (null == byDefault)
    byDefault = "";
  return byDefault;
}
 

public void load(IProject project) throws CoreException {
		
		String property = project.getPersistentProperty(new QualifiedName (
				CommonNames.UI_PATH, DSPORT));
		port = (property != null && property.length() > 0) ? Integer.parseInt(property) : port;
		property = project.getPersistentProperty(new QualifiedName (
				CommonNames.UI_PATH, DSHOST));
		host = (property != null && property.length() > 0) ? property : host;
		property = project.getPersistentProperty(new QualifiedName (
				CommonNames.UI_PATH, DS_SYS_HOME));
		systemHome = (property != null && property.length() > 0) ? property : systemHome;
//		property = project.getPersistentProperty(new QualifiedName (
//				CommonNames.UI_PATH, DS_RUNNING_PORT));
//		runningPort = (property != null && property.length() > 0) ? Integer.parseInt(property) : runningPort;
	}
 

public void setRunning(IProject proj, Boolean value) throws CoreException {
	try{
		if (value != null && value.equals(Boolean.FALSE)){
			value = null;
		}
		if(proj.isOpen()){
			proj.setSessionProperty(new QualifiedName(CommonNames.UI_PATH,CommonNames.ISRUNNING ),value);
		}
	}catch(Exception e){
		Logger.log("DerbyServerUtils.setRunning() error: "+e, IStatus.ERROR);	
		
	}
	DerbyIsRunningDecorator.performUpdateDecor(proj);
}
 

@Override
public synchronized String getPropertyFromXml(QualifiedName key) {
    if (this.project == null) {
        return "";
    }

    traceFunc("getPropertyFromXml - ", key);
    synchronized (this) {
        checkLoad("getPropertyFromXml");
        try {
            Object object = cache.get(key);
            if (object == NULL_VALUE_IN_CACHE) {
                return null;
            }
            if (object instanceof String) {
                return (String) object;
            }

            Node propertyNode = findPropertyNodeInXml("pydev_property", key);

            if (propertyNode != null) {
                String ret = getTextContent(propertyNode);
                traceFunc("END getPropertyFromXml -- ", ret);
                cache.put(key, ret == null ? NULL_VALUE_IN_CACHE : ret);
                return ret;
            } else {
                cache.put(key, NULL_VALUE_IN_CACHE);
            }

            traceFunc("END getPropertyFromXml (null)");
            return null;
        } catch (Exception e) {
            traceFunc("END getPropertyFromXml (EXCEPTION)");
            throw new RuntimeException("Error on document:" + document + " project:" + project, e);
        }
    }
}
 

/**
 * Finds a property node as a direct child of the root node with the specified type and key.
 *
 * @param type
 * @param key
 * @return The property node or null if a node with the supplied key and type cannot be found.
 * @throws MisconfigurationException
 * @throws CoreException
 */
private synchronized Node findPropertyNodeInXml(String type, QualifiedName key) throws MisconfigurationException {
    traceFunc("findPropertyNodeInXml");
    Node root = getRootNodeInXml();
    NodeList childNodes = root.getChildNodes();
    if (childNodes != null && childNodes.getLength() > 0) {
        String keyString = getKeyString(key);
        for (int i = 0; i < childNodes.getLength(); i++) {
            Node child = childNodes.item(i);
            if (child.getNodeName().equals(type)) {
                NamedNodeMap attrs = child.getAttributes();
                if (attrs != null && attrs.getLength() > 0) {
                    Node namedItem = attrs.getNamedItem("name");
                    if (namedItem != null) {
                        String name = namedItem.getNodeValue();
                        if (name != null && name.equals(keyString)) {
                            traceFunc("END findPropertyNodeInXml - ", child);
                            return child;
                        }
                    }
                }
            }
        }
    }
    traceFunc("END findPropertyNodeInXml (null)");
    return null;
}
 

/**
 * Sets the add to flow.
 *
 * @param project the project
 * @param byDefault the by default
 */
public static void setAddToFlow(IProject project, String byDefault) {
  try {
    project.setPersistentProperty(new QualifiedName("", ADD_TO_FLOW_PROPERTY_KEY), byDefault);
  } catch (CoreException e) {
    throw new InternalErrorCDE("unhandled exception", e);
  }
}
 

@Override
public boolean performOk() {
  // store the value in the owner text field
  try {
    ((IResource) getElement()).setPersistentProperty(
            new QualifiedName("", DATAPATH_PROPERTY_KEY), dataPathUI.getText());
  } catch (CoreException e) {
    return false;
  }
  return true;
}
 

@Override
public synchronized Map<String, String> getMapProperty(QualifiedName key) throws CoreException {
    if (this.project == null) {
        return null;
    }
    checkLoad("getMapProperty");

    String[] keyAndValues;
    synchronized (this) {
        Object object = cache.get(key);
        if (object == NULL_VALUE_IN_CACHE) {
            keyAndValues = null;

        } else if (object instanceof String[]) {
            keyAndValues = (String[]) object;

        } else {
            keyAndValues = null;
            try {
                Node propertyNode = findPropertyNodeInXml("pydev_variables_property", key);
                if (propertyNode != null) {
                    keyAndValues = getChildValuesWithType(propertyNode, "key", "value");
                }
            } catch (Exception e) {
                traceFunc("END getMapProperty (EXCEPTION)");
                IStatus status = new Status(IStatus.ERROR, "PythonNatureStore", -1, e.toString(), e);
                throw new CoreException(status);
            }
            cache.put(key, keyAndValues == null ? NULL_VALUE_IN_CACHE : keyAndValues);
        }
    }

    Map<String, String> ret = null;
    if (keyAndValues != null) {
        ret = getMapStringFromArray(keyAndValues);
    }
    traceFunc("END getMapProperty - ", key, ret);
    return ret;
}
 

public boolean performOk() {
  
  // have check, so performOk is only done when ts file is a valid file string
  
  // store the value in the owner text field
  try {
    ((IResource) getElement()).setPersistentProperty(
            new QualifiedName("", TYPE_SYSTEM_PROPERTY), typeSystemText.getText());
  } catch (CoreException e) {
    return false;
  }
  return true;
}
 

/**
 * Gets the data path.
 *
 * @param project the project
 * @return the data path
 */
public static String getDataPath(IProject project) {
  String dataPath;
  try {
    dataPath = project.getPersistentProperty(new QualifiedName("", DATAPATH_PROPERTY_KEY));
  } catch (CoreException e) {
    dataPath = "";
  }
  if (null == dataPath)
    dataPath = "";
  return dataPath;
}
 

public void save(IProject project) throws CoreException {
		
		project.setPersistentProperty(new QualifiedName (
			CommonNames.UI_PATH, DSPORT), Integer.toString(port));
		project.setPersistentProperty(new QualifiedName (
			CommonNames.UI_PATH, DSHOST), host);
		project.setPersistentProperty(new QualifiedName (
			CommonNames.UI_PATH, DS_SYS_HOME), systemHome);
//		project.setPersistentProperty(new QualifiedName (
//				CommonNames.UI_PATH, DS_RUNNING_PORT), Integer.toString(runningPort));
	}
 

public String getPropertyValueString(String key) {
	String value;
	try {
		value = ((IResource) getElement())
				.getPersistentProperty(new QualifiedName("", key));
		if (value == null) {
			return "";
		}

	} catch (CoreException e) {
		return "";
	}

	return value;
}
 

public static void setTypeSystemLocation(IProject project, String typeSystemLocation) {
  
  try {
    project.setPersistentProperty(new QualifiedName("", TYPE_SYSTEM_PROPERTY), typeSystemLocation);
  } catch (CoreException e) {
    CasEditorPlugin.log(e);
  }
}
 

public static String getCpplintRoot(IFile file) {
	IProject project = file.getProject();
	String rootSpec;
	try {
		rootSpec = project.getPersistentProperty(new QualifiedName("", CppStyleConstants.CPPLINT_PROJECT_ROOT));

		if (rootSpec == null || rootSpec.isEmpty()) {
			return null;
		}
	} catch (CoreException e) {
		return null;
	}

	String rootVc = getVersionControlRoot(file);

	if (rootVc == null) {
		return null;
	}

	String relative = new File(rootVc).toURI().relativize(new File(rootSpec).toURI()).getPath();

	if (relative.endsWith("" + Path.SEPARATOR)) {
		return relative.substring(0, relative.length() - 1);
	}

	return relative;
}