Useful RegularTimePeriod

[Zane]

Sometimes you need RegularTimePeriod like Quarter of Hour or Third of a Day or something like that.
So that this would be very easy to do I have written this.

Code: Select all

/**
 * User: zanel
 * Date: 2005.6.10
 * Time: 10:50:29
 */
package org.jfree.chart.demo.myDemo;

import org.jfree.data.time.Hour;

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

public class QuarterOfHour extends DynamicRegularTimePeriod {
    private static final int NUM_OF_SPLITS = 4;
    private static final int MIN_PER_HOUR = 60;

    public QuarterOfHour(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int minutes = calendar.get(Calendar.MINUTE);
        int split = minutes / (MIN_PER_HOUR / NUM_OF_SPLITS);
        setDynamicRegularTimePeriod(new Hour(date), NUM_OF_SPLITS, split);
    }
}

You can see that it is easy to make a class of your own.

class DynamicRegularTimePeriod

Code: Select all

/**
 * User: zanel
 * Date: 2005.2.10
 * Time: 8:58:04
 */
package org.jfree.chart.demo.myDemo;

import org.jfree.data.time.RegularTimePeriod;

import java.io.Serializable;
import java.util.Calendar;

public class DynamicRegularTimePeriod extends RegularTimePeriod implements Serializable{
    private RegularTimePeriod m_regularTimePeriod;
    private int m_numOfSplits;
    private int m_split;
    private long m_periode;

    public DynamicRegularTimePeriod() {
    }

    /**
     * @param regularTimePeriod
     * @param numOfSplits
     * @param split                 zero based
     */
    public void setDynamicRegularTimePeriod(RegularTimePeriod regularTimePeriod, int numOfSplits, int split) {
        m_regularTimePeriod = regularTimePeriod;
        m_periode = (regularTimePeriod.getLastMillisecond() + 1 - regularTimePeriod.getFirstMillisecond())
                / numOfSplits;
        m_numOfSplits = numOfSplits;
        m_split = split;
    }

    public RegularTimePeriod previous() {
        DynamicRegularTimePeriod newDynamic = copy();
        if (m_split == 0) {
            newDynamic.setSplit(m_numOfSplits - 1);
            newDynamic.setRegularTimePeriod(m_regularTimePeriod.previous());
        } else {
            newDynamic.setSplit(m_split - 1);
        }
        return newDynamic;
    }

    public RegularTimePeriod next() {
        DynamicRegularTimePeriod newDynamic = copy();
        if (m_split + 1 >= m_numOfSplits) {
            newDynamic.setSplit(0);
            newDynamic.setRegularTimePeriod(m_regularTimePeriod.next());
        } else {
            newDynamic.setSplit(m_split + 1);
        }
        return newDynamic;
    }

    public long getSerialIndex() {
        return m_regularTimePeriod.getSerialIndex() * 100 + m_numOfSplits * 10 + m_split;
    }

    public long getFirstMillisecond(Calendar calendar) {
        long firstMillisecond = m_regularTimePeriod.getFirstMillisecond(calendar);
        return firstMillisecond + m_periode * m_split;
    }

    public long getLastMillisecond(Calendar calendar) {
        long lastMillisecond = m_regularTimePeriod.getLastMillisecond(calendar);
        return lastMillisecond - m_periode * (m_numOfSplits - m_split - 1);
    }

    public RegularTimePeriod getRegularTimePeriod() {
        return m_regularTimePeriod;
    }

    public void setRegularTimePeriod(RegularTimePeriod regularTimePeriod) {
        m_regularTimePeriod = regularTimePeriod;
    }

    public int getNumOfSplits() {
        return m_numOfSplits;
    }

    public void setNumOfSplits(int numOfSplits) {
        m_numOfSplits = numOfSplits;
    }

    public int getSplit() {
        return m_split;
    }

    public void setSplit(int split) {
        m_split = split;
    }

    public boolean equals(Object object) {
        if (object instanceof DynamicRegularTimePeriod) {
            DynamicRegularTimePeriod period = (DynamicRegularTimePeriod) object;
            return this.getFirstMillisecond() == period.getFirstMillisecond() &&
                    this.getLastMillisecond() == period.getLastMillisecond();
        } else {
            return false;
        }
    }

    public int compareTo(Object o1) {
        if (o1 instanceof DynamicRegularTimePeriod) {
            DynamicRegularTimePeriod period = (DynamicRegularTimePeriod) o1;
            if (this.getFirstMillisecond() > period.getFirstMillisecond()) {
                return 1;
            } else if (this.getFirstMillisecond() == period.getFirstMillisecond()){
                return 0;
            } else {
                return -1;
            }
        } else if (o1 instanceof RegularTimePeriod) {
            return 0;
        } else {
            return 1;
        }
    }

    private DynamicRegularTimePeriod copy() {
        DynamicRegularTimePeriod newDynamic = new DynamicRegularTimePeriod();
        newDynamic.setDynamicRegularTimePeriod(m_regularTimePeriod, m_numOfSplits, m_split);
        return newDynamic;
    }
}

[medloh]

Digging up this very old post. I tried to use the code, but it no longer compiles. Assuming RegularTimePeriod must have changed some over the years.

I'd like to make or use a subclass of RegularTimePeriod. Currently I only need a 'QuarterHour' subclass but having a dynamic one might be nice. My current guess on how to make a QuarterHour subclass is to copy the code for Minute into a new subclass of RegularTimePeriod and then modify it to work like 15*Minute.

Before I got started I wanted to see if anyone could provide an example of making a custom subclass of RegularTimePeriod? Does it makes sense to create a new QuarterHour class based off Minute (or Hour)? My current need is for sizing the bars correctly in a bar chart, a bar every 15 minutes.