Apache
/
activemq
mirror of https://github.com/apache/activemq.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
James Strachan 2006-08-10 19:51:56 +00:00
parent 1ff8046990
commit cd9ce2e93d
273 changed files with 11338 additions and 1320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
activemq-dotnet/src/main/csharp/ActiveMQ/Commands/MessagePull.cs Normal file
View File

@ -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; } } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQBytesMessageMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQDestinationMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQMapMessageMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQMessageMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQObjectMessageMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQQueueMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQStreamMessageMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTempDestinationMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTempQueueMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTempTopicMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTextMessageMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ActiveMQTopicMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/BaseCommandMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/BrokerIdMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/BrokerInfoMarshaller.cs Normal file
View File

File diff suppressed because one or more lines are too long

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConnectionControlMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConnectionErrorMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConnectionIdMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConnectionInfoMarshaller.cs Normal file
View File

File diff suppressed because one or more lines are too long

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConsumerControlMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConsumerIdMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ConsumerInfoMarshaller.cs Normal file
View File

File diff suppressed because one or more lines are too long

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ControlCommandMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/DataArrayResponseMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/DataResponseMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/DestinationInfoMarshaller.cs Normal file
View File

File diff suppressed because one or more lines are too long

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/DiscoveryEventMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ExceptionResponseMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/FlushCommandMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/IntegerResponseMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/JournalQueueAckMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/JournalTopicAckMarshaller.cs Normal file
View File

File diff suppressed because one or more lines are too long

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/JournalTraceMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/JournalTransactionMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/KeepAliveInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/LastPartialCommandMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/LocalTransactionIdMarshaller.cs Normal file
View File

@ -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); } } }

98
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MarshallerFactory.cs Normal file
View File

@ -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());
}
}
}

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessageAckMarshaller.cs Normal file
View File

File diff suppressed because one or more lines are too long

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessageDispatchMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessageDispatchNotificationMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessageIdMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessageMarshaller.cs Normal file
View File

File diff suppressed because one or more lines are too long

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/MessagePullMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/NetworkBridgeFilterMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/PartialCommandMarshaller.cs Normal file
View File

@ -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); } } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ProducerIdMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ProducerInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/RemoveInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/RemoveSubscriptionInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ReplayCommandMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ResponseMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/SessionIdMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/SessionInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/ShutdownInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/SubscriptionInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/TransactionIdMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/TransactionInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/WireFormatInfoMarshaller.cs Normal file
View File

@ -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); } } }

1
activemq-dotnet/src/main/csharp/ActiveMQ/OpenWire/V2/XATransactionIdMarshaller.cs Normal file
View File

@ -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); } } } }

3227
openwire-c/src/libopenwire/ow_commands_v2.c Normal file
View File

File diff suppressed because it is too large Load Diff

900
openwire-c/src/libopenwire/ow_commands_v2.h Normal file
View File

@ -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 */

1
openwire-cpp/src/main/cpp/activemq/command/BrokerId.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/BrokerId.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/BrokerInfo.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/BrokerInfo.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConnectionControl.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConnectionControl.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConnectionError.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConnectionError.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConnectionId.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConnectionId.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConnectionInfo.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConnectionInfo.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConsumerControl.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConsumerControl.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConsumerId.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConsumerId.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConsumerInfo.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ConsumerInfo.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ControlCommand.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ControlCommand.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/DataArrayResponse.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/DataArrayResponse.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/DataResponse.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/DataResponse.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/DestinationInfo.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/DestinationInfo.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/DiscoveryEvent.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/DiscoveryEvent.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ExceptionResponse.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/ExceptionResponse.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/FlushCommand.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/FlushCommand.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/IntegerResponse.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/IntegerResponse.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/JournalQueueAck.cpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/JournalQueueAck.hpp
View File

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

1
openwire-cpp/src/main/cpp/activemq/command/JournalTopicAck.cpp
View File

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

Some files were not shown because too many files have changed in this diff Show More