| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef _ACTIVEMQ_UTIL_CMSPROVIDER_H_ |
| #define _ACTIVEMQ_UTIL_CMSPROVIDER_H_ |
| |
| #include <string> |
| #include <memory> |
| |
| #include <cms/ConnectionFactory.h> |
| #include <cms/Connection.h> |
| #include <cms/MessageConsumer.h> |
| #include <cms/MessageProducer.h> |
| #include <cms/MessageListener.h> |
| #include <cms/Session.h> |
| #include <cms/Destination.h> |
| |
| #include <decaf/io/Closeable.h> |
| |
| namespace activemq { |
| namespace util { |
| |
| class CMSProvider : decaf::io::Closeable { |
| private: |
| |
| std::string brokerURL; |
| cms::Session::AcknowledgeMode ackMode; |
| std::string username; |
| std::string password; |
| std::string clientId; |
| |
| std::string destinationName; |
| bool topic; |
| bool durable; |
| std::string subscription; |
| |
| std::auto_ptr<cms::ConnectionFactory> connectionFactory; |
| std::auto_ptr<cms::Connection> connection; |
| std::auto_ptr<cms::Session> session; |
| std::auto_ptr<cms::MessageConsumer> consumer; |
| std::auto_ptr<cms::MessageProducer> producer; |
| std::auto_ptr<cms::MessageProducer> noDestProducer; |
| std::auto_ptr<cms::Destination> destination; |
| std::auto_ptr<cms::Destination> tempDestination; |
| |
| public: |
| |
| CMSProvider(const std::string& brokerURL, cms::Session::AcknowledgeMode ackMode = cms::Session::AUTO_ACKNOWLEDGE); |
| |
| CMSProvider(const std::string& brokerURL, |
| const std::string& destinationName, |
| const std::string& subscription, |
| cms::Session::AcknowledgeMode ackMode = cms::Session::AUTO_ACKNOWLEDGE); |
| |
| virtual ~CMSProvider(); |
| |
| virtual void close(); |
| |
| std::string getBrokerURL() const { |
| return this->brokerURL; |
| } |
| |
| void setBrokerURL(const std::string& brokerURL) { |
| this->brokerURL = brokerURL; |
| } |
| |
| void setDestinationName(const std::string name) { |
| this->destinationName = name; |
| } |
| |
| std::string getDestinationName() const { |
| return this->destinationName; |
| } |
| |
| void setSubscription(const std::string name) { |
| this->subscription = name; |
| } |
| |
| std::string getSubscription() const { |
| return this->subscription; |
| } |
| |
| void setTopic(bool value) { |
| this->topic = value; |
| } |
| |
| bool isTopic() const { |
| return this->topic; |
| } |
| |
| void setDurable(bool value) { |
| this->durable = value; |
| } |
| |
| bool isDurable() const { |
| return this->durable; |
| } |
| |
| void setAckMode(cms::Session::AcknowledgeMode ackMode) { |
| this->ackMode = ackMode; |
| } |
| |
| cms::Session::AcknowledgeMode getAckMode() const { |
| return this->ackMode; |
| } |
| |
| public: |
| |
| /** |
| * Initializes a CMSProvider with the Login data for the session that |
| * this provider is managing. Once called a new Connection to the broker |
| * is made and will remain open until a reconnect is requested or until |
| * the CMSProvider instance is closed. |
| */ |
| virtual void initialize(const std::string& username = "", |
| const std::string& password = "", |
| const std::string& clientId = ""); |
| |
| /** |
| * Forces a reconnect of the Connection and then of the Session and its |
| * associated resources. |
| */ |
| virtual void reconnect(); |
| |
| /** |
| * Forces a Recreation of a Session and any of its Resources. |
| */ |
| virtual void reconnectSession(); |
| |
| /** |
| * Unsubscribes a durable consumer if one has been created and the chosen |
| * wireformat supports it. The consumer is closed as a result any calls to |
| * it after calling this method will result in an error. |
| */ |
| virtual void unsubscribe(); |
| |
| /** |
| * Returns the ConnectionFactory object that this Provider has allocated. |
| */ |
| virtual cms::ConnectionFactory* getConnectionFactory(); |
| |
| /** |
| * Returns the Connection object that this Provider has allocated. |
| */ |
| virtual cms::Connection* getConnection(); |
| |
| /** |
| * Returns the Session object that this Provider has allocated. |
| */ |
| virtual cms::Session* getSession(); |
| |
| /** |
| * Returns the MessageConsumer object that this Provider has allocated. |
| */ |
| virtual cms::MessageConsumer* getConsumer(); |
| |
| /** |
| * Returns the MessageProducer object that this Provider has allocated. |
| */ |
| virtual cms::MessageProducer* getProducer(); |
| |
| /** |
| * Returns the MessageProducer object that this Provider has allocated that has |
| * no assigned Destination, message sent must be assigned one at send time. |
| */ |
| virtual cms::MessageProducer* getNoDestProducer(); |
| |
| /** |
| * Returns the Destination object that this Provider has allocated. |
| */ |
| virtual cms::Destination* getDestination(); |
| |
| /** |
| * Returns the Temporary Destination object that this Provider has allocated. |
| */ |
| virtual cms::Destination* getTempDestination(); |
| |
| /** |
| * Destroys a Destination at the Broker side, freeing the resources associated with it. |
| */ |
| virtual void destroyDestination(const cms::Destination* destination); |
| |
| }; |
| |
| }} |
| |
| #endif /*_ACTIVEMQ_UTIL_CMSPROVIDER_H_*/ |