protected void validateAllImports(final Grammar grammar) { List<AbstractMetamodelDeclaration> _allMetamodelDeclarations = GrammarUtil.allMetamodelDeclarations(grammar); for (final AbstractMetamodelDeclaration amd : _allMetamodelDeclarations) { if ((amd instanceof ReferencedMetamodel)) { this.validateReferencedMetamodel(((ReferencedMetamodel)amd)); } } }
@Override protected List<EPackage> getEPackages() { List<EPackage> pkg = new ArrayList<EPackage>(); for (AbstractMetamodelDeclaration a : GrammarUtil.allMetamodelDeclarations(grammar.getGrammar())) pkg.add(a.getEPackage()); return pkg; }
protected EClassifier getEClassifierForGrammar(String fqnClassName, Grammar grammar) { int dotIndex = fqnClassName.indexOf('.'); String packageName = null; String className = fqnClassName; if (dotIndex > 0) { packageName = fqnClassName.substring(0, dotIndex); className = fqnClassName.substring(dotIndex + 1); } List<AbstractMetamodelDeclaration> allMetamodelDeclarations = GrammarUtil .allMetamodelDeclarations(grammar); for (AbstractMetamodelDeclaration decl : allMetamodelDeclarations) { EPackage pack = decl.getEPackage(); if (packageName == null || pack.getName().equals(packageName)) { EClassifier eClassifier = pack.getEClassifier(className); if (eClassifier != null) { return eClassifier; } } } return null; }
protected EClass globalFindInstantiableCompatible(EClass eType) { Set<String> visitedPackages = Sets.newHashSet(eType.getEPackage().getNsURI()); for(AbstractMetamodelDeclaration metamodel: GrammarUtil.allMetamodelDeclarations(grammarAccess.getGrammar())) { if (visitedPackages.add(metamodel.getEPackage().getNsURI())) { EClass result = findSubTypeInEPackage(metamodel.getEPackage(), eType); if (result != null) return result; } } log.warn("Traversing EPackage registry to find instantiable subtype for '" + eType.getName() + "'"); log.warn("You may override LazyLinker#globalFindInstantiableCompatible(..) to prevent this."); for (String nsURI : getRegisteredNsUris()) { if (visitedPackages.add(nsURI)) { try { EClass result = findSubTypeInEPackage(getRegistry().getEPackage(nsURI), eType); if (result != null) return result; } catch(WrappedException ex) { log.error("Error when loading EPackage '" + nsURI + "'"); log.error("You may override LazyLinker#globalFindInstantiableCompatible(..) to prevent this."); log.error("Error when loading EPackage '" + nsURI + "'", ex); } } } throw new IllegalStateException( "Could not find an instantiable subtype for type: '" + eType.getName() + "' (" + eType.getEPackage().getNsURI() + ")."); }
protected Collection<EPackage> getRegistryPackagesToValidate() { final Collection<EPackage> packages = GrammarUtil.allEPackagesToValidate(this.getGrammar()); final Function1<GeneratedMetamodel, EPackage> _function = (GeneratedMetamodel it) -> { return it.getEPackage(); }; packages.removeAll(IterableExtensions.<EPackage>toList(IterableExtensions.<GeneratedMetamodel, EPackage>map(Iterables.<GeneratedMetamodel>filter(GrammarUtil.allMetamodelDeclarations(this.getGrammar()), GeneratedMetamodel.class), _function))); return packages; }
TypeRef getTypeRef(EClassifier classifier) { TypeRef result = XtextFactory.eINSTANCE.createTypeRef(); result.setClassifier(classifier); EPackage pack = classifier.getEPackage(); for(AbstractMetamodelDeclaration decl: GrammarUtil.allMetamodelDeclarations(grammar)) { if (pack.equals(decl.getEPackage())) { result.setMetamodel(decl); return result; } } return result; }
private static EClassifier findEClassifierByName(Grammar grammar, String nsURI, String name) { if (grammar != null) { for(AbstractMetamodelDeclaration declaration: allMetamodelDeclarations(grammar)) { if (declaration instanceof ReferencedMetamodel) { EPackage referencedPackage = declaration.getEPackage(); if (referencedPackage != null && !referencedPackage.eIsProxy()) { if (nsURI.equals(referencedPackage.getNsURI())) { EClassifier result = referencedPackage.getEClassifier(name); if (result != null) return result; } } } } } return null; } }