/** * Add <tt>amount</tt> empty space */ public final void increaseSize(final int amount) { check( amount ); pos += amount; }
@Override public final void write_short(final short value) { check(3,2); buffer[pos++] = (byte)((value >> 8) & 0xFF); buffer[pos++] = (byte)( value & 0xFF); index += 2; }
@Override public final void write_octet(final byte value) { check(1); index++; buffer[pos++] = value; }
@Override public final void write_boolean(final boolean value) { check(1); if( value ) { buffer[pos++] = 1; } else { buffer[pos++] = 0; } index++; }
@Override public final void write_longlong(final long value) { check(15,8); buffer[pos] = (byte)((value >>> 56) & 0xFF); buffer[pos+1] = (byte)((value >>> 48) & 0xFF); buffer[pos+2] = (byte)((value >>> 40) & 0xFF); buffer[pos+3] = (byte)((value >>> 32) & 0xFF); buffer[pos+4] = (byte)((value >>> 24) & 0xFF); buffer[pos+5] = (byte)((value >>> 16) & 0xFF); buffer[pos+6] = (byte)((value >>> 8) & 0xFF); buffer[pos+7] = (byte)(value & 0xFF); index += 8; pos += 8; }
@Override public final void write_boolean_array (final boolean[] value, final int offset, final int length) { if (value != null ) { //no alignment necessary check(length); for( int i = offset; i < offset+length; i++ ) { if( value[i] ) { buffer[pos++] = 1; } else { buffer[pos++] = 0; } } index += length; } }
@Override public final void write_octet_array( final byte[] value, final int offset, final int length) { if( value != null ) { check(length); System.arraycopy(value,offset,buffer,pos,length); index += length; pos += length; } }
@Override public final void write_longlong_array (final long[] value, final int offset, final int length) { //if nothing has to be written, return, and especially DON'T //ALIGN if( length == 0 ) { return; } check(7 + length*8,8); if( value != null ) { for( int i = offset; i < offset+length; i++ ) { buffer[pos] = (byte)((value[i] >>> 56) & 0xFF); buffer[pos+1] = (byte)((value[i] >>> 48) & 0xFF); buffer[pos+2] = (byte)((value[i] >>> 40) & 0xFF); buffer[pos+3] = (byte)((value[i] >>> 32) & 0xFF); buffer[pos+4] = (byte)((value[i] >>> 24) & 0xFF); buffer[pos+5] = (byte)((value[i] >>> 16) & 0xFF); buffer[pos+6] = (byte)((value[i] >>> 8) & 0xFF); buffer[pos+7] = (byte) (value[i] & 0xFF); pos += 8; } index += 8*length; } }
@Override public final void write_short_array (final short[] value, final int offset, final int length) { //if nothing has to be written, return, and especially DON'T //ALIGN if( length == 0 ) { return; } /* align to 2-byte boundary */ check(2*length + 3); final int remainder = 2 - (index % 2); if (remainder != 2) { index += remainder; pos+=remainder; } if( value != null ) { for( int i = offset; i < offset+length; i++ ) { buffer[pos++] = (byte)((value[i] >> 8) & 0xFF ); buffer[pos++] = (byte)( value[i] & 0xFF ); } index += 2*length; } }
/** * This version of check does both array length checking and * data type alignment. It is a convenience method. */ public final void check(final int i, final int align) { final int remainder = align - (index % align); check (i + remainder); if (remainder != align) { // Clear padding. Allowing for possible buffer end. final int blp = buffer.length - pos; final int topad = (blp <= 8 ? blp : 8); Arrays.fill(buffer, pos, pos + topad, (byte)0); index += remainder; pos += remainder; } }
@Override public final void write_double_array (final double[] value, final int offset, final int length) { //if nothing has to be written, return, and especially DON'T //ALIGN if( length == 0 ) { return; } /* align to 8 byte boundary */ check(7 + length*8, 8); if( value != null ) { for( int i = offset; i < offset+length; i++ ) { long d = Double.doubleToLongBits(value[i]); buffer[pos] = (byte)((d >>> 56) & 0xFF); buffer[pos+1] = (byte)((d >>> 48) & 0xFF); buffer[pos+2] = (byte)((d >>> 40) & 0xFF); buffer[pos+3] = (byte)((d >>> 32) & 0xFF); buffer[pos+4] = (byte)((d >>> 24) & 0xFF); buffer[pos+5] = (byte)((d >>> 16) & 0xFF); buffer[pos+6] = (byte)((d >>> 8) & 0xFF); buffer[pos+7] = (byte) (d & 0xFF); pos += 8; } index += 8*length; } }
@Override public final void write_long(final int value) { check(7,4); _write4int(buffer,pos,value); pos += 4; index += 4; }
@Override public final void write_float_array (final float[] value, final int offset, final int length) { //if nothing has to be written, return, and especially DON'T //ALIGN if( length == 0 ) { return; } /* align to 4 byte boundary */ check(3 + length*4,4); if( value != null ) { for( int i = offset; i < offset+length; i++ ) { _write4int(buffer,pos, Float.floatToIntBits( value[i] )); pos += 4; } index += 4*length; } }
/** * <code>write_char</code> writes a character to the output stream. If * codeset translation is active then it will use String and an encoding to * get the bytes. It can then do a test for whether to throw DATA_CONVERSION. * * @param c a <code>char</code> value */ @Override public final void write_char (final char c) { // According to 15.3.1.6 of CORBA 3.0 'a single instance of the char type // may only hold one octet of any multi-byte character encoding.' // Therefore we ensure that we are in the single byte range i.e. // less than 0xFF or \377. if (c > '\377') { throw new DATA_CONVERSION ("Char " + c + " out of range"); } check( 1 ); buffer[pos++] = (byte)c; index++; }
@Override public final void write_long_array (final int[] value, final int offset, final int length) { //if nothing has to be written, return, and especially DON'T //ALIGN if( length == 0 ) { return; } /* align to 4 byte boundary */ check(3 + length*4,4); final int remainder = 4 - (index % 4); if (remainder != 4) { index += remainder; pos+=remainder; } if( value != null ) { for( int i = offset; i < offset+length; i++ ) { _write4int(buffer,pos,value[i]); pos += 4; } index += 4*length; } }
@Override public final void write_wchar(final char c) { check(6); // maximum is UTF-16 handling non-BPM character with BOM // alignment/check must happen prior to calling. codeSetW.write_char( this, c, codeSetW.write_bom( useBOM ), true, giop_minor ); }
(byte)((value.signum() < 0 )? (b | 0xD) : (b | 0xC)); check(representation.length); System.arraycopy(representation,0,buffer,pos,representation.length); index += representation.length;
@Override public final void write_wchar_array (final char[] value, final int offset, final int length) { if( value == null ) { throw new MARSHAL("Null References"); } check( length * 3 ); for( int i = offset; i < offset+length; i++) { write_wchar( value[i] ); } }
@Override public final void write_char_array (final char[] value, final int offset, final int length) { if( value == null ) { throw new MARSHAL("Cannot marshall null array."); } else if ( offset + length > value.length || length < 0 || offset < 0 ) { throw new MARSHAL ("Cannot marshall as indices for array are out bounds."); } check( length ); for (int i=offset; i < length+offset; i++) { if (value[i] > '\377') { throw new DATA_CONVERSION ("Char " + value[i] + " out of range"); } buffer[pos++] = (byte)value[i]; } index+=length; }
@Override public void write_value(final java.io.Serializable value, final org.omg.CORBA.portable.BoxedValueHelper factory) { if (!write_special_value (value)) { write_previous_chunk_size(); check(7,4); getValueMap().put (value, Integer.valueOf(size())); if (((value instanceof org.omg.CORBA.portable.IDLEntity) || isSimpleString(value, factory))) { write_long (0x7fffff00 | chunkingFlag); } else { // repository id is required for RMI: types write_long (0x7fffff02 | chunkingFlag); final String repId = factory.get_id(); write_repository_id (repId); } start_chunk(); factory.write_value (this, value); end_chunk(); } }