Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.robolectric.annotation.processing;
  
  import static com.google.common.collect.Lists.*;
  import static com.google.common.collect.Maps.*;
  import static com.google.common.collect.Sets.*;
  
  import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
Model describing the Robolectric source file.
 
 public class RobolectricModel {
   private static FQComparator fqComparator = new FQComparator();
   private static SimpleComparator comparator = new SimpleComparator();
  
  
TypeElement representing the Robolectric.Anything interface, or null if the element isn't found.
 
   final TypeElement ANYTHING;
  
TypeMirror representing the Robolectric.Anything interface, or null if the element isn't found.
 
   public final TypeMirror ANYTHING_MIRROR;
  
TypeMirror representing the Object class.
 
   final TypeMirror OBJECT_MIRROR;
  
TypeElement representing the

Implements:
annotation.
 
   final TypeElement IMPLEMENTS;

  
PackageElement representing the java.lang package.
 
   final PackageElement JAVA_LANG;

  
Convenience reference for the processing environment's elements utilities.
 
   private final Elements elements;
  
Convenience reference for the processing environment's types utilities.
 
   private final Types types;
   
   private HashMultimap<String,TypeElementtypeMap = HashMultimap.create();
   private TreeSet<Stringimports = newTreeSet();
 
   private static class FQComparator implements Comparator<TypeElement> {
     @Override
     public int compare(TypeElement o1TypeElement o2) {
       return o1.getQualifiedName().toString().compareTo(o2.getQualifiedName().toString());
     }
   }
 
   private static class SimpleComparator implements Comparator<Element> {
     @Override
     public int compare(Element o1Element o2) {
       return o1.getSimpleName().toString().compareTo(o2.getSimpleName().toString());
     }
   }
 
   public RobolectricModel(Elements elementsTypes types) {
     this. = elements;
     this. = types;
        = elements.getTypeElement("org.robolectric.Robolectric.Anything");
      =  == null ? null : .asType();
     // FIXME: check this type lookup for NPEs (and also the ones in the
     // validators)
     = elements.getPackageElement("java.lang");
     = new Predicate<TypeMirror>() {
      @Override
      public boolean apply(TypeMirror t) {
        return !RobolectricModel.this..isSameType(t);
      }
    };
  }
  public AnnotationMirror getAnnotationMirror(Element elementTypeElement annotation) {
    TypeMirror expectedType = annotation.asType();
    for (AnnotationMirror m : element.getAnnotationMirrors()) {
      if (.isSameType(expectedTypem.getAnnotationType())) {
        return m;
      }
    }
    return null;
  }
    @Override
    public TypeElement visitType(TypeElement eVoid p) {
      return e;
    }
  };
  public static AnnotationValue getAnnotationValue(AnnotationMirror annotationMirrorString key) {
    for (Entry<? extends ExecutableElement, ? extends AnnotationValueentry : annotationMirror.getElementValues().entrySet() ) {
      if (entry.getKey().getSimpleName().toString().equals(key)) {
        return entry.getValue();
      }
    }
    return null;
  }
    @Override
    public TypeMirror visitType(TypeMirror tVoid arg) {
      return t;
    }
  };
    @Override
    public String visitString(String sVoid arg) {
      return s;
    }
  };
  
    return getAnnotationMirror(elem);
  }
  
    AnnotationValue className = getAnnotationValue(am"className");
    if (className == null) {
      return null;
    }
    String classNameString = .visit(className);
    if (classNameString == null) {
      return null;
    }
    TypeElement impElement = .getTypeElement(classNameString.replace('$''.'));
    if (impElement == null) {
      return null;
    }
    return impElement.asType();
  }
  
    if (am == null) {
      return null;
    }
    // RobolectricWiringTest prefers className (if provided) to value, so we do the same here.
    TypeMirror impType = getImplementedClassName(am);
    if (impType != null) {
      return impType;
    }
    AnnotationValue av = getAnnotationValue(am"value");
    if (av == null) {
      return null;
    }
    TypeMirror type = .visit(av);
    if (type == null) {
      return null;
    }
    // If the class is Robolectric.Anything, treat as if it wasn't specified at all.
    if ( != null && .isSameType(type)) {
      return null;
    }
    
    return type;
  }
  
    @Override
    public TypeElement visitType(TypeElement eVoid p) {
      return e;
    }
  };
  
  private void registerType(TypeElement type) {
    if (!Objects.equal(type) && !.containsKey(type)) {
      .put(type.getSimpleName().toString(), type);
      .put(typetype);
      for (TypeParameterElement typeParam : type.getTypeParameters()) {
        for (TypeMirror bound : typeParam.getBounds()) {
          // FIXME: get rid of cast using a visitor
          TypeElement boundElement = .visit(.asElement(bound));
          registerType(boundElement);
        }
      }
    }
  }
  
  
