/** * Creates a mutable {@link Set} instance containing the given initial elements. * * @param elements * the initial elements that the set should contain, in order. May not be <code>null</code> but may * contain <code>null</code> values. * @return a new {@link Set} containing those elements */ public static <T> Set<T> set(T... elements){ return newHashSet(elements); }
public Set<ComponentType> getTypes(final Component component) { final HashSet<ComponentType> result = CollectionLiterals.<ComponentType>newHashSet(); this.collectTypes(component, result); return result; }
/** * check that all variables are used according to their actual type (transitively in their fixture) */ private void checkAllReferencedVariablesAreUsedWellTyped(final TestStepContext ctx, final Map<String, JvmTypeReference> declaredVariablesTypeMap) { this.checkReferencedVariablesAreUsedWellTypedExcluding(ctx, declaredVariablesTypeMap, Collections.<String>unmodifiableSet(CollectionLiterals.<String>newHashSet())); }
/** * Returns an inferred class with a predefined <em>direct</em> subtype */ public JvmType findInferredClass(final EObject pattern, final Class<?> clazz) { return this.findInferredClass(pattern, ((Class<?>[])Conversions.unwrapArray(Collections.<Class<?>>unmodifiableSet(CollectionLiterals.<Class<?>>newHashSet(clazz)), Class.class))); }
protected Object getAttribute(final URI uri, final String attributeName) { Object _xblockexpression = null; { if ((uri == null)) { return null; } final HashMap<String, Set<String>> options = CollectionLiterals.<String, Set<String>>newHashMap(); options.put(URIConverter.OPTION_REQUESTED_ATTRIBUTES, Collections.<String>unmodifiableSet(CollectionLiterals.<String>newHashSet(attributeName))); _xblockexpression = this.getURIConverter().getAttributes(uri, options).get(attributeName); } return _xblockexpression; }
public Object evaluate(final XExpression it) { HashSet<XExpression> _newHashSet = CollectionLiterals.<XExpression>newHashSet(); Context _context = new Context(null, null, null, _newHashSet); return this.evaluate(it, _context); }
public Object evaluate(final XExpression it, final boolean validationMode) { Object _xblockexpression = null; { HashSet<XExpression> _newHashSet = CollectionLiterals.<XExpression>newHashSet(); final SwitchConstantExpressionsInterpreter.SwitchContext ctx = new SwitchConstantExpressionsInterpreter.SwitchContext(null, null, null, _newHashSet); ctx.validationMode = validationMode; _xblockexpression = this.evaluate(it, ctx); } return _xblockexpression; }
protected GraphvizDotBuilder.Digraph drawGrammar(final ISyntacticSequencerPDAProvider.ISynState pr) { final GraphvizDotBuilder.Digraph d = new GraphvizDotBuilder.Digraph(); final Set<ISyntacticSequencerPDAProvider.ISynState> visited = CollectionLiterals.<ISyntacticSequencerPDAProvider.ISynState>newHashSet(); this.drawState(d, pr, visited); return d; }
public Set<TemplateVariable> getEnclosingMacroParameters(final EObject object) { final Macro container = EcoreUtil2.<Macro>getContainerOfType(object, Macro.class); if ((container != null)) { return this.amlModelUtil.getReferenceableVariables(container.getTemplate()); } return Collections.<TemplateVariable>unmodifiableSet(CollectionLiterals.<TemplateVariable>newHashSet()); }
public Iterable<EnvironmentVariable> getEnvParams(final EObject object) { final TclModel root = EcoreUtil2.<TclModel>getContainerOfType(object, TclModel.class); if (((root != null) && (root.getEnvironmentVariables() != null))) { return root.getEnvironmentVariables(); } return Collections.<EnvironmentVariable>unmodifiableSet(CollectionLiterals.<EnvironmentVariable>newHashSet()); }
public String getURIFragment(final EClassifier classifier) { EPackage _eSuperPackage = classifier.getEPackage().getESuperPackage(); boolean _tripleNotEquals = (_eSuperPackage != null); if (_tripleNotEquals) { final StringBuilder result = new StringBuilder(60); this.calculateURIFragment(classifier.getEPackage(), result, CollectionLiterals.<EPackage>newHashSet()); result.append(classifier.getName()); return result.toString(); } return null; }
public Set<ISyntacticSequencerPDAProvider.ISynTransition> getAllAmbiguousTransitions() { final Set<ISyntacticSequencerPDAProvider.ISynTransition> result = CollectionLiterals.<ISyntacticSequencerPDAProvider.ISynTransition>newLinkedHashSet(); List<ISyntacticSequencerPDAProvider.ISynAbsorberState> _allPDAs = this.getAllPDAs(); for (final ISyntacticSequencerPDAProvider.ISynAbsorberState start : _allPDAs) { this.collectAllAmbiguousTransitions(start, result, CollectionLiterals.<Object>newHashSet()); } return result; }
@Override public void apply(final Contact it) { it.setMoniker("Stefan Oehme"); it.setRoles(Collections.<String>unmodifiableSet(CollectionLiterals.<String>newHashSet("owner"))); it.setGithub("oehme"); it.setTwitter("StefanOehme"); } };
public XtextBracePairProvider() { super( Collections.<BracePair>unmodifiableSet(CollectionLiterals.<BracePair>newHashSet(new BracePair(":", ";", true), new BracePair("(", ")", false), new BracePair("{", "}", true), new BracePair("[", "]", false)))); } }
public boolean usesXImportSection(final Grammar grammar) { final Set<AbstractRule> usedRules = CollectionLiterals.<AbstractRule>newHashSet(); new UsedRulesFinder(usedRules).compute(grammar); final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf((Objects.equal(it.getName(), "XImportSection") && Objects.equal(GrammarUtil.getGrammar(it).getName(), "org.eclipse.xtext.xbase.Xtype"))); }; return IterableExtensions.<AbstractRule>exists(usedRules, _function); } }
protected void withOutputConfig(final BuildRequest it, final Procedure1<? super OutputConfiguration> init) { Set<OutputConfiguration> _outputConfigurations = this.configurationProvider.getOutputConfigurations(); final OutputConfiguration config = IterableExtensions.<OutputConfiguration>head(_outputConfigurations); init.apply(config); Pair<String, Set<OutputConfiguration>> _mappedTo = Pair.<String, Set<OutputConfiguration>>of(this.languageName, Collections.<OutputConfiguration>unmodifiableSet(CollectionLiterals.<OutputConfiguration>newHashSet(config))); final OutputConfigurationAdapter adapter = new OutputConfigurationAdapter(Collections.<String, Set<OutputConfiguration>>unmodifiableMap(CollectionLiterals.<String, Set<OutputConfiguration>>newHashMap(_mappedTo))); XtextResourceSet _resourceSet = it.getResourceSet(); EList<Adapter> _eAdapters = _resourceSet.eAdapters(); _eAdapters.add(adapter); }
protected List<AbstractRule> getExportedRulesFromGrammar() { List<AbstractRule> _xblockexpression = null; { final HashSet<EClassifier> alreadyCollected = CollectionLiterals.<EClassifier>newHashSet(); final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf((this.isExported(it) && alreadyCollected.add(it.getType().getClassifier()))); }; _xblockexpression = IterableExtensions.<AbstractRule>toList(IterableExtensions.<AbstractRule>filter(this.getGrammar().getRules(), _function)); } return _xblockexpression; }
/** * @since 2.14 */ protected List<AbstractRule> getDeprecatedRulesFromGrammar() { final HashSet<EClassifier> alreadyCollected = CollectionLiterals.<EClassifier>newHashSet(); final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf((this.isDeprecated(it) && alreadyCollected.add(it.getType().getClassifier()))); }; return IterableExtensions.<AbstractRule>toList(IterableExtensions.<AbstractRule>filter(this.getGrammar().getRules(), _function)); }
protected String elementAliasToIdentifier(final GrammarAlias.AbstractElementAlias alias) { final Set<String> rulesSet = CollectionLiterals.<String>newHashSet(); final String body = this.elementAliasToIdentifier(alias, rulesSet, false); final List<String> rulesList = CollectionLiterals.<String>newArrayList(((String[])Conversions.unwrapArray(rulesSet, String.class))); ListExtensions.<String>sortInplace(rulesList); final String rule = IterableExtensions.join(rulesList, "_"); return ((rule + "_") + body); } }
private Iterable<EClassTransitiveInstancesKey> minimizeEClassKeyList(final Iterable<EClassTransitiveInstancesKey> types, final boolean mergeWithSupertypes) { final Function1<EClassTransitiveInstancesKey, EClass> _function = (EClassTransitiveInstancesKey it) -> { return it.getEmfKey(); }; final HashSet<EClass> emfTypes = CollectionLiterals.<EClass>newHashSet(((EClass[])Conversions.unwrapArray(IterableExtensions.<EClassTransitiveInstancesKey, EClass>map(types, _function), EClass.class))); final Function1<EClass, EClassTransitiveInstancesKey> _function_1 = (EClass it) -> { return new EClassTransitiveInstancesKey(it); }; return IterableExtensions.<EClass, EClassTransitiveInstancesKey>map(this.minimizeEClassList(emfTypes, mergeWithSupertypes), _function_1); }