Need to removed the vetoed classes from the set so that we can ignore them

@param classes
170004
private void removeVetoedClasses(Set<Class<?>> classes) {
        //get hold of classnames
        Set<String> classNames = new HashSet<String>();
        for (Class<?> clazz : classes) {
            classNames.add(clazz.getName());
        }
        // take into considerations of the exclude in beans.xml
        Collection<String> includedClasses = WeldCDIUtils.filterClassesBasedOnBeansXML(this.beansXml, this.resourceLoader, classNames);
        Iterator<Class<?>> iterator = classes.iterator();
        while (iterator.hasNext()) {
            Class<?> clazz = iterator.next();
            if (WeldCDIUtils.isClassVetoed(clazz)) {
                iterator.remove();
            } else if (!includedClasses.contains(clazz.getName())) {
                iterator.remove();
            }

        }
    }
567692
protected void updateClasses(HashMap<String,List<Class>> list, String superclass, List<Class> classes) {
    if (!list.containsKey(superclass)) {
      list.put(superclass, classes);
    }
    else {
      for (Class cls : classes) {
        if (!list.get(superclass).contains(cls))
          list.get(superclass).add(cls);
      }
    }
  }
1285074
public void instrumentWithProbes(Collection<Class<?>> classes) {
        for (Class<?> clazz : classes) {
            try {
                instrumentation.retransformClasses(clazz);
            } catch (Throwable t) {
            }
        }
    }
930139
public void clear() {
        exceptionSet.clear();
        explicitSet.clear();
        universalHandler = false;
        commonSupertype = null;
        size = 0;
    }
93293
public Set<String> getUnconditionalClasses() {
		Set<String> filtered = new HashSet<>(this.unconditionalClasses);
		filtered.removeAll(this.exclusions);
		return Collections.unmodifiableSet(filtered);
	}
143745
public void remove(Class<? extends T> type) throws IOException {
        for (T t : data) {
            if(t.getClass()==type) {
                data.remove(t);
                onModified();
                return;
            }
        }
    }
638464
private void removeSuperClass(Object object, Class<?> type)
    {
        for (final Class<?> types : type.getInterfaces())
        {
            remove(types, object);
        }
        final Class<?> parent = type.getSuperclass();
        if (parent != null)
        {
            removeSuperClass(object, parent);
        }
    }
1157718
public void removeSimilarClassesFromFile1() throws IOException {
        logging.info("Start reding cs File");
        List<String> linescs1 = getFileLinesAsList(csFile1);
        logging.info("Start reding cs File");
        List<String> linescs2 = getFileLinesAsList(csFile2);
        logging.info("Search classes");
        List<String> classNames1 = searchClasses(linescs1);
        logging.info("Found " + classNames1.size() + " classes");
        logging.info("Search classes");
        List<String> classNames2 = searchClasses(linescs2);
        logging.info("Found " + classNames2.size() + " classes");
        logging.info("Removing similarities from the file");
        for (String name : findSimilarClassNames(classNames1, classNames2)) {
            linescs1 = removeLinesContainingClassname(linescs1, name);
        }
        logging.info("Remove Attributes, which stands alone");
        linescs1 = removeAttributesNotBoundToClass(linescs1);
        if (!windows) {
            logging.info("Replace abstract classes with interfaces");
            linescs1 = replaceAbstractClasses(linescs1);
            linescs2 = replaceAbstractClasses(linescs2);
            logging.info("Save files");
        }
        replaceFilesWithNewContent(linescs1, csFile1);
        replaceFilesWithNewContent(linescs2, csFile2);
    }
750279
public Datatype.Builder clearNestedClasses() {
    if (nestedClasses instanceof ImmutableList) {
      nestedClasses = ImmutableList.of();
    } else {
      nestedClasses.clear();
    }
    return (Datatype.Builder) this;
  }
282674
public void setRowClasses(java.lang.String rowClasses) {
        getStateHelper().put(PropertyKeys.rowClasses, rowClasses);
    }
1176528
@SuppressWarnings("unchecked")
    public <T extends XPathBuilder> T setExcludeClasses(final String... excludeClasses) {
        if (excludeClasses != null) {
            this.excludeClasses = Arrays.asList(excludeClasses);
        }
        return (T) this;
    }
714486
public static void removeDeadClasses(CompilationUnit unit, CodeReferenceMap deadCodeMap) {
    ElementUtil elementUtil = unit.getEnv().elementUtil();
    Iterator<AbstractTypeDeclaration> iter = unit.getTypes().iterator();
    while (iter.hasNext()) {
      AbstractTypeDeclaration type = iter.next();
      TypeElement typeElement = type.getTypeElement();
      if (!ElementUtil.isGeneratedAnnotation(typeElement)) {
        if (deadCodeMap.containsClass(typeElement, elementUtil)) {
          type.setDeadClass(true);
        } else {
          // Keep class, remove dead interfaces.
          if (typeElement.getInterfaces().size() > 0) {
            GeneratedTypeElement replacement = GeneratedTypeElement.mutableCopy(typeElement);
            for (TypeElement intrface : ElementUtil.getInterfaces(typeElement)) {
              if (!deadCodeMap.containsClass(intrface, elementUtil)) {
                replacement.addInterface(intrface.asType());
              }
            }
            if (typeElement.getInterfaces().size() > replacement.getInterfaces().size()) {
              type.setTypeElement(replacement);
            }
          }
        }
      }
    }
  }
597343
public static function unmap($classes) {
		if (!is_array($classes)) {
			$classes = [$classes];
		}
		foreach ($classes as $value) {
			unset(static::$_map[$value]);
		}
	}
220313
public void addClasses(Set<Class<?>> classes) {
        for (Class<?> classToAdd: classes) {
            localClassCache.put(classToAdd.getName(), classToAdd);
        }
    }
980094
private Class<?> eliminateEnumSubclass(Class<?> cls) {
        Class<?> sup = cls.getSuperclass();
        if (sup != null && sup.getSuperclass() == Enum.class) {
            return sup;
        }
        return cls;
    }
826354
public void setDfltTableStylesStr(String classes) {
        dfltTableStyles.clear();
        if (classes == null || classes.isEmpty()) return;
        List<String> lst = StrUtils.split(classes, " ");
        for (int k = 0; k < lst.size(); k++) {
            String s = lst.get(k).trim();
            DataTableStyleClass cls;
            try {
                cls = DataTableStyleClass.valueOf(s);
                dfltTableStyles.add(cls);
            } catch (Exception ex) {
                continue;
            }
        }
    }
1227630
private static void removeDuplicateContracts(final Class<?> type, final Set<Class<?>> contracts) {
        if (contracts.isEmpty()) {
            return;
        }

        // remove interfaces already included in common type (e.g. Number and Serializable)
        Iterator<Class<?>> it = contracts.iterator();
        while (it.hasNext()) {
            if (it.next().isAssignableFrom(type)) {
                it.remove();
            }
        }

        // remove duplicate interfaces (e.g. List already include Collection and Iterable)
        it = contracts.iterator();
        while (it.hasNext()) {
            final Class<?> current = it.next();
            for (Class<?> iface : contracts) {
                if (!current.equals(iface) && current.isAssignableFrom(iface)) {
                    it.remove();
                    break;
                }
            }
        }
    }