private void postProcessGeneratedPackages() { if (postProcessor != null) { final Iterable<GeneratedMetamodel> generatedMetamodels = Iterables.filter(grammar .getMetamodelDeclarations(), GeneratedMetamodel.class); for (GeneratedMetamodel metamodel : generatedMetamodels) { postProcessor.process(metamodel); } } }
private Set<String> getGeneratedEPackageURIs() { List<GeneratedMetamodel> list = EcoreUtil2.typeSelect(grammar.getMetamodelDeclarations(), GeneratedMetamodel.class); return Sets.newLinkedHashSet(Iterables.transform(list, new Function<GeneratedMetamodel, String>() { public String apply(GeneratedMetamodel from) { return from.getEPackage()!=null?from.getEPackage().getNsURI() : null; } })); }
protected IScope createEPackageScope(final Grammar grammar, IScope parent) { return new SimpleScope(parent,Iterables.transform(Iterables.filter(grammar.getMetamodelDeclarations(), new Predicate<AbstractMetamodelDeclaration>() { public boolean apply(AbstractMetamodelDeclaration input) { return input.getEPackage() != null; } }), new Function<AbstractMetamodelDeclaration, IEObjectDescription>() { public IEObjectDescription apply(AbstractMetamodelDeclaration from) { return EObjectDescription.create(QualifiedName.create(from.getEPackage().getNsURI()), from.getEPackage()); } })); }
private Iterable<GeneratedMetamodel> getAllGeneratedMetamodels(Grammar grammar, Set<Grammar> visited) { Iterable<GeneratedMetamodel> result = Iterables.filter(grammar.getMetamodelDeclarations(), GeneratedMetamodel.class); for (Grammar gr : grammar.getUsedGrammars()) { if (visited.add(gr)) result = Iterables.concat(result, getAllGeneratedMetamodels(gr, visited)); } return result; }
public List<EPackage> getGeneratedPackages() { final List<EPackage> result = new ArrayList<EPackage>(); final ResourceSet resourceSet = grammar.eResource().getResourceSet(); if (resourceSet == null) throw new NullPointerException("resourceSet may not be null"); Iterables.addAll(result, Iterables.filter(Iterables.transform( Iterables.filter(grammar.getMetamodelDeclarations(), GeneratedMetamodel.class), new Function<AbstractMetamodelDeclaration, EPackage>() { public EPackage apply(AbstractMetamodelDeclaration param) { return param.getEPackage(); } }), Predicates.notNull())); return getPackagesSortedByName(result); }
private static void collectAllMetamodelDeclarations(Grammar grammar, List<AbstractMetamodelDeclaration> result, Set<Pair<String, String>> knownAliases, Set<Grammar> visitedGrammars) { if (!visitedGrammars.add(grammar)) return; for (AbstractMetamodelDeclaration decl : grammar.getMetamodelDeclarations()) { if (decl.getEPackage() == null) result.add(decl); else if (knownAliases.add(getURIAliasPair(decl))) { result.add(decl); } } for (Grammar usedGrammar : grammar.getUsedGrammars()) collectAllMetamodelDeclarations(usedGrammar, result, knownAliases, visitedGrammars); }
protected Iterable<EPackage> getGeneratedPackagesToValidate() { final Function1<GeneratedMetamodel, EPackage> _function = (GeneratedMetamodel it) -> { return it.getEPackage(); }; return IterableExtensions.<GeneratedMetamodel, EPackage>map(Iterables.<GeneratedMetamodel>filter(this.getGrammar().getMetamodelDeclarations(), GeneratedMetamodel.class), _function); }
private List<EObject> getPackage(String nsUri, Grammar grammar, Set<Grammar> visitedGrammars) { if (!visitedGrammars.add(grammar)) return null; for(AbstractMetamodelDeclaration declaration: grammar.getMetamodelDeclarations()) { EPackage pack = declaration.getEPackage(); if (pack != null && nsUri.equals(pack.getNsURI())) return Collections.<EObject>singletonList(pack); } for (Grammar usedGrammar: grammar.getUsedGrammars()) { List<EObject> result = getPackage(nsUri, usedGrammar, visitedGrammars); if (result != null) return result; } return null; }
protected IScope createReferencedPackagesScope(Grammar g) { final Collection<EClassifier> allClassifiers = new ArrayList<EClassifier>(); for(AbstractMetamodelDeclaration decl: g.getMetamodelDeclarations()) { if (decl.getEPackage() != null) allClassifiers.addAll(decl.getEPackage().getEClassifiers()); } return createClassifierScope(allClassifiers); }
private boolean isReferencedByUsedGrammar(Grammar grammar, String nsURI, Set<Grammar> visitedGrammars) { if (!visitedGrammars.add(grammar)) return false; for(AbstractMetamodelDeclaration decl: grammar.getMetamodelDeclarations()) { EPackage pack = decl.getEPackage(); if (pack != null && nsURI.equals(pack.getNsURI())) { return true; } } for (Grammar usedGrammar: grammar.getUsedGrammars()) { if (isReferencedByUsedGrammar(usedGrammar, nsURI, visitedGrammars)) return true; } return false; }
public boolean isPackageReferenced(ResourceSet set, EPackage pack, Collection<AbstractMetamodelDeclaration> knownReferences) { for (int i = 0; i < set.getResources().size(); i++) { // cannot use foreach since we may get // a CME due to proxy resolution and transparent // loading of resources Resource resource = set.getResources().get(i); if (resource != null) { for (EObject content : resource.getContents()) { if (content instanceof Grammar) { for (AbstractMetamodelDeclaration decl : ((Grammar) content).getMetamodelDeclarations()) { if (pack.equals(decl.getEPackage()) && !knownReferences.contains(decl)) return true; } } } } } return false; }
protected IScope createScope(final Grammar grammar, EClass type) { if (EcorePackage.Literals.EPACKAGE == type) { return createEPackageScope(grammar); } else if (AbstractMetamodelDeclaration.class.isAssignableFrom(type.getInstanceClass())) { return new SimpleScope(IScope.NULLSCOPE,Iterables.transform(grammar.getMetamodelDeclarations(), new Function<AbstractMetamodelDeclaration,IEObjectDescription>(){ public IEObjectDescription apply(AbstractMetamodelDeclaration from) { String name = from.getAlias() != null ? from.getAlias() : ""; return EObjectDescription.create(QualifiedName.create(name), from); } })); } final List<Grammar> allGrammars = getAllGrammars(grammar); IScope current = IScope.NULLSCOPE; for (int i = allGrammars.size() - 1; i >= 0; i--) { current = createScope(allGrammars.get(i), type, current); } return current; }
public AbstractMetamodelDeclaration findMetamodel(Grammar grammar, String alias, String containedClassifier) { final List<AbstractMetamodelDeclaration> declarations = grammar.getMetamodelDeclarations(); AbstractMetamodelDeclaration result = null; for (AbstractMetamodelDeclaration decl : declarations) { if (isSameAlias(decl.getAlias(), alias)) { EPackage pack = decl.getEPackage(); if (pack != null && pack.getEClassifier(containedClassifier) != null) { if (result != null) return null; result = decl; } } } return result; }
private EClassifierInfos createClassifierInfosFor(Grammar grammar, Set<Grammar> visitedGrammars) { if (!visitedGrammars.add(grammar)) return null; final EClassifierInfos result = new EClassifierInfos(grammar); for(AbstractMetamodelDeclaration declaration: grammar.getMetamodelDeclarations()) { final EPackage referencedEPackage = declaration.getEPackage(); if (referencedEPackage != null) { collectClassInfosOf(result, referencedEPackage, declaration, false); } } for(Grammar usedGrammar: grammar.getUsedGrammars()) { EClassifierInfos parent = createClassifierInfosFor(usedGrammar, visitedGrammars); if (parent != null) result.addParent(parent); } return result; }
@Check public void checkMetamodelUris(final AbstractMetamodelDeclaration declaration) { if (!(declaration.getEPackage()!=null && declaration.getEPackage().getNsURI() != null)) return; Grammar grammar = GrammarUtil.getGrammar(declaration); Iterable<String> nsUris = Iterables.transform(grammar.getMetamodelDeclarations(), new Function<AbstractMetamodelDeclaration, String>() { public String apply(AbstractMetamodelDeclaration param) { if (param.getEPackage() != null) return param.getEPackage().getNsURI(); return null; } }); int count = Iterables.size(Iterables.filter(nsUris, new Predicate<String>() { public boolean apply(String param) { return declaration.getEPackage().getNsURI().equals(param); } })); if (count != 1) { error( "EPackage with ns-uri '" + declaration.getEPackage().getNsURI() + "' is used twice.", XtextPackage.Literals.ABSTRACT_METAMODEL_DECLARATION__EPACKAGE); } }
@Override protected void checkConfigurationInternal(final Issues issues) { this.initialize(); final MweIssues generatorIssues = new MweIssues(this, issues); this.configuration.checkConfiguration(generatorIssues); final HashMap<String, Grammar> uris = new HashMap<String, Grammar>(); for (final XtextGeneratorLanguage language : this.languageConfigs) { { language.checkConfiguration(generatorIssues); Iterable<GeneratedMetamodel> _filter = Iterables.<GeneratedMetamodel>filter(language.getGrammar().getMetamodelDeclarations(), GeneratedMetamodel.class); for (final GeneratedMetamodel generatedMetamodel : _filter) { { final String nsURI = generatedMetamodel.getEPackage().getNsURI(); boolean _containsKey = uris.containsKey(nsURI); if (_containsKey) { String _name = uris.get(nsURI).getName(); String _plus = ((("Duplicate generated grammar with nsURI \'" + nsURI) + "\' in ") + _name); String _plus_1 = (_plus + " and "); String _name_1 = language.getGrammar().getName(); String _plus_2 = (_plus_1 + _name_1); generatorIssues.addError(_plus_2); } else { uris.put(nsURI, language.getGrammar()); } } } } } }
EList<AbstractMetamodelDeclaration> _metamodelDeclarations = grammar.getMetamodelDeclarations(); for (final AbstractMetamodelDeclaration metamodelDecl : _metamodelDeclarations) {
void discardGeneratedPackages(EObject root) { if (root instanceof Grammar) { // unload generated metamodels as they will be recreated during linking for (AbstractMetamodelDeclaration metamodelDeclaration : ((Grammar) root).getMetamodelDeclarations()) { if (metamodelDeclaration instanceof GeneratedMetamodel) { EPackage ePackage = ((GeneratedMetamodel) metamodelDeclaration).getEPackage(); if (ePackage != null) { Resource resource = ePackage.eResource(); if (resource != null && resource.getResourceSet() != null) { if (unloader != null) { for (EObject content : resource.getContents()) { unloader.unloadRoot(content); } } resource.getResourceSet().getResources().remove(resource); } } } } } }
private void collectEPackages() { final List<AbstractMetamodelDeclaration> metamodelDeclarations = grammar.getMetamodelDeclarations(); final Map<String, GeneratedMetamodel> generateUs = Maps.newLinkedHashMap();
private TypeRef getOrComputeReturnType(AbstractRule rule) { TypeRef result = rule.getType(); if (result == null) { EClassifier classifier = getClassifierFor(rule); if (classifier == null) { if (rule.getName() == null) return null; result = getTypeRef(rule.getName()); } else result = getTypeRef(classifier); if (result.getMetamodel() == null) { AbstractMetamodelDeclaration bestMatch = null; for (AbstractMetamodelDeclaration decl : grammar.getMetamodelDeclarations()) { if (decl instanceof GeneratedMetamodel && Strings.isEmpty(decl.getAlias())) { bestMatch = decl; break; } } if (result.getMetamodel() == null) result.setMetamodel(bestMatch); } rule.setType(result); } return result; }