org.eclipse.xtext.EnumLiteralDeclaration Java Examples

@Override
public ISerializationDiagnostic getInvalidEnumValueDiagnostic(EObject semanticObject, RuleCall rc, Object value) {
	List<String> valid = Lists.newArrayList();
	for (EnumLiteralDeclaration eld : org.eclipse.xtext.EcoreUtil2.getAllContentsOfType(rc.getRule(),
			EnumLiteralDeclaration.class))
		valid.add(eld.getEnumLiteral().getInstance().getName());
	StringBuilder msg = new StringBuilder();
	msg.append("The value '" + value + "' is invalid for enum " + rc.getRule().getName() + "\n");
	msg.append("Valid values are: " + Joiner.on(", ").join(valid));
	return new SerializationDiagnostic(INVALID_ENUM_VALUE, semanticObject, rc, grammarAccess.getGrammar(), msg.toString());
}
 

StyledString text(EnumLiteralDeclaration object) {
	String literalName = getLiteralName(object);
	Keyword kw = object.getLiteral();
	String kwValue = kw == null ? "" : " = '" + kw.getValue() + "'";
	return new StyledString(literalName + kwValue, UNKNOWN.equalsIgnoreCase(literalName) ? stylerFactory.createStyler(
			JFacePreferences.ERROR_COLOR, null) : null);
}
 

@Override
public int consumeEnum(EnumLiteralDeclaration literal, ICharacterClass notFollowedBy) {
	if (log.isDebugEnabled()) {
		log.debug("consumeEnum(enum = '" + literal.getEnumLiteral().getName() + "', " +
				"literal = " + literal.getLiteral() + ")");
	}
	int result = delegate.consumeEnum(literal, notFollowedBy);
	if (log.isDebugEnabled()) {
		log.debug("consumeKeyword('" + literal.getLiteral() + "') = " + result);
	}
	return result;
}
 

@Test public void testEnum_04() throws Exception {
	String modelAsString =
		"grammar TestLanguage with org.eclipse.xtext.common.Terminals\n" +
		"import 'classpath:/org/eclipse/xtext/enumrules/enums.ecore'\n" +
		"generate testLanguage 'http://www.eclipse.org/2009/tmf/xtext/AbstractEnumRulesTest/TestEnum/4'\n" +
		"Model: enumValue=ExistingEnum;\n" +
		"enum ExistingEnum: SameName;";
	Grammar grammar = (Grammar) getModel(modelAsString);
	assertTrue(grammar.eResource().getErrors().toString(), grammar.eResource().getErrors().isEmpty());
	checkEnums(grammar);
	EPackage pack = grammar.getMetamodelDeclarations().get(0).getEPackage();
	assertEquals("http://www.eclipse.org/2009/tmf/xtext/EnumRulesTestLanguage/imported", pack.getNsURI());
	EEnum eEnum = (EEnum) pack.getEClassifier("ExistingEnum");
	assertNotNull(eEnum);
	assertEquals(3, eEnum.getELiterals().size());
	EEnumLiteral value = eEnum.getELiterals().get(0);
	assertEquals(ExistingEnum.SAME_NAME.getName(), value.getName());
	assertEquals(ExistingEnum.SAME_NAME.getValue(), value.getValue());
	assertEquals(ExistingEnum.SAME_NAME.getLiteral(), value.getLiteral());
	
	EnumRule rule = (EnumRule) grammar.getRules().get(1);
	assertEquals(eEnum, rule.getType().getClassifier());
	EnumLiteralDeclaration decl = (EnumLiteralDeclaration) rule.getAlternatives();
	assertEquals(value, decl.getEnumLiteral());
	assertNotNull(decl.getLiteral());
	assertEquals(value.getLiteral(), decl.getLiteral().getValue());
}
 

