Java RunnableWithResult类代码示例

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
public static void writeExternal(final ObjectOutput out, final EPlanElement eObject) throws IOException {
	IOException result = TransactionUtils.reading(eObject, new RunnableWithResult.Impl<IOException>() {
		@Override
		public void run() {
			try {
				out.writeObject(eObject);
			} catch (IOException e) {
				Logger.getLogger(WrapperUtils.class).error("writeExternal", e);
				setResult(e);
			}
		}
	});
	if (result != null) {
		throw result;
	}
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
@Override
protected List<? extends Violation> initialize() {
	return TransactionUtils.reading(plan, new RunnableWithResult.Impl<List<? extends Violation>>() {
		@Override
		public void run() {
			if (isQuit()) {
				return;
			}
			final List<EPlanElement> affectedElements = new ArrayList<EPlanElement>();
			new PlanVisitor() {
				@Override
				protected void visit(EPlanElement element) {
				    affectedElements.add(element);
				}
			}.visitAll(plan);
			List<Violation> violations = findViolations(affectedElements);
			setResult(violations);
		}
	});
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
public static <T extends Throwable> void writing(final Object object, final Class<T> throwableClass, final RunnableWithThrowable runnable) throws T {
	final Option<T> exception = TransactionUtils.writing(object, new RunnableWithResult.Impl<Option<T>>() {
		@Override
		public void run() {
			try {
				runnable.run();
				setResult(Option.<T> none());
			} catch (Throwable throwable) {
				if (throwableClass.isAssignableFrom(throwable.getClass())) {
					setResult(some((T) throwable));
					return;
				}
				if (throwable instanceof RuntimeException)
					throw (RuntimeException) throwable;
				if (throwable instanceof Error)
					throw (Error) throwable;
				throw new RuntimeException(throwable);
			}
		}
	});
	if (exception.isSome())
		throw exception.some();
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
public static String getString(EPlanElement element) {
	if (element instanceof EPlanChild) {
		final EPlanChild child = (EPlanChild) element;
		if (child.getParent() == null) {
			return TransactionUtils.writing(DUMMY_PLAN, new RunnableWithResult.Impl<String>() {
				public void run() {
					EList<EPlanChild> children = DUMMY_PLAN.getChildren();
					children.add(child);
					setResult(EMFUtils.convertToXML(child, OPTIONS));
					children.remove(child);
				}
			});
		}
	}
	return EMFUtils.convertToXML(element, OPTIONS);
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
private void unloadModelResource(final IFile file){

		logger.info("Alternative '"+ getName() +"' is unloading model resource: " + file.getFullPath().toString());

		try {
			TransactionUtil.runExclusive(editingDomain, new RunnableWithResult.Impl<Resource>(){

				@Override
				public void run() {
					Resource resource = getModelResource(file);
					if(resource != null){
						resource.unload();
						resSet.getResources().remove(resource);
					}
				}
			});
		} 
		catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
/**
 * Loads the EMF resource under specified file into the editing domain.
 * 
 * @param file
 * @return EMF Resource
 */
public Resource loadExternalModel(final IFile file){
	
	Resource resource = null;
	
	try {
		resource = TransactionUtil.runExclusive(editingDomain, new RunnableWithResult.Impl<Resource>(){
			
			@Override
			public void run() {
				
				Resource res = getModelResource(file);
				if(res == null){
					res = loadModelResource(file);
				}
				setResult(res);
				
			}
		});
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	
	return resource;
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
/**
 * @generated
 */
public ICellEditorValidator getEditTextValidator() {
	return new ICellEditorValidator() {

		public String isValid(final Object value) {
			if (value instanceof String) {
				final EObject element = getParserElement();
				final IParser parser = getParser();
				try {
					IParserEditStatus valid = (IParserEditStatus) getEditingDomain()
							.runExclusive(
									new RunnableWithResult.Impl<IParserEditStatus>() {

										public void run() {
											setResult(parser
													.isValidEditString(
															new EObjectAdapter(
																	element),
															(String) value));
										}
									});
					return valid.getCode() == ParserEditStatus.EDITABLE ? null
							: valid.getMessage();
				} catch (InterruptedException ie) {
					ie.printStackTrace();
				}
			}

			// shouldn't get here
			return null;
		}
	};
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
public void testLocalVariable() throws Exception {
	load(URI.createURI("platform:/plugin/gov.nasa.ensemble.core.plan.resources/datafiles/test/TestLocalVariable.dictionary"));
	
	EActivityDef activityDef = getActivityDef("LocalVariableTest");
	
	final EActivity activity = PLAN_FACTORY.createActivity(activityDef);
	plan = createPlan(activity);
	
	assertEquals(Integer.valueOf(0), ADParameterUtils.getParameterObject(activity, "baseParameter"));
	
	ResourceUpdater.recompute(plan);
	
	assertEquals(Integer.valueOf(10), ADParameterUtils.getParameterObject(activity, "variableParameter"));

	Exception exception = TransactionUtils.writing(activity, new RunnableWithResult.Impl<Exception>() {
		@Override
		public void run() {
			try {
                ADParameterUtils.setParameterObject(activity, "baseParameter", 10);
               } catch (UndefinedParameterException e) {
               	setResult(e);
               }
		}
	});
	if (exception != null) {
		throw exception;
	}
	
	ResourceUpdater.recompute(plan);
	
	assertEquals(Integer.valueOf(20), ADParameterUtils.getParameterObject(activity, "variableParameter"));
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
public static EPlan createPlan() {
	// clear the activity dictionary of previous definitions
	final ActivityDictionary adict = ActivityDictionary.getInstance();
	adict.clearCache();
	
	// create some activity definitions
	EActivityDef actDef1 = createActivityDef(0, "actDef1", "group 1");
	EActivityDef actDef2 = createActivityDef(1, "actDef2", "group 2");
	EActivityDef actDef3 = createActivityDef(3, "actDef3", "group 1");
	
	adict.addDefinition(actDef1);
	adict.addDefinition(actDef2);
	adict.addDefinition(actDef3);
	
	// hack to re-initialize any members that may have cached a previous version of the AD
	adict.fireActivityDictionaryLoadedEvent();
	
	final EPlan plan = PlanFactory.getInstance().createPlan(TestPlanUtils.TEST_PLAN_NAME);
	Exception exception = TransactionUtils.writing(plan, new RunnableWithResult.Impl<Exception>() {
		@Override
		public void run() {
			try {
                constructPlan(adict, plan);
               } catch (Exception e) {
                setResult(e);
               }
		}
	});
	if (exception != null) {
		throw new RuntimeException("exception in constructPlan: ", exception);
	}

	trace.debug("createPlan: After multiArgActivity");
	return plan;
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
/**
 * Creates an {@link EActivityGroup} within the given parent.
 */
public EActivityGroup createActivityGroup(final EPlanParent parent) {
	String nameOfPlan = "Unnamed";
	if (parent != null) {
		nameOfPlan = TransactionUtils.reading(parent, new RunnableWithResult.Impl<String>() {
			@Override
			public void run() {
				setResult(createName(parent, EPlanUtils.getActivityGroupDisplayName()));
			}
		});
	}
	final String name = nameOfPlan; 
	final EActivityGroup group = createActivityGroupInstance();
	TransactionUtils.writeIfNecessary(group, new Runnable() {
		@Override
		public void run() {
			group.setData(ADParameterMemberFactory.FACTORY.createData(PlanPackage.Literals.EACTIVITY_GROUP));
			group.setName(name);
			TemporalMember temporalMember = group.getMember(TemporalMember.class);
			temporalMember.setUseChildTimes(true);
			CommonMember commonMember = group.getMember(CommonMember.class);
			commonMember.setNotes("");
			RGB randomColor = ColorUtils.getRandomColor();
			commonMember.setColor(ColorUtils.getAsERGB(randomColor));
		}
	});
	return group;
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
@Override
protected List<? extends Violation> check(final List<Notification> notifications) {
	return TransactionUtils.reading(plan, new RunnableWithResult.Impl<List<? extends Violation>>() {
		@Override
		public void run() {
			Set<EPlanElement> affectedElements = getAffectedElements(notifications);
			List<Violation> violations = findViolations(affectedElements);
			setResult(violations);
		}
	});
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
private Runnable displayRunnable(final Control control, final Runnable runnable) {
	return new Runnable() {
		@Override
		public void run() {
			if (control.isDisposed()) {
				return;
			}
			Display display = control.getDisplay();
			if (display.isDisposed()) {
				return;
			}
			final RunnableWithResult<?> privilegedRunnable = domain.createPrivilegedRunnable(runnable);
			display.syncExec(new Runnable() {
				@Override
				public void run() {
					if (!control.isDisposed()) {
						privilegedRunnable.run();
					}
				}
			});
		}
		@Override
		public String toString() {
			return runnable.toString();
		}
	};
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
public static void reading(Object object, final Runnable runnable) {
	reading(object, new RunnableWithResult.Impl<Object>() {
		@Override
		public void run() {
			runnable.run();
		}

		@Override
		public String toString() {
			return runnable.toString();
		}
	});
}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
public static <T> T checkedWriting(Object object, final RunnableWithResult<T> runnable, Map<Object, Object> options) throws InterruptedException, RollbackException {

		final EditingDomain domain = EMFUtils.getAnyDomain(object);
		if (domain instanceof TransactionalEditingDomain) {
			TransactionalEditingDomain transactionDomain = (TransactionalEditingDomain) domain;
			checkForDeadlock(transactionDomain);
			InternalTransaction transaction = ((TransactionalEditingDomainImpl) transactionDomain).getActiveTransaction();
			if ((transaction != null) && (transaction.getOwner() == Thread.currentThread()) && !transaction.isReadOnly()) {
				// nested writing
				runnable.run();
				return runnable.getResult();
			}
			TransactionalCommandStack stack = (TransactionalCommandStack) domain.getCommandStack();
			if (stack != null) {
				Map writingOptions = getWritingOptions(domain);
				Map newOptions = new HashMap();
				if (options != null) {
					newOptions.putAll(options);
				}
				if (writingOptions != null) {
					newOptions.putAll(writingOptions);
				}
				writingOptions = newOptions;
				stack.execute(new RunnableRecordingCommand("writing", runnable), writingOptions);
			} else {
				runnable.run();
			}
		} else {
			runnable.run();
		}
		return runnable.getResult();
	}
 

import org.eclipse.emf.transaction.RunnableWithResult; //导入依赖的package包/类
public static Collection<EObject> getReachableObjectsOfType(final EObject object, final EClassifier type) {
	if (object == null) {
		return Collections.emptyList();
	}
	Resource resource = object.eResource();
	if (resource != null) {
		ResourceSet resourceSet = resource.getResourceSet();
		if (resourceSet != null) {
			Map<EClassifier, Collection<EObject>> cache = TYPES_BY_RESOURCE_SET_CACHE.get(resourceSet);
			if (cache == null) {
				cache = new HashMap<EClassifier, Collection<EObject>>();
				TYPES_BY_RESOURCE_SET_CACHE.put(resourceSet, cache);
			}
			Collection<EObject> collection = cache.get(type);
			if (collection == null) {
				TransactionalEditingDomain domain = TransactionUtils.getDomain(resourceSet);
				if (domain != null) {
					collection = TransactionUtils.reading(domain, new RunnableWithResult.Impl<Collection<EObject>>() {
						@Override
						public void run() {
							try {
								setResult(ItemPropertyDescriptor.getReachableObjectsOfType(object, type));
								setStatus(Status.OK_STATUS);
							} catch (Exception e) {
								setStatus(new ExceptionStatus(Activator.PLUGIN_ID, "failed in reading", e));
							}
						}
					});
				} else {
					collection = ItemPropertyDescriptor.getReachableObjectsOfType(object, type);
				}
				cache.put(type, collection);
			}
			return collection;
		}
	}
	return ItemPropertyDescriptor.getReachableObjectsOfType(object, type);
}