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

latest generated openwire code 

git-svn-id: https://svn.apache.org/repos/asf/incubator/activemq/trunk@384233 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
James Strachan 2006-03-08 15:16:40 +00:00
parent ef59d2c1e3
commit ac3e41b7b7
82 changed files with 196 additions and 5711 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
openwire-cpp/src/command/ConnectionError.hpp
View File

@ -1,81 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ConnectionError_hpp_
#define ConnectionError_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "BrokerError.hpp"
#include "command/ConnectionId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for ConnectionError
*
*
* 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
*
*/
class ConnectionError : public BaseCommand
{
private:
p<BrokerError> exception ;
p<ConnectionId> connectionId ;
public:
const static int TYPE = 16;
public:
ConnectionError() ;
virtual ~ConnectionError() ;
virtual int getCommandType() ;
virtual p<BrokerError> getException() ;
virtual void setException(p<BrokerError> exception) ;
virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ;
} ;
/* namespace */
}
}
}
}
#endif /*ConnectionError_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ConnectionError_hpp_ #define ConnectionError_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "BrokerError.hpp" #include "command/ConnectionId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for ConnectionError * * * 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 * */ class ConnectionError : public BaseCommand { private: p<BrokerError> exception ; p<ConnectionId> connectionId ; public: const static int TYPE = 16; public: ConnectionError() ; virtual ~ConnectionError() ; virtual int getCommandType() ; virtual p<BrokerError> getException() ; virtual void setException(p<BrokerError> exception) ; virtual p<ConnectionId> getConnectionId() ; virtual void setConnectionId(p<ConnectionId> connectionId) ; } ; /* namespace */ } } } } #endif /*ConnectionError_hpp_*/

76
openwire-cpp/src/command/ControlCommand.hpp
View File

@ -1,75 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ControlCommand_hpp_
#define ControlCommand_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for ControlCommand
*
*
* 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
*
*/
class ControlCommand : public BaseCommand
{
private:
p<string> command ;
public:
const static int TYPE = 14;
public:
ControlCommand() ;
virtual ~ControlCommand() ;
virtual int getCommandType() ;
virtual p<string> getCommand() ;
virtual void setCommand(p<string> command) ;
} ;
/* namespace */
}
}
}
}
#endif /*ControlCommand_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ControlCommand_hpp_ #define ControlCommand_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for ControlCommand * * * 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 * */ class ControlCommand : public BaseCommand { private: p<string> command ; public: const static int TYPE = 14; public: ControlCommand() ; virtual ~ControlCommand() ; virtual int getCommandType() ; virtual p<string> getCommand() ; virtual void setCommand(p<string> command) ; } ; /* namespace */ } } } } #endif /*ControlCommand_hpp_*/

77
openwire-cpp/src/command/DataArrayResponse.hpp
View File

@ -1,76 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef DataArrayResponse_hpp_
#define DataArrayResponse_hpp_
#include <string>
#include "command/Response.hpp"
#include "command/IDataStructure.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for DataArrayResponse
*
*
* 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
*
*/
class DataArrayResponse : public Response
{
private:
ap<IDataStructure> data ;
public:
const static int TYPE = 33;
public:
DataArrayResponse() ;
virtual ~DataArrayResponse() ;
virtual int getCommandType() ;
virtual ap<IDataStructure> getData() ;
virtual void setData(ap<IDataStructure> data) ;
} ;
/* namespace */
}
}
}
}
#endif /*DataArrayResponse_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef DataArrayResponse_hpp_ #define DataArrayResponse_hpp_ #include <string> #include "command/Response.hpp" #include "command/IDataStructure.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for DataArrayResponse * * * 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 * */ class DataArrayResponse : public Response { private: ap<IDataStructure> data ; public: const static int TYPE = 33; public: DataArrayResponse() ; virtual ~DataArrayResponse() ; virtual int getCommandType() ; virtual ap<IDataStructure> getData() ; virtual void setData(ap<IDataStructure> data) ; } ; /* namespace */ } } } } #endif /*DataArrayResponse_hpp_*/

77
openwire-cpp/src/command/DataResponse.hpp
View File

@ -1,76 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef DataResponse_hpp_
#define DataResponse_hpp_
#include <string>
#include "command/Response.hpp"
#include "command/IDataStructure.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for DataResponse
*
*
* 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
*
*/
class DataResponse : public Response
{
private:
p<IDataStructure> data ;
public:
const static int TYPE = 32;
public:
DataResponse() ;
virtual ~DataResponse() ;
virtual int getCommandType() ;
virtual p<IDataStructure> getData() ;
virtual void setData(p<IDataStructure> data) ;
} ;
/* namespace */
}
}
}
}
#endif /*DataResponse_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef DataResponse_hpp_ #define DataResponse_hpp_ #include <string> #include "command/Response.hpp" #include "command/IDataStructure.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for DataResponse * * * 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 * */ class DataResponse : public Response { private: p<IDataStructure> data ; public: const static int TYPE = 32; public: DataResponse() ; virtual ~DataResponse() ; virtual int getCommandType() ; virtual p<IDataStructure> getData() ; virtual void setData(p<IDataStructure> data) ; } ; /* namespace */ } } } } #endif /*DataResponse_hpp_*/

95
openwire-cpp/src/command/DestinationInfo.hpp
View File

@ -1,94 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef DestinationInfo_hpp_
#define DestinationInfo_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "command/ConnectionId.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/BrokerId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for DestinationInfo
*
*
* 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
*
*/
class DestinationInfo : public BaseCommand
{
private:
p<ConnectionId> connectionId ;
p<ActiveMQDestination> destination ;
char operationType ;
long long timeout ;
ap<BrokerId> brokerPath ;
public:
const static int TYPE = 8;
public:
DestinationInfo() ;
virtual ~DestinationInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual char getOperationType() ;
virtual void setOperationType(char operationType) ;
virtual long long getTimeout() ;
virtual void setTimeout(long long timeout) ;
virtual ap<BrokerId> getBrokerPath() ;
virtual void setBrokerPath(ap<BrokerId> brokerPath) ;
} ;
/* namespace */
}
}
}
}
#endif /*DestinationInfo_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef DestinationInfo_hpp_ #define DestinationInfo_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "command/ConnectionId.hpp" #include "command/ActiveMQDestination.hpp" #include "command/BrokerId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for DestinationInfo * * * 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 * */ class DestinationInfo : public BaseCommand { private: p<ConnectionId> connectionId ; p<ActiveMQDestination> destination ; char operationType ; long long timeout ; ap<BrokerId> brokerPath ; public: const static int TYPE = 8; public: DestinationInfo() ; virtual ~DestinationInfo() ; virtual int getCommandType() ; virtual p<ConnectionId> getConnectionId() ; virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual p<ActiveMQDestination> getDestination() ; virtual void setDestination(p<ActiveMQDestination> destination) ; virtual char getOperationType() ; virtual void setOperationType(char operationType) ; virtual long long getTimeout() ; virtual void setTimeout(long long timeout) ; virtual ap<BrokerId> getBrokerPath() ; virtual void setBrokerPath(ap<BrokerId> brokerPath) ; } ; /* namespace */ } } } } #endif /*DestinationInfo_hpp_*/

80
openwire-cpp/src/command/DiscoveryEvent.hpp
View File

@ -1,79 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef DiscoveryEvent_hpp_
#define DiscoveryEvent_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for DiscoveryEvent
*
*
* 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
*
*/
class DiscoveryEvent : public AbstractCommand
{
private:
p<string> serviceName ;
p<string> brokerName ;
public:
const static int TYPE = 40;
public:
DiscoveryEvent() ;
virtual ~DiscoveryEvent() ;
virtual int getCommandType() ;
virtual p<string> getServiceName() ;
virtual void setServiceName(p<string> serviceName) ;
virtual p<string> getBrokerName() ;
virtual void setBrokerName(p<string> brokerName) ;
} ;
/* namespace */
}
}
}
}
#endif /*DiscoveryEvent_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef DiscoveryEvent_hpp_ #define DiscoveryEvent_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for DiscoveryEvent * * * 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 * */ class DiscoveryEvent : public AbstractCommand { private: p<string> serviceName ; p<string> brokerName ; public: const static int TYPE = 40; public: DiscoveryEvent() ; virtual ~DiscoveryEvent() ; virtual int getCommandType() ; virtual p<string> getServiceName() ; virtual void setServiceName(p<string> serviceName) ; virtual p<string> getBrokerName() ; virtual void setBrokerName(p<string> brokerName) ; } ; /* namespace */ } } } } #endif /*DiscoveryEvent_hpp_*/

72
openwire-cpp/src/command/FlushCommand.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef FlushCommand_hpp_
#define FlushCommand_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for FlushCommand
*
*
* 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
*
*/
class FlushCommand : public BaseCommand
{
private:
public:
const static int TYPE = 15;
public:
FlushCommand() ;
virtual ~FlushCommand() ;
virtual int getCommandType() ;
} ;
/* namespace */
}
}
}
}
#endif /*FlushCommand_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef FlushCommand_hpp_ #define FlushCommand_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for FlushCommand * * * 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 * */ class FlushCommand : public BaseCommand { private: public: const static int TYPE = 15; public: FlushCommand() ; virtual ~FlushCommand() ; virtual int getCommandType() ; } ; /* namespace */ } } } } #endif /*FlushCommand_hpp_*/

76
openwire-cpp/src/command/IntegerResponse.hpp
View File

