*/
private final SchemaContext schemaContext;
- AbstractTypeGenerator(final SchemaContext context, final AbstractTypeProvider typeProvider) {
+ /**
+ * Holds renamed elements.
+ */
+ private final Map<SchemaNode, JavaTypeName> renames;
+
+ AbstractTypeGenerator(final SchemaContext context, final AbstractTypeProvider typeProvider,
+ final Map<SchemaNode, JavaTypeName> renames) {
this.schemaContext = requireNonNull(context);
this.typeProvider = requireNonNull(typeProvider);
+ this.renames = requireNonNull(renames);
final List<Module> contextModules = ModuleDependencySort.sort(schemaContext.getModules());
final List<ModuleContext> contexts = new ArrayList<>(contextModules.size());
if (typedef != null) {
final Type type = typeProvider.generatedTypeForExtendedDefinitionType(typedef, typedef);
if (type != null) {
- context.addTypedefType(typedef.getPath(), type);
+ context.addTypedefType(typedef, type);
context.addTypeToSchema(type,typedef);
}
}
if (identity == null) {
return;
}
- final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(JavaTypeName.create(
- packageNameForGeneratedType(context.modulePackageName(), identity.getPath()),
- BindingMapping.getClassName(identity.getQName())));
+
+ JavaTypeName name = renames.get(identity);
+ if (name == null) {
+ name = JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), identity.getPath()),
+ BindingMapping.getClassName(identity.getQName()));
+ }
+
+ final GeneratedTypeBuilder newType = typeProvider.newGeneratedTypeBuilder(name);
final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
if (!baseIdentities.isEmpty()) {
for (IdentitySchemaNode baseIdentity : baseIdentities) {
- final QName qname = baseIdentity.getQName();
- final GeneratedTransferObject gto = typeProvider.newGeneratedTOBuilder(JavaTypeName.create(
- BindingMapping.getRootPackageName(qname.getModule()), BindingMapping.getClassName(qname))).build();
+ JavaTypeName base = renames.get(baseIdentity);
+ if (base == null) {
+ final QName qname = baseIdentity.getQName();
+ base = JavaTypeName.create(BindingMapping.getRootPackageName(qname.getModule()),
+ BindingMapping.getClassName(qname));
+ }
+
+ final GeneratedTransferObject gto = typeProvider.newGeneratedTOBuilder(base).build();
newType.addImplementsType(gto);
}
} else {
qnameConstant(newType, JavaTypeName.create(context.modulePackageName(), BindingMapping.MODULE_INFO_CLASS_NAME),
identity.getQName().getLocalName());
- context.addIdentityType(identity.getQName(), newType);
+ context.addIdentityType(identity, newType);
}
private static Constant qnameConstant(final GeneratedTypeBuilderBase<?> toBuilder,
// node of grouping is resolved to the method.
final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, grouping);
annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
- context.addGroupingType(grouping.getPath(), genType);
+ context.addGroupingType(grouping, genType);
resolveDataSchemaNodes(context, genType, genType, grouping.getChildNodes());
groupingsToGenTypes(context, grouping.getGroupings());
processUsesAugments(grouping, context);
*/
private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
final Type baseInterface, final ModuleContext context) {
- final GeneratedTypeBuilder it = addRawInterfaceDefinition(
- JavaTypeName.create(packageName, BindingMapping.getClassName(schemaNode.getQName())), schemaNode);
+ JavaTypeName name = renames.get(schemaNode);
+ if (name == null) {
+ name = JavaTypeName.create(packageName, BindingMapping.getClassName(schemaNode.getQName()));
+ }
+
+ final GeneratedTypeBuilder it = addRawInterfaceDefinition(name, schemaNode);
it.addImplementsType(baseInterface);
if (!(schemaNode instanceof GroupingDefinition)) {
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
+import java.util.IdentityHashMap;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import org.opendaylight.mdsal.binding.generator.api.BindingGenerator;
import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeGenerator;
import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeTypes;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class BindingGeneratorImpl implements BindingGenerator, BindingRuntimeGenerator {
+ private static final Logger LOG = LoggerFactory.getLogger(BindingGeneratorImpl.class);
+
/**
* Resolves generated types from <code>context</code> schema nodes only for
* modules specified in <code>modules</code>
public List<Type> generateTypes(final SchemaContext context, final Set<Module> modules) {
checkContext(context);
checkArgument(modules != null, "Set of Modules cannot be NULL.");
- return new CodegenTypeGenerator(context).toTypes(modules);
+
+ final Map<SchemaNode, JavaTypeName> renames = new IdentityHashMap<>();
+ for (;;) {
+ try {
+ return new CodegenTypeGenerator(context, renames).toTypes(modules);
+ } catch (RenameMappingException e) {
+ rename(renames, e);
+ }
+ }
}
@Override
public BindingRuntimeTypes generateTypeMapping(final SchemaContext context) {
checkContext(context);
- return new RuntimeTypeGenerator(context).toTypeMapping();
+
+ final Map<SchemaNode, JavaTypeName> renames = new IdentityHashMap<>();
+ for (;;) {
+ try {
+ return new RuntimeTypeGenerator(context, renames).toTypeMapping();
+ } catch (RenameMappingException e) {
+ rename(renames, e);
+ }
+ }
}
private static void checkContext(final SchemaContext context) {
checkArgument(context != null, "Schema Context reference cannot be NULL.");
checkState(context.getModules() != null, "Schema Context does not contain defined modules.");
}
+
+ private static void rename(final Map<SchemaNode, JavaTypeName> renames, final RenameMappingException e) {
+ final JavaTypeName name = e.getName();
+ final SchemaNode def = e.getDefinition();
+ final JavaTypeName existing = renames.get(def);
+ if (existing != null) {
+ throw new IllegalStateException("Attempted to relocate " + def + " to " + name + ", already remapped to "
+ + existing, e);
+ }
+
+ final String suffix;
+ if (def instanceof IdentitySchemaNode) {
+ suffix = "$I";
+ } else if (def instanceof GroupingDefinition) {
+ suffix = "$G";
+ } else if (def instanceof TypeDefinition) {
+ suffix = "$T";
+ } else {
+ throw new IllegalStateException("Unhandled remapping of " + def + " at " + name, e);
+ }
+
+ final JavaTypeName newName = name.createSibling(name.simpleName() + suffix);
+ renames.put(def, newName);
+ LOG.debug("Restarting code generation after remapping {} to {}", name, newName);
+ }
}
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.Set;
+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.GeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
final class CodegenTypeGenerator extends AbstractTypeGenerator {
- CodegenTypeGenerator(final SchemaContext context) {
- super(context, new CodegenTypeProvider(context));
+ CodegenTypeGenerator(final SchemaContext context, final Map<SchemaNode, JavaTypeName> renames) {
+ super(context, new CodegenTypeProvider(context, renames), renames);
}
List<Type> toTypes(final Set<Module> modules) {
import java.util.Map;
import java.util.Set;
import javax.annotation.concurrent.NotThreadSafe;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@NotThreadSafe
public final class ModuleContext {
+ private static final Logger LOG = LoggerFactory.getLogger(ModuleContext.class);
+
private final BiMap<Type, AugmentationSchemaNode> typeToAugmentation = HashBiMap.create();
private final Map<SchemaPath, GeneratedTypeBuilder> childNodes = new HashMap<>();
private final Map<SchemaPath, GeneratedTypeBuilder> groupings = new HashMap<>();
private final Map<SchemaPath, Type> typedefs = new HashMap<>();
private final Module module;
+ // Conflict mapping
+ private final Map<JavaTypeName, SchemaNode> nameMapping = new HashMap<>();
+
private GeneratedTypeBuilder moduleNode;
private String modulePackageName;
genTOs.add(b);
}
- public void addChildNodeType(final SchemaNode p, final GeneratedTypeBuilder b) {
- childNodes.put(p.getPath(), b);
- typeToSchema.put(b,p);
+ public void addChildNodeType(final SchemaNode def, final GeneratedTypeBuilder b) {
+ checkNamingConflict(def, b.getIdentifier());
+ childNodes.put(def.getPath(), b);
+ typeToSchema.put(b, def);
}
- public void addGroupingType(final SchemaPath p, final GeneratedTypeBuilder b) {
- groupings.put(p, b);
+ public void addGroupingType(final GroupingDefinition def, final GeneratedTypeBuilder b) {
+ checkNamingConflict(def, b.getIdentifier());
+ groupings.put(def.getPath(), b);
}
- public void addTypedefType(final SchemaPath p, final Type t) {
- typedefs.put(p, t);
+ public void addTypedefType(final TypeDefinition<?> def, final Type t) {
+ final JavaTypeName name = t.getIdentifier();
+ final SchemaNode existingDef = nameMapping.putIfAbsent(name, def);
+ if (existingDef != null) {
+ if (!(existingDef instanceof TypeDefinition)) {
+ throw resolveNamingConfict(existingDef, def, name);
+ }
+
+ // This seems to be fine
+ LOG.debug("GeneratedType conflict between {} and {} on {}", def, existingDef, name);
+ }
+
+ typedefs.put(def.getPath(), t);
}
public void addCaseType(final SchemaPath p, final GeneratedTypeBuilder b) {
cases.put(p, b);
}
- public void addIdentityType(final QName name,final GeneratedTypeBuilder b) {
- identities.put(name, b);
+ public void addIdentityType(final IdentitySchemaNode def, final GeneratedTypeBuilder b) {
+ checkNamingConflict(def, b.getIdentifier());
+ identities.put(def.getQName(), b);
}
public void addTopLevelNodeType(final GeneratedTypeBuilder b) {
return innerTypes.get(path);
}
+ private void checkNamingConflict(final SchemaNode def, final JavaTypeName name) {
+ final SchemaNode existingDef = nameMapping.putIfAbsent(name, def);
+ if (existingDef != null) {
+ if (def.equals(existingDef)) {
+ if (LOG.isDebugEnabled()) {
+ // TODO: this should not really be happening
+ LOG.debug("Duplicate definition on {} as {}", name, def, new Throwable());
+ }
+ } else {
+ throw resolveNamingConfict(existingDef, def, name);
+ }
+ }
+ }
+
+ private static IllegalStateException resolveNamingConfict(final SchemaNode existing, final SchemaNode incoming,
+ final JavaTypeName name) {
+ if (existing instanceof IdentitySchemaNode) {
+ if (incoming instanceof GroupingDefinition || incoming instanceof TypeDefinition
+ || incoming instanceof DataSchemaNode || incoming instanceof NotificationDefinition
+ || incoming instanceof OperationDefinition) {
+ return new RenameMappingException(name, existing);
+ }
+ } else if (existing instanceof GroupingDefinition) {
+ if (incoming instanceof IdentitySchemaNode) {
+ return new RenameMappingException(name, incoming);
+ }
+ if (incoming instanceof TypeDefinition || incoming instanceof DataSchemaNode
+ || incoming instanceof NotificationDefinition || incoming instanceof OperationDefinition) {
+ return new RenameMappingException(name, existing);
+ }
+ } else if (existing instanceof TypeDefinition) {
+ if (incoming instanceof GroupingDefinition || incoming instanceof IdentitySchemaNode) {
+ return new RenameMappingException(name, incoming);
+ }
+ if (incoming instanceof DataSchemaNode || incoming instanceof NotificationDefinition
+ || incoming instanceof OperationDefinition) {
+ return new RenameMappingException(name, existing);
+ }
+ } else {
+ if (incoming instanceof GroupingDefinition || incoming instanceof IdentitySchemaNode
+ || incoming instanceof TypeDefinition) {
+ return new RenameMappingException(name, incoming);
+ }
+ }
+
+ return new IllegalStateException(String.format("Unhandled GeneratedType conflict between %s and %s on %s",
+ incoming, existing, name));
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl;
+
+import static java.util.Objects.requireNonNull;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+
+/**
+ * Exception thrown from ModuleContext when it detects a Java namespace clash between generated classes. This can occur
+ * because we are mapping multiple YANG namespaces to a single Java class namespace.
+ *
+ * <p>
+ * While handling this case via an exception (and related mechanics) is a bit slow, it works with minimal disturbance
+ * of existing logic. The situation should not be very common and hence it should provide an acceptable performance
+ * envelope.
+ *
+ * @author Robert Varga
+ */
+@NonNullByDefault
+final class RenameMappingException extends IllegalStateException {
+ private static final long serialVersionUID = 1L;
+
+ private final JavaTypeName name;
+ private final SchemaNode definition;
+
+ RenameMappingException(final JavaTypeName name, final SchemaNode definition) {
+ super("Remap " + name + " occupant " + definition);
+ this.name = requireNonNull(name);
+ this.definition = requireNonNull(definition);
+ }
+
+ JavaTypeName getName() {
+ return name;
+ }
+
+ SchemaNode getDefinition() {
+ return definition;
+ }
+}
import java.util.Map.Entry;
import java.util.Set;
import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeTypes;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
final class RuntimeTypeGenerator extends AbstractTypeGenerator {
- RuntimeTypeGenerator(final SchemaContext context) {
- super(context, new RuntimeTypeProvider(context));
+ RuntimeTypeGenerator(final SchemaContext context, final Map<SchemaNode, JavaTypeName> renames) {
+ super(context, new RuntimeTypeProvider(context, renames), renames);
}
BindingRuntimeTypes toTypeMapping() {
*/
package org.opendaylight.mdsal.binding.yang.types;
+import static java.util.Objects.requireNonNull;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNodeForRelativeXPath;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
*/
private final Map<SchemaPath, Type> referencedTypes = new HashMap<>();
private final Map<Module, Set<Type>> additionalTypes = new HashMap<>();
+ private final Map<SchemaNode, JavaTypeName> renames;
/**
* Creates new instance of class <code>TypeProviderImpl</code>.
*
* @param schemaContext
* contains the schema data red from YANG files
+ * @param renames
* @throws IllegalArgumentException
* if <code>schemaContext</code> equal null.
*/
- AbstractTypeProvider(final SchemaContext schemaContext) {
+ AbstractTypeProvider(final SchemaContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
Preconditions.checkArgument(schemaContext != null, "Schema Context cannot be null!");
this.schemaContext = schemaContext;
+ this.renames = requireNonNull(renames);
resolveTypeDefsFromContext();
}
*/
private GeneratedTOBuilder typedefToTransferObject(final String basePackageName,
final TypeDefinition<?> typedef, final String moduleName) {
- final GeneratedTOBuilder newType = newGeneratedTOBuilder(JavaTypeName.create(
- BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typedef.getPath()),
- BindingMapping.getClassName(typedef.getQName().getLocalName())));
+ JavaTypeName name = renames.get(typedef);
+ if (name == null) {
+ name = JavaTypeName.create(
+ BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typedef.getPath()),
+ BindingMapping.getClassName(typedef.getQName().getLocalName()));
+ }
+
+ final GeneratedTOBuilder newType = newGeneratedTOBuilder(name);
newType.setSchemaPath(typedef.getPath());
newType.setModuleName(moduleName);
addCodegenInformation(newType, typedef);
import static org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil.encodeAngleBrackets;
import com.google.common.annotations.Beta;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import java.util.List;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.binding.RegexPatterns;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
* Creates new instance of class <code>TypeProviderImpl</code>.
*
* @param schemaContext contains the schema data read from YANG files
+ * @param renames
* @throws IllegalArgumentException if <code>schemaContext</code> is null.
*/
- public CodegenTypeProvider(final SchemaContext schemaContext) {
- super(schemaContext);
+ public CodegenTypeProvider(final SchemaContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
+ super(schemaContext, renames);
+ }
+
+ @VisibleForTesting
+ CodegenTypeProvider(final SchemaContext schemaContext) {
+ this(schemaContext, ImmutableMap.of());
}
@Override
package org.opendaylight.mdsal.binding.yang.types;
import com.google.common.annotations.Beta;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableMap;
import java.util.List;
import java.util.Map;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.RuntimeGeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.RuntimeGeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
*/
@Beta
public final class RuntimeTypeProvider extends AbstractTypeProvider {
- public RuntimeTypeProvider(final SchemaContext schemaContext) {
- super(schemaContext);
+ public RuntimeTypeProvider(final SchemaContext schemaContext, final Map<SchemaNode, JavaTypeName> renames) {
+ super(schemaContext, renames);
+ }
+
+ @VisibleForTesting
+ RuntimeTypeProvider(final SchemaContext schemaContext) {
+ this(schemaContext, ImmutableMap.of());
}
@Override
--- /dev/null
+/*
+ * Copyright (c) 2018 Pantheon Technologies, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.mdsal.binding.generator.impl;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.util.List;
+import java.util.Set;
+import org.junit.Test;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.Type;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
+
+public class Mdsal332Test {
+
+ @Test
+ public void mdsal332Test() {
+ final SchemaContext context = YangParserTestUtils.parseYangResource("/mdsal332.yang");
+
+ final List<Type> generateTypes = new BindingGeneratorImpl().generateTypes(context);
+ assertNotNull(generateTypes);
+ assertEquals(5, generateTypes.size());
+
+ final List<JavaTypeName> names = generateTypes.stream().map(Type::getIdentifier)
+ .collect(ImmutableList.toImmutableList());
+ final Set<JavaTypeName> uniqueNames = ImmutableSet.copyOf(names);
+ assertEquals(ImmutableList.copyOf(uniqueNames), names);
+ }
+}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import com.google.common.collect.ImmutableMap;
import java.util.Set;
import org.junit.Before;
import org.junit.BeforeClass;
@Before
public void init() {
- provider = new CodegenTypeProvider(context);
+ provider = new CodegenTypeProvider(context, ImmutableMap.of());
m = context.findModule("test", Revision.of("2013-10-08")).get();
}
import java.net.URI;
import java.util.NoSuchElementException;
import org.junit.Test;
-import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.util.generated.type.builder.CodegenGeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
provider.javaTypeForSchemaDefinitionType(testTypedef, null, null);
}
- private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName, final String leafNodeName) {
+ private static LeafSchemaNode provideLeafNodeFromTopLevelContainer(final Module module, final String containerName,
+ final String leafNodeName) {
final QName containerNode = QName.create(module.getQNameModule(), containerName);
final DataSchemaNode rootNode = module.getDataChildByName(containerNode);
assertNotNull("Container foo is not present in root of module "+ module.getName(), rootNode);
return (LeafSchemaNode) node;
}
- private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module, final String containerName, final String leafListNodeName) {
+ private static LeafListSchemaNode provideLeafListNodeFromTopLevelContainer(final Module module,
+ final String containerName, final String leafListNodeName) {
final QName containerNode = QName.create(module.getQNameModule(), containerName);
final DataSchemaNode rootNode = module.getDataChildByName(containerNode);
assertNotNull("Container foo is not present in root of module " + module.getName(), rootNode);
@Test
public void javaTypeForSchemaDefinitionExtTypeTest() {
final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "yang-int8-type");
+ final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
+ "yang-int8-type");
final TypeDefinition<?> leafType = leaf.getType();
final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
assertEquals("base-yang-types", genTO.getModuleName());
- assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
+ assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
+ genTO.getPackageName());
assertEquals("YangInt8", genTO.getName());
assertEquals(1, genTO.getProperties().size());
}
@Test
public void javaTypeForSchemaDefinitionRestrictedExtTypeTest() {
final TypeProvider provider = new CodegenTypeProvider(this.schemaContext);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo", "restricted-int8-type");
+ final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "foo",
+ "restricted-int8-type");
final TypeDefinition<?> leafType = leaf.getType();
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(leafType);
assertTrue(result instanceof GeneratedTransferObject);
final GeneratedTransferObject genTO = (GeneratedTransferObject) result;
- assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914", genTO.getPackageName());
+ assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.org.test.base.yang.types.rev140914",
+ genTO.getPackageName());
assertEquals("YangInt8Restricted", genTO.getName());
assertEquals(1, genTO.getProperties().size());
final Optional<? extends RangeConstraint<?>> rangeConstraints = genTO.getRestrictions().getRangeConstraint();
final AbstractTypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
final Module testTypeProvider = resolveModule("test-type-provider");
- final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider, "empty-pattern-string");
+ final TypeDefinition<?> emptyPatternString = resolveTypeDefinitionFromModule(testTypeProvider,
+ "empty-pattern-string");
assertNotNull(emptyPatternString);
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(emptyPatternString);
@Test
public void javaTypeForSchemaDefinitionForExtUnionWithSimpleTypesTest() {
final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "simple-int-types-union");
+ final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions",
+ "simple-int-types-union");
final TypeDefinition<?> leafType = leaf.getType();
final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
@Test
public void javaTypeForSchemaDefinitionForExtComplexUnionWithInnerUnionTypesTest() {
final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "complex-union");
+ final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions",
+ "complex-union");
final TypeDefinition<?> leafType = leaf.getType();
final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
@Test
public void javaTypeForSchemaDefinitionForExtUnionWithInnerUnionAndSimpleTypeTest() {
final TypeProvider provider = new RuntimeTypeProvider(this.schemaContext);
- final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions", "complex-string-int-union");
+ final LeafSchemaNode leaf = provideLeafNodeFromTopLevelContainer(this.testTypeProviderModule, "use-of-unions",
+ "complex-string-int-union");
final TypeDefinition<?> leafType = leaf.getType();
final Type result = provider.javaTypeForSchemaDefinitionType(leafType, leaf);
--- /dev/null
+module mdsal332 {
+ namespace "mdsal332";
+ prefix "mdsal332";
+
+ grouping foo {
+
+ }
+
+ identity foo {
+
+ }
+
+ container foo {
+
+ }
+
+ typedef foo {
+ type string;
+ }
+}
+
Code Review / mdsal.git / commitdiff