104 lines
3.1 KiB
Java
104 lines
3.1 KiB
Java
/**
|
|
* A train line as a common set of stations with many departures
|
|
*
|
|
* @author ab
|
|
*/
|
|
package btools.memrouter;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
|
|
final class ScheduledLine
|
|
{
|
|
String name;
|
|
List<Integer> offsetMinutes = new ArrayList<Integer>();
|
|
TrainSchedule schedule;
|
|
|
|
|
|
/**
|
|
* get a list of departures relative to the start-time plus
|
|
* the individual offsets according to the offset mask
|
|
*
|
|
* departures with the same wait-time are aggregated in one
|
|
* result element with multiple 1-bits in the offset mask
|
|
*
|
|
* departures with different wait-times are returned as separate items
|
|
*
|
|
* @param id the value to add to this set.
|
|
* @return true if "id" already contained in this set.
|
|
*/
|
|
public List<ScheduledDeparture> getScheduledDepartures( int idx, long timeFrom, OffsetSet offsets )
|
|
{
|
|
List<ScheduledDeparture> result = new ArrayList<ScheduledDeparture>();
|
|
|
|
long minutesFrom = (timeFrom + 59999L) / 60000L;
|
|
long timeFromCorrection = minutesFrom * 60000L - timeFrom;
|
|
|
|
if ( idx < 0 || idx >= offsetMinutes.size() -1 ) return result;
|
|
|
|
int offsetStart = offsetMinutes.get(idx).intValue();
|
|
int offsetEnd = offsetMinutes.get(idx+1).intValue();
|
|
|
|
|
|
Map<Integer,List<Integer>> waitOffsets = getDepartures( offsetStart, timeFrom + timeFromCorrection, offsets );
|
|
|
|
for( Map.Entry<Integer,List<Integer>> e : waitOffsets.entrySet() )
|
|
{
|
|
ScheduledDeparture depart = new ScheduledDeparture( );
|
|
depart.waitTime = e.getKey().intValue() * 60000L + timeFromCorrection;
|
|
depart.offsets = OffsetSet.create( e.getValue(), offsets );
|
|
depart.rideTime = (offsetEnd-offsetStart)*60000L;
|
|
result.add( depart );
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private Map<Integer,List<Integer>> getDepartures( int offsetStart, long timeFrom, OffsetSet offsets )
|
|
{
|
|
Map<Integer,List<Integer>> waitOffsets = new HashMap<Integer,List<Integer>>();
|
|
int size = offsets.size();
|
|
|
|
for(int offset = 0;;)
|
|
{
|
|
// skip to next offset bit
|
|
while( offset < size && !offsets.contains( offset ) )
|
|
{
|
|
offset++;
|
|
}
|
|
if ( offset >= size ) return waitOffsets;
|
|
|
|
int toNext = schedule.getMinutesToNext( timeFrom + 60000L*(offset - offsetStart ) );
|
|
if ( toNext < 0 ) return waitOffsets;
|
|
int departOffset = offset + toNext;
|
|
|
|
// whats the closest offset within the next toNext minutes
|
|
int lastOffset = offset;
|
|
while( toNext-- >= 0 && offset < size )
|
|
{
|
|
if ( offsets.contains( offset ) )
|
|
{
|
|
lastOffset = offset;
|
|
}
|
|
offset++;
|
|
}
|
|
|
|
if ( lastOffset == size-1 ) return waitOffsets; // todo?
|
|
|
|
int waitTime = departOffset - lastOffset;
|
|
|
|
// if we have that wait time in the list, just add the offset bit
|
|
List<Integer> offsetList = waitOffsets.get( Integer.valueOf( waitTime ) );
|
|
if ( offsetList == null )
|
|
{
|
|
offsetList = new ArrayList<Integer>();
|
|
waitOffsets.put( Integer.valueOf( waitTime ), offsetList );
|
|
}
|
|
offsetList.add( Integer.valueOf( lastOffset ) );
|
|
}
|
|
}
|
|
}
|