protected void updateTraitInformation(
AbstractClassTypeDeclarationDescr typeDescr,
TypeDeclaration type,
ClassDefinition def,
PackageRegistry pkgRegistry) {
if (typeDescr.hasAnnotation(Traitable.class)
|| (!type.getKind().equals(TypeDeclaration.Kind.TRAIT)
&& kbuilder.getPackageRegistry().containsKey(def.getSuperClass())
&& kbuilder
.getPackageRegistry(def.getSuperClass())
.getTraitRegistry()
.getTraitables()
.containsKey(def.getSuperClass()))) {
// traitable
if (type.isNovel()) {
try {
PackageRegistry reg = kbuilder.getPackageRegistry(typeDescr.getNamespace());
String availableName = typeDescr.getType().getFullName();
Class<?> resolvedType = reg.getTypeResolver().resolveType(availableName);
updateTraitDefinition(type, resolvedType, false);
} catch (ClassNotFoundException cnfe) {
// we already know the class exists
}
}
pkgRegistry.getTraitRegistry().addTraitable(def);
} else if (type.getKind().equals(TypeDeclaration.Kind.TRAIT)
|| typeDescr.hasAnnotation(Trait.class)) {
// trait
if (!type.isNovel()) {
try {
PackageRegistry reg = kbuilder.getPackageRegistry(typeDescr.getNamespace());
String availableName = typeDescr.getType().getFullName();
Class<?> resolvedType = reg.getTypeResolver().resolveType(availableName);
if (!Thing.class.isAssignableFrom(resolvedType)) {
if (!resolvedType.isInterface()) {
kbuilder.addBuilderResult(
new TypeDeclarationError(
typeDescr,
"Unable to redeclare concrete class "
+ resolvedType.getName()
+ " as a trait."));
return;
}
updateTraitDefinition(type, resolvedType, false);
String target = typeDescr.getTypeName() + TraitFactory.SUFFIX;
TypeDeclarationDescr tempDescr = new TypeDeclarationDescr();
tempDescr.setNamespace(typeDescr.getNamespace());
tempDescr.setFields(typeDescr.getFields());
tempDescr.setType(target, typeDescr.getNamespace());
tempDescr.setTrait(true);
tempDescr.addSuperType(typeDescr.getType());
tempDescr.setResource(type.getResource());
TypeDeclaration tempDeclr = new TypeDeclaration(target);
tempDeclr.setKind(TypeDeclaration.Kind.TRAIT);
tempDeclr.setTypesafe(type.isTypesafe());
tempDeclr.setNovel(true);
tempDeclr.setTypeClassName(tempDescr.getType().getFullName());
tempDeclr.setResource(type.getResource());
ClassDefinition tempDef = new ClassDefinition(target);
tempDef.setClassName(tempDescr.getType().getFullName());
tempDef.setTraitable(false);
for (FieldDefinition fld : def.getFieldsDefinitions()) {
tempDef.addField(fld);
}
tempDef.setInterfaces(def.getInterfaces());
tempDef.setSuperClass(def.getClassName());
tempDef.setDefinedClass(resolvedType);
tempDef.setAbstrakt(true);
tempDeclr.setTypeClassDef(tempDef);
declaredClassBuilder.generateBeanFromDefinition(
tempDescr, tempDeclr, pkgRegistry, tempDef);
try {
Class<?> clazz =
pkgRegistry.getTypeResolver().resolveType(tempDescr.getType().getFullName());
tempDeclr.setTypeClass(clazz);
pkgRegistry
.getTraitRegistry()
.addTrait(tempDef.getClassName().replace(TraitFactory.SUFFIX, ""), tempDef);
} catch (ClassNotFoundException cnfe) {
kbuilder.addBuilderResult(
new TypeDeclarationError(
typeDescr,
"Internal Trait extension Class '"
+ target
+ "' could not be generated correctly'"));
} finally {
pkgRegistry.getPackage().addTypeDeclaration(tempDeclr);
}
} else {
updateTraitDefinition(type, resolvedType, true);
pkgRegistry.getTraitRegistry().addTrait(def);
}
} catch (ClassNotFoundException cnfe) {
// we already know the class exists
}
} else {
if (def.getClassName().endsWith(TraitFactory.SUFFIX)) {
pkgRegistry
.getTraitRegistry()
.addTrait(def.getClassName().replace(TraitFactory.SUFFIX, ""), def);
} else {
pkgRegistry.getTraitRegistry().addTrait(def);
}
}
}
}
protected void createBean(
AbstractClassTypeDeclarationDescr typeDescr,
PackageRegistry pkgRegistry,
ClassHierarchyManager hierarchyManager,
List<TypeDefinition> unresolvedTypes,
Map<String, AbstractClassTypeDeclarationDescr> unprocesseableDescrs) {
// descriptor needs fields inherited from superclass
if (typeDescr instanceof TypeDeclarationDescr) {
hierarchyManager.inheritFields(
pkgRegistry,
typeDescr,
hierarchyManager.getSortedDescriptors(),
unresolvedTypes,
unprocesseableDescrs);
}
TypeDeclaration type = typeDeclarationFactory.processTypeDeclaration(pkgRegistry, typeDescr);
boolean success = !kbuilder.hasErrors();
try {
// the type declaration is generated in any case (to be used by subclasses, if any)
// the actual class will be generated only if needed
ClassDefinition def = null;
if (success) {
def =
classDefinitionFactory.generateDeclaredBean(
typeDescr, type, pkgRegistry, unresolvedTypes, unprocesseableDescrs);
// now use the definition to compare redeclarations, if any
// this has to be done after the classDef has been generated
if (!type.isNovel()) {
typeDeclarationFactory.checkRedeclaration(typeDescr, type, pkgRegistry);
}
}
success = (def != null) && (!kbuilder.hasErrors());
if (success) {
updateTraitInformation(typeDescr, type, def, pkgRegistry);
}
success = !kbuilder.hasErrors();
if (success) {
declaredClassBuilder.generateBeanFromDefinition(typeDescr, type, pkgRegistry, def);
}
success = !kbuilder.hasErrors();
if (success) {
Class<?> clazz =
pkgRegistry.getTypeResolver().resolveType(typeDescr.getType().getFullName());
type.setTypeClass(clazz);
type.setValid(true);
} else {
unprocesseableDescrs.put(typeDescr.getType().getFullName(), typeDescr);
type.setValid(false);
}
typeDeclarationConfigurator.finalize(
type, typeDescr, pkgRegistry, kbuilder.getPackageRegistry(), hierarchyManager);
} catch (final ClassNotFoundException e) {
unprocesseableDescrs.put(typeDescr.getType().getFullName(), typeDescr);
kbuilder.addBuilderResult(
new TypeDeclarationError(
typeDescr,
"Class '"
+ type.getTypeClassName()
+ "' not found for type declaration of '"
+ type.getTypeName()
+ "'"));
}
if (!success) {
unresolvedTypes.add(new TypeDefinition(type, typeDescr));
} else {
registerGeneratedType(typeDescr);
}
}
