blob: 3a7891293f054d3ee24ef27039f099e7107859b6 [file] [log] [blame]
/*
* 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;
};
/**
* The default target for ordered destinations
*/
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:
/**
* Fetch this destination's physical name
* @return const string containing the name
*/
virtual std::string getPhysicalName() const {
return this->physicalName;
}
/**
* Set this destination's physical name
* @return const string containing the name
*/
virtual void setPhysicalName(const std::string& physicalName);
/**
* @return Returns the advisory.
*/
virtual bool isAdvisory() const {
return advisory;
}
/**
* @param advisory The advisory to set.
*/
virtual void setAdvisory(bool advisory) {
this->advisory = advisory;
}
/**
* @return Returns the exclusive.
*/
virtual bool isExclusive() const {
return exclusive;
}
/**
* @param exclusive The exclusive to set.
*/
virtual void setExclusive( bool exclusive ) {
this->exclusive = exclusive;
}
/**
* @return Returns the ordered.
*/
virtual bool isOrdered() const {
return ordered;
}
/**
* @param ordered The ordered to set.
*/
virtual void setOrdered(bool ordered) {
this->ordered = ordered;
}
/**
* @return Returns the orderedTarget.
*/
virtual std::string getOrderedTarget() const {
return orderedTarget;
}
/**
* @param orderedTarget The orderedTarget to set.
*/
virtual void setOrderedTarget(const std::string& orderedTarget) {
this->orderedTarget = orderedTarget;
}
/**
* Returns the Type of Destination that this object represents
* @return int type qualifier.
*/
virtual cms::Destination::DestinationType getDestinationType() const = 0;
/**
* Returns the type of Destination that this object represents as a string, the
* available string values are, "Queue", "Topic", "TempQueue" and "TempTopic".
*
* @return The string value that represents the type of this destination.
*/
std::string getDestinationTypeAsString() const;
/**
* Returns true if a temporary Destination
* @return true/false
*/
virtual bool isTemporary() const {
return getDestinationType() == cms::Destination::TEMPORARY_TOPIC ||
getDestinationType() == cms::Destination::TEMPORARY_QUEUE;
}
/**
* Returns true if a Topic Destination
* @return true/false
*/
virtual bool isTopic() const {
return getDestinationType() == cms::Destination::TOPIC ||
getDestinationType() == cms::Destination::TEMPORARY_TOPIC;
}
/**
* Returns true if a Queue Destination
* @return true/false
*/
virtual bool isQueue() const {
return !isTopic();
}
/**
* Returns true if this destination represents a collection of
* destinations; allowing a set of destinations to be published to or
* subscribed from in one CMS operation.
*
* @return true if this destination represents a collection of child
* destinations.
*/
virtual bool isComposite() const {
return physicalName.find_first_of(COMPOSITE_SEPARATOR) != std::string::npos;
}
/**
* Returns an ArrayList containing all the ActiveMQDestinations that comprise this
* Composite destination, if this destination is composite, otherwise it returns an
* empty list.
*/
decaf::util::ArrayList< Pointer<ActiveMQDestination> > getCompositeDestinations() const;
/**
* @return true if the destination matches multiple possible destinations
*/
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;
}
/**
* @return a reference (const) to the options properties for this Destination.
*/
const activemq::util::ActiveMQProperties& getOptions() const {
return options;
}
/**
* @return the cms::Destination interface pointer that the
* objects that derive from this class implement.
*/
virtual const cms::Destination* getCMSDestination() const {
return NULL;
}
/**
* Create a new Destination that's of the same type as this one but with
* the given destination name.
*
* @param name
* The name
*
* @return Pointer to a new ActiveMQDestination.
*/
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
/**
* Create a temporary name from the clientId
*
* @param clientId
* @return
*/
static std::string createTemporaryName(const std::string& clientId) {
return TEMP_PREFIX + clientId + TEMP_POSTFIX;
}
/**
* From a temporary destination find the clientId of the Connection that created it
*
* @param destination
* @return the clientId or null if not a temporary destination
*/
static std::string getClientId(const ActiveMQDestination* destination);
/**
* Creates a Destination given the String Name to use and a Type.
*
* @param type - The Type of Destination to Create
* @param name - The Name to use in the creation of the Destination
*
* @return Pointer to a new ActiveMQDestination instance.
*/
static Pointer<ActiveMQDestination> createDestination(int type, const std::string& name);
};
}}
#endif /*_ACTIVEMQ_COMMANDS_ACTIVEMQDESTINATION_H_*/