From: Martin Vitez Date: Mon, 25 Nov 2013 16:55:00 +0000 (+0100) Subject: Added getTypeDefaultConstruction method to TypeProvider. X-Git-Tag: release/beryllium~712 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=53898033299ec016df466cb304a616ac75af2d27;p=mdsal.git Added getTypeDefaultConstruction method to TypeProvider. Method can be used in code generation to create construction for new type with default value. Added tests. Signed-off-by: Martin Vitez --- diff --git a/code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.xtend b/code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.xtend index 367d3b5697..b3926169cf 100644 --- a/code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.xtend +++ b/code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.xtend @@ -244,7 +244,7 @@ public class BindingGeneratorImpl implements BindingGenerator { if (node.augmenting || node.addedByUses) { return null } - val packageName = packageNameForGeneratedType(basePackageName, (node).path) + val packageName = packageNameForGeneratedType(basePackageName, node.path) val genType = addDefaultInterfaceDefinition(packageName, node, childOf) if (node instanceof DataNodeContainer) { genCtx.get(module).addChildNodeType(node.path, genType) diff --git a/code-generator/binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/TypeProviderIntegrationTest.java b/code-generator/binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/TypeProviderIntegrationTest.java new file mode 100644 index 0000000000..117aab875d --- /dev/null +++ b/code-generator/binding-generator-impl/src/test/java/org/opendaylight/yangtools/sal/binding/generator/impl/TypeProviderIntegrationTest.java @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2013 Cisco Systems, Inc. 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.yangtools.sal.binding.generator.impl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import java.io.File; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +import org.junit.Test; +import org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl; +import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; +import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser; +import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl; + +public class TypeProviderIntegrationTest { + private final String PKG = "org.opendaylight.yang.gen.v1.urn.opendaylight.test.rev131008."; + + private SchemaContext resolveSchemaContextFromFiles(final String... yangFiles) { + final YangModelParser parser = new YangParserImpl(); + + final List inputFiles = new ArrayList(); + for (int i = 0; i < yangFiles.length; ++i) { + inputFiles.add(new File(yangFiles[i])); + } + + final Set modules = parser.parseYangModels(inputFiles); + return parser.resolveSchemaContext(modules); + } + + @Test + public void testGetTypeDefaultConstruction1() throws ParseException { + final String path = getClass().getResource("/type-provider/test.yang").getPath(); + final SchemaContext context = resolveSchemaContextFromFiles(path); + assertNotNull(context); + TypeProviderImpl provider = new TypeProviderImpl(context); + Module m = context.findModuleByName("test", new SimpleDateFormat("yyyy-MM-dd").parse("2013-10-08")); + + LeafSchemaNode leaf = (LeafSchemaNode)m.getDataChildByName("id-binary"); + String actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new byte[] {77, 97, 110}", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-bits"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "TestData.IdBits(false, false, true)", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-boolean"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Boolean(\"true\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-decimal64"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.math.BigDecimal(\"3.14\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-empty"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Boolean(\"false\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-enumeration"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("org.opendaylight.yang.gen.v1.urn.opendaylight.test.rev131008.IdEnumeration.Seven", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-8"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Byte(\"11\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-16"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Short(\"111\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-32"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Integer(\"1111\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-64"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Long(\"11111\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-leafref"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.math.BigDecimal(\"1.234\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-string"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("\"name\"", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-u8"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Short(\"11\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-u16"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Integer(\"111\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-u32"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.lang.Long(\"1111\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("id-u64"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.math.BigInteger(\"11111\")", actual); + } + + @Test + public void testGetTypeDefaultConstruction2() throws ParseException { + final String path = getClass().getResource("/type-provider/test.yang").getPath(); + final SchemaContext context = resolveSchemaContextFromFiles(path); + assertNotNull(context); + TypeProviderImpl provider = new TypeProviderImpl(context); + Module m = context.findModuleByName("test", new SimpleDateFormat("yyyy-MM-dd").parse("2013-10-08")); + + LeafSchemaNode leaf = (LeafSchemaNode)m.getDataChildByName("ext-binary"); + String actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyBinary(new byte[] {77, 97, 110})", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-bits"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyBits(false, false, true)", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-boolean"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyBoolean(new java.lang.Boolean(\"true\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-decimal64"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyDecimal64(new java.math.BigDecimal(\"3.14\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-empty"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyEmpty(new java.lang.Boolean(\"false\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-enumeration"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyEnumeration(" + PKG + "MyEnumeration.Seven)", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-8"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "My8(new java.lang.Byte(\"11\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-16"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "My16(new java.lang.Short(\"111\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-32"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "My32(new java.lang.Integer(\"1111\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-64"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "My64(new java.lang.Long(\"11111\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-leafref"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new java.math.BigDecimal(\"1.234\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-string"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyString(\"name\")", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-u8"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyU8(new java.lang.Short(\"11\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-u16"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyU16(new java.lang.Integer(\"111\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-u32"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyU32(new java.lang.Long(\"1111\"))", actual); + + leaf = (LeafSchemaNode)m.getDataChildByName("ext-u64"); + actual = provider.getTypeDefaultConstruction(leaf); + assertEquals("new " + PKG + "MyU64(new java.math.BigInteger(\"11111\"))", actual); + } + +} diff --git a/code-generator/binding-generator-impl/src/test/resources/type-provider/test.yang b/code-generator/binding-generator-impl/src/test/resources/type-provider/test.yang new file mode 100644 index 0000000000..7171a5383b --- /dev/null +++ b/code-generator/binding-generator-impl/src/test/resources/type-provider/test.yang @@ -0,0 +1,290 @@ +module test { + yang-version 1; + namespace "urn:opendaylight:test"; + prefix "t"; + + revision "2013-10-08" { + } + + + typedef my-binary { + type binary; + } + + typedef my-bits { + type bits { + bit ctrl; + bit alt { + position 5; + } + bit delete; + } + } + + typedef my-boolean { + type boolean; + } + + + typedef my-decimal64 { + type decimal64 { + fraction-digits 4; + } + } + + typedef my-empty { + type empty; + } + + typedef my-enumeration { + type enumeration { + enum zero; + enum one; + enum seven { + value 7; + } + } + } + + typedef my-identityref { + type identityref { + base alg; + } + } + + typedef my-8 { + type int8; + } + typedef my-16 { + type int16; + } + typedef my-32 { + type int32; + } + typedef my-64 { + type int64; + } + + typedef my-leafref { + type leafref { + path "/links/node/id-64"; + } + } + + typedef my-string { + type string; + } + + typedef my-u8 { + type uint8; + } + typedef my-u16 { + type uint16; + } + typedef my-u32 { + type uint32; + } + typedef my-u64 { + type uint64; + } + + + + leaf id-binary { + type binary; + default "TWFu"; + } + + leaf id-bits { + type bits { + bit ctrl; + bit alt { + position 5; + } + bit delete; + } + default "delete"; + } + + leaf id-boolean { + type boolean; + default true; + } + + leaf id-decimal64 { + type decimal64 { + fraction-digits 4; + } + default "3.14"; + } + + leaf id-empty { + type empty; + default false; + } + + leaf id-enumeration { + type enumeration { + enum zero; + enum one; + enum seven { + value 7; + } + } + default seven; + } + + leaf id-identityref { + type identityref { + base alg; + } + } + + leaf id-8 { + type int8; + default "11"; + } + leaf id-16 { + type int16; + default "111"; + } + leaf id-32 { + type int32; + default "1111"; + } + leaf id-64 { + type int64; + default "11111"; + } + + leaf id-leafref { + type leafref { + path "/links/node/id-64"; + } + default "1.234"; + } + + leaf id-string { + type string; + default "name"; + } + + leaf id-u8 { + type uint8; + default "11"; + } + leaf id-u16 { + type uint16; + default "111"; + } + leaf id-u32 { + type uint32; + default "1111"; + } + leaf id-u64 { + type uint64; + default "11111"; + } + + + + leaf ext-binary { + type my-binary; + default "TWFu"; + } + + leaf ext-bits { + type my-bits { + bit ctrl; + bit alt { + position 5; + } + bit delete; + } + default "delete"; + } + + leaf ext-boolean { + type my-boolean; + default true; + } + + leaf ext-decimal64 { + type my-decimal64; + default "3.14"; + } + + leaf ext-empty { + type my-empty; + default false; + } + + leaf ext-enumeration { + type my-enumeration; + default seven; + } + + leaf ext-identityref { + type my-identityref; + } + + leaf ext-8 { + type my-8; + default "11"; + } + leaf ext-16 { + type my-16; + default "111"; + } + leaf ext-32 { + type my-32; + default "1111"; + } + leaf ext-64 { + type my-64; + default "11111"; + } + + leaf ext-leafref { + type my-leafref; + default "1.234"; + } + + leaf ext-string { + type my-string; + default "name"; + } + + leaf ext-u8 { + type my-u8; + default "11"; + } + leaf ext-u16 { + type my-u16; + default "111"; + } + leaf ext-u32 { + type my-u32; + default "1111"; + } + leaf ext-u64 { + type my-u64; + default "11111"; + } + + + + list links { + container node { + leaf id-64 { + type decimal64 { + fraction-digits "7"; + } + } + } + } + + identity alg { + } + +} diff --git a/code-generator/binding-generator-spi/src/main/java/org/opendaylight/yangtools/sal/binding/generator/spi/TypeProvider.java b/code-generator/binding-generator-spi/src/main/java/org/opendaylight/yangtools/sal/binding/generator/spi/TypeProvider.java index d8b1338593..ad9b04de37 100644 --- a/code-generator/binding-generator-spi/src/main/java/org/opendaylight/yangtools/sal/binding/generator/spi/TypeProvider.java +++ b/code-generator/binding-generator-spi/src/main/java/org/opendaylight/yangtools/sal/binding/generator/spi/TypeProvider.java @@ -9,6 +9,7 @@ package org.opendaylight.yangtools.sal.binding.generator.spi; import org.opendaylight.yangtools.sal.binding.model.api.Restrictions; import org.opendaylight.yangtools.sal.binding.model.api.Type; +import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; @@ -36,4 +37,12 @@ public interface TypeProvider { Type javaTypeForSchemaDefinitionType(final TypeDefinition type, final SchemaNode parentNode); Type javaTypeForSchemaDefinitionType(final TypeDefinition type, final SchemaNode parentNode, final Restrictions restrictions); + + /** + * Returns string containing code for creation of new type instance. + * + * @param node + * @return + */ + String getTypeDefaultConstruction(LeafSchemaNode node); } diff --git a/code-generator/binding-type-provider/src/main/java/org/opendaylight/yangtools/sal/binding/yang/types/BaseYangTypes.java b/code-generator/binding-type-provider/src/main/java/org/opendaylight/yangtools/sal/binding/yang/types/BaseYangTypes.java index adffbf0105..be6a0fb394 100644 --- a/code-generator/binding-type-provider/src/main/java/org/opendaylight/yangtools/sal/binding/yang/types/BaseYangTypes.java +++ b/code-generator/binding-type-provider/src/main/java/org/opendaylight/yangtools/sal/binding/yang/types/BaseYangTypes.java @@ -17,6 +17,7 @@ import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider; import org.opendaylight.yangtools.sal.binding.model.api.Restrictions; import org.opendaylight.yangtools.sal.binding.model.api.Type; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; import org.opendaylight.yangtools.yang.model.api.SchemaNode; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; @@ -171,5 +172,10 @@ public final class BaseYangTypes { default: return javaTypeForSchemaDefinitionType(type, parentNode); } } + + @Override + public String getTypeDefaultConstruction(LeafSchemaNode node) { + return null; + } }; } diff --git a/code-generator/binding-type-provider/src/main/java/org/opendaylight/yangtools/sal/binding/yang/types/TypeProviderImpl.java b/code-generator/binding-type-provider/src/main/java/org/opendaylight/yangtools/sal/binding/yang/types/TypeProviderImpl.java index 5ca744e909..fdff9e2aab 100644 --- a/code-generator/binding-type-provider/src/main/java/org/opendaylight/yangtools/sal/binding/yang/types/TypeProviderImpl.java +++ b/code-generator/binding-type-provider/src/main/java/org/opendaylight/yangtools/sal/binding/yang/types/TypeProviderImpl.java @@ -10,8 +10,12 @@ package org.opendaylight.yangtools.sal.binding.yang.types; import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.*; import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.*; +import java.math.BigDecimal; +import java.math.BigInteger; import java.util.ArrayList; import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -38,6 +42,8 @@ import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPr import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder; import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilderBase; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; +import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode; import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode; @@ -47,20 +53,36 @@ import org.opendaylight.yangtools.yang.model.api.SchemaContext; 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.opendaylight.yangtools.yang.model.api.YangNode; +import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit; +import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition; +import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition; +import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition; +import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; +import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; import org.opendaylight.yangtools.yang.model.util.DataNodeIterator; import org.opendaylight.yangtools.yang.model.util.ExtendedType; +import org.opendaylight.yangtools.yang.model.util.Int16; +import org.opendaylight.yangtools.yang.model.util.Int32; +import org.opendaylight.yangtools.yang.model.util.Int64; +import org.opendaylight.yangtools.yang.model.util.Int8; import org.opendaylight.yangtools.yang.model.util.StringType; +import org.opendaylight.yangtools.yang.model.util.Uint16; +import org.opendaylight.yangtools.yang.model.util.Uint32; +import org.opendaylight.yangtools.yang.model.util.Uint64; +import org.opendaylight.yangtools.yang.model.util.Uint8; import org.opendaylight.yangtools.yang.model.util.UnionType; import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort; import com.google.common.base.Preconditions; +import com.google.common.io.BaseEncoding; public final class TypeProviderImpl implements TypeProvider { /** @@ -1211,4 +1233,194 @@ public final class TypeProviderImpl implements TypeProvider { } } + @Override + public String getTypeDefaultConstruction(LeafSchemaNode node) { + return getTypeDefaultConstruction(node, node.getDefault()); + } + + public String getTypeDefaultConstruction(LeafSchemaNode node, String defaultValue) { + TypeDefinition type = node.getType(); + Preconditions.checkNotNull(type, "Cannot provide default construction for null type of " + node); + Preconditions.checkNotNull(defaultValue, "Cannot provide default construction for null default statement of " + + node); + + Module module = getParentModule(node); + String basePackageName = BindingGeneratorUtil.moduleNamespaceToPackageName(module); + String packageName = packageNameForGeneratedType(basePackageName, node.getPath()); + String className = packageName + "." + parseToClassName(node.getQName().getLocalName()); + + StringBuilder sb = new StringBuilder(); + TypeDefinition base = baseTypeDefForExtendedType(type); + final boolean isBaseNull = base == null; + + if (isBaseNull) { + base = type; + } + + String result = null; + if (base instanceof BinaryTypeDefinition) { + result = binaryToDef(defaultValue); + } else if (base instanceof BitsTypeDefinition) { + String parentName; + YangNode parent = node.getParent(); + if (parent instanceof Module) { + parentName = parseToClassName(((Module)parent).getName()) + "Data"; + className = basePackageName + "." + parentName + "." + parseToClassName(node.getQName().getLocalName()); + } else { + parentName = parseToClassName(((SchemaNode)parent).getQName().getLocalName()); + className = packageName + "." + parentName + "." + parseToClassName(node.getQName().getLocalName()); + } + result = bitsToDef((BitsTypeDefinition) base, className, defaultValue, isBaseNull); + } else if (base instanceof BooleanTypeDefinition) { + result = typeToDef(Boolean.class, defaultValue); + } else if (base instanceof DecimalTypeDefinition) { + result = typeToDef(BigDecimal.class, defaultValue); + } else if (base instanceof EmptyTypeDefinition) { + result = typeToDef(Boolean.class, defaultValue); + } else if (base instanceof EnumTypeDefinition) { + char[] defValArray = defaultValue.toCharArray(); + char first = Character.toUpperCase(defaultValue.charAt(0)); + defValArray[0] = first; + String newDefVal = new String(defValArray); + if (type instanceof ExtendedType) { + className = packageName + "." + parseToClassName(node.getType().getQName().getLocalName()); + } + result = className + "." + newDefVal; + } else if (base instanceof IdentityrefTypeDefinition) { + throw new UnsupportedOperationException("Cannot get default construction for identityref type"); + } else if (base instanceof InstanceIdentifierTypeDefinition) { + throw new UnsupportedOperationException("Cannot get default construction for instance-identifier type"); + } else if (base instanceof Int8) { + result = typeToDef(Byte.class, defaultValue); + } else if (base instanceof Int16) { + result = typeToDef(Short.class, defaultValue); + } else if (base instanceof Int32) { + result = typeToDef(Integer.class, defaultValue); + } else if (base instanceof Int64) { + result = typeToDef(Long.class, defaultValue); + } else if (base instanceof LeafrefTypeDefinition) { + result = leafrefToDef(node, (LeafrefTypeDefinition)base); + } else if (base instanceof StringTypeDefinition) { + result = "\"" + defaultValue + "\""; + } else if (base instanceof Uint8) { + result = typeToDef(Short.class, defaultValue); + } else if (base instanceof Uint16) { + result = typeToDef(Integer.class, defaultValue); + } else if (base instanceof Uint32) { + result = typeToDef(Long.class, defaultValue); + } else if (base instanceof Uint64) { + result = typeToDef(BigInteger.class, defaultValue); + } else if (base instanceof UnionTypeDefinition) { + throw new UnsupportedOperationException("Cannot get default construction for union type"); + } else { + result = ""; + } + sb.append(result); + + if (result != null && !result.isEmpty() && type instanceof ExtendedType && !(base instanceof LeafrefTypeDefinition)) { + className = packageName + "." + parseToClassName(node.getType().getQName().getLocalName()); + sb.insert(0, "new " + className + "("); + sb.insert(sb.length(), ")"); + } + + return sb.toString(); + } + + + private String typeToDef(Class clazz, String defaultValue) { + return "new " + clazz.getName() + "(\"" + defaultValue + "\")"; + } + + private String binaryToDef(String defaultValue) { + StringBuilder sb = new StringBuilder(); + BaseEncoding en = BaseEncoding.base64(); + byte[] encoded = en.decode(defaultValue); + sb.append("new byte[] {"); + for (int i = 0; i < encoded.length; i++) { + sb.append(encoded[i]); + if (i != encoded.length - 1) { + sb.append(", "); + } + } + sb.append("}"); + return sb.toString(); + } + + private String bitsToDef(BitsTypeDefinition type, String className, String defaultValue, boolean isBase) { + List bits = new ArrayList<>(type.getBits()); + Collections.sort(bits, new Comparator() { + @Override + public int compare(Bit o1, Bit o2) { + return o1.getName().compareTo(o2.getName()); + } + }); + StringBuilder sb = new StringBuilder(); + sb.append(isBase ? "new " + className + "(" : ""); + for (int i = 0; i < bits.size(); i++) { + if (bits.get(i).getName().equals(defaultValue)) { + sb.append(true); + } else { + sb.append(false); + } + if (i != bits.size() - 1) { + sb.append(", "); + } + } + sb.append(isBase ? ")" : ""); + return sb.toString(); + } + + private Module getParentModule(YangNode node) { + if (node instanceof Module) { + return (Module) node; + } + + YangNode parent = null; + if (node instanceof DataSchemaNode) { + parent = ((DataSchemaNode) node).getParent(); + } else if (node instanceof DataNodeContainer) { + parent = ((DataNodeContainer) node).getParent(); + } else { + parent = null; + } + + while (parent != null && !(parent instanceof Module)) { + if (parent instanceof DataSchemaNode) { + parent = ((DataSchemaNode) parent).getParent(); + } else if (parent instanceof DataNodeContainer) { + parent = ((DataNodeContainer) parent).getParent(); + } else { + parent = null; + } + } + return (Module) parent; + } + + private String leafrefToDef(LeafSchemaNode parentNode, LeafrefTypeDefinition leafrefType) { + Preconditions.checkArgument(leafrefType != null, "Leafref Type Definition reference cannot be NULL!"); + Preconditions.checkArgument(leafrefType.getPathStatement() != null, "The Path Statement for Leafref Type Definition cannot be NULL!"); + + final RevisionAwareXPath xpath = leafrefType.getPathStatement(); + final String strXPath = xpath.toString(); + + if (strXPath != null) { + if (strXPath.contains("[")) { + return "new java.lang.Object()"; + } else { + final Module module = findParentModule(schemaContext, parentNode); + if (module != null) { + final SchemaNode dataNode; + if (xpath.isAbsolute()) { + dataNode = findDataSchemaNode(schemaContext, module, xpath); + } else { + dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module, parentNode, xpath); + } + return getTypeDefaultConstruction((LeafSchemaNode)dataNode, parentNode.getDefault()); + } + } + } + + return null; + } + }