source: branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/Descriptors/HookDescriptor.cs @ 6221

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion
using System;
using System.Reflection;
using System.Text;
using HeuristicLab.Persistence.Auxiliary;

namespace HeuristicLab.Persistence.Default.CompositeSerializers.Storable.Descriptors {

  /// <summary>
  /// Describes a storable hook method of a storable type.
  /// </summary>
  [StorableClass]
  public sealed class HookDescriptor {

    #region Fields & Properties
    /// <summary>
    /// The type that declared this hook.
    /// </summary>
    [Storable]
    public TypeDescriptor DeclaringType { get; set; }

    /// <summary>
    /// The name of the method that represents this hook.
    /// </summary>
    [Storable]
    public string MethodName { get; set; }

    /// <summary>
    /// The type of the hook.
    /// </summary>
    [Storable]
    public HookType HookType { get; set; }

    internal MethodInfo handle;
    /// <summary>
    /// The MethodInfo of the hook as obtained by reflection.
    /// </summary>
    public MethodInfo Handle {
      get {
        if (handle == null)
          handle = DeclaringType.Handle.GetMethod(MethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
        return handle;
      }
    }
    #endregion

    [StorableConstructor]
    private HookDescriptor(bool deserializing) { }

    /// <summary>
    /// Creates a new hook description.
    /// </summary>
    /// <param name="declaringType">The declaring type.</param>
    /// <param name="methodInfo">The MethodInfo as obtained by reflection.</param>
    /// <param name="hookType">The hook type.</param>
    public HookDescriptor(TypeDescriptor declaringType, MethodInfo methodInfo, HookType hookType) {
      DeclaringType = declaringType;
      MethodName = methodInfo.Name;
      HookType = hookType;
      handle = methodInfo;
    }

    /// <summary>
    /// Invokes the hook method on the given object.
    /// </summary>
    public void Invoke(object o) {
      Handle.Invoke(o, Type.EmptyTypes);
    }

    /// <summary>
    /// Creates a string representation of this hook description.
    /// </summary>
    public override string ToString() {
      return new StringBuilder()
        .Append(HookType.ToString())
        .Append(' ')
        .Append(TypeNameParser.Parse(DeclaringType.AssemblyQualifiedName).ClassName)
        .Append('.')
        .Append(MethodName)
        .Append("()")
        .ToString();
    }
  }
}