timeframeimpl.java

It is all about project scheduling. GanttProject is a tool for creating a project schedule by means

/*
 * Created on 08.11.2004
 */
package net.sourceforge.ganttproject.time.gregorian;

import java.util.Calendar;
import java.util.Date;

import net.sourceforge.ganttproject.time.DateFrameable;
import net.sourceforge.ganttproject.time.TimeFrame;
import net.sourceforge.ganttproject.time.TimeUnit;
import net.sourceforge.ganttproject.time.TimeUnitFunctionOfDate;
import net.sourceforge.ganttproject.time.TimeUnitText;

class TimeFrameImpl implements TimeFrame {
    private final Date myBaseDate;

    private final TimeUnit myTopUnit;

    private final TimeUnit myBottomUnit;

    private Date myNextFrameStartDate;

    private Calendar myCalendar;

    private DateFrameable myLowestFrameable;

    private Date myStartDate;

    private DateFrameable myHighestFrameable;

    private Date myEndDate;

    private LineHeader myLineHeader;

    TimeFrameImpl(Date baseDate, TimeUnit topUnit, TimeUnit bottomUnit) {
        // if (!topUnit.isConstructedFrom(bottomUnit)) {
        // throw new RuntimeException("Top unit="+topUnit+" is not constructed
        // from bottom unit="+bottomUnit);
        // }
        if (topUnit instanceof TimeUnitFunctionOfDate) {
            topUnit = ((TimeUnitFunctionOfDate) topUnit)
                    .createTimeUnit(baseDate);
        }
        myBaseDate = baseDate;
        myHighestFrameable = calculateHighestFrameableUnit(topUnit, bottomUnit);
        myLowestFrameable = calculateLowestFrameableUnit(topUnit, bottomUnit);
        // if (myHighestFrameable!=topUnit || myLowestFrameable!=bottomUnit) {
        // throw new RuntimeException("Current implementation requires all units
        // to be frameable. myHighestFrameable="+myHighestFrameable+"
        // myLowestFrameable="+myLowestFrameable);
        // }
        myTopUnit = topUnit;
        myBottomUnit = bottomUnit;
        myCalendar = (Calendar) Calendar.getInstance().clone();
        myCalendar.setTime(myBaseDate);
        if (myLowestFrameable == null) {
            throw new RuntimeException(
                    "Failed to find any time frameable unit :(");
        }
        myStartDate = myLowestFrameable.adjustLeft(myBaseDate);
        if (myStartDate.after(myBaseDate)) {
            throw new IllegalStateException("Start date is after base date");
        }
        // System.err.println("TimeFrame.init: myStartDate="+myStartDate+"
        // myBaseDate="+myBaseDate);
        // myEndDate = calculateEndDate();
        // myNextFrameStartDate = shiftDate(myBaseDate, myTopUnit, 1);
    }

    private DateFrameable calculateLowestFrameableUnit(TimeUnit topUnit,
            TimeUnit bottomUnit) {
        // DateFrameable lowestFrameable = null;
        // for (TimeUnit timeUnit = topUnit; timeUnit!=null; timeUnit =
        // timeUnit.getDirectAtomUnit()) {
        // if (timeUnit instanceof DateFrameable) {
        // lowestFrameable = (DateFrameable)timeUnit;
        // }
        // if (bottomUnit.equals(timeUnit)) {
        // break;
        // }
        // }
        // return lowestFrameable;
        return bottomUnit;
    }

    private DateFrameable calculateHighestFrameableUnit(TimeUnit topUnit,
            TimeUnit bottomUnit) {
        // DateFrameable highestFrameable = null;
        // for (TimeUnit timeUnit = topUnit; timeUnit!=null; timeUnit =
        // timeUnit.getDirectAtomUnit()) {
        // System.err.println("next time unit="+timeUnit);
        // if (timeUnit instanceof DateFrameable) {
        // highestFrameable = (DateFrameable)timeUnit;
        // break;
        // }
        // if (timeUnit==bottomUnit) {
        // break;
        // }
        // }
        // return highestFrameable;
        return topUnit;
    }

    private Date calculateEndDate() {
        // int countFrameable =
        // myTopUnit.getAtomCount((TimeUnit)myHighestFrameable);
        Date date = myTopUnit.adjustRight(myBaseDate);
        if (date.before(myStartDate)) {
            throw new IllegalStateException("End date="+date+" start="+myStartDate+" base="+myBaseDate);
        }
        // for (int i=0; i<countFrameable; i++) {
        // date = myHighestFrameable.adjustRight(date);
        // }
        return date;
    }

