public SegmentRange(long fromMillisecond,
    long toMillisecond) 
{
            Segment start = getSegment(fromMillisecond);
            Segment end = getSegment(toMillisecond);
//            if (start.getSegmentStart() != fromMillisecond
//                || end.getSegmentEnd() != toMillisecond) {
//                throw new IllegalArgumentException("Invalid Segment Range ["
//                    + fromMillisecond + "," + toMillisecond + "]");
//            }
            this.millisecond = fromMillisecond;
            this.segmentNumber = calculateSegmentNumber(fromMillisecond);
            this.segmentStart = start.segmentStart;
            this.segmentEnd = end.segmentEnd;
            this.segmentCount
                = (end.getSegmentNumber() - start.getSegmentNumber() + 1);
}

Creates a SegmentRange between a start and end domain values.

Parameters:

fromMillisecond - start of the range

toMillisecond - end of the range

 public long getSegmentCount() 
{
            return this.segmentCount;
}

Returns the number of segments contained in this range.

 public boolean inExcludeSegments() 
{
            for (Segment segment = getSegment(this.segmentStart);
                segment.getSegmentStart() <  this.segmentEnd;
                segment.inc()) {
                if (!segment.inExceptionSegments()) {
                    return (false);
                }
            }
            return true;
}

Returns true if we are an excluded segment.

 public boolean inIncludeSegments() 
{
            for (Segment segment = getSegment(this.segmentStart);
                segment.getSegmentStart() <  this.segmentEnd;
                segment.inc()) {
                if (!segment.inIncludeSegments()) {
                    return (false);
                }
            }
            return true;
}

Returns true if all Segments of this SegmentRenge are an included segment and are not an exception.

 public  void inc(long n) 
{
            throw new IllegalArgumentException(
                    "Not implemented in SegmentRange");
}

Not implemented for SegmentRange. Always throws IllegalArgumentException.

 public SegmentedTimeline.Segment intersect(long from,
    long to) 
{
            // Segment fromSegment = getSegment(from);
            // fromSegment.inc();
            // Segment toSegment = getSegment(to);
            // toSegment.dec();
            long start = Math.max(from, this.segmentStart);
            long end = Math.min(to, this.segmentEnd);
            // long start = Math.max(
            //     fromSegment.getSegmentStart(), this.segmentStart
            // );
            // long end = Math.min(toSegment.getSegmentEnd(), this.segmentEnd);
            if (start < = end) {
                return new SegmentRange(start, end);
            }
            else {
                return null;
            }
}

Returns a segment that is the intersection of this segment and the interval.