/**
* 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
*/
public void tightUnmarshal(
OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
super.tightUnmarshal(wireFormat, o, dataIn, bs);
ConnectionControl info = (ConnectionControl) o;
info.setClose(bs.readBoolean());
info.setExit(bs.readBoolean());
info.setFaultTolerant(bs.readBoolean());
info.setResume(bs.readBoolean());
info.setSuspend(bs.readBoolean());
}
/**
* 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
*/
public void tightUnmarshal(
OpenWireFormat wireFormat, Object o, DataInput dataIn, BooleanStream bs) throws IOException {
super.tightUnmarshal(wireFormat, o, dataIn, bs);
ConsumerInfo info = (ConsumerInfo) o;
info.setConsumerId(
(org.apache.activemq.command.ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
info.setBrowser(bs.readBoolean());
info.setDestination(
(org.apache.activemq.command.ActiveMQDestination)
tightUnmarsalCachedObject(wireFormat, dataIn, bs));
info.setPrefetchSize(dataIn.readInt());
info.setMaximumPendingMessageLimit(dataIn.readInt());
info.setDispatchAsync(bs.readBoolean());
info.setSelector(tightUnmarshalString(dataIn, bs));
info.setSubscriptionName(tightUnmarshalString(dataIn, bs));
info.setNoLocal(bs.readBoolean());
info.setExclusive(bs.readBoolean());
info.setRetroactive(bs.readBoolean());
info.setPriority(dataIn.readByte());
if (bs.readBoolean()) {
short size = dataIn.readShort();
org.apache.activemq.command.BrokerId value[] = new org.apache.activemq.command.BrokerId[size];
for (int i = 0; i < size; i++) {
value[i] =
(org.apache.activemq.command.BrokerId)
tightUnmarsalNestedObject(wireFormat, dataIn, bs);
}
info.setBrokerPath(value);
} else {
info.setBrokerPath(null);
}
info.setAdditionalPredicate(
(org.apache.activemq.filter.BooleanExpression)
tightUnmarsalNestedObject(wireFormat, dataIn, bs));
info.setNetworkSubscription(bs.readBoolean());
info.setOptimizedAcknowledge(bs.readBoolean());
info.setNoRangeAcks(bs.readBoolean());
if (bs.readBoolean()) {
short size = dataIn.readShort();
org.apache.activemq.command.ConsumerId value[] =
new org.apache.activemq.command.ConsumerId[size];
for (int i = 0; i < size; i++) {
value[i] =
(org.apache.activemq.command.ConsumerId)
tightUnmarsalNestedObject(wireFormat, dataIn, bs);
}
info.setNetworkConsumerPath(value);
} else {
info.setNetworkConsumerPath(null);
}
}
/**
* 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
*/
public void tightMarshal2(
OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs)
throws IOException {
super.tightMarshal2(wireFormat, o, dataOut, bs);
ConnectionControl info = (ConnectionControl) o;
bs.readBoolean();
bs.readBoolean();
bs.readBoolean();
bs.readBoolean();
bs.readBoolean();
}
protected void tightMarshalString2(String value, DataOutput dataOut, BooleanStream bs)
throws IOException {
if (bs.readBoolean()) {
// If we verified it only holds ascii values
if (bs.readBoolean()) {
dataOut.writeShort(value.length());
dataOut.writeBytes(value);
} else {
dataOut.writeUTF(value);
}
}
}
public void tightMarshalLong2(
OpenWireFormat wireFormat, long o, DataOutput dataOut, BooleanStream bs) throws IOException {
if (bs.readBoolean()) {
if (bs.readBoolean()) {
dataOut.writeLong(o);
} else {
dataOut.writeInt((int) o);
}
} else {
if (bs.readBoolean()) {
dataOut.writeShort((int) o);
}
}
}
protected void tightMarshalByteArray2(byte[] data, DataOutput dataOut, BooleanStream bs)
throws IOException {
if (bs.readBoolean()) {
dataOut.writeInt(data.length);
dataOut.write(data);
}
}
protected void tightMarshalByteSequence2(ByteSequence data, DataOutput dataOut, BooleanStream bs)
throws IOException {
if (bs.readBoolean()) {
dataOut.writeInt(data.getLength());
dataOut.write(data.getData(), data.getOffset(), data.getLength());
}
}
public long tightUnmarshalLong(OpenWireFormat wireFormat, DataInput dataIn, BooleanStream bs)
throws IOException {
if (bs.readBoolean()) {
if (bs.readBoolean()) {
return dataIn.readLong();
} else {
return toLong(dataIn.readInt());
}
} else {
if (bs.readBoolean()) {
return toLong(dataIn.readShort());
} else {
return 0;
}
}
}
@SuppressWarnings("deprecation")
protected String tightUnmarshalString(DataInput dataIn, BooleanStream bs) throws IOException {
if (bs.readBoolean()) {
if (bs.readBoolean()) {
int size = dataIn.readShort();
byte data[] = new byte[size];
dataIn.readFully(data);
// Yes deprecated, but we know what we are doing.
// This allows us to create a String from a ASCII byte array. (no UTF-8 decoding)
return new String(data, 0);
} else {
return dataIn.readUTF();
}
} else {
return null;
}
}
protected byte[] tightUnmarshalByteArray(DataInput dataIn, BooleanStream bs) throws IOException {
byte rc[] = null;
if (bs.readBoolean()) {
int size = dataIn.readInt();
rc = new byte[size];
dataIn.readFully(rc);
}
return rc;
}
protected void tightMarshalObjectArray2(
OpenWireFormat wireFormat, DataStructure[] objects, DataOutput dataOut, BooleanStream bs)
throws IOException {
if (bs.readBoolean()) {
dataOut.writeShort(objects.length);
for (int i = 0; i < objects.length; i++) {
tightMarshalNestedObject2(wireFormat, objects[i], dataOut, bs);
}
}
}
protected ByteSequence tightUnmarshalByteSequence(DataInput dataIn, BooleanStream bs)
throws IOException {
ByteSequence rc = null;
if (bs.readBoolean()) {
int size = dataIn.readInt();
byte[] t = new byte[size];
dataIn.readFully(t);
return new ByteSequence(t, 0, size);
}
return rc;
}
/**
* 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
*/
public void tightMarshal2(
OpenWireFormat wireFormat, Object o, DataOutput dataOut, BooleanStream bs)
throws IOException {
super.tightMarshal2(wireFormat, o, dataOut, bs);
ConsumerInfo info = (ConsumerInfo) o;
tightMarshalCachedObject2(wireFormat, (DataStructure) info.getConsumerId(), dataOut, bs);
bs.readBoolean();
tightMarshalCachedObject2(wireFormat, (DataStructure) info.getDestination(), dataOut, bs);
dataOut.writeInt(info.getPrefetchSize());
dataOut.writeInt(info.getMaximumPendingMessageLimit());
bs.readBoolean();
tightMarshalString2(info.getSelector(), dataOut, bs);
tightMarshalString2(info.getSubscriptionName(), dataOut, bs);
bs.readBoolean();
bs.readBoolean();
bs.readBoolean();
dataOut.writeByte(info.getPriority());
tightMarshalObjectArray2(wireFormat, info.getBrokerPath(), dataOut, bs);
tightMarshalNestedObject2(
wireFormat, (DataStructure) info.getAdditionalPredicate(), dataOut, bs);
bs.readBoolean();
bs.readBoolean();
bs.readBoolean();
tightMarshalObjectArray2(wireFormat, info.getNetworkConsumerPath(), dataOut, bs);
}
protected void tightMarshalCachedObject2(
OpenWireFormat wireFormat, DataStructure o, DataOutput dataOut, BooleanStream bs)
throws IOException {
if (wireFormat.isCacheEnabled()) {
Short index = wireFormat.getMarshallCacheIndex(o);
if (bs.readBoolean()) {
dataOut.writeShort(index.shortValue());
wireFormat.tightMarshalNestedObject2(o, dataOut, bs);
} else {
dataOut.writeShort(index.shortValue());
}
} else {
wireFormat.tightMarshalNestedObject2(o, dataOut, bs);
}
}
protected DataStructure tightUnmarsalCachedObject(
OpenWireFormat wireFormat, DataInput dataIn, BooleanStream bs) throws IOException {
if (wireFormat.isCacheEnabled()) {
if (bs.readBoolean()) {
short index = dataIn.readShort();
DataStructure object = wireFormat.tightUnmarshalNestedObject(dataIn, bs);
wireFormat.setInUnmarshallCache(index, object);
return object;
} else {
short index = dataIn.readShort();
return wireFormat.getFromUnmarshallCache(index);
}
} else {
return wireFormat.tightUnmarshalNestedObject(dataIn, bs);
}
}
protected Throwable tightUnmarsalThrowable(
OpenWireFormat wireFormat, DataInput dataIn, BooleanStream bs) throws IOException {
if (bs.readBoolean()) {
String clazz = tightUnmarshalString(dataIn, bs);
String message = tightUnmarshalString(dataIn, bs);
Throwable o = createThrowable(clazz, message);
if (wireFormat.isStackTraceEnabled()) {
if (STACK_TRACE_ELEMENT_CONSTRUCTOR != null) {
StackTraceElement ss[] = new StackTraceElement[dataIn.readShort()];
for (int i = 0; i < ss.length; i++) {
try {
ss[i] =
(StackTraceElement)
STACK_TRACE_ELEMENT_CONSTRUCTOR.newInstance(
new Object[] {
tightUnmarshalString(dataIn, bs),
tightUnmarshalString(dataIn, bs),
tightUnmarshalString(dataIn, bs),
Integer.valueOf(dataIn.readInt())
});
} catch (IOException e) {
throw e;
} catch (Throwable e) {
}
}
o.setStackTrace(ss);
} else {
short size = dataIn.readShort();
for (int i = 0; i < size; i++) {
tightUnmarshalString(dataIn, bs);
tightUnmarshalString(dataIn, bs);
tightUnmarshalString(dataIn, bs);
dataIn.readInt();
}
}
o.initCause(tightUnmarsalThrowable(wireFormat, dataIn, bs));
}
return o;
} else {
return null;
}
}
protected void tightMarshalThrowable2(
OpenWireFormat wireFormat, Throwable o, DataOutput dataOut, BooleanStream bs)
throws IOException {
if (bs.readBoolean()) {
tightMarshalString2(o.getClass().getName(), dataOut, bs);
tightMarshalString2(o.getMessage(), dataOut, bs);
if (wireFormat.isStackTraceEnabled()) {
StackTraceElement[] stackTrace = o.getStackTrace();
dataOut.writeShort(stackTrace.length);
for (int i = 0; i < stackTrace.length; i++) {
StackTraceElement element = stackTrace[i];
tightMarshalString2(element.getClassName(), dataOut, bs);
tightMarshalString2(element.getMethodName(), dataOut, bs);
tightMarshalString2(element.getFileName(), dataOut, bs);
dataOut.writeInt(element.getLineNumber());
}
tightMarshalThrowable2(wireFormat, o.getCause(), dataOut, bs);
}
}
}
/**
