internal override void AntiAlias(IDeepCopier deepCopier) { if (!((Result is Exception) || (Result is UnitType))) { Result = deepCopier.DeepCopy(Result); } }
public ReadOnlyMemory <T> DeepCopy(ReadOnlyMemory <T> input, CopyContext context) { if (input.IsEmpty) { return(input); } var inputSpan = input.Span; var result = new T[inputSpan.Length]; // Note that there is a possibility for unbounded recursion if the underlying object in the input is // able to take part in a cyclic reference. If we could get that object then we could prevent that cycle. // It is also possible that an IMemoryOwner<T> is the backing object, in which case this will not work. if (MemoryMarshal.TryGetArray(input, out var segment)) { context.RecordCopy(segment.Array, result); } for (var i = 0; i < inputSpan.Length; i++) { result[i] = _elementCopier.DeepCopy(inputSpan[i], context); } return(result); }
/// <inheritdoc/> public TField DeepCopy(TField input, CopyContext context) { var surrogate = _converter.ConvertToSurrogate(in input); var copy = _surrogateCopier.DeepCopy(surrogate, context); var result = _converter.ConvertFromSurrogate(in copy); return(result); }
/// <inheritdoc/> public T?DeepCopy(T?input, CopyContext context) { if (!input.HasValue) { return(input); } return(new T?(_copier.DeepCopy(input.Value, context))); }
/// <inheritdoc /> public SortedDictionary <TKey, TValue> DeepCopy(SortedDictionary <TKey, TValue> input, CopyContext context) { if (context.TryGetCopy <SortedDictionary <TKey, TValue> >(input, out var result)) { return(result); } if (input.GetType() != typeof(SortedDictionary <TKey, TValue>)) { return(context.Copy(input)); } result = new SortedDictionary <TKey, TValue>(input.Comparer); context.RecordCopy(input, result); foreach (var pair in input) { result[_keyCopier.DeepCopy(pair.Key, context)] = _valueCopier.DeepCopy(pair.Value, context); } return(result); }
/// <inheritdoc/> public List <T> DeepCopy(List <T> input, CopyContext context) { if (context.TryGetCopy <List <T> >(input, out var result)) { return(result); } if (input.GetType() != typeof(List <T>)) { return(context.DeepCopy(input)); } result = new List <T>(input.Count); context.RecordCopy(input, result); foreach (var item in input) { result.Add(_copier.DeepCopy(item, context)); } return(result); }
/// <inheritdoc /> public SortedSet <T> DeepCopy(SortedSet <T> input, CopyContext context) { if (context.TryGetCopy <SortedSet <T> >(input, out var result)) { return(result); } if (input.GetType() != typeof(SortedSet <T>)) { return(context.Copy(input)); } result = new SortedSet <T>(input.Comparer); context.RecordCopy(input, result); foreach (var element in input) { result.Add(_elementCopier.DeepCopy(element, context)); } return(result); }
public ConcurrentDictionary <TKey, TValue> DeepCopy(ConcurrentDictionary <TKey, TValue> input, CopyContext context) { if (context.TryGetCopy <ConcurrentDictionary <TKey, TValue> >(input, out var result)) { return(result); } if (input.GetType() != typeof(ConcurrentDictionary <TKey, TValue>)) { return(context.Copy(input)); } // Note that this cannot propagate the input's key comparer, since it is not exposed from ConcurrentDictionary. result = new ConcurrentDictionary <TKey, TValue>(); context.RecordCopy(input, result); foreach (var pair in input) { result[_keyCopier.DeepCopy(pair.Key, context)] = _valueCopier.DeepCopy(pair.Value, context); } return(result); }
/// <inheritdoc/> public ConcurrentQueue <T> DeepCopy(ConcurrentQueue <T> input, CopyContext context) { if (context.TryGetCopy <ConcurrentQueue <T> >(input, out var result)) { return(result); } if (input.GetType() != typeof(ConcurrentQueue <T>)) { return(context.Copy(input)); } // Note that this cannot propagate the input's key comparer, since it is not exposed from ConcurrentDictionary. result = new ConcurrentQueue <T>(); context.RecordCopy(input, result); foreach (var item in input) { result.Enqueue(_copier.DeepCopy(item, context)); } return(result); }
/// <inheritdoc/> public TField DeepCopy(TField input, CopyContext context) { if (context.TryGetCopy <TField>(input, out var result)) { return(result); } var surrogate = _converter.ConvertToSurrogate(in input); var copy = _surrogateCopier.DeepCopy(surrogate, context); result = _converter.ConvertFromSurrogate(in copy); context.RecordCopy(input, result); return(result); }
public T[] DeepCopy(T[] input, CopyContext context) { if (context.TryGetCopy <T[]>(input, out var result)) { return(result); } result = new T[input.Length]; context.RecordCopy(input, result); for (var i = 0; i < input.Length; i++) { result[i] = _elementCopier.DeepCopy(input[i], context); } return(result); }
public Tuple <T> DeepCopy(Tuple <T> input, CopyContext context) { if (context.TryGetCopy(input, out Tuple <T> result)) { return(result); } if (input.GetType() != typeof(Tuple <T>)) { return(context.Copy(input)); } result = new Tuple <T>(_copier.DeepCopy(input.Item1, context)); context.RecordCopy(input, result); return(result); }
public ArraySegment <T> DeepCopy(ArraySegment <T> input, CopyContext context) { if (input.Array is null) { return(input); } var inputSpan = input.AsSpan(); var result = new T[inputSpan.Length]; context.RecordCopy(input.Array, result); for (var i = 0; i < inputSpan.Length; i++) { result[i] = _elementCopier.DeepCopy(inputSpan[i], context); } return(new ArraySegment <T>(result)); }
public Memory <T> DeepCopy(Memory <T> input, CopyContext context) { if (input.IsEmpty) { return(input); } // Note that there is a possibility for infinite recursion here if the underlying object in the input is // able to take part in a cyclic reference. If we could get that object then we could prevent that cycle. var inputSpan = input.Span; var result = new T[inputSpan.Length]; for (var i = 0; i < inputSpan.Length; i++) { result[i] = _elementCopier.DeepCopy(inputSpan[i], context); } return(result); }
public ReadOnlyDictionary <TKey, TValue> DeepCopy(ReadOnlyDictionary <TKey, TValue> input, CopyContext context) { if (context.TryGetCopy <ReadOnlyDictionary <TKey, TValue> >(input, out var result)) { return(result); } if (input.GetType() != typeof(ReadOnlyDictionary <TKey, TValue>)) { return(context.Copy(input)); } var temp = new Dictionary <TKey, TValue>(input.Count); foreach (var pair in input) { temp[_keyCopier.DeepCopy(pair.Key, context)] = _valueCopier.DeepCopy(pair.Value, context); } result = new ReadOnlyDictionary <TKey, TValue>(temp); context.RecordCopy(input, result); return(result); }
/// <inheritdoc/> object IDeepCopier <object> .DeepCopy(object original, CopyContext context) { if (context.TryGetCopy <Array>(original, out var result)) { return(result); } var type = original.GetType(); var originalArray = (Array)original; var elementType = type.GetElementType(); if (ShallowCopyableTypes.Contains(elementType)) { return(originalArray.Clone()); } // We assume that all arrays have lower bound 0. In .NET 4.0, it's hard to create an array with a non-zero lower bound. var rank = originalArray.Rank; var lengths = new int[rank]; for (var i = 0; i < rank; i++) { lengths[i] = originalArray.GetLength(i); } result = Array.CreateInstance(elementType, lengths); context.RecordCopy(original, result); if (rank == 1) { for (var i = 0; i < lengths[0]; i++) { result.SetValue(_elementCopier.DeepCopy(originalArray.GetValue(i), context), i); } } else if (rank == 2) { for (var i = 0; i < lengths[0]; i++) { for (var j = 0; j < lengths[1]; j++) { result.SetValue(_elementCopier.DeepCopy(originalArray.GetValue(i, j), context), i, j); } } } else { var index = new int[rank]; var sizes = new int[rank]; sizes[rank - 1] = 1; for (var k = rank - 2; k >= 0; k--) { sizes[k] = sizes[k + 1] * lengths[k + 1]; } for (var i = 0; i < originalArray.Length; i++) { int k = i; for (int n = 0; n < rank; n++) { int offset = k / sizes[n]; k -= offset * sizes[n]; index[n] = offset; } result.SetValue(_elementCopier.DeepCopy(originalArray.GetValue(index), context), index); } } return(result); }