import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.mdsal.binding.generator.BindingGeneratorUtil;
import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.GeneratedType;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotableTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
import org.opendaylight.mdsal.binding.model.ri.Types;
import org.opendaylight.mdsal.binding.model.ri.generated.type.builder.GeneratedPropertyBuilderImpl;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.binding.DataContainer;
-import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.ri.type.TypeBuilder;
/**
* A single node in generator tree. Each node will eventually resolve to a generated Java class. Each node also can have
* a number of children, which are generators corresponding to the YANG subtree of this node.
+ *
+ * <p>
+ * Each tree is rooted in a {@link ModuleGenerator} and its organization follows roughly YANG {@code schema tree}
+ * layout, but with a twist coming from the reuse of generated interfaces from a {@code grouping} in the location of
+ * every {@code uses} encountered and also the corresponding backwards propagation of {@code augment} effects.
+ *
+ * <p>
+ * Overall the tree layout guides the allocation of Java package and top-level class namespaces.
*/
public abstract class Generator implements Iterable<Generator> {
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;
private String javaPackage;
Generator() {
- this.parent = null;
+ 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 true;
}
- @Nullable AbstractExplicitGenerator<?> findGenerator(final EffectiveStatement<?, ?> stmt) {
- return null;
- }
-
- final @NonNull AbstractExplicitGenerator<?> getGenerator(final EffectiveStatement<?, ?> stmt) {
- return verifyNotNull(findGenerator(stmt), "Cannot match statement %s in %s", stmt, this);
- }
-
/**
* Return the namespace of this statement.
*
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;
}
}
- static final void addCodegenInformation(final EffectiveStatement<?, ?> stmt,
- final GeneratedTypeBuilderBase<?> builder) {
- if (stmt instanceof DocumentedNode) {
- addCodegenInformation((DocumentedNode) stmt, builder);
- }
- }
-
- static final void addCodegenInformation(final DocumentedNode node, final GeneratedTypeBuilderBase<?> builder) {
- node.getDescription().map(BindingGeneratorUtil::encodeAngleBrackets).ifPresent(builder::setDescription);
- node.getReference().ifPresent(builder::setReference);
- }
-
- static final void addCodegenInformation(final ModuleGenerator module, final EffectiveStatement<?, ?> stmt,
- final GeneratedTypeBuilderBase<?> builder) {
- if (stmt instanceof DocumentedNode) {
- final DocumentedNode node = (DocumentedNode) stmt;
- TypeComments.description(node).ifPresent(builder::addComment);
- node.getDescription().ifPresent(builder::setDescription);
- node.getReference().ifPresent(builder::setReference);
- }
- if (stmt instanceof SchemaNode) {
- YangSourceDefinition.of(module.statement(), (SchemaNode) stmt).ifPresent(builder::setYangSourceDefinition);
- }
- }
-
static final void addUnits(final GeneratedTOBuilder builder, final TypeDefinition<?> typedef) {
typedef.getUnits().ifPresent(units -> {
if (!units.isEmpty()) {
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);
Code Review / mdsal.git / blobdiff