ActiveMQConnectionFactory.h

Go to the documentation of this file.

/*
 * 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_CORE_ACTIVEMQCONNECTIONFACTORY_H_
#define _ACTIVEMQ_CORE_ACTIVEMQCONNECTIONFACTORY_H_

#include <activemq/util/Config.h>

#include <cms/ConnectionFactory.h>
#include <cms/Connection.h>

#include <activemq/transport/Transport.h>

#include <decaf/net/URI.h>
#include <decaf/util/Properties.h>

namespace activemq {
namespace core {

    using decaf::lang::Pointer;

    class ActiveMQConnection;
    class FactorySettings;
    class PrefetchPolicy;
    class RedeliveryPolicy;

    class AMQCPP_API ActiveMQConnectionFactory : public cms::ConnectionFactory {
    public:

        // Default Broker URI if none specified 'failover:tcp://localhost:61616'
        static const std::string DEFAULT_URI;

    private:

        FactorySettings* settings;

    private:

        ActiveMQConnectionFactory(const ActiveMQConnectionFactory&);
        ActiveMQConnectionFactory& operator=(const ActiveMQConnectionFactory&);

    public:

        ActiveMQConnectionFactory();

        ActiveMQConnectionFactory(const std::string& uri,
                                  const std::string& username = "",
                                  const std::string& password = "");

        ActiveMQConnectionFactory(const decaf::net::URI& uri,
                                  const std::string& username = "",
                                  const std::string& password = "");

        virtual ~ActiveMQConnectionFactory();

        virtual cms::Connection* createConnection();

        virtual cms::Connection* createConnection(const std::string& username,
                                                  const std::string& password);

        virtual cms::Connection* createConnection(const std::string& username,
                                                  const std::string& password,
                                                  const std::string& clientId);

    public:   // Configuration Options

        void setUsername(const std::string& username);

        const std::string& getUsername() const;

        void setPassword(const std::string& password);

        const std::string& getPassword() const;

        std::string getClientId() const;

        void setClientId(const std::string& clientId);

        void setBrokerURI(const std::string& uri);

        void setBrokerURI(const decaf::net::URI& uri);

        const decaf::net::URI& getBrokerURI() const;

        virtual void setExceptionListener(cms::ExceptionListener* listener);

        virtual cms::ExceptionListener* getExceptionListener() const;

        virtual void setMessageTransformer(cms::MessageTransformer* transformer);

        virtual cms::MessageTransformer* getMessageTransformer() const;

        void setPrefetchPolicy(PrefetchPolicy* policy);

        PrefetchPolicy* getPrefetchPolicy() const;

        void setRedeliveryPolicy(RedeliveryPolicy* policy);

        RedeliveryPolicy* getRedeliveryPolicy() const;

        bool isDispatchAsync() const;

        void setDispatchAsync(bool value);

        bool isAlwaysSyncSend() const;

        void setAlwaysSyncSend(bool value);

        bool isUseAsyncSend() const;

        void setUseAsyncSend(bool value);

        bool isSendAcksAsync() const;

        void setSendAcksAsync(bool sendAcksAsync);

        bool isUseCompression() const;

        void setUseCompression(bool value);

        void setCompressionLevel(int value);

        int getCompressionLevel() const;

        unsigned int getSendTimeout() const;

        void setSendTimeout(unsigned int timeout);

        unsigned int getConnectResponseTimeout() const;

        void setConnectResponseTimeout(unsigned int connectResponseTimeout);

        unsigned int getCloseTimeout() const;

        void setCloseTimeout(unsigned int timeout);

        unsigned int getProducerWindowSize() const;

        void setProducerWindowSize(unsigned int windowSize);

        bool isMessagePrioritySupported() const;

        void setMessagePrioritySupported(bool value);

        bool isUseRetroactiveConsumer() const;

        void setUseRetroactiveConsumer(bool useRetroactiveConsumer);

        bool isExclusiveConsumer() const;

        void setExclusiveConsumer(bool exclusiveConsumer);

        bool isWatchTopicAdvisories() const;

        void setWatchTopicAdvisories(bool value);

        int getAuditDepth() const;

        void setAuditDepth(int auditDepth);

        int getAuditMaximumProducerNumber() const;

        void setAuditMaximumProducerNumber(int auditMaximumProducerNumber);

        bool isCheckForDuplicates() const;

        void setCheckForDuplicates(bool checkForDuplicates);

        bool isTransactedIndividualAck() const;

        void setTransactedIndividualAck(bool transactedIndividualAck);

        bool isNonBlockingRedelivery() const;

        void setNonBlockingRedelivery(bool nonBlockingRedelivery);

        long long getConsumerFailoverRedeliveryWaitPeriod() const;

        void setConsumerFailoverRedeliveryWaitPeriod(long long value);

        bool isOptimizeAcknowledge() const;

        void setOptimizeAcknowledge(bool optimizeAcknowledge);

        long long getOptimizeAcknowledgeTimeOut() const;

        void setOptimizeAcknowledgeTimeOut(long long optimizeAcknowledgeTimeOut);

        long long getOptimizedAckScheduledAckInterval() const;

        void setOptimizedAckScheduledAckInterval(long long optimizedAckScheduledAckInterval);

        bool isAlwaysSessionAsync() const;

        void setAlwaysSessionAsync(bool alwaysSessionAsync);

        bool isConsumerExpiryCheckEnabled();

        void setConsumerExpiryCheckEnabled(bool consumerExpiryCheckEnabled);

    public:

        static cms::Connection* createConnection(const std::string& uri, const std::string& username,
                                                 const std::string& password, const std::string& clientId = "");

    protected:

        virtual ActiveMQConnection* createActiveMQConnection(const Pointer<transport::Transport>& transport,
                                                             const Pointer<decaf::util::Properties>& properties);

    private:

        cms::Connection* doCreateConnection(const decaf::net::URI& uri, const std::string& username,
                                            const std::string& password, const std::string& clientId);

        void configureConnection(ActiveMQConnection* connection);

    };

}}

#endif /*_ACTIVEMQ_CORE_ACTIVEMQCONNECTIONFACTORY_H_*/