public CDRInputStream() 
{

}

 public CDRInputStream(CDRInputStream is) 
{
        impl = is.impl.dup();
        impl.setParent(this);
}

 public CDRInputStream(ORB orb,
    ByteBuffer byteBuffer,
    int size,
    boolean littleEndian,
    GIOPVersion version,
    byte encodingVersion,
    BufferManagerRead bufMgr) 
{
        impl = InputStreamFactory.newInputStream((ORB)orb, version,
                                                 encodingVersion);
        impl.init(orb, byteBuffer, size, littleEndian, bufMgr);
        impl.setParent(this);
}

 public final String[] _truncatable_ids() 
{
        return impl._truncatable_ids();
}

 public  void alignOnBoundary(int octetBoundary) 
{
        impl.alignOnBoundary(octetBoundary);
}

Aligns the current position on the given octet boundary if there are enough bytes available to do so. Otherwise, it just returns. This is used for some (but not all) GIOP 1.2 message headers.

 public final int available() throws IOException 
{
        return impl.available();
}

 public final  void close() throws IOException 
{
        impl.close();
}

 public final  void consumeEndian() 
{
        impl.consumeEndian();
}

 protected CodeSetConversion.BTCConverter createCharBTCConverter() 
{
        return CodeSetConversion.impl().getBTCConverter(OSFCodeSetRegistry.ISO_8859_1,
                                                        impl.isLittleEndian());
}

 abstract protected CodeSetConversion.BTCConverter createWCharBTCConverter()

 abstract public CDRInputStream dup()

 public  void end_value() 
{
        impl.end_value();
}

 public final int getBufferLength() 
{
        return impl.getBufferLength();
}

 public final BufferManagerRead getBufferManager() 
{
        return impl.getBufferManager();
}

 protected final ByteBuffer getByteBuffer() 
{
        return impl.getByteBuffer();
}

 public CodeBase getCodeBase() 
{
        return null;
}

 public final GIOPVersion getGIOPVersion() 
{
        return impl.getGIOPVersion();
}

 protected final int getIndex() 
{
        return impl.getIndex();
}

 public MessageMediator getMessageMediator() 
{
        return messageMediator;
}

 public final int getPosition() 
{
        return impl.getPosition();
}

 public final boolean isLittleEndian() 
{
        return impl.isLittleEndian();
}

 public final  void mark(int readlimit) 
{
        impl.mark(readlimit);
}

 public final boolean markSupported() 
{
        return impl.markSupported();
}

 public final ORB orb() 
{
        return impl.orb();
}

 public final  void orb(ORB orb) 
{
        impl.orb(orb);
}

 public  void performORBVersionSpecificInit() 
{
        // In the case of SystemExceptions, a stream is created
        // with its default constructor (and thus no impl is set).
        if (impl != null)
            impl.performORBVersionSpecificInit();
}

