path: root/java/common/src/main/java/org/apache/qpid/transport/Range.java

/*
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 */
package org.apache.qpid.transport;

import static org.apache.qpid.util.Serial.gt;
import static org.apache.qpid.util.Serial.le;
import static org.apache.qpid.util.Serial.max;
import static org.apache.qpid.util.Serial.min;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;


/**
 * Range
 *
 * @author Rafael H. Schloming
 */

public abstract class Range implements RangeSet
{
    public static Range newInstance(int point)
    {
        return new PointImpl(point);
    }

    public static Range newInstance(int lower, int upper)
    {
        return lower == upper ? new PointImpl(lower) : new RangeImpl(lower, upper);
    }

    public abstract int getLower();

    public abstract int getUpper();

    public abstract boolean includes(int value);

    public abstract boolean includes(Range range);

    public abstract boolean intersects(Range range);

    public abstract boolean touches(Range range);

    public abstract Range span(Range range);

    public abstract List<Range> subtract(Range range);


    public Range intersect(Range range)
    {
        int l = max(getLower(), range.getLower());
        int r = min(getUpper(), range.getUpper());
        if (gt(l, r))
        {
            return null;
        }
        else
        {
            return newInstance(l, r);
        }
    }



    public int size()
    {
        return 1;
    }

    public Iterator<Range> iterator()
    {
        return new RangeIterator();
    }

    public Range getFirst()
    {
        return this;
    }

    public Range getLast()
    {
        return this;
    }

    public void add(Range range)
    {
        throw new UnsupportedOperationException();
    }

    public void add(int lower, int upper)
    {
        throw new UnsupportedOperationException();
    }

    public void add(int value)
    {
        throw new UnsupportedOperationException();
    }

    public void clear()
    {
        throw new UnsupportedOperationException();
    }

    public void subtract(RangeSet rangeSet)
    {
        throw new UnsupportedOperationException();
    }

    public RangeSet copy()
    {
        RangeSet rangeSet = RangeSetFactory.createRangeSet();
        rangeSet.add(this);
        return rangeSet;
    }

    private static class PointImpl extends Range
    {
        private final int point;

        private PointImpl(int point)
        {
            this.point = point;
        }

        public int getLower()
        {
            return point;
        }

        public int getUpper()
        {
            return point;
        }

        public boolean includes(int value)
        {
            return value == point;
        }


        public boolean includes(Range range)
        {
            return range.getLower() == point && range.getUpper() == point;
        }

        public boolean intersects(Range range)
        {
            return range.includes(point);
        }

        public boolean touches(Range range)
        {
            return intersects(range) ||
                    includes(range.getUpper() + 1) || includes(range.getLower() - 1) ||
                    range.includes(point + 1) || range.includes(point - 1);
        }

        public Range span(Range range)
        {
            return newInstance(min(point, range.getLower()), max(point, range.getUpper()));
        }

        public List<Range> subtract(Range range)
        {
            if(range.includes(point))
            {
                return Collections.emptyList();
            }
            else
            {
                return Collections.singletonList((Range) this);
            }
        }

        public String toString()
        {
            return "[" + point + ", " + point + "]";
        }


    }

    private static class RangeImpl extends Range
    {
        private final int lower;
        private final int upper;

        private RangeImpl(int lower, int upper)
        {
            this.lower = lower;
            this.upper = upper;
        }

        public int getLower()
        {
            return lower;
        }

        public int getUpper()
        {
            return upper;
        }

        public boolean includes(int value)
        {
            return le(lower, value) && le(value, upper);
        }

        public boolean includes(Range range)
        {
            return includes(range.getLower()) && includes(range.getUpper());
        }

        public boolean intersects(Range range)
        {
            return (includes(range.getLower()) || includes(range.getUpper()) ||
                    range.includes(lower) || range.includes(upper));
        }

        public boolean touches(Range range)
        {
            return (intersects(range) ||
                    includes(range.getUpper() + 1) || includes(range.getLower() - 1) ||
                    range.includes(upper + 1) || range.includes(lower - 1));
        }

        public Range span(Range range)
        {
            return newInstance(min(lower, range.getLower()), max(upper, range.getUpper()));
        }

        public List<Range> subtract(Range range)
        {
            List<Range> result = new ArrayList<Range>();

            if (includes(range.getLower()) && le(lower, range.getLower() - 1))
            {
                result.add(newInstance(lower, range.getLower() - 1));
            }

            if (includes(range.getUpper()) && le(range.getUpper() + 1, upper))
            {
                result.add(newInstance(range.getUpper() + 1, upper));
            }

            if (result.isEmpty() && !range.includes(this))
            {
                result.add(this);
            }

            return result;
        }


        public String toString()
        {
            return "[" + lower + ", " + upper + "]";
        }
    }


    private class RangeIterator implements Iterator<Range>
    {
        private boolean atFirst = true;

        public boolean hasNext()
        {
            return atFirst;
        }

        public Range next()
        {

            Range range = atFirst ? Range.this : null;
            atFirst = false;
            return range;
        }


        public void remove()
        {
            throw new UnsupportedOperationException();
        }
    }
}