src/main/activemq/commands/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 <vector>
#include <string>
#include <map>

namespace activemq{
namespace commands{

    using decaf::lang::Pointer;

    class AMQCPP_API ActiveMQDestination : public BaseDataStructure {
    protected:

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

        static const std::string ADVISORY_PREFIX;

        static const std::string CONSUMER_ADVISORY_PREFIX;

        static const std::string PRODUCER_ADVISORY_PREFIX;

        static const std::string CONNECTION_ADVISORY_PREFIX;

        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;
        std::string orderedTarget;

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

    public:

        const static unsigned char ID_ACTIVEMQDESTINATION = 0;

    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;

        virtual const std::string& getPhysicalName() const {
            return this->physicalName;
        }
        virtual std::string& getPhysicalName() {
            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 isConsumerAdvisory() const {
            return isAdvisory() &&
                   physicalName.find(CONSUMER_ADVISORY_PREFIX) == 0;
        }

        virtual bool isProducerAdvisory() const {
            return isAdvisory() &&
                   physicalName.find(PRODUCER_ADVISORY_PREFIX) == 0;
        }

        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;
        }

    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 );

    public:

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

        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 ) > 0;
        }

        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;
        }

    };

}}

#endif /*_ACTIVEMQ_COMMANDS_ACTIVEMQDESTINATION_H_*/