@ -1,75 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef IntegerResponse_hpp_
#define IntegerResponse_hpp_
#include <string>
#include "command/Response.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for IntegerResponse
*
*
* 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
*
*/
class IntegerResponse : public Response
{
private:
int result ;
public:
const static int TYPE = 34;
public:
IntegerResponse() ;
virtual ~IntegerResponse() ;
virtual int getCommandType() ;
virtual int getResult() ;
virtual void setResult(int result) ;
} ;
/* namespace */
}
}
}
}
#endif /*IntegerResponse_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef IntegerResponse_hpp_ #define IntegerResponse_hpp_ #include <string> #include "command/Response.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for IntegerResponse * * * 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 * */ class IntegerResponse : public Response { private: int result ; public: const static int TYPE = 34; public: IntegerResponse() ; virtual ~IntegerResponse() ; virtual int getCommandType() ; virtual int getResult() ; virtual void setResult(int result) ; } ; /* namespace */ } } } } #endif /*IntegerResponse_hpp_*/

82
openwire-cpp/src/command/JournalQueueAck.hpp
View File

@ -1,81 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef JournalQueueAck_hpp_
#define JournalQueueAck_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/MessageAck.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for JournalQueueAck
*
*
* 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
*
*/
class JournalQueueAck : public AbstractCommand
{
private:
p<ActiveMQDestination> destination ;
p<MessageAck> messageAck ;
public:
const static int TYPE = 52;
public:
JournalQueueAck() ;
virtual ~JournalQueueAck() ;
virtual int getCommandType() ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<MessageAck> getMessageAck() ;
virtual void setMessageAck(p<MessageAck> messageAck) ;
} ;
/* namespace */
}
}
}
}
#endif /*JournalQueueAck_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef JournalQueueAck_hpp_ #define JournalQueueAck_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "command/ActiveMQDestination.hpp" #include "command/MessageAck.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for JournalQueueAck * * * 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 * */ class JournalQueueAck : public AbstractCommand { private: p<ActiveMQDestination> destination ; p<MessageAck> messageAck ; public: const static int TYPE = 52; public: JournalQueueAck() ; virtual ~JournalQueueAck() ; virtual int getCommandType() ; virtual p<ActiveMQDestination> getDestination() ; virtual void setDestination(p<ActiveMQDestination> destination) ; virtual p<MessageAck> getMessageAck() ; virtual void setMessageAck(p<MessageAck> messageAck) ; } ; /* namespace */ } } } } #endif /*JournalQueueAck_hpp_*/

99
openwire-cpp/src/command/JournalTopicAck.hpp
View File

@ -1,98 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef JournalTopicAck_hpp_
#define JournalTopicAck_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/MessageId.hpp"
#include "command/TransactionId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for JournalTopicAck
*
*
* 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
*
*/
class JournalTopicAck : public AbstractCommand
{
private:
p<ActiveMQDestination> destination ;
p<MessageId> messageId ;
long long messageSequenceId ;
p<string> subscritionName ;
p<string> clientId ;
p<TransactionId> transactionId ;
public:
const static int TYPE = 50;
public:
JournalTopicAck() ;
virtual ~JournalTopicAck() ;
virtual int getCommandType() ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<MessageId> getMessageId() ;
virtual void setMessageId(p<MessageId> messageId) ;
virtual long long getMessageSequenceId() ;
virtual void setMessageSequenceId(long long messageSequenceId) ;
virtual p<string> getSubscritionName() ;
virtual void setSubscritionName(p<string> subscritionName) ;
virtual p<string> getClientId() ;
virtual void setClientId(p<string> clientId) ;
virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ;
} ;
/* namespace */
}
}
}
}
#endif /*JournalTopicAck_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef JournalTopicAck_hpp_ #define JournalTopicAck_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "command/ActiveMQDestination.hpp" #include "command/MessageId.hpp" #include "command/TransactionId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for JournalTopicAck * * * 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 * */ class JournalTopicAck : public AbstractCommand { private: p<ActiveMQDestination> destination ; p<MessageId> messageId ; long long messageSequenceId ; p<string> subscritionName ; p<string> clientId ; p<TransactionId> transactionId ; public: const static int TYPE = 50; public: JournalTopicAck() ; virtual ~JournalTopicAck() ; virtual int getCommandType() ; virtual p<ActiveMQDestination> getDestination() ; virtual void setDestination(p<ActiveMQDestination> destination) ; virtual p<MessageId> getMessageId() ; virtual void setMessageId(p<MessageId> messageId) ; virtual long long getMessageSequenceId() ; virtual void setMessageSequenceId(long long messageSequenceId) ; virtual p<string> getSubscritionName() ; virtual void setSubscritionName(p<string> subscritionName) ; virtual p<string> getClientId() ; virtual void setClientId(p<string> clientId) ; virtual p<TransactionId> getTransactionId() ; virtual void setTransactionId(p<TransactionId> transactionId) ; } ; /* namespace */ } } } } #endif /*JournalTopicAck_hpp_*/

76
openwire-cpp/src/command/JournalTrace.hpp
View File

@ -1,75 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef JournalTrace_hpp_
#define JournalTrace_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for JournalTrace
*
*
* 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
*
*/
class JournalTrace : public AbstractCommand
{
private:
p<string> message ;
public:
const static int TYPE = 53;
public:
JournalTrace() ;
virtual ~JournalTrace() ;
virtual int getCommandType() ;
virtual p<string> getMessage() ;
virtual void setMessage(p<string> message) ;
} ;
/* namespace */
}
}
}
}
#endif /*JournalTrace_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef JournalTrace_hpp_ #define JournalTrace_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for JournalTrace * * * 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 * */ class JournalTrace : public AbstractCommand { private: p<string> message ; public: const static int TYPE = 53; public: JournalTrace() ; virtual ~JournalTrace() ; virtual int getCommandType() ; virtual p<string> getMessage() ; virtual void setMessage(p<string> message) ; } ; /* namespace */ } } } } #endif /*JournalTrace_hpp_*/

85
openwire-cpp/src/command/JournalTransaction.hpp
View File

@ -1,84 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef JournalTransaction_hpp_
#define JournalTransaction_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "command/TransactionId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for JournalTransaction
*
*
* 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
*
*/
class JournalTransaction : public AbstractCommand
{
private:
p<TransactionId> transactionId ;
char type ;
bool wasPrepared ;
public:
const static int TYPE = 54;
public:
JournalTransaction() ;
virtual ~JournalTransaction() ;
virtual int getCommandType() ;
virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ;
virtual char getType() ;
virtual void setType(char type) ;
virtual bool getWasPrepared() ;
virtual void setWasPrepared(bool wasPrepared) ;
} ;
/* namespace */
}
}
}
}
#endif /*JournalTransaction_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef JournalTransaction_hpp_ #define JournalTransaction_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "command/TransactionId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for JournalTransaction * * * 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 * */ class JournalTransaction : public AbstractCommand { private: p<TransactionId> transactionId ; char type ; bool wasPrepared ; public: const static int TYPE = 54; public: JournalTransaction() ; virtual ~JournalTransaction() ; virtual int getCommandType() ; virtual p<TransactionId> getTransactionId() ; virtual void setTransactionId(p<TransactionId> transactionId) ; virtual char getType() ; virtual void setType(char type) ; virtual bool getWasPrepared() ; virtual void setWasPrepared(bool wasPrepared) ; } ; /* namespace */ } } } } #endif /*JournalTransaction_hpp_*/

72
openwire-cpp/src/command/KeepAliveInfo.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef KeepAliveInfo_hpp_
#define KeepAliveInfo_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for KeepAliveInfo
*
*
* 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
*
*/
class KeepAliveInfo : public AbstractCommand
{
private:
public:
const static int TYPE = 10;
public:
KeepAliveInfo() ;
virtual ~KeepAliveInfo() ;
virtual int getCommandType() ;
} ;
/* namespace */
}
}
}
}
#endif /*KeepAliveInfo_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef KeepAliveInfo_hpp_ #define KeepAliveInfo_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for KeepAliveInfo * * * 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 * */ class KeepAliveInfo : public AbstractCommand { private: public: const static int TYPE = 10; public: KeepAliveInfo() ; virtual ~KeepAliveInfo() ; virtual int getCommandType() ; } ; /* namespace */ } } } } #endif /*KeepAliveInfo_hpp_*/

81
openwire-cpp/src/command/LocalTransactionId.hpp
View File

@ -1,80 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef LocalTransactionId_hpp_
#define LocalTransactionId_hpp_
#include <string>
#include "command/TransactionId.hpp"
#include "command/ConnectionId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for LocalTransactionId
*
*
* 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
*
*/
class LocalTransactionId : public TransactionId
{
private:
long long value ;
p<ConnectionId> connectionId ;
public:
const static int TYPE = 111;
public:
LocalTransactionId() ;
virtual ~LocalTransactionId() ;
virtual int getCommandType() ;
virtual long long getValue() ;
virtual void setValue(long long value) ;
virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ;
} ;
/* namespace */
}
}
}
}
#endif /*LocalTransactionId_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef LocalTransactionId_hpp_ #define LocalTransactionId_hpp_ #include <string> #include "command/TransactionId.hpp" #include "command/ConnectionId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for LocalTransactionId * * * 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 * */ class LocalTransactionId : public TransactionId { private: long long value ; p<ConnectionId> connectionId ; public: const static int TYPE = 111; public: LocalTransactionId() ; virtual ~LocalTransactionId() ; virtual int getCommandType() ; virtual long long getValue() ; virtual void setValue(long long value) ; virtual p<ConnectionId> getConnectionId() ; virtual void setConnectionId(p<ConnectionId> connectionId) ; } ; /* namespace */ } } } } #endif /*LocalTransactionId_hpp_*/

