org.apache.activemq.openwire.commands.MessageAck

Here are the examples of the java api class org.apache.activemq.openwire.commands.MessageAck taken from open source projects.

1. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(tightUnmarsalThrowable(wireFormat, dataIn, bs));
}

2. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(tightUnmarsalThrowable(wireFormat, dataIn, bs));
}

3. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(looseUnmarsalThrowable(wireFormat, dataIn));
}

4. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(looseUnmarsalThrowable(wireFormat, dataIn));
}

5. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(tightUnmarsalThrowable(wireFormat, dataIn, bs));
}

6. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(looseUnmarsalThrowable(wireFormat, dataIn));
}

7. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(looseUnmarsalThrowable(wireFormat, dataIn));
}

8. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(tightUnmarsalThrowable(wireFormat, dataIn, bs));
}

9. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(looseUnmarsalThrowable(wireFormat, dataIn));
}

10. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
    info.setPoisonCause(tightUnmarsalThrowable(wireFormat, dataIn, bs));
}

11. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
}

12. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
}

13. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
}

14. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
}

15. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
}

16. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
}

17. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
}

18. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
}

19. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
}

20. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     * 
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
}

21. MessageAckMarshaller#looseUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     *
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException {
    super.looseUnmarshal(wireFormat, o, dataIn);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setTransactionId((org.apache.activemq.openwire.commands.TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setConsumerId((org.apache.activemq.openwire.commands.ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((org.apache.activemq.openwire.commands.MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setLastMessageId((org.apache.activemq.openwire.commands.MessageId) looseUnmarsalNestedObject(wireFormat, dataIn));
    info.setMessageCount(dataIn.readInt());
}

22. MessageAckMarshaller#tightUnmarshal()

View license
/**
     * Un-marshal an object instance from the data input stream
     *
     * @param o
     *        the object to un-marshal
     * @param dataIn
     *        the data input stream to build the object from
     * @throws IOException
     */
@Override
public void tightUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
    super.tightUnmarshal(wireFormat, o, dataIn, bs);
    MessageAck info = (MessageAck) o;
    info.setDestination((OpenWireDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setTransactionId((org.apache.activemq.openwire.commands.TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setConsumerId((org.apache.activemq.openwire.commands.ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
    info.setAckType(dataIn.readByte());
    info.setFirstMessageId((org.apache.activemq.openwire.commands.MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setLastMessageId((org.apache.activemq.openwire.commands.MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs));
    info.setMessageCount(dataIn.readInt());
}

23. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
}

24. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    return rc + 5;
}

25. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
}

26. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
    looseMarshalThrowable(wireFormat, info.getPoisonCause(), dataOut);
}

27. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
}

28. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    rc += tightMarshalThrowable1(wireFormat, info.getPoisonCause(), bs);
    return rc + 5;
}

29. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
    tightMarshalThrowable2(wireFormat, info.getPoisonCause(), dataOut, bs);
}

30. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    return rc + 5;
}

31. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    rc += tightMarshalThrowable1(wireFormat, info.getPoisonCause(), bs);
    return rc + 5;
}

32. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
    tightMarshalThrowable2(wireFormat, info.getPoisonCause(), dataOut, bs);
}

33. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
    looseMarshalThrowable(wireFormat, info.getPoisonCause(), dataOut);
}

34. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    rc += tightMarshalThrowable1(wireFormat, info.getPoisonCause(), bs);
    return rc + 5;
}

35. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
    tightMarshalThrowable2(wireFormat, info.getPoisonCause(), dataOut, bs);
}

36. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
    looseMarshalThrowable(wireFormat, info.getPoisonCause(), dataOut);
}

37. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    return rc + 5;
}

38. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    return rc + 5;
}

39. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     *
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
}

40. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
}

41. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    rc += tightMarshalThrowable1(wireFormat, info.getPoisonCause(), bs);
    return rc + 5;
}

42. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
    tightMarshalThrowable2(wireFormat, info.getPoisonCause(), dataOut, bs);
}

43. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
    looseMarshalThrowable(wireFormat, info.getPoisonCause(), dataOut);
}

44. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    rc += tightMarshalThrowable1(wireFormat, info.getPoisonCause(), bs);
    return rc + 5;
}

45. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
    tightMarshalThrowable2(wireFormat, info.getPoisonCause(), dataOut, bs);
}

46. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
    looseMarshalThrowable(wireFormat, info.getPoisonCause(), dataOut);
}

47. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    return rc + 5;
}

48. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
}

49. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
}

50. MessageAckMarshaller#tightMarshal1()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException {
    MessageAck info = (MessageAck) o;
    int rc = super.tightMarshal1(wireFormat, o, bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getDestination(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getTransactionId(), bs);
    rc += tightMarshalCachedObject1(wireFormat, info.getConsumerId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getFirstMessageId(), bs);
    rc += tightMarshalNestedObject1(wireFormat, info.getLastMessageId(), bs);
    return rc + 5;
}

51. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
}

52. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
}

53. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
}

54. MessageAckMarshaller#looseMarshal()

View license
/**
     * Write the booleans that this object uses to a BooleanStream
     */
