Combines types of getClasses() and getSingletons in one Set.

@return all registered types
163925
Set<Class<?>> allClasses() {
        final Set<Class<?>> allClasses = new HashSet<>(getClasses());
        for (Object singleton : getSingletons()) {
            allClasses.add(singleton.getClass());
        }
        return allClasses;
    }
1136491
public List<ImmutableFunctionalTerm> getClassPredicates() {
		List<ImmutableFunctionalTerm> classes = new ArrayList<>();
		for (ImmutableFunctionalTerm p : classPredicates)
			classes.add(p);
		classPredicates.clear();
		return classes;
	}
235631
public Set<ClassModel> getAllClassDependencies() {
		HashSet<ClassModel> result = new HashSet<>();

		for (ModuleModel module : allModuleDependencies) {
			for (ClassModel clazz : module.classes) {
				ClassModel.getAllClassDependencies(result, clazz);
			}
		}

		return result;
	}
768878
@SuppressWarnings("unchecked")
	 Class<?>[] getAllInterfacesAndClasses ( Class<?>[] classes ) 
    {
        if(0 == classes.length ) 
        {
            return classes;
        }
        else 
        {
            List<Class<?>> extendedClasses = new ArrayList<Class<?>>();
            // all interfaces hierarchy
            for (Class<?> clazz: classes) {
            	if (clazz != null) 
            	{
            		Class<?>[] interfaces = clazz.getInterfaces();
	                if (interfaces != null)
	                {
	                	extendedClasses.addAll(Arrays.asList(interfaces));
	                }
	                Class<?> superclass = clazz.getSuperclass();
	                if (superclass != null && superclass != Object.class)
	                {
	                	extendedClasses.addAll(Arrays.asList(superclass));
	                }
            	}
            }
            
            //Class::getInterfaces() gets only interfaces/classes implemented/extended directly by a given class.
            //We need to walk the whole way up the tree.
            return (Class[]) ArrayUtils.addAll( classes, getAllInterfacesAndClasses( extendedClasses.toArray(new Class[extendedClasses.size()])));
        }
    }
652383
protected Set<Class<? extends Annotation>> getSupportedAnnotationClasses() {
		Set<Class<? extends Annotation>> annotations = new LinkedHashSet<Class<? extends Annotation>>();

		annotations.addAll(typeProcessor.getSupportedAnnotationClasses());
		annotations.addAll(sharedPreferencesProcessor.getSupportedAnnotationClasses());
		annotations.addAll(dataSourceProcessor.getSupportedAnnotationClasses());
		annotations.addAll(many2ManyProcessor.getSupportedAnnotationClasses());

		return annotations;
	}
