Extracts all {@link RpcGateway} interfaces implemented by the given clazz.

@param clazz from which to extract the implemented RpcGateway interfaces
@return A set of all implemented RpcGateway interfaces
771533
public static Set<Class<? extends RpcGateway>> extractImplementedRpcGateways(Class<?> clazz) {
		HashSet<Class<? extends RpcGateway>> interfaces = new HashSet<>();

		while (clazz != null) {
			for (Class<?> interfaze : clazz.getInterfaces()) {
				if (RpcGateway.class.isAssignableFrom(interfaze)) {
					interfaces.add((Class<? extends RpcGateway>) interfaze);
				}
			}

			clazz = clazz.getSuperclass();
		}

		return interfaces;
	}
668889
public static List<Class<?>> getAllClasses(Class<?> clazz) {
        List<Class<?>> types = new ArrayList<>();
        while (clazz != null) {
            types.add(clazz);
            clazz = clazz.getSuperclass();
        }
        return types;
    }
580857
public static List<Class<?>> getSuperclasses(Class<?> clazz) {
        return getSuperclassesAsStream(clazz).collect(Collectors.toList());
    }
1124584
public java.util.List<InternetGateway> getInternetGateways() {
        if (internetGateways == null) {
            internetGateways = new com.amazonaws.internal.SdkInternalList<InternetGateway>();
        }
        return internetGateways;
    }
757647
public static Method[] findMethods(Class<?> clazz) throws IllegalAccessException {
        final List<Method> methodList = new ArrayList<Method>();

        doWithDeclaredMethods(clazz, new MethodCallback() {
            public void doWith(Method method) {
                methodList.add(method);
            }
        });
        return methodList.toArray(new Method[methodList.size()]);
    }
837201
public static <T> Collection<T> getLoadedImplementations(Class<T> clazz)
  {
    @SuppressWarnings("unchecked")
    Collection<T> retVal = (Collection<T>) extensionsMap.get(clazz);
    if (retVal == null) {
      return new HashSet<>();
    }
    return retVal;
  }
761780
static List<NetworkInterface> getInterfaces() throws SocketException {
        List<NetworkInterface> all = new ArrayList<NetworkInterface>();
        addAllInterfaces(all, Collections.list(NetworkInterface.getNetworkInterfaces()));
        return all;
    }
813535
public static List<String> getNames(Class<? extends Enum<?>> clazz) {
		final Enum<?>[] enums = clazz.getEnumConstants();
		if (null == enums) {
			return null;
		}
		final List<String> list = new ArrayList<>(enums.length);
		for (Enum<?> e : enums) {
			list.add(e.name());
		}
		return list;
	}
1174168
public static Method[] getAllMethods(Class<?> clazz) {
        Method[] allMethods = allClassMethodsCache.get(clazz);
        if (allMethods == null) {
            // Allows a race between concurrent threads coming for clazz's methods at the same time,
            // but the race seems to be harmless.
            allMethods = doGetAllMethods(clazz);
            allClassMethodsCache.put(clazz, allMethods);
        }
        return allMethods;
    }
565015
public static Set<Class<? extends Annotation>> getStereotypes(final Class<?> clazz) {
        final Set<Class<? extends Annotation>> ret = new HashSet<>();

        final Set<Annotation> annotations = getAnnotations(clazz.getAnnotations(), Stereotype.class);
        if (annotations.isEmpty()) {
            return ret;
        }

        for (final Annotation annotation : annotations) {
            ret.add(annotation.annotationType());
        }

        return ret;
    }
99357
public java.util.List<NatGateway> getNatGateways() {
        if (natGateways == null) {
            natGateways = new com.amazonaws.internal.SdkInternalList<NatGateway>();
        }
        return natGateways;
    }
246209
private static Map<String, Method> gatherAllDeclaredMethods(Class clazz) {
        Map<String, Method> methods = new HashMap<String, Method>();
        gatherAllDeclaredMethods(methods, clazz);
        return methods;
    }
722932
private static Map<String, Method> getAllMethod(Class<?> clazz, Map<String, Method> methods) {
        if (clazz == null || clazz == Object.class) {
            return methods;
        }

        Arrays.stream(clazz.getDeclaredMethods()).forEach(method -> {
            String key = String.format("%s:%s", method.getName(),
                ByteCodeUtils.getMethodDesc(method));
            Method m = methods.get(key);
            if (m == null || (m.getDeclaringClass().isInterface()
                              && !method.getDeclaringClass().isInterface())) {
                methods.put(key, method);
            }
        });

        Arrays.stream(clazz.getInterfaces()).forEach(c -> getAllMethod(c, methods));

        return getAllMethod(clazz.getSuperclass(), methods);
    }
647656
public static <T> Set<Class<? extends T>> getNonAbstractSubclasses(Class<T> clazz) {
        return ClassGraphUtil/*TraverseClasspath*/.getNonAbstractSubClasses(clazz);
    }
895706
public static Field[] getFields (Class<?> clazz)
    {
        ArrayList<Field> list = new ArrayList<Field>();
        getFields(clazz, list);
        return list.toArray(new Field[list.size()]);
    }
66468
public static List<StartContainerConfig> getContainers(Class clazz) {
      if (!cacheSCC.containsKey(clazz)) {
         cacheSCC.put(clazz, new ArrayList<>(1));
         ContainerStart cs = (ContainerStart) clazz.getAnnotation(ContainerStart.class);
         if (cs != null) {
            cacheSCC.get(clazz).add(fromContainerStart(cs));
         }
         Containers c = (Containers) clazz.getAnnotation(com.vectorprint.report.itext.annotations.Containers.class);
         if (c != null) {
            for (ContainerStart s : c.containers()) {
               cacheSCC.get(clazz).add(fromContainerStart(s));
            }
         }
      }
      return cacheSCC.get(clazz);
   }
1369334
public static Map<String, Type> getReflectiveMappingTypes(Class<? extends MailChimpObject> clazz) {
		Map<String, Type> types = reflectiveMappingsTypes.get(clazz);

		if (types == null) {
			types = new LinkedHashMap<String, Type>();

			for(Map.Entry<String, java.lang.reflect.Field> entry: getReflectiveMapping(clazz).entrySet()) {
				types.put(entry.getKey(), entry.getValue().getGenericType());
			}

			reflectiveMappingsTypes.put(clazz, Collections.unmodifiableMap(types));
		}

		return types;
	}