@Override
public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException {
    MessageAck info = (MessageAck) o;
    super.looseMarshal(wireFormat, o, dataOut);
    looseMarshalCachedObject(wireFormat, info.getDestination(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getTransactionId(), dataOut);
    looseMarshalCachedObject(wireFormat, info.getConsumerId(), dataOut);
    dataOut.writeByte(info.getAckType());
    looseMarshalNestedObject(wireFormat, info.getFirstMessageId(), dataOut);
    looseMarshalNestedObject(wireFormat, info.getLastMessageId(), dataOut);
    dataOut.writeInt(info.getMessageCount());
}

55. MessageAckMarshaller#tightMarshal2()

View license
/**
     * Write a object instance to data output stream
     * 
     * @param o
     *        the instance to be marshaled
     * @param dataOut
     *        the output stream
     * @throws IOException
     *         thrown if an error occurs
     */
@Override
public void tightMarshal2(OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs) throws IOException {
    super.tightMarshal2(wireFormat, o, dataOut, bs);
    MessageAck info = (MessageAck) o;
    tightMarshalCachedObject2(wireFormat, info.getDestination(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
    tightMarshalCachedObject2(wireFormat, info.getConsumerId(), dataOut, bs);
    dataOut.writeByte(info.getAckType());
    tightMarshalNestedObject2(wireFormat, info.getFirstMessageId(), dataOut, bs);
    tightMarshalNestedObject2(wireFormat, info.getLastMessageId(), dataOut, bs);
    dataOut.writeInt(info.getMessageCount());
}

56. MessageCompressionTest#receiveOpenWireTextMessage()

View license
public OpenWireTextMessage receiveOpenWireTextMessage() throws Exception {
    connect();
    assertTrue(awaitConnected(10, TimeUnit.SECONDS));
    OpenWireConnection connection = new OpenWireConnection();
    ConnectionInfo connectionInfo = connection.createConnectionInfo();
    connectionInfo.setClientId(name.getMethodName());
    assertTrue(request(connectionInfo, 10, TimeUnit.SECONDS));
    assertEquals(1, brokerService.getAdminView().getCurrentConnectionsCount());
    OpenWireSession sessionId = connection.createOpenWireSession();
    assertTrue(request(sessionId.createSessionInfo(), 10, TimeUnit.SECONDS));
    assertEquals(1, getProxyToQueue(getOpenWireQueue().getPhysicalName()).getQueueSize());
    OpenWireConsumer consumerId = sessionId.createOpenWireConsumer();
    ConsumerInfo consumerInfo = consumerId.createConsumerInfo(getOpenWireQueue());
    consumerInfo.setDispatchAsync(false);
    consumerInfo.setPrefetchSize(1);
    assertTrue(request(consumerInfo, 10, TimeUnit.SECONDS));
    assertEquals(1, brokerService.getAdminView().getQueueSubscribers().length);
    assertTrue("Should have received a message", Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisified() throws Exception {
            return messages.size() == 1;
        }
    }));
    Message incoming = messages.poll();
    assertTrue(incoming instanceof OpenWireTextMessage);
    OpenWireTextMessage received = (OpenWireTextMessage) incoming;
    MessageAck ack = new MessageAck();
    ack.setAckType(MessageAck.STANDARD_ACK_TYPE);
    ack.setConsumerId(consumerId.getConsumerId());
    ack.setDestination(getOpenWireQueue());
    ack.setLastMessageId(received.getMessageId());
    ack.setMessageCount(1);
    assertTrue(request(ack, 60, TimeUnit.SECONDS));
    assertEquals(0, getProxyToQueue(getOpenWireQueue().getPhysicalName()).getQueueSize());
    assertTrue(request(connection.createRemoveInfo(), 10, TimeUnit.SECONDS));
    assertEquals(0, brokerService.getAdminView().getCurrentConnectionsCount());
    disconnect();
    return received;
}

57. MessageCompressionTest#receiveOpenWireBytesMessage()

View license
public OpenWireBytesMessage receiveOpenWireBytesMessage() throws Exception {
    connect();
    assertTrue(awaitConnected(10, TimeUnit.SECONDS));
    OpenWireConnection connection = new OpenWireConnection();
    ConnectionInfo connectionInfo = connection.createConnectionInfo();
    connectionInfo.setClientId(name.getMethodName());
    assertTrue(request(connectionInfo, 10, TimeUnit.SECONDS));
    assertEquals(1, brokerService.getAdminView().getCurrentConnectionsCount());
    OpenWireSession sessionId = connection.createOpenWireSession();
    assertTrue(request(sessionId.createSessionInfo(), 10, TimeUnit.SECONDS));
    assertEquals(1, getProxyToQueue(getOpenWireQueue().getPhysicalName()).getQueueSize());
    OpenWireConsumer consumerId = sessionId.createOpenWireConsumer();
    ConsumerInfo consumerInfo = consumerId.createConsumerInfo(getOpenWireQueue());
    consumerInfo.setDispatchAsync(false);
    consumerInfo.setPrefetchSize(1);
    assertTrue(request(consumerInfo, 10, TimeUnit.SECONDS));
    assertEquals(1, brokerService.getAdminView().getQueueSubscribers().length);
    assertTrue("Should have received a message", Wait.waitFor(new Wait.Condition() {

        @Override
        public boolean isSatisified() throws Exception {
            return messages.size() == 1;
        }
    }));
    Message incoming = messages.poll();
    assertTrue(incoming instanceof OpenWireBytesMessage);
    OpenWireBytesMessage received = (OpenWireBytesMessage) incoming;
    MessageAck ack = new MessageAck();
    ack.setAckType(MessageAck.STANDARD_ACK_TYPE);
    ack.setConsumerId(consumerId.getConsumerId());
    ack.setDestination(getOpenWireQueue());
    ack.setLastMessageId(received.getMessageId());
    ack.setMessageCount(1);
    assertTrue(request(ack, 60, TimeUnit.SECONDS));
    assertEquals(0, getProxyToQueue(getOpenWireQueue().getPhysicalName()).getQueueSize());
    assertTrue(request(connection.createRemoveInfo(), 10, TimeUnit.SECONDS));
    assertEquals(0, brokerService.getAdminView().getCurrentConnectionsCount());
    disconnect();
    return received;
}