Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014 JBoss Inc
   *
   * 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 io.apiman.test.common.io;
 
 
A simple io.apiman.gateway.engine.io.IApimanBuffer from a byte array.

Author(s):
eric.wittmann@redhat.com
 
 @SuppressWarnings("nls"// TODO finish the implementation of this class!
 public class ByteBuffer implements IApimanBuffer {
 
     private byte [] buffer;
     private int bytesInBuffer = 0;

    
Constructor.

Parameters:
size initial size
 
     public ByteBuffer(int size) {
          = new byte[size];
     }

    
Constructor.

Parameters:
stringData String data
 
     public ByteBuffer(String stringData) {
          = stringData.getBytes();
          = .;
     }

    
Constructor.

Parameters:
stringData String data
enc String data encoding
 
     public ByteBuffer(String stringDataString enc) {
         try {
              = stringData.getBytes(enc);
         } catch (UnsupportedEncodingException e) {
             throw new RuntimeException(e);
         }
     }

    

Parameters:
byteData the byte data to initialize buffer
 
     public ByteBuffer(byte[] byteData) {
          = Arrays.copyOf(byteDatabyteData.length);
     }

    
 
     @Override
     public Object getNativeBuffer() {
         return ;
     }

    
 
     @Override
     public int length() {
         return ;
     }

    
 
     @Override
     public void insert(int indexIApimanBuffer buffer) {
         throw new RuntimeException("Not yet implemented");
     }

    
    @Override
    public void insert(int indexIApimanBuffer bufferint offsetint length) {
        throw new RuntimeException("Not yet implemented");
    }

    
    @Override
    public void append(IApimanBuffer buffer) {
        throw new RuntimeException("Not yet implemented");
    }

    
    @Override
    public void append(IApimanBuffer bufferint offsetint length) {
        throw new RuntimeException("Not yet implemented");
    }

    
    @Override
    public byte get(int index) {
        return [index];
    }

    
    @Override
    public void set(int indexbyte b) {
        [index] = b;
    }

    
    @Override
    public void append(byte b) {
        byte [] bytes = new byte[1];
        bytes[0] = b;
        append(bytes);
    }

    
    @Override
    public byte[] getBytes() {
        byte [] rval = new byte[];
        System.arraycopy(, 0, rval, 0, );
        return rval;
    }

    
    @Override
    public byte[] getBytes(int startint end) {
        int size = (end - start) - 1;
        byte [] rval = new byte[];
        System.arraycopy(startrval, 0, size);
        return rval;
    }

    
    @Override
    public void insert(int indexbyte[] b) {
        throw new RuntimeException("Not yet implemented");
    }

    
    @Override
    public void insert(int indexbyte[] bint offsetint length) {
        throw new RuntimeException("Not yet implemented");
    }

    
    @Override
    public void append(byte[] bytes) {
        int requiredBytes =  + bytes.length;
        if (requiredBytes > .) {
            byte [] oldbuffer = ;
             = new byte[requiredBytes];
            System.arraycopy(oldbuffer, 0, , 0, );
        }
        System.arraycopy(bytes, 0, bytes.length);
         = requiredBytes;
    }

    
    @Override
    public void append(byte[] bytesint offsetint length) {
        int requiredBytes =  + length;
        if (requiredBytes > .) {
            byte [] oldbuffer = ;
             = new byte[requiredBytes];
            System.arraycopy(oldbuffer, 0, , 0, );
        }
        System.arraycopy(bytesoffsetlength);
         = requiredBytes;
    }

    
    @Override
    public String getString(int startint end) {
        return new String(getBytes(startend));
    }

    
    @Override
    public String getString(int startint endString encoding) {
        try {
            return new String(getBytes(startend), encoding);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }

    
    @Override
    public void insert(int indexString string) {
        throw new RuntimeException("Not yet implemented");
    }

    
    @Override
    public void insert(int indexString stringString encoding) {
        throw new RuntimeException("Not yet implemented");
    }

    
    @Override
    public void append(String string) {
        byte[] bytes = string.getBytes();
        append(bytes);
    }

    
    @Override
    public void append(String stringString encodingthrows UnsupportedEncodingException {
        byte [] bytes = string.getBytes(encoding);
        append(bytes);
    }

    
    @Override
    public String toString(String encoding) {
        try {
            return new String(, 0, encoding);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }

    
    @Override
    public String toString() {
        return new String(, 0, );
    }

    

Returns:
the bytesInBuffer
    public int getBytesInBuffer() {
        return ;
    }

    
Reads from the input stream.

Parameters:
stream the input stream to read from
Returns:
bytes read from buffer
Throws:
java.io.IOException I/O error when reading from buffer
    public int readFrom(InputStream streamthrows IOException {
         = stream.read();
        return ;
    }
New to GrepCode? Check out our FAQ X