インポート名を追加します。

@param classDesc クラス記述
@param importedClassName インポートされるクラスの名前
962951
public void addImportName(ClassDesc classDesc, String importedClassName) {
    String packageName = ClassUtil.getPackageName(importedClassName);
    if (isImportTargetPackage(classDesc, packageName)) {
      classDesc.addImportName(importedClassName);
    }
  }
1114178
@Nonnull
    public BugInstance addClass(String className, String sourceFileName) {
        ClassAnnotation classAnnotation = new ClassAnnotation(className, sourceFileName);
        add(classAnnotation);
        return this;
    }
184292
private static void setImportInfo(Catalog catalog, ImportType importType) {
        if (importType == null) {
            return;
        }
        List<String> streamList = new ArrayList<>();
        List<ImportConfigurationType> kafkaConfigs = new ArrayList<>();

        for (ImportConfigurationType importConfiguration : importType.getConfiguration()) {

            boolean connectorEnabled = importConfiguration.isEnabled();
            if (!connectorEnabled) {
                continue;
            }

            if (importConfiguration.getType().equals(ServerImportEnum.KAFKA)) {
                kafkaConfigs.add(importConfiguration);
            }

            if (!streamList.contains(importConfiguration.getModule())) {
                streamList.add(importConfiguration.getModule());
            }

            buildImportProcessorConfiguration(importConfiguration, true);
        }
        validateKafkaConfig(kafkaConfigs);
    }
935055
@Override
	public void registerBeanDefinitions(final AnnotationMetadata importingClassMetadata,
			final BeanDefinitionRegistry registry) {

		Map<String, Object> componentScan = importingClassMetadata
				.getAnnotationAttributes(RemoteApplicationEventScan.class.getName(),
						false);

		Set<String> basePackages = new HashSet<>();
		for (String pkg : (String[]) componentScan.get("value")) {
			if (StringUtils.hasText(pkg)) {
				basePackages.add(pkg);
			}
		}
		for (String pkg : (String[]) componentScan.get("basePackages")) {
			if (StringUtils.hasText(pkg)) {
				basePackages.add(pkg);
			}
		}
		for (Class<?> clazz : (Class[]) componentScan.get("basePackageClasses")) {
			basePackages.add(ClassUtils.getPackageName(clazz));
		}

		if (basePackages.isEmpty()) {
			basePackages.add(
					ClassUtils.getPackageName(importingClassMetadata.getClassName()));
		}

		BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder
				.genericBeanDefinition(BusJacksonMessageConverter.class);
		beanDefinitionBuilder.addPropertyValue("packagesToScan",
				basePackages.toArray(new String[basePackages.size()]));
		AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();

		BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition,
				"busJsonConverter");
		BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
	}
930327
public void setImportTablesCompleted(java.util.Collection<String> importTablesCompleted) {
        if (importTablesCompleted == null) {
            this.importTablesCompleted = null;
            return;
        }

        this.importTablesCompleted = new com.amazonaws.internal.SdkInternalList<String>(importTablesCompleted);
    }
437215
public void addTranslation (String className, String streamedName)
    {
        if (_translations == null) {
            _translations = Maps.newHashMap();
        }
        _translations.put(className, streamedName);
    }
417638
protected Class resolveClass(ObjectStreamClass classDesc) throws IOException, ClassNotFoundException {
		try {
			return getClass().getClassLoader().loadClass(classDesc.getName());
		} catch (ClassNotFoundException ex) {
			ClassLoader tccl = Thread.currentThread().getContextClassLoader();
			if (tccl != null) {
				return tccl.loadClass(classDesc.getName());
			} else {
				throw ex;
			}
		}
	}
679108
public void addClassElement(final String className, final MetadataElement classElement) {
        classElement.setType(getNamespaceValue(classElement.getType()));

        if (classElement.getMaxOccurs() != null && !classElement.getMaxOccurs().equals("1")) {
            classElement.setMaxOccurs("unbounded");
        }

        for (MetadataItem item : classList) {
            if (item.getName().equals(className) && item.getNamespace().equals(getCurrentNamespace())
                && item.getPackageApi().equals(getCurrentPackageApi())) {
                // check for a element with the same name, if found then set 'maxOccurs = unbounded'
                for (MetadataElement element : item.getElements()) {
                    if (element.getName().equals(classElement.getName()) && !classElement.getIsAttribute()) {
                        element.setMaxOccurs("unbounded");
                        return;
                    }
                }

                item.getElements().add(classElement);
                return;
            }
        }

        final MetadataItem newItem = new MetadataItem(className);
        newItem.getElements().add(classElement);
        newItem.setNamespace(getCurrentNamespace());
        newItem.setSchemaName(getCurrentSchmema());
        newItem.setPackageApi(getCurrentPackageApi());
        newItem.setPackageImpl(getCurrentPackageImpl());
        classList.add(newItem);
    }
949038
public void addAccessorAnnotationDescriptor(String annotationDesc) {
        if (mAnnotationDescs == null) {
            mAnnotationDescs = new ArrayList<String>(4);
        }
        mAnnotationDescs.add(annotationDesc);
    }
