void delete(int index) 
{
                        // Number of range array elements in use
            // Return if no elements left or index is out of range
            if (num == 0 || index  >= num)
            {
                return;
            }
            // Move elements down
            while (++index <  num)
            {
                if (index - 1  >= 0)
                {
                    minRange[index-1] = minRange[index];
                    maxRange[index-1] = maxRange[index];
                }
            }
            // One less element now
            num--;
}

Deletes the range at a given index from the range lists

  void include(char minmax,
    boolean include) 
{
            include(minmax, minmax, include);
}

Includes a range with the same min and max

  void include(int min,
    int max,
    boolean include) 
{
            if (include)
            {
                merge(min, max);
            }
            else
            {
                remove(min, max);
            }
}

Includes (or excludes) the range from min to max, inclusive.

  void merge(int min,
    int max) 
{
            // Loop through ranges
            for (int i = 0; i <  num; i++)
            {
                // Min-max is subsumed by minRange[i]-maxRange[i]
                if (min  >= minRange[i] && max < = maxRange[i])
                {
                    return;
                }
                // Min-max subsumes minRange[i]-maxRange[i]
                else if (min < = minRange[i] && max  >= maxRange[i])
                {
                    delete(i);
                    merge(min, max);
                    return;
                }
                // Min is in the range, but max is outside
                else if (min  >= minRange[i] && min < = maxRange[i])
                {
                    min = minRange[i];
                    delete(i);
                    merge(min, max);
                    return;
                }
                // Max is in the range, but min is outside
                else if (max  >= minRange[i] && max < = maxRange[i])
                {
                    max = maxRange[i];
                    delete(i);
                    merge(min, max);
                    return;
                }
            }
            // Must not overlap any other ranges
            if (num  >= size)
            {
                size *= 2;
                int[] newMin = new int[size];
                int[] newMax = new int[size];
                System.arraycopy(minRange, 0, newMin, 0, num);
                System.arraycopy(maxRange, 0, newMax, 0, num);
                minRange = newMin;
                maxRange = newMax;
            }
            minRange[num] = min;
            maxRange[num] = max;
            num++;
}

Merges a range into the range list, coalescing ranges if possible.

  void remove(int min,
    int max) 
{
            // Loop through ranges
            for (int i = 0; i <  num; i++)
            {
                // minRange[i]-maxRange[i] is subsumed by min-max
                if (minRange[i]  >= min && maxRange[i] < = max)
                {
                    delete(i);
                    return;
                }
                // min-max is subsumed by minRange[i]-maxRange[i]
                else if (min  >= minRange[i] && max < = maxRange[i])
                {
                    int minr = minRange[i];
                    int maxr = maxRange[i];
                    delete(i);
                    if (minr <  min)
                    {
                        merge(minr, min - 1);
                    }
                    if (max <  maxr)
                    {
                        merge(max + 1, maxr);
                    }
                    return;
                }
                // minRange is in the range, but maxRange is outside
                else if (minRange[i]  >= min && minRange[i] < = max)
                {
                    minRange[i] = max + 1;
                    return;
                }
                // maxRange is in the range, but minRange is outside
                else if (maxRange[i]  >= min && maxRange[i] < = max)
                {
                    maxRange[i] = min - 1;
                    return;
                }
            }
}

Removes a range by deleting or shrinking all other ranges