Java IProgressMonitor.done方法代码示例

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
@Override
protected void fillContentProvider(final AbstractContentProvider contentProvider, final ItemsFilter itemsFilter,
		final IProgressMonitor monitor) throws CoreException {

	monitor.beginTask("Searching for N4JS types...", UNKNOWN);

	final Iterable<IEObjectDescription> types = filter(indexSupplier.get().getExportedObjects(),
			desc -> searchKind.matches(desc.getEClass()));

	monitor.beginTask("Searching for N4JS types...", size(types));
	types.forEach(desc -> {
		contentProvider.add(desc, itemsFilter);
		monitor.worked(1);
	});

	monitor.done();
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
public void process ( final IProgressMonitor monitor )
{
    try
    {
        new TypeWalker<> ( AlarmsEventsModule.class ).walk ( this.app, new TypeVisitor<AlarmsEventsModule> () {

            @Override
            public void visit ( final AlarmsEventsModule item ) throws Exception
            {
                process ( item );
            }
        } );
    }
    catch ( final Exception e )
    {
        throw new RuntimeException ( e );
    }
    finally
    {
        monitor.done ();
    }
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
/**
 * Implements the interface method by looping through template sections and
 * executing them sequentially.
 * 
 * @param project
 *            the project
 * @param monitor
 *            the progress monitor to track the execution progress as part
 *            of the overall new project creation operation
 * @return <code>true</code> if the wizard completed the operation with
 *         success, <code>false</code> otherwise.
 */
public boolean performFinish(IProject project,  IProgressMonitor monitor) {
	try {
		ITemplateSection[] sections = getTemplateSections();
		monitor.beginTask("", sections.length); //$NON-NLS-1$
		for (int i = 0; i < sections.length; i++) {
			sections[i].execute(project,  new SubProgressMonitor(monitor, 1));
		}
		//No reason to do this any more with the new editors
		//saveTemplateFile(project, null);
	} catch (CoreException e) {
		PDEPlugin.logException(e);
		return false;
	} finally {
		monitor.done();
	}
	return true;
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
public static void processFile ( final IContainer parent, final Definition definition, final Profile profile, final IProgressMonitor monitor ) throws Exception
{
    monitor.beginTask ( makeJobLabel ( definition, profile ), 100 );

    final IFolder output = parent.getFolder ( new Path ( "output" ) ); //$NON-NLS-1$
    if ( output.exists () )
    {
        output.delete ( true, new SubProgressMonitor ( monitor, 9 ) );
    }
    output.create ( true, true, new SubProgressMonitor ( monitor, 1 ) );

    final Builder builder = new Builder ( definition, profile );
    final Recipe recipe = builder.build ();

    try
    {
        final Map<String, Object> initialContent = new HashMap<String, Object> ();
        initialContent.put ( "output", output ); //$NON-NLS-1$

        recipe.execute ( initialContent, new SubProgressMonitor ( monitor, 90 ) );
    }
    finally
    {
        monitor.done ();
    }
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
@Override
protected IStatus run(IProgressMonitor monitor) {
    try {
        Log.log(Log.LOG_INFO, "Update DDL starting"); //$NON-NLS-1$
        SubMonitor.convert(monitor).setTaskName(Messages.SqlEditor_update_ddl);

        scriptThread.start();

        while(scriptThread.isAlive()) {
            Thread.sleep(20);
            if(monitor.isCanceled()) {
                ConsoleFactory.write(Messages.sqlScriptDialog_script_execution_interrupted);
                Log.log(Log.LOG_INFO, "Script execution interrupted by user"); //$NON-NLS-1$

                scriptThread.interrupt();
                return Status.CANCEL_STATUS;
            }
        }
        return Status.OK_STATUS;
    } catch (InterruptedException ex) {
        scriptThread.interrupt();
        return Status.CANCEL_STATUS;
    } finally {
        monitor.done();
    }
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
public void performTasks(IProgressMonitor monitor) throws IOException, InterruptedException {
	File rootDir = configAdoc.getDocRootDir();
	FileSystem.ensureFileStructure(rootDir);
	int workload = 1;

	SubMonitor subMonitor = SubMonitor.convert(monitor, workload);

	if (configOutput.writeAdocFiles) {
		writeAdocFiles(subMonitor);
	}

	subMonitor.subTask("Finished.");
	subMonitor.done();
	monitor.done();
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
@Override
public void run(IProgressMonitor monitor, CancellationToken token) {
	monitor.beginTask("Init Gluon project", IProgressMonitor.UNKNOWN);
	try {
		File projectDir = new File(projectData.projectLocation);
		if (!projectDir.exists()) {
			if (projectDir.mkdir()) {
				operation.perform(monitor, projectDir);
			}
		}
	} finally {
		monitor.done();
	}
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
private void createProjectContents(IProgressMonitor mon, File projectDir) {
	mon.beginTask("Create project contents", 1);
	try {
		Map<String, Object> parameters = projectData.asParameters();
		parameters.put(ProjectConstants.PARAM_PROJECT_NAME, projectData.projectName);
		
		parameters.put(ProjectConstants.PARAM_GLUON_DESKTOP_VERSION, ProjectConstants.getDesktopVersion());
		parameters.put(ProjectConstants.PARAM_GLUON_MOBILE_VERSION, ProjectConstants.getMobileVersion());
		parameters.put(ProjectConstants.PARAM_GLUON_MOBILE_GVM_VERSION, ProjectConstants.getMobileGvmVersion());
		parameters.put(ProjectConstants.PARAM_GLUON_DOWN_VERSION, ProjectConstants.getDownVersion());
		parameters.put(ProjectConstants.PARAM_GLUON_MOBILE_PLUGIN, ProjectConstants.getPluginVersion());
		parameters.put(ProjectConstants.PARAM_GLUON_MOBILE_GVM_PLUGIN, ProjectConstants.getPluginGvmVersion());
		parameters.put(ProjectConstants.PARAM_GLUON_GLISTEN_AFTERBURNER_VERSION, ProjectConstants.getGlistenAfterburnerVersion());

		List<File> filesToOpen = new ArrayList<>();
		if (projectTemplate != null) {
			projectTemplate.render(projectDir, parameters);
			filesToOpen.addAll(projectTemplate.getFilesToOpen());

			if (sourceTemplate != null) {
				sourceTemplate.render(projectDir, parameters);
				filesToOpen.addAll(sourceTemplate.getFilesToOpen());
			}
		}
		
		// TODO: open files
	} finally {
		mon.done();
	}
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
/** deal with not justified and large string
 * this is because large string may block Eclipse UI
 */
protected void safePrint(String message, final Color c, final int style, IProgressMonitor monitor){
	try {
		String justifiedMsg = justifyMessage(message);
		if(justifiedMsg.length() > LARGE_MESSAGE_SIZE){
			// deal with large messages ... chunk the message
			int nbChunk = justifiedMsg.length()/LARGE_MESSAGE_SIZE;
			monitor.beginTask("writing large string to the console", nbChunk+1);
			int start, end= 0;
			for(int i = 0; i< nbChunk; i++){
				start = LARGE_MESSAGE_SIZE*i;
				end = LARGE_MESSAGE_SIZE*i + LARGE_MESSAGE_SIZE;
				changeStream();
				safeChangeStyle(c, style);
				((IOConsoleOutputStream)getOutputStream()).write(justifiedMsg.substring(start, end));
				monitor.worked(1);
			}
			changeStream();
			safeChangeStyle(c, style);
			((IOConsoleOutputStream)getOutputStream()).write(justifiedMsg.substring(end, justifiedMsg.length()));
			monitor.done();
		}
		else{
			safeChangeStyle(c, style);
			((IOConsoleOutputStream)getOutputStream()).write(justifiedMsg);
		}
	} catch (IOException e) {
		e.printStackTrace();
	}
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
@Override
  public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
      int totalUnitsOfWork = IProgressMonitor.UNKNOWN;
      monitor.beginTask("Performing read. Please wait...", totalUnitsOfWork);
      // This only performs the tasks
try {
	client.setCredentials(Constants.USERNAME, Constants.PASSWORD);
	System.out.println(getClient().getUser());
	issues = loadRequirements();
} catch (IOException e) {
	e.printStackTrace();
}
      monitor.done();
  }
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
@Override
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
  int totalUnitsOfWork = IProgressMonitor.UNKNOWN;
  monitor.beginTask("Performing read. Please wait...", totalUnitsOfWork);
  // This only performs the tasks
  try {
    client.setCredentials(Constants.USERNAME, Constants.PASSWORD);
    System.out.println(getClient().getUser());
    issues = loadRequirements();
  } catch (IOException e) {
    e.printStackTrace();
  }
  monitor.done();
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
protected IRunnableWithProgress createResourceOperation(IFolder folder,InitialBuildPolicies policies) {
	WorkspaceModifyOperation operation = new WorkspaceModifyOperation() {
		@Override
		protected void execute(IProgressMonitor monitor) {
			String resource = "";
			String targetFile = "";
			try {
				for (int i = 0; i < resources.length; i++) {
					resource = resources[i];
					targetFile =  targetFiles[i];
					IFile file =  create(folder, resource, targetFile, monitor);
					if (file != null) {
						createdResources.add(file);
						policies.setFile(file);
						policies.run();
						BasicNewResourceWizard.selectAndReveal(file,
								PlatformUI.getWorkbench().getActiveWorkbenchWindow());
					}
				}			
			} catch (Exception exception) {
				ResourceManager.logException(exception, "Unable to create " + resource);
			} finally {
				monitor.done();
			}
		}
	};
	return operation;
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
@Override
public void postContent(@NonNull TaskRepository repository, @NonNull ITask task,
		@NonNull AbstractTaskAttachmentSource source, @Nullable String comment,
		@Nullable TaskAttribute attachmentAttribute, @Nullable IProgressMonitor monitor) throws CoreException {

	monitor.beginTask("Uploading attachment", 1);

	CharmClient client = connector.getClient(repository);

	try {
		byte attachment[] = readData(source, monitor);

		String filename = source.getName();
		String description = source.getDescription();

		if (CONTEXT_DESCRIPTION.equals(source.getDescription()))
			filename = CONTEXT_DESCRIPTION + "-" + dateFormat.format(new Date()) + ".zip";

		else if (attachmentAttribute != null) {
			TaskAttachmentMapper mapper = TaskAttachmentMapper.createFrom(attachmentAttribute);
			if (mapper.getFileName() != null)
				filename = mapper.getFileName();
			if (mapper.getDescription() != null)
				description = mapper.getDescription();
		}

		client.putAttachmentData(task, filename, source.getContentType(), description, attachment, monitor);
		Policy.advance(monitor, 1);

	} catch (IOException | CharmHttpException e) {
		throw new CoreException(new Status(IStatus.ERROR, CharmCorePlugin.PLUGIN_ID,
				NLS.bind("Uploading attachment failed: {0}", e.getMessage(), e)));
	} finally {
		monitor.done();
	}

}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
@Override
protected void fillContentProvider(AbstractContentProvider contentProvider, ItemsFilter itemsFilter, IProgressMonitor progressMonitor) throws CoreException {
	      progressMonitor.beginTask("Searching", paths.size());
	      for (Iterator<VFUnit> iter = paths.iterator(); iter.hasNext();) {
	         contentProvider.add(((VFUnit)iter.next()), itemsFilter);
	         progressMonitor.worked(1);
	      }
	      progressMonitor.done();
}
 

import org.eclipse.core.runtime.IProgressMonitor; //导入方法依赖的package包/类
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
    // DebugLog.println("Running task");
    monitor.beginTask("Running task ", IProgressMonitor.UNKNOWN);
    if (simpleThread != null) {
        simpleThread.start();
        simpleThread.join();
    }
    // DebugLog.println("Task complete.");
    monitor.done();
    if (monitor.isCanceled())
        throw new InterruptedException("The operation was cancelled");
}