delegatebuffer.java

银行项目为后台ｓｏｃｋｅｔ通信写的程序

/****************************************************************************
 * Package		: com.ecSolutions.ecAppServer.server.buffer
 * File			: DelegateBuffer.java
 * Create Date  : 2007-7-20
 * Author		: Steven Chen
 * 
 * Copyright(C) 2006 ecSolutions(shanghai) Co.,Limited.All Rights Reserved.
 *			
 ***************************************************************************/
package com.ecSolutions.ecAppServer.server.buffer;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;

import com.ecSolutions.ecAppServer.server.Buffer;
import com.ecSolutions.ecAppServer.server.util.Charset;

/**
 * Delegate buffer.
 * 
 * @author Steven Chen
 * @version $Id: DelegateBuffer.java,v 1.2 2007/07/26 03:14:22 stevenchen Exp $
 */
public class DelegateBuffer implements Buffer {

    /**
     * Delegate buffer.
     */
    protected final Buffer delegate;

    public DelegateBuffer(Buffer delegate) {
        this.delegate = delegate;
    }

    public Buffer getDelegate() {
        return delegate;
    }

    public ByteBuffer asByteBuffer() {
        return delegate.asByteBuffer();
    }

    public Buffer asReadOnlyBuffer() {
        return delegate.asReadOnlyBuffer();
    }

    public int capacity() {
        return delegate.capacity();
    }

    public Buffer clear() {
        return delegate.clear();
    }

    public Buffer compact() {
        return delegate.compact();
    }

    public String dump() {
        return delegate.dump();
    }

    public Buffer duplicate() {
        return delegate.duplicate();
    }

    public Buffer flip() {
        return delegate.flip();
    }

    public byte get() {
        return delegate.get();
    }

    public Buffer get(Buffer dst, int length) {
        return delegate.get(dst, length);
    }

    public Buffer get(Buffer dst) {
        return delegate.get(dst);
    }

    public Buffer get(byte[] dst, int offset, int length) {
        return delegate.get(dst, offset, length);
    }

    public Buffer get(byte[] dst) {
        return delegate.get(dst);
    }

    public Buffer get(ByteBuffer dst, int length) {
        return delegate.get(dst, length);
    }

    public Buffer get(ByteBuffer dst) {
        return delegate.get(dst);
    }

    public Buffer get(int index, Buffer dst, int length) {
        return delegate.get(index, dst, length);
    }

    public Buffer get(int index, Buffer dst) {
        return delegate.get(index, dst);
    }

    public Buffer get(int index, byte[] dst, int offset, int length) {
        return delegate.get(index, dst, offset, length);
    }

    public Buffer get(int index, byte[] dst) {
        return delegate.get(index, dst);
    }

    public Buffer get(int index, ByteBuffer dst, int length) {
        return delegate.get(index, dst, length);
    }

    public Buffer get(int index, ByteBuffer dst) {
        return delegate.get(index, dst);
    }

    public byte get(int index) {
        return delegate.get(index);
    }

    public char getChar() {
        return delegate.getChar();
    }

    public char getChar(int index) {
        return delegate.getChar(index);
    }

    public double getDouble() {
        return delegate.getDouble();
    }

    public double getDouble(int index) {
        return delegate.getDouble(index);
    }

    public float getFloat() {
        return delegate.getFloat();
    }

    public float getFloat(int index) {
        return delegate.getFloat(index);
    }

    public int getInt() {
        return delegate.getInt();
    }

    public int getInt(int index) {
        return delegate.getInt(index);
    }

    public long getLong() {
        return delegate.getLong();
    }

    public long getLong(int index) {
        return delegate.getLong(index);
    }

    public short getShort() {
        return delegate.getShort();
    }

    public short getShort(int index) {
        return delegate.getShort(index);
    }

    public String getString(Charset charset, int bufferLen) {
        return delegate.getString(charset, bufferLen);
    }

    public String getString(int index, Charset charset, int bufferLen) {
        return delegate.getString(index, charset, bufferLen);
    }

    public short getUnsignedByte() {
        return delegate.getUnsignedByte();
    }

    public short getUnsignedByte(int index) {
        return delegate.getUnsignedByte(index);
    }

    public long getUnsignedInt() {
        return delegate.getUnsignedInt();
    }

    public long getUnsignedInt(int index) {
        return delegate.getUnsignedInt(index);
    }

    public int getUnsignedShort() {
        return delegate.getUnsignedShort();
    }

    public int getUnsignedShort(int index) {
        return delegate.getUnsignedShort(index);
    }

    public boolean hasRemaining() {
        return delegate.hasRemaining();
    }