91
openwire-cpp/src/command/MessageDispatch.hpp
View File

@ -1,90 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef MessageDispatch_hpp_
#define MessageDispatch_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "command/ConsumerId.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/Message.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for MessageDispatch
*
*
* 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
*
*/
class MessageDispatch : public BaseCommand
{
private:
p<ConsumerId> consumerId ;
p<ActiveMQDestination> destination ;
p<Message> message ;
int redeliveryCounter ;
public:
const static int TYPE = 21;
public:
MessageDispatch() ;
virtual ~MessageDispatch() ;
virtual int getCommandType() ;
virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<Message> getMessage() ;
virtual void setMessage(p<Message> message) ;
virtual int getRedeliveryCounter() ;
virtual void setRedeliveryCounter(int redeliveryCounter) ;
} ;
/* namespace */
}
}
}
}
#endif /*MessageDispatch_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef MessageDispatch_hpp_ #define MessageDispatch_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "command/ConsumerId.hpp" #include "command/ActiveMQDestination.hpp" #include "command/Message.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for MessageDispatch * * * 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 * */ class MessageDispatch : public BaseCommand { private: p<ConsumerId> consumerId ; p<ActiveMQDestination> destination ; p<Message> message ; int redeliveryCounter ; public: const static int TYPE = 21; public: MessageDispatch() ; virtual ~MessageDispatch() ; virtual int getCommandType() ; virtual p<ConsumerId> getConsumerId() ; virtual void setConsumerId(p<ConsumerId> consumerId) ; virtual p<ActiveMQDestination> getDestination() ; virtual void setDestination(p<ActiveMQDestination> destination) ; virtual p<Message> getMessage() ; virtual void setMessage(p<Message> message) ; virtual int getRedeliveryCounter() ; virtual void setRedeliveryCounter(int redeliveryCounter) ; } ; /* namespace */ } } } } #endif /*MessageDispatch_hpp_*/

91
openwire-cpp/src/command/MessageDispatchNotification.hpp
View File

@ -1,90 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef MessageDispatchNotification_hpp_
#define MessageDispatchNotification_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "command/ConsumerId.hpp"
#include "command/ActiveMQDestination.hpp"
#include "command/MessageId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for MessageDispatchNotification
*
*
* 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
*
*/
class MessageDispatchNotification : public BaseCommand
{
private:
p<ConsumerId> consumerId ;
p<ActiveMQDestination> destination ;
long long deliverySequenceId ;
p<MessageId> messageId ;
public:
const static int TYPE = 90;
public:
MessageDispatchNotification() ;
virtual ~MessageDispatchNotification() ;
virtual int getCommandType() ;
virtual p<ConsumerId> getConsumerId() ;
virtual void setConsumerId(p<ConsumerId> consumerId) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual long long getDeliverySequenceId() ;
virtual void setDeliverySequenceId(long long deliverySequenceId) ;
virtual p<MessageId> getMessageId() ;
virtual void setMessageId(p<MessageId> messageId) ;
} ;
/* namespace */
}
}
}
}
#endif /*MessageDispatchNotification_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef MessageDispatchNotification_hpp_ #define MessageDispatchNotification_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "command/ConsumerId.hpp" #include "command/ActiveMQDestination.hpp" #include "command/MessageId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for MessageDispatchNotification * * * 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 * */ class MessageDispatchNotification : public BaseCommand { private: p<ConsumerId> consumerId ; p<ActiveMQDestination> destination ; long long deliverySequenceId ; p<MessageId> messageId ; public: const static int TYPE = 90; public: MessageDispatchNotification() ; virtual ~MessageDispatchNotification() ; virtual int getCommandType() ; virtual p<ConsumerId> getConsumerId() ; virtual void setConsumerId(p<ConsumerId> consumerId) ; virtual p<ActiveMQDestination> getDestination() ; virtual void setDestination(p<ActiveMQDestination> destination) ; virtual long long getDeliverySequenceId() ; virtual void setDeliverySequenceId(long long deliverySequenceId) ; virtual p<MessageId> getMessageId() ; virtual void setMessageId(p<MessageId> messageId) ; } ; /* namespace */ } } } } #endif /*MessageDispatchNotification_hpp_*/

85
openwire-cpp/src/command/MessageId.hpp
View File

@ -1,84 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef MessageId_hpp_
#define MessageId_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "command/ProducerId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for MessageId
*
*
* 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
*
*/
class MessageId : public AbstractCommand
{
private:
p<ProducerId> producerId ;
long long producerSequenceId ;
long long brokerSequenceId ;
public:
const static int TYPE = 110;
public:
MessageId() ;
virtual ~MessageId() ;
virtual int getCommandType() ;
virtual p<ProducerId> getProducerId() ;
virtual void setProducerId(p<ProducerId> producerId) ;
virtual long long getProducerSequenceId() ;
virtual void setProducerSequenceId(long long producerSequenceId) ;
virtual long long getBrokerSequenceId() ;
virtual void setBrokerSequenceId(long long brokerSequenceId) ;
} ;
/* namespace */
}
}
}
}
#endif /*MessageId_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef MessageId_hpp_ #define MessageId_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "command/ProducerId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for MessageId * * * 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 * */ class MessageId : public AbstractCommand { private: p<ProducerId> producerId ; long long producerSequenceId ; long long brokerSequenceId ; public: const static int TYPE = 110; public: MessageId() ; virtual ~MessageId() ; virtual int getCommandType() ; virtual p<ProducerId> getProducerId() ; virtual void setProducerId(p<ProducerId> producerId) ; virtual long long getProducerSequenceId() ; virtual void setProducerSequenceId(long long producerSequenceId) ; virtual long long getBrokerSequenceId() ; virtual void setBrokerSequenceId(long long brokerSequenceId) ; } ; /* namespace */ } } } } #endif /*MessageId_hpp_*/

62
openwire-cpp/src/command/NetworkBridgeFilter.cpp
View File

@ -1,61 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#include "command/NetworkBridgeFilter.hpp"
using namespace apache::activemq::client::command;
/*
*
* Marshalling code for Open Wire Format for NetworkBridgeFilter
*
*
* 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
*
*/
NetworkBridgeFilter::NetworkBridgeFilter()
{
this->networkTTL = 0 ;
this->networkBrokerId = 0 ;
}
NetworkBridgeFilter::~NetworkBridgeFilter()
{
}
int NetworkBridgeFilter::getNetworkTTL()
{
return networkTTL ;
}
void NetworkBridgeFilter::setNetworkTTL(int networkTTL)
{
this->networkTTL = networkTTL ;
}
p<BrokerId> NetworkBridgeFilter::getNetworkBrokerId()
{
return networkBrokerId ;
}
void NetworkBridgeFilter::setNetworkBrokerId(p<BrokerId> networkBrokerId)
{
this->networkBrokerId = networkBrokerId ;
}
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #include "command/NetworkBridgeFilter.hpp" using namespace apache::activemq::client::command; /* * * Marshalling code for Open Wire Format for NetworkBridgeFilter * * * 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 * */ NetworkBridgeFilter::NetworkBridgeFilter() { this->networkTTL = 0 ; this->networkBrokerId = 0 ; } NetworkBridgeFilter::~NetworkBridgeFilter() { } int NetworkBridgeFilter::getNetworkTTL() { return networkTTL ; } void NetworkBridgeFilter::setNetworkTTL(int networkTTL) { this->networkTTL = networkTTL ; } p<BrokerId> NetworkBridgeFilter::getNetworkBrokerId() { return networkBrokerId ; } void NetworkBridgeFilter::setNetworkBrokerId(p<BrokerId> networkBrokerId) { this->networkBrokerId = networkBrokerId ; }

81
openwire-cpp/src/command/NetworkBridgeFilter.hpp
View File

@ -1,80 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef NetworkBridgeFilter_hpp_
#define NetworkBridgeFilter_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "command/BrokerId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for NetworkBridgeFilter
*
*
* 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
*
*/
class NetworkBridgeFilter : public AbstractCommand
{
private:
int networkTTL ;
p<BrokerId> networkBrokerId ;
public:
const static int TYPE = 91;
public:
NetworkBridgeFilter() ;
virtual ~NetworkBridgeFilter() ;
virtual int getCommandType() ;
virtual int getNetworkTTL() ;
virtual void setNetworkTTL(int networkTTL) ;
virtual p<BrokerId> getNetworkBrokerId() ;
virtual void setNetworkBrokerId(p<BrokerId> networkBrokerId) ;
} ;
/* namespace */
}
}
}
}
#endif /*NetworkBridgeFilter_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef NetworkBridgeFilter_hpp_ #define NetworkBridgeFilter_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "command/BrokerId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for NetworkBridgeFilter * * * 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 * */ class NetworkBridgeFilter : public AbstractCommand { private: int networkTTL ; p<BrokerId> networkBrokerId ; public: const static int TYPE = 91; public: NetworkBridgeFilter() ; virtual ~NetworkBridgeFilter() ; virtual int getCommandType() ; virtual int getNetworkTTL() ; virtual void setNetworkTTL(int networkTTL) ; virtual p<BrokerId> getNetworkBrokerId() ; virtual void setNetworkBrokerId(p<BrokerId> networkBrokerId) ; } ; /* namespace */ } } } } #endif /*NetworkBridgeFilter_hpp_*/

85
openwire-cpp/src/command/RemoveSubscriptionInfo.hpp
View File

