ActiveMQDestination.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_COMMANDS_ACTIVEMQDESTINATION_H_
#define _ACTIVEMQ_COMMANDS_ACTIVEMQDESTINATION_H_

// Turn off warning message for ignored exception specification
#ifdef _MSC_VER
#pragma warning( disable : 4290 )
#endif

#include <activemq/util/Config.h>
#include <activemq/commands/BaseDataStructure.h>
#include <activemq/util/ActiveMQProperties.h>
#include <cms/Destination.h>
#include <decaf/lang/Pointer.h>
#include <decaf/lang/Comparable.h>
#include <decaf/util/ArrayList.h>

#include <vector>
#include <string>
#include <map>

namespace activemq{
namespace commands{

    using decaf::lang::Pointer;

    class AMQCPP_API ActiveMQDestination : public BaseDataStructure,
                                           public decaf::lang::Comparable<ActiveMQDestination> {
    protected:

        struct DestinationFilter{
            static const std::string ANY_CHILD;
            static const std::string ANY_DESCENDENT;
        };

        static const std::string DEFAULT_ORDERED_TARGET;

        static const std::string TEMP_PREFIX;
        static const std::string TEMP_POSTFIX;
        static const std::string COMPOSITE_SEPARATOR;

        static const std::string QUEUE_QUALIFIED_PREFIX;
        static const std::string TOPIC_QUALIFIED_PREFIX;
        static const std::string TEMP_QUEUE_QUALIFED_PREFIX;
        static const std::string TEMP_TOPIC_QUALIFED_PREFIX;

        // Cached transient data
        bool exclusive;
        bool ordered;
        bool advisory;
        mutable decaf::util::ArrayList< Pointer<ActiveMQDestination> > compositeDestinations;
        std::string orderedTarget;

        std::string physicalName;
        util::ActiveMQProperties options;

    public:

        const static unsigned char ID_ACTIVEMQDESTINATION = 0;

        typedef decaf::lang::PointerComparator<ActiveMQDestination> COMPARATOR;

    private:

        ActiveMQDestination(const ActiveMQDestination&);
        ActiveMQDestination& operator=(const ActiveMQDestination&);

    public:

        ActiveMQDestination();

        ActiveMQDestination(const std::string& physicalName);

        virtual ~ActiveMQDestination() throw();

        virtual ActiveMQDestination* cloneDataStructure() const {
            return NULL;
        }

        virtual void copyDataStructure(const DataStructure* src);

        virtual bool equals(const DataStructure* value) const;

        virtual unsigned char getDataStructureType() const;

        virtual std::string toString() const;

    public:

        virtual std::string getPhysicalName() const {
            return this->physicalName;
        }

        virtual void setPhysicalName(const std::string& physicalName);

        virtual bool isAdvisory() const {
            return advisory;
        }

        virtual void setAdvisory(bool advisory) {
            this->advisory = advisory;
        }

//        /**
//         * @return true if this is a destination for Consumer advisories
//         */
//        virtual bool isConsumerAdvisory() const {
//            return isAdvisory() && physicalName.find(CONSUMER_ADVISORY_PREFIX) == 0;
//        }
//
//        /**
//         * @return true if this is a destination for Producer advisories
//         */
//        virtual bool isProducerAdvisory() const {
//            return isAdvisory() && physicalName.find(PRODUCER_ADVISORY_PREFIX) == 0;
//        }
//
//        /**
//         * @return true if this is a destination for Connection advisories
//         */
//        virtual bool isConnectionAdvisory() const {
//            return isAdvisory() && physicalName.find(CONNECTION_ADVISORY_PREFIX) == 0;
//        }

        virtual bool isExclusive() const {
            return exclusive;
        }

        virtual void setExclusive( bool exclusive ) {
            this->exclusive = exclusive;
        }

        virtual bool isOrdered() const {
            return ordered;
        }

        virtual void setOrdered(bool ordered) {
            this->ordered = ordered;
        }

        virtual std::string getOrderedTarget() const {
            return orderedTarget;
        }

        virtual void setOrderedTarget(const std::string& orderedTarget) {
            this->orderedTarget = orderedTarget;
        }

        virtual cms::Destination::DestinationType getDestinationType() const = 0;

        std::string getDestinationTypeAsString() const;

        virtual bool isTemporary() const {
            return getDestinationType() == cms::Destination::TEMPORARY_TOPIC ||
                   getDestinationType() == cms::Destination::TEMPORARY_QUEUE;
        }

        virtual bool isTopic() const {
            return getDestinationType() == cms::Destination::TOPIC ||
                   getDestinationType() == cms::Destination::TEMPORARY_TOPIC;
        }

        virtual bool isQueue() const {
            return !isTopic();
        }

        virtual bool isComposite() const {
            return physicalName.find_first_of(COMPOSITE_SEPARATOR) != std::string::npos;
        }

        decaf::util::ArrayList< Pointer<ActiveMQDestination> > getCompositeDestinations() const;

        virtual bool isWildcard() const {
            return physicalName.find_first_of(DestinationFilter::ANY_CHILD) != std::string::npos||
                   physicalName.find_first_of(DestinationFilter::ANY_DESCENDENT) != std::string::npos;
        }

        const activemq::util::ActiveMQProperties& getOptions() const {
            return options;
        }

        virtual const cms::Destination* getCMSDestination() const {
            return NULL;
        }

        Pointer<ActiveMQDestination> createDestination(const std::string& name) const {
            return ActiveMQDestination::createDestination(getDestinationType(), name);
        }

        virtual int compareTo(const ActiveMQDestination& value) const;

        virtual bool equals(const ActiveMQDestination& value) const;

        virtual bool operator==(const ActiveMQDestination& value) const;

        virtual bool operator<(const ActiveMQDestination& value) const;

    public:  // Statics

        static std::string createTemporaryName(const std::string& clientId) {
            return TEMP_PREFIX + clientId + TEMP_POSTFIX;
        }

        static std::string getClientId(const ActiveMQDestination* destination);

        static Pointer<ActiveMQDestination> createDestination(int type, const std::string& name);

    };

}}

#endif /*_ACTIVEMQ_COMMANDS_ACTIVEMQDESTINATION_H_*/