1053241
public static void addExistingImports (String asFile, ImportSet imports)
    {
        // Discover the location of the 'public class' declaration.
        // We won't search past there.
        Matcher m = AS_PUBLIC_CLASS_DECL.matcher(asFile);
        int searchTo = asFile.length();
        if (m.find()) {
            searchTo = m.start();
        }

        m = AS_IMPORT.matcher(asFile.substring(0, searchTo));
        while (m.find()) {
            imports.add(m.group(3));
        }
    }
626544
private void register(String converterClassName) {

    Class<Converter> converterClass = ObjectUtils.loadClass(converterClassName);

    if (ObjectUtils.assignableTo(converterClass, Converter.class)) {
      try {
        Converter<?, ?> converter = (Converter<?, ?>) converterClass.newInstance();
        register(converter);
      }
      catch (Exception ignore) {
      }
    }
  }
1195884
public ImportDescr importStatement( PackageDescrBuilder pkg ) throws RecognitionException {
        ImportDescrBuilder imp = null;
        try {
            imp = helper.start( pkg,
                                ImportDescrBuilder.class,
                                null );

            // import
            match( input,
                   DRL5Lexer.ID,
                   DroolsSoftKeywords.IMPORT,
                   null,
                   DroolsEditorType.KEYWORD );
            if ( state.failed ) return null;

            String kwd;
            if ( helper.validateIdentifierKey( kwd = DroolsSoftKeywords.FUNCTION ) ||
                 helper.validateIdentifierKey( kwd = DroolsSoftKeywords.STATIC ) ) {
                // function
                match( input,
                       DRL5Lexer.ID,
                       kwd,
                       null,
                       DroolsEditorType.KEYWORD );
                if ( state.failed ) return null;
            }

            // qualifiedIdentifier
            String target = qualifiedIdentifier();
            if ( state.failed ) return null;

            if ( input.LA( 1 ) == DRL5Lexer.DOT && input.LA( 2 ) == DRL5Lexer.STAR ) {
                // .*
                match( input,
                       DRL5Lexer.DOT,
                       null,
                       null,
                       DroolsEditorType.IDENTIFIER );
                if ( state.failed ) return null;
                match( input,
                       DRL5Lexer.STAR,
                       null,
                       null,
                       DroolsEditorType.IDENTIFIER );
                if ( state.failed ) return null;
                target += ".*";
            }
            if ( state.backtracking == 0 ) imp.target( target );

        } catch ( RecognitionException re ) {
            reportError( re );
        } finally {
            helper.end( ImportDescrBuilder.class,
                        imp );
        }
        return (imp != null) ? imp.getDescr() : null;
    }
633880
private void addAlternateNamedFacesConfig(Container moduleContainer, ArrayList<String> classList) {
        try {
            WebApp webapp = moduleContainer.adapt(WebApp.class);

            //If null, assume there was no web.xml, so no need to look for ContextParams in it.
            if (webapp == null) {
                return;
            }

            List<ParamValue> params = webapp.getContextParams();
            String configNames = null;
            for (ParamValue param : params) {
                if (param.getName().equals(FACES_CONFIG_NAMES)) {
                    configNames = param.getValue();
                    break;
                }
            }

            //If we didn't find the param, then bail out
            if (configNames == null)
                return;

            //Treat value as a comma delimited list of file names
            StringTokenizer st = new StringTokenizer(configNames, ",");
            while (st.hasMoreTokens()) {
                addConfigFileBeans(moduleContainer.getEntry(st.nextToken()), classList);
            }

        } catch (UnableToAdaptException e) {
            if (log.isLoggable(Level.FINE)) {
                log.logp(Level.FINE, CLASS_NAME, "addAlternateNamedFacesConfig", "failed to adapt conatiner to WebApp", e);
            }
        }
    }
1150822
protected Class resolveClass(ObjectStreamClass classDesc)
            throws IOException, ClassNotFoundException {
        String className = classDesc.getName();
        try {
            return loader.loadClass(className);
        } catch (ClassNotFoundException exp) {
            return super.resolveClass(classDesc);
        }
    }
1223071
public void importClass(final String name) {
        this.importedClasses.put(Name.suffix(name, 1), name);
        this.nameSpaceChanged();
    }
627691
public void addActionImport(Class<?> cls) {
        EdmActionImport actionImportAnnotation = cls.getAnnotation(EdmActionImport.class);
        ActionImportImpl.Builder actionImportBuilder = new ActionImportImpl.Builder()
                .setEntitySetName(actionImportAnnotation.entitySet())
                .setActionName(actionImportAnnotation.namespace() + "." + actionImportAnnotation.action())
                .setName(actionImportAnnotation.name())
                .setJavaClass(cls);

        actionImportBuilders.add(actionImportBuilder);
    }
977973
@Nonnull
    public BugInstance addClass(ClassNode classNode) {
        String dottedClassName = ClassName.toDottedClassName(classNode.name);
        ClassAnnotation classAnnotation = new ClassAnnotation(dottedClassName);
        add(classAnnotation);
        return this;
    }