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 boolean generateToFile() {
  48         return generateToFile(null);
  49     }
  50
  51     public boolean generateToFile(String path) {
  52         try {
  53             for (GeneratedType type : types) {
  54                 String parentPath = generateParentPath(path,
  55                         type.getPackageName());
  56
  57                 File file = new File(parentPath, type.getName() + ".java");
  58                 File parent = file.getParentFile();
  59                 if (!parent.exists()) {
  60                     parent.mkdirs();
  61                 }
  62
  63                 if (!file.exists()) {
  64                     FileWriter fw = null;
  65                     BufferedWriter bw = null;
  66
  67                     file.createNewFile();
  68                     fw = new FileWriter(file);
  69                     bw = new BufferedWriter(fw);
  70                     Writer writer = interfaceGenerator.generate(type);
  71                     bw.write(writer.toString());
  72
  73                     if (bw != null) {
  74                         try {
  75                             bw.close();
  76                         } catch (IOException e) {
  77                             // TODO: log?
  78                         }
  79                     }
  80                 }
  81             }
  82             for (GeneratedTransferObject transferObject : genTransferObjects) {
  83                 String parentPath = generateParentPath(path,
  84                         transferObject.getPackageName());
  85
  86                 File file = new File(parentPath, transferObject.getName() + ".java");
  87                 File parent = file.getParentFile();
  88                 if (!parent.exists()) {
  89                     parent.mkdirs();
  90                 }
  91
  92                 if (!file.exists()) {
  93                     FileWriter fw = null;
  94                     BufferedWriter bw = null;
  95
  96                     file.createNewFile();
  97                     fw = new FileWriter(file);
  98                     bw = new BufferedWriter(fw);
  99                     Writer writer = classGenerator.generate(transferObject);
 100                     bw.write(writer.toString());
 101
 102                     if (bw != null) {
 103                         try {
 104                             bw.close();
 105                         } catch (IOException e) {
 106                             // TODO: log?
 107                         }
 108                     }
 109                 }
 110             }
 111             return true;
 112         } catch (IOException e) {
 113             // TODO: log?
 114             return false;
 115         }
 116     }
 117
 118     private String generateParentPath(String path, String pkg) {
 119         List<String> dirs = new ArrayList<String>();
 120         String pkgPath = "";
 121         if (pkg != null) {
 122             if (pkg.length() > 0) {
 123                 if (pkg.contains(".")) {
 124                     String[] split = pkg.split("\\.");
 125                     for (String dir : split) {
 126                         dirs.add(dir);
 127                     }
 128                 } else {
 129                     dirs.add(pkg);
 130                 }
 131                 for (int i = 0; i < dirs.size(); i++) {
 132                     if (i == 0) {
 133                         pkgPath += dirs.get(i);
 134                     } else {
 135                         pkgPath += File.separator + dirs.get(i);
 136                     }
 137                 }
 138             }
 139         }
 140         String fullPath = "";
 141         if (path != null) {
 142             if (path.endsWith(File.separator)) {
 143                 fullPath = path + pkgPath;
 144             } else {
 145                 fullPath = path + File.separator + pkgPath;
 146             }
 147         } else {
 148             fullPath = pkgPath;
 149         }
 150         return fullPath;
 151     }
 152
 153 }