@SuppressWarnings({ "unchecked", "rawtypes" })
static Type createReturnTypeForUnion(final GeneratedTOBuilder genTOBuilder, final TypeDefinition<?> typeDef,
final GeneratedTypeBuilder typeBuilder, final Module parentModule, final TypeProvider typeProvider) {
- final GeneratedTOBuilderImpl returnType = new GeneratedTOBuilderImpl(genTOBuilder.getPackageName(),
- genTOBuilder.getName());
+ final GeneratedTOBuilderImpl returnType = (GeneratedTOBuilderImpl) genTOBuilder;
final String typedefDescription = encodeAngleBrackets(typeDef.getDescription());
returnType.setDescription(typedefDescription);
final String basePackageName = BindingMapping.getRootPackageName(module);
final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, typeDefinition
.getPath(), BindingNamespaceType.Typedef);
- final String genTOName = JavaIdentifierNormalizer.normalizeClassIdentifier(packageName, typedefName);
+ final String genTOName =
+ JavaIdentifierNormalizer.normalizeSpecificIdentifier(typedefName, JavaIdentifier.CLASS);
final String name = packageName + "." + genTOName;
if (!(returnType.getFullyQualifiedName().equals(name))) {
returnType = shadedTOWithRestrictions(gto, r);
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-
import java.util.List;
import org.junit.Test;
import org.opendaylight.mdsal.binding.javav2.generator.api.BindingGenerator;
public class BindingGeneratorImplTest {
+ @Test
+ public void genTypesTypeDefTest() throws Exception {
+ final BindingGeneratorImpl bg = new BindingGeneratorImpl(false);
+ final SchemaContext schemaContext = YangParserTestUtils.parseYangSource("/generator/test-typedef.yang");
+ final List<Type> generateTypes = bg.generateTypes(schemaContext);
+ assertNotNull(generateTypes);
+ for (final Type genType : generateTypes) {
+ if (genType.getName().equals("MyInnerCont") && genType.getPackageName()
+ .equals("org.opendaylight.mdsal.gen.javav2.urn.test.simple.test.rev170206.data.asteriskmy_cont")) {
+ final GeneratedType gt = (GeneratedType) genType;
+ for (final MethodSignature methodSignature : gt.getMethodDefinitions()) {
+ if (methodSignature.getName().equals("getMyLeaf2")) {
+ assertEquals(methodSignature.getReturnType().getName(), "MyType");
+ }
+ }
+ }
+ }
+ }
+
@Test
public void generatedTypesEnumTest() throws Exception {
final BindingGenerator bg = new BindingGeneratorImpl(false);
--- /dev/null
+module test {
+ yang-version 1;
+
+ namespace "urn:test:simple:test";
+ prefix test;
+ organization "test.org";
+ revision "2017-02-06";
+
+ typedef my-type {
+ type int8;
+ }
+
+ container *my-cont {
+ container my-inner-cont {
+ leaf my-leaf {
+ type string;
+ }
+
+ leaf my-leaf2 {
+ type my-type;
+ }
+ }
+ }
+
+ container my-union-cont {
+ leaf my-union-leaf {
+ type union {
+ type int8;
+ type int16;
+ }
+ }
+ }
+
+ grouping my-grouping {
+ container *my-cont {
+ }
+ }
+}
\ No newline at end of file
import com.google.common.collect.ListMultimap;
import java.util.List;
import java.util.Set;
-import org.apache.commons.lang3.StringUtils;
import org.opendaylight.mdsal.binding.javav2.model.api.Enumeration;
import org.opendaylight.mdsal.binding.javav2.model.api.Enumeration.Pair;
import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
private static final String EMPTY_STRING = "";
private static final String RESERVED_KEYWORD = "reserved_keyword";
private static final ListMultimap<String, String> PACKAGES_MAP = ArrayListMultimap.create();
+ private static final Set<String> PRIMITIVE_TYPES = ImmutableSet.of("char[]", "byte[]");
public static final Set<String> SPECIAL_RESERVED_PATHS =
ImmutableSet.of("org.opendaylight.yangtools.yang.model","org.opendaylight.yangtools.concepts","org.opendaylight.yangtools.yang.common",
- "org.opendaylight.mdsal.binding.javav2.spec","java", "com");
+ "org.opendaylight.mdsal.binding.javav2.spec", "java", "com");
private JavaIdentifierNormalizer() {
throw new UnsupportedOperationException("Util class");
// capitalize last part of normalized package name
if (packageNameParts.length != 1 && i == packageNameParts.length - 1
&& Character.isUpperCase(packageNameParts[i].charAt(FIRST_CHAR))) {
- normalizedPartialPackageName = StringUtils.capitalize(normalizedPartialPackageName);
+ normalizedPartialPackageName = packageNameParts[i];
}
sb.append(normalizedPartialPackageName);
* @return - java acceptable identifier
*/
public static String normalizeClassIdentifier(final String packageName, final String className) {
+ if (packageName.isEmpty() && PRIMITIVE_TYPES.contains(className)) {
+ return className;
+ }
for (final String reservedPath : SPECIAL_RESERVED_PATHS) {
if (packageName.startsWith(reservedPath)) {
return className;
importMap.put(typeName, typePackageName);
}
+ protected void putAllToImportMap(@NonNull Map<String, String> imports) {
+ importMap.putAll(imports);
+ }
+
protected Map<String, String> getImportMap() {
return ImmutableMap.copyOf(importMap);
}
* set to true
*/
private List<GeneratedProperty> resolveReadOnlyPropertiesFromTO(final List<GeneratedProperty> properties) {
- return new ArrayList(Collections2.transform(properties, GeneratedProperty::isReadOnly));
+ return new ArrayList<>(Collections2.filter(properties, GeneratedProperty::isReadOnly));
}
/**
if (((GeneratedTransferObject) innerClass).isUnionType()) {
final UnionRenderer unionRenderer = new UnionRenderer((GeneratedTransferObject) innerClass);
innerClasses.add(unionRenderer.body());
- this.getImportMap().putAll(unionRenderer.getImportMap());
+ this.putAllToImportMap(unionRenderer.getImportMap());
} else {
final ClassRenderer classRenderer = new ClassRenderer((GeneratedTransferObject) innerClass);
innerClasses.add(classRenderer.generateAsInnerClass());
- this.getImportMap().putAll(classRenderer.getImportMap());
+ this.putAllToImportMap(classRenderer.getImportMap());
}
}
}
import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.BOOLEAN;
-import com.google.common.base.Function;
import com.google.common.base.Predicate;
-import com.google.common.collect.Iterables;
+import com.google.common.collect.Collections2;
import java.beans.ConstructorProperties;
import java.util.ArrayList;
import java.util.HashMap;
return super.getterMethod(field);
}
- final Function<GeneratedProperty, Boolean> tempFunction = (GeneratedProperty p) -> {
- String name = p.getName();
- return !"value".equals(name);
- };
- List<GeneratedProperty> filtered = (List) Iterables.filter(this.getFinalProperties(),
- (Predicate<? super GeneratedProperty>) tempFunction);
+ Predicate<GeneratedProperty> predicate = input -> !"value".equals(input.getName());
+ final List<GeneratedProperty> filtered = new ArrayList<>(Collections2.filter(this.getFinalProperties(),
+ predicate));
final List<CharSequence> strings = new ArrayList<>(filtered.size());
Code Review / mdsal.git / commitdiff