Autogenerated OpenWire code after version 2 along with the MessagePull command

git-svn-id: https://svn.apache.org/repos/asf/incubator/activemq/trunk@430504 13f79535-47bb-0310-9956-ffa450edef68

activemq-dotnet/src/main/csharp/ActiveMQ/Commands/MessagePull.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
//  NOTE!: This file is autogenerated - do not modify!
//         if you need to make a change, please see the Groovy scripts in the
//         activemq-core module
//

using System;
using System.Collections;

using ActiveMQ.OpenWire;
using ActiveMQ.Commands;

namespace ActiveMQ.Commands
{
	/// <summary>
    ///  The ActiveMQ MessagePull Command
	/// </summary>
    public class MessagePull : BaseCommand
    {
        public const byte ID_MessagePull = 20;
    			
        ConsumerId consumerId;
        ActiveMQDestination destination;
        long timeout;

		public override string ToString() {
            return GetType().Name + "["
                + " ConsumerId=" + ConsumerId
                + " Destination=" + Destination
                + " Timeout=" + Timeout
                + " ]";

		}
	


        public override byte GetDataStructureType() {
            return ID_MessagePull;
        }


        // Properties

        public ConsumerId ConsumerId
        {
            get { return consumerId; }
            set { this.consumerId = value; }            
        }

        public ActiveMQDestination Destination
        {
            get { return destination; }
            set { this.destination = value; }            
        }

