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 directory) throws IOException {
  85         final List<File> result = new ArrayList<File>();
  86         for (GeneratedType type : genTypes) {
  87             final File genFile = generateTypeToJavaFile(directory, type,
  88                     interfaceGenerator);
  89
  90             if (genFile != null) {
  91                 result.add(genFile);
  92             }
  93         }
  94         for (GeneratedTransferObject transferObject : genTransferObjects) {
  95             final File genFile = generateTypeToJavaFile(directory,
  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 directory, final Type type,
 106             final CodeGenerator generator) throws IOException {
 107         if ((directory != null) && (type != null) && (generator != null)) {
 108
 109             if (!directory.exists()) {
 110                 directory.mkdirs();
 111             }
 112
 113             final File file = new File(directory, type.getName() + ".java");
 114             try (final FileWriter fw = new FileWriter(file)) {
 115                 file.createNewFile();
 116
 117                 try (final BufferedWriter bw = new BufferedWriter(fw)) {
 118                     Writer writer = generator.generate(type);
 119                     bw.write(writer.toString());
 120                 }
 121             } catch (IOException e) {
 122                 log.error(e.getMessage());
 123                 throw new IOException(e.getMessage());
 124             }
 125
 126             return file;
 127         }
 128         return null;
 129     }
 130
 131     private String generateParentPath(String path, String pkg) {
 132         List<String> dirs = new ArrayList<String>();
 133         String pkgPath = "";
 134         if (pkg != null) {
 135             if (pkg.length() > 0) {
 136                 if (pkg.contains(".")) {
 137                     String[] split = pkg.split("\\.");
 138                     for (String dir : split) {
 139                         dirs.add(dir);
 140                     }
 141                 } else {
 142                     dirs.add(pkg);
 143                 }
 144                 for (int i = 0; i < dirs.size(); i++) {
 145                     if (i == 0) {
 146                         pkgPath += dirs.get(i);
 147                     } else {
 148                         pkgPath += File.separator + dirs.get(i);
 149                     }
 150                 }
 151             }
 152         }
 153         String fullPath = "";
 154         if (path != null) {
 155             if (path.endsWith(File.separator)) {
 156                 fullPath = path + pkgPath;
 157             } else {
 158                 fullPath = path + File.separator + pkgPath;
 159             }
 160         } else {
 161             fullPath = pkgPath;
 162         }
 163         return fullPath;
 164     }
 165 }