@Override public void setObjectProperty(String name, Object value) throws JMSException { initializeWriting(); super.setObjectProperty(name, value); }
/** * Writes a byte array to the bytes message stream. * * @param value the byte array to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeBytes(byte[] value) throws JMSException { initializeWriting(); try { this.dataOut.write(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes a <code>byte</code> to the bytes message stream as a 1-byte * value. * * @param value the <code>byte</code> value to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeByte(byte value) throws JMSException { initializeWriting(); try { this.dataOut.writeByte(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes a <code>char</code> to the bytes message stream as a 2-byte * value, high byte first. * * @param value the <code>char</code> value to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeChar(char value) throws JMSException { initializeWriting(); try { this.dataOut.writeChar(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes a <code>long</code> to the bytes message stream as eight bytes, * high byte first. * * @param value the <code>long</code> to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeLong(long value) throws JMSException { initializeWriting(); try { this.dataOut.writeLong(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes a portion of a byte array to the bytes message stream. * * @param value the byte array value to be written * @param offset the initial offset within the byte array * @param length the number of bytes to use * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeBytes(byte[] value, int offset, int length) throws JMSException { initializeWriting(); try { this.dataOut.write(value, offset, length); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes a <code>short</code> to the bytes message stream as two bytes, * high byte first. * * @param value the <code>short</code> to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeShort(short value) throws JMSException { initializeWriting(); try { this.dataOut.writeShort(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes an <code>int</code> to the bytes message stream as four bytes, * high byte first. * * @param value the <code>int</code> to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeInt(int value) throws JMSException { initializeWriting(); try { this.dataOut.writeInt(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes a <code>boolean</code> to the bytes message stream as a 1-byte * value. The value <code>true</code> is written as the value * <code>(byte)1</code>; the value <code>false</code> is written as the * value <code>(byte)0</code>. * * @param value the <code>boolean</code> value to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeBoolean(boolean value) throws JMSException { initializeWriting(); try { this.dataOut.writeBoolean(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Converts the <code>double</code> argument to a <code>long</code> * using the <code>doubleToLongBits</code> method in class * <code>Double</code>, and then writes that <code>long</code> value to * the bytes message stream as an 8-byte quantity, high byte first. * * @param value the <code>double</code> value to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeDouble(double value) throws JMSException { initializeWriting(); try { this.dataOut.writeDouble(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes a string to the bytes message stream using UTF-8 encoding in a * machine-independent manner. * <P> * For more information on the UTF-8 format, see "File System Safe UCS * Transformation Format (FSS_UTF)", X/Open Preliminary Specification, * X/Open Company Ltd., Document Number: P316. This information also appears * in ISO/IEC 10646, Annex P. * * @param value the <code>String</code> value to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeUTF(String value) throws JMSException { initializeWriting(); try { this.dataOut.writeUTF(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Converts the <code>float</code> argument to an <code>int</code> using * the <code>floatToIntBits</code> method in class <code>Float</code>, * and then writes that <code>int</code> value to the bytes message stream * as a 4-byte quantity, high byte first. * * @param value the <code>float</code> value to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeFloat(float value) throws JMSException { initializeWriting(); try { this.dataOut.writeFloat(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
throw new NullPointerException(); initializeWriting(); if (value instanceof Boolean) { writeBoolean(((Boolean)value).booleanValue());
@Override public void setObjectProperty(String name, Object value) throws JMSException { initializeWriting(); super.setObjectProperty(name, value); }
@Override public void setObjectProperty(String name, Object value) throws JMSException { initializeWriting(); super.setObjectProperty(name, value); }
@Override public void setObjectProperty(String name, Object value) throws JMSException { initializeWriting(); super.setObjectProperty(name, value); }
public void setObjectProperty(String name, Object value) throws JMSException { initializeWriting(); super.setObjectProperty(name, value); }
/** * Writes a byte array to the bytes message stream. * * @param value the byte array to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeBytes(byte[] value) throws JMSException { initializeWriting(); try { this.dataOut.write(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes a <code>byte</code> to the bytes message stream as a 1-byte * value. * * @param value the <code>byte</code> value to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeByte(byte value) throws JMSException { initializeWriting(); try { this.dataOut.writeByte(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }
/** * Writes an <code>int</code> to the bytes message stream as four bytes, * high byte first. * * @param value the <code>int</code> to be written * @throws JMSException if the JMS provider fails to write the message due * to some internal error. * @throws MessageNotWriteableException if the message is in read-only mode. */ @Override public void writeInt(int value) throws JMSException { initializeWriting(); try { this.dataOut.writeInt(value); } catch (IOException ioe) { throw JMSExceptionSupport.create(ioe); } }