Java Code Examples for javax.lang.model.type.MirroredTypeException#getTypeMirror()

Property(String fieldName, VariableElement element) {
    this.fieldName = fieldName;
    this.element = element;
    this.typeName = TypeName.get(element.asType());
    this.annotations = getAnnotations(element);

    // get the parcel adapter if any
    ParcelAdapter parcelAdapter = element.getAnnotation(ParcelAdapter.class);
    if (parcelAdapter != null) {
        try {
            parcelAdapter.value();
        } catch (MirroredTypeException e) {
            this.typeAdapter = e.getTypeMirror();
        }
    }

    // get the element version, default 0
    ParcelVersion parcelVersion = element.getAnnotation(ParcelVersion.class);
    this.version = parcelVersion == null ? 0 : parcelVersion.from();
}
 

public FactoryAnnotatedCls(TypeElement classElement) throws ProcessingException {
    this.mAnnotatedClsElement = classElement;
    ShapeType annotation = classElement.getAnnotation(ShapeType.class);
    type = annotation.value();
    try {

        mSupperClsSimpleName = annotation.superClass().getSimpleName();
        mSupperClsQualifiedName = annotation.superClass().getCanonicalName();
    } catch (MirroredTypeException mte) {
        DeclaredType classTypeMirror = (DeclaredType) mte.getTypeMirror();
        TypeElement classTypeElement = (TypeElement) classTypeMirror.asElement();
        mSupperClsQualifiedName = classTypeElement.getQualifiedName().toString();
        mSupperClsSimpleName = classTypeElement.getSimpleName().toString();
    }

    if (mSupperClsSimpleName == null || mSupperClsSimpleName.equals("")) {
        throw new ProcessingException(classElement,
                "superClass() in @%s for class %s is null or empty! that's not allowed",
                ShapeType.class.getSimpleName(), classElement.getQualifiedName().toString());
    }
}
 

private String getViewStateClassFromAnnotationParams(TypeElement typeElement) {
	InjectViewState annotation = typeElement.getAnnotation(InjectViewState.class);
	String mvpViewStateClassName = "";

	if (annotation != null) {
		TypeMirror value;
		try {
			annotation.value();
		} catch (MirroredTypeException mte) {
			value = mte.getTypeMirror();
			mvpViewStateClassName = value.toString();
		}
	}

	if (mvpViewStateClassName.isEmpty() || DefaultViewState.class.getName().equals(mvpViewStateClassName)) {
		return null;
	}

	return mvpViewStateClassName;
}
 

private String getViewClassFromAnnotationParams(TypeElement typeElement) {
	InjectViewState annotation = typeElement.getAnnotation(InjectViewState.class);
	String mvpViewClassName = "";

	if (annotation != null) {
		TypeMirror value = null;
		try {
			annotation.view();
		} catch (MirroredTypeException mte) {
			value = mte.getTypeMirror();
		}

		mvpViewClassName = Util.getFullClassName(value);
	}

	if (mvpViewClassName.isEmpty() || DefaultView.class.getName().equals(mvpViewClassName)) {
		return null;
	}

	return mvpViewClassName;
}
 

public ArgumentAnnotatedField(Element element, TypeElement classElement, Arg annotation)
    throws ProcessingException {

  this.name = element.getSimpleName().toString();
  this.key = getKey(element, annotation);
  this.type = element.asType().toString();
  this.element = element;
  this.required = annotation.required();
  this.classElement = classElement;

  try {
    Class<? extends ArgsBundler> clazz = annotation.bundler();
    bundlerClass = getFullQualifiedNameByClass(clazz);
  } catch (MirroredTypeException mte) {
    TypeMirror baggerClass = mte.getTypeMirror();
    bundlerClass = getFullQualifiedNameByTypeMirror(baggerClass);
  }
}
 

private static TypeMirror getCreator(AutoReducer.Action action, Elements elements, Env env, ExecutableElement element) {
    TypeMirror typeMirror;
    try {
        Class<?> fromClass = action.from();
        String className = fromClass.getCanonicalName();
        typeMirror = elements.getTypeElement(className).asType();
    } catch (MirroredTypeException mte) {
        typeMirror = mte.getTypeMirror();
    }

    //Void is used by default meaning it's not linked to any action creator
    return env.getTypes().isSameType(typeMirror, env.asType(Void.class))
            ? null
            : typeMirror;
}
 

