/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
*  contributor license agreements.  See the NOTICE file distributed with
*  this work for additional information regarding copyright ownership.
*  The ASF licenses this file to You 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.apache.yoko.orb.CORBA;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.apache.yoko.orb.OCI.GiopVersion;
import org.omg.CORBA.portable.ValueOutputStream;

final public class OutputStream extends org.omg.CORBA_2_3.portable.OutputStream implements ValueOutputStream {
    static final Logger LOGGER = Logger.getLogger(OutputStream.class.getName());

    private org.apache.yoko.orb.OB.ORBInstance orbInstance_; // Java only

    public org.apache.yoko.orb.OCI.Buffer buf_;

    private GiopVersion giopVersion_ = org.apache.yoko.orb.OB.OB_Extras.DEFAULT_GIOP_VERSION;

    private org.apache.yoko.orb.OB.CodeConverters codeConverters_;

    private boolean charWriterRequired_;

    private boolean charConversionRequired_;

    private boolean wCharWriterRequired_;

    private boolean wCharConversionRequired_;

    //
    // Handles all OBV marshalling
    //
    private org.apache.yoko.orb.OB.ValueWriter valueWriter_;

    //
    // If alignNext_ > 0, the next write should be aligned on this
    // boundary
    //
    private int alignNext_;

    private java.lang.Object invocationContext_; // Java only

    private java.lang.Object delegateContext_; // Java only

    // ------------------------------------------------------------------
    // Private and protected functions
    // ------------------------------------------------------------------

    // Write a gap of four bytes (ulong aligned), avoids byte shifts
    private int writeGap() {
        LOGGER.finest("Writing a gap value");
        addCapacity(4, 4);
        int result = buf_.pos_;
        buf_.pos_ += 4;
        return result;
    }

    private void writeLength(int start) {
        int length = buf_.pos_ - (start + 4);
        LOGGER.finest("Writing a length value of " + length + " at offset " + start);

        buf_.data_[start++] = (byte) (length >>> 24);
        buf_.data_[start++] = (byte) (length >>> 16);
        buf_.data_[start++] = (byte) (length >>> 8);
        buf_.data_[start] = (byte) length;
    }

    public void writeTypeCodeImpl(org.omg.CORBA.TypeCode tc,
            java.util.Hashtable history) {
        //
        // Try casting the TypeCode to org.apache.yoko.orb.CORBA.TypeCode. This
        // could
        // fail if the TypeCode was created by a foreign singleton ORB.
        //
        TypeCode obTC = null;
        try {
            obTC = (TypeCode) tc;
        } catch (ClassCastException ex) {
        }

        if (obTC != null) {
            if (obTC.recId_ != null) {
                if (obTC.recType_ == null)
                    throw new org.omg.CORBA.BAD_TYPECODE(
                            org.apache.yoko.orb.OB.MinorCodes
                                    .describeBadTypecode(org.apache.yoko.orb.OB.MinorCodes.MinorIncompleteTypeCode),
                            org.apache.yoko.orb.OB.MinorCodes.MinorIncompleteTypeCode,
                            org.omg.CORBA.CompletionStatus.COMPLETED_NO);
                writeTypeCodeImpl(obTC.recType_, history);
                return;
            }
        }

        LOGGER.finest("Writing a type code of type " + tc.kind().value());

        //
        // For performance reasons, handle the primitive TypeCodes first
        //
        switch (tc.kind().value()) {
        case org.omg.CORBA.TCKind._tk_null:
        case org.omg.CORBA.TCKind._tk_void:
        case org.omg.CORBA.TCKind._tk_short:
        case org.omg.CORBA.TCKind._tk_long:
        case org.omg.CORBA.TCKind._tk_longlong:
        case org.omg.CORBA.TCKind._tk_ushort:
        case org.omg.CORBA.TCKind._tk_ulong:
        case org.omg.CORBA.TCKind._tk_ulonglong:
        case org.omg.CORBA.TCKind._tk_float:
        case org.omg.CORBA.TCKind._tk_double:
        case org.omg.CORBA.TCKind._tk_longdouble:
        case org.omg.CORBA.TCKind._tk_boolean:
        case org.omg.CORBA.TCKind._tk_char:
        case org.omg.CORBA.TCKind._tk_wchar:
        case org.omg.CORBA.TCKind._tk_octet:
        case org.omg.CORBA.TCKind._tk_any:
        case org.omg.CORBA.TCKind._tk_TypeCode:
        case org.omg.CORBA.TCKind._tk_Principal:
            write_ulong(tc.kind().value());
            return;

        default:
            break;
        }

        Integer indirectionPos = (Integer) history.get(tc);
        if (indirectionPos != null) {
            write_long(-1);
            int offs = indirectionPos.intValue() - buf_.pos_;
            LOGGER.finest("Writing an indirect type code for offset " + offs);
            write_long(offs);
        } else {
            write_ulong(tc.kind().value());
            Integer oldPos = new Integer(buf_.pos_ - 4);

            try {
                switch (tc.kind().value()) {
                case org.omg.CORBA.TCKind._tk_fixed: {
                    history.put(tc, oldPos);

                    write_ushort(tc.fixed_digits());
                    write_short(tc.fixed_scale());

                    break;
                }

                case org.omg.CORBA.TCKind._tk_objref: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_struct:
                case org.omg.CORBA.TCKind._tk_except: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    write_ulong(tc.member_count());
                    for (int i = 0; i < tc.member_count(); i++) {
                        write_string(tc.member_name(i));
                        writeTypeCodeImpl(tc.member_type(i), history);
                    }
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_union: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    org.omg.CORBA.TypeCode discType = tc.discriminator_type();
                    writeTypeCodeImpl(discType, history);
                    int defaultIndex = tc.default_index();
                    write_long(defaultIndex);
                    write_ulong(tc.member_count());
                    for (int i = 0; i < tc.member_count(); i++) {
                        //
                        // Check for default label value
                        //
                        if (i == defaultIndex) {
                            //
                            // Marshal a dummy value of the appropriate size
                            // for the discriminator type
                            //
                            org.omg.CORBA.TypeCode origDiscType = TypeCode
                                    ._OB_getOrigType(discType);
                            switch (origDiscType.kind().value()) {
                            case org.omg.CORBA.TCKind._tk_short:
                                write_short((short) 0);
                                break;
                            case org.omg.CORBA.TCKind._tk_ushort:
                                write_ushort((short) 0);
                                break;
                            case org.omg.CORBA.TCKind._tk_long:
                                write_long(0);
                                break;
                            case org.omg.CORBA.TCKind._tk_ulong:
                                write_ulong(0);
                                break;
                            case org.omg.CORBA.TCKind._tk_longlong:
                                write_longlong(0);
                                break;
                            case org.omg.CORBA.TCKind._tk_ulonglong:
                                write_ulonglong(0);
                                break;
                            case org.omg.CORBA.TCKind._tk_boolean:
                                write_boolean(false);
                                break;
                            case org.omg.CORBA.TCKind._tk_char:
                                write_char((char) 0);
                                break;
                            case org.omg.CORBA.TCKind._tk_enum:
                                write_ulong(0);
                                break;
                            default:
                                org.apache.yoko.orb.OB.Assert._OB_assert("Invalid sub-type in tk_union");
                            }
                        } else {
                            tc.member_label(i).write_value(this);
                        }

                        write_string(tc.member_name(i));
                        writeTypeCodeImpl(tc.member_type(i), history);
                    }
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_enum: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    write_ulong(tc.member_count());
                    for (int i = 0; i < tc.member_count(); i++)
                        write_string(tc.member_name(i));
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_string:
                case org.omg.CORBA.TCKind._tk_wstring:
                    write_ulong(tc.length());
                    break;

                case org.omg.CORBA.TCKind._tk_sequence:
                case org.omg.CORBA.TCKind._tk_array: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    writeTypeCodeImpl(tc.content_type(), history);
                    write_ulong(tc.length());
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_alias: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    writeTypeCodeImpl(tc.content_type(), history);
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_value: {
                    history.put(tc, oldPos);

                    org.omg.CORBA.TypeCode concreteBase = tc
                            .concrete_base_type();
                    if (concreteBase == null) {
                        concreteBase = org.apache.yoko.orb.OB.TypeCodeFactory
                                .createPrimitiveTC(org.omg.CORBA.TCKind.tk_null);
                    }

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    write_short(tc.type_modifier());
                    writeTypeCodeImpl(concreteBase, history);
                    write_ulong(tc.member_count());
                    for (int i = 0; i < tc.member_count(); i++) {
                        write_string(tc.member_name(i));
                        writeTypeCodeImpl(tc.member_type(i), history);
                        write_short(tc.member_visibility(i));
                    }
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_value_box: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    writeTypeCodeImpl(tc.content_type(), history);
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_abstract_interface: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA.TCKind._tk_native: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    writeLength(start);

                    break;
                }

                case org.omg.CORBA_2_4.TCKind._tk_local_interface: {
                    history.put(tc, oldPos);

                    int start = writeGap();
                    _OB_writeEndian();
                    write_string(tc.id());
                    write_string(tc.name());
                    writeLength(start);

                    break;
                }

                default:
                    org.apache.yoko.orb.OB.Assert._OB_assert("Invalid typecode");
                }
            } catch (org.omg.CORBA.TypeCodePackage.BadKind ex) {
                org.apache.yoko.orb.OB.Assert._OB_assert(ex);
            } catch (org.omg.CORBA.TypeCodePackage.Bounds ex) {
                org.apache.yoko.orb.OB.Assert._OB_assert(ex);
            }
        }
    }

