br.com.objectos.code.testing.model.ModelTesting Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of code-testing Show documentation
The newest version!
/*
 * Copyright (C) 2014-2020 Objectos Software LTDA.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package br.com.objectos.code.testing.model;

import static br.com.objectos.comuns.lang.Preconditions.checkNotNull;

import java.io.Writer;
import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Function;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.AnnotationValue;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Name;
import javax.lang.model.element.PackageElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.NoType;
import javax.lang.model.type.NullType;
import javax.lang.model.type.PrimitiveType;
import javax.lang.model.type.TypeKind;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.type.WildcardType;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;

public class ModelTesting implements Elements, Types {

  private final ProcessingEnvironment processingEnv;
  private final Elements elements;
  private final Types types;

  private ModelTesting(ProcessingEnvironment processingEnv, Elements elements, Types types) {
    this.processingEnv = processingEnv;
    this.elements = elements;
    this.types = types;
  }

  public static ModelTesting of(ProcessingEnvironment processingEnv) {
    checkNotNull(processingEnv);
    return new ModelTesting(
        processingEnv,
        processingEnv.getElementUtils(),
        processingEnv.getTypeUtils());
  }

  public final  T applyProcessingEnvironment(Function function) {
    checkNotNull(function, "function == null");
    return function.apply(processingEnv);
  }

  public final  T applyProcessingEnvironment(BiFunction function, E element) {
    checkNotNull(function, "function == null");
    checkNotNull(element, "element == null");
    return function.apply(processingEnv, element);
  }

  public final TypeElement getTypeElement(Class type) {
    checkNotNull(type, "type == null");
    return getTypeElement(type.getCanonicalName());
  }

  public final TypeMirror getTypeMirror(Class type) {
    return getTypeElement(type).asType();
  }

  public final ModelQuery with(Class type) {
    TypeElement typeElement = getTypeElement(type);
    return new ModelQueryTypeElement(this, typeElement);
  }

  //

  @Override
  public final PackageElement getPackageElement(CharSequence name) {
    return elements.getPackageElement(name);
  }

  @Override
  public final TypeElement getTypeElement(CharSequence name) {
    return elements.getTypeElement(name);
  }

  @Override
  public final Map getElementValuesWithDefaults(
      AnnotationMirror a) {
    return elements.getElementValuesWithDefaults(a);
  }

  @Override
  public final String getDocComment(Element e) {
    return elements.getDocComment(e);
  }

  @Override
  public final boolean isDeprecated(Element e) {
    return elements.isDeprecated(e);
  }

  @Override
  public final Name getBinaryName(TypeElement type) {
    return elements.getBinaryName(type);
  }

  @Override
  public final PackageElement getPackageOf(Element type) {
    return elements.getPackageOf(type);
  }

  @Override
  public final List getAllMembers(TypeElement type) {
    return elements.getAllMembers(type);
  }

  @Override
  public final List getAllAnnotationMirrors(Element e) {
    return elements.getAllAnnotationMirrors(e);
  }

  @Override
  public final boolean hides(Element hider, Element hidden) {
    return elements.hides(hider, hidden);
  }

  @Override
  public final boolean overrides(ExecutableElement overrider, ExecutableElement overridden, TypeElement type) {
    return elements.overrides(overrider, overridden, type);
  }

  @Override
  public final String getConstantExpression(Object value) {
    return elements.getConstantExpression(value);
  }

  @Override
  public final void printElements(Writer w, Element... elements) {
    this.elements.printElements(w, elements);
  }

  @Override
  public final Name getName(CharSequence cs) {
    return elements.getName(cs);
  }

  @Override
  public final boolean isFunctionalInterface(TypeElement type) {
    return elements.isFunctionalInterface(type);
  }

  @Override
  public final Element asElement(TypeMirror t) {
    return types.asElement(t);
  }

  @Override
  public final boolean isSameType(TypeMirror t1, TypeMirror t2) {
    return types.isSameType(t1, t2);
  }

  @Override
  public final boolean isSubtype(TypeMirror t1, TypeMirror t2) {
    return types.isSubtype(t1, t2);
  }

  @Override
  public final boolean isAssignable(TypeMirror t1, TypeMirror t2) {
    return types.isAssignable(t1, t2);
  }

  @Override
  public final boolean contains(TypeMirror t1, TypeMirror t2) {
    return types.contains(t1, t2);
  }

  @Override
  public final boolean isSubsignature(ExecutableType m1, ExecutableType m2) {
    return types.isSubsignature(m1, m2);
  }

  @Override
  public final List directSupertypes(TypeMirror t) {
    return types.directSupertypes(t);
  }

  @Override
  public final TypeMirror erasure(TypeMirror t) {
    return types.erasure(t);
  }

  @Override
  public final TypeElement boxedClass(PrimitiveType p) {
    return types.boxedClass(p);
  }

  @Override
  public final PrimitiveType unboxedType(TypeMirror t) {
    return types.unboxedType(t);
  }

  @Override
  public final TypeMirror capture(TypeMirror t) {
    return types.capture(t);
  }

  @Override
  public final PrimitiveType getPrimitiveType(TypeKind kind) {
    return types.getPrimitiveType(kind);
  }

  @Override
  public final NullType getNullType() {
    return types.getNullType();
  }

  @Override
  public final NoType getNoType(TypeKind kind) {
    return types.getNoType(kind);
  }

  @Override
  public final ArrayType getArrayType(TypeMirror componentType) {
    return types.getArrayType(componentType);
  }

  @Override
  public final WildcardType getWildcardType(TypeMirror extendsBound, TypeMirror superBound) {
    return types.getWildcardType(extendsBound, superBound);
  }

  @Override
  public final DeclaredType getDeclaredType(TypeElement typeElem, TypeMirror... typeArgs) {
    return types.getDeclaredType(typeElem, typeArgs);
  }

  @Override
  public final DeclaredType getDeclaredType(DeclaredType containing, TypeElement typeElem, TypeMirror... typeArgs) {
    return types.getDeclaredType(containing, typeElem, typeArgs);
  }

  @Override
  public final TypeMirror asMemberOf(DeclaredType containing, Element element) {
    return types.asMemberOf(containing, element);
  }

}