import java.io.BufferedWriter;
import java.io.File;
-import java.io.FileWriter;
import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.sonatype.plexus.build.incremental.BuildContext;
+import org.sonatype.plexus.build.incremental.DefaultBuildContext;
+
+import com.google.common.base.Preconditions;
/**
* Generates files with JAVA source codes for every specified type.
*/
private final Set<? extends Type> types;
+ /**
+ * BuildContext used for instantiating files
+ */
+ private final BuildContext buildContext;
+
/**
* Creates instance of this class with the set of <code>types</code> for
* which the JAVA code is generated.
*
* The instances of concrete JAVA code generator are created.
*
+ * @param buildContext
+ * build context to use for accessing files
* @param types
* set of types for which JAVA code should be generated
*/
- public GeneratorJavaFile(final Set<? extends Type> types) {
- this.types = types;
+ public GeneratorJavaFile(final BuildContext buildContext, final Set<? extends Type> types) {
+ this.buildContext = Preconditions.checkNotNull(buildContext);
+ this.types = Preconditions.checkNotNull(types);
generators.add(new InterfaceGenerator());
generators.add(new TOGenerator());
generators.add(new EnumGenerator());
generators.add(new BuilderGenerator());
}
+ /**
+ * Creates instance of this class with the set of <code>types</code> for
+ * which the JAVA code is generated. Generator instantiated this way uses
+ * the default build context, e.g. it will re-generate any and all files.
+ *
+ * The instances of concrete JAVA code generator are created.
+ *
+ * @param types
+ * set of types for which JAVA code should be generated
+ */
+ public GeneratorJavaFile(final Set<? extends Type> types) {
+ this(new DefaultBuildContext(), types);
+ }
+
/**
* Generates list of files with JAVA source code. Only the suitable code
* generator is used to generate the source code for the concrete type.
* directory to which the output source codes should be generated
* @return list of output files
* @throws IOException
- * if the error during writting to the file occures
+ * if the error during writing to the file occurs
*/
public List<File> generateToFile(final File parentDirectory) throws IOException {
final List<File> result = new ArrayList<>();
* code generator which is used for generating of the source code
* @return file which contains JAVA source code
* @throws IOException
- * if the error during writting to the file occures
+ * if the error during writing to the file occurs
* @throws IllegalArgumentException
* if <code>type</code> equals <code>null</code>
* @throws IllegalStateException
}
if (generator.isAcceptable(type)) {
- String generatedCode = generator.generate(type);
+ final String generatedCode = generator.generate(type);
if (generatedCode.isEmpty()) {
throw new IllegalStateException("Generated code should not be empty!");
}
final File file = new File(packageDir, generator.getUnitName(type) + ".java");
- try (final FileWriter fw = new FileWriter(file)) {
- file.createNewFile();
- try (final BufferedWriter bw = new BufferedWriter(fw)) {
- bw.write(generatedCode);
+ try (final OutputStream stream = buildContext.newFileOutputStream(file)) {
+ try (final Writer fw = new OutputStreamWriter(stream)) {
+ try (final BufferedWriter bw = new BufferedWriter(fw)) {
+ bw.write(generatedCode);
+ }
+ } catch (IOException e) {
+ LOG.error("Failed to write generate output into {}", file.getPath(), e);
+ throw e;
}
- } catch (IOException e) {
- LOG.error(e.getMessage());
- throw new IOException(e);
}
return file;
}
import org.opendaylight.yangtools.sal.java.api.generator.GeneratorJavaFile;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang2sources.spi.BuildContextAware;
import org.opendaylight.yangtools.yang2sources.spi.CodeGenerator;
+import org.sonatype.plexus.build.incremental.BuildContext;
-public final class CodeGeneratorImpl implements CodeGenerator {
+import com.google.common.base.Preconditions;
+
+public final class CodeGeneratorImpl implements CodeGenerator, BuildContextAware {
+ private BuildContext buildContext;
@Override
public Collection<File> generateSources(final SchemaContext context, final File outputDir,
final BindingGenerator bindingGenerator = new BindingGeneratorImpl();
final List<Type> types = bindingGenerator.generateTypes(context, yangModules);
- final GeneratorJavaFile generator = new GeneratorJavaFile(new HashSet<>(types));
+ final GeneratorJavaFile generator = new GeneratorJavaFile(buildContext, new HashSet<>(types));
return generator.generateToFile(outputBaseDir);
}
// no additional information needed
}
+ @Override
+ public void setBuildContext(BuildContext buildContext) {
+ this.buildContext = Preconditions.checkNotNull(buildContext);
+ }
+
}
import org.opendaylight.yangtools.yang.model.api.Module\r
import java.io.IOException\r
import java.util.HashSet\r
-import java.io.FileWriter\r
import java.io.BufferedWriter\r
+import java.io.OutputStream;\r
+import java.io.OutputStreamWriter;\r
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode\r
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode\r
import org.opendaylight.yangtools.yang.model.api.TypeDefinition\r
import java.util.Map\r
import org.opendaylight.yangtools.yang.model.api.SchemaPath\r
\r
+import org.sonatype.plexus.build.incremental.BuildContext;\r
+import org.sonatype.plexus.build.incremental.DefaultBuildContext;\r
+\r
import org.opendaylight.yangtools.yang.model.api.ChoiceNode\r
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode\r
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode\r
File path\r
static val REVISION_FORMAT = new SimpleDateFormat("yyyy-MM-dd")\r
static val Logger LOG = LoggerFactory.getLogger(GeneratorImpl)\r
+ static val BuildContext CTX = new DefaultBuildContext();\r
var Module currentModule;\r
\r
\r
def generateDocumentation(Module module) {\r
val destination = new File(path, '''«module.name».html''')\r
try {\r
- val fw = new FileWriter(destination)\r
- destination.createNewFile();\r
+ val fw = new OutputStreamWriter(CTX.newFileOutputStream(destination))\r
val bw = new BufferedWriter(fw)\r
currentModule = module;\r
bw.append(module.generate);\r