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_
 
#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;
        int hashCode;
 
    public:
 
        const static unsigned char ID_ACTIVEMQDESTINATION = 0;
 
        static const std::string TEMP_DESTINATION_NAME_PREFIX;
 
        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;
 
        int getHashCode() const {
            return this->hashCode;
        }
 
    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;
        }
 
        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_*/