1:
43:
44: package ;
45:
46: import ;
47: import ;
48: import ;
49: import ;
50: import ;
51:
52: import ;
53: import ;
54: import ;
55:
56:
63: public class DefaultIntervalCategoryDataset extends AbstractSeriesDataset
64: implements IntervalCategoryDataset {
65:
66:
67: private Comparable[] seriesKeys;
68:
69:
70: private Comparable[] categoryKeys;
71:
72:
73: private Number[][] startData;
74:
75:
76: private Number[][] endData;
77:
78:
84: public DefaultIntervalCategoryDataset(double[][] starts, double[][] ends) {
85: this(DataUtilities.createNumberArray2D(starts),
86: DataUtilities.createNumberArray2D(ends));
87: }
88:
89:
100: public DefaultIntervalCategoryDataset(Number[][] starts, Number[][] ends) {
101: this(null, null, starts, ends);
102: }
103:
104:
115: public DefaultIntervalCategoryDataset(String[] seriesNames,
116: Number[][] starts,
117: Number[][] ends) {
118:
119: this(seriesNames, null, starts, ends);
120:
121: }
122:
123:
133: public DefaultIntervalCategoryDataset(Comparable[] seriesKeys,
134: Comparable[] categoryKeys,
135: Number[][] starts,
136: Number[][] ends) {
137:
138: this.startData = starts;
139: this.endData = ends;
140:
141: if (starts != null && ends != null) {
142:
143: String baseName = "org.jfree.data.resources.DataPackageResources";
144: ResourceBundle resources = ResourceBundle.getBundle(baseName);
145:
146: int seriesCount = starts.length;
147: if (seriesCount != ends.length) {
148: String errMsg = "DefaultIntervalCategoryDataset: the number "
149: + "of series in the start value dataset does "
150: + "not match the number of series in the end "
151: + "value dataset.";
152: throw new IllegalArgumentException(errMsg);
153: }
154: if (seriesCount > 0) {
155:
156:
157: if (seriesKeys != null) {
158:
159: if (seriesKeys.length != seriesCount) {
160: throw new IllegalArgumentException(
161: "The number of series keys does not "
162: + "match the number of series in the data.");
163: }
164:
165: this.seriesKeys = seriesKeys;
166: }
167: else {
168: String prefix = resources.getString(
169: "series.default-prefix") + " ";
170: this.seriesKeys = generateKeys(seriesCount, prefix);
171: }
172:
173:
174: int categoryCount = starts[0].length;
175: if (categoryCount != ends[0].length) {
176: String errMsg = "DefaultIntervalCategoryDataset: the "
177: + "number of categories in the start value "
178: + "dataset does not match the number of "
179: + "categories in the end value dataset.";
180: throw new IllegalArgumentException(errMsg);
181: }
182: if (categoryKeys != null) {
183: if (categoryKeys.length != categoryCount) {
184: throw new IllegalArgumentException(
185: "The number of category keys does not match "
186: + "the number of categories in the data.");
187: }
188: this.categoryKeys = categoryKeys;
189: }
190: else {
191: String prefix = resources.getString(
192: "categories.default-prefix") + " ";
193: this.categoryKeys = generateKeys(categoryCount, prefix);
194: }
195:
196: }
197: else {
198: this.seriesKeys = null;
199: this.categoryKeys = null;
200: }
201: }
202:
203: }
204:
205:
213: public int getSeriesCount() {
214: int result = 0;
215: if (this.startData != null) {
216: result = this.startData.length;
217: }
218: return result;
219: }
220:
221:
231: public int getSeriesIndex(Comparable seriesKey) {
232: int result = -1;
233: for (int i = 0; i < this.seriesKeys.length; i++) {
234: if (seriesKey.equals(this.seriesKeys[i])) {
235: result = i;
236: break;
237: }
238: }
239: return result;
240: }
241:
242:
251: public Comparable getSeriesKey(int series) {
252: if ((series >= getSeriesCount()) || (series < 0)) {
253: throw new IllegalArgumentException("No such series : " + series);
254: }
255: return this.seriesKeys[series];
256: }
257:
258:
267: public void setSeriesKeys(Comparable[] seriesKeys) {
268: if (seriesKeys == null) {
269: throw new IllegalArgumentException("Null 'seriesKeys' argument.");
270: }
271: if (seriesKeys.length != getSeriesCount()) {
272: throw new IllegalArgumentException(
273: "The number of series keys does not match the data.");
274: }
275: this.seriesKeys = seriesKeys;
276: fireDatasetChanged();
277: }
278:
279:
286: public int getCategoryCount() {
287: int result = 0;
288: if (this.startData != null) {
289: if (getSeriesCount() > 0) {
290: result = this.startData[0].length;
291: }
292: }
293: return result;
294: }
295:
296:
304: public List getColumnKeys() {
305:
306:
307: if (this.categoryKeys == null) {
308: return new ArrayList();
309: }
310: else {
311: return Collections.unmodifiableList(Arrays.asList(
312: this.categoryKeys));
313: }
314: }
315:
316:
325: public void setCategoryKeys(Comparable[] categoryKeys) {
326: if (categoryKeys == null) {
327: throw new IllegalArgumentException("Null 'categoryKeys' argument.");
328: }
329: if (categoryKeys.length != this.startData[0].length) {
330: throw new IllegalArgumentException(
331: "The number of categories does not match the data.");
332: }
333: for (int i = 0; i < categoryKeys.length; i++) {
334: if (categoryKeys[i] == null) {
335: throw new IllegalArgumentException(
336: "DefaultIntervalCategoryDataset.setCategoryKeys(): "
337: + "null category not permitted.");
338: }
339: }
340: this.categoryKeys = categoryKeys;
341: fireDatasetChanged();
342: }
343:
344:
357: public Number getValue(Comparable series, Comparable category) {
358: int seriesIndex = getSeriesIndex(series);
359: if (seriesIndex < 0) {
360: throw new UnknownKeyException("Unknown 'series' key.");
361: }
362: int itemIndex = getColumnIndex(category);
363: if (itemIndex < 0) {
364: throw new UnknownKeyException("Unknown 'category' key.");
365: }
366: return getValue(seriesIndex, itemIndex);
367: }
368:
369:
382: public Number getValue(int series, int category) {
383: return getEndValue(series, category);
384: }
385:
386:
397: public Number getStartValue(Comparable series, Comparable category) {
398: int seriesIndex = getSeriesIndex(series);
399: if (seriesIndex < 0) {
400: throw new UnknownKeyException("Unknown 'series' key.");
401: }
402: int itemIndex = getColumnIndex(category);
403: if (itemIndex < 0) {
404: throw new UnknownKeyException("Unknown 'category' key.");
405: }
406: return getStartValue(seriesIndex, itemIndex);
407: }
408:
409:
420: public Number getStartValue(int series, int category) {
421:
422:
423: if ((series < 0) || (series >= getSeriesCount())) {
424: throw new IllegalArgumentException(
425: "DefaultIntervalCategoryDataset.getValue(): "
426: + "series index out of range.");
427: }
428:
429: if ((category < 0) || (category >= getCategoryCount())) {
430: throw new IllegalArgumentException(
431: "DefaultIntervalCategoryDataset.getValue(): "
432: + "category index out of range.");
433: }
434:
435:
436: return this.startData[series][category];
437:
438: }
439:
440:
450: public Number getEndValue(Comparable series, Comparable category) {
451: int seriesIndex = getSeriesIndex(series);
452: if (seriesIndex < 0) {
453: throw new UnknownKeyException("Unknown 'series' key.");
454: }
455: int itemIndex = getColumnIndex(category);
456: if (itemIndex < 0) {
457: throw new UnknownKeyException("Unknown 'category' key.");
458: }
459: return getEndValue(seriesIndex, itemIndex);
460: }
461:
462:
472: public Number getEndValue(int series, int category) {
473: if ((series < 0) || (series >= getSeriesCount())) {
474: throw new IllegalArgumentException(
475: "DefaultIntervalCategoryDataset.getValue(): "
476: + "series index out of range.");
477: }
478:
479: if ((category < 0) || (category >= getCategoryCount())) {
480: throw new IllegalArgumentException(
481: "DefaultIntervalCategoryDataset.getValue(): "
482: + "category index out of range.");
483: }
484:
485: return this.endData[series][category];
486: }
487:
488:
498: public void setStartValue(int series, Comparable category, Number value) {
499:
500:
501: if ((series < 0) || (series > getSeriesCount() - 1)) {
502: throw new IllegalArgumentException(
503: "DefaultIntervalCategoryDataset.setValue: "
504: + "series outside valid range.");
505: }
506:
507:
508: int categoryIndex = getCategoryIndex(category);
509: if (categoryIndex < 0) {
510: throw new IllegalArgumentException(
511: "DefaultIntervalCategoryDataset.setValue: "
512: + "unrecognised category.");
513: }
514:
515:
516: this.startData[series][categoryIndex] = value;
517: fireDatasetChanged();
518:
519: }
520:
521:
531: public void setEndValue(int series, Comparable category, Number value) {
532:
533:
534: if ((series < 0) || (series > getSeriesCount() - 1)) {
535: throw new IllegalArgumentException(
536: "DefaultIntervalCategoryDataset.setValue: "
537: + "series outside valid range.");
538: }
539:
540:
541: int categoryIndex = getCategoryIndex(category);
542: if (categoryIndex < 0) {
543: throw new IllegalArgumentException(
544: "DefaultIntervalCategoryDataset.setValue: "
545: + "unrecognised category.");
546: }
547:
548:
549: this.endData[series][categoryIndex] = value;
550: fireDatasetChanged();
551:
552: }
553:
554:
563: public int getCategoryIndex(Comparable category) {
564: int result = -1;
565: for (int i = 0; i < this.categoryKeys.length; i++) {
566: if (category.equals(this.categoryKeys[i])) {
567: result = i;
568: break;
569: }
570: }
571: return result;
572: }
573:
574:
583: private Comparable[] generateKeys(int count, String prefix) {
584: Comparable[] result = new Comparable[count];
585: String name;
586: for (int i = 0; i < count; i++) {
587: name = prefix + (i + 1);
588: result[i] = name;
589: }
590: return result;
591: }
592:
593:
602: public Comparable getColumnKey(int column) {
603: return this.categoryKeys[column];
604: }
605:
606:
615: public int getColumnIndex(Comparable columnKey) {
616: if (columnKey == null) {
617: throw new IllegalArgumentException("Null 'columnKey' argument.");
618: }
619: return getCategoryIndex(columnKey);
620: }
621:
622:
631: public int getRowIndex(Comparable rowKey) {
632: return getSeriesIndex(rowKey);
633: }
634:
635:
643: public List getRowKeys() {
644:
645:
646: if (this.seriesKeys == null) {
647: return new java.util.ArrayList();
648: }
649: else {
650: return Collections.unmodifiableList(Arrays.asList(this.seriesKeys));
651: }
652: }
653:
654:
663: public Comparable getRowKey(int row) {
664: if ((row >= getRowCount()) || (row < 0)) {
665: throw new IllegalArgumentException(
666: "The 'row' argument is out of bounds.");
667: }
668: return this.seriesKeys[row];
669: }
670:
671:
680: public int getColumnCount() {
681: return this.categoryKeys.length;
682: }
683:
684:
692: public int getRowCount() {
693: return this.seriesKeys.length;
694: }
695:
696:
703: public boolean equals(Object obj) {
704: if (obj == this) {
705: return true;
706: }
707: if (!(obj instanceof DefaultIntervalCategoryDataset)) {
708: return false;
709: }
710: DefaultIntervalCategoryDataset that
711: = (DefaultIntervalCategoryDataset) obj;
712: if (!Arrays.equals(this.seriesKeys, that.seriesKeys)) {
713: return false;
714: }
715: if (!Arrays.equals(this.categoryKeys, that.categoryKeys)) {
716: return false;
717: }
718: if (!equal(this.startData, that.startData)) {
719: return false;
720: }
721: if (!equal(this.endData, that.endData)) {
722: return false;
723: }
724:
725: return true;
726: }
727:
728:
736: public Object clone() throws CloneNotSupportedException {
737: DefaultIntervalCategoryDataset clone
738: = (DefaultIntervalCategoryDataset) super.clone();
739: clone.categoryKeys = (Comparable[]) this.categoryKeys.clone();
740: clone.seriesKeys = (Comparable[]) this.seriesKeys.clone();
741: clone.startData = clone(this.startData);
742: clone.endData = clone(this.endData);
743: return clone;
744: }
745:
746:
754: private static boolean equal(Number[][] array1, Number[][] array2) {
755: if (array1 == null) {
756: return (array2 == null);
757: }
758: if (array2 == null) {
759: return false;
760: }
761: if (array1.length != array2.length) {
762: return false;
763: }
764: for (int i = 0; i < array1.length; i++) {
765: if (!Arrays.equals(array1[i], array2[i])) {
766: return false;
767: }
768: }
769: return true;
770: }
771:
772:
779: private static Number[][] clone(Number[][] array) {
780: if (array == null) {
781: throw new IllegalArgumentException("Null 'array' argument.");
782: }
783: Number[][] result = new Number[array.length][];
784: for (int i = 0; i < array.length; i++) {
785: Number[] child = array[i];
786: Number[] copychild = new Number[child.length];
787: System.arraycopy(child, 0, copychild, 0, child.length);
788: result[i] = copychild;
789: }
790: return result;
791: }
792:
793:
800: public List getSeries() {
801: if (this.seriesKeys == null) {
802: return new java.util.ArrayList();
803: }
804: else {
805: return Collections.unmodifiableList(Arrays.asList(this.seriesKeys));
806: }
807: }
808:
809:
816: public List getCategories() {
817: return getColumnKeys();
818: }
819:
820:
827: public int getItemCount() {
828: return this.categoryKeys.length;
829: }
830:
831: }