Java ManagedBuildManager类代码示例

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
/**
 * Creates a problem marker.
 *
 * @param fileName
 *        the file where the problem has occurred
 * @param epm
 * @param lineNo
 *        the line number of the problem
 * @param severity
 *        the severity of the problem, see {@link IMarkerGenerator} for
 *        acceptable severity values
 * @param varName
 *        the name of the variable involved in the error or {@code null} if
 *        unknown
 */
private void createMarker(String fileName, ErrorParserManager epm,
    String lineNo, int severity, String varName) {
  int lineNumber = Integer.parseInt(lineNo);
  // cmake reports the file relative to source entry
  final IProject project = epm.getProject();
  IConfiguration cfg = ManagedBuildManager.getBuildInfo(project, true)
      .getDefaultConfiguration();
  ICConfigurationDescription cfgDes = ManagedBuildManager
      .getDescriptionForConfiguration(cfg);
  ICSourceEntry[] srcEntriesR = cfgDes.getResolvedSourceEntries();

  ICSourceEntry[] srcEntries = cfg.getSourceEntries();
  srcEntries = CDataUtil.resolveEntries(srcEntries, cfgDes);

  IPath srcPath = srcEntries[0].getFullPath(); // project-relative path!
  IPath filePath = srcPath.append(fileName);
  IFile file2 = project.getFile(filePath);
  IFile file = epm.findFileName(filePath.toString());

  this.markerInfo = new ProblemMarkerInfo(file2, lineNumber, null, severity,
      varName);
  markerInfo.setType(CMAKE_PROBLEM_MARKER_ID);
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
/**
 * Appends arguments common to all OS preferences. The first argument in the
 * list will be replaced by the cmake command from the specified preferences,
 * if given.
 *
 * @param args
 *        the list to append cmake-arguments to.
 * @param prefs
 *        the generic OS preferences to convert and append.
 * @throws CoreException
 *         if unable to resolve the value of one or more variables
 */
private void appendAbstractOsPreferences(List<String> args, final AbstractOsPreferences prefs)
    throws CoreException {
  // replace cmake command, if given
  if (!prefs.getUseDefaultCommand()){
    ICdtVariableManager varManager = CCorePlugin.getDefault().getCdtVariableManager();
    String cmd = varManager.resolveValue(prefs.getCommand(), "<undefined variable here, but CDT does not allow"
        + " to pass it unexpanded; thus its name is lost>"
        , null,
        ManagedBuildManager.getDescriptionForConfiguration(config));
    args.set(0, cmd);
  }
  args.add("-G");
  final CmakeGenerator generator = prefs.getGenerator();
  args.add(generator.getCmakeName());

  appendDefines(args, prefs.getDefines());
  appendUndefines(args, prefs.getUndefines());
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
@Override
public String getMakefileName() {
  // load project properties..
  final ICConfigurationDescription cfgd = ManagedBuildManager.getDescriptionForConfiguration(config);
  CMakePreferences prefs;
  try {
    prefs = ConfigurationManager.getInstance().getOrLoad(cfgd);
  } catch (CoreException ex) {
    // Auto-generated catch block
    ex.printStackTrace();
    return "Makefile"; // default
  }
  AbstractOsPreferences osPrefs = AbstractOsPreferences.extractOsPreferences(prefs);
  // file generated by cmake
  return osPrefs.getGenerator().getMakefileName();
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
public static void setIncludePaths(IProject project, List<String> includePaths) {
	configureIndexerToIncludeAllReferencedHeaders(project);
	
	ICProjectDescription projectDescription = CoreModel.getDefault().getProjectDescription(project);
	ICLanguageSettingEntry[] entries = IncludePathString2ICLanguageSettingEntryArray(includePaths);
	
	// Set include paths for all configurations in the CDT project
	for(ICConfigurationDescription confDesc : projectDescription.getConfigurations()) {
		IConfiguration configuration = ManagedBuildManager.getConfigurationForDescription(confDesc);
		CConfigurationData Cconfigdata = configuration.getConfigurationData();
        CFolderData rootFolderData = Cconfigdata.getRootFolderData();
        CLanguageData[] languageDatas = rootFolderData.getLanguageDatas();
        
        for(CLanguageData languageData : languageDatas) {
        	languageData.setEntries(ICLanguageSettingEntry.INCLUDE_PATH, entries);
        }
	}
	
	try {
		CoreModel.getDefault().setProjectDescription(project, projectDescription);
	} catch (CoreException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
private static void ConfigureProjectNature(IProject project) throws CoreException {
	// Set up build information
	ICProjectDescriptionManager pdMgr = CoreModel.getDefault().getProjectDescriptionManager();
	ICProjectDescription cProjDesc = pdMgr.createProjectDescription(project, false);
	ManagedBuildInfo info = ManagedBuildManager.createBuildInfo(project);
	ManagedProject mProj = new ManagedProject(cProjDesc);
	info.setManagedProject(mProj);

	CfgHolder cfgHolder = new CfgHolder(null, null);
	String s = "0";
	Configuration config = new Configuration(mProj, (ToolChain)null, ManagedBuildManager.calculateChildId(s, null), cfgHolder.getName());
	IBuilder builder = config.getEditableBuilder();
	builder.setManagedBuildOn(false);
	CConfigurationData data = config.getConfigurationData();
	cProjDesc.createConfiguration(ManagedBuildManager.CFG_DATA_PROVIDER_ID, data);

	pdMgr.setProjectDescription(project, cProjDesc);
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
protected void buildAllConfigurations(final IProject project) {
	final ICProjectDescription prjd = CoreModel.getDefault().getProjectDescription(project, false);
	if (prjd != null) {
		final ICConfigurationDescription[] cfgDescriptions = prjd.getConfigurations();
		if (cfgDescriptions != null && cfgDescriptions.length > 0) {
			final IConfiguration[] cfgs = new IConfiguration[cfgDescriptions.length];
			for (int i=0; i < cfgDescriptions.length; ++i) {
				cfgs[i] = ManagedBuildManager.getConfigurationForDescription(cfgDescriptions[i]);
			}
			final Job job = new Job("Building all configurations") {

				@Override
				protected IStatus run(IProgressMonitor monitor) {
					try {
						ManagedBuildManager.buildConfigurations(cfgs, monitor);
					} catch (CoreException e) {
						return e.getStatus();
					}
					return Status.OK_STATUS;
				}
			};
			job.schedule();
			waitForJobs();
		}
	}		
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
private IConfiguration createConfiguration(IConfiguration cfg, IManagedProject proj, ICProjectDescription des) throws WriteAccessException, CoreException {
	String id = ManagedBuildManager.calculateChildId(cfg.getId(), null);
	// CProjectDescriptionManager.getInstance();
	Configuration config = new Configuration((ManagedProject) proj, (Configuration) cfg, id, false, true);
	CConfigurationData data = config.getConfigurationData();
	ICConfigurationDescription cfgDes = des.createConfiguration(ManagedBuildManager.CFG_DATA_PROVIDER_ID, data);
	config.setConfigurationDescription(cfgDes);
	config.exportArtifactInfo();

	// Force internal builder
	IBuilder internalBuilder = ManagedBuildManager.getInternalBuilder();
	config.changeBuilder(internalBuilder, internalBuilder.getId(), internalBuilder.getName());

	// IBuilder bld = config.getEditableBuilder();
	// if (bld != null) { bld.setManagedBuildOn(true); }

	config.setName(cfg.getName());
	config.setArtifactName(proj.getDefaultArtifactName());

	return config;
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
/**
 * @param cprojDesc
 * @return 
 */
private ICConfigurationDescription createBuildConfigurations(ICProjectDescription cprojDesc) throws CoreException {

	ManagedProject managedProject = new ManagedProject(cprojDesc);
	String configId = ManagedBuildManager.calculateChildId(CMAKE_TOOLCHAIN_ID, null);
	IToolChain cmakeToolChain = ManagedBuildManager.getExtensionToolChain(CMAKE_TOOLCHAIN_ID);
	org.eclipse.cdt.managedbuilder.internal.core.Configuration newConfig = new org.eclipse.cdt.managedbuilder.internal.core.Configuration(
			managedProject, (ToolChain) cmakeToolChain, configId, "debug");
	IToolChain newToolChain = newConfig.getToolChain();

	switch (Platform.getOS()) 
	{
		case "win32": {
			newConfig.getEditableBuilder().setCommand("mingw32-make.exe");
			break;
		}
		default: {
			newConfig.getEditableBuilder().setCommand("make");
			break;
		}
	}

	
	CConfigurationData data = newConfig.getConfigurationData();
	return cprojDesc.createConfiguration(ManagedBuildManager.CFG_DATA_PROVIDER_ID, data);
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
/**
 * Gets whether the user changed the generator setting in the preferences.
 *
 * @return {@code true} if the user changed the generator setting in the
 *         preferences, otherwise {@code false}
 */
private boolean isGeneratorChanged() {
  // load project properties..
  final ICConfigurationDescription cfgd = ManagedBuildManager.getDescriptionForConfiguration(config);
  CMakePreferences prefs;
  try {
    prefs = ConfigurationManager.getInstance().getOrLoad(cfgd);
    AbstractOsPreferences osPrefs = AbstractOsPreferences.extractOsPreferences(prefs);
    return osPrefs.getGenerator() != osPrefs.getGeneratedWith();
  } catch (CoreException ex) {
    log.log(new Status(IStatus.ERROR, CdtPlugin.PLUGIN_ID, null, ex));
    return false;
  }
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
/**
 * Appends arguments for the specified cmake defines. Performs substitutions
 * on variables found in a value of each define.
 *
 * @param args
 *        the list to append cmake-arguments to.
 * @param defines
 *        the cmake defines to convert and append.
 * @throws CoreException
 *         if unable to resolve the value of one or more variables
 */
private void appendDefines(List<String> args, final List<CmakeDefine> defines) throws CoreException {
  final ICdtVariableManager mngr = CCorePlugin.getDefault().getCdtVariableManager();
  final ICConfigurationDescription cfgd = ManagedBuildManager.getDescriptionForConfiguration(config);
  for (CmakeDefine def : defines) {
    final StringBuilder sb = new StringBuilder("-D");
    sb.append(def.getName());
    sb.append(':').append(def.getType().getCmakeArg());
    sb.append('=');
    String expanded = mngr.resolveValue(def.getValue(), "", "", cfgd);
    sb.append(expanded);
    args.add(sb.toString());
  }
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
public static String convertArtefactType(final String narArtefactType) {
	if (NarBuildArtifact.EXECUTABLE.equals(narArtefactType)) {
		return ManagedBuildManager.BUILD_ARTEFACT_TYPE_PROPERTY_EXE;
	}
	if (NarBuildArtifact.SHARED.equals(narArtefactType)) {
		return ManagedBuildManager.BUILD_ARTEFACT_TYPE_PROPERTY_SHAREDLIB;
	}
	if (NarBuildArtifact.STATIC.equals(narArtefactType)) {
		return ManagedBuildManager.BUILD_ARTEFACT_TYPE_PROPERTY_STATICLIB;
	}
	return ManagedBuildManager.BUILD_ARTEFACT_TYPE_PROPERTY_SHAREDLIB;
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
/**
 * Checks whether toolchain can be used on this system
 * 
 * @param tc
 * @return
 */
protected boolean isValid(IToolChain tc) {
	/*
	 * // Check for langiuage compatibility first in any case if
	 * (!isLanguageCompatible(tc, w)) return false;
	 */

	// Filter off unsupported and system toolchains
	if (tc == null || !tc.isSupported() || tc.isAbstract() || tc.isSystemObject())
		return false;

	// Check for platform compatibility
	return ManagedBuildManager.isPlatformOk(tc);
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
protected List<IConfiguration> getCfgs(IToolChain tc, String artefactType) {
	List<IConfiguration> out = new ArrayList<IConfiguration>();
	IConfiguration[] cfgs = ManagedBuildManager.getExtensionConfigurations(tc, ManagedBuildManager.BUILD_ARTEFACT_TYPE_PROPERTY_ID, artefactType);
	if (cfgs != null) {
		for (IConfiguration cfg : cfgs) {
			if (isValid(cfg)) {
				out.add(cfg);
			}
		}
	}
	return out;
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
/**
 * Reorders selected configurations in "physical" order. Although toolchains
 * are displayed in alphabetical order in Wizard, it's required to create
 * corresponding configurations in the same order as they are listed in xml
 * file, inside of single project type.
 * 
 * @param its
 *            - items in initial order.
 * @return
 * @return - items in "physical" order.
 */
/*
 * public static List<IConfiguration> reorder(List<IConfiguration> cfgs) {
 * List<IConfiguration> ls = new ArrayList<IConfiguration>(cfgs.size());
 * IConfiguration[] its = cfgs.toArray(new IConfiguration[cfgs.size()]);
 * boolean found = true; while (found) { found = false; for (int i=0;
 * i<its.length; i++) { if (its[i] == null) continue; found = true;
 * IProjectType pt = its[i].getProjectType(); if (pt == null) {
 * ls.add(its[i]); its[i] = null; continue; } IConfiguration[] cfs =
 * pt.getConfigurations(); for (int j=0; j<cfs.length; j++) { for (int k=0;
 * k<its.length; k++) { if (its[k] == null) continue; if
 * (cfs[j].equals(its[k].getTcCfg())) { ls.add(its[k]); its[k] = null; } } }
 * } } return ls.toArray(new CfgHolder[ls.size()]); }
 */

private IToolChain getToolChain(final String toolChain, final String artefactType) throws CoreException {
	// Find the tool chains supported on our system for the selected
	// artefact type
	IToolChain[] tcs = ManagedBuildManager.getExtensionsToolChains(ManagedBuildManager.BUILD_ARTEFACT_TYPE_PROPERTY_ID, artefactType, true);
	// Find the tool chain
	IToolChain tc = null;
	for (IToolChain tc2 : tcs) {
		if (isValid(tc2) && toolChain.equals(tc2.getUniqueRealName())) {
			tc = tc2;
			break;
		}
	}
	if (tc == null) {
		throw new CoreException(new Status(IStatus.ERROR, MavenNarPlugin.PLUGIN_ID, "Could not find valid tool chain \"" + toolChain + "\""));
	}
	return tc;
}
 

import org.eclipse.cdt.managedbuilder.core.ManagedBuildManager; //导入依赖的package包/类
private ITool getCMakeTool() {
	IConfiguration cfg = ManagedBuildManager.getConfigurationForDescription(cfgd);
	ITool[] cmakeTools = cfg.getToolsBySuperClassId(CMakeMakefileGenerator.CMAKE_TOOL_ID);
	ITool cmakeTool = null;
	if(cmakeTools.length > 0) {
		cmakeTool = cmakeTools[0];
	}
	return cmakeTool;
}