    //
    // Must be called prior to any writes
    //
    private void checkBeginChunk() {
        org.apache.yoko.orb.OB.Assert._OB_assert(valueWriter_ != null);
        valueWriter_.checkBeginChunk();
    }

    private org.apache.yoko.orb.OB.ValueWriter valueWriter() {
        if (valueWriter_ == null)
            valueWriter_ = new org.apache.yoko.orb.OB.ValueWriter(this);
        return valueWriter_;
    }

    private void addCapacity(int size) {
        //
        // Expand buffer to hold requested size
        //
        // Note: OutputStreams are not always written to in a linear
        // fashion, i.e., sometimes the position is reset to
        // an earlier point and data is patched in. Therefore,
        // do NOT do this:
        //
        // buf_.realloc(buf_.len_ + size);
        //
        //
        if (alignNext_ > 0) {
            int align = alignNext_;
            alignNext_ = 0;
            addCapacity(size, align);
        } else {
            //
            // If we're at the end of the current buffer, then we are about
            // to write new data. We must first check if we need to start a
            // chunk, which may result in a recursive call to addCapacity().
            //
            if (buf_.pos_ == buf_.len_ && valueWriter_ != null) {
                checkBeginChunk();
            }

            //
            // If there isn't enough room, then reallocate the buffer
            //
            final int len = buf_.pos_ + size;
            if (len > buf_.len_) {
                buf_.realloc(len);
            }
        }
    }

    private int roundUp(final int i, final int align) {
        switch (align) {
            case 0x00: return i;
            case 0x01: return i;
            case 0x02: return ((i + 0b0001) & ~(0b0001));
            case 0x04: return ((i + 0b0011) & ~(0b0011));
            case 0x08: return ((i + 0b0111) & ~(0b0111));
            case 0x10: return ((i + 0b1111) & ~(0b1111));
            default:
                if (LOGGER.isLoggable(Level.WARNING))
                    LOGGER.warning(String.format("Aligning on a strange number 0x%x", align));
                final int j = (i + align - 1);
                return (j - (j % align));
        }
    }

    private static final byte PAD_BYTE = (byte)0xbd;

    private void addCapacity(int size, int align) {
        // use addCapacity(int) if align == 0
        org.apache.yoko.orb.OB.Assert._OB_assert(align > 0);

        //
        // If we're at the end of the current buffer, then we are about
        // to write new data. We must first check if we need to start a
        // chunk, which may result in a recursive call to addCapacity().
        //
        if (buf_.pos_ == buf_.len_ && valueWriter_ != null) {
            checkBeginChunk();
        }

        //
        // If alignNext_ is set, then use the larger of alignNext_ and align
        //
        if (alignNext_ > 0) {
            align = (alignNext_ > align ? alignNext_ : align);
            alignNext_ = 0;
        }

        final int newPos = roundUp(buf_.pos_, align);

        //
        // If there isn't enough room, then reallocate the buffer
        //
        final int len = newPos + size;
        if (len > buf_.len_) {
            buf_.realloc(len);
        }

        //
        // Pad to the requested boundary
        //
        for (; buf_.pos_ < newPos; buf_.pos_++) {
            buf_.data_[buf_.pos_] = PAD_BYTE;
        }
    }

    //
    // write wchar using old non-compliant method
    //
    private void _OB_write_wchar_old(char value) {
        if (wCharConversionRequired_) {
            final org.apache.yoko.orb.OB.CodeConverterBase converter = codeConverters_.outputWcharConverter;

            value = converter.convert(value);

            //
            // For GIOP 1.1 non byte-oriented wide characters are written
            // as ushort or ulong, depending on their maximum length
            // listed in the code set registry.
            //
            switch (giopVersion_) {
            case GIOP1_1: {
                if (converter.getTo().max_bytes <= 2)
                    write_ushort((short) value);
                else
                    write_ulong((int) value);
            }
                break;

            default: {
                final int length = converter.write_count_wchar(value);
                write_octet((byte) length);
                addCapacity(length);
                converter.write_wchar(this, value);
            }
                break;
            }
        }
        //
        // UTF-16
        //
        else {
            switch (giopVersion_) {
            case GIOP1_0:
            case GIOP1_1:
                write_ushort((short) value);
                break;

            default:
                addCapacity(3);
                buf_.data_[buf_.pos_++] = 2;
                buf_.data_[buf_.pos_++] = (byte) (value >> 8);
                buf_.data_[buf_.pos_++] = (byte) value;
                break;
            }
        }
    }