@ -1,84 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef RemoveSubscriptionInfo_hpp_
#define RemoveSubscriptionInfo_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "command/ConnectionId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for RemoveSubscriptionInfo
*
*
* 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
*
*/
class RemoveSubscriptionInfo : public BaseCommand
{
private:
p<ConnectionId> connectionId ;
p<string> subcriptionName ;
p<string> clientId ;
public:
const static int TYPE = 0;
public:
RemoveSubscriptionInfo() ;
virtual ~RemoveSubscriptionInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ;
virtual p<string> getSubcriptionName() ;
virtual void setSubcriptionName(p<string> subcriptionName) ;
virtual p<string> getClientId() ;
virtual void setClientId(p<string> clientId) ;
} ;
/* namespace */
}
}
}
}
#endif /*RemoveSubscriptionInfo_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef RemoveSubscriptionInfo_hpp_ #define RemoveSubscriptionInfo_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "command/ConnectionId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for RemoveSubscriptionInfo * * * 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 * */ class RemoveSubscriptionInfo : public BaseCommand { private: p<ConnectionId> connectionId ; p<string> subcriptionName ; p<string> clientId ; public: const static int TYPE = 0; public: RemoveSubscriptionInfo() ; virtual ~RemoveSubscriptionInfo() ; virtual int getCommandType() ; virtual p<ConnectionId> getConnectionId() ; virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual p<string> getSubcriptionName() ; virtual void setSubcriptionName(p<string> subcriptionName) ; virtual p<string> getClientId() ; virtual void setClientId(p<string> clientId) ; } ; /* namespace */ } } } } #endif /*RemoveSubscriptionInfo_hpp_*/

37
openwire-cpp/src/command/ReplayCommand.cpp Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#include "command/ReplayCommand.hpp"
using namespace apache::activemq::client::command;
/*
*
* Marshalling code for Open Wire Format for ReplayCommand
*
*
* 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
*
*/
ReplayCommand::ReplayCommand()
{
}
ReplayCommand::~ReplayCommand()
{
}

1
openwire-cpp/src/command/ReplayCommand.hpp Normal file
View File

@ -0,0 +1 @@
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ReplayCommand_hpp_ #define ReplayCommand_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for ReplayCommand * * * 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 * */ class ReplayCommand : public BaseCommand { private: public: const static int TYPE = 38; public: ReplayCommand() ; virtual ~ReplayCommand() ; virtual int getCommandType() ; } ; /* namespace */ } } } } #endif /*ReplayCommand_hpp_*/

72
openwire-cpp/src/command/ShutdownInfo.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ShutdownInfo_hpp_
#define ShutdownInfo_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for ShutdownInfo
*
*
* 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
*
*/
class ShutdownInfo : public BaseCommand
{
private:
public:
const static int TYPE = 11;
public:
ShutdownInfo() ;
virtual ~ShutdownInfo() ;
virtual int getCommandType() ;
} ;
/* namespace */
}
}
}
}
#endif /*ShutdownInfo_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ShutdownInfo_hpp_ #define ShutdownInfo_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for ShutdownInfo * * * 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 * */ class ShutdownInfo : public BaseCommand { private: public: const static int TYPE = 11; public: ShutdownInfo() ; virtual ~ShutdownInfo() ; virtual int getCommandType() ; } ; /* namespace */ } } } } #endif /*ShutdownInfo_hpp_*/

89
openwire-cpp/src/command/SubscriptionInfo.hpp
View File

@ -1,88 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef SubscriptionInfo_hpp_
#define SubscriptionInfo_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "command/ActiveMQDestination.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for SubscriptionInfo
*
*
* 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
*
*/
class SubscriptionInfo : public AbstractCommand
{
private:
p<string> clientId ;
p<ActiveMQDestination> destination ;
p<string> selector ;
p<string> subcriptionName ;
public:
const static int TYPE = 55;
public:
SubscriptionInfo() ;
virtual ~SubscriptionInfo() ;
virtual int getCommandType() ;
virtual p<string> getClientId() ;
virtual void setClientId(p<string> clientId) ;
virtual p<ActiveMQDestination> getDestination() ;
virtual void setDestination(p<ActiveMQDestination> destination) ;
virtual p<string> getSelector() ;
virtual void setSelector(p<string> selector) ;
virtual p<string> getSubcriptionName() ;
virtual void setSubcriptionName(p<string> subcriptionName) ;
} ;
/* namespace */
}
}
}
}
#endif /*SubscriptionInfo_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef SubscriptionInfo_hpp_ #define SubscriptionInfo_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "command/ActiveMQDestination.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for SubscriptionInfo * * * 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 * */ class SubscriptionInfo : public AbstractCommand { private: p<string> clientId ; p<ActiveMQDestination> destination ; p<string> selector ; p<string> subcriptionName ; public: const static int TYPE = 55; public: SubscriptionInfo() ; virtual ~SubscriptionInfo() ; virtual int getCommandType() ; virtual p<string> getClientId() ; virtual void setClientId(p<string> clientId) ; virtual p<ActiveMQDestination> getDestination() ; virtual void setDestination(p<ActiveMQDestination> destination) ; virtual p<string> getSelector() ; virtual void setSelector(p<string> selector) ; virtual p<string> getSubcriptionName() ; virtual void setSubcriptionName(p<string> subcriptionName) ; } ; /* namespace */ } } } } #endif /*SubscriptionInfo_hpp_*/

72
openwire-cpp/src/command/TransactionId.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef TransactionId_hpp_
#define TransactionId_hpp_
#include <string>
#include "command/AbstractCommand.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for TransactionId
*
*
* 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
*
*/
class TransactionId : public AbstractCommand
{
private:
public:
const static int TYPE = 0;
public:
TransactionId() ;
virtual ~TransactionId() ;
virtual int getCommandType() ;
} ;
/* namespace */
}
}
}
}
#endif /*TransactionId_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef TransactionId_hpp_ #define TransactionId_hpp_ #include <string> #include "command/AbstractCommand.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for TransactionId * * * 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 * */ class TransactionId : public AbstractCommand { private: public: const static int TYPE = 0; public: TransactionId() ; virtual ~TransactionId() ; virtual int getCommandType() ; } ; /* namespace */ } } } } #endif /*TransactionId_hpp_*/

86
openwire-cpp/src/command/TransactionInfo.hpp
View File

@ -1,85 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef TransactionInfo_hpp_
#define TransactionInfo_hpp_
#include <string>
#include "command/BaseCommand.hpp"
#include "command/ConnectionId.hpp"
#include "command/TransactionId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for TransactionInfo
*
*
* 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
*
*/
class TransactionInfo : public BaseCommand
{
private:
p<ConnectionId> connectionId ;
p<TransactionId> transactionId ;
char type ;
public:
const static int TYPE = 7;
public:
TransactionInfo() ;
virtual ~TransactionInfo() ;
virtual int getCommandType() ;
virtual p<ConnectionId> getConnectionId() ;
virtual void setConnectionId(p<ConnectionId> connectionId) ;
virtual p<TransactionId> getTransactionId() ;
virtual void setTransactionId(p<TransactionId> transactionId) ;
virtual char getType() ;
virtual void setType(char type) ;
} ;
/* namespace */
}
}
}
}
#endif /*TransactionInfo_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef TransactionInfo_hpp_ #define TransactionInfo_hpp_ #include <string> #include "command/BaseCommand.hpp" #include "command/ConnectionId.hpp" #include "command/TransactionId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for TransactionInfo * * * 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 * */ class TransactionInfo : public BaseCommand { private: p<ConnectionId> connectionId ; p<TransactionId> transactionId ; char type ; public: const static int TYPE = 7; public: TransactionInfo() ; virtual ~TransactionInfo() ; virtual int getCommandType() ; virtual p<ConnectionId> getConnectionId() ; virtual void setConnectionId(p<ConnectionId> connectionId) ; virtual p<TransactionId> getTransactionId() ; virtual void setTransactionId(p<TransactionId> transactionId) ; virtual char getType() ; virtual void setType(char type) ; } ; /* namespace */ } } } } #endif /*TransactionInfo_hpp_*/

84
openwire-cpp/src/command/XATransactionId.hpp
View File

