source: branches/New Persistence Exploration/Persistence/Persistence/Default/Decomposers/EnumerableDecomposer.cs @ 1434

using System;
using System.Collections;
using System.Reflection;
using HeuristicLab.Persistence.Core;
using HeuristicLab.Persistence.Interfaces;
using System.Collections.Generic;

namespace HeuristicLab.Persistence.Default.Decomposers {

  public abstract class EnumerableDecomposer : IDecomposer {

    public abstract void PerformAdd(object instance, MethodInfo addMethod, Tag tag);

    public bool CanDecompose(Type type) {
      return
        type.GetInterface(typeof(IEnumerable).FullName) != null &&
        type.GetMethod("Add") != null &&
        type.GetMethod("Add").GetParameters().Length == 1 &&
        type.GetConstructor(
          BindingFlags.Public |
          BindingFlags.NonPublic |
          BindingFlags.Instance,
          null, Type.EmptyTypes, null) != null;
    }

    public IEnumerable<Tag> DeCompose(object obj) {
      foreach (object o in (IEnumerable)obj) {
        yield return new Tag(null, o);
      }
    }

    public object CreateInstance(Type type) {
      return Activator.CreateInstance(type, true);
    }

    public object Populate(object instance, IEnumerable<Tag> tags, Type type) {
      MethodInfo addMethod = type.GetMethod("Add");
      foreach (var tag in tags) {
        PerformAdd(instance, addMethod, tag);        
      }
      return instance;
    }

  }

  /// <summary>
  /// Does never re-order elements but cannot reconstruct enumerables that directly
  /// or indirectly contain references to not-yet-contructed parent objects (e.g. arrays).
  /// </summary>
  public class SafeEnumerableDecomposer : EnumerableDecomposer {
    public override void PerformAdd(object instance, MethodInfo addMethod, Tag tag) {
      addMethod.Invoke(instance, new[] { tag.Value });
    }
  }
  /// <summary>
  /// May re-order elements if the enumerable contains references to
  /// not-yet-constructed parent objects (e.g. arrays).
  /// </summary>
  public class RobustEnumerableDecomposer : EnumerableDecomposer {
     public override void PerformAdd(object instance, MethodInfo addMethod, Tag tag) {
      tag.SafeSet((value) => addMethod.Invoke(instance, new[] { value }));
    }    
  }

}