源码类别
热门源码
 当前位置：源码 > Java源码 >

Java源码示例：org.eclipse.emf.ecore.EcoreFactory

示例1
protected Result<Boolean> applyRuleEClassEClass(final RuleEnvironment G, final RuleApplicationTrace _trace_, final EClass eClass1, final EClass eClass2) throws RuleFailedException {
  String _string = new String();
  String _firstUpper = StringExtensions.toFirstUpper("bar");
  String _plus = (_string + _firstUpper);
  boolean _equals = Objects.equal("foo", _plus);
  /* 'foo' == new String() + 'bar'.toFirstUpper */
  if (!_equals) {
    sneakyThrowRuleFailedException("\'foo\' == new String() + \'bar\'.toFirstUpper");
  }
  final EClass eC = EcoreFactory.eINSTANCE.createEClass();
  eC.setName("MyEClass");
  /* eClass1 == eC */
  if (!Objects.equal(eClass1, eC)) {
    sneakyThrowRuleFailedException("eClass1 == eC");
  }
  return new Result<Boolean>(true);
}
示例2
@Test public void testNestedPackage() throws Exception {
	Resource resource = new XMIResourceImpl();
	EPackage parent = EcoreFactory.eINSTANCE.createEPackage();
	parent.setName("parent");
	parent.setNsURI("http://parent");
	EPackage child = EcoreFactory.eINSTANCE.createEPackage();
	child.setName("child");
	child.setNsURI("http://child");
	EClass eClass = EcoreFactory.eINSTANCE.createEClass();
	eClass.setName("Test");
	child.getEClassifiers().add(eClass);
	parent.getESubpackages().add(child);
	resource.getContents().add(parent);
	Map<QualifiedName, IEObjectDescription> index = createIndex(resource);
	checkEntry(index, parent, false, "parent");
	checkEntry(index, child, false, "parent", "child");
	checkEntry(index, eClass, false, "parent", "child", "Test");
	checkEntry(index, parent, true, "http://parent");
	checkEntry(index, child, true, "http://child");
	checkEntry(index, eClass, true, "http://child", "Test");
	assertEquals(6,index.size());
}
示例3
@Test public void testMissingMiddleName() {
	Resource resource = new XMIResourceImpl();
	EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
	ePackage.setName("test");
	ePackage.setNsURI("http://test");
	EClass unnamedEClass = EcoreFactory.eINSTANCE.createEClass();
	EAttribute eAttribute = EcoreFactory.eINSTANCE.createEAttribute();
	eAttribute.setName("test");
	unnamedEClass.getEStructuralFeatures().add(eAttribute);
	ePackage.getEClassifiers().add(unnamedEClass);
	resource.getContents().add(ePackage);
	Map<QualifiedName, IEObjectDescription> index = createIndex(resource);
	checkEntry(index, ePackage, false, "test");
	checkEntry(index, ePackage, true, "http://test");
	assertEquals(2,index.size());
	
	unnamedEClass.setName("Test");
	index = createIndex(resource);
	checkEntry(index, ePackage, false, "test");
	checkEntry(index, ePackage, true, "http://test");
	checkEntry(index, unnamedEClass, false, "test", "Test");
	checkEntry(index, unnamedEClass, true, "http://test", "Test");
	checkEntry(index, eAttribute, false, "test", "Test", "test");
	checkEntry(index, eAttribute, true, "http://test", "Test", "test");
	assertEquals(6,index.size());
}
示例4
@Override
public IResourceDescription getResourceDescription(final URI uri) {
	return new AbstractResourceDescription() {

		@Override
		public Iterable<QualifiedName> getImportedNames() {
			return Collections.emptyList();
		}

		@Override
		public Iterable<IReferenceDescription> getReferenceDescriptions() {
			return Collections.emptyList();
		}

		@Override
		public URI getURI() {
			return uri;
		}

		@Override
		protected List<IEObjectDescription> computeExportedObjects() {
			return Collections.singletonList(EObjectDescription.create(exportedName, EcoreFactory.eINSTANCE.createEObject()));
		}
		
	};
}
示例5
@Test public void testCreateDeltaAndIsAffected() {
	GenericResourceDescriptionManager manager = getEmfResourceDescriptionsManager();
	EClass eClass = EcoreFactory.eINSTANCE.createEClass();
	eClass.setName("Test");
	eClass.getESuperTypes().add(EcorePackage.Literals.EPACKAGE);
	Resource resource = new XMIResourceImpl(URI.createFileURI("test.ecore"));
	resource.getContents().add(eClass);

	EPackage copyOfEPackage = EcoreUtil.copy(EcorePackage.eINSTANCE);
	Resource ecoreResource = new XMIResourceImpl(URI.createURI(copyOfEPackage.getNsURI()));
	ecoreResource.getContents().add(copyOfEPackage);
	
	IResourceDescription oldDescription = new CopiedResourceDescription(manager.getResourceDescription(ecoreResource));
	oldDescription.getExportedObjects();
	copyOfEPackage.setName("ecore_new");
	IResourceDescription newDescription = manager.getResourceDescription(ecoreResource);
	
	Delta delta = manager.createDelta(oldDescription, newDescription);
	assertTrue(delta.haveEObjectDescriptionsChanged());
	
	IResourceDescription referrerDescription = manager.getResourceDescription(resource);
	assertTrue(manager.isAffected(delta, referrerDescription));
}
示例6
protected Result<Boolean> applyRuleEClassEObject(final RuleEnvironment G, final RuleApplicationTrace _trace_, final EClass eClass, final EObject object) throws RuleFailedException {
  String _string = new String();
  String _firstUpper = StringExtensions.toFirstUpper("bar");
  String _plus = (_string + _firstUpper);
  boolean _equals = Objects.equal("foo", _plus);
  /* 'foo' == new String() + 'bar'.toFirstUpper */
  if (!_equals) {
    sneakyThrowRuleFailedException("\'foo\' == new String() + \'bar\'.toFirstUpper");
  }
  final EClass eC = EcoreFactory.eINSTANCE.createEClass();
  eC.setName("MyEClass");
  /* eClass == eC */
  if (!Objects.equal(eClass, eC)) {
    sneakyThrowRuleFailedException("eClass == eC");
  }
  return new Result<Boolean>(true);
}
示例7
protected Result<Boolean> applyRuleEClassEClass(final RuleEnvironment G, final RuleApplicationTrace _trace_, final EClass eClass1, final EClass eClass2) throws RuleFailedException {
  String _string = new String();
  String _firstUpper = StringExtensions.toFirstUpper("bar");
  String _plus = (_string + _firstUpper);
  boolean _equals = Objects.equal("foo", _plus);
  /* 'foo' == new String() + 'bar'.toFirstUpper */
  if (!_equals) {
    sneakyThrowRuleFailedException("\'foo\' == new String() + \'bar\'.toFirstUpper");
  }
  final EClass eC = EcoreFactory.eINSTANCE.createEClass();
  eC.setName("MyEClass");
  /* eClass1 == eC */
  if (!Objects.equal(eClass1, eC)) {
    sneakyThrowRuleFailedException("eClass1 == eC");
  }
  return new Result<Boolean>(true);
}
示例8
protected Result<Boolean> applyRuleEClassEClass(final RuleEnvironment G, final RuleApplicationTrace _trace_, final EClass eClass1, final EClass eClass2) throws RuleFailedException {
  String _string = new String();
  String _firstUpper = StringExtensions.toFirstUpper("bar");
  String _plus = (_string + _firstUpper);
  boolean _equals = Objects.equal("foo", _plus);
  /* 'foo' == new String() + 'bar'.toFirstUpper */
  if (!_equals) {
    sneakyThrowRuleFailedException("\'foo\' == new String() + \'bar\'.toFirstUpper");
  }
  final EClass eC = EcoreFactory.eINSTANCE.createEClass();
  eC.setName("MyEClass");
  /* eClass1 == eC */
  if (!Objects.equal(eClass1, eC)) {
    sneakyThrowRuleFailedException("eClass1 == eC");
  }
  return new Result<Boolean>(true);
}
示例9
@Test
public void testCacheSurvivesChangesToAdapters() throws Exception {
	EcoreFactory factory = EcoreFactory.eINSTANCE;
	EClass eClass = factory.createEClass();
	Resource resource = new ResourceImpl();
	resource.getContents().add(eClass);
	CacheAdapter ca = new OnChangeEvictingCache().getOrCreate(resource);
	setValue(ca);
	List<Adapter> adapters = resource.eAdapters();
	assertIsSet(ca);
	AdapterImpl adapter = new AdapterImpl();
	adapters.add(adapter);
	assertIsSet(ca);
	adapters.remove(adapter);
	assertIsSet(ca);
}
示例10
protected Result<Boolean> applyRuleEClassEObject(final RuleEnvironment G, final RuleApplicationTrace _trace_, final EClass eClass, final EObject object) throws RuleFailedException {
  String _string = new String();
  String _firstUpper = StringExtensions.toFirstUpper("bar");
  String _plus = (_string + _firstUpper);
  boolean _equals = Objects.equal("foo", _plus);
  /* 'foo' == new String() + 'bar'.toFirstUpper */
  if (!_equals) {
    sneakyThrowRuleFailedException("\'foo\' == new String() + \'bar\'.toFirstUpper");
  }
  final EClass eC = EcoreFactory.eINSTANCE.createEClass();
  eC.setName("MyEClass");
  /* eClass == eC */
  if (!Objects.equal(eClass, eC)) {
    sneakyThrowRuleFailedException("eClass == eC");
  }
  return new Result<Boolean>(true);
}
示例11
@Test
public void testConvertNullInput() throws Exception {
	EClass eClass = EcoreFactory.eINSTANCE.createEClass();
	Function2<String, INode, Object> toValueImpl = new Function2<String, INode, Object>() {

		@Override
		public Object apply(String lexerRule, INode node) {
			if ("foo".equals(lexerRule) ) {
				return "FOO";
			}
			return null;
		}
	};
	DefaultEcoreElementFactory factory = new DefaultEcoreElementFactory();
	factory.setConverterService(new MockedConverterService(toValueImpl));
	factory.set(eClass, "name", null, "foo", null);

	assertEquals("FOO", eClass.getName());
}
示例12
@Test public void testAdapterIsCleared() throws Exception {
	EcoreFactory factory = EcoreFactory.eINSTANCE;
	EClass eClass = factory.createEClass();
	Resource resource = new ResourceImpl();
	resource.getContents().add(eClass);
	CacheAdapter ca = new OnChangeEvictingCache().getOrCreate(resource);
	setValue(ca);
	EAttribute attribute = factory.createEAttribute();
	assertIsSet(ca);
	eClass.getEStructuralFeatures().add(attribute);
	assertIsNull(ca);
	setValue(ca);
	attribute.setName("Foo");
	assertIsNull(ca);
	setValue(ca);
}
示例13
@Test public void testGetAllReferencedObjects() {
	EClass a = createEClass("a");
	EClass b = createEClass("b");
	
	EPackage pack = EcoreFactory.eINSTANCE.createEPackage();
	pack.setName("empty");
	pack.setNsPrefix("empty");
	pack.setNsURI("empty");
	pack.getEClassifiers().add(a);
	pack.getEClassifiers().add(b);
	
	EReference ref = EcoreFactory.eINSTANCE.createEReference();
	a.getEStructuralFeatures().add(ref);
	ref.setUpperBound(1);
	ref.setEType(b);
	EObject objA = pack.getEFactoryInstance().create(a);
	EObject objB = pack.getEFactoryInstance().create(b);
	List<EObject> res = EcoreUtil2.getAllReferencedObjects(objA, ref);
	assertNotNull(res);
	assertTrue(res.isEmpty());
	res = EcoreUtil2.getAllReferencedObjects(objA, ref);
	assertNotNull(res);
	objA.eSet(ref, objB);
}
示例14
@Test public void testPathFragment() {
	EClass foo = EcoreFactory.eINSTANCE.createEClass();
	foo.setName("foo");
	EClass bar = EcoreFactory.eINSTANCE.createEClass();
	foo.setName("bar");
	EPackage p = EcoreFactory.eINSTANCE.createEPackage();
	bar.setName("p");
	p.getEClassifiers().add(foo);
	p.getEClassifiers().add(bar);
	
	assertEquals("/-1", EcoreUtil2.getFragmentPath(foo));
	assertEquals("/-1", EcoreUtil2.getFragmentPath(bar));
	assertEquals("/-1", EcoreUtil2.getFragmentPath(p));
	Resource resource = new ResourceImpl(URI.createURI("platform:/resource/res"));
	resource.getContents().add(p);
	assertEquals(URI.createURI("platform:/resource/res#//@eClassifiers.0"), EcoreUtil2.getFragmentPathURI(foo));
	assertEquals(URI.createURI("platform:/resource/res#//@eClassifiers.1"), EcoreUtil2.getFragmentPathURI(bar));
	assertEquals(URI.createURI("platform:/resource/res#/"), EcoreUtil2.getFragmentPathURI(p));
	assertEquals(resource.getEObject("//@eClassifiers.0"), foo);
	assertEquals(resource.getEObject("//@eClassifiers.1"), bar);
	assertEquals(resource.getEObject("/"), p);
}
示例15
@Test public void testIsAssignableFrom() {
	EClass superCls = EcoreFactory.eINSTANCE.createEClass();
	superCls.setName("MySuper");
	superCls.getESuperTypes().add(EcorePackage.eINSTANCE.getEObject());

	EClass subCls = EcoreFactory.eINSTANCE.createEClass();
	subCls.setName("MySub");
	subCls.getESuperTypes().add(superCls);
	
	assertFalse(EcoreUtil2.isAssignableFrom(null, null));
	assertFalse(EcoreUtil2.isAssignableFrom(superCls, null));
	assertFalse(EcoreUtil2.isAssignableFrom(null, superCls));
	
	assertTrue(EcoreUtil2.isAssignableFrom(superCls, superCls));
	assertTrue(EcoreUtil2.isAssignableFrom(superCls, subCls));
	assertFalse(EcoreUtil2.isAssignableFrom(subCls, superCls));
	
	assertTrue(EcoreUtil2.isAssignableFrom(EcorePackage.eINSTANCE.getEObject(), superCls));
	assertTrue(EcoreUtil2.isAssignableFrom(EcorePackage.eINSTANCE.getEObject(), subCls));
}
示例16
@Before
public void init() {
  EcoreFactory modelFactory = EcoreFactory.eINSTANCE;
  testModelPackage = modelFactory.createEPackage();
  testModelPackage.setName("TypeProviderTestEPackage");
  testModelPackage.setNsPrefix("typeprovidertestpackage");
  testModelPackage.setNsURI("http://testabstracttype");
  EFactory instanceFactory = testModelPackage.getEFactoryInstance();
  EClass clazz = createEClass("ExpressionContainer");
  expressionContainerReference = modelFactory.createEReference();
  clazz.getEStructuralFeatures().add(expressionContainerReference);
  expressionContainerReference.setName("expression");
  expressionContainerReference.setEType(typeModelPackage.getIExpression());
  expressionContainerReference.setContainment(true);
  expression1Container = instanceFactory.create(clazz);
  expression1Container.eSet(expressionContainerReference, expression1);
  expression2Container = instanceFactory.create(clazz);
  expression2Container.eSet(expressionContainerReference, expression2);
  expression3Container = instanceFactory.create(clazz);
  expression3Container.eSet(expressionContainerReference, expression3);
}
示例17
@Test public void testWithDifferentElements() throws Exception {
	EAttribute attr = EcoreFactory.eINSTANCE.createEAttribute();
	attr.setName("Foo");
	EDataType datatype = EcoreFactory.eINSTANCE.createEDataType();
	datatype.setName("Bar");
	
	ArrayList<EObject> list = new ArrayList<EObject>();
	list.add(attr);
	list.add(EcoreFactory.eINSTANCE.createEObject());
	list.add(datatype);
	
	Iterable<IEObjectDescription> iterable = Scopes.scopedElementsFor(list);
	Iterator<IEObjectDescription> iterator = iterable.iterator();
	IEObjectDescription next = iterator.next();
	assertEquals(FOO, next.getName());
	assertEquals(attr,next.getEObjectOrProxy());
	next = iterator.next();
	assertEquals(BAR, next.getName());
	assertEquals(datatype,next.getEObjectOrProxy());
	assertFalse(iterator.hasNext());
}
示例18
@Test
public void testVarNameConflictingWithParam() {
  EAttribute _createEAttribute = EcoreFactory.eINSTANCE.createEAttribute();
  final Procedure1<EAttribute> _function = (EAttribute it) -> {
    it.setName("xxx");
  };
  EAttribute _doubleArrow = ObjectExtensions.<EAttribute>operator_doubleArrow(_createEAttribute, _function);
  Assert.assertEquals("_xxx", this.fragment.toVarName(_doubleArrow), "xxx");
}
示例19
/**
* @generated
*/
protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info) throws ExecutionException {
	for (Iterator it = myDescriptors.iterator(); it.hasNext();) {
		CreateViewRequest.ViewDescriptor nextDescriptor = (CreateViewRequest.ViewDescriptor) it.next();
		View view = (View) nextDescriptor.getAdapter(View.class);
		if (view != null && view.getEAnnotation("Shortcut") == null) { //$NON-NLS-1$
			EAnnotation shortcutAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
			shortcutAnnotation.setSource("Shortcut"); //$NON-NLS-1$
			shortcutAnnotation.getDetails().put("modelID", WorkflowEditPart.MODEL_ID); //$NON-NLS-1$
			view.getEAnnotations().add(shortcutAnnotation);
		}
	}
	return CommandResult.newOKCommandResult();
}
示例20
/**
* @generated
*/
private void stampShortcut(View containerView, Node target) {
	if (!WorkflowEditPart.MODEL_ID.equals(CrossflowVisualIDRegistry.getModelID(containerView))) {
		EAnnotation shortcutAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
		shortcutAnnotation.setSource("Shortcut"); //$NON-NLS-1$
		shortcutAnnotation.getDetails().put("modelID", WorkflowEditPart.MODEL_ID); //$NON-NLS-1$
		target.getEAnnotations().add(shortcutAnnotation);
	}
}
示例21
@Test
public void testRecursiveInheritance() {
	EObject eObject = EcoreFactory.eINSTANCE.createEObject();
	JvmGenericType bar = jvmTypesBuilder.toClass(eObject, "Bar");
	JvmGenericType foo = jvmTypesBuilder.toClass(eObject, "Foo");
	bar.getSuperTypes().add(typeReferences.createTypeRef(foo));
	foo.getSuperTypes().add(typeReferences.createTypeRef(bar));
	Assert.assertNotNull(jvmDeclaredTypeSignatureHashProvider.getHash(foo));
	Assert.assertNotEquals(jvmDeclaredTypeSignatureHashProvider.getHash(foo), jvmDeclaredTypeSignatureHashProvider.getHash(bar));
}
示例22
@Override
public void setUp() {
  super.setUp();
  EcoreFactory factory = EcoreFactory.eINSTANCE;
  EClass baseClass = factory.createEClass();
  baseClass.setName("Base");
  primaryResource.getContents().add(baseClass);
  EClass superClass = factory.createEClass();
  superClass.setName("SuperClass");
  referencedResource.getContents().add(superClass);
  baseClass.getESuperTypes().add(superClass);
}
示例23
@Test public void testMissingNsURI() {
	Resource resource = new XMIResourceImpl();
	EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
	ePackage.setName("test");
	EClass eClass = EcoreFactory.eINSTANCE.createEClass();
	eClass.setName("Test");
	ePackage.getEClassifiers().add(eClass);
	resource.getContents().add(ePackage);
	Map<QualifiedName, IEObjectDescription> index = createIndex(resource);
	checkEntry(index, ePackage, false, "test");
	checkEntry(index, eClass, false, "test", "Test");
	assertEquals(2,index.size());
}
示例24
@Test public void testEObjectDescription() throws Exception {
	XtextResourceSet resourceSet = new XtextResourceSet();
	Resource resource = resourceSet.createResource(URI.createPlatformResourceURI("test/test.ecore", true));
	EPackage ePackage = EcoreFactory.eINSTANCE.createEPackage();
	resource.getContents().add(ePackage);
	IEObjectDescription eObjectDescription = EObjectDescription.create("test", ePackage);
	assertEquals("test - EPackage", globalDescriptionLabelProvider.getText(eObjectDescription));
	assertNotNull(globalDescriptionLabelProvider.getImage(eObjectDescription));
}
示例25
@Test public void testAnnounceDirtyState_02() {
	ignoreConcurrentEditing.add(Boolean.TRUE);
	dirtyStateManager.manageDirtyState(this);
	dirtyStateSupport.initializeDirtyStateSupport(this);
	dirtyStateSupport.isEditingPossible(this);
	assertEquals(getContents(), dirtyStateManager.getContent(resourceURI));
	exportedObjects = Lists.newArrayList(EObjectDescription.create(QualifiedName.create("foo"), EcoreFactory.eINSTANCE.createEClass()));
	dirtyStateSupport.announceDirtyState(resource);
	assertTrue(dirtyStateManager.hasContent(resourceURI));
	assertEquals(get(), dirtyStateManager.getContent(resourceURI));
}
示例26
@Override
public EObject getEObjectOrProxy() {
	EObject element = super.getEObjectOrProxy();
	InternalEObject result = (InternalEObject) EcoreFactory.eINSTANCE.create(element.eClass());
	result.eSetProxyURI(EcoreUtil.getURI(element));
	return result;
}
示例27
protected void completeSpecialAttributeAssignment(String specialAttribute, int priorityFactor, Iterable<String> processedFeatures,
		Function<IEObjectDescription, ICompletionProposal> factory, ContentAssistContext context,
		ICompletionProposalAcceptor acceptor) {
	if(!contains(processedFeatures, specialAttribute)) {
		EAttribute dummyAttribute = EcoreFactory.eINSTANCE.createEAttribute();
		dummyAttribute.setName(specialAttribute);
		dummyAttribute.setEType(EcorePackage.Literals.ESTRING);
		acceptor.accept(createFeatureProposal(dummyAttribute, priorityFactor, factory, context));
	}
}
示例28
@Override
protected List<EObject> getRenamedElementsOrProxies(EObject originalTarget) {
	if (originalTarget instanceof ParserRule) {
		TypeRef returnType = ((ParserRule) originalTarget).getType();
		if (returnType != null && returnType.getClassifier() != null
				&& !Strings.isEmpty(returnType.getClassifier().getName())
				&& equal(((ParserRule) originalTarget).getName(), returnType.getClassifier().getName())
				&& returnType.getClassifier().eClass() != null && returnType.getClassifier().getEPackage() != null
				&& !Strings.isEmpty(returnType.getClassifier().getEPackage().getNsURI())) {
			String packageNsURI = returnType.getClassifier().getEPackage().getNsURI();
			QualifiedName classifierQualifiedName = QualifiedName.create(packageNsURI, returnType.getClassifier()
					.getName());
			URI platformResourceURI = findPlatformResourceURI(classifierQualifiedName, EcorePackage.Literals.ECLASS);
			if (platformResourceURI == null) {
				if (returnType.getMetamodel() instanceof ReferencedMetamodel)
					getStatus().add(ERROR, "Return type '{0}' is not indexed.", returnType.getClassifier());
			} else {
				EObject classifierProxy = EcoreFactory.eINSTANCE.create(returnType.getClassifier().eClass());
				((InternalEObject) classifierProxy).eSetProxyURI(platformResourceURI);
				if(!isDisableWarning)
					getStatus().add(WARNING, 
							"Renaming EClass '{0}' in ecore file. Please rerun the Ecore generator.", returnType.getClassifier());
				
				return singletonList(classifierProxy);
			}
		}
	}
	return null;
}
示例29
@Test public void testNoNPE() {
	EObjectDescriptionImpl objectDescription = (EObjectDescriptionImpl) BuilderStateFactory.eINSTANCE.createEObjectDescription();
	objectDescription.setFragment("myFragment");
	ResourceDescriptionImpl resourceDescription = (ResourceDescriptionImpl) BuilderStateFactory.eINSTANCE.createResourceDescription();
	resourceDescription.getExportedObjects().add(objectDescription);
	resourceDescription.setURI(URI.createURI("does.not.matter"));
	EClass doesNotExist = EcoreFactory.eINSTANCE.createEClass();
	InternalEObject proxy = (InternalEObject) doesNotExist;
	proxy.eSetProxyURI(URI.createURI("does.not.exist"));
	objectDescription.setEClass(doesNotExist);
	assertSame(doesNotExist, objectDescription.getEClass());
	assertNull(objectDescription.getEObjectOrProxy());
	assertEquals("does.not.matter#myFragment", objectDescription.getEObjectURI().toString());
}
示例30
public void refreshInput() {
	ISelection selection = viewer.getSelection();
	EList<EObject> listInput = getListInput();
	viewer.setInput(listInput);
	if (listInput.isEmpty()) {
		viewer.getTable().clearAll();
		TableItem item = new TableItem(viewer.getTable(), SWT.NONE);
		item.setData(EcoreFactory.eINSTANCE.createEObject());
		item.setText(placeholder);
	} else {
		viewer.setSelection(selection);
	}
	viewer.setSelection(selection);
}