opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/GeneratorJavaFile.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.sal.java.api.generator;
   9
  10 import java.io.BufferedWriter;
  11 import java.io.File;
  12 import java.io.FileWriter;
  13 import java.io.IOException;
  14 import java.io.Writer;
  15 import java.util.ArrayList;
  16 import java.util.HashSet;
  17 import java.util.List;
  18 import java.util.Set;
  19
  20 import org.opendaylight.controller.sal.binding.model.api.CodeGenerator;
  21 import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
  22 import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
  23 import org.opendaylight.controller.sal.binding.model.api.Type;
  24 import org.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26
  27 public class GeneratorJavaFile {
  28
  29     private static final Logger log = LoggerFactory
  30             .getLogger(GeneratorJavaFile.class);
  31     private final CodeGenerator interfaceGenerator;
  32     private final ClassCodeGenerator classGenerator;
  33     private final Set<GeneratedType> genTypes;
  34     private final Set<GeneratedTransferObject> genTransferObjects;
  35
  36     public GeneratorJavaFile(final CodeGenerator codeGenerator,
  37             final Set<GeneratedType> types) {
  38         this.interfaceGenerator = codeGenerator;
  39         this.genTypes = types;
  40         this.genTransferObjects = new HashSet<GeneratedTransferObject>();
  41         classGenerator = new ClassCodeGenerator();
  42     }
  43
  44     public GeneratorJavaFile(final Set<GeneratedType> types,
  45             final Set<GeneratedTransferObject> genTransferObjects) {
  46         this.interfaceGenerator = new InterfaceGenerator();
  47         this.classGenerator = new ClassCodeGenerator();
  48         this.genTypes = types;
  49         this.genTransferObjects = genTransferObjects;
  50     }
  51
  52     @Deprecated
  53     public List<File> generateToFile(String path) throws IOException {
  54         final List<File> result = new ArrayList<File>();
  55
  56         for (GeneratedType genType : genTypes) {
  57             final String parentPath = generateParentPath(path,
  58                     genType.getPackageName());
  59
  60             final File directory = new File(parentPath);
  61             final File genFile = generateTypeToJavaFile(directory, genType,
  62                     interfaceGenerator);
  63
  64             if (genFile != null) {
  65                 result.add(genFile);
  66             }
  67         }
  68
  69         for (GeneratedTransferObject transferObject : genTransferObjects) {
  70             final String parentPath = generateParentPath(path,
  71                     transferObject.getPackageName());
  72
  73             final File directory = new File(parentPath);
  74             final File genFile = generateTypeToJavaFile(directory,
  75                     transferObject, classGenerator);
  76
  77             if (genFile != null) {
  78                 result.add(genFile);
  79             }
  80         }
  81         return result;
  82     }
  83
  84     public List<File> generateToFile(final File parentDirectory) throws IOException {
  85         final List<File> result = new ArrayList<File>();
  86         for (GeneratedType type : genTypes) {
  87             final File genFile = generateTypeToJavaFile(parentDirectory, type,
  88                     interfaceGenerator);
  89
  90             if (genFile != null) {
  91                 result.add(genFile);
  92             }
  93         }
  94         for (GeneratedTransferObject transferObject : genTransferObjects) {
  95             final File genFile = generateTypeToJavaFile(parentDirectory,
  96                     transferObject, classGenerator);
  97
  98             if (genFile != null) {
  99                 result.add(genFile);
 100             }
 101         }
 102         return result;
 103     }
 104
 105     private File generateTypeToJavaFile(final File parentDir, final Type type,
 106             final CodeGenerator generator) throws IOException {
 107         if (parentDir == null) {
 108             log.warn("Parent Directory not specified, files will be generated "
 109                     + "accordingly to generated Type package path.");
 110         }
 111         if (type == null) {
 112             log.error("Cannot generate Type into Java File because " +
 113                         "Generated Type is NULL!");
 114             throw new IllegalArgumentException("Generated Type Cannot be NULL!");
 115         }
 116         if (generator == null) {
 117             log.error("Cannot generate Type into Java File because " +
 118                         "Code Generator instance is NULL!");
 119             throw new IllegalArgumentException("Code Generator Cannot be NULL!");
 120         }
 121         final File packageDir = packageToDirectory(parentDir,
 122                 type.getPackageName());
 123
 124         if (!packageDir.exists()) {
 125             packageDir.mkdirs();
 126         }
 127         final File file = new File(packageDir, type.getName() + ".java");
 128         try (final FileWriter fw = new FileWriter(file)) {
 129             file.createNewFile();
 130
 131             try (final BufferedWriter bw = new BufferedWriter(fw)) {
 132                 Writer writer = generator.generate(type);
 133                 bw.write(writer.toString());
 134             }
 135         } catch (IOException e) {
 136             log.error(e.getMessage());
 137             throw new IOException(e.getMessage());
 138         }
 139         return file;
 140     }
 141
 142     private File packageToDirectory(final File parentDirectory,
 143             final String packageName) {
 144         if (packageName == null) {
 145             throw new IllegalArgumentException("Package Name cannot be NULL!");
 146         }
 147
 148         final String[] subDirNames = packageName.split("\\.");
 149         final StringBuilder dirPathBuilder = new StringBuilder();
 150         dirPathBuilder.append(subDirNames[0]);
 151         for (int i = 1; i < subDirNames.length; ++i) {
 152             dirPathBuilder.append(File.separator);
 153             dirPathBuilder.append(subDirNames[i]);
 154         }
 155         return new File(parentDirectory, dirPathBuilder.toString());
 156     }
 157
 158     @Deprecated
 159     private String generateParentPath(String path, String pkg) {
 160         List<String> dirs = new ArrayList<String>();
 161         String pkgPath = "";
 162         if (pkg != null) {
 163             if (pkg.length() > 0) {
 164                 if (pkg.contains(".")) {
 165                     String[] split = pkg.split("\\.");
 166                     for (String dir : split) {
 167                         dirs.add(dir);
 168                     }
 169                 } else {
 170                     dirs.add(pkg);
 171                 }
 172                 for (int i = 0; i < dirs.size(); i++) {
 173                     if (i == 0) {
 174                         pkgPath += dirs.get(i);
 175                     } else {
 176                         pkgPath += File.separator + dirs.get(i);
 177                     }
 178                 }
 179             }
 180         }
 181         String fullPath = "";
 182         if (path != null) {
 183             if (path.endsWith(File.separator)) {
 184                 fullPath = path + pkgPath;
 185             } else {
 186                 fullPath = path + File.separator + pkgPath;
 187             }
 188         } else {
 189             fullPath = pkgPath;
 190         }
 191         return fullPath;
 192     }
 193 }