add to list of known classes
186194
private void addClassInfo(Object value, Class<?> declaredClass) {
        if (value instanceof Bean && !(value instanceof ImmutableBean)) {
            throw new IllegalArgumentException(
                    "Can only serialize immutable beans in referencing binary format: " + value.getClass().getName());
        }

        if (value instanceof ImmutableBean) {
            boolean isConvertible = settings.getConverter().isConvertible(value.getClass());
            boolean noNeedToSerializeTypeName = declaredClass.equals(value.getClass()) &&
                    (classes.containsKey(value.getClass()) || isConvertible);

            if (noNeedToSerializeTypeName) {
                return;
            }

            ImmutableBean bean = (ImmutableBean) value;
            // Don't need metaproperty info if it's a convertible type
            ClassInfo classInfo = isConvertible ?
                    new ClassInfo(value.getClass(), new MetaProperty<?>[0]) :
                    classInfoFromMetaBean(bean.metaBean(), bean.getClass());

            addClassInfoAndIncrementCount(bean.getClass(), classInfo);
            
        } else if (value instanceof Class<?>) {
            Class<?> type = (Class<?>) value;
            if (type.equals(declaredClass) || settings.getConverter().isConvertible(type)) {
                return;
            }
            if (Bean.class.isAssignableFrom(type) && !ImmutableBean.class.isAssignableFrom(type)) {
                throw new IllegalArgumentException(
                        "Can only serialize immutable beans in referencing binary format: " + type.getName());
            }
            if (ImmutableBean.class.isAssignableFrom(type)) {
                if (classes.containsKey(type)) {
                    classSerializationCount.compute(type, BeanReferences::incrementOrOne);
                    return;
                }
                ClassInfo classInfo;
                if (settings.getConverter().isConvertible(type)) {
                    // Don't need metaproperty info if it's a convertible type
                    classInfo = new ClassInfo(type, new MetaProperty<?>[0]);
                } else {
                    SerDeserializer deser = settings.getDeserializers().findDeserializer(type);
                    MetaBean metaBean = deser.findMetaBean(type);
                    classInfo = classInfoFromMetaBean(metaBean, type);
                }
                addClassInfoAndIncrementCount(type, classInfo);
            }
            
        } else if (declaredClass == Object.class && !value.getClass().equals(String.class)) {
            Class<?> effectiveType = settings.getConverter().findTypedConverter(value.getClass()).getEffectiveType();
            ClassInfo classInfo = new ClassInfo(value.getClass(), new MetaProperty<?>[0]);
            addClassInfoAndIncrementCount(effectiveType, classInfo);
            
        } else if (!settings.getConverter().isConvertible(declaredClass)) {
            ClassInfo classInfo = new ClassInfo(value.getClass(), new MetaProperty<?>[0]);
            addClassInfoAndIncrementCount(value.getClass(), classInfo);
        }
    }
316679
def _import_classes(self, class_names, currmodule):
        # type: (unicode, str) -> List[Any]
        """"""
        classes = []  # type: List[Any]
        for name in class_names:
            classes.extend(import_classes(name, currmodule))
        return classes
1245821
def add_for_targets(self, targets, classpath_elements):
    """"""
    for target in targets:
      self.add_for_target(target, classpath_elements)
633148
def addClassKey(self, klass, key, obj):
        
        d = self._getClass(klass)

        d[key] = obj
1030611
function addClass(element, name) {
    var oldList = classList(element),
        newList = oldList + name;

    if (hasClass(oldList, name)) return; 

    // Trim the opening space.
    element.className = newList.substring(1);
  }
997241
private void addClasses(Class<?>[] classes, HashSet<Class<?>> result){
		
		if(isNull(classes) || classes.length==0)	
			Error.globalClassesAbsent(configuredClass);
		
		for (Class<?> classe : classes)	result.add(classe);
	}
1164411
def DEFINE_list(self, name, default, help, constant=False):
    """"""
    self.AddOption(
        type_info.List(
            name=name,
            default=default,
            description=help,
            validator=type_info.String()),
        constant=constant)
1257195
def add_metaclass(metaclass):
    """"""
    def wrapper(cls):
        orig_vars = cls.__dict__.copy()
        orig_vars.pop('__dict__', None)
        orig_vars.pop('__weakref__', None)
        return metaclass(cls.__name__, cls.__bases__, orig_vars)
    return wrapper
879303
def get_orm_classes(path):
    """"""
    ret = set()
    try:
        m = importlib.import_module(path)

    except ImportError:
        # we have a classpath
        m, klass = get_objects(path)
        if issubclass(klass, Orm):
            ret.add(klass)

    else:
        ret.update(get_subclasses(m, Orm))

    return ret
206697
function (el, cls) {
        cls = getString(cls);
        if (!cls) return;
        if (Array.isArray(cls)) {
            cls.forEach(function(c) {
                dom.addClass(el, c);
            });
        } else if (el.classList) {
            el.classList.add(cls);
        } else {
            if (!hasClass(el, cls)) {
                if (el.classList) {
                    el.classList.add(cls);
                } else {
                    el.className += ' ' + cls;
                }
            }
        }
    }
31373
private void addVetoedClasses(String serviceName, String serviceImpls, ClassLoader classLoader,
        Map<Class<?>, Set<Class<?>>> vetoed) {
        try {
            final Class<?> serviceClass = classLoader.loadClass(serviceName);
            final Set<Class<?>> classes = loadVetoedServiceImpl(serviceImpls, classLoader);

            final Set<Class<?>> registeredVetoedClasses = vetoed.get(serviceClass);
            if (registeredVetoedClasses == null) {
                vetoed.put(serviceClass, classes);
            } else {
                registeredVetoedClasses.addAll(classes);
            }
        } catch (ClassNotFoundException e) {
            // ignores since this is a veto that it is not applicable
        }
    }
515663
def add(class_, name, value, sep=';'):
		
		values = class_.get_values_list(name, sep)
		if value in values:
			return
		new_value = sep.join(values + [value])
		winreg.SetValueEx(
			class_.key, name, 0, winreg.REG_EXPAND_SZ, new_value)
		class_.notify()
149793
def add_class(self, ioclass):
        
        current_ioclasses = self.ioclasses
        if ioclass.name in current_ioclasses.name:
            return
        current_ioclasses.append(ioclass)
        self.modify(new_ioclasses=current_ioclasses)
843732
def classname_list(p)
      classes = []
      while cls = p.hw.ident_chain
        classes << cls
      end
      classes
    end
640848
def match_classes(self, el, classes):
        """"""

        current_classes = self.get_classes(el)
        found = True
        for c in classes:
            if c not in current_classes:
                found = False
                break
        return found
99156
def populate_class_members(self, element_cls, prop_name):
        
        self._element_cls = element_cls
        self._prop_name = prop_name

        self._add_attr_property()
1212380
def do_includes
      @body.scan(/rb_include_module\s*\(\s*(\w+?),\s*(\w+?)\s*\)/) do |c,m|
        if cls = @classes[c]
          m = @known_classes[m] || m
          cls.add_include(Include.new(m, ""))
        end
      end
    end