1183129
public java.util.List<String> getInstanceTypes() {
        if (instanceTypes == null) {
            instanceTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return instanceTypes;
    }
948130
public List<MappedSuperclass<OrmDescriptor>> getAllMappedSuperclass()
   {
      List<MappedSuperclass<OrmDescriptor>> list = new ArrayList<MappedSuperclass<OrmDescriptor>>();
      List<Node> nodeList = model.get("mapped-superclass");
      for(Node node: nodeList)
      {
         MappedSuperclass<OrmDescriptor>  type = new MappedSuperclassImpl<OrmDescriptor>(this, "mapped-superclass", model, node);
         list.add(type);
      }
      return list;
   }
195165
public Iterable<String> getAllSortedTypeNames() {
    synchronized (lock) {
      if (lazyAllSortedTypeNames == null) {
        lazyAllSortedTypeNames =
            Stream.concat(BUILTIN_TYPES.keySet().stream(), descriptors.keySet().stream())
                .sorted()
                .collect(toImmutableList());
      }
      return lazyAllSortedTypeNames;
    }
  }
745508
private Set<Class<?>> getClasses() {
		HashSet<Class<?>> result = new HashSet<Class<?>>();
		
		// in case of override only the last global configuration must be analyzed
		JGlobalMap jGlobalMap = null;
		
		for (Class<?> clazz : getAllsuperClasses(configuredClass)) {
			
			// only if global configuration is null will be searched global configuration on super classes
			if(isNull(jGlobalMap)){
				
				jGlobalMap = clazz.getAnnotation(JGlobalMap.class);
				//if the field configuration is defined in the global map
				if(!isNull(jGlobalMap)){
					addClasses(jGlobalMap.classes(),result);
					if(!isNull(jGlobalMap.excluded()))
						for (Field field : getListOfFields(configuredClass)){ 
							JMap jMap = field.getAnnotation(JMap.class);
							if(!isNull(jMap)) 
								for (String fieldName : jGlobalMap.excluded()) 
									if(field.getName().equals(fieldName))
										addClasses(jMap.classes(),result,field.getName());
						}
					
					return result;
				}
			}
		}
		
		for (Field field : getListOfFields(configuredClass)){ 
			JMap jMap = field.getAnnotation(JMap.class);
			if(!isNull(jMap)) addClasses(jMap.classes(),result,field.getName());
		}	
		
		return result;	
	}
38724
public List<MappedSuperclass<EntityMappings<T>>> getAllMappedSuperclass()
   {
      List<MappedSuperclass<EntityMappings<T>>> list = new ArrayList<MappedSuperclass<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("mapped-superclass");
      for(Node node: nodeList)
      {
         MappedSuperclass<EntityMappings<T>>  type = new MappedSuperclassImpl<EntityMappings<T>>(this, "mapped-superclass", childNode, node);
         list.add(type);
      }
      return list;
   }
355592
public Class getTypeClass() {
        try {
            return Class.forName(s.getContract().getClassNameForEntity(s.getName()));
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
925548
public ClassInfoList getStandardClasses() {
        return filter(new ClassInfoFilter() {
            @Override
            public boolean accept(final ClassInfo ci) {
                return ci.isStandardClass();
            }
        });
    }
1228106
public Class<?> getClassType() {
        try {
            return Class.forName(getType(), true, ClassLoaderHolder.getClassLoader());
        } catch (ClassNotFoundException e) {
            throw new IllegalStateException(e);
        }
    }
1281331
public <T extends TypeDefinition> List<T> getTypes(Class<T> targetClass) {
        return types.values().stream()
                .filter(targetClass::isInstance)
                .map(targetClass::cast)
                .collect(Collectors.toList());
    }
292295
@SuppressWarnings("unchecked")
	protected List<? extends Class<? extends WebPage>> getAllPageClassesQuietly()
	{
		final List<Class<? extends WebPage>> pages = new ArrayList<>();
		try
		{
			final Set<Class<?>> set = AnnotationExtensions.getAllAnnotatedClasses(getPackageName(),
				MountPath.class);
			for (final Class<?> class1 : set)
			{
				pages.add((Class<? extends WebPage>)class1);
			}
		}
		catch (final ClassCastException e)
		{
			LOGGER.error(
				e.getClass().getName() + " occured while scanning for MountPath annotations.", e);
		}
		catch (final ClassNotFoundException e)
		{
			LOGGER.error(
				e.getClass().getName() + " occured while scanning for MountPath annotations.", e);
		}
		catch (final IOException e)
		{
			LOGGER.error(
				e.getClass().getName() + " occured while scanning for MountPath annotations.", e);
		} catch (URISyntaxException e) {
			LOGGER.error(
					e.getClass().getName() + " occured while scanning for MountPath annotations.", e);
		}
		return pages;
	}
547894
public Class[] getLoadedClasses() {
        synchronized (classCache) {
            final Collection<Class> values = classCache.values();
            return values.toArray(new Class[values.size()]);
        }
    }
235967
public LinkedHashSet<Class<?>> getRegisteredKryoTypes() {
		if (isForceKryoEnabled()) {
			// if we force kryo, we must also return all the types that
			// were previously only registered as POJO
			LinkedHashSet<Class<?>> result = new LinkedHashSet<>();
			result.addAll(registeredKryoTypes);
			for(Class<?> t : registeredPojoTypes) {
				if (!result.contains(t)) {
					result.add(t);
				}
			}
			return result;
		} else {
			return registeredKryoTypes;
		}
	}