@Override public Pair<Boolean, Boolean> caseAction(Action object) { return Tuples.create(true, true); }
protected Pair<String, String> splitQualifiedName(String name) { String simpleName = name; String packageName = null; final int dotIdx = name.lastIndexOf('.'); if (dotIdx != -1) { simpleName = name.substring(dotIdx + 1); packageName = name.substring(0, dotIdx); } Pair<String,String> fullName = Tuples.create(packageName, simpleName); return fullName; }
public Pda<ISerState, RuleCall> getContextTypePDA(EObject context, EClass type) { Pair<EObject, EClass> key = Tuples.create(context, type); Pda<ISerState, RuleCall> result = cache.get(key); if (result == null) cache.put(key, result = createPDA(context, type)); return result; }
public Pair<Integer, RuleCall> findTopmostRuleCall(Predicate<RuleCall> predicate) { for (int i = ruleCallStack.size() - 1; i >= 0; i--) if (predicate.apply((RuleCall) ruleCallStack.get(i).getGrammarElement())) return Tuples.create(i, (RuleCall) ruleCallStack.get(i).getGrammarElement()); return null; }
public Pair<URI, Integer> apply(URI uri) { IResourceServiceProvider serviceProvider = registry.getResourceServiceProvider(uri); if (serviceProvider != null) { IndexingPriorityProvider priorityProvider = serviceProvider.get(IndexingPriorityProvider.class); if (priorityProvider != null) return Tuples.create(uri, priorityProvider.getIndexingPriority(resourceSet, uri)); } return Tuples.create(uri, 0); } }));
public void consume(Diagnostic diagnostic) { final Pair<Integer, Integer> newRange = Tuples.create(diagnostic.getOffset(), diagnostic.getLength()); if (coveredNodes.add(newRange)) { boolean changed = this.diagnostics.add(diagnostic); diagnosticsConsumed |= changed; } }
@Override public void acceptInfo(String message, EObject object, EStructuralFeature feature, int index, String code, String... issueData) { if (accepted.add(Tuples.create(object, feature, message))) { XtextValidator.this.getMessageAcceptor().acceptInfo(message, object, feature, index, code, issueData); } }
@Override public void acceptWarning(String message, EObject object, EStructuralFeature feature, int index, String code, String... issueData) { if (accepted.add(Tuples.create(object, feature, message))) { XtextValidator.this.getMessageAcceptor().acceptWarning(message, object, feature, index, code, issueData); } }
protected List<ImportNormalizer> getImportedNamespaceResolvers(final EObject context, final boolean ignoreCase) { return cache.get(Tuples.create(context, ignoreCase, "imports"), context.eResource(), new Provider<List<ImportNormalizer>>() { public List<ImportNormalizer> get() { return internalGetImportedNamespaceResolvers(context, ignoreCase); } }); }
@Nullable public ITrace getTraceToSource(final ITypeRoot derivedJavaType) { if (lruCache != null && lruCache.getFirst().equals(derivedJavaType)) return lruCache.getSecond(); ITrace trace = createTraceToSource(derivedJavaType); lruCache = Tuples.<ITypeRoot, ITrace> create(derivedJavaType, trace); return trace; }
public Pair<AbstractRule, String> getSpaces(LineEntry entry, boolean isLineStart) { String space = getSpacesStr(entry, isLineStart); if (space == null) return null; AbstractRule rule = hiddenTokenHelper.getWhitespaceRuleFor(entry.hiddenTokenDefinition, space); if (rule == null) return null; return Tuples.create(rule, space); }
protected List<ImportNormalizer> getImportedNamespaceResolvers(final EObject context, final boolean ignoreCase) { return cache.get(Tuples.create(context, ignoreCase, "imports"), context.eResource(), new Provider<List<ImportNormalizer>>() { @Override public List<ImportNormalizer> get() { return internalGetImportedNamespaceResolvers(context, ignoreCase); } }); }
protected List<ImportNormalizer> getImportedNamespaceResolvers(final EObject context, final boolean ignoreCase) { return cache.get(Tuples.create(context, ignoreCase, "imports"), context.eResource(), new Provider<List<ImportNormalizer>>() { @Override public List<ImportNormalizer> get() { return internalGetImportedNamespaceResolvers(context, ignoreCase); } }); }
protected void indexFeatures(JvmDeclaredType type, Multimap<Triple<EClass, String, Integer>, JvmFeature> index) { for (JvmMember member : type.getMembers()) { if (member instanceof JvmExecutable) { Triple<EClass, String, Integer> key = Tuples.create(member.eClass(), member.getSimpleName(), ((JvmExecutable) member).getParameters().size()); index.put(key, (JvmFeature) member); } else if (member instanceof JvmField) { Triple<EClass, String, Integer> key = Tuples.create(member.eClass(), member.getSimpleName(), -1); index.put(key, (JvmFeature) member); } } }
public List<Pair<IFeatureInfo, RelationalDependencyType>> getDependingFeatures() { if (dependingFeatures == null) { dependingFeatures = Lists.newArrayList(); for (Pair<IConstraintElement, RelationalDependencyType> p : getRelationalAssignemntConstraintIntersection()) dependingFeatures.add(Tuples.create(p.getFirst().getFeatureInfo(), p.getSecond())); } return dependingFeatures; }
protected boolean isValueValid(ISemState state, int index, Object value) { if (state.getToBeValidatedAssignedElements().isEmpty()) return true; Pair<AbstractElement, Integer> key = Tuples.create(state.getAssignedGrammarElement(), index); if (valid.get(key) == Boolean.TRUE) return true; Set<AbstractElement> validAssignments = Sets.newHashSet(assignmentFinder.findAssignmentsByValue(eObject, state.getToBeValidatedAssignedElements(), value, getNode(state.getFeatureID(), index))); boolean result = validAssignments.contains(state.getAssignedGrammarElement()); valid.put(key, result); return result; }
protected Pair<URI, IXtextDocument> getEntry(IWorkbenchPartReference partRef) { IWorkbenchPart part = partRef.getPart(false); if (part instanceof XtextEditor) { XtextEditor xtextEditor = (XtextEditor) part; URI resourceURI = getResourceURI(xtextEditor); IXtextDocument document = xtextEditor.getDocument(); if (resourceURI != null && document != null) return Tuples.create(resourceURI, document); } return null; }
protected void initConstraints() { if (constraintContexts == null) { constraints = Maps.newHashMap(); constraintContexts = grammarConstraintProvider.getConstraints(grammar.getGrammar()); // System.out.println(Joiner.on("\n").join(constraintContexts)); for (IConstraintContext ctx : constraintContexts) for (IConstraint constraint : ctx.getConstraints()) constraints.put(Tuples.create(ctx.getContext(), constraint.getType()), constraint); } }
@Override public Pair<Boolean, Boolean> caseAlternatives(Alternatives object) { boolean valid = true; boolean instantiated = !GrammarUtil.isOptionalCardinality(object); for(AbstractElement element: object.getElements()) { Pair<Boolean, Boolean> elementResult = doSwitch(element); valid &= elementResult.getFirst().booleanValue(); instantiated &= elementResult.getSecond().booleanValue(); } return Tuples.create(valid, instantiated); }
protected void initConstraints() { if (constraintContexts == null) { constraints = Maps.newHashMap(); constraintContexts = grammarConstraintProvider.getConstraints(grammarAccess.getGrammar()); // System.out.println(Joiner.on("\n").join(constraintContexts)); for (IConstraintContext ctx : constraintContexts) for (IConstraint constraint : ctx.getConstraints()) constraints.put(Tuples.create(ctx.getContext(), constraint.getType()), constraint); } }