+ private static TypeDefinition<?> getBaseOrDeclaredType(final TypeDefinition<?> typeDef) {
+ final TypeDefinition<?> baseType = typeDef.getBaseType();
+ return (baseType != null && baseType.getBaseType() != null) ? baseType : typeDef;
+ }
+
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ private static GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName,
+ final GeneratedTypeBuilder childOf, final DataSchemaNode node, final SchemaContext schemaContext,
+ final boolean verboseClassComments, Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
+ GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
+
+ if (node.isAugmenting()) {
+ return null;
+ }
+
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, node, childOf, module,
+ genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
+ genType.addComment(node.getDescription());
+ annotateDeprecatedIfNecessary(node.getStatus(), genType);
+ genType.setDescription(createDescription(node, genType.getFullyQualifiedName(), schemaContext,
+ verboseClassComments, namespaceType));
+ genType.setModuleName(module.getName());
+ genType.setReference(node.getReference());
+ genType.setSchemaPath((List) node.getPath().getPathFromRoot());
+ genType.setParentTypeForBuilder(childOf);
+ if (node instanceof DataNodeContainer) {
+ genCtx.get(module).addChildNodeType(node, genType);
+ genCtx = groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings(), genCtx, schemaContext,
+ verboseClassComments, genTypeBuilders, typeProvider);
+ processUsesAugments(schemaContext, (DataNodeContainer) node, module, genCtx, genTypeBuilders,
+ verboseClassComments, typeProvider, namespaceType);
+ }
+ return genType;
+ }
+
+ /**
+ * Converts all <b>groupings</b> of the module to the list of
+ * <code>Type</code> objects. Firstly are groupings sorted according mutual
+ * dependencies. At least dependent (independent) groupings are in the list
+ * saved at first positions. For every grouping the record is added to map
+ * {@link ModuleContext#groupings allGroupings}
+ *
+ * @param module
+ * current module
+ * @param groupings
+ * collection of groupings from which types will be generated
+ * @param typeProvider
+ * provider that defines contract for generated types
+ * @param schemaContext
+ * schema context
+ * @param genCtx
+ * map of generated entities in context of YANG modules
+ * @param genTypeBuilders
+ * map of generated type builders
+ * @param verboseClassComments
+ * generate verbose comments
+ *
+ */
+ static Map<Module, ModuleContext> groupingsToGenTypes(final Module module, final Collection<GroupingDefinition>
+ groupings, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
+ verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+ final String basePackageName = BindingMapping.getRootPackageName(module);
+ final List<GroupingDefinition> groupingsSortedByDependencies = new GroupingDefinitionDependencySort()
+ .sort(groupings);
+ for (final GroupingDefinition grouping : groupingsSortedByDependencies) {
+ genCtx = groupingToGenType(basePackageName, grouping, module, genCtx, schemaContext,
+ verboseClassComments, genTypeBuilders, typeProvider);
+ }
+ return genCtx;
+ }
+
+ /**
+ * Converts individual grouping to GeneratedType. Firstly generated type
+ * builder is created and every child node of grouping is resolved to the
+ * method.
+ *
+ * @param basePackageName
+ * string contains the module package name
+ * @param grouping
+ * GroupingDefinition which contains data about grouping
+ * @param module
+ * current module
+ * @param typeProvider
+ * provider that defines contract for generated types
+ * @param schemaContext
+ * schema context
+ * @param genCtx
+ * map of generated entities in context of YANG modules
+ * @param genTypeBuilders
+ * map of generated type builders
+ * @param verboseClassComments
+ * generate verbose comments
+ *
+ * @return GeneratedType which is generated from grouping (object of type
+ * <code>GroupingDefinition</code>)
+ */
+ private static Map<Module, ModuleContext> groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module
+ module, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
+ verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
+ final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, module, genCtx,
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
+ annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
+ genCtx.get(module).addGroupingType(grouping, genType);
+ resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes(), genCtx,
+ schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
+ genCtx = groupingsToGenTypes(module, grouping.getGroupings(), genCtx, schemaContext, verboseClassComments,
+ genTypeBuilders, typeProvider);
+ genCtx = processUsesAugments(schemaContext, grouping, module, genCtx, genTypeBuilders, verboseClassComments,
+ typeProvider, BindingNamespaceType.Grouping);
+ return genCtx;
+ }
+
+ /**
+ * //TODO: add information about multiple base identities in YANG 1.1
+ * Converts the <b>identity</b> object to GeneratedType. Firstly it is
+ * created transport object builder. If identity contains base identity then
+ * reference to base identity is added to superior identity as its extend.
+ * If identity doesn't contain base identity then only reference to abstract
+ * class {@link org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode
+ * BaseIdentity} is added
+ *
+ * @param module
+ * current module
+ * @param basePackageName
+ * string contains the module package name
+ * @param identity
+ * IdentitySchemaNode which contains data about identity
+ * @param schemaContext
+ * SchemaContext which is used to get package and name
+ * information about base of identity
+ * @param genCtx generated context
+ * @return returns generated context
+ */
+ static Map<Module, ModuleContext> identityToGenType(final Module module, final String basePackageName,
+ final IdentitySchemaNode identity, final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx,
+ boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
+ final TypeProvider typeProvider, Map<QName, GeneratedTOBuilderImpl> generatedIdentities) {
+
+ //check first if identity has been resolved as base identity of some other one
+ GeneratedTOBuilderImpl newType = generatedIdentities.get(identity.getQName());
+
+ if (newType == null) {
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath(),
+ BindingNamespaceType.Identity);
+ newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false);
+ }
+
+ final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
+ if (baseIdentities.size() == 0) {
+ //no base - abstract
+ final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(),
+ BaseIdentity.class.getSimpleName());
+ newType.setExtendsType(gto.toInstance());
+ generatedIdentities.put(identity.getQName(), newType);
+ } else {
+ //one base - inheritance
+ final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
+ final Module baseIdentityParentModule = SchemaContextUtil.findParentModule(schemaContext, baseIdentity);
+ final String returnTypePkgName = new StringBuilder(BindingMapping.getRootPackageName
+ (baseIdentityParentModule))
+ .append('.')
+ .append(BindingNamespaceType.Identity.getPackagePrefix())
+ .toString();
+
+ final GeneratedTOBuilderImpl existingIdentityGto = generatedIdentities.get(baseIdentity.getQName());
+ if (existingIdentityGto != null) {
+ newType.setExtendsType(existingIdentityGto.toInstance());
+ } else {
+ final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(returnTypePkgName,
+ baseIdentity.getQName().getLocalName());
+ newType.setExtendsType(gto.toInstance());
+ generatedIdentities.put(baseIdentity.getQName(), gto);
+ }
+
+ //FIXME: more bases - possible composition, multiple inheritance not possible
+ }
+ generatedIdentities.put(identity.getQName(), newType);
+
+ newType.setAbstract(true);
+ newType.addComment(identity.getDescription());
+ newType.setDescription(createDescription(identity, newType.getFullyQualifiedName(), schemaContext,
+ verboseClassComments, BindingNamespaceType.Identity));
+ newType.setReference(identity.getReference());
+ newType.setModuleName(module.getName());
+ newType.setSchemaPath((List) identity.getPath().getPathFromRoot());
+
+ qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, identity.getQName());
+
+ genCtx.get(module).addIdentityType(identity.getQName(), newType);
+ return genCtx;
+ }