Beispiel #1
0
        public bool Equals(UidInterval p)
        {
            // If parameter is null return false:
            if ((object)p == null)
            {
                return(false);
            }

            // Return true if the fields match:
            return((From == p.From) && (To == p.To));
        }
 public void AddHandledInterval(UidInterval newInterval)
 {
     var newIntervals = new List<UidInterval>();
     foreach (var interval in _unhandledIntervals)
     {
         if (interval.To < newInterval.From || interval.From > newInterval.To)
             newIntervals.Add(interval);
         else
         {
             if (interval.To > newInterval.To)
                 newIntervals.Add(new UidInterval(newInterval.To + 1, interval.To));
             if (interval.From < newInterval.From)
                 newIntervals.Add(new UidInterval(interval.From, newInterval.From - 1));
         }
     }
     _unhandledIntervals = newIntervals;
 }
Beispiel #3
0
        public void AddUnhandledInterval(UidInterval newInterval)
        {
            var newIntervals = new List <UidInterval>();

            var intersectionMinFrom      = newInterval.From;
            var intersectionMaxTo        = newInterval.To;
            var intersectionWasAddedFlag = false;

            foreach (var interval in _unhandledIntervals)
            {
                if (interval.From > newInterval.To)
                {
                    newIntervals.Add(interval);
                }
                else if (interval.To < newInterval.From)
                {
                    if (!intersectionWasAddedFlag)
                    {
                        intersectionWasAddedFlag = true;
                        newIntervals.Add(new UidInterval(intersectionMinFrom, intersectionMaxTo));
                    }
                    newIntervals.Add(interval);
                }
                else
                {
                    intersectionMinFrom = Math.Min(intersectionMinFrom, interval.From);
                    intersectionMaxTo   = Math.Max(intersectionMaxTo, interval.To);
                }
            }

            if (!intersectionWasAddedFlag)
            {
                newIntervals.Add(new UidInterval(intersectionMinFrom, intersectionMaxTo));
            }

            _unhandledIntervals = newIntervals;
        }
Beispiel #4
0
        public void AddHandledInterval(UidInterval newInterval)
        {
            var newIntervals = new List <UidInterval>();

            foreach (var interval in _unhandledIntervals)
            {
                if (interval.To < newInterval.From || interval.From > newInterval.To)
                {
                    newIntervals.Add(interval);
                }
                else
                {
                    if (interval.To > newInterval.To)
                    {
                        newIntervals.Add(new UidInterval(newInterval.To + 1, interval.To));
                    }
                    if (interval.From < newInterval.From)
                    {
                        newIntervals.Add(new UidInterval(interval.From, newInterval.From - 1));
                    }
                }
            }
            _unhandledIntervals = newIntervals;
        }
        public void AddUnhandledInterval(UidInterval newInterval)
        {
            var newIntervals = new List<UidInterval>();

            var intersectionMinFrom = newInterval.From;
            var intersectionMaxTo = newInterval.To;
            var intersectionWasAddedFlag = false;

            foreach (var interval in _unhandledIntervals)
            {
                if (interval.From > newInterval.To)
                    newIntervals.Add(interval);
                else if (interval.To < newInterval.From)
                {
                    if (!intersectionWasAddedFlag)
                    {
                        intersectionWasAddedFlag = true;
                        newIntervals.Add(new UidInterval(intersectionMinFrom, intersectionMaxTo));
                    }
                    newIntervals.Add(interval);
                }
                else
                {
                    intersectionMinFrom = Math.Min(intersectionMinFrom, interval.From);
                    intersectionMaxTo = Math.Max(intersectionMaxTo, interval.To);
                }
            }

            if (!intersectionWasAddedFlag)
                newIntervals.Add(new UidInterval(intersectionMinFrom, intersectionMaxTo));

            _unhandledIntervals = newIntervals;
        }
        public void AddUnhandledIntervalBaseTest(int[] indexes, UidInterval newInterval, int[] indexesMody, UidInterval[] intervals)
        {
            var imapIntervals = new ImapIntervals(new List<int>(indexes));
            imapIntervals.AddUnhandledInterval(newInterval);
            var uidIntervals = imapIntervals.GetUnhandledIntervalsCopy();
            Assert.IsTrue(uidIntervals.Count == intervals.Count());
            foreach (var interval in intervals)
            {
                Assert.IsTrue(uidIntervals.Contains(interval));
            }

            var indexesListMody = new List<int>(indexesMody);
            Assert.IsTrue(indexesListMody.SequenceEqual(imapIntervals.ToIndexes()));
        }
        public void SetBeginIndexForSeveralIntervalsBase(int[] indexes, int beginIndex, int[] indexesMody, UidInterval[] intervals)
        {
            var imapIntervals = new ImapIntervals(new List<int>(indexes));
            imapIntervals.SetBeginIndex(beginIndex);
            var uidIntervals = imapIntervals.GetUnhandledIntervalsCopy();
            foreach (var interval in intervals)
            {
                Assert.IsTrue(uidIntervals.Contains(interval));
            }

            var indexesListMody = new List<int>(indexesMody);
            Assert.IsTrue(indexesListMody.SequenceEqual(imapIntervals.ToIndexes()));
        }
Beispiel #8
0
        public bool Equals(UidInterval p)
        {
            // If parameter is null return false:
            if ((object)p == null)
            {
                return false;
            }

            // Return true if the fields match:
            return (From == p.From) && (To == p.To);
        }