Return-Path: X-Original-To: apmail-activemq-commits-archive@www.apache.org Delivered-To: apmail-activemq-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 730F0DD4E for ; Fri, 17 May 2013 16:28:19 +0000 (UTC) Received: (qmail 64982 invoked by uid 500); 17 May 2013 16:28:19 -0000 Delivered-To: apmail-activemq-commits-archive@activemq.apache.org Received: (qmail 64939 invoked by uid 500); 17 May 2013 16:28:19 -0000 Mailing-List: contact commits-help@activemq.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@activemq.apache.org Delivered-To: mailing list commits@activemq.apache.org Received: (qmail 64931 invoked by uid 99); 17 May 2013 16:28:19 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 17 May 2013 16:28:19 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 17 May 2013 16:28:07 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id A2CA12388A2C; Fri, 17 May 2013 16:27:44 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1483902 [4/5] - in /activemq/trunk: activemq-client/ activemq-client/src/main/java/org/apache/activemq/command/ activemq-client/src/main/java/org/apache/activemq/openwire/v10/ activemq-client/src/main/java/org/apache/activemq/openwire/v8/ ... Date: Fri, 17 May 2013 16:27:38 -0000 To: commits@activemq.apache.org From: dejanb@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20130517162744.A2CA12388A2C@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessageIdMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessageIdMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessageIdMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessageIdMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,139 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for MessageIdMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class MessageIdMarshaller extends BaseDataStreamMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return MessageId.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new MessageId(); + } + + /** + * 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); + + MessageId info = (MessageId)o; + info.setProducerId((org.apache.activemq.command.ProducerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setProducerSequenceId(tightUnmarshalLong(wireFormat, dataIn, bs)); + info.setBrokerSequenceId(tightUnmarshalLong(wireFormat, dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + MessageId info = (MessageId)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getProducerId(), bs); + rc+=tightMarshalLong1(wireFormat, info.getProducerSequenceId(), bs); + rc+=tightMarshalLong1(wireFormat, info.getBrokerSequenceId(), bs); + + return rc + 0; + } + + /** + * 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); + + MessageId info = (MessageId)o; + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getProducerId(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getProducerSequenceId(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getBrokerSequenceId(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + MessageId info = (MessageId)o; + info.setProducerId((org.apache.activemq.command.ProducerId) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setProducerSequenceId(looseUnmarshalLong(wireFormat, dataIn)); + info.setBrokerSequenceId(looseUnmarshalLong(wireFormat, dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + MessageId info = (MessageId)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getProducerId(), dataOut); + looseMarshalLong(wireFormat, info.getProducerSequenceId(), dataOut); + looseMarshalLong(wireFormat, info.getBrokerSequenceId(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessageMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessageMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessageMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessageMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,311 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for MessageMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public abstract class MessageMarshaller extends BaseCommandMarshaller { + + /** + * 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); + + Message info = (Message)o; + + info.beforeUnmarshall(wireFormat); + + info.setProducerId((org.apache.activemq.command.ProducerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setDestination((org.apache.activemq.command.ActiveMQDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setTransactionId((org.apache.activemq.command.TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setOriginalDestination((org.apache.activemq.command.ActiveMQDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setMessageId((org.apache.activemq.command.MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs)); + info.setOriginalTransactionId((org.apache.activemq.command.TransactionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setGroupID(tightUnmarshalString(dataIn, bs)); + info.setGroupSequence(dataIn.readInt()); + info.setCorrelationId(tightUnmarshalString(dataIn, bs)); + info.setPersistent(bs.readBoolean()); + info.setExpiration(tightUnmarshalLong(wireFormat, dataIn, bs)); + info.setPriority(dataIn.readByte()); + info.setReplyTo((org.apache.activemq.command.ActiveMQDestination) tightUnmarsalNestedObject(wireFormat, dataIn, bs)); + info.setTimestamp(tightUnmarshalLong(wireFormat, dataIn, bs)); + info.setType(tightUnmarshalString(dataIn, bs)); + info.setContent(tightUnmarshalByteSequence(dataIn, bs)); + info.setMarshalledProperties(tightUnmarshalByteSequence(dataIn, bs)); + info.setDataStructure((org.apache.activemq.command.DataStructure) tightUnmarsalNestedObject(wireFormat, dataIn, bs)); + info.setTargetConsumerId((org.apache.activemq.command.ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setCompressed(bs.readBoolean()); + info.setRedeliveryCounter(dataIn.readInt()); + + 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.setArrival(tightUnmarshalLong(wireFormat, dataIn, bs)); + info.setUserID(tightUnmarshalString(dataIn, bs)); + info.setRecievedByDFBridge(bs.readBoolean()); + info.setDroppable(bs.readBoolean()); + + 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.setCluster(value); + } + else { + info.setCluster(null); + } + info.setBrokerInTime(tightUnmarshalLong(wireFormat, dataIn, bs)); + info.setBrokerOutTime(tightUnmarshalLong(wireFormat, dataIn, bs)); + + info.afterUnmarshall(wireFormat); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + Message info = (Message)o; + + info.beforeMarshall(wireFormat); + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getProducerId(), bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getDestination(), bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getTransactionId(), bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getOriginalDestination(), bs); + rc += tightMarshalNestedObject1(wireFormat, (DataStructure)info.getMessageId(), bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getOriginalTransactionId(), bs); + rc += tightMarshalString1(info.getGroupID(), bs); + rc += tightMarshalString1(info.getCorrelationId(), bs); + bs.writeBoolean(info.isPersistent()); + rc+=tightMarshalLong1(wireFormat, info.getExpiration(), bs); + rc += tightMarshalNestedObject1(wireFormat, (DataStructure)info.getReplyTo(), bs); + rc+=tightMarshalLong1(wireFormat, info.getTimestamp(), bs); + rc += tightMarshalString1(info.getType(), bs); + rc += tightMarshalByteSequence1(info.getContent(), bs); + rc += tightMarshalByteSequence1(info.getMarshalledProperties(), bs); + rc += tightMarshalNestedObject1(wireFormat, (DataStructure)info.getDataStructure(), bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getTargetConsumerId(), bs); + bs.writeBoolean(info.isCompressed()); + rc += tightMarshalObjectArray1(wireFormat, info.getBrokerPath(), bs); + rc+=tightMarshalLong1(wireFormat, info.getArrival(), bs); + rc += tightMarshalString1(info.getUserID(), bs); + bs.writeBoolean(info.isRecievedByDFBridge()); + bs.writeBoolean(info.isDroppable()); + rc += tightMarshalObjectArray1(wireFormat, info.getCluster(), bs); + rc+=tightMarshalLong1(wireFormat, info.getBrokerInTime(), bs); + rc+=tightMarshalLong1(wireFormat, info.getBrokerOutTime(), bs); + + return rc + 9; + } + + /** + * 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); + + Message info = (Message)o; + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getProducerId(), dataOut, bs); + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getDestination(), dataOut, bs); + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getTransactionId(), dataOut, bs); + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getOriginalDestination(), dataOut, bs); + tightMarshalNestedObject2(wireFormat, (DataStructure)info.getMessageId(), dataOut, bs); + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getOriginalTransactionId(), dataOut, bs); + tightMarshalString2(info.getGroupID(), dataOut, bs); + dataOut.writeInt(info.getGroupSequence()); + tightMarshalString2(info.getCorrelationId(), dataOut, bs); + bs.readBoolean(); + tightMarshalLong2(wireFormat, info.getExpiration(), dataOut, bs); + dataOut.writeByte(info.getPriority()); + tightMarshalNestedObject2(wireFormat, (DataStructure)info.getReplyTo(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getTimestamp(), dataOut, bs); + tightMarshalString2(info.getType(), dataOut, bs); + tightMarshalByteSequence2(info.getContent(), dataOut, bs); + tightMarshalByteSequence2(info.getMarshalledProperties(), dataOut, bs); + tightMarshalNestedObject2(wireFormat, (DataStructure)info.getDataStructure(), dataOut, bs); + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getTargetConsumerId(), dataOut, bs); + bs.readBoolean(); + dataOut.writeInt(info.getRedeliveryCounter()); + tightMarshalObjectArray2(wireFormat, info.getBrokerPath(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getArrival(), dataOut, bs); + tightMarshalString2(info.getUserID(), dataOut, bs); + bs.readBoolean(); + bs.readBoolean(); + tightMarshalObjectArray2(wireFormat, info.getCluster(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getBrokerInTime(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getBrokerOutTime(), dataOut, bs); + + info.afterMarshall(wireFormat); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + Message info = (Message)o; + + info.beforeUnmarshall(wireFormat); + + info.setProducerId((org.apache.activemq.command.ProducerId) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setDestination((org.apache.activemq.command.ActiveMQDestination) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setTransactionId((org.apache.activemq.command.TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setOriginalDestination((org.apache.activemq.command.ActiveMQDestination) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setMessageId((org.apache.activemq.command.MessageId) looseUnmarsalNestedObject(wireFormat, dataIn)); + info.setOriginalTransactionId((org.apache.activemq.command.TransactionId) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setGroupID(looseUnmarshalString(dataIn)); + info.setGroupSequence(dataIn.readInt()); + info.setCorrelationId(looseUnmarshalString(dataIn)); + info.setPersistent(dataIn.readBoolean()); + info.setExpiration(looseUnmarshalLong(wireFormat, dataIn)); + info.setPriority(dataIn.readByte()); + info.setReplyTo((org.apache.activemq.command.ActiveMQDestination) looseUnmarsalNestedObject(wireFormat, dataIn)); + info.setTimestamp(looseUnmarshalLong(wireFormat, dataIn)); + info.setType(looseUnmarshalString(dataIn)); + info.setContent(looseUnmarshalByteSequence(dataIn)); + info.setMarshalledProperties(looseUnmarshalByteSequence(dataIn)); + info.setDataStructure((org.apache.activemq.command.DataStructure) looseUnmarsalNestedObject(wireFormat, dataIn)); + info.setTargetConsumerId((org.apache.activemq.command.ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setCompressed(dataIn.readBoolean()); + info.setRedeliveryCounter(dataIn.readInt()); + + if (dataIn.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) looseUnmarsalNestedObject(wireFormat,dataIn); + } + info.setBrokerPath(value); + } + else { + info.setBrokerPath(null); + } + info.setArrival(looseUnmarshalLong(wireFormat, dataIn)); + info.setUserID(looseUnmarshalString(dataIn)); + info.setRecievedByDFBridge(dataIn.readBoolean()); + info.setDroppable(dataIn.readBoolean()); + + if (dataIn.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) looseUnmarsalNestedObject(wireFormat,dataIn); + } + info.setCluster(value); + } + else { + info.setCluster(null); + } + info.setBrokerInTime(looseUnmarshalLong(wireFormat, dataIn)); + info.setBrokerOutTime(looseUnmarshalLong(wireFormat, dataIn)); + + info.afterUnmarshall(wireFormat); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + Message info = (Message)o; + + info.beforeMarshall(wireFormat); + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getProducerId(), dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getDestination(), dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getTransactionId(), dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getOriginalDestination(), dataOut); + looseMarshalNestedObject(wireFormat, (DataStructure)info.getMessageId(), dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getOriginalTransactionId(), dataOut); + looseMarshalString(info.getGroupID(), dataOut); + dataOut.writeInt(info.getGroupSequence()); + looseMarshalString(info.getCorrelationId(), dataOut); + dataOut.writeBoolean(info.isPersistent()); + looseMarshalLong(wireFormat, info.getExpiration(), dataOut); + dataOut.writeByte(info.getPriority()); + looseMarshalNestedObject(wireFormat, (DataStructure)info.getReplyTo(), dataOut); + looseMarshalLong(wireFormat, info.getTimestamp(), dataOut); + looseMarshalString(info.getType(), dataOut); + looseMarshalByteSequence(wireFormat, info.getContent(), dataOut); + looseMarshalByteSequence(wireFormat, info.getMarshalledProperties(), dataOut); + looseMarshalNestedObject(wireFormat, (DataStructure)info.getDataStructure(), dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getTargetConsumerId(), dataOut); + dataOut.writeBoolean(info.isCompressed()); + dataOut.writeInt(info.getRedeliveryCounter()); + looseMarshalObjectArray(wireFormat, info.getBrokerPath(), dataOut); + looseMarshalLong(wireFormat, info.getArrival(), dataOut); + looseMarshalString(info.getUserID(), dataOut); + dataOut.writeBoolean(info.isRecievedByDFBridge()); + dataOut.writeBoolean(info.isDroppable()); + looseMarshalObjectArray(wireFormat, info.getCluster(), dataOut); + looseMarshalLong(wireFormat, info.getBrokerInTime(), dataOut); + looseMarshalLong(wireFormat, info.getBrokerOutTime(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessagePullMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessagePullMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessagePullMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/MessagePullMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,149 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for MessagePullMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class MessagePullMarshaller extends BaseCommandMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return MessagePull.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new MessagePull(); + } + + /** + * 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); + + MessagePull info = (MessagePull)o; + info.setConsumerId((org.apache.activemq.command.ConsumerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setDestination((org.apache.activemq.command.ActiveMQDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setTimeout(tightUnmarshalLong(wireFormat, dataIn, bs)); + info.setCorrelationId(tightUnmarshalString(dataIn, bs)); + info.setMessageId((org.apache.activemq.command.MessageId) tightUnmarsalNestedObject(wireFormat, dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + MessagePull info = (MessagePull)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getConsumerId(), bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getDestination(), bs); + rc+=tightMarshalLong1(wireFormat, info.getTimeout(), bs); + rc += tightMarshalString1(info.getCorrelationId(), bs); + rc += tightMarshalNestedObject1(wireFormat, (DataStructure)info.getMessageId(), bs); + + return rc + 0; + } + + /** + * 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); + + MessagePull info = (MessagePull)o; + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getConsumerId(), dataOut, bs); + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getDestination(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getTimeout(), dataOut, bs); + tightMarshalString2(info.getCorrelationId(), dataOut, bs); + tightMarshalNestedObject2(wireFormat, (DataStructure)info.getMessageId(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + MessagePull info = (MessagePull)o; + info.setConsumerId((org.apache.activemq.command.ConsumerId) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setDestination((org.apache.activemq.command.ActiveMQDestination) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setTimeout(looseUnmarshalLong(wireFormat, dataIn)); + info.setCorrelationId(looseUnmarshalString(dataIn)); + info.setMessageId((org.apache.activemq.command.MessageId) looseUnmarsalNestedObject(wireFormat, dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + MessagePull info = (MessagePull)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getConsumerId(), dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getDestination(), dataOut); + looseMarshalLong(wireFormat, info.getTimeout(), dataOut); + looseMarshalString(info.getCorrelationId(), dataOut); + looseMarshalNestedObject(wireFormat, (DataStructure)info.getMessageId(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/NetworkBridgeFilterMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/NetworkBridgeFilterMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/NetworkBridgeFilterMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/NetworkBridgeFilterMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,133 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for NetworkBridgeFilterMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class NetworkBridgeFilterMarshaller extends BaseDataStreamMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return NetworkBridgeFilter.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new NetworkBridgeFilter(); + } + + /** + * 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); + + NetworkBridgeFilter info = (NetworkBridgeFilter)o; + info.setNetworkTTL(dataIn.readInt()); + info.setNetworkBrokerId((org.apache.activemq.command.BrokerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + NetworkBridgeFilter info = (NetworkBridgeFilter)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getNetworkBrokerId(), bs); + + return rc + 4; + } + + /** + * 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); + + NetworkBridgeFilter info = (NetworkBridgeFilter)o; + dataOut.writeInt(info.getNetworkTTL()); + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getNetworkBrokerId(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + NetworkBridgeFilter info = (NetworkBridgeFilter)o; + info.setNetworkTTL(dataIn.readInt()); + info.setNetworkBrokerId((org.apache.activemq.command.BrokerId) looseUnmarsalCachedObject(wireFormat, dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + NetworkBridgeFilter info = (NetworkBridgeFilter)o; + + super.looseMarshal(wireFormat, o, dataOut); + dataOut.writeInt(info.getNetworkTTL()); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getNetworkBrokerId(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/PartialCommandMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/PartialCommandMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/PartialCommandMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/PartialCommandMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,133 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for PartialCommandMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class PartialCommandMarshaller extends BaseDataStreamMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return PartialCommand.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new PartialCommand(); + } + + /** + * 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); + + PartialCommand info = (PartialCommand)o; + info.setCommandId(dataIn.readInt()); + info.setData(tightUnmarshalByteArray(dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + PartialCommand info = (PartialCommand)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalByteArray1(info.getData(), bs); + + return rc + 4; + } + + /** + * 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); + + PartialCommand info = (PartialCommand)o; + dataOut.writeInt(info.getCommandId()); + tightMarshalByteArray2(info.getData(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + PartialCommand info = (PartialCommand)o; + info.setCommandId(dataIn.readInt()); + info.setData(looseUnmarshalByteArray(dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + PartialCommand info = (PartialCommand)o; + + super.looseMarshal(wireFormat, o, dataOut); + dataOut.writeInt(info.getCommandId()); + looseMarshalByteArray(wireFormat, info.getData(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerAckMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerAckMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerAckMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerAckMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,133 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for ProducerAckMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class ProducerAckMarshaller extends BaseCommandMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return ProducerAck.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new ProducerAck(); + } + + /** + * 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); + + ProducerAck info = (ProducerAck)o; + info.setProducerId((org.apache.activemq.command.ProducerId) tightUnmarsalNestedObject(wireFormat, dataIn, bs)); + info.setSize(dataIn.readInt()); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + ProducerAck info = (ProducerAck)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalNestedObject1(wireFormat, (DataStructure)info.getProducerId(), bs); + + return rc + 4; + } + + /** + * 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); + + ProducerAck info = (ProducerAck)o; + tightMarshalNestedObject2(wireFormat, (DataStructure)info.getProducerId(), dataOut, bs); + dataOut.writeInt(info.getSize()); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + ProducerAck info = (ProducerAck)o; + info.setProducerId((org.apache.activemq.command.ProducerId) looseUnmarsalNestedObject(wireFormat, dataIn)); + info.setSize(dataIn.readInt()); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + ProducerAck info = (ProducerAck)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalNestedObject(wireFormat, (DataStructure)info.getProducerId(), dataOut); + dataOut.writeInt(info.getSize()); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerIdMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerIdMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerIdMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerIdMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,139 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for ProducerIdMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class ProducerIdMarshaller extends BaseDataStreamMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return ProducerId.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new ProducerId(); + } + + /** + * 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); + + ProducerId info = (ProducerId)o; + info.setConnectionId(tightUnmarshalString(dataIn, bs)); + info.setValue(tightUnmarshalLong(wireFormat, dataIn, bs)); + info.setSessionId(tightUnmarshalLong(wireFormat, dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + ProducerId info = (ProducerId)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalString1(info.getConnectionId(), bs); + rc+=tightMarshalLong1(wireFormat, info.getValue(), bs); + rc+=tightMarshalLong1(wireFormat, info.getSessionId(), bs); + + return rc + 0; + } + + /** + * 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); + + ProducerId info = (ProducerId)o; + tightMarshalString2(info.getConnectionId(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getValue(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getSessionId(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + ProducerId info = (ProducerId)o; + info.setConnectionId(looseUnmarshalString(dataIn)); + info.setValue(looseUnmarshalLong(wireFormat, dataIn)); + info.setSessionId(looseUnmarshalLong(wireFormat, dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + ProducerId info = (ProducerId)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalString(info.getConnectionId(), dataOut); + looseMarshalLong(wireFormat, info.getValue(), dataOut); + looseMarshalLong(wireFormat, info.getSessionId(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerInfoMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerInfoMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerInfoMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ProducerInfoMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,170 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for ProducerInfoMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class ProducerInfoMarshaller extends BaseCommandMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return ProducerInfo.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new ProducerInfo(); + } + + /** + * 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); + + ProducerInfo info = (ProducerInfo)o; + info.setProducerId((org.apache.activemq.command.ProducerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setDestination((org.apache.activemq.command.ActiveMQDestination) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + + 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.setDispatchAsync(bs.readBoolean()); + info.setWindowSize(dataIn.readInt()); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + ProducerInfo info = (ProducerInfo)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getProducerId(), bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getDestination(), bs); + rc += tightMarshalObjectArray1(wireFormat, info.getBrokerPath(), bs); + bs.writeBoolean(info.isDispatchAsync()); + + return rc + 4; + } + + /** + * 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); + + ProducerInfo info = (ProducerInfo)o; + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getProducerId(), dataOut, bs); + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getDestination(), dataOut, bs); + tightMarshalObjectArray2(wireFormat, info.getBrokerPath(), dataOut, bs); + bs.readBoolean(); + dataOut.writeInt(info.getWindowSize()); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + ProducerInfo info = (ProducerInfo)o; + info.setProducerId((org.apache.activemq.command.ProducerId) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setDestination((org.apache.activemq.command.ActiveMQDestination) looseUnmarsalCachedObject(wireFormat, dataIn)); + + if (dataIn.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) looseUnmarsalNestedObject(wireFormat,dataIn); + } + info.setBrokerPath(value); + } + else { + info.setBrokerPath(null); + } + info.setDispatchAsync(dataIn.readBoolean()); + info.setWindowSize(dataIn.readInt()); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + ProducerInfo info = (ProducerInfo)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getProducerId(), dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getDestination(), dataOut); + looseMarshalObjectArray(wireFormat, info.getBrokerPath(), dataOut); + dataOut.writeBoolean(info.isDispatchAsync()); + dataOut.writeInt(info.getWindowSize()); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/RemoveInfoMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/RemoveInfoMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/RemoveInfoMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/RemoveInfoMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,134 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for RemoveInfoMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class RemoveInfoMarshaller extends BaseCommandMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return RemoveInfo.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new RemoveInfo(); + } + + /** + * 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); + + RemoveInfo info = (RemoveInfo)o; + info.setObjectId((org.apache.activemq.command.DataStructure) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setLastDeliveredSequenceId(tightUnmarshalLong(wireFormat, dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + RemoveInfo info = (RemoveInfo)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getObjectId(), bs); + rc+=tightMarshalLong1(wireFormat, info.getLastDeliveredSequenceId(), bs); + + return rc + 0; + } + + /** + * 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); + + RemoveInfo info = (RemoveInfo)o; + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getObjectId(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getLastDeliveredSequenceId(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + RemoveInfo info = (RemoveInfo)o; + info.setObjectId((org.apache.activemq.command.DataStructure) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setLastDeliveredSequenceId(looseUnmarshalLong(wireFormat, dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + RemoveInfo info = (RemoveInfo)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getObjectId(), dataOut); + looseMarshalLong(wireFormat, info.getLastDeliveredSequenceId(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/RemoveSubscriptionInfoMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/RemoveSubscriptionInfoMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/RemoveSubscriptionInfoMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/RemoveSubscriptionInfoMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,139 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for RemoveSubscriptionInfoMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class RemoveSubscriptionInfoMarshaller extends BaseCommandMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return RemoveSubscriptionInfo.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new RemoveSubscriptionInfo(); + } + + /** + * 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); + + RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o; + info.setConnectionId((org.apache.activemq.command.ConnectionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + info.setSubcriptionName(tightUnmarshalString(dataIn, bs)); + info.setClientId(tightUnmarshalString(dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getConnectionId(), bs); + rc += tightMarshalString1(info.getSubcriptionName(), bs); + rc += tightMarshalString1(info.getClientId(), bs); + + return rc + 0; + } + + /** + * 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); + + RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o; + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getConnectionId(), dataOut, bs); + tightMarshalString2(info.getSubcriptionName(), dataOut, bs); + tightMarshalString2(info.getClientId(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o; + info.setConnectionId((org.apache.activemq.command.ConnectionId) looseUnmarsalCachedObject(wireFormat, dataIn)); + info.setSubcriptionName(looseUnmarshalString(dataIn)); + info.setClientId(looseUnmarshalString(dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getConnectionId(), dataOut); + looseMarshalString(info.getSubcriptionName(), dataOut); + looseMarshalString(info.getClientId(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ReplayCommandMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ReplayCommandMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ReplayCommandMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ReplayCommandMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,132 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for ReplayCommandMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class ReplayCommandMarshaller extends BaseCommandMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return ReplayCommand.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new ReplayCommand(); + } + + /** + * 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); + + ReplayCommand info = (ReplayCommand)o; + info.setFirstNakNumber(dataIn.readInt()); + info.setLastNakNumber(dataIn.readInt()); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + ReplayCommand info = (ReplayCommand)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + + return rc + 8; + } + + /** + * 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); + + ReplayCommand info = (ReplayCommand)o; + dataOut.writeInt(info.getFirstNakNumber()); + dataOut.writeInt(info.getLastNakNumber()); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + ReplayCommand info = (ReplayCommand)o; + info.setFirstNakNumber(dataIn.readInt()); + info.setLastNakNumber(dataIn.readInt()); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + ReplayCommand info = (ReplayCommand)o; + + super.looseMarshal(wireFormat, o, dataOut); + dataOut.writeInt(info.getFirstNakNumber()); + dataOut.writeInt(info.getLastNakNumber()); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ResponseMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ResponseMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ResponseMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/ResponseMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,128 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for ResponseMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class ResponseMarshaller extends BaseCommandMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return Response.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new Response(); + } + + /** + * 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); + + Response info = (Response)o; + info.setCorrelationId(dataIn.readInt()); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + Response info = (Response)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + + return rc + 4; + } + + /** + * 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); + + Response info = (Response)o; + dataOut.writeInt(info.getCorrelationId()); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + Response info = (Response)o; + info.setCorrelationId(dataIn.readInt()); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + Response info = (Response)o; + + super.looseMarshal(wireFormat, o, dataOut); + dataOut.writeInt(info.getCorrelationId()); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/SessionIdMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/SessionIdMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/SessionIdMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/SessionIdMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,134 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for SessionIdMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class SessionIdMarshaller extends BaseDataStreamMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return SessionId.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new SessionId(); + } + + /** + * 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); + + SessionId info = (SessionId)o; + info.setConnectionId(tightUnmarshalString(dataIn, bs)); + info.setValue(tightUnmarshalLong(wireFormat, dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + SessionId info = (SessionId)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalString1(info.getConnectionId(), bs); + rc+=tightMarshalLong1(wireFormat, info.getValue(), bs); + + return rc + 0; + } + + /** + * 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); + + SessionId info = (SessionId)o; + tightMarshalString2(info.getConnectionId(), dataOut, bs); + tightMarshalLong2(wireFormat, info.getValue(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + SessionId info = (SessionId)o; + info.setConnectionId(looseUnmarshalString(dataIn)); + info.setValue(looseUnmarshalLong(wireFormat, dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + SessionId info = (SessionId)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalString(info.getConnectionId(), dataOut); + looseMarshalLong(wireFormat, info.getValue(), dataOut); + + } +} Added: activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/SessionInfoMarshaller.java URL: http://svn.apache.org/viewvc/activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/SessionInfoMarshaller.java?rev=1483902&view=auto ============================================================================== --- activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/SessionInfoMarshaller.java (added) +++ activemq/trunk/activemq-client/src/main/java/org/apache/activemq/openwire/v10/SessionInfoMarshaller.java Fri May 17 16:27:35 2013 @@ -0,0 +1,129 @@ +/** + * + * 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.activemq.openwire.v10; + +import java.io.DataInput; +import java.io.DataOutput; +import java.io.IOException; + +import org.apache.activemq.openwire.*; +import org.apache.activemq.command.*; + + + +/** + * Marshalling code for Open Wire Format for SessionInfoMarshaller + * + * + * NOTE!: This file is auto generated - do not modify! + * if you need to make a change, please see the modify the groovy scripts in the + * under src/gram/script and then use maven openwire:generate to regenerate + * this file. + * + * + */ +public class SessionInfoMarshaller extends BaseCommandMarshaller { + + /** + * Return the type of Data Structure we marshal + * @return short representation of the type data structure + */ + public byte getDataStructureType() { + return SessionInfo.DATA_STRUCTURE_TYPE; + } + + /** + * @return a new object instance + */ + public DataStructure createObject() { + return new SessionInfo(); + } + + /** + * 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); + + SessionInfo info = (SessionInfo)o; + info.setSessionId((org.apache.activemq.command.SessionId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public int tightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) throws IOException { + + SessionInfo info = (SessionInfo)o; + + int rc = super.tightMarshal1(wireFormat, o, bs); + rc += tightMarshalCachedObject1(wireFormat, (DataStructure)info.getSessionId(), bs); + + return rc + 0; + } + + /** + * 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); + + SessionInfo info = (SessionInfo)o; + tightMarshalCachedObject2(wireFormat, (DataStructure)info.getSessionId(), dataOut, bs); + + } + + /** + * 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 looseUnmarshal(OpenWireFormat wireFormat, Object o, DataInput dataIn) throws IOException { + super.looseUnmarshal(wireFormat, o, dataIn); + + SessionInfo info = (SessionInfo)o; + info.setSessionId((org.apache.activemq.command.SessionId) looseUnmarsalCachedObject(wireFormat, dataIn)); + + } + + + /** + * Write the booleans that this object uses to a BooleanStream + */ + public void looseMarshal(OpenWireFormat wireFormat, Object o, DataOutput dataOut) throws IOException { + + SessionInfo info = (SessionInfo)o; + + super.looseMarshal(wireFormat, o, dataOut); + looseMarshalCachedObject(wireFormat, (DataStructure)info.getSessionId(), dataOut); + + } +}