This must be called after determining the proper ORB version, and setting it on the stream's ORB instance. It can be called after reading the service contexts, since that is the only place we can get the ORB version info. Trying to unmarshal things requiring repository IDs before calling this will result in NullPtrExceptions.

  void printBuffer() 
{
        impl.printBuffer();
}

 public final int read() throws IOException 
{
        return impl.read();
}

 public final int read(byte[] b) throws IOException 
{
        return impl.read(b);
}

 public final int read(byte[] b,
    int off,
    int len) throws IOException 
{
        return impl.read(b, off, len);
}

 public final Object read_Abstract() 
{
        return impl.read_Abstract();
}

 public final Context read_Context() 
{
        return impl.read_Context();
}

 public final Object read_Object() 
{
        return impl.read_Object();
}

 public final Object read_Object(Class clz) 
{
        return impl.read_Object(clz);
}

 public final Principal read_Principal() 
{
        return impl.read_Principal();
}

 public final TypeCode read_TypeCode() 
{
        return impl.read_TypeCode();
}

 public final Serializable read_Value() 
{
        return impl.read_Value();
}

 public final Object read_abstract_interface() 
{
        return impl.read_abstract_interface();
}

 public final Object read_abstract_interface(Class clz) 
{
        return impl.read_abstract_interface(clz);
}

 public final Any read_any() 
{
        return impl.read_any();
}

 public final  void read_any_array(AnySeqHolder seq,
    int offset,
    int length) 
{
        impl.read_any_array(seq, offset, length);
}

 public final boolean read_boolean() 
{
        return impl.read_boolean();
}

 public final  void read_boolean_array(boolean[] value,
    int offset,
    int length) 
{
        impl.read_boolean_array(value, offset, length);
}

 public final  void read_boolean_array(BooleanSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_boolean_array(seq, offset, length);
}

 public final char read_char() 
{
        return impl.read_char();
}

 public final  void read_char_array(char[] value,
    int offset,
    int length) 
{
        impl.read_char_array(value, offset, length);
}

 public final  void read_char_array(CharSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_char_array(seq, offset, length);
}

 public final double read_double() 
{
        return impl.read_double();
}

 public final  void read_double_array(double[] value,
    int offset,
    int length) 
{
        impl.read_double_array(value, offset, length);
}

 public final  void read_double_array(DoubleSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_double_array(seq, offset, length);
}

 public final BigDecimal read_fixed() 
{
        return impl.read_fixed();
}

 public final BigDecimal read_fixed(short digits,
    short scale) 
{
        return impl.read_fixed(digits, scale);
}

 public final float read_float() 
{
        return impl.read_float();
}

 public final  void read_float_array(float[] value,
    int offset,
    int length) 
{
        impl.read_float_array(value, offset, length);
}

 public final  void read_float_array(FloatSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_float_array(seq, offset, length);
}

 public final int read_long() 
{
        return impl.read_long();
}

 public final  void read_long_array(int[] value,
    int offset,
    int length) 
{
        impl.read_long_array(value, offset, length);
}

 public final  void read_long_array(LongSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_long_array(seq, offset, length);
}

 public final long read_longlong() 
{
        return impl.read_longlong();
}

 public final  void read_longlong_array(long[] value,
    int offset,
    int length) 
{
        impl.read_longlong_array(value, offset, length);
}

 public final  void read_longlong_array(LongLongSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_longlong_array(seq, offset, length);
}

 public final byte read_octet() 
{
        return impl.read_octet();
}

 public final  void read_octet_array(byte[] value,
    int offset,
    int length) 
{
        impl.read_octet_array(value, offset, length);
}

 public final  void read_octet_array(OctetSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_octet_array(seq, offset, length);
}

 public final short read_short() 
{
        return impl.read_short();
}

 public final  void read_short_array(short[] value,
    int offset,
    int length) 
{
        impl.read_short_array(value, offset, length);
}

 public final  void read_short_array(ShortSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_short_array(seq, offset, length);
}

 public final String read_string() 
{
        return impl.read_string();
}

 public final int read_ulong() 
{
        return impl.read_ulong();
}

 public final  void read_ulong_array(int[] value,
    int offset,
    int length) 
{
        impl.read_ulong_array(value, offset, length);
}

 public final  void read_ulong_array(ULongSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_ulong_array(seq, offset, length);
}

 public final long read_ulonglong() 
{
        return impl.read_ulonglong();
}

 public final  void read_ulonglong_array(long[] value,
    int offset,
    int length) 
{
        impl.read_ulonglong_array(value, offset, length);
}

 public final  void read_ulonglong_array(ULongLongSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_ulonglong_array(seq, offset, length);
}

 public final short read_ushort() 
{
        return impl.read_ushort();
}

 public final  void read_ushort_array(short[] value,
    int offset,
    int length) 
{
        impl.read_ushort_array(value, offset, length);
}

 public final  void read_ushort_array(UShortSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_ushort_array(seq, offset, length);
}

 public final Serializable read_value() 
{
        return impl.read_value();
}

 public final Serializable read_value(Class clz) 
{
        return impl.read_value(clz);
}

 public final Serializable read_value(BoxedValueHelper factory) 
{
        return impl.read_value(factory);
}

 public final Serializable read_value(String rep_id) 
{
        return impl.read_value(rep_id);
}

 public final Serializable read_value(Serializable value) 
{
        return impl.read_value(value);
}

 public final char read_wchar() 
{
        return impl.read_wchar();
}

 public final  void read_wchar_array(char[] value,
    int offset,
    int length) 
{
        impl.read_wchar_array(value, offset, length);
}

 public final  void read_wchar_array(WCharSeqHolder seq,
    int offset,
    int length) 
{
        impl.read_wchar_array(seq, offset, length);
}

 public final String read_wstring() 
{
        return impl.read_wstring();
}

 public final  void reset() 
{
        impl.reset();
}

 public  void resetCodeSetConverters() 
{
        impl.resetCodeSetConverters();
}

Resets any internal references to code set converters. This is useful for forcing the CDR stream to reacquire converters (probably from its subclasses) when state has changed.

 protected final  void setBufferLength(int value) 
{
        impl.setBufferLength(value);
}

 protected final  void setByteBuffer(ByteBuffer byteBuffer) 
{
        impl.setByteBuffer(byteBuffer);
}

 protected final  void setByteBufferWithInfo(ByteBufferWithInfo bbwi) 
{
        impl.setByteBufferWithInfo(bbwi);
}

 public  void setHeaderPadding(boolean headerPadding) 
{
        impl.setHeaderPadding(headerPadding);
}

 protected final  void setIndex(int value) 
{
        impl.setIndex(value);
}

 public  void setMessageMediator(MessageMediator messageMediator) 
{
        this.messageMediator = (CorbaMessageMediator) messageMediator;
}

 public final long skip(long n) throws IOException 
{
        return impl.skip(n);
}

 public  void start_value() 
{
        impl.start_value();
}