Prepares the various derived parts of the model based on the class mappings that have been registered to date.
  public void prepare() {
      final TypeElement shadowType = entry.getKey();
      registerType(shadowType);
      final TypeElement solidType = entry.getValue();
      registerType(solidType);
    }
    while (!.isEmpty()) {
      final HashMultimap<String,TypeElementnextRound = HashMultimap.create();
      for (Map.Entry<StringSet<TypeElement>> referents : Multimaps.asMap().entrySet()) {
        final Set<TypeElementc = referents.getValue();
        // If there is only one type left with the given simple
        // name, then
        if (c.size() == 1) {
          final TypeElement type = c.iterator().next();
          .put(typereferents.getKey());
        }
        else {
          for (TypeElement type : c) {
            SimpleElementVisitor6<Void,TypeElementvisitor = new SimpleElementVisitor6<Void,TypeElement>() {
              @Override
              public Void visitType(TypeElement parentTypeElement type) {
                nextRound.put(parent.getSimpleName() + "." + type.getSimpleName(), type);
                .put(typeparent);
                return null;
              }
              @Override 
              public Void visitPackage(PackageElement parentTypeElement type) {
                .put(typetype.getQualifiedName().toString());
                .remove(type);
                return null;
              }
            };
            visitor.visit(.get(type).getEnclosingElement(), type);
          }
        }
      }
       = nextRound;
    }
    for (TypeElement imp.values()) {
      if (imp.getModifiers().contains(.)
          && !.equals(imp.getEnclosingElement())) {
        .add(imp.getQualifiedName().toString());
      }
    }
    // Other imports that the generated class needs
    .add("javax.annotation.Generated");
    .add("org.robolectric.internal.ShadowExtractor");
    .add("org.robolectric.internal.ShadowProvider");
  }
  public void addShadowType(TypeElement elemTypeElement type) {
    .put(elemtype);
  }
  public void addResetter(TypeElement parentExecutableElement elem) {
    .put(parentelem);
  }
    return .entrySet();
  }
  public Set<StringgetImports() {
    return ;
  }
    return Maps.filterEntries(new Predicate<Entry<TypeElementTypeElement>>() {
      @Override
      public boolean apply(Entry<TypeElementTypeElemententry) {
        return entry.getKey().getAnnotation(Implements.class).isInAndroidSdk();
      }
    });
  }
      @Override
      public boolean apply(Entry<TypeElementTypeElemententry) {
        return !Objects.equal(entry.getValue());
      }
    });
  }
    Set<Stringpackages = new HashSet<>();
    for (TypeElement element : getVisibleShadowTypes().values()) {
      packages.add("\"" + .getPackageOf(element).toString() + "\"");
    }
    return packages;
  }
    return newArrayList(Iterables.filter(typeParam.getBounds(), ));    
  }
  
  
Returns a plain string to be used in the generated source to identify the given type. The returned string will have sufficient level of qualification in order to make the referent unique for the source file.

Parameters:
type
Returns:
  public String getReferentFor(TypeElement type) {
    return .get(type);
  }
  
    @Override
    public String visitDeclared(DeclaredType tVoid p) {
      return .get(t.asElement());
    }
  };
  
  public String getReferentFor(TypeMirror type) {
    return .visit(type);
  }
    @Override
    protected boolean doEquivalent(TypeMirror aTypeMirror b) {
      return .isSameType(ab);
    }
    @Override
    protected int doHash(TypeMirror t) {
      // We're not using the hash.
      return 0;
    }
  };
  
  
    @Override
    @SuppressWarnings({"unchecked"})
    protected boolean doEquivalent(TypeParameterElement arg0,
        TypeParameterElement arg1) {
      // Casts are necessary due to flaw in pairwise equivalence implementation.
                                                (List<TypeMirror>)arg1.getBounds());
    }
    @Override
    protected int doHash(TypeParameterElement arg0) {
      // We don't use the hash code.
      return 0;
    }
  };
  
  public void appendParameterList(StringBuilder messageList<? extends TypeParameterElementtpeList) {
    boolean first = true;
    for (TypeParameterElement tpe : tpeList) {
      if (first) {
        first = false;
      } else {
        message.append(',');
      }
      message.append(tpe.toString());
      boolean iFirst = true;
      for (TypeMirror bound : getExplicitBounds(tpe)) {
        if (iFirst) {
          message.append(" extends ");
          iFirst = false;
        } else {
          message.append(',');
        }
        message.append(bound);
      }
    }
  }
  
  @SuppressWarnings({"unchecked"})
  public boolean isSameParameterList(List<? extends TypeParameterElementl1List<? extends TypeParameterElementl2) {
    // Cast is necessary because of a flaw in the API design of "PairwiseEquivalent",
    // a flaw that is even acknowledged in the source.
    // Our casts are safe because we're not trying to add elements to the list
    // and therefore can't violate the constraint.
                                        (List<TypeParameterElement>)l2);
  }
New to GrepCode? Check out our FAQ X