org.eclipse.xtend.lib.macro.declaration.AnnotationTypeDeclaration Java Examples

@Override
public AnnotationTypeDeclaration getAnnotationTypeDeclaration() {
  AnnotationTypeDeclaration _switchResult = null;
  JvmType _annotationType = this.getAnnotationType();
  final JvmType type = _annotationType;
  boolean _matched = false;
  if (type instanceof JvmAnnotationType) {
    _matched=true;
    TypeDeclaration _typeDeclaration = this.getCompilationUnit().toTypeDeclaration(((JvmDeclaredType)type));
    _switchResult = ((AnnotationTypeDeclaration) _typeDeclaration);
  }
  if (!_matched) {
    _switchResult = null;
  }
  return _switchResult;
}
 

private JvmOperation findOperation(final String name) {
  ConditionUtils.checkJavaIdentifier(name, "name");
  AnnotationTypeDeclaration _annotationTypeDeclaration = this.getAnnotationTypeDeclaration();
  final JvmAnnotationType jvmAnnoType = ((JvmAnnotationTypeDeclarationImpl) _annotationTypeDeclaration).getDelegate();
  final Function1<JvmOperation, Boolean> _function = (JvmOperation it) -> {
    String _simpleName = it.getSimpleName();
    return Boolean.valueOf(Objects.equal(_simpleName, name));
  };
  final JvmOperation jvmOperation = IterableExtensions.<JvmOperation>findFirst(jvmAnnoType.getDeclaredOperations(), _function);
  if ((jvmOperation == null)) {
    String _identifier = jvmAnnoType.getIdentifier();
    String _plus = ((("The annotation property \'" + name) + "\' is not declared on the annotation type \'") + _identifier);
    String _plus_1 = (_plus + "\'.");
    throw new IllegalArgumentException(_plus_1);
  }
  return jvmOperation;
}
 

protected void _internalSet(final String name, final AnnotationReference[] values, final boolean mustBeArray) {
  ConditionUtils.checkIterable(((Iterable<?>)Conversions.doWrapArray(values)), "values");
  AnnotationReference _head = IterableExtensions.<AnnotationReference>head(((Iterable<AnnotationReference>)Conversions.doWrapArray(values)));
  AnnotationTypeDeclaration _annotationTypeDeclaration = null;
  if (_head!=null) {
    _annotationTypeDeclaration=_head.getAnnotationTypeDeclaration();
  }
  String _qualifiedName = null;
  if (_annotationTypeDeclaration!=null) {
    _qualifiedName=_annotationTypeDeclaration.getQualifiedName();
  }
  this.setValues(name, values, _qualifiedName, mustBeArray);
}
 

@Test
public void testAnnotation() {
  StringConcatenation _builder = new StringConcatenation();
  _builder.append("@SuppressWarnings(\"unused\")");
  _builder.newLine();
  _builder.append("class MyClass {");
  _builder.newLine();
  _builder.append("\t");
  _builder.append("@com.google.inject.Inject(optional=true) MyClass foo");
  _builder.newLine();
  _builder.append("}");
  _builder.newLine();
  final Procedure1<CompilationUnitImpl> _function = (CompilationUnitImpl it) -> {
    Assert.assertNull(it.getPackageName());
    TypeDeclaration _head = IterableExtensions.head(it.getSourceTypeDeclarations());
    final ClassDeclaration clazz = ((ClassDeclaration) _head);
    Assert.assertEquals("MyClass", clazz.getQualifiedName());
    final AnnotationReference suppressWarning = IterableExtensions.head(clazz.getAnnotations());
    final AnnotationTypeDeclaration supressWarningsDeclaration = suppressWarning.getAnnotationTypeDeclaration();
    Assert.assertEquals("java.lang.SuppressWarnings", supressWarningsDeclaration.getQualifiedName());
    Assert.assertEquals("unused", suppressWarning.getStringArrayValue("value")[0]);
    Assert.assertEquals(2, IterableExtensions.size(supressWarningsDeclaration.getAnnotations()));
    final AnnotationTypeElementDeclaration valueProperty = IterableExtensions.<AnnotationTypeElementDeclaration>head(Iterables.<AnnotationTypeElementDeclaration>filter(supressWarningsDeclaration.getDeclaredMembers(), AnnotationTypeElementDeclaration.class));
    Assert.assertEquals("String[]", valueProperty.getType().toString());
    Assert.assertEquals("value", valueProperty.getSimpleName());
    MemberDeclaration _head_1 = IterableExtensions.head(clazz.getDeclaredMembers());
    final FieldDeclaration field = ((FieldDeclaration) _head_1);
    final AnnotationReference inject = IterableExtensions.head(field.getAnnotations());
    Object _value = inject.getValue("optional");
    Assert.assertTrue((((Boolean) _value)).booleanValue());
  };
  this.asCompilationUnit(this.validFile(_builder), _function);
}
 

public AnnotationReference findAnnotation(final Type annotationType) {
  final Function1<AnnotationReference, Boolean> _function = (AnnotationReference it) -> {
    AnnotationTypeDeclaration _annotationTypeDeclaration = it.getAnnotationTypeDeclaration();
    return Boolean.valueOf(Objects.equal(_annotationTypeDeclaration, annotationType));
  };
  return IterableExtensions.findFirst(this.getAnnotations(), _function);
}
 

@Override
public AnnotationTypeDeclaration findSourceAnnotationType(final String qualifiedName) {
  final XtendTypeDeclarationImpl<? extends XtendTypeDeclaration> type = this.findSourceType(qualifiedName);
  XtendTypeDeclarationImpl<? extends XtendTypeDeclaration> _switchResult = null;
  boolean _matched = false;
  if (type instanceof AnnotationTypeDeclaration) {
    _matched=true;
    _switchResult = ((XtendTypeDeclarationImpl<? extends XtendTypeDeclaration>)type);
  }
  return ((AnnotationTypeDeclaration)_switchResult);
}
 

