    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017package org.apache.commons.io.input;
    018
    019import static org.apache.commons.io.IOUtils.CR;
    020import static org.apache.commons.io.IOUtils.EOF;
    021import static org.apache.commons.io.IOUtils.LF;
    022
    023import java.io.IOException;
    024import java.io.InputStream;
    025
    026/**
    027 * A filtering input stream that ensures the content will have Windows line endings, CRLF.
    028 *
    029 * @since 2.5
    030 */
    031public class WindowsLineEndingInputStream  extends InputStream {
    032
    033    private boolean atEos;
    034
    035    private boolean atSlashCr;
    036
    037    private boolean atSlashLf;
    038
    039    private final InputStream in;
    040
    041    private boolean injectSlashLf;
    042
    043    private final boolean lineFeedAtEndOfFile;
    044
    045    /**
    046     * Constructs an input stream that filters another stream
    047     *
    048     * @param in                        The input stream to wrap
    049     * @param ensureLineFeedAtEndOfFile true to ensure that the file ends with CRLF
    050     */
    051    public WindowsLineEndingInputStream(final InputStream in, final boolean ensureLineFeedAtEndOfFile) {
    052        this.in = in;
    053        this.lineFeedAtEndOfFile = ensureLineFeedAtEndOfFile;
    054    }
    055
    056    /**
    057     * Closes the stream. Also closes the underlying stream.
    058     *
    059     * @throws IOException upon error
    060     */
    061    @Override
    062    public void close() throws IOException {
    063        super.close();
    064        in.close();
    065    }
    066
    067    /**
    068     * Handles the end of stream condition.
    069     *
    070     * @return The next char to output to the stream
    071     */
    072    private int handleEos() {
    073        if (!lineFeedAtEndOfFile) {
    074            return EOF;
    075        }
    076        if (!atSlashLf && !atSlashCr) {
    077            atSlashCr = true;
    078            return CR;
    079        }
    080        if (!atSlashLf) {
    081            atSlashCr = false;
    082            atSlashLf = true;
    083            return LF;
    084        }
    085        return EOF;
    086    }
    087
    088    /**
    089     * {@inheritDoc}
    090     */
    091    @Override
    092    public synchronized void mark(final int readLimit) {
    093        throw UnsupportedOperationExceptions.mark();
    094    }
    095
    096    /**
    097     * {@inheritDoc}
    098     */
    099    @Override
    100    public int read() throws IOException {
    101        if (atEos) {
    102            return handleEos();
    103        }
    104        if (injectSlashLf) {
    105            injectSlashLf = false;
    106            return LF;
    107        }
    108        final boolean prevWasSlashR = atSlashCr;
    109        final int target = readWithUpdate();
    110        if (atEos) {
    111            return handleEos();
    112        }
    113        if (target == LF && !prevWasSlashR) {
    114            injectSlashLf = true;
    115            return CR;
    116        }
    117        return target;
    118    }
    119
    120    /**
    121     * Reads the next item from the target, updating internal flags in the process
    122     * @return the next int read from the target stream
    123     * @throws IOException upon error
    124     */
    125    private int readWithUpdate() throws IOException {
    126        final int target = this.in.read();
    127        atEos = target == EOF;
    128        if (atEos) {
    129            return target;
    130        }
    131        atSlashCr = target == CR;
    132        atSlashLf = target == LF;
    133        return target;
    134    }
    135}