*/
package org.opendaylight.mdsal.binding.yang.types;
-import static org.opendaylight.mdsal.binding.generator.util.BindingGeneratorUtil.encodeAngleBrackets;
+import static org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil.encodeAngleBrackets;
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;
-
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import java.util.regex.Pattern;
import org.apache.commons.lang3.StringEscapeUtils;
import org.opendaylight.mdsal.binding.generator.spi.TypeProvider;
-import org.opendaylight.mdsal.binding.generator.util.BindingGeneratorUtil;
-import org.opendaylight.mdsal.binding.generator.util.TypeConstants;
-import org.opendaylight.mdsal.binding.generator.util.Types;
-import org.opendaylight.mdsal.binding.generator.util.generated.type.builder.EnumerationBuilderImpl;
-import org.opendaylight.mdsal.binding.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
-import org.opendaylight.mdsal.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
import org.opendaylight.mdsal.binding.model.api.AccessModifier;
import org.opendaylight.mdsal.binding.model.api.ConcreteType;
import org.opendaylight.mdsal.binding.model.api.Enumeration;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.mdsal.binding.model.util.BindingGeneratorUtil;
+import org.opendaylight.mdsal.binding.model.util.TypeConstants;
+import org.opendaylight.mdsal.binding.model.util.Types;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.EnumerationBuilderImpl;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedPropertyBuilderImpl;
+import org.opendaylight.mdsal.binding.model.util.generated.type.builder.GeneratedTOBuilderImpl;
import org.opendaylight.yangtools.yang.binding.BindingMapping;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
Preconditions.checkArgument(typeDefinition != null, "Type Definition cannot be NULL!");
Preconditions.checkArgument(typeDefinition.getQName() != null,
"Type Definition cannot have non specified QName (QName cannot be NULL!)");
- String typedefName = typeDefinition.getQName().getLocalName();
+ final String typedefName = typeDefinition.getQName().getLocalName();
Preconditions.checkArgument(typedefName != null, "Type Definitions Local Name cannot be NULL!");
// Deal with base types
Type returnType = javaTypeForExtendedType(typeDefinition);
if (r != null && returnType instanceof GeneratedTransferObject) {
- GeneratedTransferObject gto = (GeneratedTransferObject) returnType;
- Module module = findParentModule(schemaContext, parentNode);
- String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
- String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typeDefinition.getPath());
- String genTOName = BindingMapping.getClassName(typedefName);
- String name = packageName + "." + genTOName;
+ final GeneratedTransferObject gto = (GeneratedTransferObject) returnType;
+ final Module module = findParentModule(schemaContext, parentNode);
+ final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typeDefinition.getPath());
+ final String genTOName = BindingMapping.getClassName(typedefName);
+ final String name = packageName + "." + genTOName;
if (!(returnType.getFullyQualifiedName().equals(name))) {
returnType = shadedTOWithRestrictions(gto, r);
}
}
private static GeneratedTransferObject shadedTOWithRestrictions(final GeneratedTransferObject gto, final Restrictions r) {
- GeneratedTOBuilder gtob = new GeneratedTOBuilderImpl(gto.getPackageName(), gto.getName());
- GeneratedTransferObject parent = gto.getSuperType();
+ final GeneratedTOBuilder gtob = new GeneratedTOBuilderImpl(gto.getPackageName(), gto.getName());
+ final GeneratedTransferObject parent = gto.getSuperType();
if (parent != null) {
gtob.setExtendsType(parent);
}
gtob.setRestrictions(r);
- for (GeneratedProperty gp : gto.getProperties()) {
- GeneratedPropertyBuilder gpb = gtob.addProperty(gp.getName());
+ for (final GeneratedProperty gp : gto.getProperties()) {
+ final GeneratedPropertyBuilder gpb = gtob.addProperty(gp.getName());
gpb.setValue(gp.getValue());
gpb.setReadOnly(gp.isReadOnly());
gpb.setAccessModifier(gp.getAccessModifier());
}
/////
- Module parentModule = getParentModule(parentNode);
+ final Module parentModule = getParentModule(parentNode);
if (!leafRefStrippedXPath.isAbsolute()) {
leafRefValueNode = SchemaContextUtil.findDataSchemaNodeForRelativeXPath(schemaContext, parentModule,
parentNode, leafRefStrippedXPath);
returnType = provideTypeForEnum(enumTypeDef, typedefName, typeDefinition);
} else {
final Module module = findParentModule(schemaContext, typeDefinition);
- Restrictions r = BindingGeneratorUtil.getRestrictions(typeDefinition);
+ final Restrictions r = BindingGeneratorUtil.getRestrictions(typeDefinition);
if (module != null) {
final Map<Date, Map<String, Type>> modulesByDate = genTypeDefsContextMap.get(module.getName());
final Map<String, Type> genTOs = modulesByDate.get(module.getRevision());
* <code>idref</code>
*/
private Type provideTypeForIdentityref(final IdentityrefTypeDefinition idref) {
- QName baseIdQName = idref.getIdentity().getQName();
- Module module = schemaContext.findModuleByNamespaceAndRevision(baseIdQName.getNamespace(),
+ final QName baseIdQName = idref.getIdentity().getQName();
+ final Module module = schemaContext.findModuleByNamespaceAndRevision(baseIdQName.getNamespace(),
baseIdQName.getRevision());
IdentitySchemaNode identity = null;
- for (IdentitySchemaNode id : module.getIdentities()) {
+ for (final IdentitySchemaNode id : module.getIdentities()) {
if (id.getQName().equals(baseIdQName)) {
identity = id;
}
final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath());
final String genTypeName = BindingMapping.getClassName(identity.getQName());
- Type baseType = Types.typeForClass(Class.class);
- Type paramType = Types.wildcardTypeFor(packageName, genTypeName);
+ final Type baseType = Types.typeForClass(Class.class);
+ final Type paramType = Types.wildcardTypeFor(packageName, genTypeName);
return Types.parameterizedTypeFor(baseType, paramType);
}
final String enumerationName = BindingMapping.getClassName(enumName);
- Module module = findParentModule(schemaContext, parentNode);
+ final Module module = findParentModule(schemaContext, parentNode);
final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
final EnumerationBuilderImpl enumBuilder = new EnumerationBuilderImpl(basePackageName, enumerationName);
Preconditions.checkArgument(modules != null, "Set of Modules cannot be NULL!");
final Module[] modulesArray = new Module[modules.size()];
int i = 0;
- for (Module modul : modules) {
+ for (final Module modul : modules) {
modulesArray[i++] = modul;
}
final List<Module> modulesSortedByDependency = org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort
makeSerializable((GeneratedTOBuilderImpl) genTOBuilder);
returnType = genTOBuilder.toInstance();
// union builder
- GeneratedTOBuilder unionBuilder = new GeneratedTOBuilderImpl(genTOBuilder.getPackageName(),
+ final GeneratedTOBuilder unionBuilder = new GeneratedTOBuilderImpl(genTOBuilder.getPackageName(),
genTOBuilder.getName() + "Builder");
unionBuilder.setIsUnionBuilder(true);
- MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
+ final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
method.setReturnType(returnType);
method.addParameter(Types.STRING, "defaultValue");
method.setAccessModifier(AccessModifier.PUBLIC);
Preconditions.checkState(!builders.isEmpty(), "No GeneratedTOBuilder objects generated from union %s", typedef);
final GeneratedTOBuilder resultTOBuilder = builders.remove(0);
- for (GeneratedTOBuilder genTOBuilder : builders) {
+ for (final GeneratedTOBuilder genTOBuilder : builders) {
resultTOBuilder.addEnclosingTransferObject(genTOBuilder);
}
if (javaType != null) {
updateUnionTypeAsProperty(parentUnionGenTOBuilder, javaType, unionTypeName);
}
+ } else if (baseType instanceof LeafrefTypeDefinition) {
+ final Type javaType = javaTypeForSchemaDefinitionType(baseType, parentNode);
+ boolean typeExist = false;
+ for (final GeneratedPropertyBuilder generatedPropertyBuilder : parentUnionGenTOBuilder
+ .getProperties()) {
+ final Type origType = ((GeneratedPropertyBuilderImpl) generatedPropertyBuilder).getReturnType();
+ if (origType != null && javaType != null && javaType == origType) {
+ typeExist = true;
+ break;
+ }
+ }
+ if (!typeExist && javaType != null) {
+ updateUnionTypeAsProperty(parentUnionGenTOBuilder, javaType, new StringBuilder(javaType.getName())
+ .append(parentUnionGenTOBuilder.getName()).append("Value").toString());
+ }
}
if (baseType instanceof StringTypeDefinition) {
regularExpressions.addAll(resolveRegExpressionsFromTypedef(unionSubtype));
if (!(newTypeDef instanceof UnionTypeDefinition)) {
final Module parentModule = findParentModule(schemaContext, parentNode);
if (parentModule != null && parentModule.getName() != null) {
- Map<Date, Map<String, Type>> modulesByDate = genTypeDefsContextMap.get(parentModule.getName());
- Map<String, Type> genTOsMap = modulesByDate.get(parentModule.getRevision());
+ final Map<Date, Map<String, Type>> modulesByDate = genTypeDefsContextMap.get(parentModule.getName());
+ final Map<String, Type> genTOsMap = modulesByDate.get(parentModule.getRevision());
genTOsMap.put(newTypeDef.getQName().getLocalName(), genTOBuilder.toInstance());
}
}
Preconditions.checkArgument(basePackageName != null, "Base Package Name cannot be NULL!");
if (typeDef instanceof BitsTypeDefinition) {
- BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) typeDef;
+ final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) typeDef;
final String typeName = BindingMapping.getClassName(typeDefName);
final GeneratedTOBuilderImpl genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeName);
final List<Bit> bitList = bitsTypeDefinition.getBits();
GeneratedPropertyBuilder genPropertyBuilder;
for (final Bit bit : bitList) {
- String name = bit.getName();
+ final String name = bit.getName();
genPropertyBuilder = genTOBuilder.addProperty(BindingMapping.getPropertyName(name));
genPropertyBuilder.setReadOnly(true);
genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE);
}
final List<String> regExps = new ArrayList<>(patternConstraints.size());
- for (PatternConstraint patternConstraint : patternConstraints) {
+ for (final PatternConstraint patternConstraint : patternConstraints) {
final String regEx = patternConstraint.getRegularExpression();
final String modifiedRegEx = StringEscapeUtils.escapeJava(regEx);
regExps.add(modifiedRegEx);
genTOBuilder.setSchemaPath(typedef.getPath().getPathFromRoot());
genTOBuilder.setModuleName(moduleName);
genTOBuilder.setTypedef(true);
- Restrictions r = BindingGeneratorUtil.getRestrictions(typedef);
+ final Restrictions r = BindingGeneratorUtil.getRestrictions(typedef);
genTOBuilder.setRestrictions(r);
if (typedef.getStatus() == Status.DEPRECATED) {
genTOBuilder.addAnnotation("", "Deprecated");
}
if (typeMap != null) {
- Type type = typeMap.get(innerTypeDef);
+ final Type type = typeMap.get(innerTypeDef);
if (type instanceof GeneratedTransferObject) {
genTOBuilder.setExtendsType((GeneratedTransferObject) type);
}
*/
private static void makeSerializable(final GeneratedTOBuilderImpl gto) {
gto.addImplementsType(Types.typeForClass(Serializable.class));
- GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
+ final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
prop.setValue(Long.toString(BindingGeneratorUtil.computeDefaultSUID(gto)));
gto.setSUID(prop);
}
*/
private static List<TypeDefinition<?>> sortTypeDefinitionAccordingDepth(
final Collection<TypeDefinition<?>> unsortedTypeDefinitions) {
- List<TypeDefinition<?>> sortedTypeDefinition = new ArrayList<>();
+ final List<TypeDefinition<?>> sortedTypeDefinition = new ArrayList<>();
- Map<Integer, List<TypeDefinition<?>>> typeDefinitionsDepths = new TreeMap<>();
- for (TypeDefinition<?> unsortedTypeDefinition : unsortedTypeDefinitions) {
+ final Map<Integer, List<TypeDefinition<?>>> typeDefinitionsDepths = new TreeMap<>();
+ for (final TypeDefinition<?> unsortedTypeDefinition : unsortedTypeDefinitions) {
final int depth = getTypeDefinitionDepth(unsortedTypeDefinition);
List<TypeDefinition<?>> typeDefinitionsConcreteDepth = typeDefinitionsDepths.get(depth);
if (typeDefinitionsConcreteDepth == null) {
}
// SortedMap guarantees order corresponding to keys in ascending order
- for (List<TypeDefinition<?>> v : typeDefinitionsDepths.values()) {
+ for (final List<TypeDefinition<?>> v : typeDefinitionsDepths.values()) {
sortedTypeDefinition.addAll(v);
}
if (typeDefinition == null) {
return 1;
}
- TypeDefinition<?> baseType = typeDefinition.getBaseType();
+ final TypeDefinition<?> baseType = typeDefinition.getBaseType();
if (baseType == null) {
return 1;
}
if (baseType.getBaseType() != null) {
depth = depth + getTypeDefinitionDepth(baseType);
} else if (baseType instanceof UnionTypeDefinition) {
- List<TypeDefinition<?>> childTypeDefinitions = ((UnionTypeDefinition) baseType).getTypes();
+ final List<TypeDefinition<?>> childTypeDefinitions = ((UnionTypeDefinition) baseType).getTypes();
int maxChildDepth = 0;
int childDepth = 1;
- for (TypeDefinition<?> childTypeDefinition : childTypeDefinitions) {
+ for (final TypeDefinition<?> childTypeDefinition : childTypeDefinitions) {
childDepth = childDepth + getTypeDefinitionDepth(childTypeDefinition);
if (childDepth > maxChildDepth) {
maxChildDepth = childDepth;
* @return string with the number suffix incremented by one (or 1 is added)
*/
private static String provideAvailableNameForGenTOBuilder(final String name) {
- Matcher mtch = NUMBERS_PATTERN.matcher(name);
+ final Matcher mtch = NUMBERS_PATTERN.matcher(name);
if (mtch.find()) {
final int newSuffix = Integer.valueOf(name.substring(mtch.start())) + 1;
return name.substring(0, mtch.start()) + newSuffix;
public static void addUnitsToGenTO(final GeneratedTOBuilder to, final String units) {
if (!Strings.isNullOrEmpty(units)) {
to.addConstant(Types.STRING, "_UNITS", "\"" + units + "\"");
- GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("UNITS");
+ final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("UNITS");
prop.setReturnType(Types.STRING);
to.addToStringProperty(prop);
}
}
public String getTypeDefaultConstruction(final LeafSchemaNode node, final String defaultValue) {
- TypeDefinition<?> type = CompatUtils.compatLeafType(node);
- QName typeQName = type.getQName();
- TypeDefinition<?> base = baseTypeDefForExtendedType(type);
+ final TypeDefinition<?> type = CompatUtils.compatLeafType(node);
+ final QName typeQName = type.getQName();
+ final TypeDefinition<?> base = baseTypeDefForExtendedType(type);
Preconditions.checkNotNull(type, "Cannot provide default construction for null type of %s", node);
Preconditions.checkNotNull(defaultValue, "Cannot provide default construction for null default statement of %s",
node);
- StringBuilder sb = new StringBuilder();
+ final StringBuilder sb = new StringBuilder();
String result = null;
if (base instanceof BinaryTypeDefinition) {
result = binaryToDef(defaultValue);
} else if (base instanceof BitsTypeDefinition) {
String parentName;
String className;
- Module parent = getParentModule(node);
- Iterator<QName> path = node.getPath().getPathFromRoot().iterator();
+ final Module parent = getParentModule(node);
+ final Iterator<QName> path = node.getPath().getPathFromRoot().iterator();
path.next();
if (!(path.hasNext())) {
parentName = BindingMapping.getClassName(parent.getName()) + "Data";
- String basePackageName = BindingMapping.getRootPackageName(parent.getQNameModule());
+ final String basePackageName = BindingMapping.getRootPackageName(parent.getQNameModule());
className = basePackageName + "." + parentName + "." + BindingMapping.getClassName(node.getQName());
} else {
- String basePackageName = BindingMapping.getRootPackageName(parent.getQNameModule());
- String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, type.getPath());
+ final String basePackageName = BindingMapping.getRootPackageName(parent.getQNameModule());
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, type.getPath());
parentName = BindingMapping.getClassName(parent.getName());
className = packageName + "." + parentName + "." + BindingMapping.getClassName(node.getQName());
}
} else if (base instanceof EmptyTypeDefinition) {
result = typeToBooleanDef(defaultValue);
} else if (base instanceof EnumTypeDefinition) {
- char[] defValArray = defaultValue.toCharArray();
- char first = Character.toUpperCase(defaultValue.charAt(0));
+ final char[] defValArray = defaultValue.toCharArray();
+ final char first = Character.toUpperCase(defaultValue.charAt(0));
defValArray[0] = first;
- String newDefVal = new String(defValArray);
+ final String newDefVal = new String(defValArray);
String className;
if (type.getBaseType() != null) {
- Module m = getParentModule(type);
- String basePackageName = BindingMapping.getRootPackageName(m.getQNameModule());
- String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, type.getPath());
+ final Module m = getParentModule(type);
+ final String basePackageName = BindingMapping.getRootPackageName(m.getQNameModule());
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, type.getPath());
className = packageName + "." + BindingMapping.getClassName(typeQName);
} else {
- Module parentModule = getParentModule(node);
- String basePackageName = BindingMapping.getRootPackageName(parentModule.getQNameModule());
- String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, node.getPath());
+ final Module parentModule = getParentModule(node);
+ final String basePackageName = BindingMapping.getRootPackageName(parentModule.getQNameModule());
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, node.getPath());
className = packageName + "." + BindingMapping.getClassName(node.getQName());
}
result = className + "." + newDefVal;
if (type.getBaseType() != null && !(base instanceof LeafrefTypeDefinition)
&& !(base instanceof EnumTypeDefinition) && !(base instanceof UnionTypeDefinition)) {
- Module m = getParentModule(type);
- String basePackageName = BindingMapping.getRootPackageName(m.getQNameModule());
- String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, type.getPath());
- String className = packageName + "." + BindingMapping.getClassName(typeQName);
+ final Module m = getParentModule(type);
+ final String basePackageName = BindingMapping.getRootPackageName(m.getQNameModule());
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, type.getPath());
+ final String className = packageName + "." + BindingMapping.getClassName(typeQName);
sb.insert(0, "new " + className + "(");
sb.insert(sb.length(), ')');
}
}
private static String binaryToDef(final String defaultValue) {
- StringBuilder sb = new StringBuilder();
- BaseEncoding en = BaseEncoding.base64();
- byte[] encoded = en.decode(defaultValue);
+ final StringBuilder sb = new StringBuilder();
+ final BaseEncoding en = BaseEncoding.base64();
+ final byte[] encoded = en.decode(defaultValue);
sb.append("new byte[] {");
for (int i = 0; i < encoded.length; i++) {
sb.append(encoded[i]);
private static final Comparator<Bit> BIT_NAME_COMPARATOR = (o1, o2) -> o1.getName().compareTo(o2.getName());
private static String bitsToDef(final BitsTypeDefinition type, final String className, final String defaultValue, final boolean isExt) {
- List<Bit> bits = new ArrayList<>(type.getBits());
+ final List<Bit> bits = new ArrayList<>(type.getBits());
Collections.sort(bits, BIT_NAME_COMPARATOR);
- StringBuilder sb = new StringBuilder();
+ final StringBuilder sb = new StringBuilder();
if (!isExt) {
sb.append("new ");
sb.append(className);
}
private Module getParentModule(final SchemaNode node) {
- QName qname = node.getPath().getPathFromRoot().iterator().next();
- URI namespace = qname.getNamespace();
- Date revision = qname.getRevision();
+ final QName qname = node.getPath().getPathFromRoot().iterator().next();
+ final URI namespace = qname.getNamespace();
+ final Date revision = qname.getRevision();
return schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
}
} else {
dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module, parentNode, xpath);
}
- String result = getTypeDefaultConstruction((LeafSchemaNode) dataNode, defaultValue);
+ final String result = getTypeDefaultConstruction((LeafSchemaNode) dataNode, defaultValue);
return result;
}
} else {
String className;
if (type.getBaseType() != null) {
- QName typeQName = type.getQName();
+ final QName typeQName = type.getQName();
Module module = null;
- Set<Module> modules = schemaContext.findModuleByNamespace(typeQName.getNamespace());
+ final Set<Module> modules = schemaContext.findModuleByNamespace(typeQName.getNamespace());
if (modules.size() > 1) {
- for (Module m : modules) {
+ for (final Module m : modules) {
if (m.getRevision().equals(typeQName.getRevision())) {
module = m;
break;
}
}
if (module == null) {
- List<Module> modulesList = new ArrayList<>(modules);
+ final List<Module> modulesList = new ArrayList<>(modules);
Collections.sort(modulesList, (o1, o2) -> o1.getRevision().compareTo(o2.getRevision()));
module = modulesList.get(0);
}
module = modules.iterator().next();
}
- String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
+ final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
className = basePackageName + "." + BindingMapping.getClassName(typeQName);
} else {
- Iterator<QName> path = node.getPath().getPathFromRoot().iterator();
- QName first = path.next();
+ final Iterator<QName> path = node.getPath().getPathFromRoot().iterator();
+ final QName first = path.next();
if (!(path.hasNext())) {
- URI namespace = first.getNamespace();
- Date revision = first.getRevision();
- Module parent = schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
+ final URI namespace = first.getNamespace();
+ final Date revision = first.getRevision();
+ final Module parent = schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
parentName = BindingMapping.getClassName((parent).getName()) + "Data";
- String basePackageName = BindingMapping.getRootPackageName(parent.getQNameModule());
+ final String basePackageName = BindingMapping.getRootPackageName(parent.getQNameModule());
className = basePackageName + "." + parentName + "." + BindingMapping.getClassName(node.getQName());
} else {
- URI namespace = first.getNamespace();
- Date revision = first.getRevision();
- Module parentModule = schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
- String basePackageName = BindingMapping.getRootPackageName(parentModule.getQNameModule());
- String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, UNION_PATH);
+ final URI namespace = first.getNamespace();
+ final Date revision = first.getRevision();
+ final Module parentModule = schemaContext.findModuleByNamespaceAndRevision(namespace, revision);
+ final String basePackageName = BindingMapping.getRootPackageName(parentModule.getQNameModule());
+ final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, UNION_PATH);
className = packageName + "." + BindingMapping.getClassName(node.getQName());
}
}
}
private static String union(final String className, final String defaultValue, final LeafSchemaNode node) {
- StringBuilder sb = new StringBuilder();
+ final StringBuilder sb = new StringBuilder();
sb.append("new ");
sb.append(className);
sb.append("(\"");
Code Review / mdsal.git / blobdiff