    private LineHeader calculateLines(LineHeader lastHeader) {
        TimeUnit curUnit = lastHeader == null ? myTopUnit : lastHeader.myUnit
                .getDirectAtomUnit();
        LineHeader curHeader = createHeader(curUnit);
        fillLine(lastHeader, curHeader);
        if (lastHeader != null) {
            lastHeader.append(curHeader);
        }
        if (curUnit != myBottomUnit) {
            calculateLines(curHeader);
        }
        return curHeader;
    }

    private void fillLine(LineHeader higherHeader, LineHeader header) {
        if (higherHeader == null) {
            Date startDate = myStartDate;
            Date endDate = ((DateFrameable) myTopUnit).adjustRight(myBaseDate);
            // System.err.println("filling line="+header+" endDate="+endDate);
            LineItem item = createLineItem(startDate, endDate);
            header.myFirstItem = item;
        } else {
            // System.err.println("filling line="+header);
            for (LineItem higherItem = higherHeader.myFirstItem; higherItem != null; higherItem = higherItem.myNextItem) {
                int unitCount = getUnitCount(higherHeader, header, higherItem);
                Date curStartDate = higherItem.myStartDate;
                LineItem curItem = null;
                // System.err.println("unit count="+unitCount+"
                // startDate="+curStartDate);
                for (int i = 0; i < unitCount
                        && curStartDate.compareTo(higherItem.myEndDate) < 0; i++) {
                    Date nextEndDate = ((DateFrameable) header.myUnit)
                            .adjustRight(curStartDate);
                    LineItem newItem = createLineItem(curStartDate, nextEndDate);
                    if (curItem == null) {
                        header.myFirstItem = newItem;
                    } else {
                        curItem.myNextItem = newItem;
                    }
                    curItem = newItem;
                    curStartDate = nextEndDate;
                }
                // System.err.println("result: "+header.fullDump());
            }
        }

    }

    private int getUnitCount(LineHeader higherHeader, LineHeader header,
            LineItem higherItem) {
        TimeUnit higherUnit = higherHeader.myUnit instanceof TimeUnitFunctionOfDate ? ((TimeUnitFunctionOfDate) higherHeader.myUnit)
                .createTimeUnit(higherItem.myStartDate)
                : higherHeader.myUnit;
        TimeUnit lowerUnit = header.myUnit;
        int result = higherUnit.getAtomCount(lowerUnit);
        return result;
    }

    private LineItem createLineItem(Date startDate, Date endDate) {
        return new LineItem(startDate, endDate);
    }

    private LineHeader createHeader(TimeUnit unit) {
        return new LineHeader(unit);
    }

    public Date getFinishDate() {
        if (myEndDate == null) {
            myEndDate = calculateEndDate();
            // System.err.println("getFinishDate(): startDate="+myStartDate+"
            // finish="+myEndDate);
        }
        return myEndDate;
    }

    public int getUnitCount(TimeUnit unit) {
        LineHeader lineHeader = getLineHeader(unit);
        if (lineHeader == null) {
            lineHeader = new LineHeader(unit);
            // return getUnitCount(getLineHeader(), lineHeader,
            // getLineHeader().myFirstItem);
            fillLine(getLineHeader(), lineHeader);
            return lineHeader.getItemCount();
        }
        int result = lineHeader == null ? -1 : lineHeader.getItemCount();
        if (result == -1) {
            throw new RuntimeException("There is not time unit=" + unit
                    + " in this time frame");
        }
        return result;
    }

    private LineHeader getLineHeader(TimeUnit timeUnit) {
        LineHeader result = getLineHeader();
        for (; result != null; result = result.next()) {
            if (result.myUnit == timeUnit) {
                break;
            }
        }
        return result;
    }

    // public int _getUnitCount(TimeUnit unit) {
    // if (unit.isConstructedFrom((TimeUnit)myLowestFrameable)) {
    // UnitInfo info = calculateInfo(myHighestFrameable, myEndDate);
    // if (unit==myHighestFrameable) {
    // return info.myRoundedCount;
    // }
    // else if (unit.isConstructedFrom((TimeUnit)myHighestFrameable)) {
    // int atomCount = unit.getAtomCount((TimeUnit)myHighestFrameable);