private static final JavaTypeName DEPRECATED_ANNOTATION = JavaTypeName.create(Deprecated.class);
static final JavaTypeName OVERRIDE_ANNOTATION = JavaTypeName.create(Override.class);
- private final AbstractCompositeGenerator<?> parent;
+ private final AbstractCompositeGenerator<?, ?> parent;
private Optional<Member> member;
private GeneratorResult result;
parent = null;
}
- Generator(final AbstractCompositeGenerator<?> parent) {
+ Generator(final AbstractCompositeGenerator<?, ?> parent) {
this.parent = requireNonNull(parent);
}
*
* @return Parent generator
*/
- final @NonNull AbstractCompositeGenerator<?> getParent() {
+ final @NonNull AbstractCompositeGenerator<?, ?> getParent() {
return verifyNotNull(parent, "No parent for %s", this);
}
return JavaTypeName.create(getPackageParent().javaPackage(), assignedName());
}
- @NonNull AbstractCompositeGenerator<?> getPackageParent() {
+ @NonNull AbstractCompositeGenerator<?, ?> getPackageParent() {
return getParent();
}
}
final void addImplementsChildOf(final GeneratedTypeBuilder builder) {
- AbstractCompositeGenerator<?> ancestor = getParent();
+ AbstractCompositeGenerator<?, ?> ancestor = getParent();
while (true) {
// choice/case hierarchy does not factor into 'ChildOf' hierarchy, hence we need to skip them
if (ancestor instanceof CaseGenerator || ancestor instanceof ChoiceGenerator) {
// if we into a choice we need to follow the hierararchy of that choice
if (ancestor instanceof AbstractAugmentGenerator) {
- final AbstractCompositeGenerator<?> target = ((AbstractAugmentGenerator) ancestor).targetGenerator();
+ final AbstractCompositeGenerator<?, ?> target = ((AbstractAugmentGenerator) ancestor).targetGenerator();
if (target instanceof ChoiceGenerator) {
ancestor = target;
continue;
defineImplementedInterfaceMethod(builder, Type.of(builder)).setDefault(true);
}
- static final <T extends EffectiveStatement<?, ?>> AbstractExplicitGenerator<T> getChild(final Generator parent,
+ static final <T extends EffectiveStatement<?, ?>> AbstractExplicitGenerator<T, ?> getChild(final Generator parent,
final Class<T> type) {
for (Generator child : parent) {
if (child instanceof AbstractExplicitGenerator) {
@SuppressWarnings("unchecked")
- final AbstractExplicitGenerator<T> explicit = (AbstractExplicitGenerator<T>)child;
+ final AbstractExplicitGenerator<T, ?> explicit = (AbstractExplicitGenerator<T, ?>)child;
if (type.isInstance(explicit.statement())) {
return explicit;
}
private static MethodSignatureBuilder defineImplementedInterfaceMethod(final GeneratedTypeBuilder typeBuilder,
final Type classType) {
final MethodSignatureBuilder ret = typeBuilder
- .addMethod(BindingMapping.DATA_CONTAINER_IMPLEMENTED_INTERFACE_NAME)
+ .addMethod(BindingMapping.BINDING_CONTRACT_IMPLEMENTED_INTERFACE_NAME)
.setAccessModifier(AccessModifier.PUBLIC)
.setReturnType(classType(classType));
ret.addAnnotation(OVERRIDE_ANNOTATION);