public String getAssignmentName() { if (type != ConstraintType.ASSIGNMENT) throw new RuntimeException("Constraint '" + this + "' is not an assignment, but a " + getType()); return ((Assignment) element).getFeature(); }
@Override public Void caseAssignment(Assignment object) { if (object.getTerminal() != null) return doSwitch(object.getTerminal()); return null; }
protected String addAssignemnt(String result, AbstractElement ele) { if (!showAssignment) return result; Assignment ass = GrammarUtil.containingAssignment(ele); result = ass != null ? ass.getFeature() + ass.getOperator() + result : result; return addQualified(result, ele); }
protected boolean _predicated(final Assignment it) { return (it.isPredicated() || this.predicated(it.getTerminal())); }
protected boolean _mustBeParenthesized(final Assignment it) { return ((this._grammarAccessExtensions.predicated(it) || it.isFirstSetPredicated()) || this.mustBeParenthesized(it.getTerminal())); }
String _feature = it.getFeature(); String _feature_1 = assignment.getFeature(); return Boolean.valueOf(Objects.equal(_feature, _feature_1)); }; final Function1<Assignment, AbstractElement> _function_1 = (Assignment it) -> { return it.getTerminal(); }; final List<AbstractElement> terminals = IterableExtensions.<AbstractElement>toList(IterableExtensions.<Assignment, AbstractElement>map(IterableExtensions.<Assignment>filter(GrammarUtil.containedAssignments(GrammarUtil.containingParserRule(assignment)), _function), _function_1));
public String setOrAdd(final Assignment it) { String _xifexpression = null; String _operator = it.getOperator(); boolean _equals = Objects.equal(_operator, "+="); if (_equals) { _xifexpression = "add"; } else { _xifexpression = "set"; } return _xifexpression; }
protected boolean shouldUseParent(ICompositeNode result, int offset, ILeafNode leaf) { if (leaf.getTotalEndOffset() == offset) { return true; } if (result.getGrammarElement() instanceof RuleCall) { RuleCall rc = (RuleCall) result.getGrammarElement(); if (!rc.getArguments().isEmpty()) { return true; } Assignment assignment = GrammarUtil.containingAssignment(rc); if (assignment != null && (GrammarUtil.isMultipleCardinality(assignment) || (assignment.eContainer() instanceof AbstractElement && GrammarUtil .isMultipleCardinality((AbstractElement) assignment.eContainer())))) { return true; } } return false; }
protected void _createProposals(final Assignment assignment, final ContentAssistContext context, final IIdeContentProposalAcceptor acceptor) { final AbstractElement terminal = assignment.getTerminal(); if ((terminal instanceof CrossReference)) { this.createProposals(terminal, context, acceptor); boolean _equals = Objects.equal(_name, "STRING"); if (_equals) { String _feature = assignment.getFeature(); String _plus = ("\"" + _feature); _xifexpression = (_plus + "\""); } else { _xifexpression = assignment.getFeature();
public static boolean isBooleanAssignment(Assignment a) { return "?=".equals(a.getOperator()); }
private String getAssignedFeature(RuleCall call) { Assignment ass = GrammarUtil.containingAssignment(call); if (ass != null) { String result = ass.getFeature(); if (result.equals(result.toLowerCase())) result = Strings.toFirstUpper(result); return result; } return null; }
public void completeCodetemplate_KeywordContext(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } public void completeCodetemplate_Body(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
public void addFeature(Assignment assignment) throws TransformationException { final String featureName = assignment.getFeature(); boolean isMultivalue = GrammarUtil.isMultipleAssignment(assignment); boolean isContainment = true; EClassifierInfo featureTypeInfo; if (GrammarUtil.isBooleanAssignment(assignment)) { EDataType eBoolean = GrammarUtil.findEBoolean(GrammarUtil.getGrammar(assignment)); featureTypeInfo = getEClassifierInfoOrThrowException(eBoolean, assignment); isMultivalue = false; } else { AbstractElement terminal = assignment.getTerminal(); if (terminal == null) { throw new TransformationException(TransformationErrorCode.NoSuchTypeAvailable, "Cannot derive type from incomplete assignment.", assignment); } EClassifier type = getTerminalType(terminal); isContainment = isContainmentAssignment(assignment); featureTypeInfo = getEClassifierInfoOrThrowException(type, assignment); } addFeature(featureName, featureTypeInfo, isMultivalue, isContainment, assignment); }
@Override public String caseAssignment(Assignment object) { String result = object.getFeature() + object.getOperator() + " " + card(object); return addQualified(result, object); }
public static boolean isSingleAssignment(Assignment a) { return "=".equals(a.getOperator()); }
private String getAssignedFeature(RuleCall call) { Assignment ass = GrammarUtil.containingAssignment(call); if (ass != null) { String result = ass.getFeature(); if (result.equals(result.toLowerCase())) result = Strings.toFirstUpper(result); return result; } return null; }
public void completeVariable_Name(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); } public void completeVariable_Type(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
public void completeNestedAssignment(Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { String proposalText = "${" + assignment.getFeature() + "}"; StyledString displayText; if (assignment.getTerminal() instanceof RuleCall) { RuleCall ruleCall = (RuleCall) assignment.getTerminal(); AbstractRule calledRule = ruleCall.getRule(); displayText = new StyledString("${", StyledString.DECORATIONS_STYLER) .append(assignment.getFeature(), null) .append("}", StyledString.DECORATIONS_STYLER) .append(" - ", StyledString.QUALIFIER_STYLER) .append(calledRule.getName(), StyledString.COUNTER_STYLER) .append(" - Create a new template variable", StyledString.QUALIFIER_STYLER); } else { displayText = new StyledString("${", StyledString.DECORATIONS_STYLER) .append(assignment.getFeature(), null) .append("}", StyledString.DECORATIONS_STYLER) .append(" - Create a new template variable", StyledString.QUALIFIER_STYLER); } ICompletionProposal proposal = createCompletionProposal(proposalText, displayText, null, context); if (proposal instanceof ConfigurableCompletionProposal) { ConfigurableCompletionProposal configurable = (ConfigurableCompletionProposal) proposal; configurable.setSelectionStart(configurable.getReplacementOffset() + 2); configurable.setSelectionLength(proposalText.length() - 3); configurable.setAutoInsertable(false); configurable.setSimpleLinkedMode(context.getViewer(), '\t'); configurable.setPriority(configurable.getPriority() * 2); } acceptor.accept(proposal); }
public static boolean isMultipleAssignment(Assignment a) { return "+=".equals(a.getOperator()); }
public String localVar(final Assignment it, final AbstractElement terminal) { String _feature = it.getFeature(); String _plus = ("lv_" + _feature); String _plus_1 = (_plus + "_"); int _indexOf = this.contentsAsList(GrammarUtil.containingParserRule(it)).indexOf(it); String _plus_2 = (_plus_1 + Integer.valueOf(_indexOf)); String _plus_3 = (_plus_2 + "_"); int _indexOf_1 = EcoreUtil2.eAllContentsAsList(it).indexOf(terminal); return (_plus_3 + Integer.valueOf(_indexOf_1)); }