    //
    // write wchar using new compilant method
    //
    private void _OB_write_wchar_new(char value, boolean partOfString) {
        final org.apache.yoko.orb.OB.CodeConverterBase converter = codeConverters_.outputWcharConverter;

        //
        // pre-convert the character if necessary
        //
        if (wCharConversionRequired_)
            value = converter.convert(value);

        if (wCharWriterRequired_) {
            if (partOfString == false)
                converter
                        .set_writer_flags(org.apache.yoko.orb.OB.CodeSetWriter.FIRST_CHAR);

            //
            // For GIOP 1.1 non byte-oriented wide characters are written
            // as ushort or ulong, depending on their maximum length
            // listed in the code set registry.
            //
            switch (giopVersion_) {
            case GIOP1_0: {
                //
                // we don't support special writers for GIOP 1.0 if
                // conversion is required or if a writer is required
                //
                org.apache.yoko.orb.OB.Assert._OB_assert(false);
            }
                break;

            case GIOP1_1: {
                //
                // get the length of the character
                //
                int len = converter.write_count_wchar(value);

                //
                // For GIOP 1.1 we are limited to 2-byte wchars
                // so make sure to check for that
                //
                org.apache.yoko.orb.OB.Assert._OB_assert(len == 2);

                //
                // allocate aligned space
                //
                addCapacity(2, 2);

                //
                // write using the writer
                //
                converter.write_wchar(this, value);
            }
                break;

            default: {
                //
                // get the length of the character
                //
                int len = converter.write_count_wchar(value);

                //
                // write the octet length at the beginning
                //
                write_octet((byte) len);

                //
                // add unaligned capacity
                //
                addCapacity(len);

                //
                // write the actual character
                //
                converter.write_wchar(this, value);
            }
                break;
            }
        } else {
            switch (giopVersion_) {
            case GIOP1_0: {
                //
                // Orbix2000/Orbacus/E compatible 1.0 marshal
                //

                //
                // add aligned capacity
                //
                addCapacity(2, 2);

                //
                // write 2-byte character in big endian
                //
                buf_.data_[buf_.pos_++] = (byte) (value >>> 8);
                buf_.data_[buf_.pos_++] = (byte) (value & 0xff);
            }
                break;

            case GIOP1_1: {
                write_ushort((short) value);
            }
                break;

            default: {
                //
                // add unaligned space for character
                //
                addCapacity(3);

                //
                // write the octet length at the start
                //
                buf_.data_[buf_.pos_++] = 2;

                //
                // write the character in big endian format
                //
                buf_.data_[buf_.pos_++] = (byte) (value >>> 8);
                buf_.data_[buf_.pos_++] = (byte) (value & 0xff);
            }
                break;
            }
        }
    }

    //
    // write wstring using old non-compliant method
    //
    private void _OB_write_wstring_old(String value) {
        final char[] arr = value.toCharArray();
        final int len = arr.length;

        //
        // 15.3.2.7: For GIOP version 1.1, a wide string is encoded as an
        // unsigned long indicating the length of the string in octets or
        // unsigned integers (determined by the transfer syntax for wchar)
        // followed by the individual wide characters. Both the string length
        // and contents include a terminating null. The terminating null
        // character for a wstring is also a wide character.
        //
        switch (giopVersion_) {
        case GIOP1_0:
        case GIOP1_1: {
            write_ulong(len + 1);
            write_wchar_array(arr, 0, len);
            write_wchar((char) 0);
        }
            break;

        default: {
            //
            // For octet count
            //
            int start = writeGap();

            if (wCharConversionRequired_) {
                final org.apache.yoko.orb.OB.CodeConverterBase converter = codeConverters_.outputWcharConverter;

                for (int i = 0; i < len; i++) {
                    char v = converter.convert(arr[i]);

                    if (v == 0)
                        throw new org.omg.CORBA.DATA_CONVERSION(
                                "illegal wchar value for wstring: " + (int) v);

                    addCapacity(converter.write_count_wchar(v));
                    converter.write_wchar(this, v);
                }
            }
            //
            // UTF-16
            //
            else {
                addCapacity(2 * len);

                for (int i = 0; i < len; i++) {
                    char v = arr[i];

                    if (v == 0)
                        throw new org.omg.CORBA.DATA_CONVERSION(
                                "illegal wchar value for wstring: " + (int) v);

                    buf_.data_[buf_.pos_++] = (byte) (v >> 8);
                    buf_.data_[buf_.pos_++] = (byte) v;
                }
            }

            //
            // Write octet count
            //
            writeLength(start);
        }
            break;
        }
    }

    //
    // write wstring using new compliant method
    //
    private void _OB_write_wstring_new(String value) {
        final char[] arr = value.toCharArray();
        final int len = arr.length;

        LOGGER.finest("Writing wstring value " + value);
        //
        // get converter/writer instance
        //
        final org.apache.yoko.orb.OB.CodeConverterBase converter = codeConverters_.outputWcharConverter;

        //
        // some writers (specially UTF-16) requires the possible BOM
        // only found at the beginning of a string... this will
        // indicate that we are at the start of the first character
        // of the string to the writer
        if (wCharWriterRequired_)
            converter
                    .set_writer_flags(org.apache.yoko.orb.OB.CodeSetWriter.FIRST_CHAR);

        //
        // for GIOP 1.0/1.1 we don't need to differentiate between
        // strings requiring a writer/converter (or not) since they can
        // be handled by the write_wchar() method
        //
        switch (giopVersion_) {
            case GIOP1_0:
            case GIOP1_1:
                //
                // write the length of the string
                //
                write_ulong(len + 1);

                //
                // now write all the characters
                //
                for (int i = 0; i < len; i++)
                    write_wchar(arr[i], true);

                //
                // and the null terminator
                //
                write_wchar((char) 0, true);
                return;
            default:
        }

        //
        // save the starting position and write the gap to place the
        // length of the string later
        //
        int start = writeGap();

        //
        // we've handled GIOP 1.0/1.1 above so this must be GIOP 1.2+
        //
        if (wCharWriterRequired_) {
            for (int i = 0; i < len; i++) {
                char v = arr[i];

                //
                // check if the character requires conversion
                //
                if (wCharConversionRequired_)
                    v = converter.convert(v);

                //
                // illegal for the string to contain nulls
                //
                if (v == 0)
                    throw new org.omg.CORBA.DATA_CONVERSION(
                            "illegal wchar value for wstring: " + (int) v);

                //
                // add capacity for the character
                //
                addCapacity(converter.write_count_wchar(v));

                //
                // write the character
                //
                converter.write_wchar(this, v);
            }
        } else {
            //
            // since we don't require a special writer, each character
            // MUST be 2-bytes in size
            //
            addCapacity(len << 1);

            for (int i = 0; i < len; i++) {
                char v = arr[i];

                //
                // check for conversion
                //
                if (wCharConversionRequired_)
                    v = converter.convert(v);

                //
                // write character in big endian format
                //
                buf_.data_[buf_.pos_++] = (byte) (v >>> 8);
                buf_.data_[buf_.pos_++] = (byte) (v & 0xff);
            }
        }

        //
        // write the octet length
        //
        writeLength(start);
    }

