Add function import to builder of this factory by specified class.
@param cls    function import class
965503
public void addFunctionImport(Class<?> cls) {
        EdmFunctionImport functionImportAnnotation = cls.getAnnotation(EdmFunctionImport.class);
        FunctionImportImpl.Builder functionImportBuilder = new FunctionImportImpl.Builder()
                .setEntitySetName(functionImportAnnotation.entitySet())
                .setFunctionName(functionImportAnnotation.namespace() + "." + functionImportAnnotation.function())
                .setIncludeInServiceDocument(functionImportAnnotation.includeInServiceDocument())
                .setName(functionImportAnnotation.name())
                .setJavaClass(cls);

        functionImportBuilders.add(functionImportBuilder);
    }
305649
public static void addImport( Instance instance, String componentOrFacetName, Import imp ) {

		Collection<Import> imports = instance.getImports().get( componentOrFacetName );
		if(imports == null) {
			imports = new LinkedHashSet<Import> ();
			instance.getImports().put( componentOrFacetName, imports );
		}

		if( ! imports.contains( imp ))
			imports.add( imp );
	}
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;
                }
            }
        }
    }
301454
public static DocumentBuilderFactory newInstance(String factoryClassName,
            ClassLoader classLoader) {
        if (factoryClassName == null) {
            throw new FactoryConfigurationError("factoryClassName == null");
        }
        if (classLoader == null) {
            classLoader = Thread.currentThread().getContextClassLoader();
        }
        try {
            Class<?> type = classLoader != null
                    ? classLoader.loadClass(factoryClassName)
                    : Class.forName(factoryClassName);
            return (DocumentBuilderFactory) type.newInstance();
        } catch (ClassNotFoundException e) {
            throw new FactoryConfigurationError(e);
        } catch (InstantiationException e) {
            throw new FactoryConfigurationError(e);
        } catch (IllegalAccessException e) {
            throw new FactoryConfigurationError(e);
        }
    }
763367
def add_service(self, cls):
        
        service_name = get_service_name(cls)
        container = self.container_cls(cls, self.config)
        self.service_map[service_name] = container
227203
public void addImportName(ClassDesc classDesc, EnumConstants importedClass) {
    ClassConstants classConstant = importedClass.getClassConstant();
    String packageName = classConstant.getPackageName();
    if (isImportTargetPackage(classDesc, packageName)) {
      classDesc.addImportName(importedClass.getImportName());
    }
  }
300322
private static void buildClass(StringBuilder builder, Class cls) {
        int arrayDims = 0;
        Class tmp = cls;
        while (tmp.isArray()) {
            arrayDims++;
            tmp = tmp.getComponentType();
        }
        builder.append(tmp.getName());
        if (arrayDims > 0) {
            for (; arrayDims > 0 ; arrayDims--) {
                builder.append("[]");
            }
        }
    }
452253
protected static void buildClassArgument(StringBuilder builder, Class cls) {
        buildClass(builder, cls);
        builder.append(".class");
    }
1294574
public static <T> Parameters.Builder<T> logger(Class<?> cls) {
        return Parameters.<T> builder().logger(cls);
    }
783981
function() {
		var args = Array.prototype.slice.call(arguments);
		args.unshift(null);
		var Factory = classFunc.bind.apply(
			classFunc,
			args
		);
		this._inst = new Factory();
	}
1254882
public void ensureImport(Class<?> cls) {
        if (currentImports.contains(cls.getName()) == false) {
            newImports.add(cls.getName());
        }
    }
