Java Setting类代码示例

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
protected boolean isLocallyUsed(EObject target, EObject containerToFindUsage) {
	if (readAndWriteTracking.isRead(target)) {
		return true;
	}
	Collection<Setting> usages = XbaseUsageCrossReferencer.find(target, containerToFindUsage);
	// for non-private members it is enough to check that there are usages
	if (!(target instanceof JvmOperation) || ((JvmOperation)target).getVisibility()!=JvmVisibility.PRIVATE) {
		return !usages.isEmpty();
	} else {
		// for private members it has to be checked if all usages are within the operation
		EObject targetSourceElem = associations.getPrimarySourceElement(target);
		for (Setting s : usages) {
			if (s.getEObject() instanceof XAbstractFeatureCall) {
				XAbstractFeatureCall fc = (XAbstractFeatureCall) s.getEObject();
				// when the feature call does not call itself or the call is
				// from another function, then it is locally used
				if (fc.getFeature() != target || !EcoreUtil.isAncestor(targetSourceElem, fc))
					return true;
			} else {
				return true;
			}
		}
		return false;
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
protected void addAnnotationsForReferences(EObject referencedElement, List<String> matchingNames) {
	
	IDocument document = getSourceViewer().getDocument();
	
	// Determine all references to the EObject
	Map<EObject, Collection<Setting>> map = EcoreUtil.UsageCrossReferencer.find(Collections.singleton(textResource));
	Collection<Setting> referencingObjects = map.get(referencedElement);
	if (referencingObjects == null) {
		// No references found
		return;
	}
	
	// Highlight the token in the text for the referencing objects
	for (Setting setting : referencingObjects) {
		EObject referencingElement = setting.getEObject();
		// Search through all tokens in the elements that reference the element at the
		// caret position
		for (String name : matchingNames) {
			int index = getIndexOf(referencingElement, name);
			if (index > 0) {
				addAnnotation(document, de.darwinspl.preferences.resource.dwprofile.ui.DwprofilePositionCategory.PROXY, name, index, name.length());
			}
		}
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
protected void addAnnotationsForReferences(EObject referencedElement, List<String> matchingNames) {
	
	IDocument document = getSourceViewer().getDocument();
	
	// Determine all references to the EObject
	Map<EObject, Collection<Setting>> map = EcoreUtil.UsageCrossReferencer.find(Collections.singleton(textResource));
	Collection<Setting> referencingObjects = map.get(referencedElement);
	if (referencingObjects == null) {
		// No references found
		return;
	}
	
	// Highlight the token in the text for the referencing objects
	for (Setting setting : referencingObjects) {
		EObject referencingElement = setting.getEObject();
		// Search through all tokens in the elements that reference the element at the
		// caret position
		for (String name : matchingNames) {
			int index = getIndexOf(referencingElement, name);
			if (index > 0) {
				addAnnotation(document, eu.hyvar.feature.expression.resource.hyexpression.ui.HyexpressionPositionCategory.PROXY, name, index, name.length());
			}
		}
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
protected void addAnnotationsForReferences(EObject referencedElement, List<String> matchingNames) {
	
	IDocument document = getSourceViewer().getDocument();
	
	// Determine all references to the EObject
	Map<EObject, Collection<Setting>> map = EcoreUtil.UsageCrossReferencer.find(Collections.singleton(textResource));
	Collection<Setting> referencingObjects = map.get(referencedElement);
	if (referencingObjects == null) {
		// No references found
		return;
	}
	
	// Highlight the token in the text for the referencing objects
	for (Setting setting : referencingObjects) {
		EObject referencingElement = setting.getEObject();
		// Search through all tokens in the elements that reference the element at the
		// caret position
		for (String name : matchingNames) {
			int index = getIndexOf(referencingElement, name);
			if (index > 0) {
				addAnnotation(document, eu.hyvar.context.contextValidity.resource.hyvalidityformula.ui.HyvalidityformulaPositionCategory.PROXY, name, index, name.length());
			}
		}
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
protected void addAnnotationsForReferences(EObject referencedElement, List<String> matchingNames) {
	
	IDocument document = getSourceViewer().getDocument();
	
	// Determine all references to the EObject
	Map<EObject, Collection<Setting>> map = EcoreUtil.UsageCrossReferencer.find(Collections.singleton(textResource));
	Collection<Setting> referencingObjects = map.get(referencedElement);
	if (referencingObjects == null) {
		// No references found
		return;
	}
	
	// Highlight the token in the text for the referencing objects
	for (Setting setting : referencingObjects) {
		EObject referencingElement = setting.getEObject();
		// Search through all tokens in the elements that reference the element at the
		// caret position
		for (String name : matchingNames) {
			int index = getIndexOf(referencingElement, name);
			if (index > 0) {
				addAnnotation(document, eu.hyvar.dataValues.resource.hydatavalue.ui.HydatavaluePositionCategory.PROXY, name, index, name.length());
			}
		}
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
protected void addAnnotationsForReferences(EObject referencedElement, List<String> matchingNames) {
	
	IDocument document = getSourceViewer().getDocument();
	
	// Determine all references to the EObject
	Map<EObject, Collection<Setting>> map = EcoreUtil.UsageCrossReferencer.find(Collections.singleton(textResource));
	Collection<Setting> referencingObjects = map.get(referencedElement);
	if (referencingObjects == null) {
		// No references found
		return;
	}
	
	// Highlight the token in the text for the referencing objects
	for (Setting setting : referencingObjects) {
		EObject referencingElement = setting.getEObject();
		// Search through all tokens in the elements that reference the element at the
		// caret position
		for (String name : matchingNames) {
			int index = getIndexOf(referencingElement, name);
			if (index > 0) {
				addAnnotation(document, eu.hyvar.feature.mapping.resource.hymapping.ui.HymappingPositionCategory.PROXY, name, index, name.length());
			}
		}
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
protected void addAnnotationsForReferences(EObject referencedElement, List<String> matchingNames) {
	
	IDocument document = getSourceViewer().getDocument();
	
	// Determine all references to the EObject
	Map<EObject, Collection<Setting>> map = EcoreUtil.UsageCrossReferencer.find(Collections.singleton(textResource));
	Collection<Setting> referencingObjects = map.get(referencedElement);
	if (referencingObjects == null) {
		// No references found
		return;
	}
	
	// Highlight the token in the text for the referencing objects
	for (Setting setting : referencingObjects) {
		EObject referencingElement = setting.getEObject();
		// Search through all tokens in the elements that reference the element at the
		// caret position
		for (String name : matchingNames) {
			int index = getIndexOf(referencingElement, name);
			if (index > 0) {
				addAnnotation(document, eu.hyvar.feature.constraint.resource.hyconstraints.ui.HyconstraintsPositionCategory.PROXY, name, index, name.length());
			}
		}
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
protected void addAnnotationsForReferences(EObject referencedElement, List<String> matchingNames) {
	
	IDocument document = getSourceViewer().getDocument();
	
	// Determine all references to the EObject
	Map<EObject, Collection<Setting>> map = EcoreUtil.UsageCrossReferencer.find(Collections.singleton(textResource));
	Collection<Setting> referencingObjects = map.get(referencedElement);
	if (referencingObjects == null) {
		// No references found
		return;
	}
	
	// Highlight the token in the text for the referencing objects
	for (Setting setting : referencingObjects) {
		EObject referencingElement = setting.getEObject();
		// Search through all tokens in the elements that reference the element at the
		// caret position
		for (String name : matchingNames) {
			int index = getIndexOf(referencingElement, name);
			if (index > 0) {
				addAnnotation(document, eu.hyvar.mspl.manifest.resource.hymanifest.ui.HymanifestPositionCategory.PROXY, name, index, name.length());
			}
		}
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
public List<Method> findFieldReferences(IResourceDescriptions descriptions, Class element){
	List<Method> usages = new ArrayList<Method>();
	Iterable<IEObjectDescription> exportedObjectsByType = descriptions.getExportedObjectsByType(element.eClass());
	final ArrayList<EObject> gather = new ArrayList<>();

	exportedObjectsByType.forEach((e) -> {
		EObject eObjectOrProxy = e.getEObjectOrProxy();
		EObject resolve = EcoreUtil.resolve(eObjectOrProxy, element);
		gather.add(resolve);
	});

	element.getFields().listIterator().forEachRemaining((a) -> {
		Collection<Setting> references = EcoreUtil.UsageCrossReferencer.find(a, gather);
		references.forEach((f) -> {
			usages.add((Method) f.getEObject().eContainer());
		});
	});
	return usages;
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
@Override
protected Object adapt(Object element) {
	final Object res;

	final EObject eObject = IdeMappingUtils.adapt(element, EObject.class);
	if (eObject != null) {
		res = eObject;
	} else {
		final Setting setting = IdeMappingUtils.adapt(element, Setting.class);
		if (setting != null) {
			res = setting;
		} else {
			res = super.adapt(element);
		}
	}

	return res;
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * @see org.eclipse.mylyn.docs.intent.mapping.connector.IConnector#getName(org.eclipse.mylyn.docs.intent.mapping.base.ILocation)
 */
public String getName(ILocation location) {
	final String res;

	final Object element = getElement(location);
	if (element instanceof Setting) {
		final Setting setting = (Setting)element;
		res = getName(setting.getEObject(), setting.getEStructuralFeature(), ((IEObjectLocation)location)
				.getIndex());
	} else if (element instanceof EObject) {
		res = getName((EObject)element, null, 0);
	} else {
		// the located element has been deleted...
		res = null;
	}

	return res;
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
private Set<Resource> findCrossReferenceResource(Resource resource) {
    if (tempSet.contains(resource)) {
        return Collections.emptySet();
    }
    tempSet.add(resource);
    
    Set<Resource> unloadResourceList = new LinkedHashSet<Resource>();

    Map<EObject, Collection<Setting>> find = EcoreUtil.CrossReferencer.find(resource.getContents());

    for (Iterator<?> iterator = find.keySet().iterator(); iterator.hasNext();) {
        EObject type = (EObject) iterator.next();
        if (ProjectUtil.isModelFile(type.eResource())) {
            unloadResourceList.add(type.eResource());
            
            Set<Resource> referenceResource = findCrossReferenceResource(resource);
            if(!referenceResource.isEmpty()) {
                unloadResourceList.addAll(referenceResource);
            }
        }
    }

    return unloadResourceList;
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
private void pruneDanglingReferences(final EPlan plan) {
	TransactionUtils.writing(plan, new Runnable() {
		@Override
		@SuppressWarnings("unchecked")
		public void run() {
			Map<EObject, Collection<Setting>> proxiesMap = UnresolvedProxyCrossReferencer.find(plan);
			for (EObject proxy : proxiesMap.keySet()) {
				for (Setting setting : proxiesMap.get(proxy)) {
					EStructuralFeature feature = setting.getEStructuralFeature();
					if (feature instanceof EReference) {
						Object newValue = null;
						if (feature.isMany()) {
							newValue = new ArrayList((Collection)setting.get(true));
							((Collection)newValue).remove(proxy);
						}
						setting.set(newValue);
					}
				}
			}
		}
	});
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
/**
 * Delete the given incoming cross references to the given model element from any
 * other model element in the given project.
 * 
 * @param inverseReferences a collection of inverse references
 * @param modelElement
 *            the model element
 */
public static void deleteIncomingCrossReferencesFromParent(Collection<Setting> inverseReferences,
	EObject modelElement) {
	for (final Setting setting : inverseReferences) {
		final EStructuralFeature eStructuralFeature = setting.getEStructuralFeature();
		final EReference reference = (EReference) eStructuralFeature;

		if (reference.isContainer() || reference.isContainment() || !reference.isChangeable()) {
			continue;
		}

		final EObject opposite = setting.getEObject();

		if (eStructuralFeature.isMany()) {
			((EList<?>) opposite.eGet(eStructuralFeature)).remove(modelElement);
		} else {
			if (opposite instanceof Map.Entry<?, ?> && eStructuralFeature.getName().equals("key")) {
				logWarning("Incoming cross reference for model element " + modelElement + " is a map key.");
			}

			opposite.eUnset(eStructuralFeature);
		}
	}
}
 

import org.eclipse.emf.ecore.EStructuralFeature.Setting; //导入依赖的package包/类
/**
 * Delete all outgoing cross references of the given model element to any element in the given collection.
 * 
 * @param collection the collection
 * @param modelElement
 *            the model element
 */
public static void deleteOutgoingCrossReferences(IdEObjectCollection collection, EObject modelElement) {
	final Set<EObject> allModelElements = new LinkedHashSet<EObject>();
	allModelElements.add(modelElement);
	allModelElements.addAll(ModelUtil.getAllContainedModelElements(modelElement, false));

	final List<SettingWithReferencedElement> crossReferences = collectOutgoingCrossReferences(collection,
		allModelElements);
	for (final SettingWithReferencedElement settingWithReferencedElement : crossReferences) {
		final Setting setting = settingWithReferencedElement.getSetting();
		if (!settingWithReferencedElement.getSetting().getEStructuralFeature().isMany()) {
			setting.getEObject().eUnset(setting.getEStructuralFeature());
		} else {
			final List<?> references = (List<?>) setting.getEObject().eGet(setting.getEStructuralFeature());
			references.remove(settingWithReferencedElement.getReferencedElement());
		}
	}
}