Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.util.io;
  
 import org.jruby.Ruby;
Wrapper around Stream that packs and unpacks LF <=> CRLF.

Author(s):
nicksieger
 
 public class CRLFStreamWrapper implements Stream {
     private final Stream stream;
     private boolean binmode = false;
     private static final int CR = 13;
     private static final int LF = 10;
 
     public CRLFStreamWrapper(Stream stream) {
         this. = stream;
     }
 
     public ChannelDescriptor getDescriptor() {
         return .getDescriptor();
     }
 
     public void clearerr() {
         .clearerr();
     }
 
     public ModeFlags getModes() {
         return .getModes();
     }
 
     public boolean isSync() {
         return .isSync();
     }
 
     public void setSync(boolean sync) {
         .setSync(sync);
     }
 
     public void setBinmode() {
          = true;
         .setBinmode();
     }
 
     public boolean isBinmode() {
         return ;
     }
 
     public boolean isAutoclose() {
         return .isAutoclose();
     }
 
     public void setAutoclose(boolean autoclose) {
         .setAutoclose(autoclose);
     }
 
     public ByteList fgets(ByteList separatorStringthrows IOExceptionBadDescriptorExceptionEOFException {
         return convertCRLFToLF(.fgets(separatorString));
     }
 
         return convertCRLFToLF(.readall());
     }
 
     public int getline(ByteList dstbyte terminatorthrows IOExceptionBadDescriptorException {
         if () {
             return .getline(dstterminator);
         }
 
         ByteList intermediate = new ByteList();
         int result = .getline(intermediateterminator);
         convertCRLFToLF(intermediatedst);
         return result;
     }
 
     public int getline(ByteList dstbyte terminatorlong limitthrows IOExceptionBadDescriptorException {
         if () {
             return .getline(dstterminatorlimit);
         }
 
         ByteList intermediate = new ByteList();
         int result = .getline(intermediateterminatorlimit);
         convertCRLFToLF(intermediatedst);
         return result;
     }
 
     public ByteList fread(int numberthrows IOExceptionBadDescriptorExceptionEOFException {
         if (number == 0) {
             if (.feof()) {
                 return null;
             } else {
                return new ByteList(0);
            }
        }
        boolean eof = false;
        ByteList bl = new ByteList(number > . ? . : number);
        for (int i = 0; i < numberi++) {
            int c = fgetc();
            if (c == -1) {
                eof = true;
                break;
            }
            bl.append(c);
        }
        if (eof && bl.length() == 0) {
            return null;
        }
        return bl;
    }
    public int fwrite(ByteList stringthrows IOExceptionBadDescriptorException {
        return .fwrite(convertLFToCRLF(string));
    }
    public int fgetc() throws IOExceptionBadDescriptorExceptionEOFException {
        int c = .fgetc();
        if (! && c == ) {
            c = .fgetc();
            if (c != ) {
                .ungetc(c);
                return ;
            }
        }
        return c;
    }
    public int ungetc(int c) {
        return .ungetc(c);
    }
    public void fputc(int cthrows IOExceptionBadDescriptorException {
        if (! && c == ) {
            .fputc();
        }
        .fputc(c);
    }
    public ByteList read(int numberthrows IOExceptionBadDescriptorExceptionEOFException {
        return convertCRLFToLF(.read(number));
    }
    public void fclose() throws IOExceptionBadDescriptorException {
        .fclose();
    }
    public int fflush() throws IOExceptionBadDescriptorException {
        return .fflush();
    }
    public void sync() throws IOExceptionBadDescriptorException {
        .sync();
    }
    public boolean feof() throws IOExceptionBadDescriptorException {
        return .feof();
    }
        return .fgetpos();
    }
    public void lseek(long offsetint typethrows IOExceptionInvalidValueExceptionPipeExceptionBadDescriptorException {
        .lseek(offsettype);
    }
    public void ftruncate(long newLengththrows IOExceptionPipeExceptionInvalidValueExceptionBadDescriptorException {
        .ftruncate(newLength);
    }
    public int ready() throws IOException {
        return .ready();
    }
    public void waitUntilReady() throws IOExceptionInterruptedException {
        .waitUntilReady();
    }
    public boolean readDataBuffered() {
        return .readDataBuffered();
    }
    public boolean writeDataBuffered() {
        return .writeDataBuffered();
    }
    public InputStream newInputStream() {
        return .newInputStream();
    }
    public OutputStream newOutputStream() {
        return .newOutputStream();
    }
    public boolean isBlocking() {
        return .isBlocking();
    }
    public void setBlocking(boolean blockingthrows IOException {
        .setBlocking(blocking);
    }
        .freopen(runtimepathmodes);
    }
    private ByteList convertCRLFToLF(ByteList input) {
        if (input == null || return input;        
        ByteList result = new ByteList();
        convertCRLFToLF(inputresult);
        return result;
    }
    // FIXME: Horrific hack until we properly setup transcoding support of cr/lf logic in 1.9 proper.  This class
    // is going away in 9k and the LE/BE logic is never used by 1.8 support.
    
    // I could not find any way in MRI to exercise this logic....endless needs
    // binmode set (which obviously would not work here).  Leaving it for now
    // since I will likely be either doubling down on new knowledge for 1.7.2
    // or ripping all this out when we have real transcoding logic ported
    // properly
//    private int skipCROfLF(ByteList src, int i, int c) {
//        Encoding encoding = src.getEncoding();
//        int length = src.length();
//        
//        if (encoding == UTF16BEEncoding.INSTANCE) {
//            if (i + 3 < length && c == 0 && src.get(i + 1) == CR && 
//                    src.get(i + 2) == 0 && src.get(i + 3) == LF) {
//                return i + 1;
//            }
//        } else if (encoding == UTF16LEEncoding.INSTANCE) {
//            if (i + 3 < length && c == CR && src.get(i + 1) == 0 && 
//                    src.get(i + 2) == LF && src.get(i + 3) == 0) {
//                return i + 1;
//            }            
//        } else if (c == CR && i + 1 < length && src.get(i + 1) == LF) {
//            return i;
//        }
//        
//        return -1;
//    }
//    
//    private void convertCRLFToLF(ByteList src, ByteList dst) {
//        for (int i = 0; i < src.length(); i++) {
//            int b = src.get(i);
//            int j = skipCROfLF(src, i, b);
//            if (j != -1) i = j;
//
//            dst.append(b);
//        }
//    }
    
    
    private void convertCRLFToLF(ByteList srcByteList dst) {
        for (int i = 0; i < src.length(); i++) {
            int b = src.get(i);
            if (b ==  && i + 1 < src.length() && src.get(i + 1) == ) {
                continue;
            }
            dst.append(b);
        }
    }
    final byte[] CRBYTES = new byte[] {  };
    final byte[] CRLEBYTES = new byte[] { , 0};
    final byte[] CRBEBYTES = new byte[] { 0,  };
    
    private byte[] crBytes(Encoding encoding) {
        if (encoding == .return ;
        if (encoding == .return ;
            
        return ;
    }
    
    final byte[] LFBYTES = new byte[] {  };
    final byte[] LFLEBYTES = new byte[] { , 0 };
    final byte[] LFBEBYTES = new byte[] { 0,  };    
    private byte[] lfBytes(Encoding encoding) {
        if (encoding == .return ;
        if (encoding == .return ;
            
        return ;
    }
    
    private ByteList convertLFToCRLF(ByteList input) {
        if (input == null || return input;
        byte[] crBytes = crBytes(input.getEncoding());
        byte[] lfBytes = lfBytes(input.getEncoding());
        ByteList result = new ByteList();
        int length = input.lengthEnc();
        for (int i = 0; i < lengthi++) {
            int b = input.getEnc(i);
            if (b == ) {
                result.append(crBytes);
                result.append(lfBytes);
            } else {
                result.append(b);
            }
        }
        return result;
    }
    public Channel getChannel() {
        return .getChannel();
    }
New to GrepCode? Check out our FAQ X