    // ------------------------------------------------------------------
    // Standard IDL to Java Mapping
    // ------------------------------------------------------------------

    public void write(int b) throws java.io.IOException {
        //
        // this matches the behaviour of this function in the Java ORB
        // and not what is outlined in the java.io.OutputStream
        //
        write_long(b);
    }

    public org.omg.CORBA.ORB orb() {
        if (orbInstance_ != null)
            return orbInstance_.getORB();
        return null;
    }

    public org.omg.CORBA.portable.InputStream create_input_stream() {
        org.apache.yoko.orb.OCI.Buffer buf = new org.apache.yoko.orb.OCI.Buffer(
                buf_.len_);
        if (buf_.len_ > 0)
            System.arraycopy(buf_.data_, 0, buf.data_, 0, buf_.len_);

// this is a useful tracepoint, but produces a lot of data, so turn on only
// if really needed.
//      if (logger.isLoggable(Level.FINEST)) {
//          logger.fine("new input stream created:\n" + buf.dumpData());
//      }

        InputStream in = new InputStream(buf, 0, false, codeConverters_,
                giopVersion_);
        in._OB_ORBInstance(orbInstance_);
        return in;
    }

    public void write_boolean(boolean value) {
        addCapacity(1);

        buf_.data_[buf_.pos_++] = value ? (byte) 1 : (byte) 0;
    }

    public void write_char(char value) {
        if (value > 255)
            throw new org.omg.CORBA.DATA_CONVERSION("char value exceeds 255: "
                    + (int) value);

        addCapacity(1);

        final org.apache.yoko.orb.OB.CodeConverterBase converter = codeConverters_.outputCharConverter;

        if (charConversionRequired_)
            value = converter.convert(value);

        if (charWriterRequired_)
            converter.write_char(this, value);
        else
            buf_.data_[buf_.pos_++] = (byte) value;
    }

    public void write_wchar(char value) {
        write_wchar(value, false);
    }

    public void write_wchar(char value, boolean partOfString) {
        if (org.apache.yoko.orb.OB.OB_Extras.COMPAT_WIDE_MARSHAL == false)
            _OB_write_wchar_new(value, partOfString);
        else
            _OB_write_wchar_old(value);
    }

    public void write_octet(byte value) {
        addCapacity(1);
        buf_.data_[buf_.pos_++] = value;
    }