@Fix(EMPTY_ENUM_LITERAL)
public void fixEmptyEnumLiteral(final Issue issue, IssueResolutionAcceptor acceptor) {
	acceptor.acceptMulti(issue, "Fix empty enum literal", "Fix empty enum literal", NULL_QUICKFIX_IMAGE,
			(EObject element) -> {
				EnumLiteralDeclaration enumLiteralDeclaration = (EnumLiteralDeclaration) element;
				Keyword keyword = XtextFactory.eINSTANCE.createKeyword();
				keyword.setValue(enumLiteralDeclaration.getEnumLiteral().getName().toLowerCase());
				enumLiteralDeclaration.setLiteral(keyword);
			});
}
 

@Test public void testEnum_10() throws Exception {
	String modelAsString =
		"grammar TestLanguage with org.eclipse.xtext.enumrules.EnumRulesTestLanguage\n" +
		"import 'classpath:/org/eclipse/xtext/enumrules/enums.ecore'\n" +
		"generate testLanguage 'http://www.eclipse.org/2009/tmf/xtext/AbstractEnumRulesTest/TestEnum/10'\n" +
		"Model: enumValue=ExistingEnum;\n" +
		"enum ExistingEnum: SameName;";
	Grammar grammar = (Grammar) getModel(modelAsString);
	assertTrue(grammar.eResource().getErrors().toString(), grammar.eResource().getErrors().isEmpty());
	checkEnums(grammar);
	EPackage pack = grammar.getMetamodelDeclarations().get(0).getEPackage();
	assertEquals("http://www.eclipse.org/2009/tmf/xtext/EnumRulesTestLanguage/imported", pack.getNsURI());
	EEnum eEnum = (EEnum) pack.getEClassifier("ExistingEnum");
	assertNotNull(eEnum);
	assertEquals(3, eEnum.getELiterals().size());
	EEnumLiteral value = eEnum.getELiterals().get(0);
	assertEquals(ExistingEnum.SAME_NAME.getName(), value.getName());
	assertEquals(ExistingEnum.SAME_NAME.getValue(), value.getValue());
	assertEquals(ExistingEnum.SAME_NAME.getLiteral(), value.getLiteral());
	
	EnumRule rule = (EnumRule) grammar.getRules().get(1);
	assertEquals(eEnum, rule.getType().getClassifier());
	EnumLiteralDeclaration decl = (EnumLiteralDeclaration) rule.getAlternatives();
	assertEquals(value, decl.getEnumLiteral());
	assertNotNull(decl.getLiteral());
	assertEquals("SameName", decl.getLiteral().getValue());
}
 

protected Keyword getLiteral(INode node) {
	if (node != null) {
		for(ILeafNode leaf: node.getLeafNodes()) {
			if (leaf.getGrammarElement() instanceof EnumLiteralDeclaration)
				return ((EnumLiteralDeclaration) leaf.getGrammarElement()).getLiteral();
		}
	}
	return null;
}
 

@Override
protected String _ebnf2(final EnumLiteralDeclaration it, final AntlrOptions options, final boolean supportActions) {
  String _xifexpression = null;
  if ((!supportActions)) {
    _xifexpression = super._ebnf2(it, options, supportActions);
  } else {
    StringConcatenation _builder = new StringConcatenation();
    String _localVar = this._grammarAccessExtensions.localVar(it);
    _builder.append(_localVar);
    _builder.append("=");
    String __ebnf2 = super._ebnf2(it, options, supportActions);
    _builder.append(__ebnf2);
    _builder.newLineIfNotEmpty();
    _builder.append("{");
    _builder.newLine();
    _builder.append("\t");
    _builder.append("$current = grammarAccess.");
    String _grammarElementAccess = this._grammarAccessExtensions.grammarElementAccess(AntlrGrammarGenUtil.<EnumLiteralDeclaration>getOriginalElement(it));
    _builder.append(_grammarElementAccess, "\t");
    _builder.append(".getEnumLiteral().getInstance();");
    _builder.newLineIfNotEmpty();
    _builder.append("\t");
    CharSequence _newLeafNode = this.newLeafNode(it, this._grammarAccessExtensions.localVar(it));
    _builder.append(_newLeafNode, "\t");
    _builder.newLineIfNotEmpty();
    _builder.append("}");
    _builder.newLine();
    _xifexpression = _builder.toString();
  }
  return _xifexpression;
}
 

