#region License Information
/* HeuristicLab
* Copyright (C) 2002-2016 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 .
*/
#endregion
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using HeuristicLab.Persistence.Auxiliary;
using HeuristicLab.Persistence.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Persistence.Interfaces;
namespace HeuristicLab.Persistence.Default.CompositeSerializers {
[StorableClass]
internal sealed class NumberEnumerable2StringSerializer : ICompositeSerializer {
[StorableConstructor]
private NumberEnumerable2StringSerializer(bool deserializing) { }
public NumberEnumerable2StringSerializer() { }
public int Priority {
get { return 200; }
}
private static readonly Number2StringSerializer numberConverter =
new Number2StringSerializer();
private static readonly Dictionary interfaceCache = new Dictionary();
private static readonly object locker = new object();
public Type GetGenericEnumerableInterface(Type type) {
lock (locker) {
if (interfaceCache.ContainsKey(type))
return interfaceCache[type];
foreach (Type iface in type.GetInterfaces()) {
if (iface.IsGenericType &&
iface.GetGenericTypeDefinition() == typeof(IEnumerable<>) &&
numberConverter.CanSerialize(iface.GetGenericArguments()[0])) {
interfaceCache.Add(type, iface);
return iface;
}
}
interfaceCache.Add(type, null);
}
return null;
}
public bool ImplementsGenericEnumerable(Type type) {
return GetGenericEnumerableInterface(type) != null;
}
public bool HasAddMethod(Type type) {
return
type.GetMethod("Add") != null &&
type.GetMethod("Add").GetParameters().Length == 1 &&
type.GetConstructor(
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance,
null, Type.EmptyTypes, null) != null;
}
public bool CanSerialize(Type type) {
return
ReflectionTools.HasDefaultConstructor(type) &&
ImplementsGenericEnumerable(type) &&
HasAddMethod(type);
}
public string JustifyRejection(Type type) {
if (!ReflectionTools.HasDefaultConstructor(type))
return "no default constructor";
if (!ImplementsGenericEnumerable(type))
return "IEnumerable<> not implemented";
return "no Add method with one parameter";
}
public IEnumerable CreateMetaInfo(object o) {
return new Tag[] { };
}
private static object[] emptyArgs = new object[0];
public IEnumerable Decompose(object obj) {
Type type = obj.GetType();
Type enumerable = GetGenericEnumerableInterface(type);
InterfaceMapping iMap = obj.GetType().GetInterfaceMap(enumerable);
MethodInfo getEnumeratorMethod =
iMap.TargetMethods[
Array.IndexOf(
iMap.InterfaceMethods,
enumerable.GetMethod("GetEnumerator"))];
object genericEnumerator = getEnumeratorMethod.Invoke(obj, emptyArgs);
MethodInfo moveNextMethod = genericEnumerator.GetType().GetMethod("MoveNext");
PropertyInfo currentProperty = genericEnumerator.GetType().GetProperty("Current");
StringBuilder sb = new StringBuilder();
while ((bool)moveNextMethod.Invoke(genericEnumerator, emptyArgs))
sb.Append(
numberConverter.Format(
currentProperty.GetValue(genericEnumerator, null))).Append(';');
yield return new Tag("compact enumerable", sb.ToString());
}
public object CreateInstance(Type type, IEnumerable metaInfo) {
return Activator.CreateInstance(type, true);
}
public void Populate(object instance, IEnumerable tags, Type type) {
Type enumerable = GetGenericEnumerableInterface(type);
Type elementType = enumerable.GetGenericArguments()[0];
MethodInfo addMethod = type.GetMethod("Add");
try {
var tagEnumerator = tags.GetEnumerator();
tagEnumerator.MoveNext();
string[] stringValues = ((string)tagEnumerator.Current.Value)
.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var value in stringValues) {
addMethod.Invoke(instance, new[] { numberConverter.Parse(value, elementType) });
}
}
catch (InvalidOperationException e) {
throw new PersistenceException("Insufficient element data to reconstruct number enumerable", e);
}
catch (InvalidCastException e) {
throw new PersistenceException("Invalid element data during reconstruction of number enumerable", e);
}
}
}
}