/* (non-Javadoc)
@see com.abubusoft.kripton.processor.BaseProcessor#getSupportedAnnotationClasses()
165761
protected Set<Class<? extends Annotation>> getSupportedAnnotationClasses() {
		Set<Class<? extends Annotation>> annotations = new LinkedHashSet<Class<? extends Annotation>>();
		annotations.add(BindType.class);		

		return annotations;
	}
454703
@Override
    protected void findReferencedClassNames(final Set<String> referencedClassNames) {
        if (this.referencedClassNames != null) {
            referencedClassNames.addAll(this.referencedClassNames);
        }
        getMethodInfo().findReferencedClassNames(referencedClassNames);
        getFieldInfo().findReferencedClassNames(referencedClassNames);
        getAnnotationInfo().findReferencedClassNames(referencedClassNames);
        if (annotationDefaultParamValues != null) {
            annotationDefaultParamValues.findReferencedClassNames(referencedClassNames);
        }
        final ClassTypeSignature classSig = getTypeSignature();
        if (classSig != null) {
            classSig.findReferencedClassNames(referencedClassNames);
        }
        // Remove any self-references
        referencedClassNames.remove(name);
    }
1154466
protected List<Class<?>> getExtensionClasses() {
		return Lists.<Class<?>> newArrayList(
			ArrayExtensions.class,
			BigDecimalExtensions.class,
			BigIntegerExtensions.class,
			BooleanExtensions.class,
			ByteExtensions.class,
			CharacterExtensions.class,
			CollectionExtensions.class,
			ComparableExtensions.class,
			DoubleExtensions.class,
			FloatExtensions.class,
			FunctionExtensions.class,
			IntegerExtensions.class,
			IterableExtensions.class,
			IteratorExtensions.class,
			ListExtensions.class,
			LongExtensions.class,
			MapExtensions.class,
			ObjectExtensions.class,
			ProcedureExtensions.class,
			ShortExtensions.class,
			StringExtensions.class);
	}
977842
@Override
	public Set<Class<?>> getClasses()
	{
		Set<Class<?>> classes = new HashSet<>();
		classes.add(HelloResource.class);
		return classes;
	}
147846
@Override
    void findReferencedClassNames(final Set<String> classNameListOut) {
        if (classBound != null) {
            classBound.findReferencedClassNames(classNameListOut);
        }
        for (final ReferenceTypeSignature typeSignature : interfaceBounds) {
            typeSignature.findReferencedClassNames(classNameListOut);
        }
    }
806
public List<JavaResource> getProjectClasses(Project project)
   {
      final List<JavaResource> classes = new ArrayList<>();
      if (project != null)
      {
         project.getFacet(JavaSourceFacet.class).visitJavaSources(new JavaClassSourceVisitor(classes));
      }
      return classes;
   }
894801
private List<Class<?>> getClassesByDiscriminators(Collection<String> discriminators)
	{
		Map<String, Class<?>> entitiesByName = new HashMap<>();

		// Prepare a Map of discriminator name -> entity class
		for (QEntity child : entity.getSubEntities())
		{
			entitiesByName.put(child.getDiscriminatorValue(), child.getEntityClass());
		}

		// If the root class isn't abstract then add it to the list of possible discriminators too
		if (!entity.isEntityClassAbstract())
			entitiesByName.put(entity.getDiscriminatorValue(), entity.getEntityClass());

		// Translate the discriminator string values to classes
		List<Class<?>> classes = new ArrayList<>(discriminators.size());
		for (String discriminator : discriminators)
		{
			final Class<?> clazz = entitiesByName.get(discriminator);

			if (clazz != null)
				classes.add(clazz);
			else
				throw new IllegalArgumentException("Invalid class discriminator '" +
				                                   discriminator +
				                                   "', expected one of: " +
				                                   entitiesByName.keySet());
		}

		return classes;
	}
22434
public SortedSet<TypeElement> allUnnamedClasses() {
        for (PackageElement pkg : allClasses.keySet()) {
            if (pkg.isUnnamed()) {
                return allClasses.get(pkg);
            }
        }
        return new TreeSet<>(comparator);
    }
577766
public <A extends Annotation> List<A> getAnnotations(final Class<A> annoClass) {
        Objects.requireNonNull(annoClass, "annoClass should not be null.");
        
        return getAnnotationsByType(expandedAnnos, annoClass);
    }
944215
public AnnotationType[] getAnnotationTypes() {
      if (annotationType.isEmpty()) {
         return new AnnotationType[]{Types.TOKEN};
      }
      return annotationType.toArray(new AnnotationType[annotationType.size()]);
   }
472530
private <A extends Annotation, AS extends Annotation> void processClassAnnotations(int processorIndex,
                                                                                       InjectionProcessorProvider<A, AS> provider,
                                                                                       Class<?> klass)
                    throws InjectionException
    {
        Class<A> annClass = provider.getAnnotationClass();
        if (annClass != null)
        {
            A ann = klass.getAnnotation(annClass);
            if (ann != null)
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                    Tr.debug(tc, "found class annotation " + toStringSecure(ann));

                InjectionProcessor<A, AS> processor = getProcessor(processorIndex, provider);
                addOrMergeInjectionBinding(processorIndex, processor, klass, null, ann);
            }

            Class<AS> pluralAnnClass = provider.getAnnotationsClass();
            if (pluralAnnClass != null)
            {
                AS pluralAnn = klass.getAnnotation(pluralAnnClass);
                if (pluralAnn != null)
                {
                    InjectionProcessor<A, AS> processor = getProcessor(processorIndex, provider);

                    A[] singleAnns = processor.getAnnotations(pluralAnn);
                    if (singleAnns != null)
                    {
                        for (A singleAnn : singleAnns)
                        {
                            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                Tr.debug(tc, "found plural class annotation " + toStringSecure(singleAnn));
                            addOrMergeInjectionBinding(processorIndex, processor, klass, null, singleAnn);
                        }
                    }
                }
            }
        }
    }
329665
@Override
    void findReferencedClassNames(final Set<String> referencedClassNames) {
        referencedClassNames.add(name);
        if (annotationParamValues != null) {
            for (final AnnotationParameterValue annotationParamValue : annotationParamValues) {
                annotationParamValue.findReferencedClassNames(referencedClassNames);
            }
        }
    }
378189
public List<JavaResource> getProjectAnnotations(Project project)
   {
      final List<JavaResource> classes = new ArrayList<>();
      if (project != null)
      {
         project.getFacet(JavaSourceFacet.class).visitJavaSources(new JavaAnnotationsSourceVisitor(classes));
      }
      return classes;
   }
541224
private static Annotation[] getAnnotations(Object targetClass) {
		if (targetClass instanceof Field)
			return ((Field) targetClass).getAnnotations();
		else if (targetClass instanceof Method)
			return ((Method) targetClass).getAnnotations();
		else if (targetClass instanceof Constructor)
			return ((Constructor<?>) targetClass).getAnnotations();
		else if (targetClass instanceof Class)
			return ((Class<?>) targetClass).getAnnotations();
		else
			return BeanBoxException.throwEX("targetClass should be Field, Method, Constructor or Class");
	}
749845
public MethodDescriptor[] 
    getTeaContextMethodDescriptors(Class<?>[] contextClasses) {

        Vector<MethodDescriptor> v = new Vector<MethodDescriptor>();
        Hashtable<Method, Method> methods = new Hashtable<Method, Method>();

        if (contextClasses != null) {

            // Combine all of the MethodDescriptors

            for (int i = 0; i < contextClasses.length; i++) {
                Class<?> c = contextClasses[i];
                if (c == null) {
                    continue;
                }

                MethodDescriptor[] mds = 
                    getTeaContextMethodDescriptors(c, false);
                
                for (int j = 0; j < mds.length; j++) {
                    MethodDescriptor md = mds[j];
                    Method m = md.getMethod();
                    // Check uniqueness of method
                    if (methods.get(m) == null) {
                        methods.put(m, m);
                        v.addElement(md);
                    }
                }
            }
        }

        MethodDescriptor[] methodDescriptors = new MethodDescriptor[v.size()];
        v.copyInto(methodDescriptors);

        // Sort the combined results
        sortMethodDescriptors(methodDescriptors);

        return methodDescriptors;
    }
420739
@Override
    public Set<String> getSupportedAnnotationTypes() {
        Class<? extends Annotation>[] supportedAnnotations = getClass().getAnnotation(SupportedAnnotations.class).value();

        return FluentIterable
                .from(Arrays.asList(supportedAnnotations))
                .transform(new ClassToNameTransform())
                .toSet();
    }
996996
@Override
    protected void findReferencedClassNames(final Set<String> classNames) {
        final MethodTypeSignature methodSig = getTypeSignature();
        if (methodSig != null) {
            methodSig.findReferencedClassNames(classNames);
        }
        final MethodTypeSignature methodDesc = getTypeDescriptor();
        if (methodDesc != null) {
            methodDesc.findReferencedClassNames(classNames);
        }
        if (annotationInfo != null) {
            for (final AnnotationInfo ai : annotationInfo) {
                ai.findReferencedClassNames(classNames);
            }
        }
        for (final MethodParameterInfo mpi : getParameterInfo()) {
            final AnnotationInfo[] aiArr = mpi.annotationInfo;
            if (aiArr != null) {
                for (final AnnotationInfo ai : aiArr) {
                    ai.findReferencedClassNames(classNames);
                }
            }
        }
    }