protected Keyword getLiteral(INode node) {
	if (node != null) {
		for (ILeafNode leaf : node.getLeafNodes()) {
			if (leaf.getGrammarElement() instanceof EnumLiteralDeclaration)
				return ((EnumLiteralDeclaration) leaf.getGrammarElement()).getLiteral();
		}
	}
	return null;
}
 

public ParsedEnumLiteral(int offset, int length, EnumLiteralDeclaration literal, IParsedTokenSource source, boolean optional) {
	super(offset, length, literal, source, optional);
}
 

protected ISegmentFigure transformInternal(EnumLiteralDeclaration enumLiteralDeclaration) {
	return factory.createNodeSegment(enumLiteralDeclaration);
}
 

@Override
public Boolean caseEnumLiteralDeclaration(EnumLiteralDeclaration object) {
	return doSwitch(object.getLiteral());
}
 

protected String _localVar(final EnumLiteralDeclaration it) {
  int _indexOf = this.contentsAsList(GrammarUtil.containingEnumRule(it).getAlternatives()).indexOf(it);
  return ("enumLiteral_" + Integer.valueOf(_indexOf));
}
 

@Override
public Boolean caseEnumLiteralDeclaration(EnumLiteralDeclaration object) {
	return doSwitch(object.getLiteral());
}
 

@Override
public int consumeEnum(EnumLiteralDeclaration literal, ICharacterClass notFollowedBy) {
	literalConsumer.configure(literal, notFollowedBy);
	return consumeTerminal(literalConsumer, null, false, false, literal, ISequenceMatcher.Factory.nullMatcher(), false);
}
 

public EnumLiteralDeclaration getPolygonEnumLiteralDeclaration_7() { return cPolygonEnumLiteralDeclaration_7; } 

public EnumLiteralDeclaration getNotEqualEnumLiteralDeclaration_5() { return cNotEqualEnumLiteralDeclaration_5; } 

public EnumLiteralDeclaration getEqualEnumLiteralDeclaration_0() { return cEqualEnumLiteralDeclaration_0; } 

public EnumLiteralDeclaration getLit1EnumLiteralDeclaration_0() { return cLit1EnumLiteralDeclaration_0; } 

public EnumLiteralDeclaration getValueEnumLiteralDeclaration() { return cValueEnumLiteralDeclaration; } 

public EnumLiteralDeclaration getRnastabEnumLiteralDeclaration_18() { return cRnastabEnumLiteralDeclaration_18; } 

public EnumLiteralDeclaration getRibositeEnumLiteralDeclaration_17() { return cRibositeEnumLiteralDeclaration_17; } 

public EnumLiteralDeclaration getLit2EnumLiteralDeclaration() { return cLit2EnumLiteralDeclaration; } 

public EnumLiteralDeclaration getRestrictionsiteEnumLiteralDeclaration_16() { return cRestrictionsiteEnumLiteralDeclaration_16; } 

public EnumLiteralDeclaration getRarrowEnumLiteralDeclaration_12() { return cRarrowEnumLiteralDeclaration_12; } 

public EnumLiteralDeclaration getLit3EnumLiteralDeclaration_2() { return cLit3EnumLiteralDeclaration_2; } 

public EnumLiteralDeclaration getPromoterEnumLiteralDeclaration_9() { return cPromoterEnumLiteralDeclaration_9; } 

public EnumLiteralDeclaration getProteasesiteEnumLiteralDeclaration_10() { return cProteasesiteEnumLiteralDeclaration_10; } 

public EnumLiteralDeclaration getBEnumLiteralDeclaration_1() { return cBEnumLiteralDeclaration_1; } 

public EnumLiteralDeclaration getRecordEnumLiteralDeclaration_13() { return cRecordEnumLiteralDeclaration_13; }