src/test/csharp/Commands/Destination.cs - activemq-nms-xms - Git at Google

 /*
  * 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.
  */

 using System;
 using System.Collections.Specialized;
 using Apache.NMS.Util;

 namespace Apache.NMS.Commands
 {
     /// <summary>
     /// Summary description for Destination.
     /// </summary>
     public abstract class Destination : IDestination, ICloneable
     {
         /// <summary>
         /// Topic Destination object
         /// </summary>
         public const int TOPIC = 1;
         /// <summary>
         /// Temporary Topic Destination object
         /// </summary>
         public const int TEMPORARY_TOPIC = 2;
         /// <summary>
         /// Queue Destination object
         /// </summary>
         public const int QUEUE = 3;
         /// <summary>
         /// Temporary Queue Destination object
         /// </summary>
         public const int TEMPORARY_QUEUE = 4;

         private const String TEMP_PREFIX = "{TD{";
         private const String TEMP_POSTFIX = "}TD}";

         private String physicalName = "";
         private StringDictionary options = null;

 		private bool disposed = false;

         /// <summary>
         /// The Default Constructor
         /// </summary>
         protected Destination()
         {
         }

         /// <summary>
         /// Construct the Destination with a defined physical name;
         /// </summary>
         /// <param name="name"></param>
         protected Destination(String name)
         {
             setPhysicalName(name);
         }

 		~Destination()
 		{
 			Dispose(false);
 		}

 		public void Dispose()
 		{
 			Dispose(true);
 			GC.SuppressFinalize(this);
 		}

 		private void Dispose(bool disposing)
 		{
 			if(disposed)
 			{
 				return;
 			}

 			if(disposing)
 			{
 				try
 				{
 					OnDispose();
 				}
 				catch(Exception ex)
 				{
 					Tracer.ErrorFormat("Exception disposing Destination {0}: {1}", this.physicalName, ex.Message);
 				}
 			}

 			disposed = true;
 		}

 		/// <summary>
 		/// Child classes can override this method to perform clean-up logic.
 		/// </summary>
 		protected virtual void OnDispose()
 		{
 		}

 		public bool IsTopic
         {
             get
             {
                 int destinationType = GetDestinationType();
                 return TOPIC == destinationType
                     || TEMPORARY_TOPIC == destinationType;
             }
         }

         public bool IsQueue
         {
             get
             {
                 int destinationType = GetDestinationType();
                 return QUEUE == destinationType
                     || TEMPORARY_QUEUE == destinationType;
             }
         }

         public bool IsTemporary
         {
             get
             {
                 int destinationType = GetDestinationType();
                 return TEMPORARY_QUEUE == destinationType
                     || TEMPORARY_TOPIC == destinationType;
             }
         }

         /// <summary>
         /// Dictionary of name/value pairs representing option values specified
         /// in the URI used to create this Destination.  A null value is returned
         /// if no options were specified.
         /// </summary>
         internal StringDictionary Options
         {
             get { return this.options; }
         }

         private void setPhysicalName(string name)
         {
             this.physicalName = name;

             int p = name.IndexOf('?');
             if(p >= 0)
             {
                 String optstring = physicalName.Substring(p + 1);
                 this.physicalName = name.Substring(0, p);
                 options = URISupport.ParseQuery(optstring);
             }
         }

         /// <summary>
         /// </summary>
         /// <param name="destination"></param>
         /// <returns></returns>
         public static Destination Transform(IDestination destination)
         {
             Destination result = null;
             if(destination != null)
             {
                 if(destination is Destination)
                 {
                     result = (Destination) destination;
                 }
                 else
                 {
                     if(destination is ITemporaryQueue)
                     {
                         result = new TempQueue(((IQueue) destination).QueueName);
                     }
                     else if(destination is ITemporaryTopic)
                     {
                         result = new TempTopic(((ITopic) destination).TopicName);
                     }
                     else if(destination is IQueue)
                     {
                         result = new Queue(((IQueue) destination).QueueName);
                     }
                     else if(destination is ITopic)
                     {
                         result = new Topic(((ITopic) destination).TopicName);
                     }
                 }
             }
             return result;
         }

         /// <summary>
         /// Create a temporary name from the clientId
         /// </summary>
         /// <param name="clientId"></param>
         /// <returns></returns>
         public static String CreateTemporaryName(String clientId)
         {
             return TEMP_PREFIX + clientId + TEMP_POSTFIX;
         }

         /// <summary>
         /// From a temporary destination find the clientId of the Connection that created it
         /// </summary>
         /// <param name="destination"></param>
         /// <returns>the clientId or null if not a temporary destination</returns>
         public static String GetClientId(Destination destination)
         {
             String answer = null;
             if(destination != null && destination.IsTemporary)
             {
                 String name = destination.PhysicalName;
                 int start = name.IndexOf(TEMP_PREFIX);
                 if(start >= 0)
                 {
                     start += TEMP_PREFIX.Length;
                     int stop = name.LastIndexOf(TEMP_POSTFIX);
                     if(stop > start && stop < name.Length)
                     {
                         answer = name.Substring(start, stop);
                     }
                 }
             }
             return answer;
         }

         /// <summary>
         /// </summary>
         /// <param name="o">object to compare</param>
         /// <returns>1 if this is less than o else 0 if they are equal or -1 if this is less than o</returns>
         public int CompareTo(Object o)
         {
             if(o is Destination)
             {
                 return CompareTo((Destination) o);
             }
             return -1;
         }

         /// <summary>
         /// Lets sort by name first then lets sort topics greater than queues
         /// </summary>
         /// <param name="that">another destination to compare against</param>
         /// <returns>1 if this is less than o else 0 if they are equal or -1 if this is less than o</returns>
         public int CompareTo(Destination that)
         {
             int answer = 0;
             if(physicalName != that.physicalName)
             {
                 if(physicalName == null)
                 {
                     return -1;
                 }
                 else if(that.physicalName == null)
                 {
                     return 1;
                 }
                 answer = physicalName.CompareTo(that.physicalName);
             }

             if(answer == 0)
             {
                 if(IsTopic)
                 {
                     if(that.IsQueue)
                     {
                         return 1;
                     }
                 }
                 else
                 {
                     if(that.IsTopic)
                     {
                         return -1;
                     }
                 }
             }
             return answer;
         }

         /// <summary>
         /// </summary>
         /// <returns>Returns the Destination type</returns>
         public abstract int GetDestinationType();

         public String PhysicalName
         {
             get { return this.physicalName; }
             set
             {
                 this.physicalName = value;
             }
         }

         /// <summary>
         /// </summary>
         /// <returns>string representation of this instance</returns>
         public override String ToString()
         {
             switch(DestinationType)
             {
             case DestinationType.Topic:
             return "topic://" + PhysicalName;

             case DestinationType.TemporaryTopic:
             return "temp-topic://" + PhysicalName;

             case DestinationType.TemporaryQueue:
             return "temp-queue://" + PhysicalName;

             default:
             return "queue://" + PhysicalName;
             }
         }

         /// <summary>
         /// </summary>
         /// <returns>hashCode for this instance</returns>
         public override int GetHashCode()
         {
             int answer = 37;

             if(this.physicalName != null)
             {
                 answer = physicalName.GetHashCode();
             }
             if(IsTopic)
             {
                 answer ^= 0xfabfab;
             }
             return answer;
         }

         /// <summary>
         /// if the object passed in is equivalent, return true
         /// </summary>
         /// <param name="obj">the object to compare</param>
         /// <returns>true if this instance and obj are equivalent</returns>
         public override bool Equals(Object obj)
         {
             bool result = this == obj;
             if(!result && obj != null && obj is Destination)
             {
                 Destination other = (Destination) obj;
                 result = this.GetDestinationType() == other.GetDestinationType()
                     && this.physicalName.Equals(other.physicalName);
             }
             return result;
         }

         /// <summary>
         /// Factory method to create a child destination if this destination is a composite
         /// </summary>
         /// <param name="name"></param>
         /// <returns>the created Destination</returns>
         public abstract Destination CreateDestination(String name);

         public abstract DestinationType DestinationType
         {
             get;
         }

         public virtual Object Clone()
         {
             // Since we are the lowest level base class, do a
             // shallow copy which will include the derived classes.
             // From here we would do deep cloning of other objects
             // if we had any.
             return this.MemberwiseClone();
         }
     }
 }
	/*
	* 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.
	*/

	using System;
	using System.Collections.Specialized;
	using Apache.NMS.Util;

	namespace Apache.NMS.Commands
	{
	/// <summary>
	/// Summary description for Destination.
	/// </summary>
	public abstract class Destination : IDestination, ICloneable
	{
	/// <summary>
	/// Topic Destination object
	/// </summary>
	public const int TOPIC = 1;
	/// <summary>
	/// Temporary Topic Destination object
	/// </summary>
	public const int TEMPORARY_TOPIC = 2;
	/// <summary>
	/// Queue Destination object
	/// </summary>
	public const int QUEUE = 3;
	/// <summary>
	/// Temporary Queue Destination object
	/// </summary>
	public const int TEMPORARY_QUEUE = 4;

	private const String TEMP_PREFIX = "{TD{";
	private const String TEMP_POSTFIX = "}TD}";

	private String physicalName = "";
	private StringDictionary options = null;

	private bool disposed = false;

	/// <summary>
	/// The Default Constructor
	/// </summary>
	protected Destination()
	{
	}

	/// <summary>
	/// Construct the Destination with a defined physical name;
	/// </summary>
	/// <param name="name"></param>
	protected Destination(String name)
	{
	setPhysicalName(name);
	}

	~Destination()
	{
	Dispose(false);
	}

	public void Dispose()
	{
	Dispose(true);
	GC.SuppressFinalize(this);
	}

	private void Dispose(bool disposing)
	{
	if(disposed)
	{
	return;
	}

	if(disposing)
	{
	try
	{
	OnDispose();
	}
	catch(Exception ex)
	{
	Tracer.ErrorFormat("Exception disposing Destination {0}: {1}", this.physicalName, ex.Message);
	}
	}

	disposed = true;
	}

	/// <summary>
	/// Child classes can override this method to perform clean-up logic.
	/// </summary>
	protected virtual void OnDispose()
	{
	}

	public bool IsTopic
	{
	get
	{
	int destinationType = GetDestinationType();
	return TOPIC == destinationType
	\|\| TEMPORARY_TOPIC == destinationType;
	}
	}

	public bool IsQueue
	{
	get
	{
	int destinationType = GetDestinationType();
	return QUEUE == destinationType
	\|\| TEMPORARY_QUEUE == destinationType;
	}
	}

	public bool IsTemporary
	{
	get
	{
	int destinationType = GetDestinationType();
	return TEMPORARY_QUEUE == destinationType
	\|\| TEMPORARY_TOPIC == destinationType;
	}
	}

	/// <summary>
	/// Dictionary of name/value pairs representing option values specified
	/// in the URI used to create this Destination. A null value is returned
	/// if no options were specified.
	/// </summary>
	internal StringDictionary Options
	{
	get { return this.options; }
	}

	private void setPhysicalName(string name)
	{
	this.physicalName = name;

	int p = name.IndexOf('?');
	if(p >= 0)
	{
	String optstring = physicalName.Substring(p + 1);
	this.physicalName = name.Substring(0, p);
	options = URISupport.ParseQuery(optstring);
	}
	}

	/// <summary>
	/// </summary>
	/// <param name="destination"></param>
	/// <returns></returns>
	public static Destination Transform(IDestination destination)
	{
	Destination result = null;
	if(destination != null)
	{
	if(destination is Destination)
	{
	result = (Destination) destination;
	}
	else
	{
	if(destination is ITemporaryQueue)
	{
	result = new TempQueue(((IQueue) destination).QueueName);
	}
	else if(destination is ITemporaryTopic)
	{
	result = new TempTopic(((ITopic) destination).TopicName);
	}
	else if(destination is IQueue)
	{
	result = new Queue(((IQueue) destination).QueueName);
	}
	else if(destination is ITopic)
	{
	result = new Topic(((ITopic) destination).TopicName);
	}
	}
	}
	return result;
	}

	/// <summary>
	/// Create a temporary name from the clientId
	/// </summary>
	/// <param name="clientId"></param>
	/// <returns></returns>
	public static String CreateTemporaryName(String clientId)
	{
	return TEMP_PREFIX + clientId + TEMP_POSTFIX;
	}

	/// <summary>
	/// From a temporary destination find the clientId of the Connection that created it
	/// </summary>
	/// <param name="destination"></param>
	/// <returns>the clientId or null if not a temporary destination</returns>
	public static String GetClientId(Destination destination)
	{
	String answer = null;
	if(destination != null && destination.IsTemporary)
	{
	String name = destination.PhysicalName;
	int start = name.IndexOf(TEMP_PREFIX);
	if(start >= 0)
	{
	start += TEMP_PREFIX.Length;
	int stop = name.LastIndexOf(TEMP_POSTFIX);
	if(stop > start && stop < name.Length)
	{
	answer = name.Substring(start, stop);
	}
	}
	}
	return answer;
	}

	/// <summary>
	/// </summary>
	/// <param name="o">object to compare</param>
	/// <returns>1 if this is less than o else 0 if they are equal or -1 if this is less than o</returns>
	public int CompareTo(Object o)
	{
	if(o is Destination)
	{
	return CompareTo((Destination) o);
	}
	return -1;
	}

	/// <summary>
	/// Lets sort by name first then lets sort topics greater than queues
	/// </summary>
	/// <param name="that">another destination to compare against</param>
	/// <returns>1 if this is less than o else 0 if they are equal or -1 if this is less than o</returns>
	public int CompareTo(Destination that)
	{
	int answer = 0;
	if(physicalName != that.physicalName)
	{
	if(physicalName == null)
	{
	return -1;
	}
	else if(that.physicalName == null)
	{
	return 1;
	}
	answer = physicalName.CompareTo(that.physicalName);
	}

	if(answer == 0)
	{
	if(IsTopic)
	{
	if(that.IsQueue)
	{
	return 1;
	}
	}
	else
	{
	if(that.IsTopic)
	{
	return -1;
	}
	}
	}
	return answer;
	}

	/// <summary>
	/// </summary>
	/// <returns>Returns the Destination type</returns>
	public abstract int GetDestinationType();

	public String PhysicalName
	{
	get { return this.physicalName; }
	set
	{
	this.physicalName = value;
	}
	}

	/// <summary>
	/// </summary>
	/// <returns>string representation of this instance</returns>
	public override String ToString()
	{
	switch(DestinationType)
	{
	case DestinationType.Topic:
	return "topic://" + PhysicalName;

	case DestinationType.TemporaryTopic:
	return "temp-topic://" + PhysicalName;

	case DestinationType.TemporaryQueue:
	return "temp-queue://" + PhysicalName;

	default:
	return "queue://" + PhysicalName;
	}
	}

	/// <summary>
	/// </summary>
	/// <returns>hashCode for this instance</returns>
	public override int GetHashCode()
	{
	int answer = 37;

	if(this.physicalName != null)
	{
	answer = physicalName.GetHashCode();
	}
	if(IsTopic)
	{
	answer ^= 0xfabfab;
	}
	return answer;
	}

	/// <summary>
	/// if the object passed in is equivalent, return true
	/// </summary>
	/// <param name="obj">the object to compare</param>
	/// <returns>true if this instance and obj are equivalent</returns>
	public override bool Equals(Object obj)
	{
	bool result = this == obj;
	if(!result && obj != null && obj is Destination)
	{
	Destination other = (Destination) obj;
	result = this.GetDestinationType() == other.GetDestinationType()
	&& this.physicalName.Equals(other.physicalName);
	}
	return result;
	}

	/// <summary>
	/// Factory method to create a child destination if this destination is a composite
	/// </summary>
	/// <param name="name"></param>
	/// <returns>the created Destination</returns>
	public abstract Destination CreateDestination(String name);

	public abstract DestinationType DestinationType
	{
	get;
	}

	public virtual Object Clone()
	{
	// Since we are the lowest level base class, do a
	// shallow copy which will include the derived classes.
	// From here we would do deep cloning of other objects
	// if we had any.
	return this.MemberwiseClone();
	}
	}
	}