    public int indexOf(byte[] b) {
        return delegate.indexOf(b);
    }

    public boolean isBigEndian() {
        return delegate.isBigEndian();
    }

    public boolean isDirect() {
        return delegate.isDirect();
    }

    public boolean isPermanent() {
        return delegate.isPermanent();
    }

    public boolean isReadonly() {
        return delegate.isReadonly();
    }

    public boolean isReleased() {
        return delegate.isReleased();
    }

    public int limit() {
        return delegate.limit();
    }

    public Buffer limit(int limit) {
        return delegate.limit(limit);
    }

    public Buffer mark() {
        return delegate.mark();
    }

    public int position() {
        return delegate.position();
    }

    public Buffer position(int position) {
        return delegate.position(position);
    }

    public Buffer put(Buffer src, int length) {
        return delegate.put(src, length);
    }

    public Buffer put(Buffer src) {
        return delegate.put(src);
    }

    public Buffer put(byte b) {
        return delegate.put(b);
    }

    public Buffer put(byte[] src, int offset, int length) {
        return delegate.put(src, offset, length);
    }

    public Buffer put(byte[] src) {
        return delegate.put(src);
    }

    public Buffer put(ByteBuffer src, int length) {
        return delegate.put(src, length);
    }

    public Buffer put(ByteBuffer src) {
        return delegate.put(src);
    }

    public Buffer put(int index, Buffer src, int length) {
        return delegate.put(index, src, length);
    }

    public Buffer put(int index, Buffer src) {
        return delegate.put(index, src);
    }

    public Buffer put(int index, byte b) {
        return delegate.put(index, b);
    }

    public Buffer put(int index, byte[] src, int offset, int length) {
        return delegate.put(index, src, offset, length);
    }

    public Buffer put(int index, byte[] src) {
        return delegate.put(index, src);
    }

    public Buffer put(int index, ByteBuffer src, int length) {
        return delegate.put(index, src, length);
    }

    public Buffer put(int index, ByteBuffer src) {
        return delegate.put(index, src);
    }

    public Buffer putChar(char c) {
        return delegate.putChar(c);
    }

    public Buffer putChar(int index, char c) {
        return delegate.putChar(index, c);
    }

    public Buffer putDouble(double d) {
        return delegate.putDouble(d);
    }

    public Buffer putDouble(int index, double d) {
        return delegate.putDouble(index, d);
    }

    public Buffer putFloat(float f) {
        return delegate.putFloat(f);
    }

    public Buffer putFloat(int index, float f) {
        return delegate.putFloat(index, f);
    }

    public Buffer putInt(int index, int i) {
        return delegate.putInt(index, i);
    }

    public Buffer putInt(int i) {
        return delegate.putInt(i);
    }

    public Buffer putLong(int index, long l) {
        return delegate.putLong(index, l);
    }

    public Buffer putLong(long l) {
        return delegate.putLong(l);
    }

    public Buffer putShort(int index, short s) {
        return delegate.putShort(index, s);
    }

    public Buffer putShort(short s) {
        return delegate.putShort(s);
    }

    public Buffer putString(int index, String s, Charset charset) {
        return delegate.putString(index, s, charset);
    }

    public Buffer putString(String s, Charset charset) {
        return delegate.putString(s, charset);
    }

    public Buffer putUnsignedByte(int index, short s) {
        return delegate.putUnsignedByte(index, s);
    }

    public Buffer putUnsignedByte(short s) {
        return delegate.putUnsignedByte(s);
    }

    public Buffer putUnsignedInt(int index, long l) {
        return delegate.putUnsignedInt(index, l);
    }

    public Buffer putUnsignedInt(long l) {
        return delegate.putUnsignedInt(l);
    }

    public Buffer putUnsignedShort(int index, int i) {
        return delegate.putUnsignedShort(index, i);
    }

    public Buffer putUnsignedShort(int i) {
        return delegate.putUnsignedShort(i);
    }

    public int read(ReadableByteChannel channel) throws IOException {
        return delegate.read(channel);
    }

    public void release() {
        delegate.release();
    }

    public int remaining() {
        return delegate.remaining();
    }

    public Buffer reset() {
        return delegate.reset();
    }

    public Buffer rewind() {
        return delegate.rewind();
    }

    public Buffer setBigEndian(boolean b) {
        return delegate.setBigEndian(b);
    }

    public void setPermanent(boolean b) {
        delegate.setPermanent(b);
    }

    public Buffer skip(int size) {
        return delegate.skip(size);
    }

    public Buffer slice() {
        return delegate.slice();
    }

    public int write(WritableByteChannel channel) throws IOException {
        return delegate.write(channel);
    }

}