--- /dev/null
+package org.opendaylight.controller.sal.java.api.generator;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
+import org.opendaylight.controller.sal.binding.model.api.MethodSignature;
+import org.opendaylight.controller.sal.binding.model.api.ParameterizedType;
+import org.opendaylight.controller.sal.binding.model.api.Type;
+import org.opendaylight.controller.yang.binding.Augmentable;
+
+public class BuilderClassDescriptor {
+
+ private static final String GET_PREFIX = "get";
+ private static final String JAVA_UTIL = "java.util";
+ private static final String HASH_MAP = "HashMap";
+ private static final String MAP = "Map";
+ private static final String GET_AUGMENTATION_METHOD_NAME = "getAugmentation";
+
+ private final GeneratedType genType;
+ private Map<String, String> imports;
+ private final String packageName;
+ private final String className;
+ private final Set<MethodDeclaration> methods;
+ private final Set<FieldDeclaration> fields;
+ private final List<String> importsNames;
+ private FieldDeclaration augmentField;
+
+ class TypeDeclaration {
+
+ private final static String JAVA_LANG_PREFIX = "java.lang";
+ private final String name;
+ private final TypeDeclaration[] generics;
+
+ public TypeDeclaration(String pkg, String name, TypeDeclaration... generics) {
+ this.name = removeJavaLangPkgName(getRightTypeName(pkg, name));
+ if (generics != null && generics.length > 0) {
+ this.generics = generics;
+ } else {
+ this.generics = null;
+ }
+ }
+
+ public TypeDeclaration(final Type type) {
+ if (type == null) {
+ throw new IllegalArgumentException("Type cannot be NULL");
+ }
+
+ this.name = removeJavaLangPkgName(getRightTypeName(type.getPackageName(), type.getName()));
+ TypeDeclaration[] generics = null;
+ if (type instanceof ParameterizedType) {
+ final ParameterizedType pType = (ParameterizedType) type;
+ final Type[] actualTypeArguments = pType.getActualTypeArguments();
+ generics = new TypeDeclaration[actualTypeArguments.length];
+ for (int i = 0; i < actualTypeArguments.length; i++) {
+ generics[i] = new TypeDeclaration(actualTypeArguments[i].getPackageName(),
+ actualTypeArguments[i].getName());
+ }
+ }
+ if (generics != null && generics.length > 0) {
+ this.generics = generics;
+ } else {
+ this.generics = null;
+ }
+ }
+
+ private String removeJavaLangPkgName(final String typeName) {
+ if (typeName.startsWith(JAVA_LANG_PREFIX)) {
+ return typeName.substring(typeName.lastIndexOf(Constants.DOT) + 1);
+ }
+ return typeName;
+ }
+
+ private String getRightTypeName(final String pkg, final String name) {
+ if (name == null) {
+ throw new IllegalArgumentException("Name cannot be NULL!");
+ }
+
+ if (imports == null) {
+ return name;
+ }
+ final String pkgFromImports = imports.get(name);
+ if (pkgFromImports == null || pkgFromImports.equals(pkg)) {
+ return name;
+ }
+ return (pkg == null ? "" : pkg) + Constants.DOT + name;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public TypeDeclaration[] getGenerics() {
+ return generics;
+ }
+
+ }
+
+ class ParameterDeclaration {
+
+ private final TypeDeclaration type;
+ private final String name;
+
+ public ParameterDeclaration(TypeDeclaration type, String name) {
+ this.type = type;
+ this.name = name;
+ }
+
+ public TypeDeclaration getType() {
+ return type;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ }
+
+ class MethodDeclaration {
+
+ private final TypeDeclaration returnType;
+ private final String name;
+ private final List<ParameterDeclaration> parameters;
+
+ public MethodDeclaration(final TypeDeclaration returnType, final String name,
+ final List<ParameterDeclaration> parameters) {
+ this.returnType = returnType;
+ this.name = name;
+ if (parameters != null && !parameters.isEmpty()) {
+ this.parameters = parameters;
+ } else {
+ this.parameters = null;
+ }
+ }
+
+ public TypeDeclaration getReturnType() {
+ return returnType;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public List<ParameterDeclaration> getParameters() {
+ return parameters;
+ }
+
+ }
+
+ class FieldDeclaration extends ParameterDeclaration {
+
+ public FieldDeclaration(final TypeDeclaration type, final String name) {
+ super(type, name);
+ }
+
+ }
+
+ public BuilderClassDescriptor(final GeneratedType genType) {
+ if (genType == null) {
+ throw new IllegalArgumentException("Generated type reference cannot be NULL!");
+ }
+ this.genType = genType;
+ this.imports = GeneratorUtil.createImports(genType);
+ addToImports(genType.getPackageName(), genType.getName());
+ packageName = genType.getPackageName();
+ className = genType.getName();
+ methods = createMethods();
+ fields = createFieldsFromMethods();
+ importsNames = createImportsNames();
+ }
+
+ private Set<MethodDeclaration> createMethods() {
+ final Set<MethodDeclaration> methods = new LinkedHashSet<>();
+ storeMethodsOfIfc(methods, genType);
+ storeMethodsOfImplementedIfcs(methods, genType.getImplements());
+ return methods;
+ }
+
+ private void storeMethodsOfIfc(final Set<MethodDeclaration> methodStorage, final GeneratedType ifc) {
+ for (MethodSignature methodSignature : ifc.getMethodDefinitions()) {
+ final List<ParameterDeclaration> parameterDeclarations = getParameterDeclarationsFrom(methodSignature
+ .getParameters());
+ methodStorage.add(new MethodDeclaration(new TypeDeclaration(methodSignature.getReturnType()),
+ methodSignature.getName(), parameterDeclarations));
+ }
+ if (ifc.getEnclosedTypes() != null && !ifc.getEnclosedTypes().isEmpty()) {
+ addToImports(ifc.getPackageName(), ifc.getName() + ".*");
+ }
+ }
+
+ private List<ParameterDeclaration> getParameterDeclarationsFrom(final List<MethodSignature.Parameter> parameters) {
+ final List<ParameterDeclaration> parameterDeclarations = new ArrayList<>();
+ for (MethodSignature.Parameter mp : parameters) {
+ parameterDeclarations.add(new ParameterDeclaration(new TypeDeclaration(mp.getType()), mp.getName()));
+ }
+ return parameterDeclarations;
+ }
+
+ private void storeMethodsOfImplementedIfcs(final Set<MethodDeclaration> methodStorage,
+ final List<Type> implementedIfcs) {
+ if (implementedIfcs == null || implementedIfcs.isEmpty()) {
+ return;
+ }
+ for (Type implementedIfc : implementedIfcs) {
+ if ((implementedIfc instanceof GeneratedType && !(implementedIfc instanceof GeneratedTransferObject))) {
+ final GeneratedType ifc = ((GeneratedType) implementedIfc);
+ storeMethodsOfIfc(methodStorage, ifc);
+ storeMethodsOfImplementedIfcs(methodStorage, ifc.getImplements());
+ } else if (implementedIfc.getFullyQualifiedName().equals(Augmentable.class.getName())) {
+ for (Method m : Augmentable.class.getMethods()) {
+ if (m.getName().equals(GET_AUGMENTATION_METHOD_NAME)) {
+ addToImports(JAVA_UTIL, HASH_MAP);
+ addToImports(JAVA_UTIL, MAP);
+ java.lang.reflect.Type returnType = m.getReturnType();
+ final String fullyQualifiedName = ((Class<?>) returnType).getName();
+ addToImports(getPackageFrom(fullyQualifiedName), getNameFrom(fullyQualifiedName));
+ TypeDeclaration augmentMethodType = new TypeDeclaration(getPackageFrom(fullyQualifiedName),
+ getNameFrom(fullyQualifiedName), new TypeDeclaration(genType));
+ augmentField = createFieldFromGetMethod(new MethodDeclaration(augmentMethodType, m.getName(),
+ null));
+ }
+ }
+ }
+ }
+ }
+
+ private void addToImports(final String pkg, final String name) {
+ if (imports == null) {
+ imports = new LinkedHashMap<>();
+ }
+ if (imports.get(name) == null) {
+ imports.put(name, pkg);
+ }
+ }
+
+ private String getPackageFrom(final String fullyQualifiedName) {
+ final int lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT);
+ return lastDotIndex == -1 ? "" : fullyQualifiedName.substring(0, lastDotIndex);
+ }
+
+ private String getNameFrom(final String fullyQualifiedName) {
+ final int lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT);
+ return lastDotIndex == -1 ? fullyQualifiedName : fullyQualifiedName.substring(lastDotIndex + 1);
+ }
+
+ private Set<FieldDeclaration> createFieldsFromMethods() {
+ final Set<FieldDeclaration> result = new LinkedHashSet<>();
+
+ if (methods == null || methods.isEmpty()) {
+ return result;
+ }
+
+ for (MethodDeclaration m : methods) {
+ final FieldDeclaration createdField = createFieldFromGetMethod(m);
+ if (createdField != null) {
+ result.add(createdField);
+ }
+ }
+ return result;
+ }
+
+ private FieldDeclaration createFieldFromGetMethod(final MethodDeclaration method) {
+ if (method == null || method.getName() == null || method.getName().isEmpty()) {
+ return null;
+ } else if (method.getName().startsWith(GET_PREFIX)) {
+ final String fieldNameFromMethod = method.getName().substring(GET_PREFIX.length());
+ final String fieldName = Character.toLowerCase(fieldNameFromMethod.charAt(0))
+ + fieldNameFromMethod.substring(1);
+ return new FieldDeclaration(method.getReturnType(), fieldName);
+ }
+ return null;
+ }
+
+ private List<String> createImportsNames() {
+ final List<String> result = new ArrayList<>();
+
+ if (imports == null || imports.isEmpty()) {
+ return result;
+ }
+
+ for (Map.Entry<String, String> entry : imports.entrySet()) {
+ final String typeName = entry.getKey();
+ final String packageName = entry.getValue();
+ result.add(packageName + Constants.DOT + typeName);
+ }
+ return result;
+ }
+
+ public String getPackageName() {
+ return packageName;
+ }
+
+ /**
+ * @return list of imports or empty list
+ */
+ public List<String> getImportsNames() {
+ return importsNames;
+ }
+
+ public String getClassName() {
+ return className;
+ }
+
+ /**
+ * @return set of methods or empty set
+ */
+ public Set<FieldDeclaration> getFields() {
+ return fields;
+ }
+
+ /**
+ * @return set of methods or empty set
+ */
+ public Set<MethodDeclaration> getMethods() {
+ return methods;
+ }
+
+ /**
+ * @return declaration of augment field or NULL
+ */
+ public FieldDeclaration getAugmentField() {
+ return augmentField;
+ }
+
+}
Code Review / controller.git / blobdiff