Add a caching output stream

Author: gnodet

src/main/java/org/sonatype/plexus/build/incremental/CachingOutputStream.java

@@ -0,0 +1,151 @@
+package org.sonatype.plexus.build.incremental;
+
+/*
+ * Copyright The Codehaus Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+
+/**
+ * Caching OutputStream to avoid overwriting a file with
+ * the same content.
+ */
+class CachingOutputStream extends OutputStream {
+    private final Path path;
+    private FileChannel channel;
+    private ByteBuffer readBuffer;
+    private ByteBuffer writeBuffer;
+    private boolean modified;
+
+    public CachingOutputStream(File path) throws IOException {
+        this(requireNonNull(path).toPath());
+    }
+
+    public CachingOutputStream(Path path) throws IOException {
+        this(path, 32 * 1024);
+    }
+
+    public CachingOutputStream(Path path, int bufferSize) throws IOException {
+        this.path = requireNonNull(path);
+        this.channel =
+                FileChannel.open(path, StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
+        this.readBuffer = ByteBuffer.allocate(bufferSize);
+        this.writeBuffer = ByteBuffer.allocate(bufferSize);
+    }
+
+    @Override
+    public void write(int b) throws IOException {
+        if (writeBuffer.remaining() < 1) {
+            ((Buffer) writeBuffer).flip();
+            flushBuffer(writeBuffer);
+            ((Buffer) writeBuffer).clear();
+        }
+        writeBuffer.put((byte) b);
+    }
+
+    @Override
+    public void write(byte[] b) throws IOException {
+        write(b, 0, b.length);
+    }
+
+    @Override
+    public void write(byte[] b, int off, int len) throws IOException {
+        if (writeBuffer.remaining() < len) {
+            ((Buffer) writeBuffer).flip();
+            flushBuffer(writeBuffer);
+            ((Buffer) writeBuffer).clear();
+        }
+        int capacity = writeBuffer.capacity();
+        while (len >= capacity) {
+            flushBuffer(ByteBuffer.wrap(b, off, capacity));
+            off += capacity;
+            len -= capacity;
+        }
+        if (len > 0) {
+            writeBuffer.put(b, off, len);
+        }
+    }
+
+    @Override
+    public void flush() throws IOException {
+        ((Buffer) writeBuffer).flip();
+        flushBuffer(writeBuffer);
+        ((Buffer) writeBuffer).clear();
+        super.flush();
+    }
+
+    private void flushBuffer(ByteBuffer writeBuffer) throws IOException {
+        if (modified) {
+            channel.write(writeBuffer);
+        } else {
+            int len = writeBuffer.remaining();
+            ByteBuffer readBuffer;
+            if (this.readBuffer.capacity() >= len) {
+                readBuffer = this.readBuffer;
+                ((Buffer) readBuffer).clear();
+                readBuffer.limit(len);
+            } else {
+                readBuffer = ByteBuffer.allocate(len);
+            }
+            while (len > 0) {
+                int read = channel.read(readBuffer);
+                if (read <= 0) {
+                    modified = true;
+                    channel.position(channel.position() - readBuffer.position());
+                    channel.write(writeBuffer);
+                    return;
+                }
+                len -= read;
+            }
+            ((Buffer) readBuffer).flip();
+            if (readBuffer.compareTo(writeBuffer) != 0) {
+                modified = true;
+                channel.position(channel.position() - readBuffer.remaining());
+                channel.write(writeBuffer);
+            }
+        }
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (channel.isOpen()) {
+            flush();
+            long position = channel.position();
+            if (position != channel.size()) {
+                modified = true;
+                channel.truncate(position);
+            }
+            channel.close();
+        }
+    }
+
+    public boolean isModified() {
+        return modified;
+    }
+
+    private static <T> T requireNonNull(T t) {
+        if (t == null) {
+            throw new NullPointerException();
+        }
+        return t;
+    }
+}

src/main/java/org/sonatype/plexus/build/incremental/DefaultBuildContext.java

@@ -51,7 +51,7 @@ public boolean hasDelta(List relpaths) {
   }
 
   public OutputStream newFileOutputStream(File file) throws IOException {
-    return new FileOutputStream(file);
+    return new CachingOutputStream(file);
   }
 
   public Scanner newScanner(File basedir) {