Changeset 13673


Ignore:
Timestamp:
Oct 4, 2019 4:27:47 PM (2 months ago)
Author:
molsson
Message:

#5843 Replaced some uses of File with Path.

Location:
branches/dev-mo-2265/Compiler
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • branches/dev-mo-2265/Compiler/ModelicaCompiler/src/jastadd/ModelicaCompiler.jrag

    r13396 r13673  
    348348            hooks.packFmu(this, fc, dir);
    349349        }
    350         fc.root().getUtilInterface().packFmu(fc);
     350        fc.root().getUtilInterface().packFmu(fc, dir.toPath());
    351351    }
    352352   
     
    358358            hooks.fmuPacked(this, fc, path);
    359359        }
    360         fc.root().getUtilInterface().fmuPacked(fc, path);
     360        fc.root().getUtilInterface().fmuPacked(fc, path.toPath());
    361361    }
    362362   
     
    838838             */
    839839            ASTNode.beginStep("packUnit()");
    840             File unitPath = packUnit(className, target, fc);
     840            Path unitPath = packUnit(className, target, fc);
    841841            unit = log.logCompiledUnit(unitPath, warnings, fc.numberOfComponents());
    842842            ASTNode.endStep("packUnit()");
     
    22072207     * Packs an FMU (helper function for {@link #compileUnit()}).
    22082208     */
    2209     protected File ModelicaCompiler.packUnit(String className,
     2209    protected Path ModelicaCompiler.packUnit(String className,
    22102210            TargetObject target, FClass fClass) throws PackingFailedException {
    22112211
    2212         File unitFile = fClass.root().getUtilInterface().getCompilationOutputPath();
     2212        Path unitFile = fClass.root().getUtilInterface().getCompilationOutputPath().toPath();
    22132213
    22142214        hookPackFmu(fClass, outDir);
     2215        hookCheckAbort();
    22152216        try {
    2216             hookCheckAbort();
    22172217            copySourceFiles(fClass, sourceDir, outDir);
    2218 
    2219             OutputStream dest = new BufferedOutputStream(new FileOutputStream(unitFile));
    2220             ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(dest));
    2221             out.setMethod(ZipOutputStream.DEFLATED);
    2222 
    2223             zipDir(outDir, out);
    2224             out.close();
    2225         } catch (CompilationAbortedException e) {
    2226             throw e;
     2218            try (ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(Files.newOutputStream(unitFile)))) {
     2219                out.setMethod(ZipOutputStream.DEFLATED);
     2220                zipDir(outDir, out);
     2221            }
    22272222        } catch (Exception e) {
    22282223            throw new PackingFailedException(String.format("Could not write to '%s'.", unitFile), e);
    22292224        }
    22302225
    2231         hookFmuPacked(fClass, unitFile.getAbsoluteFile());
     2226        hookFmuPacked(fClass, unitFile.toAbsolutePath().toFile());
    22322227        return unitFile;
    22332228    }
  • branches/dev-mo-2265/Compiler/ModelicaCompiler/src/jastadd/UtilInterface.jrag

    r13396 r13673  
    4141             * Called after code has been compiled.
    4242             */
    43             public void packFmu(FClass fc) {}
     43            public void packFmu(FClass fc, Path outDir) {}
    4444           
    4545            /**
    4646             * Called after code has been compiled.
    4747             */
    48             public void fmuPacked(FClass fc, File path) {}
     48            public void fmuPacked(FClass fc, Path outDir) {}
    4949           
    5050            /**
     
    146146    }
    147147   
    148     public void UtilInterface.packFmu(FClass fc) {
     148    public void UtilInterface.packFmu(FClass fc, Path outDir) {
    149149        for (Interfacer interfacer : interfacers) {
    150             interfacer.packFmu(fc);
     150            interfacer.packFmu(fc, outDir);
    151151        }
    152152    }
    153153   
    154     public void UtilInterface.fmuPacked(FClass fc, File path) {
     154    public void UtilInterface.fmuPacked(FClass fc, Path outDir) {
    155155        for (Interfacer interfacer : interfacers) {
    156             interfacer.fmuPacked(fc, path);
     156            interfacer.fmuPacked(fc, outDir);
    157157        }
    158158    }
  • branches/dev-mo-2265/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/GUIDManager.java

    r13396 r13673  
    22
    33import java.io.BufferedReader;
    4 import java.io.BufferedWriter;
     4import java.io.ByteArrayInputStream;
    55import java.io.ByteArrayOutputStream;
    66import java.io.File;
    7 import java.io.FileNotFoundException;
    8 import java.io.FileReader;
    9 import java.io.FileWriter;
    107import java.io.IOException;
    11 import java.io.OutputStreamWriter;
    12 import java.io.Reader;
    13 import java.io.StringReader;
    14 import java.io.Writer;
     8import java.io.InputStream;
     9import java.io.InputStreamReader;
     10import java.io.OutputStream;
     11import java.io.PrintWriter;
    1512import java.math.BigInteger;
    1613import java.nio.charset.Charset;
     14import java.nio.file.Files;
     15import java.nio.file.Path;
    1716import java.security.MessageDigest;
    1817import java.security.NoSuchAlgorithmException;
     
    6564
    6665    public void setSourceFile(File source) {
     66        this.source = new FileOpenable(source.toPath());
     67    }
     68
     69    public void setSourceFile(Path source) {
    6770        this.source = new FileOpenable(source);
    6871    }
     
    7376
    7477    public void addDependentFile(File dependentFile) {
     78        dependentFiles.add(new FileOpenable(dependentFile.toPath()));
     79    }
     80
     81    public void addDependentFile(Path dependentFile) {
    7582        dependentFiles.add(new FileOpenable(dependentFile));
    7683    }
    7784
    78     public void addDependentString(String input, StringBuilder output) {
     85    public void addDependentString(String input, ByteArrayOutputStream output) {
    7986        dependentFiles.add(new StringOpenable(input, output));
    8087    }
     
    8592            final MessageDigest md5 = MessageDigest.getInstance("MD5");
    8693
    87             try (final BufferedReader reader = new BufferedReader(source.openInput())) {
     94            try (final BufferedReader reader = new BufferedReader(new InputStreamReader(source.openInput()))) {
    8895                String line = reader.readLine();
    8996                while (line != null) {
     
    118125        for (final Openable openable : dependentFiles) {
    119126            try {
    120                 ByteArrayOutputStream os = new ByteArrayOutputStream();
    121                 try (final Writer tmp = new OutputStreamWriter(os)) {
    122                     processFiles(openable.openInput(), tmp);
    123                 }
    124 
    125                 try (BufferedWriter writer = new BufferedWriter(openable.openOutput())) {
    126                     writer.append(os.toString());
     127                try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
     128                    processFiles(openable.openInput(), os);
     129                    try (PrintWriter writer = new PrintWriter(openable.openOutput())) {
     130                        writer.append(os.toString());
     131                    }
    127132                }
    128133            } catch (IOException e) {
     
    132137    }
    133138
    134     private void processFiles(Reader source, Writer destination) throws IOException {
    135         try (final BufferedReader reader = new BufferedReader(source);
    136                 final BufferedWriter writer = new BufferedWriter(destination)) {
     139    private void processFiles(InputStream source, OutputStream destination) throws IOException {
     140        try (final BufferedReader reader = new BufferedReader(new InputStreamReader(source));
     141             final PrintWriter writer = new PrintWriter(destination)) {
    137142
    138143            String line =  reader.readLine();
     
    200205
    201206    private static interface Openable {
    202         public Reader openInput();
    203         public Writer openOutput();
     207        public InputStream openInput();
     208        public OutputStream openOutput();
    204209    }
    205210   
    206     private static class FileOpenable implements Openable{
    207         private File file;
    208        
    209         public FileOpenable(File file) {
    210             this.file = file;
    211         }
    212        
    213         @Override
    214         public Reader openInput() {
     211    private static class FileOpenable implements Openable {
     212        private Path path;
     213       
     214        public FileOpenable(Path file) {
     215            this.path = file;
     216        }
     217       
     218        @Override
     219        public InputStream openInput() {
    215220            try {
    216                 return new FileReader(file);
    217             } catch (FileNotFoundException e) {
    218                 throw new RuntimeException(e);
    219             }
    220         }
    221        
    222         @Override
    223         public Writer openOutput() {
    224             try {
    225                 return new FileWriter(file);
     221                return Files.newInputStream(path);
    226222            } catch (IOException e) {
    227223                throw new RuntimeException(e);
     
    230226       
    231227        @Override
     228        public OutputStream openOutput() {
     229            try {
     230                return Files.newOutputStream(path);
     231            } catch (IOException e) {
     232                throw new RuntimeException(e);
     233            }
     234        }
     235       
     236        @Override
    232237        public String toString() {
    233             return file.toString();
     238            return path.toString();
    234239        }
    235240    }
     
    238243       
    239244        private String input;
    240         private StringBuilder output;
    241        
    242         public StringOpenable(String input, StringBuilder output) {
     245        private ByteArrayOutputStream output;
     246       
     247        public StringOpenable(String input, ByteArrayOutputStream output) {
    243248            this.input = input;
    244249            this.output = output;
     
    246251       
    247252        @Override
    248         public Reader openInput() {
    249             return new StringReader(input);
    250         }
    251        
    252         @Override
    253         public Writer openOutput() {
    254             return new Writer() {
    255                
    256                 @Override
    257                 public void write(char[] cbuf, int off, int len) throws IOException {
    258                     output.append(cbuf, off, len);
    259                 }
    260                
    261                 @Override
    262                 public void flush() throws IOException {
    263                     // Do nothing
    264                 }
    265                
    266                 @Override
    267                 public void close() throws IOException {
    268                     // Do nothing
    269                 }
    270             };
     253        public InputStream openInput() {
     254            return new ByteArrayInputStream(input.getBytes());
     255        }
     256       
     257        @Override
     258        public OutputStream openOutput() {
     259            return output;
    271260        }
    272261    }
  • branches/dev-mo-2265/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/test/common/GUIDManagerTest.java

    r13396 r13673  
    44import static org.junit.Assert.assertFalse;
    55import static org.junit.Assert.assertTrue;
     6
     7import java.io.ByteArrayOutputStream;
    68
    79import org.jmodelica.common.GUIDManager;
     
    2022    private void test(String source, String[] dependent, String[] expected) {
    2123        guidManager.setSourceString(source);
    22         StringBuilder[] output = new StringBuilder[dependent.length];
     24        ByteArrayOutputStream[] output = new ByteArrayOutputStream[dependent.length];
    2325        for (int i = 0; i < dependent.length; i++) {
    24             output[i] = new StringBuilder();
     26            output[i] = new ByteArrayOutputStream();
    2527            guidManager.addDependentString(dependent[i], output[i]);
    2628        }
     
    4749        String expected = "guid=277efff8e9f33c422aa6e3fecb8b592";
    4850        guidManager.setSourceString(input);
    49         StringBuilder output = new StringBuilder();
     51        ByteArrayOutputStream output = new ByteArrayOutputStream();
    5052        guidManager.addDependentString(input, output);
    5153        guidManager.processDependentFiles();
  • branches/dev-mo-2265/Compiler/TestFramework/src/jastadd/CodeGenTestCase.jrag

    r11966 r13673  
    4444       
    4545        GUIDManager guidManager = fc.guidManager();
    46         StringBuilder actual = new StringBuilder();
     46        ByteArrayOutputStream actual = new ByteArrayOutputStream();
    4747        guidManager.setSourceString(test);
    4848        guidManager.addDependentString(test, actual);
Note: See TracChangeset for help on using the changeset viewer.