Пример #1
0
        private static void Copy <T>(
            ISet <T> source,
            ISet <T> target,
            MemberSettings settings,
            ReferencePairCollection referencePairs)
        {
            if (Is.IsFixedSize(source, target) && source.Count != target.Count)
            {
                throw State.Copy.Throw.CannotCopyFixesSizeCollections(source, target, settings);
            }

            if (settings.IsImmutable(typeof(T)))
            {
                using (var borrow = HashSetPool <T> .Borrow(EqualityComparer <T> .Default))
                {
                    borrow.Value.UnionWith(source);
                    target.IntersectWith(borrow.Value);
                    target.UnionWith(borrow.Value);
                    return;
                }
            }

            switch (settings.ReferenceHandling)
            {
            case ReferenceHandling.Throw:
                break;

            case ReferenceHandling.References:
                using (var borrow = HashSetPool <T> .Borrow((x, y) => ReferenceEquals(x, y), x => RuntimeHelpers.GetHashCode(x)))
                {
                    borrow.Value.UnionWith(source);
                    target.IntersectWith(borrow.Value);
                    target.UnionWith(borrow.Value);
                }

                break;

            case ReferenceHandling.Structural:
                IEqualityComparer <T> comparer;
                if (!Set.TryGetComparer(source, out comparer))
                {
                    comparer = EqualityComparer <T> .Default;
                }

                var copyIngComparer = new CopyingComparer <T>(comparer, settings, referencePairs);
                using (var borrow = HashSetPool <T> .Borrow(copyIngComparer))
                {
                    borrow.Value.UnionWith(source);
                    target.IntersectWith(borrow.Value);
                    copyIngComparer.StartCopying();
                    target.UnionWith(borrow.Value);
                }

                return;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Пример #2
0
 private bool ItemsEquals(ISet <T> x, ISet <T> y, Func <T, T, bool> compare, Func <T, int> getHashCode)
 {
     using (var borrow = HashSetPool <T> .Borrow(compare, getHashCode))
     {
         borrow.Value.UnionWith(x);
         var result = borrow.Value.SetEquals(y);
         return(result);
     }
 }
 private void AddDiffs(
     DiffBuilder collectionBuilder,
     IDictionary <TKey, TValue> x,
     IDictionary <TKey, TValue> y,
     MemberSettings settings)
 {
     using (var borrow = HashSetPool <TKey> .Borrow(EqualityComparer <TKey> .Default.Equals, EqualityComparer <TKey> .Default.GetHashCode))
     {
         borrow.Value.UnionWith(x.Keys);
         borrow.Value.UnionWith(y.Keys);
         foreach (var key in borrow.Value)
         {
             var xv = x.ElementAtOrMissing(key);
             var yv = y.ElementAtOrMissing(key);
             collectionBuilder.UpdateCollectionItemDiff(xv, yv, key, settings);
         }
     }
 }
Пример #4
0
        // ReSharper disable once UnusedParameter.Local
        private void AddDiffs(
            DiffBuilder collectionBuilder,
            ISet <T> x,
            ISet <T> y,
            MemberSettings settings)
        {
            if (typeof(T).Implements <IEquatable <T> >())
            {
                using (var borrow = HashSetPool <T> .Borrow(EqualityComparer <T> .Default.Equals, EqualityComparer <T> .Default.GetHashCode))
                {
                    AddItemDiffs(collectionBuilder, x, y, borrow.Value);
                    return;
                }
            }

            switch (settings.ReferenceHandling)
            {
            case ReferenceHandling.Throw:
                throw Throw.ShouldNeverGetHereException("ReferenceHandling should be checked before");

            case ReferenceHandling.References:
                using (var borrow = HashSetPool <T> .Borrow((xi, yi) => ReferenceEquals(xi, yi), item => RuntimeHelpers.GetHashCode(item)))
                {
                    AddItemDiffs(collectionBuilder, x, y, borrow.Value);
                    return;
                }

            case ReferenceHandling.Structural:
                using (var borrow = HashSetPool <T> .Borrow((xi, yi) => EqualBy.MemberValues(xi, yi, settings), xi => 0))
                {
                    AddItemDiffs(collectionBuilder, x, y, borrow.Value);
                    return;
                }

            default:
                throw new ArgumentOutOfRangeException();
            }
        }