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
  24 public class GeneratorJavaFile {
  25
  26     private final CodeGenerator interfaceGenerator;
  27     private final ClassCodeGenerator classGenerator;
  28     private final Set<GeneratedType> types;
  29     private final Set<GeneratedTransferObject> genTransferObjects;
  30
  31     public GeneratorJavaFile(final CodeGenerator codeGenerator,
  32             final Set<GeneratedType> types) {
  33         this.interfaceGenerator = codeGenerator;
  34         this.types = types;
  35         this.genTransferObjects = new HashSet<GeneratedTransferObject>();
  36         classGenerator = new ClassCodeGenerator();
  37     }
  38
  39     public GeneratorJavaFile(final Set<GeneratedType> types,
  40             final Set<GeneratedTransferObject> genTransferObjects) {
  41         this.interfaceGenerator = new InterfaceGenerator();
  42         this.classGenerator = new ClassCodeGenerator();
  43         this.types = types;
  44         this.genTransferObjects = genTransferObjects;
  45     }
  46
  47     public List<File> generateToFile() throws IOException {
  48         return generateToFile(null);
  49     }
  50
  51     public List<File> generateToFile(String path) throws IOException {
  52         final List<File> result = new ArrayList<File>();
  53
  54         for (GeneratedType type : types) {
  55             String parentPath = generateParentPath(path,
  56                     type.getPackageName());
  57
  58             File file = new File(parentPath, type.getName() + ".java");
  59             File parent = file.getParentFile();
  60             if (!parent.exists()) {
  61                 parent.mkdirs();
  62             }
  63
  64             if (!file.exists()) {
  65                 FileWriter fw = null;
  66                 BufferedWriter bw = null;
  67
  68                 file.createNewFile();
  69                 fw = new FileWriter(file);
  70                 bw = new BufferedWriter(fw);
  71                 Writer writer = interfaceGenerator.generate(type);
  72                 bw.write(writer.toString());
  73
  74                 if (bw != null) {
  75                     bw.close();
  76                 }
  77                 result.add(file);
  78             }
  79         }
  80
  81         for (GeneratedTransferObject transferObject : genTransferObjects) {
  82             String parentPath = generateParentPath(path,
  83                     transferObject.getPackageName());
  84
  85             File file = new File(parentPath, transferObject.getName() + ".java");
  86             File parent = file.getParentFile();
  87             if (!parent.exists()) {
  88                 parent.mkdirs();
  89             }
  90
  91             if (!file.exists()) {
  92                 FileWriter fw = null;
  93                 BufferedWriter bw = null;
  94
  95                 file.createNewFile();
  96                 fw = new FileWriter(file);
  97                 bw = new BufferedWriter(fw);
  98                 Writer writer = classGenerator.generate(transferObject);
  99                 bw.write(writer.toString());
 100
 101                 if (bw != null) {
 102                     bw.close();
 103                 }
 104                 result.add(file);
 105             }
 106         }
 107
 108         return result;
 109     }
 110
 111     private String generateParentPath(String path, String pkg) {
 112         List<String> dirs = new ArrayList<String>();
 113         String pkgPath = "";
 114         if (pkg != null) {
 115             if (pkg.length() > 0) {
 116                 if (pkg.contains(".")) {
 117                     String[] split = pkg.split("\\.");
 118                     for (String dir : split) {
 119                         dirs.add(dir);
 120                     }
 121                 } else {
 122                     dirs.add(pkg);
 123                 }
 124                 for (int i = 0; i < dirs.size(); i++) {
 125                     if (i == 0) {
 126                         pkgPath += dirs.get(i);
 127                     } else {
 128                         pkgPath += File.separator + dirs.get(i);
 129                     }
 130                 }
 131             }
 132         }
 133         String fullPath = "";
 134         if (path != null) {
 135             if (path.endsWith(File.separator)) {
 136                 fullPath = path + pkgPath;
 137             } else {
 138                 fullPath = path + File.separator + pkgPath;
 139             }
 140         } else {
 141             fullPath = pkgPath;
 142         }
 143         return fullPath;
 144     }
 145
 146 }