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)); }