public TToCollection Map(TFromCollection from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var mapper = resolver.GetMapperWithVerify <TFromElement, TToElement>();
var count = from.FastCount();
var builder = Create(count);
using (var e = GetSourceEnumerator(from))
{
var index = 0;
while (e.MoveNext())
{
var value = mapper.Map(e.Current, resolver);
Add(ref builder, index, value);
index++;
}
}
return(Complete(ref builder));
}
public TToDictionary Map(TFromDictionary from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var keyMapper = resolver.GetMapperWithVerify <TFromKey, TToKey>();
var valueMapper = resolver.GetMapperWithVerify <TFromValue, TToValue>();
var builder = Create(from);
using (var e = GetSourceEnumerator(from))
{
var index = 0;
while (e.MoveNext())
{
var key = keyMapper.Map(e.Current.Key, resolver);
var value = valueMapper.Map(e.Current.Value, resolver);
Add(ref builder, index, key, value);
index++;
}
}
return(Complete(ref builder));
}
public KeyValuePair <UKey, UValue> Map(KeyValuePair <TKey, TValue> from, IObjectMapperResolver resolver)
{
var keyMapper = resolver.GetMapperWithVerify <TKey, UKey>();
var valueMapper = resolver.GetMapperWithVerify <TValue, UValue>();
return(new KeyValuePair <UKey, UValue>(keyMapper.Map(from.Key, resolver), valueMapper.Map(from.Value, resolver)));
}
public ValueTask <U> Map(ValueTask <T> from, IObjectMapperResolver resolver)
{
var mapper = resolver.GetMapperWithVerify <T, U>();
var to = mapper.Map(from.Result, resolver); // task wait...!
return(new ValueTask <U>(to));
}
public TTo[,,,] Map(TFrom[,,,] from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var mapper = resolver.GetMapperWithVerify <TFrom, TTo>();
var iLen = from.GetLength(0);
var jLen = from.GetLength(1);
var kLen = from.GetLength(2);
var lLen = from.GetLength(3);
var to = new TTo[iLen, jLen, kLen, lLen];
for (int i = 0; i < iLen; i++)
{
for (int j = 0; j < jLen; j++)
{
for (int k = 0; k < kLen; k++)
{
for (int l = 0; l < lLen; l++)
{
to[i, j, k, l] = mapper.Map(from[i, j, k, l], resolver);
}
}
}
}
return(to);
}
public MapperNotRegisteredException(Type fromType, Type toType, IObjectMapperResolver resolver)
: base($"{fromType.FullName} -> {toType.FullName} mapper is not registered in this resolver. Resolver: {resolver.GetType().FullName}")
{
this.FromType = fromType;
this.ToType = toType;
this.Resolver = resolver;
}
public string Map(T from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
return(from.ToString());
}
public List <T> Map(TFromCollection from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
return(new List <T>(from));
}
public TTo Map(TFrom?from, IObjectMapperResolver resolver)
{
if (from == null)
{
throw new ArgumentNullException("`from` is null but `to` does not allow null.");
}
return(resolver.GetMapper <TFrom, TTo>().Map(from.Value, resolver));
}
public TTo Map(TFrom?from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
return(resolver.GetMapper <TFrom, TTo>().Map(from.Value, resolver));
}
public Tuple <U1> Map(Tuple <T1> from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
return(new Tuple <U1>(
resolver.GetMapperWithVerify <T1, U1>().Map(from.Item1, resolver)));
}
public string Map(T from, IObjectMapperResolver resolver)
{
if (valueNameMapping.TryGetValue(from, out var v))
{
return(v);
}
else
{
return(from.ToString()); // ToString is slightly slow.
}
}
public IList Map(TFromCollection from, IObjectMapperResolver resolver)
{
var mapper = resolver.GetMapperWithVerify <object, object>();
var list = new List <object>();
foreach (var item in from)
{
list.Add(mapper.Map(item, resolver));
}
return(list);
}
public Lazy <U> Map(Lazy <T> from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var mapper = resolver.GetMapperWithVerify <T, U>();
var to = mapper.Map(from.Value, resolver);
return(new Lazy <U>(to.AsFunc()));
}
public T[] Map(T[] from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var newArray = new T[from.Length];
Array.Copy(from, newArray, from.Length);
return(newArray);
}
public ExpandoObject Map(ExpandoObject from, IObjectMapperResolver resolver)
{
var objectMapper = resolver.GetMapperWithVerify <object, object>();
var to = (IDictionary <string, object>) new ExpandoObject();
foreach (var item in from)
{
to.Add(item.Key, objectMapper.Map(item.Value, resolver));
}
return((ExpandoObject)to);
}
public T[] Map(T[] from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var newArray = new T[from.Length];
Buffer.BlockCopy(from, 0, newArray, 0, elementMemorySize * from.Length);
return(newArray);
}
public Task <U> Map(Task <T> from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var mapper = resolver.GetMapperWithVerify <T, U>();
var to = mapper.Map(from.Result, resolver); // task wait...!
return(Task.FromResult(to));
}
public TTo Map(TFrom from, IObjectMapperResolver resolver)
{
if (fromAction != null)
{
fromAction(from);
}
var result = map(converts, from, resolver);
if (toAction != null)
{
toAction(result);
}
return(result);
}
public List <TTo> Map(List <TFrom> from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var mapper = resolver.GetMapperWithVerify <TFrom, TTo>();
var list = new List <TTo>(from.Count);
foreach (var item in from)
{
list.Add(mapper.Map(item, resolver));
}
return(list);
}
public TTo[] Map(TFrom[] obj, IObjectMapperResolver resolver)
{
if (obj == null)
{
return(null);
}
var mapper = resolver.GetMapperWithVerify <TFrom, TTo>();
var newArray = new TTo[obj.Length];
for (int i = 0; i < obj.Length; i++)
{
newArray[i] = mapper.Map(obj[i], resolver);
}
return(newArray);
}
public Int32[] Map(Int32[] from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var newArray = new Int32[from.Length];
ulong len = (ulong)from.Length * ElementMemorySize;
fixed(void *src = from)
fixed(void *dest = newArray)
{
Buffer.MemoryCopy(src, dest, len, len);
}
return(newArray);
}
public T Map(string from, IObjectMapperResolver resolver)
{
if (nameValueMapping.TryGetValue(from, out var value))
{
return(value);
}
else
{
if (Enum.TryParse <T>(from, out value))
{
return(value);
}
else
{
throw new ArgumentException($"Can't Parse string to {typeof(T)}, value: {from}");
}
}
}
public ArraySegment <TTo> Map(ArraySegment <TFrom> from, IObjectMapperResolver resolver)
{
if (from.Array == null)
{
return(new ArraySegment <TTo>(null, 0, 0));
}
var to = new TTo[from.Count];
var array = from.Array;
var max = from.Offset + from.Count;
var index = 0;
var mapper = resolver.GetMapperWithVerify <TFrom, TTo>();
for (int i = from.Offset; i < max; i++)
{
to[index++] = mapper.Map(array[i], resolver);
}
return(new ArraySegment <TTo>(to));
}
public static IObjectMapper <TFrom, TTo> GetMapperWithVerify <TFrom, TTo>(this IObjectMapperResolver resolver)
{
IObjectMapper <TFrom, TTo> mapper = null;
try
{
mapper = resolver.GetMapper <TFrom, TTo>();
}
catch (TypeInitializationException ex)
{
UnwrapThrow(ex);
}
if (mapper == null)
{
ThrowWhenNull <TFrom, TTo>(resolver);
}
return(mapper);
}
public TTo Map(TFrom from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var actualType = from.GetType();
if (actualType == typeof(object))
{
return((TTo) new object());
}
if (cache.TryGetValue(actualType, out var mapper))
{
return(mapper(from, resolver));
}
else
{
return(GetOrAddMapper(actualType).Invoke(from, resolver));
}
}
public HashSet <TTo> Map(HashSet <TFrom> from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var comparer = useSameComparer
? (IEqualityComparer <TTo>)(object) from.Comparer
: EqualityComparer;
comparer = comparer ?? EqualityComparer <TTo> .Default;
var mapper = resolver.GetMapperWithVerify <TFrom, TTo>();
var to = new HashSet <TTo>(comparer);
foreach (var item in from)
{
to.Add(mapper.Map(item, resolver));
}
return(to);
}
public TTo[,] Map(TFrom[,] from, IObjectMapperResolver resolver)
{
if (from == null)
{
return(null);
}
var mapper = resolver.GetMapperWithVerify <TFrom, TTo>();
var iLen = from.GetLength(0);
var jLen = from.GetLength(1);
var to = new TTo[iLen, jLen];
for (int i = 0; i < iLen; i++)
{
for (int j = 0; j < jLen; j++)
{
to[i, j] = mapper.Map(from[i, j], resolver);
}
}
return(to);
}
static void ThrowWhenNull <TFrom, TTo>(IObjectMapperResolver resolver)
{
throw new MapperNotRegisteredException(typeof(TFrom), typeof(TTo), resolver);
}
public BitArray Map(BitArray from, IObjectMapperResolver resolver)
{
return(new BitArray(from));
}