        public long Timeout
        {
            get { return timeout; }
            set { this.timeout = value; }            
        }

    }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQBytesMessageMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQBytesMessage
  /// </summary>
  class ActiveMQBytesMessageMarshaller : ActiveMQMessageMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQBytesMessage();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQBytesMessage.ID_ActiveMQBytesMessage;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQBytesMessage info = (ActiveMQBytesMessage)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQDestinationMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQDestination
  /// </summary>
  abstract class ActiveMQDestinationMarshaller : BaseDataStreamMarshaller
  {

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ActiveMQDestination info = (ActiveMQDestination)o;
        info.PhysicalName = TightUnmarshalString(dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQDestination info = (ActiveMQDestination)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.PhysicalName, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ActiveMQDestination info = (ActiveMQDestination)o;
        TightMarshalString2(info.PhysicalName, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ActiveMQDestination info = (ActiveMQDestination)o;
        info.PhysicalName = LooseUnmarshalString(dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ActiveMQDestination info = (ActiveMQDestination)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.PhysicalName, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQMapMessageMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQMapMessage
  /// </summary>
  class ActiveMQMapMessageMarshaller : ActiveMQMessageMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQMapMessage();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQMapMessage.ID_ActiveMQMapMessage;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQMapMessage info = (ActiveMQMapMessage)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQMessageMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQMessage
  /// </summary>
  class ActiveMQMessageMarshaller : MessageMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQMessage();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQMessage.ID_ActiveMQMessage;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ActiveMQMessage info = (ActiveMQMessage)o;

        info.BeforeUnmarshall(wireFormat);
        

        info.AfterUnmarshall(wireFormat);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQMessage info = (ActiveMQMessage)o;

        info.BeforeMarshall(wireFormat);

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ActiveMQMessage info = (ActiveMQMessage)o;

        info.AfterMarshall(wireFormat);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ActiveMQMessage info = (ActiveMQMessage)o;

        info.BeforeUnmarshall(wireFormat);
        

        info.AfterUnmarshall(wireFormat);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ActiveMQMessage info = (ActiveMQMessage)o;

        info.BeforeMarshall(wireFormat);

        base.LooseMarshal(wireFormat, o, dataOut);

        info.AfterMarshall(wireFormat);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQObjectMessageMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQObjectMessage
  /// </summary>
  class ActiveMQObjectMessageMarshaller : ActiveMQMessageMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQObjectMessage();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQObjectMessage.ID_ActiveMQObjectMessage;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQObjectMessage info = (ActiveMQObjectMessage)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQQueueMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQQueue
  /// </summary>
  class ActiveMQQueueMarshaller : ActiveMQDestinationMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQQueue();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQQueue.ID_ActiveMQQueue;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQQueue info = (ActiveMQQueue)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQStreamMessageMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQStreamMessage
  /// </summary>
  class ActiveMQStreamMessageMarshaller : ActiveMQMessageMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQStreamMessage();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQStreamMessage.ID_ActiveMQStreamMessage;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQStreamMessage info = (ActiveMQStreamMessage)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTempDestinationMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQTempDestination
  /// </summary>
  abstract class ActiveMQTempDestinationMarshaller : ActiveMQDestinationMarshaller
  {

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQTempDestination info = (ActiveMQTempDestination)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTempQueueMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQTempQueue
  /// </summary>
  class ActiveMQTempQueueMarshaller : ActiveMQTempDestinationMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQTempQueue();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQTempQueue.ID_ActiveMQTempQueue;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQTempQueue info = (ActiveMQTempQueue)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTempTopicMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQTempTopic
  /// </summary>
  class ActiveMQTempTopicMarshaller : ActiveMQTempDestinationMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQTempTopic();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQTempTopic.ID_ActiveMQTempTopic;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQTempTopic info = (ActiveMQTempTopic)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTextMessageMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQTextMessage
  /// </summary>
  class ActiveMQTextMessageMarshaller : ActiveMQMessageMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQTextMessage();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQTextMessage.ID_ActiveMQTextMessage;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQTextMessage info = (ActiveMQTextMessage)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTopicMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ActiveMQTopic
  /// </summary>
  class ActiveMQTopicMarshaller : ActiveMQDestinationMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ActiveMQTopic();
    }

    public override byte GetDataStructureType() 
    {
        return ActiveMQTopic.ID_ActiveMQTopic;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ActiveMQTopic info = (ActiveMQTopic)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/BaseCommandMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for BaseCommand
  /// </summary>
  abstract class BaseCommandMarshaller : BaseDataStreamMarshaller
  {

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        BaseCommand info = (BaseCommand)o;
        info.CommandId = dataIn.ReadInt32();
        info.ResponseRequired = bs.ReadBoolean();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        BaseCommand info = (BaseCommand)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        bs.WriteBoolean(info.ResponseRequired);

        return rc + 4;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        BaseCommand info = (BaseCommand)o;
        dataOut.Write(info.CommandId);
        bs.ReadBoolean();

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        BaseCommand info = (BaseCommand)o;
        info.CommandId = dataIn.ReadInt32();
        info.ResponseRequired = dataIn.ReadBoolean();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        BaseCommand info = (BaseCommand)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.CommandId);
        dataOut.Write(info.ResponseRequired);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/BrokerIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for BrokerId
  /// </summary>
  class BrokerIdMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new BrokerId();
    }

    public override byte GetDataStructureType() 
    {
        return BrokerId.ID_BrokerId;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        BrokerId info = (BrokerId)o;
        info.Value = TightUnmarshalString(dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        BrokerId info = (BrokerId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.Value, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        BrokerId info = (BrokerId)o;
        TightMarshalString2(info.Value, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        BrokerId info = (BrokerId)o;
        info.Value = LooseUnmarshalString(dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        BrokerId info = (BrokerId)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.Value, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConnectionControlMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ConnectionControl
  /// </summary>
  class ConnectionControlMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ConnectionControl();
    }

    public override byte GetDataStructureType() 
    {
        return ConnectionControl.ID_ConnectionControl;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ConnectionControl info = (ConnectionControl)o;
        info.Close = bs.ReadBoolean();
        info.Exit = bs.ReadBoolean();
        info.FaultTolerant = bs.ReadBoolean();
        info.Resume = bs.ReadBoolean();
        info.Suspend = bs.ReadBoolean();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ConnectionControl info = (ConnectionControl)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        bs.WriteBoolean(info.Close);
        bs.WriteBoolean(info.Exit);
        bs.WriteBoolean(info.FaultTolerant);
        bs.WriteBoolean(info.Resume);
        bs.WriteBoolean(info.Suspend);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ConnectionControl info = (ConnectionControl)o;
        bs.ReadBoolean();
        bs.ReadBoolean();
        bs.ReadBoolean();
        bs.ReadBoolean();
        bs.ReadBoolean();

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ConnectionControl info = (ConnectionControl)o;
        info.Close = dataIn.ReadBoolean();
        info.Exit = dataIn.ReadBoolean();
        info.FaultTolerant = dataIn.ReadBoolean();
        info.Resume = dataIn.ReadBoolean();
        info.Suspend = dataIn.ReadBoolean();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ConnectionControl info = (ConnectionControl)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.Close);
        dataOut.Write(info.Exit);
        dataOut.Write(info.FaultTolerant);
        dataOut.Write(info.Resume);
        dataOut.Write(info.Suspend);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConnectionErrorMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ConnectionError
  /// </summary>
  class ConnectionErrorMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ConnectionError();
    }

    public override byte GetDataStructureType() 
    {
        return ConnectionError.ID_ConnectionError;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ConnectionError info = (ConnectionError)o;
        info.Exception = TightUnmarshalBrokerError(wireFormat, dataIn, bs);
        info.ConnectionId = (ConnectionId) TightUnmarshalNestedObject(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ConnectionError info = (ConnectionError)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalBrokerError1(wireFormat, info.Exception, bs);
        rc += TightMarshalNestedObject1(wireFormat, (DataStructure)info.ConnectionId, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ConnectionError info = (ConnectionError)o;
        TightMarshalBrokerError2(wireFormat, info.Exception, dataOut, bs);
        TightMarshalNestedObject2(wireFormat, (DataStructure)info.ConnectionId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ConnectionError info = (ConnectionError)o;
        info.Exception = LooseUnmarshalBrokerError(wireFormat, dataIn);
        info.ConnectionId = (ConnectionId) LooseUnmarshalNestedObject(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ConnectionError info = (ConnectionError)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalBrokerError(wireFormat, info.Exception, dataOut);
        LooseMarshalNestedObject(wireFormat, (DataStructure)info.ConnectionId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConnectionIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ConnectionId
  /// </summary>
  class ConnectionIdMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ConnectionId();
    }

    public override byte GetDataStructureType() 
    {
        return ConnectionId.ID_ConnectionId;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ConnectionId info = (ConnectionId)o;
        info.Value = TightUnmarshalString(dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ConnectionId info = (ConnectionId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.Value, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ConnectionId info = (ConnectionId)o;
        TightMarshalString2(info.Value, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ConnectionId info = (ConnectionId)o;
        info.Value = LooseUnmarshalString(dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ConnectionId info = (ConnectionId)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.Value, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConsumerControlMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ConsumerControl
  /// </summary>
  class ConsumerControlMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ConsumerControl();
    }

    public override byte GetDataStructureType() 
    {
        return ConsumerControl.ID_ConsumerControl;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ConsumerControl info = (ConsumerControl)o;
        info.Close = bs.ReadBoolean();
        info.ConsumerId = (ConsumerId) TightUnmarshalNestedObject(wireFormat, dataIn, bs);
        info.Prefetch = dataIn.ReadInt32();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ConsumerControl info = (ConsumerControl)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        bs.WriteBoolean(info.Close);
        rc += TightMarshalNestedObject1(wireFormat, (DataStructure)info.ConsumerId, bs);

        return rc + 4;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ConsumerControl info = (ConsumerControl)o;
        bs.ReadBoolean();
        TightMarshalNestedObject2(wireFormat, (DataStructure)info.ConsumerId, dataOut, bs);
        dataOut.Write(info.Prefetch);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ConsumerControl info = (ConsumerControl)o;
        info.Close = dataIn.ReadBoolean();
        info.ConsumerId = (ConsumerId) LooseUnmarshalNestedObject(wireFormat, dataIn);
        info.Prefetch = dataIn.ReadInt32();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ConsumerControl info = (ConsumerControl)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.Close);
        LooseMarshalNestedObject(wireFormat, (DataStructure)info.ConsumerId, dataOut);
        dataOut.Write(info.Prefetch);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConsumerIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ConsumerId
  /// </summary>
  class ConsumerIdMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ConsumerId();
    }

    public override byte GetDataStructureType() 
    {
        return ConsumerId.ID_ConsumerId;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ConsumerId info = (ConsumerId)o;
        info.ConnectionId = TightUnmarshalString(dataIn, bs);
        info.SessionId = TightUnmarshalLong(wireFormat, dataIn, bs);
        info.Value = TightUnmarshalLong(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ConsumerId info = (ConsumerId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.ConnectionId, bs);
        rc += TightMarshalLong1(wireFormat, info.SessionId, bs);
        rc += TightMarshalLong1(wireFormat, info.Value, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ConsumerId info = (ConsumerId)o;
        TightMarshalString2(info.ConnectionId, dataOut, bs);
        TightMarshalLong2(wireFormat, info.SessionId, dataOut, bs);
        TightMarshalLong2(wireFormat, info.Value, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ConsumerId info = (ConsumerId)o;
        info.ConnectionId = LooseUnmarshalString(dataIn);
        info.SessionId = LooseUnmarshalLong(wireFormat, dataIn);
        info.Value = LooseUnmarshalLong(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ConsumerId info = (ConsumerId)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.ConnectionId, dataOut);
        LooseMarshalLong(wireFormat, info.SessionId, dataOut);
        LooseMarshalLong(wireFormat, info.Value, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ControlCommandMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ControlCommand
  /// </summary>
  class ControlCommandMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ControlCommand();
    }

    public override byte GetDataStructureType() 
    {
        return ControlCommand.ID_ControlCommand;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ControlCommand info = (ControlCommand)o;
        info.Command = TightUnmarshalString(dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ControlCommand info = (ControlCommand)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.Command, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ControlCommand info = (ControlCommand)o;
        TightMarshalString2(info.Command, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ControlCommand info = (ControlCommand)o;
        info.Command = LooseUnmarshalString(dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ControlCommand info = (ControlCommand)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.Command, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/DataArrayResponseMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for DataArrayResponse
  /// </summary>
  class DataArrayResponseMarshaller : ResponseMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new DataArrayResponse();
    }

    public override byte GetDataStructureType() 
    {
        return DataArrayResponse.ID_DataArrayResponse;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        DataArrayResponse info = (DataArrayResponse)o;

        if (bs.ReadBoolean()) {
            short size = dataIn.ReadInt16();
            DataStructure[] value = new DataStructure[size];
            for( int i=0; i < size; i++ ) {
                value[i] = (DataStructure) TightUnmarshalNestedObject(wireFormat,dataIn, bs);
            }
            info.Data = value;
        }
        else {
            info.Data = null;
        }

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        DataArrayResponse info = (DataArrayResponse)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalObjectArray1(wireFormat, info.Data, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        DataArrayResponse info = (DataArrayResponse)o;
        TightMarshalObjectArray2(wireFormat, info.Data, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        DataArrayResponse info = (DataArrayResponse)o;

        if (dataIn.ReadBoolean()) {
            short size = dataIn.ReadInt16();
            DataStructure[] value = new DataStructure[size];
            for( int i=0; i < size; i++ ) {
                value[i] = (DataStructure) LooseUnmarshalNestedObject(wireFormat,dataIn);
            }
            info.Data = value;
        }
        else {
            info.Data = null;
        }

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        DataArrayResponse info = (DataArrayResponse)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalObjectArray(wireFormat, info.Data, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/DataResponseMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for DataResponse
  /// </summary>
  class DataResponseMarshaller : ResponseMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new DataResponse();
    }

    public override byte GetDataStructureType() 
    {
        return DataResponse.ID_DataResponse;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        DataResponse info = (DataResponse)o;
        info.Data = (DataStructure) TightUnmarshalNestedObject(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        DataResponse info = (DataResponse)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalNestedObject1(wireFormat, (DataStructure)info.Data, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        DataResponse info = (DataResponse)o;
        TightMarshalNestedObject2(wireFormat, (DataStructure)info.Data, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        DataResponse info = (DataResponse)o;
        info.Data = (DataStructure) LooseUnmarshalNestedObject(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        DataResponse info = (DataResponse)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalNestedObject(wireFormat, (DataStructure)info.Data, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/DiscoveryEventMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for DiscoveryEvent
  /// </summary>
  class DiscoveryEventMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new DiscoveryEvent();
    }

    public override byte GetDataStructureType() 
    {
        return DiscoveryEvent.ID_DiscoveryEvent;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        DiscoveryEvent info = (DiscoveryEvent)o;
        info.ServiceName = TightUnmarshalString(dataIn, bs);
        info.BrokerName = TightUnmarshalString(dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        DiscoveryEvent info = (DiscoveryEvent)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.ServiceName, bs);
        rc += TightMarshalString1(info.BrokerName, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        DiscoveryEvent info = (DiscoveryEvent)o;
        TightMarshalString2(info.ServiceName, dataOut, bs);
        TightMarshalString2(info.BrokerName, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        DiscoveryEvent info = (DiscoveryEvent)o;
        info.ServiceName = LooseUnmarshalString(dataIn);
        info.BrokerName = LooseUnmarshalString(dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        DiscoveryEvent info = (DiscoveryEvent)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.ServiceName, dataOut);
        LooseMarshalString(info.BrokerName, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ExceptionResponseMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ExceptionResponse
  /// </summary>
  class ExceptionResponseMarshaller : ResponseMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ExceptionResponse();
    }

    public override byte GetDataStructureType() 
    {
        return ExceptionResponse.ID_ExceptionResponse;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ExceptionResponse info = (ExceptionResponse)o;
        info.Exception = TightUnmarshalBrokerError(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ExceptionResponse info = (ExceptionResponse)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalBrokerError1(wireFormat, info.Exception, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ExceptionResponse info = (ExceptionResponse)o;
        TightMarshalBrokerError2(wireFormat, info.Exception, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ExceptionResponse info = (ExceptionResponse)o;
        info.Exception = LooseUnmarshalBrokerError(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ExceptionResponse info = (ExceptionResponse)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalBrokerError(wireFormat, info.Exception, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/FlushCommandMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for FlushCommand
  /// </summary>
  class FlushCommandMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new FlushCommand();
    }

    public override byte GetDataStructureType() 
    {
        return FlushCommand.ID_FlushCommand;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        FlushCommand info = (FlushCommand)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/IntegerResponseMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for IntegerResponse
  /// </summary>
  class IntegerResponseMarshaller : ResponseMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new IntegerResponse();
    }

    public override byte GetDataStructureType() 
    {
        return IntegerResponse.ID_IntegerResponse;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        IntegerResponse info = (IntegerResponse)o;
        info.Result = dataIn.ReadInt32();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        IntegerResponse info = (IntegerResponse)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 4;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        IntegerResponse info = (IntegerResponse)o;
        dataOut.Write(info.Result);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        IntegerResponse info = (IntegerResponse)o;
        info.Result = dataIn.ReadInt32();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        IntegerResponse info = (IntegerResponse)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.Result);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/JournalQueueAckMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for JournalQueueAck
  /// </summary>
  class JournalQueueAckMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new JournalQueueAck();
    }

    public override byte GetDataStructureType() 
    {
        return JournalQueueAck.ID_JournalQueueAck;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        JournalQueueAck info = (JournalQueueAck)o;
        info.Destination = (ActiveMQDestination) TightUnmarshalNestedObject(wireFormat, dataIn, bs);
        info.MessageAck = (MessageAck) TightUnmarshalNestedObject(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        JournalQueueAck info = (JournalQueueAck)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalNestedObject1(wireFormat, (DataStructure)info.Destination, bs);
        rc += TightMarshalNestedObject1(wireFormat, (DataStructure)info.MessageAck, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        JournalQueueAck info = (JournalQueueAck)o;
        TightMarshalNestedObject2(wireFormat, (DataStructure)info.Destination, dataOut, bs);
        TightMarshalNestedObject2(wireFormat, (DataStructure)info.MessageAck, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        JournalQueueAck info = (JournalQueueAck)o;
        info.Destination = (ActiveMQDestination) LooseUnmarshalNestedObject(wireFormat, dataIn);
        info.MessageAck = (MessageAck) LooseUnmarshalNestedObject(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        JournalQueueAck info = (JournalQueueAck)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalNestedObject(wireFormat, (DataStructure)info.Destination, dataOut);
        LooseMarshalNestedObject(wireFormat, (DataStructure)info.MessageAck, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/JournalTraceMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for JournalTrace
  /// </summary>
  class JournalTraceMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new JournalTrace();
    }

    public override byte GetDataStructureType() 
    {
        return JournalTrace.ID_JournalTrace;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        JournalTrace info = (JournalTrace)o;
        info.Message = TightUnmarshalString(dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        JournalTrace info = (JournalTrace)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.Message, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        JournalTrace info = (JournalTrace)o;
        TightMarshalString2(info.Message, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        JournalTrace info = (JournalTrace)o;
        info.Message = LooseUnmarshalString(dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        JournalTrace info = (JournalTrace)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.Message, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/JournalTransactionMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for JournalTransaction
  /// </summary>
  class JournalTransactionMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new JournalTransaction();
    }

    public override byte GetDataStructureType() 
    {
        return JournalTransaction.ID_JournalTransaction;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        JournalTransaction info = (JournalTransaction)o;
        info.TransactionId = (TransactionId) TightUnmarshalNestedObject(wireFormat, dataIn, bs);
        info.Type = dataIn.ReadByte();
        info.WasPrepared = bs.ReadBoolean();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        JournalTransaction info = (JournalTransaction)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalNestedObject1(wireFormat, (DataStructure)info.TransactionId, bs);
        bs.WriteBoolean(info.WasPrepared);

        return rc + 1;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        JournalTransaction info = (JournalTransaction)o;
        TightMarshalNestedObject2(wireFormat, (DataStructure)info.TransactionId, dataOut, bs);
        dataOut.Write(info.Type);
        bs.ReadBoolean();

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        JournalTransaction info = (JournalTransaction)o;
        info.TransactionId = (TransactionId) LooseUnmarshalNestedObject(wireFormat, dataIn);
        info.Type = dataIn.ReadByte();
        info.WasPrepared = dataIn.ReadBoolean();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        JournalTransaction info = (JournalTransaction)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalNestedObject(wireFormat, (DataStructure)info.TransactionId, dataOut);
        dataOut.Write(info.Type);
        dataOut.Write(info.WasPrepared);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/KeepAliveInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for KeepAliveInfo
  /// </summary>
  class KeepAliveInfoMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new KeepAliveInfo();
    }

    public override byte GetDataStructureType() 
    {
        return KeepAliveInfo.ID_KeepAliveInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        KeepAliveInfo info = (KeepAliveInfo)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/LastPartialCommandMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for LastPartialCommand
  /// </summary>
  class LastPartialCommandMarshaller : PartialCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new LastPartialCommand();
    }

    public override byte GetDataStructureType() 
    {
        return LastPartialCommand.ID_LastPartialCommand;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        LastPartialCommand info = (LastPartialCommand)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/LocalTransactionIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for LocalTransactionId
  /// </summary>
  class LocalTransactionIdMarshaller : TransactionIdMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new LocalTransactionId();
    }

    public override byte GetDataStructureType() 
    {
        return LocalTransactionId.ID_LocalTransactionId;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        LocalTransactionId info = (LocalTransactionId)o;
        info.Value = TightUnmarshalLong(wireFormat, dataIn, bs);
        info.ConnectionId = (ConnectionId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        LocalTransactionId info = (LocalTransactionId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalLong1(wireFormat, info.Value, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ConnectionId, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        LocalTransactionId info = (LocalTransactionId)o;
        TightMarshalLong2(wireFormat, info.Value, dataOut, bs);
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ConnectionId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        LocalTransactionId info = (LocalTransactionId)o;
        info.Value = LooseUnmarshalLong(wireFormat, dataIn);
        info.ConnectionId = (ConnectionId) LooseUnmarshalCachedObject(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        LocalTransactionId info = (LocalTransactionId)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalLong(wireFormat, info.Value, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ConnectionId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MarshallerFactory.cs

@@ -0,0 +1,98 @@
+/*
+* 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.
+*/
+
+//
+// NOTE!: This file is autogenerated - do not modify!
+//        if you need to make a change, please see the Groovy scripts in the
+//        activemq-core module
+//
+
+using System;
+using System.Collections;
+using System.IO;
+
+using ActiveMQ.Commands;
+using ActiveMQ.OpenWire;
+using ActiveMQ.OpenWire.V2;
+
+namespace ActiveMQ.OpenWire.V2
+{
+	/// <summary>
+	/// Used to create marshallers for a specific version of the wire protocol
+	/// </summary>
+    public class MarshallerFactory
+    {
+        public void configure(OpenWireFormat format) 
+        {
+
+            format.addMarshaller(new LocalTransactionIdMarshaller());
+            format.addMarshaller(new PartialCommandMarshaller());
+            format.addMarshaller(new IntegerResponseMarshaller());
+            format.addMarshaller(new ActiveMQQueueMarshaller());
+            format.addMarshaller(new ActiveMQObjectMessageMarshaller());
+            format.addMarshaller(new ConnectionIdMarshaller());
+            format.addMarshaller(new ConnectionInfoMarshaller());
+            format.addMarshaller(new ProducerInfoMarshaller());
+            format.addMarshaller(new MessageDispatchNotificationMarshaller());
+            format.addMarshaller(new SessionInfoMarshaller());
+            format.addMarshaller(new TransactionInfoMarshaller());
+            format.addMarshaller(new ActiveMQStreamMessageMarshaller());
+            format.addMarshaller(new MessageAckMarshaller());
+            format.addMarshaller(new ProducerIdMarshaller());
+            format.addMarshaller(new MessageIdMarshaller());
+            format.addMarshaller(new ActiveMQTempQueueMarshaller());
+            format.addMarshaller(new RemoveSubscriptionInfoMarshaller());
+            format.addMarshaller(new SessionIdMarshaller());
+            format.addMarshaller(new DataArrayResponseMarshaller());
+            format.addMarshaller(new JournalQueueAckMarshaller());
+            format.addMarshaller(new ResponseMarshaller());
+            format.addMarshaller(new ConnectionErrorMarshaller());
+            format.addMarshaller(new ConsumerInfoMarshaller());
+            format.addMarshaller(new XATransactionIdMarshaller());
+            format.addMarshaller(new JournalTraceMarshaller());
+            format.addMarshaller(new ConsumerIdMarshaller());
+            format.addMarshaller(new ActiveMQTextMessageMarshaller());
+            format.addMarshaller(new SubscriptionInfoMarshaller());
+            format.addMarshaller(new JournalTransactionMarshaller());
+            format.addMarshaller(new ControlCommandMarshaller());
+            format.addMarshaller(new LastPartialCommandMarshaller());
+            format.addMarshaller(new NetworkBridgeFilterMarshaller());
+            format.addMarshaller(new MessagePullMarshaller());
+            format.addMarshaller(new ActiveMQBytesMessageMarshaller());
+            format.addMarshaller(new WireFormatInfoMarshaller());
+            format.addMarshaller(new ActiveMQTempTopicMarshaller());
+            format.addMarshaller(new DiscoveryEventMarshaller());
+            format.addMarshaller(new ReplayCommandMarshaller());
+            format.addMarshaller(new ActiveMQTopicMarshaller());
+            format.addMarshaller(new BrokerInfoMarshaller());
+            format.addMarshaller(new DestinationInfoMarshaller());
+            format.addMarshaller(new ShutdownInfoMarshaller());
+            format.addMarshaller(new DataResponseMarshaller());
+            format.addMarshaller(new ConnectionControlMarshaller());
+            format.addMarshaller(new KeepAliveInfoMarshaller());
+            format.addMarshaller(new FlushCommandMarshaller());
+            format.addMarshaller(new ConsumerControlMarshaller());
+            format.addMarshaller(new JournalTopicAckMarshaller());
+            format.addMarshaller(new BrokerIdMarshaller());
+            format.addMarshaller(new MessageDispatchMarshaller());
+            format.addMarshaller(new ActiveMQMapMessageMarshaller());
+            format.addMarshaller(new ActiveMQMessageMarshaller());
+            format.addMarshaller(new RemoveInfoMarshaller());
+            format.addMarshaller(new ExceptionResponseMarshaller());
+    	}
+    }
+}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessageDispatchMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for MessageDispatch
  /// </summary>
  class MessageDispatchMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new MessageDispatch();
    }

    public override byte GetDataStructureType() 
    {
        return MessageDispatch.ID_MessageDispatch;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        MessageDispatch info = (MessageDispatch)o;
        info.ConsumerId = (ConsumerId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.Destination = (ActiveMQDestination) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.Message = (Message) TightUnmarshalNestedObject(wireFormat, dataIn, bs);
        info.RedeliveryCounter = dataIn.ReadInt32();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        MessageDispatch info = (MessageDispatch)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ConsumerId, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.Destination, bs);
        rc += TightMarshalNestedObject1(wireFormat, (DataStructure)info.Message, bs);

        return rc + 4;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        MessageDispatch info = (MessageDispatch)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ConsumerId, dataOut, bs);
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.Destination, dataOut, bs);
        TightMarshalNestedObject2(wireFormat, (DataStructure)info.Message, dataOut, bs);
        dataOut.Write(info.RedeliveryCounter);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        MessageDispatch info = (MessageDispatch)o;
        info.ConsumerId = (ConsumerId) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.Destination = (ActiveMQDestination) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.Message = (Message) LooseUnmarshalNestedObject(wireFormat, dataIn);
        info.RedeliveryCounter = dataIn.ReadInt32();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        MessageDispatch info = (MessageDispatch)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ConsumerId, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.Destination, dataOut);
        LooseMarshalNestedObject(wireFormat, (DataStructure)info.Message, dataOut);
        dataOut.Write(info.RedeliveryCounter);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessageDispatchNotificationMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for MessageDispatchNotification
  /// </summary>
  class MessageDispatchNotificationMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new MessageDispatchNotification();
    }

    public override byte GetDataStructureType() 
    {
        return MessageDispatchNotification.ID_MessageDispatchNotification;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        MessageDispatchNotification info = (MessageDispatchNotification)o;
        info.ConsumerId = (ConsumerId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.Destination = (ActiveMQDestination) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.DeliverySequenceId = TightUnmarshalLong(wireFormat, dataIn, bs);
        info.MessageId = (MessageId) TightUnmarshalNestedObject(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        MessageDispatchNotification info = (MessageDispatchNotification)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ConsumerId, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.Destination, bs);
        rc += TightMarshalLong1(wireFormat, info.DeliverySequenceId, bs);
        rc += TightMarshalNestedObject1(wireFormat, (DataStructure)info.MessageId, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        MessageDispatchNotification info = (MessageDispatchNotification)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ConsumerId, dataOut, bs);
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.Destination, dataOut, bs);
        TightMarshalLong2(wireFormat, info.DeliverySequenceId, dataOut, bs);
        TightMarshalNestedObject2(wireFormat, (DataStructure)info.MessageId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        MessageDispatchNotification info = (MessageDispatchNotification)o;
        info.ConsumerId = (ConsumerId) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.Destination = (ActiveMQDestination) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.DeliverySequenceId = LooseUnmarshalLong(wireFormat, dataIn);
        info.MessageId = (MessageId) LooseUnmarshalNestedObject(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        MessageDispatchNotification info = (MessageDispatchNotification)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ConsumerId, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.Destination, dataOut);
        LooseMarshalLong(wireFormat, info.DeliverySequenceId, dataOut);
        LooseMarshalNestedObject(wireFormat, (DataStructure)info.MessageId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessageIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for MessageId
  /// </summary>
  class MessageIdMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new MessageId();
    }

    public override byte GetDataStructureType() 
    {
        return MessageId.ID_MessageId;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        MessageId info = (MessageId)o;
        info.ProducerId = (ProducerId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.ProducerSequenceId = TightUnmarshalLong(wireFormat, dataIn, bs);
        info.BrokerSequenceId = TightUnmarshalLong(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        MessageId info = (MessageId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ProducerId, bs);
        rc += TightMarshalLong1(wireFormat, info.ProducerSequenceId, bs);
        rc += TightMarshalLong1(wireFormat, info.BrokerSequenceId, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        MessageId info = (MessageId)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ProducerId, dataOut, bs);
        TightMarshalLong2(wireFormat, info.ProducerSequenceId, dataOut, bs);
        TightMarshalLong2(wireFormat, info.BrokerSequenceId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        MessageId info = (MessageId)o;
        info.ProducerId = (ProducerId) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.ProducerSequenceId = LooseUnmarshalLong(wireFormat, dataIn);
        info.BrokerSequenceId = LooseUnmarshalLong(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        MessageId info = (MessageId)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ProducerId, dataOut);
        LooseMarshalLong(wireFormat, info.ProducerSequenceId, dataOut);
        LooseMarshalLong(wireFormat, info.BrokerSequenceId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessagePullMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for MessagePull
  /// </summary>
  class MessagePullMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new MessagePull();
    }

    public override byte GetDataStructureType() 
    {
        return MessagePull.ID_MessagePull;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        MessagePull info = (MessagePull)o;
        info.ConsumerId = (ConsumerId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.Destination = (ActiveMQDestination) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.Timeout = TightUnmarshalLong(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        MessagePull info = (MessagePull)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ConsumerId, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.Destination, bs);
        rc += TightMarshalLong1(wireFormat, info.Timeout, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        MessagePull info = (MessagePull)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ConsumerId, dataOut, bs);
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.Destination, dataOut, bs);
        TightMarshalLong2(wireFormat, info.Timeout, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        MessagePull info = (MessagePull)o;
        info.ConsumerId = (ConsumerId) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.Destination = (ActiveMQDestination) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.Timeout = LooseUnmarshalLong(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        MessagePull info = (MessagePull)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ConsumerId, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.Destination, dataOut);
        LooseMarshalLong(wireFormat, info.Timeout, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/NetworkBridgeFilterMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for NetworkBridgeFilter
  /// </summary>
  class NetworkBridgeFilterMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new NetworkBridgeFilter();
    }

    public override byte GetDataStructureType() 
    {
        return NetworkBridgeFilter.ID_NetworkBridgeFilter;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        NetworkBridgeFilter info = (NetworkBridgeFilter)o;
        info.NetworkTTL = dataIn.ReadInt32();
        info.NetworkBrokerId = (BrokerId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        NetworkBridgeFilter info = (NetworkBridgeFilter)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.NetworkBrokerId, bs);

        return rc + 4;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        NetworkBridgeFilter info = (NetworkBridgeFilter)o;
        dataOut.Write(info.NetworkTTL);
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.NetworkBrokerId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        NetworkBridgeFilter info = (NetworkBridgeFilter)o;
        info.NetworkTTL = dataIn.ReadInt32();
        info.NetworkBrokerId = (BrokerId) LooseUnmarshalCachedObject(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        NetworkBridgeFilter info = (NetworkBridgeFilter)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.NetworkTTL);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.NetworkBrokerId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/PartialCommandMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for PartialCommand
  /// </summary>
  class PartialCommandMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new PartialCommand();
    }

    public override byte GetDataStructureType() 
    {
        return PartialCommand.ID_PartialCommand;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        PartialCommand info = (PartialCommand)o;
        info.CommandId = dataIn.ReadInt32();
        info.Data = ReadBytes(dataIn, bs.ReadBoolean());

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        PartialCommand info = (PartialCommand)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        bs.WriteBoolean(info.Data!=null);
        rc += info.Data==null ? 0 : info.Data.Length+4;

        return rc + 4;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        PartialCommand info = (PartialCommand)o;
        dataOut.Write(info.CommandId);
        if(bs.ReadBoolean()) {
           dataOut.Write(info.Data.Length);
           dataOut.Write(info.Data);
        }

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        PartialCommand info = (PartialCommand)o;
        info.CommandId = dataIn.ReadInt32();
        info.Data = ReadBytes(dataIn, dataIn.ReadBoolean());

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        PartialCommand info = (PartialCommand)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.CommandId);
        dataOut.Write(info.Data!=null);
        if(info.Data!=null) {
           dataOut.Write(info.Data.Length);
           dataOut.Write(info.Data);
        }

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ProducerIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ProducerId
  /// </summary>
  class ProducerIdMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ProducerId();
    }

    public override byte GetDataStructureType() 
    {
        return ProducerId.ID_ProducerId;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ProducerId info = (ProducerId)o;
        info.ConnectionId = TightUnmarshalString(dataIn, bs);
        info.Value = TightUnmarshalLong(wireFormat, dataIn, bs);
        info.SessionId = TightUnmarshalLong(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ProducerId info = (ProducerId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.ConnectionId, bs);
        rc += TightMarshalLong1(wireFormat, info.Value, bs);
        rc += TightMarshalLong1(wireFormat, info.SessionId, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ProducerId info = (ProducerId)o;
        TightMarshalString2(info.ConnectionId, dataOut, bs);
        TightMarshalLong2(wireFormat, info.Value, dataOut, bs);
        TightMarshalLong2(wireFormat, info.SessionId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ProducerId info = (ProducerId)o;
        info.ConnectionId = LooseUnmarshalString(dataIn);
        info.Value = LooseUnmarshalLong(wireFormat, dataIn);
        info.SessionId = LooseUnmarshalLong(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ProducerId info = (ProducerId)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.ConnectionId, dataOut);
        LooseMarshalLong(wireFormat, info.Value, dataOut);
        LooseMarshalLong(wireFormat, info.SessionId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ProducerInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ProducerInfo
  /// </summary>
  class ProducerInfoMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ProducerInfo();
    }

    public override byte GetDataStructureType() 
    {
        return ProducerInfo.ID_ProducerInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ProducerInfo info = (ProducerInfo)o;
        info.ProducerId = (ProducerId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.Destination = (ActiveMQDestination) TightUnmarshalCachedObject(wireFormat, dataIn, bs);

        if (bs.ReadBoolean()) {
            short size = dataIn.ReadInt16();
            BrokerId[] value = new BrokerId[size];
            for( int i=0; i < size; i++ ) {
                value[i] = (BrokerId) TightUnmarshalNestedObject(wireFormat,dataIn, bs);
            }
            info.BrokerPath = value;
        }
        else {
            info.BrokerPath = null;
        }

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ProducerInfo info = (ProducerInfo)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ProducerId, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.Destination, bs);
        rc += TightMarshalObjectArray1(wireFormat, info.BrokerPath, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ProducerInfo info = (ProducerInfo)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ProducerId, dataOut, bs);
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.Destination, dataOut, bs);
        TightMarshalObjectArray2(wireFormat, info.BrokerPath, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ProducerInfo info = (ProducerInfo)o;
        info.ProducerId = (ProducerId) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.Destination = (ActiveMQDestination) LooseUnmarshalCachedObject(wireFormat, dataIn);

        if (dataIn.ReadBoolean()) {
            short size = dataIn.ReadInt16();
            BrokerId[] value = new BrokerId[size];
            for( int i=0; i < size; i++ ) {
                value[i] = (BrokerId) LooseUnmarshalNestedObject(wireFormat,dataIn);
            }
            info.BrokerPath = value;
        }
        else {
            info.BrokerPath = null;
        }

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ProducerInfo info = (ProducerInfo)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ProducerId, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.Destination, dataOut);
        LooseMarshalObjectArray(wireFormat, info.BrokerPath, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/RemoveInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for RemoveInfo
  /// </summary>
  class RemoveInfoMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new RemoveInfo();
    }

    public override byte GetDataStructureType() 
    {
        return RemoveInfo.ID_RemoveInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        RemoveInfo info = (RemoveInfo)o;
        info.ObjectId = (DataStructure) TightUnmarshalCachedObject(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        RemoveInfo info = (RemoveInfo)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ObjectId, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        RemoveInfo info = (RemoveInfo)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ObjectId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        RemoveInfo info = (RemoveInfo)o;
        info.ObjectId = (DataStructure) LooseUnmarshalCachedObject(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        RemoveInfo info = (RemoveInfo)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ObjectId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/RemoveSubscriptionInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for RemoveSubscriptionInfo
  /// </summary>
  class RemoveSubscriptionInfoMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new RemoveSubscriptionInfo();
    }

    public override byte GetDataStructureType() 
    {
        return RemoveSubscriptionInfo.ID_RemoveSubscriptionInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o;
        info.ConnectionId = (ConnectionId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.SubcriptionName = TightUnmarshalString(dataIn, bs);
        info.ClientId = TightUnmarshalString(dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ConnectionId, bs);
        rc += TightMarshalString1(info.SubcriptionName, bs);
        rc += TightMarshalString1(info.ClientId, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ConnectionId, dataOut, bs);
        TightMarshalString2(info.SubcriptionName, dataOut, bs);
        TightMarshalString2(info.ClientId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o;
        info.ConnectionId = (ConnectionId) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.SubcriptionName = LooseUnmarshalString(dataIn);
        info.ClientId = LooseUnmarshalString(dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        RemoveSubscriptionInfo info = (RemoveSubscriptionInfo)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ConnectionId, dataOut);
        LooseMarshalString(info.SubcriptionName, dataOut);
        LooseMarshalString(info.ClientId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ReplayCommandMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ReplayCommand
  /// </summary>
  class ReplayCommandMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ReplayCommand();
    }

    public override byte GetDataStructureType() 
    {
        return ReplayCommand.ID_ReplayCommand;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        ReplayCommand info = (ReplayCommand)o;
        info.FirstNakNumber = dataIn.ReadInt32();
        info.LastNakNumber = dataIn.ReadInt32();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ReplayCommand info = (ReplayCommand)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 8;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        ReplayCommand info = (ReplayCommand)o;
        dataOut.Write(info.FirstNakNumber);
        dataOut.Write(info.LastNakNumber);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        ReplayCommand info = (ReplayCommand)o;
        info.FirstNakNumber = dataIn.ReadInt32();
        info.LastNakNumber = dataIn.ReadInt32();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        ReplayCommand info = (ReplayCommand)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.FirstNakNumber);
        dataOut.Write(info.LastNakNumber);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ResponseMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for Response
  /// </summary>
  class ResponseMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new Response();
    }

    public override byte GetDataStructureType() 
    {
        return Response.ID_Response;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        Response info = (Response)o;
        info.CorrelationId = dataIn.ReadInt32();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        Response info = (Response)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 4;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        Response info = (Response)o;
        dataOut.Write(info.CorrelationId);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        Response info = (Response)o;
        info.CorrelationId = dataIn.ReadInt32();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        Response info = (Response)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.CorrelationId);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/SessionIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for SessionId
  /// </summary>
  class SessionIdMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new SessionId();
    }

    public override byte GetDataStructureType() 
    {
        return SessionId.ID_SessionId;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        SessionId info = (SessionId)o;
        info.ConnectionId = TightUnmarshalString(dataIn, bs);
        info.Value = TightUnmarshalLong(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        SessionId info = (SessionId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.ConnectionId, bs);
        rc += TightMarshalLong1(wireFormat, info.Value, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        SessionId info = (SessionId)o;
        TightMarshalString2(info.ConnectionId, dataOut, bs);
        TightMarshalLong2(wireFormat, info.Value, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        SessionId info = (SessionId)o;
        info.ConnectionId = LooseUnmarshalString(dataIn);
        info.Value = LooseUnmarshalLong(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        SessionId info = (SessionId)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.ConnectionId, dataOut);
        LooseMarshalLong(wireFormat, info.Value, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/SessionInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for SessionInfo
  /// </summary>
  class SessionInfoMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new SessionInfo();
    }

    public override byte GetDataStructureType() 
    {
        return SessionInfo.ID_SessionInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        SessionInfo info = (SessionInfo)o;
        info.SessionId = (SessionId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        SessionInfo info = (SessionInfo)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.SessionId, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        SessionInfo info = (SessionInfo)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.SessionId, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        SessionInfo info = (SessionInfo)o;
        info.SessionId = (SessionId) LooseUnmarshalCachedObject(wireFormat, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        SessionInfo info = (SessionInfo)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.SessionId, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ShutdownInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for ShutdownInfo
  /// </summary>
  class ShutdownInfoMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new ShutdownInfo();
    }

    public override byte GetDataStructureType() 
    {
        return ShutdownInfo.ID_ShutdownInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        ShutdownInfo info = (ShutdownInfo)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/SubscriptionInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for SubscriptionInfo
  /// </summary>
  class SubscriptionInfoMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new SubscriptionInfo();
    }

    public override byte GetDataStructureType() 
    {
        return SubscriptionInfo.ID_SubscriptionInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        SubscriptionInfo info = (SubscriptionInfo)o;
        info.ClientId = TightUnmarshalString(dataIn, bs);
        info.Destination = (ActiveMQDestination) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.Selector = TightUnmarshalString(dataIn, bs);
        info.SubcriptionName = TightUnmarshalString(dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        SubscriptionInfo info = (SubscriptionInfo)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalString1(info.ClientId, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.Destination, bs);
        rc += TightMarshalString1(info.Selector, bs);
        rc += TightMarshalString1(info.SubcriptionName, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        SubscriptionInfo info = (SubscriptionInfo)o;
        TightMarshalString2(info.ClientId, dataOut, bs);
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.Destination, dataOut, bs);
        TightMarshalString2(info.Selector, dataOut, bs);
        TightMarshalString2(info.SubcriptionName, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        SubscriptionInfo info = (SubscriptionInfo)o;
        info.ClientId = LooseUnmarshalString(dataIn);
        info.Destination = (ActiveMQDestination) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.Selector = LooseUnmarshalString(dataIn);
        info.SubcriptionName = LooseUnmarshalString(dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        SubscriptionInfo info = (SubscriptionInfo)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalString(info.ClientId, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.Destination, dataOut);
        LooseMarshalString(info.Selector, dataOut);
        LooseMarshalString(info.SubcriptionName, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/TransactionIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for TransactionId
  /// </summary>
  abstract class TransactionIdMarshaller : BaseDataStreamMarshaller
  {

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        TransactionId info = (TransactionId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);

        return rc + 0;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        base.LooseMarshal(wireFormat, o, dataOut);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/TransactionInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for TransactionInfo
  /// </summary>
  class TransactionInfoMarshaller : BaseCommandMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new TransactionInfo();
    }

    public override byte GetDataStructureType() 
    {
        return TransactionInfo.ID_TransactionInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        TransactionInfo info = (TransactionInfo)o;
        info.ConnectionId = (ConnectionId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.TransactionId = (TransactionId) TightUnmarshalCachedObject(wireFormat, dataIn, bs);
        info.Type = dataIn.ReadByte();

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        TransactionInfo info = (TransactionInfo)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.ConnectionId, bs);
        rc += TightMarshalCachedObject1(wireFormat, (DataStructure)info.TransactionId, bs);

        return rc + 1;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        TransactionInfo info = (TransactionInfo)o;
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.ConnectionId, dataOut, bs);
        TightMarshalCachedObject2(wireFormat, (DataStructure)info.TransactionId, dataOut, bs);
        dataOut.Write(info.Type);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        TransactionInfo info = (TransactionInfo)o;
        info.ConnectionId = (ConnectionId) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.TransactionId = (TransactionId) LooseUnmarshalCachedObject(wireFormat, dataIn);
        info.Type = dataIn.ReadByte();

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        TransactionInfo info = (TransactionInfo)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.ConnectionId, dataOut);
        LooseMarshalCachedObject(wireFormat, (DataStructure)info.TransactionId, dataOut);
        dataOut.Write(info.Type);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/WireFormatInfoMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for WireFormatInfo
  /// </summary>
  class WireFormatInfoMarshaller : BaseDataStreamMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new WireFormatInfo();
    }

    public override byte GetDataStructureType() 
    {
        return WireFormatInfo.ID_WireFormatInfo;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        WireFormatInfo info = (WireFormatInfo)o;

        info.BeforeUnmarshall(wireFormat);
        
        info.Magic = ReadBytes(dataIn, 8);
        info.Version = dataIn.ReadInt32();
        info.MarshalledProperties = ReadBytes(dataIn, bs.ReadBoolean());

        info.AfterUnmarshall(wireFormat);

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        WireFormatInfo info = (WireFormatInfo)o;

        info.BeforeMarshall(wireFormat);

        int rc = base.TightMarshal1(wireFormat, info, bs);
        bs.WriteBoolean(info.MarshalledProperties!=null);
        rc += info.MarshalledProperties==null ? 0 : info.MarshalledProperties.Length+4;

        return rc + 12;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        WireFormatInfo info = (WireFormatInfo)o;
        dataOut.Write(info.Magic, 0, 8);
        dataOut.Write(info.Version);
        if(bs.ReadBoolean()) {
           dataOut.Write(info.MarshalledProperties.Length);
           dataOut.Write(info.MarshalledProperties);
        }

        info.AfterMarshall(wireFormat);

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        WireFormatInfo info = (WireFormatInfo)o;

        info.BeforeUnmarshall(wireFormat);
        
        info.Magic = ReadBytes(dataIn, 8);
        info.Version = dataIn.ReadInt32();
        info.MarshalledProperties = ReadBytes(dataIn, dataIn.ReadBoolean());

        info.AfterUnmarshall(wireFormat);

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        WireFormatInfo info = (WireFormatInfo)o;

        info.BeforeMarshall(wireFormat);

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.Magic, 0, 8);
        dataOut.Write(info.Version);
        dataOut.Write(info.MarshalledProperties!=null);
        if(info.MarshalledProperties!=null) {
           dataOut.Write(info.MarshalledProperties.Length);
           dataOut.Write(info.MarshalledProperties);
        }

        info.AfterMarshall(wireFormat);

    }
    
  }
}

activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/XATransactionIdMarshaller.cs

@@ -0,0 +1 @@
+/*
* 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.
*/

//
// NOTE!: This file is autogenerated - do not modify!
//        if you need to make a change, please see the Groovy scripts in the
//        activemq-core module
//

using System;
using System.Collections;
using System.IO;

using ActiveMQ.Commands;
using ActiveMQ.OpenWire;
using ActiveMQ.OpenWire.V2;

namespace ActiveMQ.OpenWire.V2
{
  /// <summary>
  ///  Marshalling code for Open Wire Format for XATransactionId
  /// </summary>
  class XATransactionIdMarshaller : TransactionIdMarshaller
  {


    public override DataStructure CreateObject() 
    {
        return new XATransactionId();
    }

    public override byte GetDataStructureType() 
    {
        return XATransactionId.ID_XATransactionId;
    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void TightUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn, BooleanStream bs) 
    {
        base.TightUnmarshal(wireFormat, o, dataIn, bs);

        XATransactionId info = (XATransactionId)o;
        info.FormatId = dataIn.ReadInt32();
        info.GlobalTransactionId = ReadBytes(dataIn, bs.ReadBoolean());
        info.BranchQualifier = ReadBytes(dataIn, bs.ReadBoolean());

    }

    //
    // Write the booleans that this object uses to a BooleanStream
    //
    public override int TightMarshal1(OpenWireFormat wireFormat, Object o, BooleanStream bs) {
        XATransactionId info = (XATransactionId)o;

        int rc = base.TightMarshal1(wireFormat, info, bs);
        bs.WriteBoolean(info.GlobalTransactionId!=null);
        rc += info.GlobalTransactionId==null ? 0 : info.GlobalTransactionId.Length+4;
        bs.WriteBoolean(info.BranchQualifier!=null);
        rc += info.BranchQualifier==null ? 0 : info.BranchQualifier.Length+4;

        return rc + 4;
    }

    // 
    // Write a object instance to data output stream
    //
    public override void TightMarshal2(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut, BooleanStream bs) {
        base.TightMarshal2(wireFormat, o, dataOut, bs);

        XATransactionId info = (XATransactionId)o;
        dataOut.Write(info.FormatId);
        if(bs.ReadBoolean()) {
           dataOut.Write(info.GlobalTransactionId.Length);
           dataOut.Write(info.GlobalTransactionId);
        }
        if(bs.ReadBoolean()) {
           dataOut.Write(info.BranchQualifier.Length);
           dataOut.Write(info.BranchQualifier);
        }

    }

    // 
    // Un-marshal an object instance from the data input stream
    // 
    public override void LooseUnmarshal(OpenWireFormat wireFormat, Object o, BinaryReader dataIn) 
    {
        base.LooseUnmarshal(wireFormat, o, dataIn);

        XATransactionId info = (XATransactionId)o;
        info.FormatId = dataIn.ReadInt32();
        info.GlobalTransactionId = ReadBytes(dataIn, dataIn.ReadBoolean());
        info.BranchQualifier = ReadBytes(dataIn, dataIn.ReadBoolean());

    }

    // 
    // Write a object instance to data output stream
    //
    public override void LooseMarshal(OpenWireFormat wireFormat, Object o, BinaryWriter dataOut) {

        XATransactionId info = (XATransactionId)o;

        base.LooseMarshal(wireFormat, o, dataOut);
        dataOut.Write(info.FormatId);
        dataOut.Write(info.GlobalTransactionId!=null);
        if(info.GlobalTransactionId!=null) {
           dataOut.Write(info.GlobalTransactionId.Length);
           dataOut.Write(info.GlobalTransactionId);
        }
        dataOut.Write(info.BranchQualifier!=null);
        if(info.BranchQualifier!=null) {
           dataOut.Write(info.BranchQualifier.Length);
           dataOut.Write(info.BranchQualifier);
        }

    }
    
  }
}

openwire-c/src/libopenwire/ow_commands_v2.h

@@ -0,0 +1,900 @@
+/**
+ *
+ * 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.
+ */
+
+/*****************************************************************************************
+ *  
+ * 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.
+ *  
+ *****************************************************************************************/
+ 
+#ifndef OW_COMMANDS_V2_H
+#define OW_COMMANDS_V2_H
+
+#include "ow.h"
+#include "ow_command_types_v2.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+      
+#define OW_WIREFORMAT_VERSION 2
+      
+apr_status_t ow_bitmarshall(ow_bit_buffer *buffer, ow_DataStructure *object);
+apr_status_t ow_marshall(ow_byte_buffer *buffer, ow_DataStructure *object);
+
+typedef struct ow_LocalTransactionId {
+
+   ow_byte structType;
+   ow_long value;
+   struct ow_ConnectionId *connectionId;
+
+} ow_LocalTransactionId;
+ow_LocalTransactionId *ow_LocalTransactionId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_LocalTransactionId(ow_DataStructure *object);
+
+typedef struct ow_PartialCommand {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_byte_array *data;
+
+} ow_PartialCommand;
+ow_PartialCommand *ow_PartialCommand_create(apr_pool_t *pool);
+ow_boolean ow_is_a_PartialCommand(ow_DataStructure *object);
+
+typedef struct ow_IntegerResponse {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_int correlationId;
+   ow_int result;
+
+} ow_IntegerResponse;
+ow_IntegerResponse *ow_IntegerResponse_create(apr_pool_t *pool);
+ow_boolean ow_is_a_IntegerResponse(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQQueue {
+
+   ow_byte structType;
+   ow_string *physicalName;
+
+} ow_ActiveMQQueue;
+ow_ActiveMQQueue *ow_ActiveMQQueue_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQQueue(ow_DataStructure *object);
+
+typedef struct ow_TransactionId {
+
+   ow_byte structType;
+
+} ow_TransactionId;
+ow_TransactionId *ow_TransactionId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_TransactionId(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQObjectMessage {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ProducerId *producerId;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_TransactionId *transactionId;
+   struct ow_ActiveMQDestination *originalDestination;
+   struct ow_MessageId *messageId;
+   struct ow_TransactionId *originalTransactionId;
+   ow_string *groupID;
+   ow_int groupSequence;
+   ow_string *correlationId;
+   ow_boolean persistent;
+   ow_long expiration;
+   ow_byte priority;
+   struct ow_ActiveMQDestination *replyTo;
+   ow_long timestamp;
+   ow_string *type;
+   struct ow_ByteSequence *content;
+   struct ow_ByteSequence *marshalledProperties;
+   struct ow_DataStructure *dataStructure;
+   struct ow_ConsumerId *targetConsumerId;
+   ow_boolean compressed;
+   ow_int redeliveryCounter;
+   ow_DataStructure_array *brokerPath;
+   ow_long arrival;
+   ow_string *userID;
+   ow_boolean recievedByDFBridge;
+
+} ow_ActiveMQObjectMessage;
+ow_ActiveMQObjectMessage *ow_ActiveMQObjectMessage_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQObjectMessage(ow_DataStructure *object);
+
+typedef struct ow_ConnectionId {
+
+   ow_byte structType;
+   ow_string *value;
+
+} ow_ConnectionId;
+ow_ConnectionId *ow_ConnectionId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ConnectionId(ow_DataStructure *object);
+
+typedef struct ow_ConnectionInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ConnectionId *connectionId;
+   ow_string *clientId;
+   ow_string *password;
+   ow_string *userName;
+   ow_DataStructure_array *brokerPath;
+   ow_boolean brokerMasterConnector;
+   ow_boolean manageable;
+
+} ow_ConnectionInfo;
+ow_ConnectionInfo *ow_ConnectionInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ConnectionInfo(ow_DataStructure *object);
+
+typedef struct ow_ProducerInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ProducerId *producerId;
+   struct ow_ActiveMQDestination *destination;
+   ow_DataStructure_array *brokerPath;
+
+} ow_ProducerInfo;
+ow_ProducerInfo *ow_ProducerInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ProducerInfo(ow_DataStructure *object);
+
+typedef struct ow_MessageDispatchNotification {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ConsumerId *consumerId;
+   struct ow_ActiveMQDestination *destination;
+   ow_long deliverySequenceId;
+   struct ow_MessageId *messageId;
+
+} ow_MessageDispatchNotification;
+ow_MessageDispatchNotification *ow_MessageDispatchNotification_create(apr_pool_t *pool);
+ow_boolean ow_is_a_MessageDispatchNotification(ow_DataStructure *object);
+
+typedef struct ow_SessionInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_SessionId *sessionId;
+
+} ow_SessionInfo;
+ow_SessionInfo *ow_SessionInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_SessionInfo(ow_DataStructure *object);
+
+typedef struct ow_TransactionInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ConnectionId *connectionId;
+   struct ow_TransactionId *transactionId;
+   ow_byte type;
+
+} ow_TransactionInfo;
+ow_TransactionInfo *ow_TransactionInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_TransactionInfo(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQStreamMessage {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ProducerId *producerId;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_TransactionId *transactionId;
+   struct ow_ActiveMQDestination *originalDestination;
+   struct ow_MessageId *messageId;
+   struct ow_TransactionId *originalTransactionId;
+   ow_string *groupID;
+   ow_int groupSequence;
+   ow_string *correlationId;
+   ow_boolean persistent;
+   ow_long expiration;
+   ow_byte priority;
+   struct ow_ActiveMQDestination *replyTo;
+   ow_long timestamp;
+   ow_string *type;
+   struct ow_ByteSequence *content;
+   struct ow_ByteSequence *marshalledProperties;
+   struct ow_DataStructure *dataStructure;
+   struct ow_ConsumerId *targetConsumerId;
+   ow_boolean compressed;
+   ow_int redeliveryCounter;
+   ow_DataStructure_array *brokerPath;
+   ow_long arrival;
+   ow_string *userID;
+   ow_boolean recievedByDFBridge;
+
+} ow_ActiveMQStreamMessage;
+ow_ActiveMQStreamMessage *ow_ActiveMQStreamMessage_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQStreamMessage(ow_DataStructure *object);
+
+typedef struct ow_MessageAck {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_TransactionId *transactionId;
+   struct ow_ConsumerId *consumerId;
+   ow_byte ackType;
+   struct ow_MessageId *firstMessageId;
+   struct ow_MessageId *lastMessageId;
+   ow_int messageCount;
+
+} ow_MessageAck;
+ow_MessageAck *ow_MessageAck_create(apr_pool_t *pool);
+ow_boolean ow_is_a_MessageAck(ow_DataStructure *object);
+
+typedef struct ow_ProducerId {
+
+   ow_byte structType;
+   ow_string *connectionId;
+   ow_long value;
+   ow_long sessionId;
+
+} ow_ProducerId;
+ow_ProducerId *ow_ProducerId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ProducerId(ow_DataStructure *object);
+
+typedef struct ow_MessageId {
+
+   ow_byte structType;
+   struct ow_ProducerId *producerId;
+   ow_long producerSequenceId;
+   ow_long brokerSequenceId;
+
+} ow_MessageId;
+ow_MessageId *ow_MessageId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_MessageId(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQTempQueue {
+
+   ow_byte structType;
+   ow_string *physicalName;
+
+} ow_ActiveMQTempQueue;
+ow_ActiveMQTempQueue *ow_ActiveMQTempQueue_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQTempQueue(ow_DataStructure *object);
+
+typedef struct ow_RemoveSubscriptionInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ConnectionId *connectionId;
+   ow_string *subcriptionName;
+   ow_string *clientId;
+
+} ow_RemoveSubscriptionInfo;
+ow_RemoveSubscriptionInfo *ow_RemoveSubscriptionInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_RemoveSubscriptionInfo(ow_DataStructure *object);
+
+typedef struct ow_SessionId {
+
+   ow_byte structType;
+   ow_string *connectionId;
+   ow_long value;
+
+} ow_SessionId;
+ow_SessionId *ow_SessionId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_SessionId(ow_DataStructure *object);
+
+typedef struct ow_DataArrayResponse {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_int correlationId;
+   ow_DataStructure_array *data;
+
+} ow_DataArrayResponse;
+ow_DataArrayResponse *ow_DataArrayResponse_create(apr_pool_t *pool);
+ow_boolean ow_is_a_DataArrayResponse(ow_DataStructure *object);
+
+typedef struct ow_JournalQueueAck {
+
+   ow_byte structType;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_MessageAck *messageAck;
+
+} ow_JournalQueueAck;
+ow_JournalQueueAck *ow_JournalQueueAck_create(apr_pool_t *pool);
+ow_boolean ow_is_a_JournalQueueAck(ow_DataStructure *object);
+
+typedef struct ow_Response {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_int correlationId;
+
+} ow_Response;
+ow_Response *ow_Response_create(apr_pool_t *pool);
+ow_boolean ow_is_a_Response(ow_DataStructure *object);
+
+typedef struct ow_ConnectionError {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_throwable *exception;
+   struct ow_ConnectionId *connectionId;
+
+} ow_ConnectionError;
+ow_ConnectionError *ow_ConnectionError_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ConnectionError(ow_DataStructure *object);
+
+typedef struct ow_ConsumerInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ConsumerId *consumerId;
+   ow_boolean browser;
+   struct ow_ActiveMQDestination *destination;
+   ow_int prefetchSize;
+   ow_int maximumPendingMessageLimit;
+   ow_boolean dispatchAsync;
+   ow_string *selector;
+   ow_string *subcriptionName;
+   ow_boolean noLocal;
+   ow_boolean exclusive;
+   ow_boolean retroactive;
+   ow_byte priority;
+   ow_DataStructure_array *brokerPath;
+   struct ow_BooleanExpression *additionalPredicate;
+   ow_boolean networkSubscription;
+   ow_boolean optimizedAcknowledge;
+   ow_boolean noRangeAcks;
+
+} ow_ConsumerInfo;
+ow_ConsumerInfo *ow_ConsumerInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ConsumerInfo(ow_DataStructure *object);
+
+typedef struct ow_XATransactionId {
+
+   ow_byte structType;
+   ow_int formatId;
+   ow_byte_array *globalTransactionId;
+   ow_byte_array *branchQualifier;
+
+} ow_XATransactionId;
+ow_XATransactionId *ow_XATransactionId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_XATransactionId(ow_DataStructure *object);
+
+typedef struct ow_JournalTrace {
+
+   ow_byte structType;
+   ow_string *message;
+
+} ow_JournalTrace;
+ow_JournalTrace *ow_JournalTrace_create(apr_pool_t *pool);
+ow_boolean ow_is_a_JournalTrace(ow_DataStructure *object);
+
+typedef struct ow_ConsumerId {
+
+   ow_byte structType;
+   ow_string *connectionId;
+   ow_long sessionId;
+   ow_long value;
+
+} ow_ConsumerId;
+ow_ConsumerId *ow_ConsumerId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ConsumerId(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQTextMessage {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ProducerId *producerId;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_TransactionId *transactionId;
+   struct ow_ActiveMQDestination *originalDestination;
+   struct ow_MessageId *messageId;
+   struct ow_TransactionId *originalTransactionId;
+   ow_string *groupID;
+   ow_int groupSequence;
+   ow_string *correlationId;
+   ow_boolean persistent;
+   ow_long expiration;
+   ow_byte priority;
+   struct ow_ActiveMQDestination *replyTo;
+   ow_long timestamp;
+   ow_string *type;
+   struct ow_ByteSequence *content;
+   struct ow_ByteSequence *marshalledProperties;
+   struct ow_DataStructure *dataStructure;
+   struct ow_ConsumerId *targetConsumerId;
+   ow_boolean compressed;
+   ow_int redeliveryCounter;
+   ow_DataStructure_array *brokerPath;
+   ow_long arrival;
+   ow_string *userID;
+   ow_boolean recievedByDFBridge;
+
+} ow_ActiveMQTextMessage;
+ow_ActiveMQTextMessage *ow_ActiveMQTextMessage_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQTextMessage(ow_DataStructure *object);
+
+typedef struct ow_SubscriptionInfo {
+
+   ow_byte structType;
+   ow_string *clientId;
+   struct ow_ActiveMQDestination *destination;
+   ow_string *selector;
+   ow_string *subcriptionName;
+
+} ow_SubscriptionInfo;
+ow_SubscriptionInfo *ow_SubscriptionInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_SubscriptionInfo(ow_DataStructure *object);
+
+typedef struct ow_JournalTransaction {
+
+   ow_byte structType;
+   struct ow_TransactionId *transactionId;
+   ow_byte type;
+   ow_boolean wasPrepared;
+
+} ow_JournalTransaction;
+ow_JournalTransaction *ow_JournalTransaction_create(apr_pool_t *pool);
+ow_boolean ow_is_a_JournalTransaction(ow_DataStructure *object);
+
+typedef struct ow_ControlCommand {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_string *command;
+
+} ow_ControlCommand;
+ow_ControlCommand *ow_ControlCommand_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ControlCommand(ow_DataStructure *object);
+
+typedef struct ow_LastPartialCommand {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_byte_array *data;
+
+} ow_LastPartialCommand;
+ow_LastPartialCommand *ow_LastPartialCommand_create(apr_pool_t *pool);
+ow_boolean ow_is_a_LastPartialCommand(ow_DataStructure *object);
+
+typedef struct ow_NetworkBridgeFilter {
+
+   ow_byte structType;
+   ow_int networkTTL;
+   struct ow_BrokerId *networkBrokerId;
+
+} ow_NetworkBridgeFilter;
+ow_NetworkBridgeFilter *ow_NetworkBridgeFilter_create(apr_pool_t *pool);
+ow_boolean ow_is_a_NetworkBridgeFilter(ow_DataStructure *object);
+
+typedef struct ow_MessagePull {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ConsumerId *consumerId;
+   struct ow_ActiveMQDestination *destination;
+   ow_long timeout;
+
+} ow_MessagePull;
+ow_MessagePull *ow_MessagePull_create(apr_pool_t *pool);
+ow_boolean ow_is_a_MessagePull(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQBytesMessage {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ProducerId *producerId;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_TransactionId *transactionId;
+   struct ow_ActiveMQDestination *originalDestination;
+   struct ow_MessageId *messageId;
+   struct ow_TransactionId *originalTransactionId;
+   ow_string *groupID;
+   ow_int groupSequence;
+   ow_string *correlationId;
+   ow_boolean persistent;
+   ow_long expiration;
+   ow_byte priority;
+   struct ow_ActiveMQDestination *replyTo;
+   ow_long timestamp;
+   ow_string *type;
+   struct ow_ByteSequence *content;
+   struct ow_ByteSequence *marshalledProperties;
+   struct ow_DataStructure *dataStructure;
+   struct ow_ConsumerId *targetConsumerId;
+   ow_boolean compressed;
+   ow_int redeliveryCounter;
+   ow_DataStructure_array *brokerPath;
+   ow_long arrival;
+   ow_string *userID;
+   ow_boolean recievedByDFBridge;
+
+} ow_ActiveMQBytesMessage;
+ow_ActiveMQBytesMessage *ow_ActiveMQBytesMessage_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQBytesMessage(ow_DataStructure *object);
+
+typedef struct ow_WireFormatInfo {
+
+   ow_byte structType;
+   ow_byte_array *magic;
+   ow_int version;
+   struct ow_ByteSequence *marshalledProperties;
+
+} ow_WireFormatInfo;
+ow_WireFormatInfo *ow_WireFormatInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_WireFormatInfo(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQTempTopic {
+
+   ow_byte structType;
+   ow_string *physicalName;
+
+} ow_ActiveMQTempTopic;
+ow_ActiveMQTempTopic *ow_ActiveMQTempTopic_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQTempTopic(ow_DataStructure *object);
+
+typedef struct ow_DiscoveryEvent {
+
+   ow_byte structType;
+   ow_string *serviceName;
+   ow_string *brokerName;
+
+} ow_DiscoveryEvent;
+ow_DiscoveryEvent *ow_DiscoveryEvent_create(apr_pool_t *pool);
+ow_boolean ow_is_a_DiscoveryEvent(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQTempDestination {
+
+   ow_byte structType;
+   ow_string *physicalName;
+
+} ow_ActiveMQTempDestination;
+ow_ActiveMQTempDestination *ow_ActiveMQTempDestination_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQTempDestination(ow_DataStructure *object);
+
+typedef struct ow_ReplayCommand {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_int firstNakNumber;
+   ow_int lastNakNumber;
+
+} ow_ReplayCommand;
+ow_ReplayCommand *ow_ReplayCommand_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ReplayCommand(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQDestination {
+
+   ow_byte structType;
+   ow_string *physicalName;
+
+} ow_ActiveMQDestination;
+ow_ActiveMQDestination *ow_ActiveMQDestination_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQDestination(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQTopic {
+
+   ow_byte structType;
+   ow_string *physicalName;
+
+} ow_ActiveMQTopic;
+ow_ActiveMQTopic *ow_ActiveMQTopic_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQTopic(ow_DataStructure *object);
+
+typedef struct ow_BrokerInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_BrokerId *brokerId;
+   ow_string *brokerURL;
+   ow_DataStructure_array *peerBrokerInfos;
+   ow_string *brokerName;
+   ow_boolean slaveBroker;
+   ow_boolean masterBroker;
+   ow_boolean faultTolerantConfiguration;
+
+} ow_BrokerInfo;
+ow_BrokerInfo *ow_BrokerInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_BrokerInfo(ow_DataStructure *object);
+
+typedef struct ow_DestinationInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ConnectionId *connectionId;
+   struct ow_ActiveMQDestination *destination;
+   ow_byte operationType;
+   ow_long timeout;
+   ow_DataStructure_array *brokerPath;
+
+} ow_DestinationInfo;
+ow_DestinationInfo *ow_DestinationInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_DestinationInfo(ow_DataStructure *object);
+
+typedef struct ow_ShutdownInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+
+} ow_ShutdownInfo;
+ow_ShutdownInfo *ow_ShutdownInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ShutdownInfo(ow_DataStructure *object);
+
+typedef struct ow_DataResponse {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_int correlationId;
+   struct ow_DataStructure *data;
+
+} ow_DataResponse;
+ow_DataResponse *ow_DataResponse_create(apr_pool_t *pool);
+ow_boolean ow_is_a_DataResponse(ow_DataStructure *object);
+
+typedef struct ow_ConnectionControl {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_boolean close;
+   ow_boolean exit;
+   ow_boolean faultTolerant;
+   ow_boolean resume;
+   ow_boolean suspend;
+
+} ow_ConnectionControl;
+ow_ConnectionControl *ow_ConnectionControl_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ConnectionControl(ow_DataStructure *object);
+
+typedef struct ow_KeepAliveInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+
+} ow_KeepAliveInfo;
+ow_KeepAliveInfo *ow_KeepAliveInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_KeepAliveInfo(ow_DataStructure *object);
+
+typedef struct ow_Message {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ProducerId *producerId;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_TransactionId *transactionId;
+   struct ow_ActiveMQDestination *originalDestination;
+   struct ow_MessageId *messageId;
+   struct ow_TransactionId *originalTransactionId;
+   ow_string *groupID;
+   ow_int groupSequence;
+   ow_string *correlationId;
+   ow_boolean persistent;
+   ow_long expiration;
+   ow_byte priority;
+   struct ow_ActiveMQDestination *replyTo;
+   ow_long timestamp;
+   ow_string *type;
+   struct ow_ByteSequence *content;
+   struct ow_ByteSequence *marshalledProperties;
+   struct ow_DataStructure *dataStructure;
+   struct ow_ConsumerId *targetConsumerId;
+   ow_boolean compressed;
+   ow_int redeliveryCounter;
+   ow_DataStructure_array *brokerPath;
+   ow_long arrival;
+   ow_string *userID;
+   ow_boolean recievedByDFBridge;
+
+} ow_Message;
+ow_Message *ow_Message_create(apr_pool_t *pool);
+ow_boolean ow_is_a_Message(ow_DataStructure *object);
+
+typedef struct ow_BaseCommand {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+
+} ow_BaseCommand;
+ow_BaseCommand *ow_BaseCommand_create(apr_pool_t *pool);
+ow_boolean ow_is_a_BaseCommand(ow_DataStructure *object);
+
+typedef struct ow_FlushCommand {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+
+} ow_FlushCommand;
+ow_FlushCommand *ow_FlushCommand_create(apr_pool_t *pool);
+ow_boolean ow_is_a_FlushCommand(ow_DataStructure *object);
+
+typedef struct ow_ConsumerControl {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_boolean close;
+   struct ow_ConsumerId *consumerId;
+   ow_int prefetch;
+
+} ow_ConsumerControl;
+ow_ConsumerControl *ow_ConsumerControl_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ConsumerControl(ow_DataStructure *object);
+
+typedef struct ow_JournalTopicAck {
+
+   ow_byte structType;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_MessageId *messageId;
+   ow_long messageSequenceId;
+   ow_string *subscritionName;
+   ow_string *clientId;
+   struct ow_TransactionId *transactionId;
+
+} ow_JournalTopicAck;
+ow_JournalTopicAck *ow_JournalTopicAck_create(apr_pool_t *pool);
+ow_boolean ow_is_a_JournalTopicAck(ow_DataStructure *object);
+
+typedef struct ow_BrokerId {
+
+   ow_byte structType;
+   ow_string *value;
+
+} ow_BrokerId;
+ow_BrokerId *ow_BrokerId_create(apr_pool_t *pool);
+ow_boolean ow_is_a_BrokerId(ow_DataStructure *object);
+
+typedef struct ow_MessageDispatch {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ConsumerId *consumerId;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_Message *message;
+   ow_int redeliveryCounter;
+
+} ow_MessageDispatch;
+ow_MessageDispatch *ow_MessageDispatch_create(apr_pool_t *pool);
+ow_boolean ow_is_a_MessageDispatch(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQMapMessage {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ProducerId *producerId;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_TransactionId *transactionId;
+   struct ow_ActiveMQDestination *originalDestination;
+   struct ow_MessageId *messageId;
+   struct ow_TransactionId *originalTransactionId;
+   ow_string *groupID;
+   ow_int groupSequence;
+   ow_string *correlationId;
+   ow_boolean persistent;
+   ow_long expiration;
+   ow_byte priority;
+   struct ow_ActiveMQDestination *replyTo;
+   ow_long timestamp;
+   ow_string *type;
+   struct ow_ByteSequence *content;
+   struct ow_ByteSequence *marshalledProperties;
+   struct ow_DataStructure *dataStructure;
+   struct ow_ConsumerId *targetConsumerId;
+   ow_boolean compressed;
+   ow_int redeliveryCounter;
+   ow_DataStructure_array *brokerPath;
+   ow_long arrival;
+   ow_string *userID;
+   ow_boolean recievedByDFBridge;
+
+} ow_ActiveMQMapMessage;
+ow_ActiveMQMapMessage *ow_ActiveMQMapMessage_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQMapMessage(ow_DataStructure *object);
+
+typedef struct ow_ActiveMQMessage {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_ProducerId *producerId;
+   struct ow_ActiveMQDestination *destination;
+   struct ow_TransactionId *transactionId;
+   struct ow_ActiveMQDestination *originalDestination;
+   struct ow_MessageId *messageId;
+   struct ow_TransactionId *originalTransactionId;
+   ow_string *groupID;
+   ow_int groupSequence;
+   ow_string *correlationId;
+   ow_boolean persistent;
+   ow_long expiration;
+   ow_byte priority;
+   struct ow_ActiveMQDestination *replyTo;
+   ow_long timestamp;
+   ow_string *type;
+   struct ow_ByteSequence *content;
+   struct ow_ByteSequence *marshalledProperties;
+   struct ow_DataStructure *dataStructure;
+   struct ow_ConsumerId *targetConsumerId;
+   ow_boolean compressed;
+   ow_int redeliveryCounter;
+   ow_DataStructure_array *brokerPath;
+   ow_long arrival;
+   ow_string *userID;
+   ow_boolean recievedByDFBridge;
+
+} ow_ActiveMQMessage;
+ow_ActiveMQMessage *ow_ActiveMQMessage_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ActiveMQMessage(ow_DataStructure *object);
+
+typedef struct ow_RemoveInfo {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   struct ow_DataStructure *objectId;
+
+} ow_RemoveInfo;
+ow_RemoveInfo *ow_RemoveInfo_create(apr_pool_t *pool);
+ow_boolean ow_is_a_RemoveInfo(ow_DataStructure *object);
+
+typedef struct ow_ExceptionResponse {
+
+   ow_byte structType;
+   ow_int commandId;
+   ow_boolean responseRequired;
+   ow_int correlationId;
+   ow_throwable *exception;
+
+} ow_ExceptionResponse;
+ow_ExceptionResponse *ow_ExceptionResponse_create(apr_pool_t *pool);
+ow_boolean ow_is_a_ExceptionResponse(ow_DataStructure *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* ! OW_COMMANDS_V2_H */

openwire-cpp/src/main/cpp/activemq/command/BrokerId.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/BrokerId.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/BrokerId.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_BrokerId_hpp_
 #define ActiveMQ_BrokerId_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/BrokerInfo.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/BrokerInfo.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/BrokerInfo.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_BrokerInfo_hpp_
 #define ActiveMQ_BrokerInfo_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ConnectionControl.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ConnectionControl.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ConnectionControl.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ConnectionControl_hpp_
 #define ActiveMQ_ConnectionControl_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ConnectionError.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ConnectionError.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ConnectionError.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ConnectionError_hpp_
 #define ActiveMQ_ConnectionError_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ConnectionId.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ConnectionId.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ConnectionId.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ConnectionId_hpp_
 #define ActiveMQ_ConnectionId_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ConnectionInfo.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ConnectionInfo.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ConnectionInfo.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ConnectionInfo_hpp_
 #define ActiveMQ_ConnectionInfo_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ConsumerControl.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ConsumerControl.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ConsumerControl.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ConsumerControl_hpp_
 #define ActiveMQ_ConsumerControl_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ConsumerId.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ConsumerId.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ConsumerId.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ConsumerId_hpp_
 #define ActiveMQ_ConsumerId_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ConsumerInfo.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ConsumerInfo.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ConsumerInfo.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ConsumerInfo_hpp_
 #define ActiveMQ_ConsumerInfo_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ControlCommand.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ControlCommand.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ControlCommand.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ControlCommand_hpp_
 #define ActiveMQ_ControlCommand_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/DataArrayResponse.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/DataArrayResponse.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/DataArrayResponse.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_DataArrayResponse_hpp_
 #define ActiveMQ_DataArrayResponse_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/DataResponse.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/DataResponse.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/DataResponse.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_DataResponse_hpp_
 #define ActiveMQ_DataResponse_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/DestinationInfo.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/DestinationInfo.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/DestinationInfo.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_DestinationInfo_hpp_
 #define ActiveMQ_DestinationInfo_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/DiscoveryEvent.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/DiscoveryEvent.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/DiscoveryEvent.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_DiscoveryEvent_hpp_
 #define ActiveMQ_DiscoveryEvent_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/ExceptionResponse.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/ExceptionResponse.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/ExceptionResponse.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_ExceptionResponse_hpp_
 #define ActiveMQ_ExceptionResponse_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/FlushCommand.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/FlushCommand.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/FlushCommand.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_FlushCommand_hpp_
 #define ActiveMQ_FlushCommand_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/IntegerResponse.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/IntegerResponse.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/IntegerResponse.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_IntegerResponse_hpp_
 #define ActiveMQ_IntegerResponse_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/JournalQueueAck.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/JournalQueueAck.hpp"
 
 using namespace apache::activemq::command;

openwire-cpp/src/main/cpp/activemq/command/JournalQueueAck.hpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #ifndef ActiveMQ_JournalQueueAck_hpp_
 #define ActiveMQ_JournalQueueAck_hpp_
 

openwire-cpp/src/main/cpp/activemq/command/JournalTopicAck.cpp

@@ -1,19 +1,20 @@
 /*
-* Licensed to the Apache Software Foundation (ASF) under one or more
+ *
-* contributor license agreements.  See the NOTICE file distributed with
+ * Licensed to the Apache Software Foundation (ASF) under one or more
-* this work for additional information regarding copyright ownership.
+ * contributor license agreements.  See the NOTICE file distributed with
-* The ASF licenses this file to You under the Apache License, Version 2.0
+ * this work for additional information regarding copyright ownership.
-* (the "License"); you may not use this file except in compliance with
+ * The ASF licenses this file to You under the Apache License, Version 2.0
-* the License.  You may obtain a copy of the License at
+ * (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
+ *
-*
+ * 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,
+ * Unless required by applicable law or agreed to in writing, software
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * distributed under the License is distributed on an "AS IS" BASIS,
-* See the License for the specific language governing permissions and
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* limitations under the License.
+ * See the License for the specific language governing permissions and
-*/
+ * limitations under the License.
+ */
 #include "activemq/command/JournalTopicAck.hpp"
 
 using namespace apache::activemq::command;