Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2014 Red Hat, Inc., and individual contributors
   * as indicated by the @author tags.
   *
   * 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.
  */
 
 package org.jboss.marshalling;
 
A simple base implementation of java.io.DataOutput which wraps a org.jboss.marshalling.ByteOutput. This implementation maintains an internal buffer.
 
 public class SimpleDataOutput extends ByteOutputStream implements DataOutput {

    
The size of the internal buffer.
 
     protected final int bufferSize;
    
The internal buffer.
 
     protected byte[] buffer;
    
The position in the buffer.
 
     private int position;

    
Construct a new instance.

Parameters:
bufferSize the buffer size
 
     public SimpleDataOutput(final int bufferSize) {
         this(bufferSizenull);
     }

    
Construct a new instance.

Parameters:
bufferSize the buffer size
byteOutput the byte output to wrap
 
     public SimpleDataOutput(final int bufferSizefinal ByteOutput byteOutput) {
         super(byteOutput);
         this. = byteOutput;
         this. = bufferSize;
          = new byte[bufferSize];
     }

    
Construct a new instance with a default buffer size.

Parameters:
byteOutput the byte output to wrap
 
     public SimpleDataOutput(final ByteOutput byteOutput) {
         this(8192, byteOutput);
     }
 
     private static NotActiveException notActiveException() {
         return new NotActiveException("Output not started");
     }

    
 
     public void write(final int vthrows IOException {
         try {
             final byte[] buffer = this.;
             final int position = this.;
             if (position == buffer.length) {
                 flush();
                 buffer[0] = (bytev;
                 this. = 1;
             } else {
                 buffer[position] = (bytev;
                 this. = position + 1;
             }
         } catch (NullPointerException e) {
             throw notActiveException();
         }
     }

    
 
     public void write(final byte[] bytesthrows IOException {
         write(bytes, 0, bytes.length);
    }

    
    public void write(final byte[] bytesfinal int offint lenthrows IOException {
        final int bl = .;
        final int position = this.;
        if (len > bl - position || len > bl >> 3) {
            flush();
            .write(bytesofflen);
        } else {
            System.arraycopy(bytesoffpositionlen);
            this. = position + len;
        }
    }

    
    public void writeBoolean(final boolean vthrows IOException {
        try {
            final byte[] buffer = this.;
            final int remaining = buffer.length - ;
            if (remaining == 0) {
                flush();
                buffer[0] = (byte) (v ? 1 : 0);
                 = 1;
            } else {
                buffer[++] = (byte) (v ? 1 : 0);
            }
        } catch (NullPointerException e) {
            throw notActiveException();
        }
    }

    
    public void writeByte(final int vthrows IOException {
        try {
            final byte[] buffer = this.;
            final int remaining = buffer.length - ;
            if (remaining == 0) {
                flush();
                buffer[0] = (bytev;
                 = 1;
            } else {
                buffer[++] = (bytev;
            }
        } catch (NullPointerException e) {
            throw notActiveException();
        }
    }

    
    public void writeShort(final int vthrows IOException {
        try {
            final byte[] buffer = this.;
            final int remaining = buffer.length - ;
            if (remaining < 2) {
                flush();
                buffer[0] = (byte) (v >> 8);
                buffer[1] = (bytev;
                 = 2;
            } else {
                final int s = ;
                 = s + 2;
                buffer[s]   = (byte) (v >> 8);
                buffer[s+1] = (bytev;
            }
        } catch (NullPointerException e) {
            throw notActiveException();
        }
    }

    
    public void writeChar(final int vthrows IOException {
        try {
            final byte[] buffer = this.;
            final int remaining = buffer.length - ;
            if (remaining < 2) {
                flush();
                buffer[0] = (byte) (v >> 8);
                buffer[1] = (bytev;
                 = 2;
            } else {
                final int s = ;
                 = s + 2;
                buffer[s]   = (byte) (v >> 8);
                buffer[s+1] = (bytev;
            }
        } catch (NullPointerException e) {
            throw notActiveException();
        }
    }

    
    public void writeInt(final int vthrows IOException {
        try {
            final byte[] buffer = this.;
            final int remaining = buffer.length - ;
            if (remaining < 4) {
                flush();
                buffer[0] = (byte) (v >> 24);
                buffer[1] = (byte) (v >> 16);
                buffer[2] = (byte) (v >> 8);
                buffer[3] = (bytev;
                 = 4;
            } else {
                final int s = ;
                 = s + 4;
                buffer[s]   = (byte) (v >> 24);
                buffer[s+1] = (byte) (v >> 16);
                buffer[s+2] = (byte) (v >> 8);
                buffer[s+3] = (bytev;
            }
        } catch (NullPointerException e) {
            throw notActiveException();
        }
    }

    
    public void writeLong(final long vthrows IOException {
        try {
            final byte[] buffer = this.;
            final int remaining = buffer.length - ;
            if (remaining < 8) {
                flush();
                buffer[0] = (byte) (v >> 56L);
                buffer[1] = (byte) (v >> 48L);
                buffer[2] = (byte) (v >> 40L);
                buffer[3] = (byte) (v >> 32L);
                buffer[4] = (byte) (v >> 24L);
                buffer[5] = (byte) (v >> 16L);
                buffer[6] = (byte) (v >> 8L);
                buffer[7] = (bytev;
                 = 8;
            } else {
                final int s = ;
                 = s + 8;
                buffer[s]   = (byte) (v >> 56L);
                buffer[s+1] = (byte) (v >> 48L);
                buffer[s+2] = (byte) (v >> 40L);
                buffer[s+3] = (byte) (v >> 32L);
                buffer[s+4] = (byte) (v >> 24L);
                buffer[s+5] = (byte) (v >> 16L);
                buffer[s+6] = (byte) (v >> 8L);
                buffer[s+7] = (bytev;
            }
        } catch (NullPointerException e) {
            throw notActiveException();
        }
    }

    
    public void writeFloat(final float vthrows IOException {
        final int bits = Float.floatToIntBits(v);
        try {
            final byte[] buffer = this.;
            final int remaining = buffer.length - ;
            if (remaining < 4) {
                flush();
                buffer[0] = (byte) (bits >> 24);
                buffer[1] = (byte) (bits >> 16);
                buffer[2] = (byte) (bits >> 8);
                buffer[3] = (bytebits;
                 = 4;
            } else {
                final int s = ;
                 = s + 4;
                buffer[s]   = (byte) (bits >> 24);
                buffer[s+1] = (byte) (bits >> 16);
                buffer[s+2] = (byte) (bits >> 8);
                buffer[s+3] = (bytebits;
            }
        } catch (NullPointerException e) {
            throw notActiveException();
        }
    }

    
    public void writeDouble(final double vthrows IOException {
        final long bits = Double.doubleToLongBits(v);
        try {
            final int remaining = . - ;
            if (remaining < 8) {
                flush();
                [0] = (byte) (bits >> 56L);
                [1] = (byte) (bits >> 48L);
                [2] = (byte) (bits >> 40L);
                [3] = (byte) (bits >> 32L);
                [4] = (byte) (bits >> 24L);
                [5] = (byte) (bits >> 16L);
                [6] = (byte) (bits >> 8L);
                [7] = (bytebits;
                 = 8;
            } else {
                final int s = ;
                 = s + 8;
                [s]   = (byte) (bits >> 56L);
                [s+1] = (byte) (bits >> 48L);
                [s+2] = (byte) (bits >> 40L);
                [s+3] = (byte) (bits >> 32L);
                [s+4] = (byte) (bits >> 24L);
                [s+5] = (byte) (bits >> 16L);
                [s+6] = (byte) (bits >> 8L);
                [s+7] = (bytebits;
            }
        } catch (NullPointerException e) {
            throw notActiveException();
        }
    }

    
    public void writeBytes(final String sthrows IOException {
        final int len = s.length();
        for (int i = 0; i < leni ++) {
            write(s.charAt(i));
        }
    }

    
    public void writeChars(final String sthrows IOException {
        final int len = s.length();
        for (int i = 0; i < leni ++) {
            writeChar(s.charAt(i));
        }
    }

    
    public void writeUTF(final String sthrows IOException {
        writeShort(UTFUtils.getShortUTFLength(s));
        UTFUtils.writeUTFBytes(thiss);
    }

    
    public void flush() throws IOException {
        final int pos = ;
        final ByteOutput byteOutput = this.;
        if (byteOutput != null) {
            if (pos > 0) {
                byteOutput.write(, 0, pos);
            }
             = 0;
            byteOutput.flush();
        }
    }

    
This shallow flush will write the internal buffer out to the ByteOutput, but will not flush it.

Throws:
java.io.IOException if an I/O error occurs
    protected void shallowFlush() throws IOException {
        final int pos = ;
        final ByteOutput byteOutput = this.;
        if (byteOutput != null) {
            if (pos > 0) {
                byteOutput.write(, 0, pos);
            }
             = 0;
        }
    }

    
Begin writing to a stream.

Parameters:
byteOutput the new stream
Throws:
java.io.IOException if an error occurs
    protected void start(ByteOutput byteOutputthrows IOException {
        this. = byteOutput;
         = new byte[];
    }

    
Finish writing to a stream. The stream is released. No further writing may be done until the start(org.jboss.marshalling.ByteOutput) method is again invoked.

Throws:
java.io.IOException if an error occurs
    protected void finish() throws IOException {
        try {
            flush();
        } finally {
             = null;
             = null;
        }
    }

    
    public void close() throws IOException {
        flush();
        .close();
    }
New to GrepCode? Check out our FAQ X