binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/ModuleGenerator.java

   1 /*
   2  * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.generator.impl.reactor;
   9
  10 import static com.google.common.base.Verify.verify;
  11 import static com.google.common.base.Verify.verifyNotNull;
  12
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import java.util.Map;
  16 import org.eclipse.jdt.annotation.NonNull;
  17 import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
  18 import org.opendaylight.mdsal.binding.generator.impl.rt.DefaultModuleRuntimeType;
  19 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  20 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  21 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
  22 import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
  23 import org.opendaylight.mdsal.binding.runtime.api.AugmentRuntimeType;
  24 import org.opendaylight.mdsal.binding.runtime.api.ModuleRuntimeType;
  25 import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
  26 import org.opendaylight.mdsal.binding.runtime.api.YangDataRuntimeType;
  27 import org.opendaylight.yangtools.yang.binding.contract.Naming;
  28 import org.opendaylight.yangtools.yang.binding.contract.StatementNamespace;
  29 import org.opendaylight.yangtools.yang.common.AbstractQName;
  30 import org.opendaylight.yangtools.yang.common.QNameModule;
  31 import org.opendaylight.yangtools.yang.common.YangDataName;
  32 import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
  33 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
  34
  35 /**
  36  * Generator corresponding to a {@code module} statement. These generators are roots for generating types for a
  37  * particular {@link QNameModule} as mapped into the root package.
  38  */
  39 public final class ModuleGenerator extends AbstractCompositeGenerator<ModuleEffectiveStatement, ModuleRuntimeType> {
  40     private final @NonNull JavaTypeName yangModuleInfo;
  41
  42     /**
  43      * Note that for sake of simplicity of lookup and child mapping, this instance serves as the root for all child
  44      * generators, but mapping to {@link CollisionDomain}s and their {@link Member}s is rather weird. This generator
  45      * actually produces one of <em>secondary</em> members, more precisely the {@link Naming#DATA_ROOT_SUFFIX} one.
  46      * Counter-intuitively the other secondary members live as children of this generator. To support this we also have
  47      * this field, which is actually the <em>primary</em> derived from the module's name.
  48      */
  49     private final Member prefixMember;
  50
  51     ModuleGenerator(final ModuleEffectiveStatement statement) {
  52         super(statement);
  53         yangModuleInfo = JavaTypeName.create(javaPackage(), Naming.MODULE_INFO_CLASS_NAME);
  54         prefixMember = domain().addPrefix(this, new ModuleNamingStrategy(statement.argument()));
  55     }
  56
  57     @Override
  58     StatementNamespace namespace() {
  59         return StatementNamespace.DATA_ROOT;
  60     }
  61
  62     @Override
  63     ModuleGenerator currentModule() {
  64         return this;
  65     }
  66
  67     @Override
  68     void pushToInference(final SchemaInferenceStack dataTree) {
  69         // No-op
  70     }
  71
  72     @Override
  73     String createJavaPackage() {
  74         return Naming.getRootPackageName(statement().localQNameModule());
  75     }
  76
  77     @Override
  78     AbstractCompositeGenerator<?, ?> getPackageParent() {
  79         return this;
  80     }
  81
  82     @Override
  83     CollisionDomain parentDomain() {
  84         return domain();
  85     }
  86
  87     @Override
  88     Member createMember(final CollisionDomain domain) {
  89         return domain.addSecondary(this, prefixMember, Naming.DATA_ROOT_SUFFIX);
  90     }
  91
  92     @Override
  93     GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
  94         final var builder = builderFactory.newGeneratedTypeBuilder(typeName());
  95         builder.setModuleName(statement().argument().getLocalName());
  96         builder.addImplementsType(BindingTypes.DATA_ROOT);
  97
  98         final int usesCount = addUsesInterfaces(builder, builderFactory);
  99         // if we have more than 2 top level uses statements we need to define getImplementedInterface() on the top-level
 100         // DataRoot object
 101         if (usesCount > 1) {
 102             narrowImplementedInterface(builder);
 103         }
 104
 105         addGetterMethods(builder, builderFactory);
 106         builderFactory.addCodegenInformation(statement(), builder);
 107
 108         return builder.build();
 109     }
 110
 111     @NonNull Member getPrefixMember() {
 112         return verifyNotNull(prefixMember);
 113     }
 114
 115     void addQNameConstant(final GeneratedTypeBuilderBase<?> builder, final AbstractQName localName) {
 116         builder.addConstant(BindingTypes.QNAME, Naming.QNAME_STATIC_FIELD_NAME,
 117             Map.entry(yangModuleInfo, localName.getLocalName()));
 118     }
 119
 120     void addNameConstant(final GeneratedTypeBuilderBase<?> builder, final YangDataName templateName) {
 121         builder.addConstant(BindingTypes.YANG_DATA_NAME, Naming.NAME_STATIC_FIELD_NAME,
 122             Map.entry(yangModuleInfo, templateName));
 123     }
 124
 125     @Override
 126     CompositeRuntimeTypeBuilder<ModuleEffectiveStatement, ModuleRuntimeType> createBuilder(
 127             final ModuleEffectiveStatement statement) {
 128         return new CompositeRuntimeTypeBuilder<>(statement) {
 129             @Override
 130             ModuleRuntimeType build(final GeneratedType type, final ModuleEffectiveStatement statement,
 131                     final List<RuntimeType> children, final List<AugmentRuntimeType> augments) {
 132                 verify(augments.isEmpty(), "Unexpected augments %s", augments);
 133
 134                 final var yangDataChildren = new ArrayList<YangDataRuntimeType>();
 135                 for (var child : ModuleGenerator.this) {
 136                     if (child instanceof YangDataGenerator yangDataGen) {
 137                         yangDataChildren.add(yangDataGen.getRuntimeType());
 138                     }
 139                 }
 140
 141                 return new DefaultModuleRuntimeType(type, statement, children, yangDataChildren);
 142             }
 143         };
 144     }
 145 }