1:
50:
51: package ;
52:
53: import ;
54: import ;
55: import ;
56:
57: import ;
58: import ;
59: import ;
60: import ;
61: import ;
62:
63:
67: public class TaskSeriesCollection extends AbstractSeriesDataset
68: implements GanttCategoryDataset, Cloneable, PublicCloneable,
69: Serializable {
70:
71:
72: private static final long serialVersionUID = -2065799050738449903L;
73:
74:
78: private List keys;
79:
80:
81: private List data;
82:
83:
86: public TaskSeriesCollection() {
87: this.keys = new java.util.ArrayList();
88: this.data = new java.util.ArrayList();
89: }
90:
91:
100: public TaskSeries getSeries(Comparable key) {
101: if (key == null) {
102: throw new NullPointerException("Null 'key' argument.");
103: }
104: TaskSeries result = null;
105: int index = getRowIndex(key);
106: if (index >= 0) {
107: result = getSeries(index);
108: }
109: return result;
110: }
111:
112:
121: public TaskSeries getSeries(int series) {
122: if ((series < 0) || (series >= getSeriesCount())) {
123: throw new IllegalArgumentException("Series index out of bounds");
124: }
125: return (TaskSeries) this.data.get(series);
126: }
127:
128:
133: public int getSeriesCount() {
134: return getRowCount();
135: }
136:
137:
144: public Comparable getSeriesKey(int series) {
145: TaskSeries ts = (TaskSeries) this.data.get(series);
146: return ts.getKey();
147: }
148:
149:
154: public int getRowCount() {
155: return this.data.size();
156: }
157:
158:
163: public List getRowKeys() {
164: return this.data;
165: }
166:
167:
172: public int getColumnCount() {
173: return this.keys.size();
174: }
175:
176:
181: public List getColumnKeys() {
182: return this.keys;
183: }
184:
185:
192: public Comparable getColumnKey(int index) {
193: return (Comparable) this.keys.get(index);
194: }
195:
196:
203: public int getColumnIndex(Comparable columnKey) {
204: if (columnKey == null) {
205: throw new IllegalArgumentException("Null 'columnKey' argument.");
206: }
207: return this.keys.indexOf(columnKey);
208: }
209:
210:
217: public int getRowIndex(Comparable rowKey) {
218: int result = -1;
219: int count = this.data.size();
220: for (int i = 0; i < count; i++) {
221: TaskSeries s = (TaskSeries) this.data.get(i);
222: if (s.getKey().equals(rowKey)) {
223: result = i;
224: break;
225: }
226: }
227: return result;
228: }
229:
230:
237: public Comparable getRowKey(int index) {
238: TaskSeries series = (TaskSeries) this.data.get(index);
239: return series.getKey();
240: }
241:
242:
249: public void add(TaskSeries series) {
250: if (series == null) {
251: throw new IllegalArgumentException("Null 'series' argument.");
252: }
253: this.data.add(series);
254: series.addChangeListener(this);
255:
256:
257: Iterator iterator = series.getTasks().iterator();
258: while (iterator.hasNext()) {
259: Task task = (Task) iterator.next();
260: String key = task.getDescription();
261: int index = this.keys.indexOf(key);
262: if (index < 0) {
263: this.keys.add(key);
264: }
265: }
266: fireDatasetChanged();
267: }
268:
269:
276: public void remove(TaskSeries series) {
277: if (series == null) {
278: throw new IllegalArgumentException("Null 'series' argument.");
279: }
280: if (this.data.contains(series)) {
281: series.removeChangeListener(this);
282: this.data.remove(series);
283: fireDatasetChanged();
284: }
285: }
286:
287:
294: public void remove(int series) {
295: if ((series < 0) || (series >= getSeriesCount())) {
296: throw new IllegalArgumentException(
297: "TaskSeriesCollection.remove(): index outside valid range.");
298: }
299:
300:
301: TaskSeries ts = (TaskSeries) this.data.get(series);
302: ts.removeChangeListener(this);
303: this.data.remove(series);
304: fireDatasetChanged();
305:
306: }
307:
308:
313: public void removeAll() {
314:
315:
316:
317: Iterator iterator = this.data.iterator();
318: while (iterator.hasNext()) {
319: TaskSeries series = (TaskSeries) iterator.next();
320: series.removeChangeListener(this);
321: }
322:
323:
324: this.data.clear();
325: fireDatasetChanged();
326:
327: }
328:
329:
337: public Number getValue(Comparable rowKey, Comparable columnKey) {
338: return getStartValue(rowKey, columnKey);
339: }
340:
341:
349: public Number getValue(int row, int column) {
350: return getStartValue(row, column);
351: }
352:
353:
362: public Number getStartValue(Comparable rowKey, Comparable columnKey) {
363: Number result = null;
364: int row = getRowIndex(rowKey);
365: TaskSeries series = (TaskSeries) this.data.get(row);
366: Task task = series.get(columnKey.toString());
367: if (task != null) {
368: TimePeriod duration = task.getDuration();
369: if (duration != null) {
370: result = new Long(duration.getStart().getTime());
371: }
372: }
373: return result;
374: }
375:
376:
384: public Number getStartValue(int row, int column) {
385: Comparable rowKey = getRowKey(row);
386: Comparable columnKey = getColumnKey(column);
387: return getStartValue(rowKey, columnKey);
388: }
389:
390:
399: public Number getEndValue(Comparable rowKey, Comparable columnKey) {
400: Number result = null;
401: int row = getRowIndex(rowKey);
402: TaskSeries series = (TaskSeries) this.data.get(row);
403: Task task = series.get(columnKey.toString());
404: if (task != null) {
405: TimePeriod duration = task.getDuration();
406: if (duration != null) {
407: result = new Long(duration.getEnd().getTime());
408: }
409: }
410: return result;
411: }
412:
413:
421: public Number getEndValue(int row, int column) {
422: Comparable rowKey = getRowKey(row);
423: Comparable columnKey = getColumnKey(column);
424: return getEndValue(rowKey, columnKey);
425: }
426:
427:
435: public Number getPercentComplete(int row, int column) {
436: Comparable rowKey = getRowKey(row);
437: Comparable columnKey = getColumnKey(column);
438: return getPercentComplete(rowKey, columnKey);
439: }
440:
441:
449: public Number getPercentComplete(Comparable rowKey, Comparable columnKey) {
450: Number result = null;
451: int row = getRowIndex(rowKey);
452: TaskSeries series = (TaskSeries) this.data.get(row);
453: Task task = series.get(columnKey.toString());
454: if (task != null) {
455: result = task.getPercentComplete();
456: }
457: return result;
458: }
459:
460:
468: public int getSubIntervalCount(int row, int column) {
469: Comparable rowKey = getRowKey(row);
470: Comparable columnKey = getColumnKey(column);
471: return getSubIntervalCount(rowKey, columnKey);
472: }
473:
474:
482: public int getSubIntervalCount(Comparable rowKey, Comparable columnKey) {
483: int result = 0;
484: int row = getRowIndex(rowKey);
485: TaskSeries series = (TaskSeries) this.data.get(row);
486: Task task = series.get(columnKey.toString());
487: if (task != null) {
488: result = task.getSubtaskCount();
489: }
490: return result;
491: }
492:
493:
502: public Number getStartValue(int row, int column, int subinterval) {
503: Comparable rowKey = getRowKey(row);
504: Comparable columnKey = getColumnKey(column);
505: return getStartValue(rowKey, columnKey, subinterval);
506: }
507:
508:
517: public Number getStartValue(Comparable rowKey, Comparable columnKey,
518: int subinterval) {
519: Number result = null;
520: int row = getRowIndex(rowKey);
521: TaskSeries series = (TaskSeries) this.data.get(row);
522: Task task = series.get(columnKey.toString());
523: if (task != null) {
524: Task sub = task.getSubtask(subinterval);
525: if (sub != null) {
526: TimePeriod duration = sub.getDuration();
527: result = new Long(duration.getStart().getTime());
528: }
529: }
530: return result;
531: }
532:
533:
542: public Number getEndValue(int row, int column, int subinterval) {
543: Comparable rowKey = getRowKey(row);
544: Comparable columnKey = getColumnKey(column);
545: return getEndValue(rowKey, columnKey, subinterval);
546: }
547:
548:
557: public Number getEndValue(Comparable rowKey, Comparable columnKey,
558: int subinterval) {
559: Number result = null;
560: int row = getRowIndex(rowKey);
561: TaskSeries series = (TaskSeries) this.data.get(row);
562: Task task = series.get(columnKey.toString());
563: if (task != null) {
564: Task sub = task.getSubtask(subinterval);
565: if (sub != null) {
566: TimePeriod duration = sub.getDuration();
567: result = new Long(duration.getEnd().getTime());
568: }
569: }
570: return result;
571: }
572:
573:
582: public Number getPercentComplete(int row, int column, int subinterval) {
583: Comparable rowKey = getRowKey(row);
584: Comparable columnKey = getColumnKey(column);
585: return getPercentComplete(rowKey, columnKey, subinterval);
586: }
587:
588:
597: public Number getPercentComplete(Comparable rowKey, Comparable columnKey,
598: int subinterval) {
599: Number result = null;
600: int row = getRowIndex(rowKey);
601: TaskSeries series = (TaskSeries) this.data.get(row);
602: Task task = series.get(columnKey.toString());
603: if (task != null) {
604: Task sub = task.getSubtask(subinterval);
605: if (sub != null) {
606: result = sub.getPercentComplete();
607: }
608: }
609: return result;
610: }
611:
612:
617: public void seriesChanged(SeriesChangeEvent event) {
618: refreshKeys();
619: fireDatasetChanged();
620: }
621:
622:
625: private void refreshKeys() {
626:
627: this.keys.clear();
628: for (int i = 0; i < getSeriesCount(); i++) {
629: TaskSeries series = (TaskSeries) this.data.get(i);
630:
631: Iterator iterator = series.getTasks().iterator();
632: while (iterator.hasNext()) {
633: Task task = (Task) iterator.next();
634: String key = task.getDescription();
635: int index = this.keys.indexOf(key);
636: if (index < 0) {
637: this.keys.add(key);
638: }
639: }
640: }
641:
642: }
643:
644:
651: public boolean equals(Object obj) {
652: if (obj == this) {
653: return true;
654: }
655: if (!(obj instanceof TaskSeriesCollection)) {
656: return false;
657: }
658: TaskSeriesCollection that = (TaskSeriesCollection) obj;
659: if (!ObjectUtilities.equal(this.data, that.data)) {
660: return false;
661: }
662: return true;
663: }
664:
665:
673: public Object clone() throws CloneNotSupportedException {
674: TaskSeriesCollection clone = (TaskSeriesCollection) super.clone();
675: clone.data = (List) ObjectUtilities.deepClone(this.data);
676: clone.keys = new java.util.ArrayList(this.keys);
677: return clone;
678: }
679:
680: }