Interval.java

package timeflow.data.time;

import java.util.*;

public class Interval {
	public long start;
	public long end;
	
	public Interval(long start, long end)
	{
		this.start=start;
		this.end=end;
	}
	
	public Interval copy()
	{
		return new Interval(start, end);
	}
	
	public boolean contains(long x)
	{
		return x>=start && x<=end;
	}
	
	public boolean intersects(Interval x)
	{
		return intersects(x.start, x.end);
	}
	
	public boolean intersects(long start1, long end1)
	{
		return start1<=end && end1>=start;
	}
	
	
	public Interval subinterval(double startFraction, double endFraction)
	{
		return new Interval((long)(start+startFraction*length()),
				            (long)(start+endFraction*length()));
	}
	
	public void setTo(long start, long end)
	{
		this.start=start;
		this.end=end;
	}
	
	public void setTo(Interval t)
	{
		start=t.start;
		end=t.end;
	}
	
	public void include(long time)
	{
		start=Math.min(start, time);
		end=Math.max(end, time);
	}
	
	public void include(Interval t)
	{
		include(t.start);
		include(t.end);
	}
	
	public void expand(long amount)
	{
		start-=amount;
		end+=amount;
	}
	
	
	public void add(long amount)
	{
		start+=amount;
		end+=amount;
	}
	
	public long length()
	{
		return end-start;
	}
	
	public void translateTo(long newStart)
	{
		add(newStart-start);
	}
	
	public Interval intersection(Interval i)
	{
		start=Math.max(i.start, start);
		end=Math.min(i.end, end);
		return this;
	}
	
	public void clampInside(Interval container)
	{
		if (length()>container.length())
			throw new IllegalArgumentException("Containing interval too small: "+container+" < "+this);
		if (start>=container.start && end<=container.end)
			return;
		add(Math.max(0, container.start-start));
		add(Math.min(0, container.end-end));
	}
	
	public String toString()
	{
		return "[Interval: From "+new Date(start)+" to "+new Date(end)+"]";
	}

}