@Override
public AnnotationReference findAnnotation(final Type annotationType) {
  final Function1<AnnotationReference, Boolean> _function = (AnnotationReference it) -> {
    AnnotationTypeDeclaration _annotationTypeDeclaration = it.getAnnotationTypeDeclaration();
    return Boolean.valueOf(Objects.equal(_annotationTypeDeclaration, annotationType));
  };
  return IterableExtensions.findFirst(this.getAnnotations(), _function);
}
 

@Override
public AnnotationTypeDeclaration getAnnotationTypeDeclaration() {
  TypeDeclaration _typeDeclaration = this.getCompilationUnit().toTypeDeclaration(this.getDelegate().getAnnotation());
  return ((AnnotationTypeDeclaration) _typeDeclaration);
}
 

@Override
public Iterable<? extends MutableAnnotationTypeDeclaration> getDeclaredAnnotationTypes() {
  Iterable<? extends AnnotationTypeDeclaration> _declaredAnnotationTypes = super.getDeclaredAnnotationTypes();
  return ((Iterable<? extends MutableAnnotationTypeDeclaration>) _declaredAnnotationTypes);
}
 

@Override
public Iterable<? extends AnnotationTypeDeclaration> getDeclaredAnnotationTypes() {
  return Iterables.<AnnotationTypeDeclaration>filter(this.getDeclaredMembers(), AnnotationTypeDeclaration.class);
}
 

@Override
public Iterable<? extends MutableAnnotationTypeDeclaration> getDeclaredAnnotationTypes() {
  Iterable<? extends AnnotationTypeDeclaration> _declaredAnnotationTypes = super.getDeclaredAnnotationTypes();
  return ((Iterable<? extends MutableAnnotationTypeDeclaration>) _declaredAnnotationTypes);
}
 

public Iterable<? extends AnnotationTypeDeclaration> getDeclaredAnnotationTypes() {
  return Iterables.<AnnotationTypeDeclaration>filter(this.getDeclaredMembers(), AnnotationTypeDeclaration.class);
}
 

@Override
public Iterable<? extends MutableAnnotationTypeDeclaration> getDeclaredAnnotationTypes() {
  Iterable<? extends AnnotationTypeDeclaration> _declaredAnnotationTypes = super.getDeclaredAnnotationTypes();
  return ((Iterable<? extends MutableAnnotationTypeDeclaration>) _declaredAnnotationTypes);
}
 

@Override
public Iterable<? extends MutableAnnotationTypeDeclaration> getDeclaredAnnotationTypes() {
  Iterable<? extends AnnotationTypeDeclaration> _declaredAnnotationTypes = super.getDeclaredAnnotationTypes();
  return ((Iterable<? extends MutableAnnotationTypeDeclaration>) _declaredAnnotationTypes);
}
 

public AnnotationTypeDeclaration findSourceAnnotationType(final String qualifiedName) {
  return this.getTypeLookup().findSourceAnnotationType(qualifiedName);
}
 

public void doValidate(List<? extends AnnotationTypeDeclaration> annotatedAnnotationTypes, @Extension ValidationContext context) {
	for (AnnotationTypeDeclaration annotatedAnnotationType : annotatedAnnotationTypes) {
		doValidate(annotatedAnnotationType, context);
	}
}
 

public void doGenerateCode(List<? extends AnnotationTypeDeclaration> annotatedSourceElements, @Extension CodeGenerationContext context) {
	for (AnnotationTypeDeclaration annotatedAnnotationType : annotatedSourceElements) {
		doGenerateCode(annotatedAnnotationType, context);
	}
}
 

public void doRegisterGlobals(List<? extends AnnotationTypeDeclaration> annotatedAnnotationTypes, @Extension RegisterGlobalsContext context) {
	for (AnnotationTypeDeclaration annotatedAnnotationType : annotatedAnnotationTypes) {
		doRegisterGlobals(annotatedAnnotationType, context);
	}
}
 

/**
 * @param qualifiedName
 *            the qualified name of the type to look up. Nested class delimiter is expected to be the '.' (dot).
 * @return the <code>AnnotationTypeDeclaration</code> with given
 *         qualified name, or <code>null</code> if no such class declaration
 *         is contained in the currently processed
 *         <code>CompilationUnit</code>
 */
AnnotationTypeDeclaration findSourceAnnotationType(String qualifiedName);
 

/**
 * Invoked by the validator
 * @param annotatedAnnotationType the generated annotation type that should be validated 
 * @param context 
 * @see #doValidate(List, ValidationContext)
 * @since 2.7
 */
public void doValidate(AnnotationTypeDeclaration annotatedAnnotationType, @Extension ValidationContext context) {}
 

/**
 * Called during code generation. 
 * 
 * @param annotatedAnnotationType a source element annotated with the annotation this processor is responsible for.
 * @param context
 * @see CodeGenerationParticipant#doGenerateCode(List, CodeGenerationContext)
 */
public void doGenerateCode(AnnotationTypeDeclaration annotatedAnnotationType, @Extension CodeGenerationContext context) {}
 

/**
 * Called during global symbol collecting.
 * 
 * @param annotatedAnnotationType a source element annotated with the annotation this processor is responsible for.
 * @param context
 */
public void doRegisterGlobals(AnnotationTypeDeclaration annotatedAnnotationType, @Extension RegisterGlobalsContext context) {}