@ -1,83 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef XATransactionId_hpp_
#define XATransactionId_hpp_
#include <string>
#include "command/TransactionId.hpp"
#include "util/ifr/ap.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace command
{
using namespace ifr;
using namespace std;
using namespace apache::activemq::client;
/*
*
* Marshalling code for Open Wire Format for XATransactionId
*
*
* 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
*
*/
class XATransactionId : public TransactionId
{
private:
int formatId ;
ap<char> globalTransactionId ;
ap<char> branchQualifier ;
public:
const static int TYPE = 112;
public:
XATransactionId() ;
virtual ~XATransactionId() ;
virtual int getCommandType() ;
virtual int getFormatId() ;
virtual void setFormatId(int formatId) ;
virtual ap<char> getGlobalTransactionId() ;
virtual void setGlobalTransactionId(ap<char> globalTransactionId) ;
virtual ap<char> getBranchQualifier() ;
virtual void setBranchQualifier(ap<char> branchQualifier) ;
} ;
/* namespace */
}
}
}
}
#endif /*XATransactionId_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef XATransactionId_hpp_ #define XATransactionId_hpp_ #include <string> #include "command/TransactionId.hpp" #include "util/ifr/ap.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace command { using namespace ifr; using namespace std; using namespace apache::activemq::client; /* * * Marshalling code for Open Wire Format for XATransactionId * * * 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 * */ class XATransactionId : public TransactionId { private: int formatId ; ap<char> globalTransactionId ; ap<char> branchQualifier ; public: const static int TYPE = 112; public: XATransactionId() ; virtual ~XATransactionId() ; virtual int getCommandType() ; virtual int getFormatId() ; virtual void setFormatId(int formatId) ; virtual ap<char> getGlobalTransactionId() ; virtual void setGlobalTransactionId(ap<char> globalTransactionId) ; virtual ap<char> getBranchQualifier() ; virtual void setBranchQualifier(ap<char> branchQualifier) ; } ; /* namespace */ } } } } #endif /*XATransactionId_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQBytesMessageMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQBytesMessageMarshaller_hpp_
#define ActiveMQBytesMessageMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQMessageMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQBytesMessageMarshaller : public ActiveMQMessageMarshaller
{
public:
ActiveMQBytesMessageMarshaller() ;
virtual ~ActiveMQBytesMessageMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQBytesMessageMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQBytesMessageMarshaller_hpp_ #define ActiveMQBytesMessageMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQMessageMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQBytesMessageMarshaller : public ActiveMQMessageMarshaller { public: ActiveMQBytesMessageMarshaller() ; virtual ~ActiveMQBytesMessageMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQBytesMessageMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQDestinationMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQDestinationMarshaller_hpp_
#define ActiveMQDestinationMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQDestinationMarshaller : public BaseDataStreamMarshaller
{
public:
ActiveMQDestinationMarshaller() ;
virtual ~ActiveMQDestinationMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQDestinationMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQDestinationMarshaller_hpp_ #define ActiveMQDestinationMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQDestinationMarshaller : public BaseDataStreamMarshaller { public: ActiveMQDestinationMarshaller() ; virtual ~ActiveMQDestinationMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQDestinationMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQMapMessageMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQMapMessageMarshaller_hpp_
#define ActiveMQMapMessageMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQMessageMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQMapMessageMarshaller : public ActiveMQMessageMarshaller
{
public:
ActiveMQMapMessageMarshaller() ;
virtual ~ActiveMQMapMessageMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQMapMessageMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQMapMessageMarshaller_hpp_ #define ActiveMQMapMessageMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQMessageMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQMapMessageMarshaller : public ActiveMQMessageMarshaller { public: ActiveMQMapMessageMarshaller() ; virtual ~ActiveMQMapMessageMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQMapMessageMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQMessageMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQMessageMarshaller_hpp_
#define ActiveMQMessageMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/MessageMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQMessageMarshaller : public MessageMarshaller
{
public:
ActiveMQMessageMarshaller() ;
virtual ~ActiveMQMessageMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQMessageMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQMessageMarshaller_hpp_ #define ActiveMQMessageMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/MessageMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQMessageMarshaller : public MessageMarshaller { public: ActiveMQMessageMarshaller() ; virtual ~ActiveMQMessageMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQMessageMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQObjectMessageMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQObjectMessageMarshaller_hpp_
#define ActiveMQObjectMessageMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQMessageMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQObjectMessageMarshaller : public ActiveMQMessageMarshaller
{
public:
ActiveMQObjectMessageMarshaller() ;
virtual ~ActiveMQObjectMessageMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQObjectMessageMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQObjectMessageMarshaller_hpp_ #define ActiveMQObjectMessageMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQMessageMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQObjectMessageMarshaller : public ActiveMQMessageMarshaller { public: ActiveMQObjectMessageMarshaller() ; virtual ~ActiveMQObjectMessageMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQObjectMessageMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQQueueMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQQueueMarshaller_hpp_
#define ActiveMQQueueMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQDestinationMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQQueueMarshaller : public ActiveMQDestinationMarshaller
{
public:
ActiveMQQueueMarshaller() ;
virtual ~ActiveMQQueueMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQQueueMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQQueueMarshaller_hpp_ #define ActiveMQQueueMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQDestinationMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQQueueMarshaller : public ActiveMQDestinationMarshaller { public: ActiveMQQueueMarshaller() ; virtual ~ActiveMQQueueMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQQueueMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQStreamMessageMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQStreamMessageMarshaller_hpp_
#define ActiveMQStreamMessageMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQMessageMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQStreamMessageMarshaller : public ActiveMQMessageMarshaller
{
public:
ActiveMQStreamMessageMarshaller() ;
virtual ~ActiveMQStreamMessageMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQStreamMessageMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQStreamMessageMarshaller_hpp_ #define ActiveMQStreamMessageMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQMessageMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQStreamMessageMarshaller : public ActiveMQMessageMarshaller { public: ActiveMQStreamMessageMarshaller() ; virtual ~ActiveMQStreamMessageMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQStreamMessageMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQTempDestinationMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQTempDestinationMarshaller_hpp_
#define ActiveMQTempDestinationMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQDestinationMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQTempDestinationMarshaller : public ActiveMQDestinationMarshaller
{
public:
ActiveMQTempDestinationMarshaller() ;
virtual ~ActiveMQTempDestinationMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQTempDestinationMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQTempDestinationMarshaller_hpp_ #define ActiveMQTempDestinationMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQDestinationMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQTempDestinationMarshaller : public ActiveMQDestinationMarshaller { public: ActiveMQTempDestinationMarshaller() ; virtual ~ActiveMQTempDestinationMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQTempDestinationMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQTempQueueMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQTempQueueMarshaller_hpp_
#define ActiveMQTempQueueMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQTempDestinationMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQTempQueueMarshaller : public ActiveMQTempDestinationMarshaller
{
public:
ActiveMQTempQueueMarshaller() ;
virtual ~ActiveMQTempQueueMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQTempQueueMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQTempQueueMarshaller_hpp_ #define ActiveMQTempQueueMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQTempDestinationMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQTempQueueMarshaller : public ActiveMQTempDestinationMarshaller { public: ActiveMQTempQueueMarshaller() ; virtual ~ActiveMQTempQueueMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQTempQueueMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQTempTopicMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQTempTopicMarshaller_hpp_
#define ActiveMQTempTopicMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQTempDestinationMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQTempTopicMarshaller : public ActiveMQTempDestinationMarshaller
{
public:
ActiveMQTempTopicMarshaller() ;
virtual ~ActiveMQTempTopicMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQTempTopicMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQTempTopicMarshaller_hpp_ #define ActiveMQTempTopicMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQTempDestinationMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQTempTopicMarshaller : public ActiveMQTempDestinationMarshaller { public: ActiveMQTempTopicMarshaller() ; virtual ~ActiveMQTempTopicMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQTempTopicMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQTextMessageMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQTextMessageMarshaller_hpp_
#define ActiveMQTextMessageMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQMessageMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQTextMessageMarshaller : public ActiveMQMessageMarshaller
{
public:
ActiveMQTextMessageMarshaller() ;
virtual ~ActiveMQTextMessageMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQTextMessageMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQTextMessageMarshaller_hpp_ #define ActiveMQTextMessageMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQMessageMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQTextMessageMarshaller : public ActiveMQMessageMarshaller { public: ActiveMQTextMessageMarshaller() ; virtual ~ActiveMQTextMessageMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQTextMessageMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ActiveMQTopicMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ActiveMQTopicMarshaller_hpp_
#define ActiveMQTopicMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ActiveMQDestinationMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ActiveMQTopicMarshaller : public ActiveMQDestinationMarshaller
{
public:
ActiveMQTopicMarshaller() ;
virtual ~ActiveMQTopicMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ActiveMQTopicMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ActiveMQTopicMarshaller_hpp_ #define ActiveMQTopicMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ActiveMQDestinationMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ActiveMQTopicMarshaller : public ActiveMQDestinationMarshaller { public: ActiveMQTopicMarshaller() ; virtual ~ActiveMQTopicMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ActiveMQTopicMarshaller_hpp_*/

72
openwire-cpp/src/marshal/BaseCommandMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef BaseCommandMarshaller_hpp_
#define BaseCommandMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class BaseCommandMarshaller : public BaseDataStreamMarshaller
{
public:
BaseCommandMarshaller() ;
virtual ~BaseCommandMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*BaseCommandMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef BaseCommandMarshaller_hpp_ #define BaseCommandMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class BaseCommandMarshaller : public BaseDataStreamMarshaller { public: BaseCommandMarshaller() ; virtual ~BaseCommandMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*BaseCommandMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ConnectionErrorMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ConnectionErrorMarshaller_hpp_
#define ConnectionErrorMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ConnectionErrorMarshaller : public BaseCommandMarshaller
{
public:
ConnectionErrorMarshaller() ;
virtual ~ConnectionErrorMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ConnectionErrorMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ConnectionErrorMarshaller_hpp_ #define ConnectionErrorMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ConnectionErrorMarshaller : public BaseCommandMarshaller { public: ConnectionErrorMarshaller() ; virtual ~ConnectionErrorMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ConnectionErrorMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ConnectionIdMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ConnectionIdMarshaller_hpp_
#define ConnectionIdMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ConnectionIdMarshaller : public BaseDataStreamMarshaller
{
public:
ConnectionIdMarshaller() ;
virtual ~ConnectionIdMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ConnectionIdMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ConnectionIdMarshaller_hpp_ #define ConnectionIdMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ConnectionIdMarshaller : public BaseDataStreamMarshaller { public: ConnectionIdMarshaller() ; virtual ~ConnectionIdMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ConnectionIdMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ConnectionInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ConnectionInfoMarshaller_hpp_
#define ConnectionInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ConnectionInfoMarshaller : public BaseCommandMarshaller
{
public:
ConnectionInfoMarshaller() ;
virtual ~ConnectionInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ConnectionInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ConnectionInfoMarshaller_hpp_ #define ConnectionInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ConnectionInfoMarshaller : public BaseCommandMarshaller { public: ConnectionInfoMarshaller() ; virtual ~ConnectionInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ConnectionInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ConsumerIdMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ConsumerIdMarshaller_hpp_
#define ConsumerIdMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ConsumerIdMarshaller : public BaseDataStreamMarshaller
{
public:
ConsumerIdMarshaller() ;
virtual ~ConsumerIdMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ConsumerIdMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ConsumerIdMarshaller_hpp_ #define ConsumerIdMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ConsumerIdMarshaller : public BaseDataStreamMarshaller { public: ConsumerIdMarshaller() ; virtual ~ConsumerIdMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ConsumerIdMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ConsumerInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ConsumerInfoMarshaller_hpp_
#define ConsumerInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ConsumerInfoMarshaller : public BaseCommandMarshaller
{
public:
ConsumerInfoMarshaller() ;
virtual ~ConsumerInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ConsumerInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ConsumerInfoMarshaller_hpp_ #define ConsumerInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ConsumerInfoMarshaller : public BaseCommandMarshaller { public: ConsumerInfoMarshaller() ; virtual ~ConsumerInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ConsumerInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ControlCommandMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ControlCommandMarshaller_hpp_
#define ControlCommandMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ControlCommandMarshaller : public BaseCommandMarshaller
{
public:
ControlCommandMarshaller() ;
virtual ~ControlCommandMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ControlCommandMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ControlCommandMarshaller_hpp_ #define ControlCommandMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ControlCommandMarshaller : public BaseCommandMarshaller { public: ControlCommandMarshaller() ; virtual ~ControlCommandMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ControlCommandMarshaller_hpp_*/

72
openwire-cpp/src/marshal/DataArrayResponseMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef DataArrayResponseMarshaller_hpp_
#define DataArrayResponseMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ResponseMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class DataArrayResponseMarshaller : public ResponseMarshaller
{
public:
DataArrayResponseMarshaller() ;
virtual ~DataArrayResponseMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*DataArrayResponseMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef DataArrayResponseMarshaller_hpp_ #define DataArrayResponseMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ResponseMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class DataArrayResponseMarshaller : public ResponseMarshaller { public: DataArrayResponseMarshaller() ; virtual ~DataArrayResponseMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*DataArrayResponseMarshaller_hpp_*/

72
openwire-cpp/src/marshal/DataResponseMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef DataResponseMarshaller_hpp_
#define DataResponseMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ResponseMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class DataResponseMarshaller : public ResponseMarshaller
{
public:
DataResponseMarshaller() ;
virtual ~DataResponseMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*DataResponseMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef DataResponseMarshaller_hpp_ #define DataResponseMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ResponseMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class DataResponseMarshaller : public ResponseMarshaller { public: DataResponseMarshaller() ; virtual ~DataResponseMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*DataResponseMarshaller_hpp_*/

72
openwire-cpp/src/marshal/DestinationInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef DestinationInfoMarshaller_hpp_
#define DestinationInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class DestinationInfoMarshaller : public BaseCommandMarshaller
{
public:
DestinationInfoMarshaller() ;
virtual ~DestinationInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*DestinationInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef DestinationInfoMarshaller_hpp_ #define DestinationInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class DestinationInfoMarshaller : public BaseCommandMarshaller { public: DestinationInfoMarshaller() ; virtual ~DestinationInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*DestinationInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/DiscoveryEventMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef DiscoveryEventMarshaller_hpp_
#define DiscoveryEventMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class DiscoveryEventMarshaller : public BaseDataStreamMarshaller
{
public:
DiscoveryEventMarshaller() ;
virtual ~DiscoveryEventMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*DiscoveryEventMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef DiscoveryEventMarshaller_hpp_ #define DiscoveryEventMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class DiscoveryEventMarshaller : public BaseDataStreamMarshaller { public: DiscoveryEventMarshaller() ; virtual ~DiscoveryEventMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*DiscoveryEventMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ExceptionResponseMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ExceptionResponseMarshaller_hpp_
#define ExceptionResponseMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ResponseMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ExceptionResponseMarshaller : public ResponseMarshaller
{
public:
ExceptionResponseMarshaller() ;
virtual ~ExceptionResponseMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ExceptionResponseMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ExceptionResponseMarshaller_hpp_ #define ExceptionResponseMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ResponseMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ExceptionResponseMarshaller : public ResponseMarshaller { public: ExceptionResponseMarshaller() ; virtual ~ExceptionResponseMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ExceptionResponseMarshaller_hpp_*/

72
openwire-cpp/src/marshal/FlushCommandMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef FlushCommandMarshaller_hpp_
#define FlushCommandMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class FlushCommandMarshaller : public BaseCommandMarshaller
{
public:
FlushCommandMarshaller() ;
virtual ~FlushCommandMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*FlushCommandMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef FlushCommandMarshaller_hpp_ #define FlushCommandMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class FlushCommandMarshaller : public BaseCommandMarshaller { public: FlushCommandMarshaller() ; virtual ~FlushCommandMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*FlushCommandMarshaller_hpp_*/

72
openwire-cpp/src/marshal/IntegerResponseMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef IntegerResponseMarshaller_hpp_
#define IntegerResponseMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/ResponseMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class IntegerResponseMarshaller : public ResponseMarshaller
{
public:
IntegerResponseMarshaller() ;
virtual ~IntegerResponseMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*IntegerResponseMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef IntegerResponseMarshaller_hpp_ #define IntegerResponseMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/ResponseMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class IntegerResponseMarshaller : public ResponseMarshaller { public: IntegerResponseMarshaller() ; virtual ~IntegerResponseMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*IntegerResponseMarshaller_hpp_*/

72
openwire-cpp/src/marshal/JournalQueueAckMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef JournalQueueAckMarshaller_hpp_
#define JournalQueueAckMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class JournalQueueAckMarshaller : public BaseDataStreamMarshaller
{
public:
JournalQueueAckMarshaller() ;
virtual ~JournalQueueAckMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*JournalQueueAckMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef JournalQueueAckMarshaller_hpp_ #define JournalQueueAckMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class JournalQueueAckMarshaller : public BaseDataStreamMarshaller { public: JournalQueueAckMarshaller() ; virtual ~JournalQueueAckMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*JournalQueueAckMarshaller_hpp_*/

72
openwire-cpp/src/marshal/JournalTopicAckMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef JournalTopicAckMarshaller_hpp_
#define JournalTopicAckMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class JournalTopicAckMarshaller : public BaseDataStreamMarshaller
{
public:
JournalTopicAckMarshaller() ;
virtual ~JournalTopicAckMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*JournalTopicAckMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef JournalTopicAckMarshaller_hpp_ #define JournalTopicAckMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class JournalTopicAckMarshaller : public BaseDataStreamMarshaller { public: JournalTopicAckMarshaller() ; virtual ~JournalTopicAckMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*JournalTopicAckMarshaller_hpp_*/

72
openwire-cpp/src/marshal/JournalTraceMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef JournalTraceMarshaller_hpp_
#define JournalTraceMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class JournalTraceMarshaller : public BaseDataStreamMarshaller
{
public:
JournalTraceMarshaller() ;
virtual ~JournalTraceMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*JournalTraceMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef JournalTraceMarshaller_hpp_ #define JournalTraceMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class JournalTraceMarshaller : public BaseDataStreamMarshaller { public: JournalTraceMarshaller() ; virtual ~JournalTraceMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*JournalTraceMarshaller_hpp_*/

72
openwire-cpp/src/marshal/JournalTransactionMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef JournalTransactionMarshaller_hpp_
#define JournalTransactionMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class JournalTransactionMarshaller : public BaseDataStreamMarshaller
{
public:
JournalTransactionMarshaller() ;
virtual ~JournalTransactionMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*JournalTransactionMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef JournalTransactionMarshaller_hpp_ #define JournalTransactionMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class JournalTransactionMarshaller : public BaseDataStreamMarshaller { public: JournalTransactionMarshaller() ; virtual ~JournalTransactionMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*JournalTransactionMarshaller_hpp_*/

72
openwire-cpp/src/marshal/KeepAliveInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef KeepAliveInfoMarshaller_hpp_
#define KeepAliveInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class KeepAliveInfoMarshaller : public BaseDataStreamMarshaller
{
public:
KeepAliveInfoMarshaller() ;
virtual ~KeepAliveInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*KeepAliveInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef KeepAliveInfoMarshaller_hpp_ #define KeepAliveInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class KeepAliveInfoMarshaller : public BaseDataStreamMarshaller { public: KeepAliveInfoMarshaller() ; virtual ~KeepAliveInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*KeepAliveInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/LocalTransactionIdMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef LocalTransactionIdMarshaller_hpp_
#define LocalTransactionIdMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/TransactionIdMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class LocalTransactionIdMarshaller : public TransactionIdMarshaller
{
public:
LocalTransactionIdMarshaller() ;
virtual ~LocalTransactionIdMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*LocalTransactionIdMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef LocalTransactionIdMarshaller_hpp_ #define LocalTransactionIdMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/TransactionIdMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class LocalTransactionIdMarshaller : public TransactionIdMarshaller { public: LocalTransactionIdMarshaller() ; virtual ~LocalTransactionIdMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*LocalTransactionIdMarshaller_hpp_*/

2
openwire-cpp/src/marshal/MarshallerFactory.cpp
View File

@ -59,6 +59,7 @@
#include "marshal/WireFormatInfoMarshaller.hpp"
#include "marshal/ActiveMQTempTopicMarshaller.hpp"
#include "marshal/DiscoveryEventMarshaller.hpp"
#include "marshal/ReplayCommandMarshaller.hpp"
#include "marshal/ActiveMQTopicMarshaller.hpp"
#include "marshal/BrokerInfoMarshaller.hpp"
#include "marshal/DestinationInfoMarshaller.hpp"
@ -115,6 +116,7 @@ void MarshallerFactory::configure(OpenWireFormat& format)
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());

72
openwire-cpp/src/marshal/MessageAckMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef MessageAckMarshaller_hpp_
#define MessageAckMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class MessageAckMarshaller : public BaseCommandMarshaller
{
public:
MessageAckMarshaller() ;
virtual ~MessageAckMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*MessageAckMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef MessageAckMarshaller_hpp_ #define MessageAckMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class MessageAckMarshaller : public BaseCommandMarshaller { public: MessageAckMarshaller() ; virtual ~MessageAckMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*MessageAckMarshaller_hpp_*/

72
openwire-cpp/src/marshal/MessageDispatchMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef MessageDispatchMarshaller_hpp_
#define MessageDispatchMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class MessageDispatchMarshaller : public BaseCommandMarshaller
{
public:
MessageDispatchMarshaller() ;
virtual ~MessageDispatchMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*MessageDispatchMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef MessageDispatchMarshaller_hpp_ #define MessageDispatchMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class MessageDispatchMarshaller : public BaseCommandMarshaller { public: MessageDispatchMarshaller() ; virtual ~MessageDispatchMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*MessageDispatchMarshaller_hpp_*/

72
openwire-cpp/src/marshal/MessageDispatchNotificationMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef MessageDispatchNotificationMarshaller_hpp_
#define MessageDispatchNotificationMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class MessageDispatchNotificationMarshaller : public BaseCommandMarshaller
{
public:
MessageDispatchNotificationMarshaller() ;
virtual ~MessageDispatchNotificationMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*MessageDispatchNotificationMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef MessageDispatchNotificationMarshaller_hpp_ #define MessageDispatchNotificationMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class MessageDispatchNotificationMarshaller : public BaseCommandMarshaller { public: MessageDispatchNotificationMarshaller() ; virtual ~MessageDispatchNotificationMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*MessageDispatchNotificationMarshaller_hpp_*/

72
openwire-cpp/src/marshal/MessageIdMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef MessageIdMarshaller_hpp_
#define MessageIdMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class MessageIdMarshaller : public BaseDataStreamMarshaller
{
public:
MessageIdMarshaller() ;
virtual ~MessageIdMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*MessageIdMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef MessageIdMarshaller_hpp_ #define MessageIdMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class MessageIdMarshaller : public BaseDataStreamMarshaller { public: MessageIdMarshaller() ; virtual ~MessageIdMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*MessageIdMarshaller_hpp_*/

72
openwire-cpp/src/marshal/MessageMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef MessageMarshaller_hpp_
#define MessageMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class MessageMarshaller : public BaseCommandMarshaller
{
public:
MessageMarshaller() ;
virtual ~MessageMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*MessageMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef MessageMarshaller_hpp_ #define MessageMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class MessageMarshaller : public BaseCommandMarshaller { public: MessageMarshaller() ; virtual ~MessageMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*MessageMarshaller_hpp_*/

88
openwire-cpp/src/marshal/NetworkBridgeFilterMarshaller.cpp
View File

@ -1,87 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#include "marshal/NetworkBridgeFilterMarshaller.hpp"
using namespace apache::activemq::client::marshal;
/*
* Marshalling code for Open Wire Format for NetworkBridgeFilter
*
* 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
*/
NetworkBridgeFilterMarshaller::NetworkBridgeFilterMarshaller()
{
// no-op
}
NetworkBridgeFilterMarshaller::~NetworkBridgeFilterMarshaller()
{
// no-op
}
DataStructure* NetworkBridgeFilterMarshaller::createObject()
{
return new NetworkBridgeFilter();
}
byte NetworkBridgeFilterMarshaller::getDataStructureType()
{
return NetworkBridgeFilter.ID_NetworkBridgeFilter;
}
/*
* Un-marshal an object instance from the data input stream
*/
void NetworkBridgeFilterMarshaller::unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs)
{
base.unmarshal(wireFormat, o, dataIn, bs);
NetworkBridgeFilter& info = (NetworkBridgeFilter&) o;
info.setNetworkTTL(dataIn.readInt());
info.setNetworkBrokerId((org.apache.activemq.command.BrokerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs));
}
/*
* Write the booleans that this object uses to a BooleanStream
*/
int NetworkBridgeFilterMarshaller::marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) {
NetworkBridgeFilter& info = (NetworkBridgeFilter&) o;
int rc = base.marshal1(wireFormat, info, bs);
rc += marshal1CachedObject(wireFormat, info.getNetworkBrokerId(), bs);
return rc + 1;
}
/*
* Write a object instance to data output stream
*/
void NetworkBridgeFilterMarshaller::marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) {
base.marshal2(wireFormat, o, dataOut, bs);
NetworkBridgeFilter& info = (NetworkBridgeFilter&) o;
DataStreamMarshaller.writeInt(info.getNetworkTTL(), dataOut);
marshal2CachedObject(wireFormat, info.getNetworkBrokerId(), dataOut, bs);
}
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #include "marshal/NetworkBridgeFilterMarshaller.hpp" using namespace apache::activemq::client::marshal; /* * Marshalling code for Open Wire Format for NetworkBridgeFilter * * 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 */ NetworkBridgeFilterMarshaller::NetworkBridgeFilterMarshaller() { // no-op } NetworkBridgeFilterMarshaller::~NetworkBridgeFilterMarshaller() { // no-op } DataStructure* NetworkBridgeFilterMarshaller::createObject() { return new NetworkBridgeFilter(); } byte NetworkBridgeFilterMarshaller::getDataStructureType() { return NetworkBridgeFilter.ID_NetworkBridgeFilter; } /* * Un-marshal an object instance from the data input stream */ void NetworkBridgeFilterMarshaller::unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) { base.unmarshal(wireFormat, o, dataIn, bs); NetworkBridgeFilter& info = (NetworkBridgeFilter&) o; info.setNetworkTTL(dataIn.readInt()); info.setNetworkBrokerId((org.apache.activemq.command.BrokerId) tightUnmarsalCachedObject(wireFormat, dataIn, bs)); } /* * Write the booleans that this object uses to a BooleanStream */ int NetworkBridgeFilterMarshaller::marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) { NetworkBridgeFilter& info = (NetworkBridgeFilter&) o; int rc = base.marshal1(wireFormat, info, bs); rc += marshal1CachedObject(wireFormat, info.getNetworkBrokerId(), bs); return rc + 1; } /* * Write a object instance to data output stream */ void NetworkBridgeFilterMarshaller::marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) { base.marshal2(wireFormat, o, dataOut, bs); NetworkBridgeFilter& info = (NetworkBridgeFilter&) o; DataStreamMarshaller.writeInt(info.getNetworkTTL(), dataOut); marshal2CachedObject(wireFormat, info.getNetworkBrokerId(), dataOut, bs); }

72
openwire-cpp/src/marshal/NetworkBridgeFilterMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef NetworkBridgeFilterMarshaller_hpp_
#define NetworkBridgeFilterMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class NetworkBridgeFilterMarshaller : public BaseDataStreamMarshaller
{
public:
NetworkBridgeFilterMarshaller() ;
virtual ~NetworkBridgeFilterMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*NetworkBridgeFilterMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef NetworkBridgeFilterMarshaller_hpp_ #define NetworkBridgeFilterMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class NetworkBridgeFilterMarshaller : public BaseDataStreamMarshaller { public: NetworkBridgeFilterMarshaller() ; virtual ~NetworkBridgeFilterMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*NetworkBridgeFilterMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ProducerIdMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ProducerIdMarshaller_hpp_
#define ProducerIdMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ProducerIdMarshaller : public BaseDataStreamMarshaller
{
public:
ProducerIdMarshaller() ;
virtual ~ProducerIdMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ProducerIdMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ProducerIdMarshaller_hpp_ #define ProducerIdMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ProducerIdMarshaller : public BaseDataStreamMarshaller { public: ProducerIdMarshaller() ; virtual ~ProducerIdMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ProducerIdMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ProducerInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ProducerInfoMarshaller_hpp_
#define ProducerInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ProducerInfoMarshaller : public BaseCommandMarshaller
{
public:
ProducerInfoMarshaller() ;
virtual ~ProducerInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ProducerInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ProducerInfoMarshaller_hpp_ #define ProducerInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ProducerInfoMarshaller : public BaseCommandMarshaller { public: ProducerInfoMarshaller() ; virtual ~ProducerInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ProducerInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/RemoveInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef RemoveInfoMarshaller_hpp_
#define RemoveInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class RemoveInfoMarshaller : public BaseCommandMarshaller
{
public:
RemoveInfoMarshaller() ;
virtual ~RemoveInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*RemoveInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef RemoveInfoMarshaller_hpp_ #define RemoveInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class RemoveInfoMarshaller : public BaseCommandMarshaller { public: RemoveInfoMarshaller() ; virtual ~RemoveInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*RemoveInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/RemoveSubscriptionInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef RemoveSubscriptionInfoMarshaller_hpp_
#define RemoveSubscriptionInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class RemoveSubscriptionInfoMarshaller : public BaseCommandMarshaller
{
public:
RemoveSubscriptionInfoMarshaller() ;
virtual ~RemoveSubscriptionInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*RemoveSubscriptionInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef RemoveSubscriptionInfoMarshaller_hpp_ #define RemoveSubscriptionInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class RemoveSubscriptionInfoMarshaller : public BaseCommandMarshaller { public: RemoveSubscriptionInfoMarshaller() ; virtual ~RemoveSubscriptionInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*RemoveSubscriptionInfoMarshaller_hpp_*/

78
openwire-cpp/src/marshal/ReplayCommandMarshaller.cpp Normal file
View File

@ -0,0 +1,78 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#include "marshal/ReplayCommandMarshaller.hpp"
using namespace apache::activemq::client::marshal;
/*
* Marshalling code for Open Wire Format for ReplayCommand
*
* 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
*/
ReplayCommandMarshaller::ReplayCommandMarshaller()
{
// no-op
}
ReplayCommandMarshaller::~ReplayCommandMarshaller()
{
// no-op
}
DataStructure* ReplayCommandMarshaller::createObject()
{
return new ReplayCommand();
}
byte ReplayCommandMarshaller::getDataStructureType()
{
return ReplayCommand.ID_ReplayCommand;
}
/*
* Un-marshal an object instance from the data input stream
*/
void ReplayCommandMarshaller::unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs)
{
base.unmarshal(wireFormat, o, dataIn, bs);
}
/*
* Write the booleans that this object uses to a BooleanStream
*/
int ReplayCommandMarshaller::marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) {
ReplayCommand& info = (ReplayCommand&) o;
int rc = base.marshal1(wireFormat, info, bs);
return rc + 0;
}
/*
* Write a object instance to data output stream
*/
void ReplayCommandMarshaller::marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) {
base.marshal2(wireFormat, o, dataOut, bs);
}

1
openwire-cpp/src/marshal/ReplayCommandMarshaller.hpp Normal file
View File

@ -0,0 +1 @@
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ReplayCommandMarshaller_hpp_ #define ReplayCommandMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ReplayCommandMarshaller : public BaseCommandMarshaller { public: ReplayCommandMarshaller() ; virtual ~ReplayCommandMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ReplayCommandMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ResponseMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ResponseMarshaller_hpp_
#define ResponseMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ResponseMarshaller : public BaseCommandMarshaller
{
public:
ResponseMarshaller() ;
virtual ~ResponseMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ResponseMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ResponseMarshaller_hpp_ #define ResponseMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ResponseMarshaller : public BaseCommandMarshaller { public: ResponseMarshaller() ; virtual ~ResponseMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ResponseMarshaller_hpp_*/

72
openwire-cpp/src/marshal/SessionIdMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef SessionIdMarshaller_hpp_
#define SessionIdMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class SessionIdMarshaller : public BaseDataStreamMarshaller
{
public:
SessionIdMarshaller() ;
virtual ~SessionIdMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*SessionIdMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef SessionIdMarshaller_hpp_ #define SessionIdMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class SessionIdMarshaller : public BaseDataStreamMarshaller { public: SessionIdMarshaller() ; virtual ~SessionIdMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*SessionIdMarshaller_hpp_*/

72
openwire-cpp/src/marshal/SessionInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef SessionInfoMarshaller_hpp_
#define SessionInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class SessionInfoMarshaller : public BaseCommandMarshaller
{
public:
SessionInfoMarshaller() ;
virtual ~SessionInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*SessionInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef SessionInfoMarshaller_hpp_ #define SessionInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class SessionInfoMarshaller : public BaseCommandMarshaller { public: SessionInfoMarshaller() ; virtual ~SessionInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*SessionInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/ShutdownInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef ShutdownInfoMarshaller_hpp_
#define ShutdownInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class ShutdownInfoMarshaller : public BaseCommandMarshaller
{
public:
ShutdownInfoMarshaller() ;
virtual ~ShutdownInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*ShutdownInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef ShutdownInfoMarshaller_hpp_ #define ShutdownInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class ShutdownInfoMarshaller : public BaseCommandMarshaller { public: ShutdownInfoMarshaller() ; virtual ~ShutdownInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*ShutdownInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/SubscriptionInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef SubscriptionInfoMarshaller_hpp_
#define SubscriptionInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class SubscriptionInfoMarshaller : public BaseDataStreamMarshaller
{
public:
SubscriptionInfoMarshaller() ;
virtual ~SubscriptionInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*SubscriptionInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef SubscriptionInfoMarshaller_hpp_ #define SubscriptionInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class SubscriptionInfoMarshaller : public BaseDataStreamMarshaller { public: SubscriptionInfoMarshaller() ; virtual ~SubscriptionInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*SubscriptionInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/TransactionIdMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef TransactionIdMarshaller_hpp_
#define TransactionIdMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class TransactionIdMarshaller : public BaseDataStreamMarshaller
{
public:
TransactionIdMarshaller() ;
virtual ~TransactionIdMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*TransactionIdMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef TransactionIdMarshaller_hpp_ #define TransactionIdMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class TransactionIdMarshaller : public BaseDataStreamMarshaller { public: TransactionIdMarshaller() ; virtual ~TransactionIdMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*TransactionIdMarshaller_hpp_*/

72
openwire-cpp/src/marshal/TransactionInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef TransactionInfoMarshaller_hpp_
#define TransactionInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseCommandMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class TransactionInfoMarshaller : public BaseCommandMarshaller
{
public:
TransactionInfoMarshaller() ;
virtual ~TransactionInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*TransactionInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef TransactionInfoMarshaller_hpp_ #define TransactionInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseCommandMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class TransactionInfoMarshaller : public BaseCommandMarshaller { public: TransactionInfoMarshaller() ; virtual ~TransactionInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*TransactionInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/WireFormatInfoMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef WireFormatInfoMarshaller_hpp_
#define WireFormatInfoMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/BaseDataStreamMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class WireFormatInfoMarshaller : public BaseDataStreamMarshaller
{
public:
WireFormatInfoMarshaller() ;
virtual ~WireFormatInfoMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*WireFormatInfoMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef WireFormatInfoMarshaller_hpp_ #define WireFormatInfoMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/BaseDataStreamMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class WireFormatInfoMarshaller : public BaseDataStreamMarshaller { public: WireFormatInfoMarshaller() ; virtual ~WireFormatInfoMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*WireFormatInfoMarshaller_hpp_*/

72
openwire-cpp/src/marshal/XATransactionIdMarshaller.hpp
View File

@ -1,71 +1 @@
/*
* Copyright 2006 The Apache Software Foundation or its licensors, as
* applicable.
*
* Licensed 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.
*/
#ifndef XATransactionIdMarshaller_hpp_
#define XATransactionIdMarshaller_hpp_
#include <string>
#include "command/DataStructure.hpp"
/* we could cut this down - for now include all possible headers */
#include "command/BrokerId.hpp"
#include "command/ConnectionId.hpp"
#include "command/ConsumerId.hpp"
#include "command/ProducerId.hpp"
#include "command/SessionId.hpp"
#include "io/BinaryReader.hpp"
#include "io/BinaryWriter.hpp"
#include "command/TransactionIdMarshaller.hpp"
#include "util/ifr/p.hpp"
namespace apache
{
namespace activemq
{
namespace client
{
namespace marshal
{
using namespace ifr ;
using namespace apache::activemq::client::command;
using namespace apache::activemq::client::io;
/*
*
*/
class XATransactionIdMarshaller : public TransactionIdMarshaller
{
public:
XATransactionIdMarshaller() ;
virtual ~XATransactionIdMarshaller() ;
virtual DataStructure* createCommand() ;
virtual byte getDataStructureType() ;
virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ;
virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ;
virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ;
} ;
/* namespace */
}
}
}
}
#endif /*XATransactionIdMarshaller_hpp_*/
/* * Copyright 2006 The Apache Software Foundation or its licensors, as * applicable. * * Licensed 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. */ #ifndef XATransactionIdMarshaller_hpp_ #define XATransactionIdMarshaller_hpp_ #include <string> #include "command/DataStructure.hpp" /* we could cut this down - for now include all possible headers */ #include "command/BrokerId.hpp" #include "command/ConnectionId.hpp" #include "command/ConsumerId.hpp" #include "command/ProducerId.hpp" #include "command/SessionId.hpp" #include "io/BinaryReader.hpp" #include "io/BinaryWriter.hpp" #include "command/TransactionIdMarshaller.hpp" #include "util/ifr/p.hpp" namespace apache { namespace activemq { namespace client { namespace marshal { using namespace ifr ; using namespace apache::activemq::client::command; using namespace apache::activemq::client::io; /* * */ class XATransactionIdMarshaller : public TransactionIdMarshaller { public: XATransactionIdMarshaller() ; virtual ~XATransactionIdMarshaller() ; virtual DataStructure* createCommand() ; virtual byte getDataStructureType() ; virtual void unmarshal(OpenWireFormat& wireFormat, Object o, BinaryReader& dataIn, BooleanStream& bs) ; virtual int marshal1(OpenWireFormat& wireFormat, Object& o, BooleanStream& bs) ; virtual void marshal2(OpenWireFormat& wireFormat, Object& o, BinaryWriter& dataOut, BooleanStream& bs) ; } ; /* namespace */ } } } } #endif /*XATransactionIdMarshaller_hpp_*/