    public void write_short(short value) {
        addCapacity(2, 2);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 8);
        buf_.data_[buf_.pos_++] = (byte) value;
    }

    public void write_ushort(short value) {
        write_short(value);
    }

    public void write_long(int value) {
        addCapacity(4, 4);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 24);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 16);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 8);
        buf_.data_[buf_.pos_++] = (byte) value;
    }

    public void write_ulong(int value) {
        write_long(value);
    }

    public void write_longlong(long value) {
        addCapacity(8, 8);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 56);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 48);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 40);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 32);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 24);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 16);
        buf_.data_[buf_.pos_++] = (byte) (value >>> 8);
        buf_.data_[buf_.pos_++] = (byte) value;
    }

    public void write_ulonglong(long value) {
        write_longlong(value);
    }

    public void write_float(float value) {
        write_long(Float.floatToIntBits(value));
    }

    public void write_double(double value) {
        write_longlong(Double.doubleToLongBits(value));
    }

    public void write_string(String value) {
        LOGGER.finest("Writing string value " + value);
        final char[] arr = value.toCharArray();
        int len = arr.length;
        int capacity = len + 1;

        if (!(charWriterRequired_ || charConversionRequired_)) {
            write_ulong(capacity);
            addCapacity(capacity);

            for (int i = 0; i < len; i++) {
                char c = arr[i];

                if (c == 0 || c > 255)
                    throw new org.omg.CORBA.DATA_CONVERSION(
                            "illegal char value for string: " + (int) c);

                buf_.data_[buf_.pos_++] = (byte) c;
            }
        } else {
            final org.apache.yoko.orb.OB.CodeConverterBase converter = codeConverters_.outputCharConverter;

            //
            // Intermediate variable used for efficiency
            //
            boolean bothRequired = charWriterRequired_
                    && charConversionRequired_;

            //
            // Temporary OCI buffer required
            //
            org.apache.yoko.orb.OCI.Buffer buffer = new org.apache.yoko.orb.OCI.Buffer(
                    64);
            OutputStream tmpStream = new OutputStream(buffer);

            for (int i = 0; i < len; i++) {
                char c = arr[i];

                if (c == 0 || c > 255)
                    throw new org.omg.CORBA.DATA_CONVERSION(
                            "illegal char value for string: " + (int) c);

                //
                // Expand the temporary buffer, if necessary
                //
                if (buffer.length() - buffer.pos() <= 4)
                    buffer.realloc(buffer.length() * 2);

                if (bothRequired)
                    converter.write_char(tmpStream, converter.convert(c));
                else if (charWriterRequired_)
                    converter.write_char(tmpStream, c);
                else
                    buffer.data_[buffer.pos_++] = (byte) converter.convert(c);
            }

            //
            // Copy the contents from the temporary buffer
            //
            int bufSize = buffer.pos_;

            write_ulong(bufSize + 1);
            addCapacity(bufSize + 1);

            for (int i = 0; i < bufSize; i++) {
                buf_.data_[buf_.pos_++] = buffer.data_[i];
            }
        }

        buf_.data_[buf_.pos_++] = (byte) 0;
    }

    public void write_wstring(String value) {
        if (org.apache.yoko.orb.OB.OB_Extras.COMPAT_WIDE_MARSHAL == false)
            _OB_write_wstring_new(value);
        else
            _OB_write_wstring_old(value);
    }

    public void write_boolean_array(boolean[] value, int offset, int length) {
        if (length > 0) {
            addCapacity(length);

            for (int i = offset; i < offset + length; i++)
                buf_.data_[buf_.pos_++] = value[i] ? (byte) 1 : (byte) 0;
        }
    }

    public void write_char_array(char[] value, int offset, int length) {
        if (length > 0) {
            addCapacity(length);

            if (!(charWriterRequired_ || charConversionRequired_)) {
                for (int i = offset; i < offset + length; i++) {
                    if (value[i] > 255)
                        throw new org.omg.CORBA.DATA_CONVERSION(
                                "char value exceeds 255: " + (int) value[i]);

                    buf_.data_[buf_.pos_++] = (byte) value[i];
                }
            } else {
                final org.apache.yoko.orb.OB.CodeConverterBase converter = codeConverters_.outputCharConverter;

                //
                // Intermediate variable used for efficiency
                //
                boolean bothRequired = charWriterRequired_
                        && charConversionRequired_;

                for (int i = offset; i < offset + length; i++) {
                    if (value[i] > 255)
                        throw new org.omg.CORBA.DATA_CONVERSION(
                                "char value exceeds 255: " + (int) value[i]);

                    if (bothRequired)
                        converter.write_char(this, converter.convert(value[i]));
                    else if (charWriterRequired_)
                        converter.write_char(this, value[i]);
                    else
                        buf_.data_[buf_.pos_++] = (byte) converter
                                .convert(value[i]);
                }
            }
        }
    }

    public void write_wchar_array(char[] value, int offset, int length) {
        for (int i = offset; i < offset + length; i++)
            write_wchar(value[i], false);
    }

    public void write_octet_array(byte[] value, int offset, int length) {
        if (length > 0) {
            addCapacity(length);

            System.arraycopy(value, offset, buf_.data_, buf_.pos_, length);

            buf_.pos_ += length;
        }
    }

    public void write_short_array(short[] value, int offset, int length) {
        if (length > 0) {
            addCapacity(length * 2, 2);

            for (int i = offset; i < offset + length; i++) {
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 8);
                buf_.data_[buf_.pos_++] = (byte) value[i];
            }
        }
    }

    public void write_ushort_array(short[] value, int offset, int length) {
        write_short_array(value, offset, length);
    }

    public void write_long_array(int[] value, int offset, int length) {
        if (length > 0) {
            addCapacity(length * 4, 4);

            for (int i = offset; i < offset + length; i++) {
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 24);
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 16);
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 8);
                buf_.data_[buf_.pos_++] = (byte) value[i];
            }
        }
    }

    public void write_ulong_array(int[] value, int offset, int length) {
        write_long_array(value, offset, length);
    }

    public void write_longlong_array(long[] value, int offset, int length) {
        if (length > 0) {
            addCapacity(length * 8, 8);

            for (int i = offset; i < offset + length; i++) {
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 56);
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 48);
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 40);
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 32);
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 24);
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 16);
                buf_.data_[buf_.pos_++] = (byte) (value[i] >>> 8);
                buf_.data_[buf_.pos_++] = (byte) value[i];
            }
        }
    }

    public void write_ulonglong_array(long[] value, int offset, int length) {
        write_longlong_array(value, offset, length);
    }

    public void write_float_array(float[] value, int offset, int length) {
        if (length > 0) {
            addCapacity(length * 4, 4);

            for (int i = offset; i < offset + length; i++) {
                int v = Float.floatToIntBits(value[i]);

                buf_.data_[buf_.pos_++] = (byte) (v >>> 24);
                buf_.data_[buf_.pos_++] = (byte) (v >>> 16);
                buf_.data_[buf_.pos_++] = (byte) (v >>> 8);
                buf_.data_[buf_.pos_++] = (byte) v;
            }
        }
    }

    public void write_double_array(double[] value, int offset, int length) {
        if (length > 0) {
            addCapacity(length * 8, 8);

            for (int i = offset; i < offset + length; i++) {
                long v = Double.doubleToLongBits(value[i]);

                buf_.data_[buf_.pos_++] = (byte) (v >>> 56);
                buf_.data_[buf_.pos_++] = (byte) (v >>> 48);
                buf_.data_[buf_.pos_++] = (byte) (v >>> 40);
                buf_.data_[buf_.pos_++] = (byte) (v >>> 32);
                buf_.data_[buf_.pos_++] = (byte) (v >>> 24);
                buf_.data_[buf_.pos_++] = (byte) (v >>> 16);
                buf_.data_[buf_.pos_++] = (byte) (v >>> 8);
                buf_.data_[buf_.pos_++] = (byte) v;
            }
        }
    }

    public void write_Object(org.omg.CORBA.Object value) {
        if (value == null) {
            LOGGER.finest("Writing a null CORBA object value");
            org.omg.IOP.IOR ior = new org.omg.IOP.IOR();
            ior.type_id = "";
            ior.profiles = new org.omg.IOP.TaggedProfile[0];
            org.omg.IOP.IORHelper.write(this, ior);
        } else {
            if (value instanceof org.omg.CORBA.LocalObject)
                throw new org.omg.CORBA.MARSHAL(
                        org.apache.yoko.orb.OB.MinorCodes
                                .describeMarshal(org.apache.yoko.orb.OB.MinorCodes.MinorLocalObject),
                        org.apache.yoko.orb.OB.MinorCodes.MinorLocalObject,
                        org.omg.CORBA.CompletionStatus.COMPLETED_NO);

            Delegate p = (Delegate) ((org.omg.CORBA.portable.ObjectImpl) value)
                    ._get_delegate();

            p._OB_marshalOrigIOR(this);
        }
    }

    public void write_TypeCode(org.omg.CORBA.TypeCode t) {
        //
        // NOTE:
        //
        // No data with natural alignment of greater than four octets
        // is needed for TypeCode. Therefore it is not necessary to do
        // encapsulation in a separate buffer.
        //

        if (t == null)
            throw new org.omg.CORBA.BAD_TYPECODE("TypeCode is nil");

        java.util.Hashtable history = new java.util.Hashtable(11);
        writeTypeCodeImpl(t, history);
    }

    public void write_any(org.omg.CORBA.Any value) {
        LOGGER.finest("Writing an ANY value of type " + value.type().kind());
        write_TypeCode(value.type());
        value.write_value(this);
    }

    public void write_Context(org.omg.CORBA.Context ctx,
            org.omg.CORBA.ContextList contexts) {
        int count = contexts.count();
        java.util.Vector v = new java.util.Vector();
        org.apache.yoko.orb.CORBA.Context ctxImpl = (org.apache.yoko.orb.CORBA.Context) ctx;
        for (int i = 0; i < count; i++) {
            try {
                String pattern = contexts.item(i);
                ctxImpl._OB_getValues("", 0, pattern, v);
            } catch (org.omg.CORBA.Bounds ex) {
                org.apache.yoko.orb.OB.Assert._OB_assert(ex);
            }
        }

        write_ulong(v.size());

        java.util.Enumeration e = v.elements();
        while (e.hasMoreElements())
            write_string((String) e.nextElement());
    }

    public void write_Principal(org.omg.CORBA.Principal value) {
        // Deprecated by CORBA 2.2
        throw new org.omg.CORBA.NO_IMPLEMENT();
    }

    public void write_fixed(java.math.BigDecimal value) {
        String v = value.abs().toString();

        //
        // Append coded sign to value string
        //
        if (value.signum() == -1)
            v += (char) ('0' + 0x0d);
        else
            v += (char) ('0' + 0x0c);

        String s = "";
        if ((v.length() & 1) != 0)
            s = "0";

        s += v;
        final int len = s.length();

        for (int i = 0; i < len - 1; i += 2) {
            char c1 = s.charAt(i);
            char c2 = s.charAt(i + 1);
            write_octet((byte) ((c1 - '0') << 4 | (c2 - '0')));
        }
    }

    public void write_value(java.io.Serializable value) {
        valueWriter().writeValue(value, null);
    }

    public void write_value(java.io.Serializable value, java.lang.String rep_id) {
        valueWriter().writeValue(value, rep_id);
    }

    public void write_value(java.io.Serializable value, Class clz) {
        valueWriter().writeValue(value, null);
    }

    public void write_value(java.io.Serializable value,
            org.omg.CORBA.portable.BoxedValueHelper helper) {
        valueWriter().writeValueBox(value, null, helper);
    }

    public void write_abstract_interface(java.lang.Object obj) {
        valueWriter().writeAbstractInterface(obj);
    }

    // ------------------------------------------------------------------
    // Additional Yoko specific functions
    // ------------------------------------------------------------------

    public void write_value(java.io.Serializable value,
            org.omg.CORBA.TypeCode tc,
            org.omg.CORBA.portable.BoxedValueHelper helper) {
        valueWriter().writeValueBox(value, tc, helper);
    }

    public void write_InputStream(org.omg.CORBA.portable.InputStream in,
            org.omg.CORBA.TypeCode tc) {
        InputStream obin = null;
        try {
            obin = (InputStream) in;
        } catch (ClassCastException ex) {
            // InputStream may have been created by a different ORB
        }

        try {
            LOGGER.fine("writing a value of type " + tc.kind().value());

            switch (tc.kind().value()) {
            case org.omg.CORBA.TCKind._tk_null:
            case org.omg.CORBA.TCKind._tk_void:
                break;

            case org.omg.CORBA.TCKind._tk_short:
            case org.omg.CORBA.TCKind._tk_ushort:
                write_short(in.read_short());
                break;

            case org.omg.CORBA.TCKind._tk_long:
            case org.omg.CORBA.TCKind._tk_ulong:
            case org.omg.CORBA.TCKind._tk_float:
            case org.omg.CORBA.TCKind._tk_enum:
                write_long(in.read_long());
                break;

            case org.omg.CORBA.TCKind._tk_double:
            case org.omg.CORBA.TCKind._tk_longlong:
            case org.omg.CORBA.TCKind._tk_ulonglong:
                write_longlong(in.read_longlong());
                break;

            case org.omg.CORBA.TCKind._tk_boolean:
            case org.omg.CORBA.TCKind._tk_octet:
                write_octet(in.read_octet());
                break;

            case org.omg.CORBA.TCKind._tk_char:
                write_char(in.read_char());
                break;

            case org.omg.CORBA.TCKind._tk_wchar:
                write_wchar(in.read_wchar());
                break;

            case org.omg.CORBA.TCKind._tk_fixed:
                write_fixed(in.read_fixed());
                break;

            case org.omg.CORBA.TCKind._tk_any: {
                // Don't do this: write_any(in.read_any())
                // This is faster:
                org.omg.CORBA.TypeCode p = in.read_TypeCode();
                write_TypeCode(p);
                write_InputStream(in, p);
                break;
            }

            case org.omg.CORBA.TCKind._tk_TypeCode: {
                // Don't do this: write_TypeCode(in.read_TypeCode())
                // This is faster:

                int kind = in.read_ulong();

                //
                // An indirection is not permitted at this level
                //
                if (kind == -1) {
                    throw new org.omg.CORBA.MARSHAL(
                            org.apache.yoko.orb.OB.MinorCodes
                                    .describeMarshal(org.apache.yoko.orb.OB.MinorCodes.MinorReadInvTypeCodeIndirection),
                            org.apache.yoko.orb.OB.MinorCodes.MinorReadInvTypeCodeIndirection,
                            org.omg.CORBA.CompletionStatus.COMPLETED_NO);
                }

                write_ulong(kind);

                switch (kind) {
                case org.omg.CORBA.TCKind._tk_null:
                case org.omg.CORBA.TCKind._tk_void:
                case org.omg.CORBA.TCKind._tk_short:
                case org.omg.CORBA.TCKind._tk_long:
                case org.omg.CORBA.TCKind._tk_ushort:
                case org.omg.CORBA.TCKind._tk_ulong:
                case org.omg.CORBA.TCKind._tk_float:
                case org.omg.CORBA.TCKind._tk_double:
                case org.omg.CORBA.TCKind._tk_boolean:
                case org.omg.CORBA.TCKind._tk_char:
                case org.omg.CORBA.TCKind._tk_octet:
                case org.omg.CORBA.TCKind._tk_any:
                case org.omg.CORBA.TCKind._tk_TypeCode:
                case org.omg.CORBA.TCKind._tk_Principal:
                case org.omg.CORBA.TCKind._tk_longlong:
                case org.omg.CORBA.TCKind._tk_ulonglong:
                case org.omg.CORBA.TCKind._tk_longdouble:
                case org.omg.CORBA.TCKind._tk_wchar:
                    break;

                case org.omg.CORBA.TCKind._tk_fixed:
                    write_ushort(in.read_ushort());
                    write_short(in.read_short());
                    break;

                case org.omg.CORBA.TCKind._tk_objref:
                case org.omg.CORBA.TCKind._tk_struct:
                case org.omg.CORBA.TCKind._tk_union:
                case org.omg.CORBA.TCKind._tk_enum:
                case org.omg.CORBA.TCKind._tk_sequence:
                case org.omg.CORBA.TCKind._tk_array:
                case org.omg.CORBA.TCKind._tk_alias:
                case org.omg.CORBA.TCKind._tk_except:
                case org.omg.CORBA.TCKind._tk_value:
                case org.omg.CORBA.TCKind._tk_value_box:
                case org.omg.CORBA.TCKind._tk_abstract_interface:
                case org.omg.CORBA.TCKind._tk_native:
                case org.omg.CORBA_2_4.TCKind._tk_local_interface: {
                    final int len = in.read_ulong();
                    write_ulong(len);
                    addCapacity(len);
                    in.read_octet_array(buf_.data_, buf_.pos_, len);
                    buf_.pos_ += len;
                    break;
                }

                case org.omg.CORBA.TCKind._tk_string:
                case org.omg.CORBA.TCKind._tk_wstring: {
                    int bound = in.read_ulong();
                    write_ulong(bound);
                    break;
                }

                default:
                    throw new InternalError();
                }

                break;
            }

            case org.omg.CORBA.TCKind._tk_Principal:
                write_Principal(in.read_Principal());
                break;

            case org.omg.CORBA.TCKind._tk_objref: {
                // Don't do this: write_Object(in.read_Object())
                // This is faster:
                org.omg.IOP.IOR ior = org.omg.IOP.IORHelper.read(in);
                org.omg.IOP.IORHelper.write(this, ior);
                break;
            }

            case org.omg.CORBA.TCKind._tk_struct:
                for (int i = 0; i < tc.member_count(); i++)
                    write_InputStream(in, tc.member_type(i));
                break;

            case org.omg.CORBA.TCKind._tk_except:
                write_string(in.read_string());
                for (int i = 0; i < tc.member_count(); i++)
                    write_InputStream(in, tc.member_type(i));
                break;

            case org.omg.CORBA.TCKind._tk_union: {
                int defaultIndex = tc.default_index();
                int memberIndex = -1;

                org.omg.CORBA.TypeCode origDiscType = TypeCode
                        ._OB_getOrigType(tc.discriminator_type());

                switch (origDiscType.kind().value()) {
                case org.omg.CORBA.TCKind._tk_short: {
                    short val = in.read_short();
                    write_short(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).extract_short()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                case org.omg.CORBA.TCKind._tk_ushort: {
                    short val = in.read_ushort();
                    write_ushort(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).extract_ushort()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                case org.omg.CORBA.TCKind._tk_long: {
                    int val = in.read_long();
                    write_long(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).extract_long()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                case org.omg.CORBA.TCKind._tk_ulong: {
                    int val = in.read_ulong();
                    write_ulong(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).extract_ulong()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                case org.omg.CORBA.TCKind._tk_longlong: {
                    long val = in.read_longlong();
                    write_longlong(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).extract_longlong()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                case org.omg.CORBA.TCKind._tk_ulonglong: {
                    long val = in.read_ulonglong();
                    write_ulonglong(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).extract_ulonglong()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                case org.omg.CORBA.TCKind._tk_char: {
                    char val = in.read_char();
                    write_char(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).extract_char()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                case org.omg.CORBA.TCKind._tk_boolean: {
                    boolean val = in.read_boolean();
                    write_boolean(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).extract_boolean()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                case org.omg.CORBA.TCKind._tk_enum: {
                    int val = in.read_long();
                    write_long(val);

                    for (int i = 0; i < tc.member_count(); i++)
                        if (i != defaultIndex) {
                            if (val == tc.member_label(i).create_input_stream()
                                    .read_long()) {
                                memberIndex = i;
                                break;
                            }
                        }

                    break;
                }

                default:
                    org.apache.yoko.orb.OB.Assert._OB_assert("Invalid typecode in tk_union");
                }

                if (memberIndex >= 0)
                    write_InputStream(in, tc.member_type(memberIndex));
                else if (defaultIndex >= 0)
                    write_InputStream(in, tc.member_type(defaultIndex));

                break;
            }

            case org.omg.CORBA.TCKind._tk_string:
                write_string(in.read_string());
                break;

            case org.omg.CORBA.TCKind._tk_wstring:
                write_wstring(in.read_wstring());
                break;

            case org.omg.CORBA.TCKind._tk_sequence:
            case org.omg.CORBA.TCKind._tk_array: {
                int len;

                if (tc.kind().value() == org.omg.CORBA.TCKind._tk_sequence) {
                    len = in.read_ulong();
                    write_ulong(len);
                } else
                    len = tc.length();

                if (len > 0) {
                    org.omg.CORBA.TypeCode origContentType = TypeCode
                            ._OB_getOrigType(tc.content_type());

                    switch (origContentType.kind().value()) {
                    case org.omg.CORBA.TCKind._tk_null:
                    case org.omg.CORBA.TCKind._tk_void:
                        break;

                    case org.omg.CORBA.TCKind._tk_short:
                    case org.omg.CORBA.TCKind._tk_ushort: {
                        if (obin == null || obin.swap_) {
                            short[] s = new short[len];
                            in.read_short_array(s, 0, len);
                            write_short_array(s, 0, len);
                        } else {
                            // Read one value for the alignment
                            write_short(obin.read_short());
                            final int n = 2 * (len - 1);

                            if (n > 0) {
                                // Copy the rest
                                addCapacity(n);
                                org.apache.yoko.orb.OCI.Buffer buf = obin
                                        ._OB_buffer();
                                System.arraycopy(buf.data_, buf.pos_,
                                        buf_.data_, buf_.pos_, n);
                                buf.pos_ += n;
                                buf_.pos_ += n;
                            }
                        }
                        break;
                    }

                    case org.omg.CORBA.TCKind._tk_long:
                    case org.omg.CORBA.TCKind._tk_ulong:
                    case org.omg.CORBA.TCKind._tk_float: {
                        if (obin == null || obin.swap_) {
                            int[] i = new int[len];
                            in.read_long_array(i, 0, len);
                            write_long_array(i, 0, len);
                        } else {
                            // Read one value for the alignment
                            write_long(obin.read_long());
                            final int n = 4 * (len - 1);

                            if (n > 0) {
                                // Copy the rest
                                addCapacity(n);
                                org.apache.yoko.orb.OCI.Buffer buf = obin
                                        ._OB_buffer();
                                System.arraycopy(buf.data_, buf.pos_,
                                        buf_.data_, buf_.pos_, n);
                                buf.pos_ += n;
                                buf_.pos_ += n;
                            }
                        }
                        break;
                    }

                    case org.omg.CORBA.TCKind._tk_double:
                    case org.omg.CORBA.TCKind._tk_longlong:
                    case org.omg.CORBA.TCKind._tk_ulonglong: {
                        if (obin == null || obin.swap_) {
                            long[] l = new long[len];
                            in.read_longlong_array(l, 0, len);
                            write_longlong_array(l, 0, len);
                        } else {
                            // Read one value for the alignment
                            write_longlong(obin.read_longlong());
                            final int n = 8 * (len - 1);
                            if (n > 0) {
                                // Copy the rest
                                addCapacity(n);
                                org.apache.yoko.orb.OCI.Buffer buf = obin
                                        ._OB_buffer();
                                System.arraycopy(buf.data_, buf.pos_,
                                        buf_.data_, buf_.pos_, n);
                                buf.pos_ += n;
                                buf_.pos_ += n;
                            }
                        }
                        break;
                    }

                    case org.omg.CORBA.TCKind._tk_boolean:
                    case org.omg.CORBA.TCKind._tk_octet:
                        if (obin == null) {
                            addCapacity(len);
                            in.read_octet_array(buf_.data_, buf_.pos_, len);
                            buf_.pos_ += len;
                        } else {
                            addCapacity(len);
                            org.apache.yoko.orb.OCI.Buffer buf = obin
                                    ._OB_buffer();
                            System.arraycopy(buf.data_, buf.pos_, buf_.data_,
                                    buf_.pos_, len);
                            buf.pos_ += len;
                            buf_.pos_ += len;
                        }
                        break;

                    case org.omg.CORBA.TCKind._tk_char:
                        if (charWriterRequired_ || charConversionRequired_) {
                            char[] ch = new char[len];
                            in.read_char_array(ch, 0, len);
                            write_char_array(ch, 0, len);
                        } else {
                            addCapacity(len);
                            in.read_octet_array(buf_.data_, buf_.pos_, len);
                            buf_.pos_ += len;
                        }
                        break;

                    case org.omg.CORBA.TCKind._tk_wchar: {
                        char[] wch = new char[len];
                        in.read_wchar_array(wch, 0, len);
                        write_wchar_array(wch, 0, len);
                        break;
                    }

                    case org.omg.CORBA.TCKind._tk_alias:
                        org.apache.yoko.orb.OB.Assert._OB_assert("tk_alias not supported in tk_array or tk_sequence");
                        break;

                    default:
                        for (int i = 0; i < len; i++)
                            write_InputStream(in, tc.content_type());
                        break;
                    }
                }

                break;
            }

            case org.omg.CORBA.TCKind._tk_alias:
                write_InputStream(in, tc.content_type());
                break;

            case org.omg.CORBA.TCKind._tk_value:
            case org.omg.CORBA.TCKind._tk_value_box:
                if (obin == null) {
                    org.omg.CORBA_2_3.portable.InputStream i = (org.omg.CORBA_2_3.portable.InputStream) in;
                    write_value(i.read_value());
                } else
                    obin._OB_remarshalValue(tc, this);
                break;

            case org.omg.CORBA.TCKind._tk_abstract_interface: {
                boolean b = in.read_boolean();
                write_boolean(b);
                if (b) {
                    write_Object(in.read_Object());
                } else {
                    if (obin == null) {
                        org.omg.CORBA_2_3.portable.InputStream i = (org.omg.CORBA_2_3.portable.InputStream) in;
                        write_value(i.read_value());
                    } else {
                        //
                        // We have no TypeCode information about the
                        // valuetype, so we must use _tc_ValueBase and
                        // rely on the type information sent on the wire
                        //
                        obin._OB_remarshalValue(org.omg.CORBA.ValueBaseHelper
                                .type(), this);
                    }
                }
                break;
            }

            case org.omg.CORBA_2_4.TCKind._tk_local_interface:
            case org.omg.CORBA.TCKind._tk_native:
            default:
                org.apache.yoko.orb.OB.Assert._OB_assert("unsupported types");
            }
        } catch (org.omg.CORBA.TypeCodePackage.BadKind ex) {
            org.apache.yoko.orb.OB.Assert._OB_assert(ex);
        } catch (org.omg.CORBA.TypeCodePackage.Bounds ex) {
            org.apache.yoko.orb.OB.Assert._OB_assert(ex);
        }
    }

    // ------------------------------------------------------------------
    // Yoko internal functions
    // Application programs must not use these functions directly
    // ------------------------------------------------------------------

    public OutputStream(org.apache.yoko.orb.OCI.Buffer buf) {
        this(buf, null, null);
    }

    public OutputStream(org.apache.yoko.orb.OCI.Buffer buf,
            org.apache.yoko.orb.OB.CodeConverters converters, GiopVersion giopVersion) {
        buf_ = buf;

        if (giopVersion != null)
            giopVersion_ = giopVersion;

        charWriterRequired_ = false;
        charConversionRequired_ = false;
        wCharWriterRequired_ = false;
        wCharConversionRequired_ = false;

        codeConverters_ = new org.apache.yoko.orb.OB.CodeConverters(converters);

        if (converters != null) {
            if (codeConverters_.outputCharConverter != null) {
                charWriterRequired_ = codeConverters_.outputCharConverter
                        .writerRequired();
                charConversionRequired_ = codeConverters_.outputCharConverter
                        .conversionRequired();
            }

            if (codeConverters_.outputWcharConverter != null) {
                wCharWriterRequired_ = codeConverters_.outputWcharConverter
                        .writerRequired();
                wCharConversionRequired_ = codeConverters_.outputWcharConverter
                        .conversionRequired();
            }
        }
    }

    public org.apache.yoko.orb.OCI.Buffer _OB_buffer() {
        return buf_;
    }

    public int _OB_pos() {
        return buf_.pos_;
    }

    public void _OB_pos(int pos) {
        buf_.pos_ = pos;
    }

    public void _OB_align(int n) {
        if (buf_.pos_ % n != 0)
            addCapacity(0, n);
    }

    public void _OB_alignNext(int n) {
        alignNext_ = n;
    }

    public void _OB_writeEndian() {
        write_boolean(false); // false means big endian
    }

    public void _OB_beginValue(int tag, String[] ids, boolean chunked) {
        valueWriter().beginValue(tag, ids, null, chunked);
    }

    public void _OB_endValue() {
        valueWriter().endValue();
    }

    // Java only
    public void _OB_ORBInstance(org.apache.yoko.orb.OB.ORBInstance orbInstance) {
        orbInstance_ = orbInstance;
    }

    // Java only
    public org.apache.yoko.orb.OB.ORBInstance _OB_ORBInstance() {
        return orbInstance_;
    }

    // Java only
    public void _OB_invocationContext(java.lang.Object invocationContext) {
        invocationContext_ = invocationContext;
    }

    // Java only
    public java.lang.Object _OB_invocationContext() {
        return invocationContext_;
    }

    // Java only
    public void _OB_delegateContext(java.lang.Object delegateContext) {
        delegateContext_ = delegateContext;
    }

    // Java only
    public java.lang.Object _OB_delegateContext() {
        return delegateContext_;
    }

    @Override
    public void end_value() {
        _OB_endValue();
    }

    @Override
    public void start_value(String rep_id) {
        final int tag = 0x7fffff02;
        final String[] ids = { rep_id };
        _OB_beginValue(tag, ids, true);
    }
}