source: branches/New Persistence Exploration/Persistence/Persistence/Interfaces/IDecomposer.cs @ 1437

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

namespace HeuristicLab.Persistence.Interfaces {

  public class Tag {
    public List<Thunk> finalFixes;
    public string Name { get; private set; }
    public object Value;      

    public Tag(string name, object value) {
      this.Name = name;
      this.Value = value;
    }
    public Tag(object value) {
      this.Name = null;
      this.Value = value;
    }
    public void SafeSet(Setter setter) {
      if ( Value != null && Value.GetType() == typeof(ParentReference))
        finalFixes.Add(() => setter(Value));
      else
        setter(Value);
    }
  }

  public interface IDecomposer {

    /// <summary>
    /// Determines for every type whether the decomposer is applicable.
    /// </summary>    
    bool CanDecompose(Type type);

    /// <summary>
    /// Decompose an object into KeyValuePairs, the Key can be null,
    /// the order in which elements are generated is guaranteed to be
    /// the same as they are supplied in the Compose method.
    /// </summary>    
    IEnumerable<Tag> DeCompose(object obj);

    /// <summary>
    /// Create an instance of the object if possible. May return null
    /// in which case the Populate method must create the instance.
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    object CreateInstance(Type type);

    /// <summary>
    /// Compose an object from the KeyValuePairs previously generated
    /// in DeCompose. The order in which the values are supplied is
    /// the same as they where generated. Keys might be null.
    /// </summary>    
    object Populate(object instance, IEnumerable<Tag> tags, Type type);
  }  

}