Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

392 lines
12 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Text;
using System.ServiceModel;
abstract class SequenceRangeCollection
{
static EmptyRangeCollection empty = new EmptyRangeCollection();
static LowerComparer lowerComparer = new LowerComparer();
static UpperComparer upperComparer = new UpperComparer();
public abstract SequenceRange this[int index] { get; }
public abstract int Count { get; }
public static SequenceRangeCollection Empty
{
get
{
return empty;
}
}
public abstract bool Contains(Int64 number);
public abstract SequenceRangeCollection MergeWith(Int64 number);
public abstract SequenceRangeCollection MergeWith(SequenceRange range);
static SequenceRangeCollection GeneralCreate(SequenceRange[] sortedRanges)
{
if (sortedRanges.Length == 0)
{
return empty;
}
else if (sortedRanges.Length == 1)
{
return new SingleItemRangeCollection(sortedRanges[0]);
}
else
{
return new MultiItemRangeCollection(sortedRanges);
}
}
static SequenceRangeCollection GeneralMerge(SequenceRange[] sortedRanges, SequenceRange range)
{
if (sortedRanges.Length == 0)
{
return new SingleItemRangeCollection(range);
}
int lowerBound;
if (sortedRanges.Length == 1)
{
// Avoid performance hit of binary search in single range case
if (range.Lower == sortedRanges[0].Upper)
{
lowerBound = 0;
}
else if (range.Lower < sortedRanges[0].Upper)
{
lowerBound = ~0;
}
else
{
lowerBound = ~1;
}
}
else
{
lowerBound = Array.BinarySearch(sortedRanges, new SequenceRange(range.Lower), upperComparer);
}
if (lowerBound < 0)
{
lowerBound = ~lowerBound;
if ((lowerBound > 0) && (sortedRanges[lowerBound - 1].Upper == range.Lower - 1))
{
lowerBound--;
}
if (lowerBound == sortedRanges.Length)
{
SequenceRange[] returnedRanges = new SequenceRange[sortedRanges.Length + 1];
Array.Copy(sortedRanges, returnedRanges, sortedRanges.Length);
returnedRanges[sortedRanges.Length] = range;
return GeneralCreate(returnedRanges);
}
}
int upperBound;
if (sortedRanges.Length == 1)
{
// Avoid performance hit of binary search in single range case
if (range.Upper == sortedRanges[0].Lower)
{
upperBound = 0;
}
else if (range.Upper < sortedRanges[0].Lower)
{
upperBound = ~0;
}
else
{
upperBound = ~1;
}
}
else
{
upperBound = Array.BinarySearch(sortedRanges, new SequenceRange(range.Upper), lowerComparer);
}
if (upperBound < 0)
{
upperBound = ~upperBound;
if (upperBound > 0)
{
if ((upperBound == sortedRanges.Length) || (sortedRanges[upperBound].Lower != range.Upper + 1))
{
upperBound--;
}
}
else if (sortedRanges[0].Lower > range.Upper + 1)
{
SequenceRange[] returnedRanges = new SequenceRange[sortedRanges.Length + 1];
Array.Copy(sortedRanges, 0, returnedRanges, 1, sortedRanges.Length);
returnedRanges[0] = range;
return GeneralCreate(returnedRanges);
}
}
Int64 newLower = (range.Lower < sortedRanges[lowerBound].Lower) ? range.Lower : sortedRanges[lowerBound].Lower;
Int64 newUpper = (range.Upper > sortedRanges[upperBound].Upper) ? range.Upper : sortedRanges[upperBound].Upper;
int rangesRemoved = upperBound - lowerBound + 1;
int rangesRemaining = sortedRanges.Length - rangesRemoved + 1;
if (rangesRemaining == 1)
{
return new SingleItemRangeCollection(newLower, newUpper);
}
else
{
SequenceRange[] returnedRanges = new SequenceRange[rangesRemaining];
Array.Copy(sortedRanges, returnedRanges, lowerBound);
returnedRanges[lowerBound] = new SequenceRange(newLower, newUpper);
Array.Copy(sortedRanges, upperBound + 1, returnedRanges, lowerBound + 1, sortedRanges.Length - upperBound - 1);
return GeneralCreate(returnedRanges);
}
}
public override string ToString()
{
StringBuilder builder = new StringBuilder();
for (int i = 0; i < Count; i++)
{
SequenceRange range = this[i];
if (i > 0)
{
builder.Append(',');
}
builder.Append(range.Lower);
builder.Append('-');
builder.Append(range.Upper);
}
return builder.ToString();
}
class EmptyRangeCollection : SequenceRangeCollection
{
public override SequenceRange this[int index]
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("index"));
}
}
public override int Count
{
get
{
return 0;
}
}
public override bool Contains(Int64 number)
{
return false;
}
public override SequenceRangeCollection MergeWith(Int64 number)
{
return new SingleItemRangeCollection(number, number);
}
public override SequenceRangeCollection MergeWith(SequenceRange range)
{
return new SingleItemRangeCollection(range);
}
}
class MultiItemRangeCollection : SequenceRangeCollection
{
SequenceRange[] ranges;
public MultiItemRangeCollection(SequenceRange[] sortedRanges)
{
this.ranges = sortedRanges;
}
public override SequenceRange this[int index]
{
get
{
if (index < 0 || index >= ranges.Length)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("index", index,
SR.GetString(SR.ValueMustBeInRange, 0, ranges.Length - 1)));
return this.ranges[index];
}
}
public override int Count
{
get
{
return this.ranges.Length;
}
}
public override bool Contains(Int64 number)
{
if (this.ranges.Length == 0)
{
return false;
}
else if (this.ranges.Length == 1)
{
return this.ranges[0].Contains(number);
}
SequenceRange searchFor = new SequenceRange(number);
int searchValue = Array.BinarySearch(this.ranges, searchFor, lowerComparer);
if (searchValue >= 0)
{
return true;
}
searchValue = ~searchValue;
if (searchValue == 0)
{
return false;
}
return (this.ranges[searchValue - 1].Upper >= number);
}
public override SequenceRangeCollection MergeWith(Int64 number)
{
return MergeWith(new SequenceRange(number));
}
public override SequenceRangeCollection MergeWith(SequenceRange newRange)
{
return GeneralMerge(this.ranges, newRange);
}
}
class SingleItemRangeCollection : SequenceRangeCollection
{
SequenceRange range;
public SingleItemRangeCollection(SequenceRange range)
{
this.range = range;
}
public SingleItemRangeCollection(Int64 lower, Int64 upper)
{
this.range = new SequenceRange(lower, upper);
}
public override SequenceRange this[int index]
{
get
{
if (index != 0)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("index"));
return this.range;
}
}
public override int Count
{
get
{
return 1;
}
}
public override bool Contains(Int64 number)
{
return this.range.Contains(number);
}
public override SequenceRangeCollection MergeWith(Int64 number)
{
if (number == this.range.Upper + 1)
{
return new SingleItemRangeCollection(range.Lower, number);
}
else
{
return MergeWith(new SequenceRange(number));
}
}
public override SequenceRangeCollection MergeWith(SequenceRange newRange)
{
if (newRange.Lower == this.range.Upper + 1)
{
return new SingleItemRangeCollection(range.Lower, newRange.Upper);
}
else if (this.range.Contains(newRange))
{
return this;
}
else if (newRange.Contains(this.range))
{
return new SingleItemRangeCollection(newRange);
}
else if (newRange.Upper == this.range.Lower - 1)
{
return new SingleItemRangeCollection(newRange.Lower, this.range.Upper);
}
else
{
return GeneralMerge(new SequenceRange[] { this.range }, newRange);
}
}
}
class LowerComparer : IComparer<SequenceRange>
{
public int Compare(SequenceRange x, SequenceRange y)
{
if (x.Lower < y.Lower)
{
return -1;
}
else if (x.Lower > y.Lower)
{
return 1;
}
else
{
return 0;
}
}
}
class UpperComparer : IComparer<SequenceRange>
{
public int Compare(SequenceRange x, SequenceRange y)
{
if (x.Upper < y.Upper)
{
return -1;
}
else if (x.Upper > y.Upper)
{
return 1;
}
else
{
return 0;
}
}
}
}
}