998216
@Override
    public T addClasses(Class<?>... classes) throws IllegalArgumentException {
        Validate.notNull(classes, "Classes must be specified");

        for (final Class<?> clazz : classes) {
            Asset resource = new ClassAsset(clazz);
            ArchivePath location = new BasicPath(getClassesPath(), AssetUtil.getFullPathForClassResource(clazz));
            add(resource, location);

            // SHRINKWRAP-335, account for classes loaded from the
            // Bootstrap CL (some JDK impls may return null on class.getClassLoader)
            final ClassLoader loadingCl = clazz.getClassLoader();
            final ClassLoader adjustedCl = loadingCl == null ? ClassLoader.getSystemClassLoader() : loadingCl;

            // Get all inner classes and add them
            addPackages(false, new Filter<ArchivePath>() {
                /**
                 * path = /package/MyClass$Test.class <br/>
                 * clazz = /package/MyClass.class <br/>
                 *
                 *
                 * @param path
                 *            The added classes
                 * @return
                 */
                @Override
                public boolean include(ArchivePath path) {
                    ArchivePath classArchivePath = AssetUtil.getFullPathForClassResource(clazz);
                    String expression = classArchivePath.get().replace(".class", "\\$.*");
                    return path.get().matches(expression);
                };
            }, adjustedCl,
            // Assumes a null package is a class in the default package
                clazz.getPackage() == null ? DEFAULT_PACKAGE_NAME : clazz.getPackage().getName());
        }
        return covarientReturn();
    }
133999
def add(cls, module_name, fsts, composer):
        '''
        
        '''
        cls._to_compose.setdefault(module_name, [])
        cls._to_compose[module_name].append(
            (list(fsts), composer)
        )
        cls._install()
429528
@Override
    @Trivial
    public void addClassLoader(ClassLoader classLoader) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "addClassLoader - " + classLoader);
        }

        if (classLoader instanceof ContainerClassLoader) {
            synchronized (classLoaders) {
                classLoaders.add((ContainerClassLoader) classLoader);
            }
        } else {
            throw new IllegalArgumentException("classLoader is not a ContainerClassLoader");
        }
    }
200981
@PublicAPI(usage = ACCESS)
    public JavaClasses importClasses(Collection<Class<?>> classes) {
        Set<Location> locations = new HashSet<>();
        for (Class<?> clazz : classes) {
            locations.addAll(Locations.ofClass(clazz));
        }
        return importLocations(locations);
    }
870220
def add_class(cls, *args):
        
        for cls2 in args:
            cls.classes[cls2.__name__] = cls2
508586
public AnnotationEntityDataModelFactory addClass(Class<?> cls) {
        EdmEntity entityAnnotation = cls.getAnnotation(EdmEntity.class);
        EdmComplex complexAnnotation = cls.getAnnotation(EdmComplex.class);
        EdmFunction functionAnnotation = cls.getAnnotation(EdmFunction.class);
        EdmFunctionImport functionImportAnnotation = cls.getAnnotation(EdmFunctionImport.class);
        EdmAction actionAnnotation = cls.getAnnotation(EdmAction.class);
        EdmActionImport actionImportAnnotation = cls.getAnnotation(EdmActionImport.class);
        EdmEnum enumAnnotation = cls.getAnnotation(EdmEnum.class);

        Set<Annotation> annotations = new HashSet<>();

        annotations.add(entityAnnotation);
        annotations.add(complexAnnotation);
        annotations.add(functionAnnotation);
        annotations.add(functionImportAnnotation);
        annotations.add(actionAnnotation);
        annotations.add(actionImportAnnotation);
        annotations.add(enumAnnotation);

        checkClassPrecondition(annotations, cls);

        if (entityAnnotation != null) {
            entityClasses.add(cls);
        } else if (complexAnnotation != null) {
            complexClasses.add(cls);
        } else if (functionAnnotation != null) {
            functionClasses.add(cls);
        } else if (functionImportAnnotation != null) {
            functionImportClasses.add(cls);
        } else if (actionAnnotation != null) {
            actionClasses.add(cls);
        } else if (actionImportAnnotation != null) {
            actionImportClasses.add(cls);
        } else if (enumAnnotation != null) {
            if (!cls.isEnum()) {
                throw new IllegalArgumentException("The EdmEnum annotation must only be used on enum classes: " +
                        cls.getName());
            }
            enumClasses.add(cls);
        }
        return this;
    }