import org.opendaylight.mdsal.binding.model.api.Type;
import org.opendaylight.mdsal.binding.model.api.TypeComment;
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public interface GeneratedTypeBuilderBase<T extends GeneratedTypeBuilderBase<T>> extends Type {
void setModuleName(String moduleName);
/**
- * Set a list of QNames which represent schema path in schema tree from
- * actual concrete type to the root.
+ * Schema path in schema tree from actual concrete type to the root.
*
- * @param schemaPath
- * a list of QNames which represent schema path in schema tree
+ * @param schemaPath schema path in schema tree
*/
- void setSchemaPath(Iterable<QName> schemaPath);
+ void setSchemaPath(SchemaPath schemaPath);
/**
* Set a string that is used to specify a textual cross-reference to an
genType.setModuleName(module.getName());
addCodegenInformation(genType, module, node);
- genType.setSchemaPath(node.getPath().getPathFromRoot());
+ genType.setSchemaPath(node.getPath());
if (node instanceof DataNodeContainer) {
genCtx.get(module).addChildNodeType(node, genType);
groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings());
addCodegenInformation(newType, module, identity);
newType.setModuleName(module.getName());
- newType.setSchemaPath(identity.getPath().getPathFromRoot());
+ newType.setSchemaPath(identity.getPath());
final QName qname = identity.getQName();
qnameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, qname);
genTOBuilder.getName());
addCodegenInformation(returnType, parentModule, typeDef);
- returnType.setSchemaPath(typeDef.getPath().getPathFromRoot());
+ returnType.setSchemaPath(typeDef.getPath());
returnType.setModuleName(parentModule.getName());
genTOBuilder.setTypedef(true);
qnameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
addCodegenInformation(newType, module, schemaNode);
- newType.setSchemaPath(schemaNode.getPath().getPathFromRoot());
+ newType.setSchemaPath(schemaNode.getPath());
newType.setModuleName(module.getName());
if (!genTypeBuilders.containsKey(packageName)) {
addEnumDescription(enumBuilder, enumTypeDef);
enumTypeDef.getReference().ifPresent(enumBuilder::setReference);
enumBuilder.setModuleName(module.getName());
- enumBuilder.setSchemaPath(enumTypeDef.getPath().getPathFromRoot());
+ enumBuilder.setSchemaPath(enumTypeDef.getPath());
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
return enumBuilder.toInstance(null);
}
if (typeDefName != null && !typeDefName.isEmpty()) {
final String typeName = BindingMapping.getClassName(typeDefName);
unionGenTOBuilder = newGeneratedTOBuilder(basePackageName, typeName);
- unionGenTOBuilder.setSchemaPath(typedef.getPath().getPathFromRoot());
+ unionGenTOBuilder.setSchemaPath(typedef.getPath());
unionGenTOBuilder.setModuleName(module.getName());
addCodegenInformation(unionGenTOBuilder, typedef);
} else {
if (packageName != null && typeDefTOName != null) {
final String genTOName = BindingMapping.getClassName(typeDefTOName);
final GeneratedTOBuilder newType = newGeneratedTOBuilder(packageName, genTOName);
- newType.setSchemaPath(typedef.getPath().getPathFromRoot());
+ newType.setSchemaPath(typedef.getPath());
newType.setModuleName(moduleName);
addCodegenInformation(newType, typedef);
return newType;
final String typeName = BindingMapping.getClassName(typeDefName);
final GeneratedTOBuilder genTOBuilder = newGeneratedTOBuilder(basePackageName, typeName);
- genTOBuilder.setSchemaPath(typeDef.getPath().getPathFromRoot());
+ genTOBuilder.setSchemaPath(typeDef.getPath());
genTOBuilder.setModuleName(moduleName);
genTOBuilder.setBaseType(typeDef);
addCodegenInformation(genTOBuilder, typeDef);
final String classTypedefName = BindingMapping.getClassName(typedefName);
final String innerTypeDef = innerExtendedType.getQName().getLocalName();
final GeneratedTOBuilder genTOBuilder = newGeneratedTOBuilder(basePackageName, classTypedefName);
- genTOBuilder.setSchemaPath(typedef.getPath().getPathFromRoot());
+ genTOBuilder.setSchemaPath(typedef.getPath());
genTOBuilder.setModuleName(moduleName);
genTOBuilder.setTypedef(true);
addCodegenInformation(genTOBuilder, typedef);
import org.opendaylight.mdsal.binding.model.util.AbstractBaseType;
import org.opendaylight.yangtools.util.LazyCollections;
import org.opendaylight.yangtools.yang.binding.BindingMapping;
-import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
public abstract void setModuleName(String moduleName);
- public abstract void setSchemaPath(Iterable<QName> schemaPath);
+ public abstract void setSchemaPath(SchemaPath schemaPath);
abstract AbstractPair createEnumPair(String name, int value, String description);
import org.opendaylight.mdsal.binding.model.api.TypeComment;
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class CodegenEnumerationBuilder extends AbstractEnumerationBuilder {
private String description;
private String reference;
private String moduleName;
- private Iterable<QName> schemaPath;
+ private SchemaPath schemaPath;
public CodegenEnumerationBuilder(final String packageName, final String name) {
super(packageName, name);
}
@Override
- public void setSchemaPath(final Iterable<QName> schemaPath) {
+ public void setSchemaPath(final SchemaPath schemaPath) {
this.schemaPath = schemaPath;
}
private final String description;
private final String reference;
private final String moduleName;
- private final Iterable<QName> schemaPath;
+ private final SchemaPath schemaPath;
EnumerationImpl(final CodegenEnumerationBuilder builder, final Type definingType) {
super(builder, definingType);
@Override
public Iterable<QName> getSchemaPath() {
- return this.schemaPath;
+ return this.schemaPath.getPathFromRoot();
}
@Override
import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class CodegenGeneratedTOBuilder extends AbstractGeneratedTOBuilder {
private String reference;
private String description;
private String moduleName;
- private Iterable<QName> schemaPath;
+ private SchemaPath schemaPath;
public CodegenGeneratedTOBuilder(final String packageName, final String name) {
super(packageName, name);
}
@Override
- public void setSchemaPath(final Iterable<QName> schemaPath) {
+ public void setSchemaPath(final SchemaPath schemaPath) {
this.schemaPath = schemaPath;
}
private final String reference;
private final String description;
private final String moduleName;
- private final Iterable<QName> schemaPath;
+ private final SchemaPath schemaPath;
public GTO(final CodegenGeneratedTOBuilder builder) {
super(builder);
@Override
public Iterable<QName> getSchemaPath() {
- return this.schemaPath;
+ return this.schemaPath.getPathFromRoot();
}
@Override
import org.opendaylight.mdsal.binding.model.api.TypeComment;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class CodegenGeneratedTypeBuilder extends AbstractGeneratedTypeBuilder<GeneratedTypeBuilder> implements
GeneratedTypeBuilder {
private String description;
private String reference;
private String moduleName;
- private Iterable<QName> schemaPath;
+ private SchemaPath schemaPath;
public CodegenGeneratedTypeBuilder(final String packageName, final String name) {
super(packageName, name);
}
@Override
- public void setSchemaPath(final Iterable<QName> schemaPath) {
+ public void setSchemaPath(final SchemaPath schemaPath) {
this.schemaPath = schemaPath;
}
private final String description;
private final String reference;
private final String moduleName;
- private final Iterable<QName> schemaPath;
+ private final SchemaPath schemaPath;
public GeneratedTypeImpl(final CodegenGeneratedTypeBuilder builder) {
super(builder);
@Override
public Iterable<QName> getSchemaPath() {
- return this.schemaPath;
+ return this.schemaPath.getPathFromRoot();
}
@Override
import org.opendaylight.mdsal.binding.model.api.TypeComment;
import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class RuntimeEnumerationBuilder extends AbstractEnumerationBuilder {
public RuntimeEnumerationBuilder(final String packageName, final String name) {
}
@Override
- public void setSchemaPath(final Iterable<QName> schemaPath) {
+ public void setSchemaPath(final SchemaPath schemaPath) {
// No-op
}
import org.opendaylight.mdsal.binding.model.api.Restrictions;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class RuntimeGeneratedTOBuilder extends AbstractGeneratedTOBuilder {
}
@Override
- public void setSchemaPath(final Iterable<QName> schemaPath) {
+ public void setSchemaPath(final SchemaPath schemaPath) {
// No-op
}
import org.opendaylight.mdsal.binding.model.api.TypeComment;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
public final class RuntimeGeneratedTypeBuilder extends AbstractGeneratedTypeBuilder<GeneratedTypeBuilder> implements
GeneratedTypeBuilder {
}
@Override
- public void setSchemaPath(final Iterable<QName> schemaPath) {
+ public void setSchemaPath(final SchemaPath schemaPath) {
// No-op
}
enumerationBuilder.setDescription(DESCRIPTION);
enumerationBuilder.setModuleName(moduleName);
enumerationBuilder.setReference(reference);
- enumerationBuilder.setSchemaPath(Collections.singletonList(qName));
+ enumerationBuilder.setSchemaPath(SchemaPath.create(true, qName));
enumerationBuilder.addValue(valueName, value, valueDescription);
enumerationBuilder.addAnnotation(packageName, "TestAnnotation");
enumerationBuilderSame = new CodegenEnumerationBuilder(packageName, name);
genTOBuilder.setDescription("test description");
genTOBuilder.setModuleName("test-module");
genTOBuilder.setReference("http://tools.ietf.org/html/rfc6020");
- genTOBuilder.setSchemaPath(SchemaPath.ROOT.getPathFromRoot());
+ genTOBuilder.setSchemaPath(SchemaPath.ROOT);
final GeneratedTransferObject genTO = genTOBuilder.toInstance();
generatedTypeBuilder.setDescription("My description ...");
generatedTypeBuilder.setModuleName("myModuleName");
generatedTypeBuilder.setReference("myReference");
- generatedTypeBuilder.setSchemaPath(SchemaPath.create(true, QName.create("test", "/path")).getPathFromRoot());
+ generatedTypeBuilder.setSchemaPath(SchemaPath.create(true, QName.create("test", "/path")));
assertNotNull(generatedTypeBuilder.addComment(TypeComments.javadoc("My comment..").get()));
assertEquals(