AbstractPointcutAdvisor.cs :  » Inversion-of-Control-Dependency-Injection » Spring.net » Spring » Aop » Support » C# / CSharp Open Source

#region License

/*
 * Copyright 2002-2007 the original author or authors.
 *
 * Licensed 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.
 */

#endregion

using System;
using AopAlliance.Aop;
using Spring.Core;

namespace Spring.Aop.Support{
    /// <summary>
    /// Abstract base class for <see cref="IPointcutAdvisor"/> implementations.  
    /// </summary>
    /// <remarks>
    /// Can be subclassed for returning a specific pointcut/advice or a freely configurable pointcut/advice.
    /// </remarks>
    /// <author>Rod Johnson</author>
    /// <author>Juergen Hoeller</author>
    /// <author>Mark Pollack (.NET)</author>
    [Serializable]
    public abstract class AbstractPointcutAdvisor : IPointcutAdvisor, IOrdered
    {
        #region Fields

        private int _order = Int32.MaxValue;

        #endregion

        #region IOrdered Members

        /// <summary>
        /// Returns this <see cref="Spring.Aop.IAdvisor"/>s order in the
        /// interception chain.
        /// </summary>
        /// <returns>
        /// This <see cref="Spring.Aop.IAdvisor"/>s order in the
        /// interception chain.
        /// </returns>
        public virtual int Order
        {
            get { return this._order; }
            set { this._order = value; }
        }

        #endregion

        #region IAdvisor Members

        /// <summary>
        /// Return the advice part of this aspect.
        /// </summary>
        /// <remarks>
        /// <p>
        /// An advice may be an interceptor, a throws advice, before advice,
        /// introduction etc.
        /// </p>
        /// </remarks>
        /// <returns>
        /// The advice that should apply if the pointcut matches.
        /// </returns>
        public abstract IAdvice Advice { get; set; }

        /// <summary>
        /// Is this advice associated with a particular instance?
        /// </summary>
        /// <remarks>
        /// <p>
        /// Not supported for dynamic advisors.
        /// </p>
        /// </remarks>
        /// <value>
        /// <see langword="true"/> if this advice is associated with a
        /// particular instance.
        /// </value>
        /// <exception cref="System.NotSupportedException">Always.</exception>
        /// <see cref="Spring.Aop.IAdvisor.IsPerInstance"/>
        public virtual bool IsPerInstance
        {
            get
            {
                throw new NotSupportedException(
                    "The 'IsPerInstance' property of the IAdvisor interface " +
                        "is not yet supported in Spring.NET.");
            }
        }

        #endregion

        #region IPointcutAdvisor Members

        /// <summary>
        /// The <see cref="Spring.Aop.IPointcut"/> that drives this advisor.
        /// </summary>
        public abstract IPointcut Pointcut { get; set; }

        #endregion

        #region Methods
        /// <summary>
        /// Determines whether the specified <see cref="System.Object"/>
        /// is equal to the current <see cref="System.Object"/>.  
        /// </summary>
        /// <param name="o">The advisor to compare with.</param>
        /// <returns>
        /// <see langword="true"/> if this instance is equal to the
        /// specified <see cref="System.Object"/>.
        /// </returns>
        public override bool Equals(object o)
        {
            if (!(o is AbstractPointcutAdvisor))
            {
                return false;
            }

            if (ReferenceEquals(this, o))
            {
                return true;
            }

            AbstractPointcutAdvisor otherAdvisor = (AbstractPointcutAdvisor)o;
            if (this.Order != otherAdvisor.Order)
            {
                return false;
            }
            if (otherAdvisor.Advice == null && otherAdvisor.Pointcut == null)
            {
                return (this.Advice == null && this.Pointcut == null);
            }
            else if (otherAdvisor.Advice == null)
            {
                return (Advice == null && otherAdvisor.Pointcut.Equals(this.Pointcut));
            }
            else if (otherAdvisor.Pointcut == null)
            {
                return (this.Pointcut == null && otherAdvisor.Advice.Equals(this.Advice));
            }
            else
            {
                return otherAdvisor.Advice.Equals(this.Advice) && otherAdvisor.Pointcut.Equals(this.Pointcut);
            }
        }

        /// <summary>
        /// Serves as a hash function for a particular type, suitable for use
        /// in hashing algorithms and data structures like a hash table.
        /// </summary>
        /// <returns>
        /// A hash code for the current <see cref="System.Object"/>.
        /// </returns>
        public override int GetHashCode()
        {
            return 0 // (SPRNET-847) base.GetHashCode()
                + 13 * (Pointcut == null ? 0 : Pointcut.GetHashCode())
                + 27 * (Advice == null ? 0 : Advice.GetHashCode())
                + 31 * Order.GetHashCode();
        }

        #endregion
    }
}