private void initPackageRegistries(Collection<CompositePackageDescr> packages) {
for (CompositePackageDescr packageDescr : packages) {
if (kBuilder.getPackageRegistry(packageDescr.getName()) == null) {
if (StringUtils.isEmpty(packageDescr.getName())) {
packageDescr.setName(kBuilder.getBuilderConfiguration().getDefaultPackageName());
}
kBuilder.createPackageRegistry(packageDescr);
}
}
}
/**
* ********************************************************************************************************************************************************************
* 1) Process the TypeDeclaration Descriptors Resolve names Normalize field descriptors
* ********************************************************************************************************************************************************************
*/
public void processTypeDeclarations(
Collection<? extends PackageDescr> packageDescrs,
Collection<AbstractClassTypeDeclarationDescr> unsortedDescrs,
List<TypeDefinition> unresolvedTypes,
Map<String, AbstractClassTypeDeclarationDescr> unprocesseableDescrs) {
// init package to ensure type resolvers are available
for (PackageDescr packageDescr : packageDescrs) {
if (kbuilder.getPackageRegistry(packageDescr.getName()) == null) {
kbuilder.createPackageRegistry(packageDescr);
}
}
setResourcesInDescriptors(packageDescrs);
// ensure all names are fully qualified before continuing
typeDeclarationNameResolver.resolveTypes(packageDescrs, unresolvedTypes);
// create "implicit" packages
for (PackageDescr packageDescr : packageDescrs) {
normalizeForeignPackages(packageDescr);
}
// merge "duplicate" definitions and declarations
unsortedDescrs = compactDefinitionsAndDeclarations(unsortedDescrs, unprocesseableDescrs);
// now sort declarations by mutual dependencies
ClassHierarchyManager classHierarchyManager =
new ClassHierarchyManager(unsortedDescrs, kbuilder);
for (AbstractClassTypeDeclarationDescr typeDescr :
classHierarchyManager.getSortedDescriptors()) {
PackageRegistry pkgRegistry = kbuilder.getPackageRegistry(typeDescr.getNamespace());
createBean(
typeDescr, pkgRegistry, classHierarchyManager, unresolvedTypes, unprocesseableDescrs);
}
for (AbstractClassTypeDeclarationDescr typeDescr :
classHierarchyManager.getSortedDescriptors()) {
if (!unprocesseableDescrs.containsKey(typeDescr.getType().getFullName())) {
PackageRegistry pkgRegistry = kbuilder.getPackageRegistry(typeDescr.getNamespace());
typeDeclarationConfigurator.wireFieldAccessors(
pkgRegistry,
typeDescr,
pkgRegistry.getPackage().getTypeDeclaration(typeDescr.getType().getName()));
}
}
}
protected void normalizeForeignPackages(PackageDescr packageDescr) {
Map<String, PackageDescr> foreignPackages = null;
for (AbstractClassTypeDeclarationDescr typeDescr :
packageDescr.getClassAndEnumDeclarationDescrs()) {
if (kbuilder.filterAccepts(
ResourceChange.Type.DECLARATION, typeDescr.getNamespace(), typeDescr.getTypeName())) {
if (!typeDescr.getNamespace().equals(packageDescr.getNamespace())) {
// If the type declaration is for a different namespace, process that separately.
PackageDescr altDescr;
if (foreignPackages == null) {
foreignPackages = new HashMap<String, PackageDescr>();
}
if (foreignPackages.containsKey(typeDescr.getNamespace())) {
altDescr = foreignPackages.get(typeDescr.getNamespace());
} else {
altDescr = new PackageDescr(typeDescr.getNamespace());
altDescr.setResource(packageDescr.getResource());
foreignPackages.put(typeDescr.getNamespace(), altDescr);
}
if (typeDescr instanceof TypeDeclarationDescr) {
altDescr.addTypeDeclaration((TypeDeclarationDescr) typeDescr);
} else if (typeDescr instanceof EnumDeclarationDescr) {
altDescr.addEnumDeclaration((EnumDeclarationDescr) typeDescr);
}
for (ImportDescr imp : packageDescr.getImports()) {
altDescr.addImport(imp);
}
if (!kbuilder.getPackageRegistry().containsKey(altDescr.getNamespace())) {
kbuilder.createPackageRegistry(altDescr);
}
}
}
}
}
