public static erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet Of(int a)
{
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet s = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet();
s.Add(a);
return(s);
}
public virtual erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet Or(IIntSet a)
{
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet o = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet();
o.AddAll(this);
o.AddAll(a);
return(o);
}
public virtual erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet AddAll(IIntSet set)
{
if (set == null)
{
return(this);
}
if (set is erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet)
{
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet other = (erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet)set;
// walk set and add each interval
int n = other.intervals.Count;
for (int i = 0; i < n; i++)
{
Interval I = other.intervals[i];
this.Add(I.a, I.b);
}
}
else
{
foreach (int value in set.ToList())
{
Add(value);
}
}
return(this);
}
/// <summary>
/// Are two IntervalSets equal? Because all intervals are sorted
/// and disjoint, equals is a simple linear walk over both lists
/// to make sure they are the same.
/// </summary>
/// <remarks>
/// Are two IntervalSets equal? Because all intervals are sorted
/// and disjoint, equals is a simple linear walk over both lists
/// to make sure they are the same. Interval.equals() is used
/// by the List.equals() method to check the ranges.
/// </remarks>
public override bool Equals(object obj)
{
if (obj == null || !(obj is erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet))
{
return(false);
}
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet other = (erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet)obj;
return(this.intervals.SequenceEqual(other.intervals));
}
/// <summary>combine all sets in the array returned the or'd value</summary>
public static erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet Or(erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet[] sets)
{
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet r = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet();
foreach (erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet s in sets)
{
r.AddAll(s);
}
return(r);
}
public virtual erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet Subtract(IIntSet a)
{
if (a == null || a.IsNil)
{
return(new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet(this));
}
if (a is erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet)
{
return(Subtract(this, (erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet)a));
}
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet other = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet();
other.AddAll(a);
return(Subtract(this, other));
}
/// <summary>
/// <inheritDoc/>
///
/// </summary>
public virtual erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet Complement(IIntSet vocabulary)
{
if (vocabulary == null || vocabulary.IsNil)
{
return(null);
}
// nothing in common with null set
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet vocabularyIS;
if (vocabulary is erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet)
{
vocabularyIS = (erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet)vocabulary;
}
else
{
vocabularyIS = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet();
vocabularyIS.AddAll(vocabulary);
}
return(vocabularyIS.Subtract(this));
}
public IntervalSet(erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet set)
: this()
{
AddAll(set);
}
/// <summary>
/// <inheritDoc/>
///
/// </summary>
public virtual erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet And(IIntSet other)
{
if (other == null)
{
//|| !(other instanceof IntervalSet) ) {
return(null);
}
// nothing in common with null set
IList <Interval> myIntervals = this.intervals;
IList <Interval> theirIntervals = ((erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet)other).intervals;
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet intersection = null;
int mySize = myIntervals.Count;
int theirSize = theirIntervals.Count;
int i = 0;
int j = 0;
// iterate down both interval lists looking for nondisjoint intervals
while (i < mySize && j < theirSize)
{
Interval mine = myIntervals[i];
Interval theirs = theirIntervals[j];
//System.out.println("mine="+mine+" and theirs="+theirs);
if (mine.StartsBeforeDisjoint(theirs))
{
// move this iterator looking for interval that might overlap
i++;
}
else
{
if (theirs.StartsBeforeDisjoint(mine))
{
// move other iterator looking for interval that might overlap
j++;
}
else
{
if (mine.ProperlyContains(theirs))
{
// overlap, add intersection, get next theirs
if (intersection == null)
{
intersection = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet();
}
intersection.Add(mine.Intersection(theirs));
j++;
}
else
{
if (theirs.ProperlyContains(mine))
{
// overlap, add intersection, get next mine
if (intersection == null)
{
intersection = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet();
}
intersection.Add(mine.Intersection(theirs));
i++;
}
else
{
if (!mine.Disjoint(theirs))
{
// overlap, add intersection
if (intersection == null)
{
intersection = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet();
}
intersection.Add(mine.Intersection(theirs));
// Move the iterator of lower range [a..b], but not
// the upper range as it may contain elements that will collide
// with the next iterator. So, if mine=[0..115] and
// theirs=[115..200], then intersection is 115 and move mine
// but not theirs as theirs may collide with the next range
// in thisIter.
// move both iterators to next ranges
if (mine.StartsAfterNonDisjoint(theirs))
{
j++;
}
else
{
if (theirs.StartsAfterNonDisjoint(mine))
{
i++;
}
}
}
}
}
}
}
}
if (intersection == null)
{
return(new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet());
}
return(intersection);
}
public static erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet Subtract(erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet left, erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet right)
{
if (left == null || left.IsNil)
{
return(new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet());
}
erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet result = new erl.Oracle.TnsNames.Antlr4.Runtime.Misc.IntervalSet(left);
if (right == null || right.IsNil)
{
// right set has no elements; just return the copy of the current set
return(result);
}
int resultI = 0;
int rightI = 0;
while (resultI < result.intervals.Count && rightI < right.intervals.Count)
{
Interval resultInterval = result.intervals[resultI];
Interval rightInterval = right.intervals[rightI];
// operation: (resultInterval - rightInterval) and update indexes
if (rightInterval.b < resultInterval.a)
{
rightI++;
continue;
}
if (rightInterval.a > resultInterval.b)
{
resultI++;
continue;
}
Interval?beforeCurrent = null;
Interval?afterCurrent = null;
if (rightInterval.a > resultInterval.a)
{
beforeCurrent = new Interval(resultInterval.a, rightInterval.a - 1);
}
if (rightInterval.b < resultInterval.b)
{
afterCurrent = new Interval(rightInterval.b + 1, resultInterval.b);
}
if (beforeCurrent != null)
{
if (afterCurrent != null)
{
// split the current interval into two
result.intervals[resultI] = beforeCurrent.Value;
result.intervals.Insert(resultI + 1, afterCurrent.Value);
resultI++;
rightI++;
continue;
}
else
{
// replace the current interval
result.intervals[resultI] = beforeCurrent.Value;
resultI++;
continue;
}
}
else
{
if (afterCurrent != null)
{
// replace the current interval
result.intervals[resultI] = afterCurrent.Value;
rightI++;
continue;
}
else
{
// remove the current interval (thus no need to increment resultI)
result.intervals.RemoveAt(resultI);
continue;
}
}
}
// If rightI reached right.intervals.size(), no more intervals to subtract from result.
// If resultI reached result.intervals.size(), we would be subtracting from an empty set.
// Either way, we are done.
return(result);
}
