source: branches/PersistenceOverhaul/HeuristicLab.Persistence/4.0/Core/PersistenceMapper.cs @ 13326

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 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.Collections.Generic;
using System.Linq;
using HeuristicLab.Persistence.Data;
using HeuristicLab.PluginInfrastructure;

namespace HeuristicLab.Persistence {
  public sealed class PersistenceMapper {
    private ShortIndex<ITransformer> transformers;
    private Dictionary<Type, TypeInfo> typeInfos;
    private ShortIndex<Type> types;
    private Index<string> strings;
    private Index<PersistenceData> data;
    private Dictionary<object, uint> dataCache;
    private Dictionary<uint, object> objectCache;

    public long Nodes { get; private set; }

    public PersistenceMapper() {
      transformers = new ShortIndex<ITransformer>();
      typeInfos = new Dictionary<Type, TypeInfo>();
      types = new ShortIndex<Type>();
      strings = new Index<string>();
      data = new Index<PersistenceData>();
      dataCache = new Dictionary<object, uint>(new ReferenceEqualityComparer<object>());
      objectCache = new Dictionary<uint, object>();

      Nodes = 0;

      foreach (var transformer in ApplicationManager.Manager.GetInstances<ITransformer>().OrderBy(x => x.Order)) {
        ushort id = transformers.GetIndex(transformer);
        transformer.Initialize(id);
      }
    }

    public TypeInfo GetTypeInfo(Type type) {
      TypeInfo typeInfo;
      typeInfos.TryGetValue(type, out typeInfo);
      if (typeInfo == null) {
        var transformer = transformers.GetValues().Select(x => x.Item2).Where(x => x.CanTransformType(type)).FirstOrDefault();
        typeInfo = new TypeInfo(type, transformer);
        typeInfos.Add(type, typeInfo);
      }
      return typeInfo;
    }
    public IEnumerable<TypeInfo> GetTypeInfos() {
      return typeInfos.Values;
    }
    public IEnumerable<Type> GetTypes() {
      return typeInfos.Values.Select(x => x.Type);
    }

    public ushort GetTypeId(Type type) {
      return types.GetIndex(type);
    }
    public Type GetType(ushort typeId) {
      return types.GetValue(typeId);
    }

    public uint GetStringId(string str) {
      return strings.GetIndex(str);
    }
    public string GetString(uint stringId) {
      return strings.GetValue(stringId);
    }

    public void Cache(object o, PersistenceData data) {
      dataCache.Add(o, this.data.GetIndex(data));
    }
    public void Cache(PersistenceData data, object o) {
      objectCache.Add(this.data.GetIndex(data), o);
    }

    public uint GetDataId(object o) {
      if (o == null) return 0;
      if (dataCache.ContainsKey(o)) return dataCache[o];

      var type = o.GetType();
      var typeInfo = GetTypeInfo(type);
      if (typeInfo.Transformer == null) throw new ArgumentException("Cannot serialize object of type " + o.GetType());
      Nodes++;
      typeInfo.Used++;
      return data.GetIndex(typeInfo.Transformer.ToData(o, this));
    }
    public object GetObject(uint dataId) {
      if (dataId == 0) return null;
      if (objectCache.ContainsKey(dataId)) return objectCache[dataId];
      var data = this.data.GetValue(dataId);
      var transformer = transformers.GetValue(data.TransformerId);
      return transformer.ToObject(data, this);
    }

    public object CreateInstance(Type type) {
      return GetTypeInfo(type).GetConstructor()();
    }

    public static PersistenceMapper mapper;
    public static PersistenceBundle ToBundle(object o) {
      mapper = new PersistenceMapper();
      var bundle = new PersistenceBundle();
      bundle.RootId = mapper.GetDataId(o);
      bundle.TransformerGuids = mapper.transformers.GetValues().Select(x => new Tuple<ushort, Guid>(x.Item1, x.Item2.Guid)).ToArray();
      bundle.TypeNames = mapper.types.GetValues().Select(x => new Tuple<ushort, string>(x.Item1, x.Item2.AssemblyQualifiedName)).ToArray();
      bundle.Strings = mapper.strings.GetValues().ToArray();
      bundle.Data = mapper.data.GetValues().ToArray();
      return bundle;
    }
    public static object ToObject(PersistenceBundle bundle) {
      mapper = new PersistenceMapper();
      mapper.types = new ShortIndex<Type>(bundle.TypeNames.Select(x => new Tuple<ushort, Type>(x.Item1, Type.GetType(x.Item2, true))));
      mapper.strings = new Index<string>(bundle.Strings);
      mapper.data = new Index<PersistenceData>(bundle.Data);
      mapper.transformers = new ShortIndex<ITransformer>(
        bundle.TransformerGuids.Select(x => new Tuple<ushort, ITransformer>(
          x.Item1,
          mapper.transformers.GetValues().Select(y => y.Item2).Where(y => y.Guid == x.Item2).First())
        )
      );
      foreach (var type in mapper.types.GetValues().Select(x => x.Item2))
        mapper.typeInfos.Add(type, new TypeInfo(type));

      return mapper.GetObject(bundle.RootId);
    }
  }
}