public ParcelableField(VariableElement element, Elements elementUtils, Types typeUtils) {

    this.element = element;
    fieldName = element.getSimpleName().toString();
    type = element.asType().toString();

    // Check for Bagger
    Bagger baggerAnnotation = element.getAnnotation(Bagger.class);
    if (baggerAnnotation != null) {
      // has a bagger annotation
      try {
        Class<? extends ParcelBagger> clazz = baggerAnnotation.value();
        baggerFullyQualifiedName = getFullQualifiedNameByClass(clazz);
      } catch (MirroredTypeException mte) {
        TypeMirror baggerClass = mte.getTypeMirror();
        baggerFullyQualifiedName = getFullQualifiedNameByTypeMirror(baggerClass);
      }

      // Everything is fine, so use the bagger
      codeGenerator = new BaggerCodeGen();
    } else {
      // Not using Bagger
      CodeGenInfo res = SupportedTypes.getCodeGenInfo(element, elementUtils, typeUtils);
      codeGenerator = res.getCodeGenerator();
      genericsTypeArgument = res.getGenericsType();

      // Check if type is supported
      if (codeGenerator == null) {
        ProcessorMessage.error(element,
            "Unsupported type %s for field %s. You could use @%s to provide your own serialization mechanism",
            element.asType().toString(), element.getSimpleName(), Bagger.class.getSimpleName());
      }
    }
  }
 

private TypeMirror getAdapterTypeMirror(BindTopping annotation){
    TypeMirror value = null;
    try {
        annotation.adapter();
    }catch (MirroredTypeException e){
        value = e.getTypeMirror();
    }
    return value;
}
 

private String getProviderClass(final JService annotation) {
    try {
        final Class<?> providerClass = annotation.value();
        return providerClass.getCanonicalName();
    } catch (final MirroredTypeException ex) {
        final TypeMirror typeMirror = ex.getTypeMirror();
        return typeMirror.toString();
    }
}
 

private static TypeMirror getParamType(Param param) {
  // See explanation of this hack at Element.getAnnotation
  // and at https://stackoverflow.com/a/10167558.
  try {
    param.type();
    throw new IllegalStateException("unreachable");
  } catch (MirroredTypeException ex) {
    return ex.getTypeMirror();
  }
}
 

private TypeMirror getInterpolatorTypeMirror(BindToppingStatus annotation){
    TypeMirror value = null;
    try{
        annotation.interpolator();
    }catch (MirroredTypeException e){
        value = e.getTypeMirror();
    }

    return value;
}
 

private String getBuilderName() {
    JsonDeserialize jsonDeserialize = typeUtils.asElement(beanType).getAnnotation(JsonDeserialize.class);
    if (isNull(jsonDeserialize)) {
        return null;
    }
    String builderName;
    try {
        builderName = jsonDeserialize.builder().getName();
    } catch (MirroredTypeException e) {
        TypeMirror typeMirror = e.getTypeMirror();
        builderName = typeMirror.toString();
    }
    return builderName;
}
 

private static TypeMirror getComponent(InjectApplication annotation) {
    try {
        annotation.component(); // this should throw
    } catch (MirroredTypeException mte) {
        return mte.getTypeMirror();
    }
    return null; // can this ever happen ??
}
 

public DeclaredType getClassFromAnnotationMethod(Supplier<Class<?>> supplier) {
	// JDK suggested way of getting type mirrors, do not waste time here,
	// just move on
	try {
		return (DeclaredType) of(supplier.get());
	} catch (MirroredTypeException e) {
		// types WILL be declared
		return (DeclaredType) e.getTypeMirror();
	}
}
 

private TypeMirror annotationMirror(AnnotationSelector selector){
    try {
        selector.value();
        return null;
    } catch (MirroredTypeException m) {
        return m.getTypeMirror();
    }
}
 

private TypeMirror getTypeMirror(final Element element) {
	final Source annotation = element.getAnnotation(Source.class);
	if (annotation != null) {
		try {
			annotation.value();
		} catch (MirroredTypeException e) {
			return e.getTypeMirror();
		}
	}

	return null;
}
 

