source: branches/PersistenceSpeedUp/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/Storable/Descriptors/PropertyDescriptor.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;

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

  /// <summary>
  /// Describes a property of a type.
  /// </summary>
  [StorableClass]
  public sealed class PropertyDescriptor : ITypeComponent {

    #region Fields & Properties
    /// <summary>
    /// The type descriptor of the type who declared this property. This
    /// can be different to the type where this property was obtained from
    /// if it has been inherited.
    /// </summary>
    [Storable]
    public TypeDescriptor DeclaringType { get; set; }

    /// <summary>
    /// The real name (i.e. in the object graph) of the property.
    /// </summary>
    [Storable]
    public string RealName { get; set; }

    /// <summary>
    /// The name used for seralization (i.e. possibly prefixed with
    /// type information to avoid confusion with equally named
    /// shadowed properties) if different to the real name.
    /// </summary>
    [Storable]
    public string StoredName { get; set; }

    /// <summary>
    /// The default value (if any) of the property if not found
    /// during deserialziation.
    /// </summary>
    [Storable]
    public object DefaultValue { get; set; }

    /// <summary>
    /// Whether this property has a read accessor.
    /// </summary>
    [Storable]
    public bool CanRead { get; set; }

    /// <summary>
    /// Whether this property has a write accessor.
    /// </summary>
    [Storable]
    public bool CanWrite { get; set; }

    /// <summary>
    /// The actual name used for serialization (either the stored name
    /// if present, otherwise the real name).
    /// </summary>
    public string Name { get { return StoredName ?? RealName; } }

    internal PropertyInfo handle;
    /// <summary>
    /// The PropertyInfo object as obtained by reflection representing
    /// the described type.
    /// </summary>
    public PropertyInfo Handle {
      get {
        if (handle == null)
          handle = DeclaringType.Handle.GetProperty(RealName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
        return handle;
      }
    }
    #endregion

    /// <summary>
    /// The type who initially declared this property. This is usually the
    /// first base type who declared this property even though it has been overridden
    /// serveral times. If it has been newly declared using <code>new</code>
    /// the type who shadowed it with new is returned.
    /// </summary>
    public Type DeclaringBaseType {
      get {
        if (CanRead)
          return Handle.GetGetMethod().GetBaseDefinition().DeclaringType;
        if (CanWrite)
          return Handle.GetSetMethod().GetBaseDefinition().DeclaringType;
        return Handle.DeclaringType;
      }
    }

    [StorableConstructor]
    private PropertyDescriptor(bool deserializing) { }

    /// <summary>
    /// Create a new property descriptor.
    /// </summary>
    /// <param name="declaringType">The declaring type.</param>
    /// <param name="propertyInfo">The reflection information.</param>
    /// <param name="attribute">The storable attribute of this property (if any).</param>
    public PropertyDescriptor(TypeDescriptor declaringType, PropertyInfo propertyInfo, StorableAttribute attribute) {
      DeclaringType = declaringType;
      RealName = propertyInfo.Name;
      if (attribute != null) {
        StoredName = attribute.Name;
        DefaultValue = attribute.DefaultValue;
      }
      CanRead = propertyInfo.CanRead;
      CanWrite = propertyInfo.CanWrite;
      handle = propertyInfo;
    }

    /// <summary>
    /// Create a shallow copy of this property descriptor.
    /// </summary>
    public object Clone() {
      var clone = new PropertyDescriptor(false);
      clone.DeclaringType = DeclaringType;
      clone.RealName = RealName;
      clone.StoredName = StoredName;
      clone.DefaultValue = DefaultValue;
      clone.CanRead = CanRead;
      clone.CanWrite = CanWrite;
      clone.handle = handle;
      return clone;
    }

    /// <summary>
    /// Create a string representation of this property descriptor.
    /// </summary>
    public override string ToString() {
      StringBuilder sb = new StringBuilder();
      sb.Append(base.ToString());
      if (CanRead && !CanWrite)
        sb.Append(" {RO}");
      else if (CanWrite && !CanRead)
        sb.Append(" {WO}");
      else if (CanRead && CanWrite)
        sb.Append(" {R/W}");
      else
        sb.Append(" {!!! MUTE !!!}");
      return sb.ToString();
    }

    /// <summary>
    /// From the given object obtain the property value that
    /// is described by this property descriptor.
    /// </summary>
    public object GetValue(object o) {
      return Handle.GetValue(o, null);
    }

    /// <summary>
    /// From the given object set the property value that
    /// is described by this property descriptor.
    /// </summary>
    public void SetValue(object o, object value) {
      Handle.SetValue(o, value, null);
    }
  }

}