private static Set<? extends EObject> checkCrossReferences(ResourceSet resourceSet, URI uri) {
Set<EObject> result = new HashSet<EObject>();
Resource resource = resourceSet.getResource(uri, false);
if (resource != null) {
EList<EObject> contents = resource.getContents();
if (!contents.isEmpty()) {
EObject eObject = contents.get(0);
for (EObject eCrossReference : eObject.eCrossReferences()) {
Resource eResource = eCrossReference.eResource();
if (eResource != null) {
for (EObject content : eResource.getContents()) {
EObject eContainer = content.eContainer();
if (eContainer != null) {
result.add(eContainer);
}
}
eResource.unload();
}
}
}
}
return result;
}
private void setCrossReferenceLinks(EObject eObject) {
for (EContentsEList.FeatureIterator<EObject> featureIterator =
(EContentsEList.FeatureIterator<EObject>) eObject.eCrossReferences().iterator();
featureIterator.hasNext(); ) {
EObject referencedEObject = (EObject) featureIterator.next();
EReference eReference = (EReference) featureIterator.feature();
int position = getPosition(eObject, eReference, referencedEObject);
addLink(eObject, referencedEObject, eReference, position);
}
}
/**
* This iterates over the entire contents and checks whether dangling references exist. If some
* are found, they are printed to the console (disabled) and the call returns the number of
* dangling references found.
*
* @param resource A resource.
* @return The number of dangling references.
*/
public static int checkDanglingReferences(Resource resource) {
int counter = 0;
final TreeIterator<EObject> iter = resource.getAllContents();
while (iter.hasNext()) {
final EObject obj = iter.next();
for (EObject ref : obj.eCrossReferences()) {
if (ref.eResource() == null) {
counter++;
// System.out.println("Dangling refrence found: " + ref);
}
}
}
return counter;
}
/**
* Resolved all proxies within the given resource set.
*
* @param resourceSet the resource set to resolve.
*/
private void resolveAll(ResourceSet resourceSet) {
if (resourceSet != null) {
final List<Resource> resources = resourceSet.getResources();
for (int i = 0; i < resources.size(); ++i) {
final Iterator<EObject> resourceContent = resources.get(i).getAllContents();
while (resourceContent.hasNext()) {
final EObject eObject = resourceContent.next();
final Iterator<EObject> objectChildren = eObject.eCrossReferences().iterator();
while (objectChildren.hasNext()) {
// Resolves cross references by simply visiting them.
objectChildren.next();
}
resourcesInScope.add(eObject.eResource());
}
}
}
}
private List<ModelUnit> getUnusedWiths(PropertySet propertySet) {
List<ModelUnit> importedUnits = propertySet.getImportedUnits();
List<ModelUnit> unusedWiths = new ArrayList<ModelUnit>();
ImportedUnitsLoop:
for (ModelUnit nextImportedUnit : importedUnits) {
if (nextImportedUnit.equals(propertySet.eContainer())) {
unusedWiths.add(nextImportedUnit);
continue ImportedUnitsLoop;
}
if (AadlUtil.isPredeclaredPropertySet(nextImportedUnit.getName())) {
unusedWiths.add(nextImportedUnit);
continue ImportedUnitsLoop;
}
TreeIterator<EObject> packageContents = propertySet.eAllContents();
while (packageContents.hasNext()) {
EObject nextObject = packageContents.next();
EList<EObject> crossReferences = nextObject.eCrossReferences();
for (EObject crossReference : crossReferences) {
EObject container = crossReference.eContainer();
if (nextImportedUnit.equals(container)) {
continue ImportedUnitsLoop;
} else {
while (container != null
&& !(container instanceof AadlPackage)
&& !(container instanceof PropertySet)) {
container = container.eContainer();
if (container.equals(nextImportedUnit)) {
continue ImportedUnitsLoop;
}
}
}
}
}
unusedWiths.add(nextImportedUnit);
}
return unusedWiths;
}
private List<ModelUnit> findMissingWiths(PropertySet propertySet) {
List<ModelUnit> currentWiths = propertySet.getImportedUnits();
List<ModelUnit> missingWiths = new ArrayList<ModelUnit>();
TreeIterator<EObject> packageContents = propertySet.eAllContents();
while (packageContents.hasNext()) {
EObject nextObject = packageContents.next();
EList<EObject> crossReferences = nextObject.eCrossReferences();
for (EObject crossReference : crossReferences) {
EObject container = crossReference.eContainer();
while (container != null) {
if ((container instanceof PropertySet || container instanceof AadlPackage)
&& (!AadlUtil.isPredeclaredPropertySet(((ModelUnit) container).getName()))
&& (!((ModelUnit) container).equals(propertySet))) {
if (!currentWiths.contains(container) && !missingWiths.contains(container)) {
missingWiths.add((ModelUnit) container);
}
}
container = container.eContainer();
}
}
}
return missingWiths;
}
public void initializeUsedGenPackages(final GenModel genModel) {
this.genModelInitializer.initialize(genModel, true);
HashSet<EPackage> _hashSet = new HashSet<EPackage>();
final HashSet<EPackage> referencedEPackages = _hashSet;
UniqueEList<EPackage> _uniqueEList = new UniqueEList<EPackage>();
final List<EPackage> ePackages = _uniqueEList;
EList<GenPackage> _genPackages = genModel.getGenPackages();
for (final GenPackage genPackage : _genPackages) {
EPackage _ecorePackage = genPackage.getEcorePackage();
ePackages.add(_ecorePackage);
}
int i = 0;
int _size = ePackages.size();
boolean _lessThan = (i < _size);
boolean _while = _lessThan;
while (_while) {
{
final EPackage ePackage = ePackages.get(i);
int _plus = (i + 1);
i = _plus;
final TreeIterator<EObject> allContents = ePackage.eAllContents();
boolean _hasNext = allContents.hasNext();
boolean _while_1 = _hasNext;
while (_while_1) {
{
final EObject eObject = allContents.next();
if ((eObject instanceof EPackage)) {
allContents.prune();
} else {
EList<EObject> _eCrossReferences = eObject.eCrossReferences();
for (final EObject eCrossReference : _eCrossReferences) {
boolean _matched = false;
if (!_matched) {
if (eCrossReference instanceof EClassifier) {
final EClassifier _eClassifier = (EClassifier) eCrossReference;
_matched = true;
final EPackage referencedEPackage = _eClassifier.getEPackage();
ePackages.add(referencedEPackage);
referencedEPackages.add(referencedEPackage);
}
}
if (!_matched) {
if (eCrossReference instanceof EStructuralFeature) {
final EStructuralFeature _eStructuralFeature =
(EStructuralFeature) eCrossReference;
_matched = true;
EClass _eContainingClass = _eStructuralFeature.getEContainingClass();
final EPackage referencedEPackage = _eContainingClass.getEPackage();
ePackages.add(referencedEPackage);
referencedEPackages.add(referencedEPackage);
}
}
}
}
}
boolean _hasNext_1 = allContents.hasNext();
_while_1 = _hasNext_1;
}
}
int _size_1 = ePackages.size();
boolean _lessThan_1 = (i < _size_1);
_while = _lessThan_1;
}
for (final EPackage referencedEPackage : referencedEPackages) {
GenPackage _findGenPackage = genModel.findGenPackage(referencedEPackage);
boolean _equals = Objects.equal(_findGenPackage, null);
if (_equals) {
ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(referencedEPackage);
XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
GenBase _gen = this.mapper.getGen(_xcoreElement);
GenPackage usedGenPackage = ((GenPackage) _gen);
boolean _equals_1 = Objects.equal(usedGenPackage, null);
if (_equals_1) {
GenPackage _findLocalGenPackage = this.findLocalGenPackage(referencedEPackage);
usedGenPackage = _findLocalGenPackage;
}
boolean _notEquals = (!Objects.equal(usedGenPackage, null));
if (_notEquals) {
EList<GenPackage> _usedGenPackages = genModel.getUsedGenPackages();
_usedGenPackages.add(usedGenPackage);
} else {
Resource _eResource = genModel.eResource();
ResourceSet _resourceSet = _eResource.getResourceSet();
final EList<Resource> resources = _resourceSet.getResources();
i = 0;
boolean found = false;
boolean _and = false;
int _size_1 = resources.size();
boolean _lessThan_1 = (i < _size_1);
if (!_lessThan_1) {
_and = false;
} else {
boolean _not = (!found);
_and = (_lessThan_1 && _not);
}
boolean _while_1 = _and;
while (_while_1) {
{
final Resource resource = resources.get(i);
boolean _and_1 = false;
URI _uRI = resource.getURI();
String _fileExtension = _uRI.fileExtension();
boolean _equals_2 = "genmodel".equals(_fileExtension);
if (!_equals_2) {
_and_1 = false;
} else {
EList<EObject> _contents = resource.getContents();
boolean _isEmpty = _contents.isEmpty();
boolean _not_1 = (!_isEmpty);
_and_1 = (_equals_2 && _not_1);
}
if (_and_1) {
EList<EObject> _contents_1 = resource.getContents();
EObject _get = _contents_1.get(0);
GenPackage _findGenPackage_1 = ((GenModel) _get).findGenPackage(referencedEPackage);
usedGenPackage = _findGenPackage_1;
boolean _notEquals_1 = (!Objects.equal(usedGenPackage, null));
if (_notEquals_1) {
EList<GenPackage> _usedGenPackages_1 = genModel.getUsedGenPackages();
_usedGenPackages_1.add(usedGenPackage);
found = true;
}
}
int _plus = (i + 1);
i = _plus;
}
boolean _and_1 = false;
int _size_2 = resources.size();
boolean _lessThan_2 = (i < _size_2);
if (!_lessThan_2) {
_and_1 = false;
} else {
boolean _not_1 = (!found);
_and_1 = (_lessThan_2 && _not_1);
}
_while_1 = _and_1;
}
boolean _not_1 = (!found);
if (_not_1) {
String _plus = ("No GenPackage found for " + referencedEPackage);
RuntimeException _runtimeException = new RuntimeException(_plus);
throw _runtimeException;
}
}
}
}
}
@Override
public org.edna.datamodel.datamodel.Model transform(org.eclipse.uml2.uml.Model sourceModel) {
this.sourceModel = sourceModel;
this.targetModel = DatamodelFactory.eINSTANCE.createModel();
targetModel.setTargetNamespace(nsUri);
new UMLSwitch<EObject>() {
private Stack<org.edna.datamodel.datamodel.Package> packageStack =
new Stack<org.edna.datamodel.datamodel.Package>();
public EObject caseModel(org.eclipse.uml2.uml.Model object) {
List<PackageableElement> packagedElements =
Lists.newArrayList(object.getPackagedElements());
Collections.sort(packagedElements, Comparators.namedElementComparator);
for (EObject obj : packagedElements) {
doSwitch(obj);
}
return object;
};
public EObject caseClass(Class object) {
if (monitor.isCanceled()) return null;
monitor.subTask(object.getName());
ComplexType type = createComplexType.apply(object);
org.edna.datamodel.datamodel.Package currentPackage =
packageStack.isEmpty() ? null : packageStack.peek();
if (currentPackage != null) {
currentPackage.getTypes().add(type);
} else {
targetModel.getTypes().add(type);
}
monitor.worked(1);
return object;
};
public EObject casePackage(org.eclipse.uml2.uml.Package object) {
org.edna.datamodel.datamodel.Package target = createPackage.apply(object);
org.edna.datamodel.datamodel.Package currentPackage =
packageStack.isEmpty() ? null : packageStack.peek();
if (currentPackage != null) {
currentPackage.getPackages().add(target);
} else {
targetModel.getPackages().add(target);
}
packageStack.push(target);
List<PackageableElement> packagedElements =
Lists.newArrayList(object.getPackagedElements());
Collections.sort(packagedElements, Comparators.namedElementComparator);
for (EObject obj : packagedElements) {
if (monitor.isCanceled()) return null;
doSwitch(obj);
}
packageStack.pop();
return object;
};
}.doSwitch(sourceModel);
if (monitor.isCanceled()) return null;
Set<String> importedNamespaces = Sets.newTreeSet();
for (Iterator<EObject> i = targetModel.eAllContents(); i.hasNext(); ) {
EObject obj = i.next();
for (EObject referenced : obj.eCrossReferences()) {
if (referenced.eResource() != null) {
importedNamespaces.add(nameProvider.getFullyQualifiedName(referenced).toString());
}
}
}
for (String elem : importedNamespaces) {
Import imported = DatamodelFactory.eINSTANCE.createImport();
imported.setImportedNamespace(elem);
targetModel.getImports().add(imported);
}
return targetModel;
}