private TypeMirror getConfigTypeResolverTypeMirror(final ConfigType configTypeAnnotation) {
	try {
		configTypeAnnotation.value();
	} catch (MirroredTypeException e) {
		return e.getTypeMirror();
	}
	// Should never happen
	return null;
}
 

private AbstractMap.SimpleEntry<Map<Element, SQLiteTable>,
        Boolean> getTableElementMappingForDatabase(
        final RoundEnvironment roundEnvironment,
        final Element databaseElement) {
    final AbstractMap.SimpleEntry<Map<Element, SQLiteTable>, Boolean> ret =
            new AbstractMap.SimpleEntry<Map<Element, SQLiteTable>, Boolean>(
                    new LinkedHashMap<Element, SQLiteTable>(), false);

    final List<String> tableNamesAdded = new ArrayList<>();
    for (final Element element : roundEnvironment.getElementsAnnotatedWith(SQLiteTable.class)) {
        if (element.getModifiers().contains(Modifier.ABSTRACT)
                || element.getKind().equals(ElementKind.INTERFACE)) continue;

        final SQLiteTable tableAnno = element.getAnnotation(SQLiteTable.class);

        TypeMirror mirror = null;
        try {
            tableAnno.database();
        } catch (MirroredTypeException e) {
            mirror = e.getTypeMirror();
        }

        final SQLiteDatabaseDescriptor dbAnno = mTypeUtils.asElement(mirror)
                .getAnnotation(SQLiteDatabaseDescriptor.class);
        if (dbAnno == null) {
            error(element, String.format("The database class must be annotated with %s",
                    SQLiteDatabaseDescriptor.class.getCanonicalName()));
            ret.setValue(true);
            return ret;
        }

        final String tableName = JavaWritableClass.getTableName(element);

        if (mTypeUtils.isSameType(mirror, databaseElement.asType())) {
            if (tableNamesAdded.contains(tableName)) {
                error(element, String.format("The table %s was already defined for database %s",
                        tableName, dbAnno.dbName()));
                ret.setValue(true);
                return ret;
            }

            tableNamesAdded.add(tableName);
            ret.getKey().put(element, tableAnno);
        }
    }

    return ret;
}
 

AutoBundleBindingField(VariableElement element,
                       AutoBundleField annotation,
                       Elements elementUtils,
                       Types typeUtils,
                       String getterName,
                       String setterName) {
    this.fieldName = element.toString();
    this.argKey = annotation.key().length() > 0 ? annotation.key() : this.fieldName;
    // @Nullable makes `required` to false
    this.required = annotation.required() && !BindingFieldHelper.hasNullableAnnotation(element);
    this.argType = TypeName.get(element.asType());
    this.getterName = getterName;
    this.setterName = setterName;
    this.annotations = BindingFieldHelper.getAnnotationsForField(element);
    Validator.checkAutoBundleFieldModifier(element, hasGetter() && hasSetter());

    TypeName converter;
    TypeName converted;
    try {
        Class clazz = annotation.converter();
        Validator.checkConverterClass(clazz);
        converter = TypeName.get(clazz);
        converted = detectConvertedTypeNameByClass(clazz);
    } catch (MirroredTypeException mte) {
        DeclaredType classTypeMirror = (DeclaredType) mte.getTypeMirror();
        TypeElement classTypeElement = (TypeElement) classTypeMirror.asElement();
        Validator.checkConverterClass(classTypeElement);
        converter = TypeName.get(classTypeMirror);
        converted = detectConvertedTypeByTypeElement(classTypeElement);
    }
    this.converter = converter;
    this.hasCustomConverter =
            !this.converter.equals(ClassName.get("com.yatatsu.autobundle", "DefaultAutoBundleConverter"));
    if (hasCustomConverter) {
        operationName = BindingFieldHelper.getOperationName(converted, elementUtils, typeUtils);
    } else {
        operationName = BindingFieldHelper.getOperationName(argType, elementUtils, typeUtils);
    }

    if (hasCustomConverter) {
        Validator.checkNotSupportedOperation(operationName, converted);
    } else {
        Validator.checkNotSupportedOperation(operationName, argType);
    }
}
 

private TypeElement getTypeElement(MirroredTypeException mte) {
    DeclaredType declaredType = (DeclaredType) mte.getTypeMirror();
    return (TypeElement) declaredType.asElement();
}