1:
45:
46: package ;
47:
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53:
54: import ;
55: import ;
56: import ;
57:
58:
65: public class DefaultIntervalCategoryDataset extends AbstractSeriesDataset
66: implements IntervalCategoryDataset {
67:
68:
69: private Comparable[] seriesKeys;
70:
71:
72: private Comparable[] categoryKeys;
73:
74:
75: private Number[][] startData;
76:
77:
78: private Number[][] endData;
79:
80:
89: public DefaultIntervalCategoryDataset(double[][] starts, double[][] ends) {
90: this(DataUtilities.createNumberArray2D(starts),
91: DataUtilities.createNumberArray2D(ends));
92: }
93:
94:
105: public DefaultIntervalCategoryDataset(Number[][] starts, Number[][] ends) {
106: this(null, null, starts, ends);
107: }
108:
109:
121: public DefaultIntervalCategoryDataset(String[] seriesNames,
122: Number[][] starts,
123: Number[][] ends) {
124:
125: this(seriesNames, null, starts, ends);
126:
127: }
128:
129:
141: public DefaultIntervalCategoryDataset(Comparable[] seriesKeys,
142: Comparable[] categoryKeys,
143: Number[][] starts,
144: Number[][] ends) {
145:
146: this.startData = starts;
147: this.endData = ends;
148:
149: if (starts != null && ends != null) {
150:
151: String baseName = "org.jfree.data.resources.DataPackageResources";
152: ResourceBundle resources = ResourceBundle.getBundle(baseName);
153:
154: int seriesCount = starts.length;
155: if (seriesCount != ends.length) {
156: String errMsg = "DefaultIntervalCategoryDataset: the number "
157: + "of series in the start value dataset does "
158: + "not match the number of series in the end "
159: + "value dataset.";
160: throw new IllegalArgumentException(errMsg);
161: }
162: if (seriesCount > 0) {
163:
164:
165: if (seriesKeys != null) {
166:
167: if (seriesKeys.length != seriesCount) {
168: throw new IllegalArgumentException(
169: "The number of series keys does not "
170: + "match the number of series in the data.");
171: }
172:
173: this.seriesKeys = seriesKeys;
174: }
175: else {
176: String prefix = resources.getString(
177: "series.default-prefix") + " ";
178: this.seriesKeys = generateKeys(seriesCount, prefix);
179: }
180:
181:
182: int categoryCount = starts[0].length;
183: if (categoryCount != ends[0].length) {
184: String errMsg = "DefaultIntervalCategoryDataset: the "
185: + "number of categories in the start value "
186: + "dataset does not match the number of "
187: + "categories in the end value dataset.";
188: throw new IllegalArgumentException(errMsg);
189: }
190: if (categoryKeys != null) {
191: if (categoryKeys.length != categoryCount) {
192: throw new IllegalArgumentException(
193: "The number of category keys does not match "
194: + "the number of categories in the data.");
195: }
196: this.categoryKeys = categoryKeys;
197: }
198: else {
199: String prefix = resources.getString(
200: "categories.default-prefix") + " ";
201: this.categoryKeys = generateKeys(categoryCount, prefix);
202: }
203:
204: }
205: else {
206: this.seriesKeys = new Comparable[0];
207: this.categoryKeys = new Comparable[0];
208: }
209: }
210:
211: }
212:
213:
221: public int getSeriesCount() {
222: int result = 0;
223: if (this.startData != null) {
224: result = this.startData.length;
225: }
226: return result;
227: }
228:
229:
239: public int getSeriesIndex(Comparable seriesKey) {
240: int result = -1;
241: for (int i = 0; i < this.seriesKeys.length; i++) {
242: if (seriesKey.equals(this.seriesKeys[i])) {
243: result = i;
244: break;
245: }
246: }
247: return result;
248: }
249:
250:
259: public Comparable getSeriesKey(int series) {
260: if ((series >= getSeriesCount()) || (series < 0)) {
261: throw new IllegalArgumentException("No such series : " + series);
262: }
263: return this.seriesKeys[series];
264: }
265:
266:
275: public void setSeriesKeys(Comparable[] seriesKeys) {
276: if (seriesKeys == null) {
277: throw new IllegalArgumentException("Null 'seriesKeys' argument.");
278: }
279: if (seriesKeys.length != getSeriesCount()) {
280: throw new IllegalArgumentException(
281: "The number of series keys does not match the data.");
282: }
283: this.seriesKeys = seriesKeys;
284: fireDatasetChanged();
285: }
286:
287:
294: public int getCategoryCount() {
295: int result = 0;
296: if (this.startData != null) {
297: if (getSeriesCount() > 0) {
298: result = this.startData[0].length;
299: }
300: }
301: return result;
302: }
303:
304:
312: public List getColumnKeys() {
313:
314:
315: if (this.categoryKeys == null) {
316: return new ArrayList();
317: }
318: else {
319: return Collections.unmodifiableList(Arrays.asList(
320: this.categoryKeys));
321: }
322: }
323:
324:
333: public void setCategoryKeys(Comparable[] categoryKeys) {
334: if (categoryKeys == null) {
335: throw new IllegalArgumentException("Null 'categoryKeys' argument.");
336: }
337: if (categoryKeys.length != getCategoryCount()) {
338: throw new IllegalArgumentException(
339: "The number of categories does not match the data.");
340: }
341: for (int i = 0; i < categoryKeys.length; i++) {
342: if (categoryKeys[i] == null) {
343: throw new IllegalArgumentException(
344: "DefaultIntervalCategoryDataset.setCategoryKeys(): "
345: + "null category not permitted.");
346: }
347: }
348: this.categoryKeys = categoryKeys;
349: fireDatasetChanged();
350: }
351:
352:
365: public Number getValue(Comparable series, Comparable category) {
366: int seriesIndex = getSeriesIndex(series);
367: if (seriesIndex < 0) {
368: throw new UnknownKeyException("Unknown 'series' key.");
369: }
370: int itemIndex = getColumnIndex(category);
371: if (itemIndex < 0) {
372: throw new UnknownKeyException("Unknown 'category' key.");
373: }
374: return getValue(seriesIndex, itemIndex);
375: }
376:
377:
390: public Number getValue(int series, int category) {
391: return getEndValue(series, category);
392: }
393:
394:
405: public Number getStartValue(Comparable series, Comparable category) {
406: int seriesIndex = getSeriesIndex(series);
407: if (seriesIndex < 0) {
408: throw new UnknownKeyException("Unknown 'series' key.");
409: }
410: int itemIndex = getColumnIndex(category);
411: if (itemIndex < 0) {
412: throw new UnknownKeyException("Unknown 'category' key.");
413: }
414: return getStartValue(seriesIndex, itemIndex);
415: }
416:
417:
428: public Number getStartValue(int series, int category) {
429:
430:
431: if ((series < 0) || (series >= getSeriesCount())) {
432: throw new IllegalArgumentException(
433: "DefaultIntervalCategoryDataset.getValue(): "
434: + "series index out of range.");
435: }
436:
437: if ((category < 0) || (category >= getCategoryCount())) {
438: throw new IllegalArgumentException(
439: "DefaultIntervalCategoryDataset.getValue(): "
440: + "category index out of range.");
441: }
442:
443:
444: return this.startData[series][category];
445:
446: }
447:
448:
458: public Number getEndValue(Comparable series, Comparable category) {
459: int seriesIndex = getSeriesIndex(series);
460: if (seriesIndex < 0) {
461: throw new UnknownKeyException("Unknown 'series' key.");
462: }
463: int itemIndex = getColumnIndex(category);
464: if (itemIndex < 0) {
465: throw new UnknownKeyException("Unknown 'category' key.");
466: }
467: return getEndValue(seriesIndex, itemIndex);
468: }
469:
470:
480: public Number getEndValue(int series, int category) {
481: if ((series < 0) || (series >= getSeriesCount())) {
482: throw new IllegalArgumentException(
483: "DefaultIntervalCategoryDataset.getValue(): "
484: + "series index out of range.");
485: }
486:
487: if ((category < 0) || (category >= getCategoryCount())) {
488: throw new IllegalArgumentException(
489: "DefaultIntervalCategoryDataset.getValue(): "
490: + "category index out of range.");
491: }
492:
493: return this.endData[series][category];
494: }
495:
496:
506: public void setStartValue(int series, Comparable category, Number value) {
507:
508:
509: if ((series < 0) || (series > getSeriesCount() - 1)) {
510: throw new IllegalArgumentException(
511: "DefaultIntervalCategoryDataset.setValue: "
512: + "series outside valid range.");
513: }
514:
515:
516: int categoryIndex = getCategoryIndex(category);
517: if (categoryIndex < 0) {
518: throw new IllegalArgumentException(
519: "DefaultIntervalCategoryDataset.setValue: "
520: + "unrecognised category.");
521: }
522:
523:
524: this.startData[series][categoryIndex] = value;
525: fireDatasetChanged();
526:
527: }
528:
529:
539: public void setEndValue(int series, Comparable category, Number value) {
540:
541:
542: if ((series < 0) || (series > getSeriesCount() - 1)) {
543: throw new IllegalArgumentException(
544: "DefaultIntervalCategoryDataset.setValue: "
545: + "series outside valid range.");
546: }
547:
548:
549: int categoryIndex = getCategoryIndex(category);
550: if (categoryIndex < 0) {
551: throw new IllegalArgumentException(
552: "DefaultIntervalCategoryDataset.setValue: "
553: + "unrecognised category.");
554: }
555:
556:
557: this.endData[series][categoryIndex] = value;
558: fireDatasetChanged();
559:
560: }
561:
562:
571: public int getCategoryIndex(Comparable category) {
572: int result = -1;
573: for (int i = 0; i < this.categoryKeys.length; i++) {
574: if (category.equals(this.categoryKeys[i])) {
575: result = i;
576: break;
577: }
578: }
579: return result;
580: }
581:
582:
591: private Comparable[] generateKeys(int count, String prefix) {
592: Comparable[] result = new Comparable[count];
593: String name;
594: for (int i = 0; i < count; i++) {
595: name = prefix + (i + 1);
596: result[i] = name;
597: }
598: return result;
599: }
600:
601:
610: public Comparable getColumnKey(int column) {
611: return this.categoryKeys[column];
612: }
613:
614:
623: public int getColumnIndex(Comparable columnKey) {
624: if (columnKey == null) {
625: throw new IllegalArgumentException("Null 'columnKey' argument.");
626: }
627: return getCategoryIndex(columnKey);
628: }
629:
630:
639: public int getRowIndex(Comparable rowKey) {
640: return getSeriesIndex(rowKey);
641: }
642:
643:
651: public List getRowKeys() {
652:
653:
654: if (this.seriesKeys == null) {
655: return new java.util.ArrayList();
656: }
657: else {
658: return Collections.unmodifiableList(Arrays.asList(this.seriesKeys));
659: }
660: }
661:
662:
671: public Comparable getRowKey(int row) {
672: if ((row >= getRowCount()) || (row < 0)) {
673: throw new IllegalArgumentException(
674: "The 'row' argument is out of bounds.");
675: }
676: return this.seriesKeys[row];
677: }
678:
679:
688: public int getColumnCount() {
689: return this.categoryKeys.length;
690: }
691:
692:
700: public int getRowCount() {
701: return this.seriesKeys.length;
702: }
703:
704:
711: public boolean equals(Object obj) {
712: if (obj == this) {
713: return true;
714: }
715: if (!(obj instanceof DefaultIntervalCategoryDataset)) {
716: return false;
717: }
718: DefaultIntervalCategoryDataset that
719: = (DefaultIntervalCategoryDataset) obj;
720: if (!Arrays.equals(this.seriesKeys, that.seriesKeys)) {
721: return false;
722: }
723: if (!Arrays.equals(this.categoryKeys, that.categoryKeys)) {
724: return false;
725: }
726: if (!equal(this.startData, that.startData)) {
727: return false;
728: }
729: if (!equal(this.endData, that.endData)) {
730: return false;
731: }
732:
733: return true;
734: }
735:
736:
744: public Object clone() throws CloneNotSupportedException {
745: DefaultIntervalCategoryDataset clone
746: = (DefaultIntervalCategoryDataset) super.clone();
747: clone.categoryKeys = (Comparable[]) this.categoryKeys.clone();
748: clone.seriesKeys = (Comparable[]) this.seriesKeys.clone();
749: clone.startData = clone(this.startData);
750: clone.endData = clone(this.endData);
751: return clone;
752: }
753:
754:
762: private static boolean equal(Number[][] array1, Number[][] array2) {
763: if (array1 == null) {
764: return (array2 == null);
765: }
766: if (array2 == null) {
767: return false;
768: }
769: if (array1.length != array2.length) {
770: return false;
771: }
772: for (int i = 0; i < array1.length; i++) {
773: if (!Arrays.equals(array1[i], array2[i])) {
774: return false;
775: }
776: }
777: return true;
778: }
779:
780:
787: private static Number[][] clone(Number[][] array) {
788: if (array == null) {
789: throw new IllegalArgumentException("Null 'array' argument.");
790: }
791: Number[][] result = new Number[array.length][];
792: for (int i = 0; i < array.length; i++) {
793: Number[] child = array[i];
794: Number[] copychild = new Number[child.length];
795: System.arraycopy(child, 0, copychild, 0, child.length);
796: result[i] = copychild;
797: }
798: return result;
799: }
800:
801:
808: public List getSeries() {
809: if (this.seriesKeys == null) {
810: return new java.util.ArrayList();
811: }
812: else {
813: return Collections.unmodifiableList(Arrays.asList(this.seriesKeys));
814: }
815: }
816:
817:
824: public List getCategories() {
825: return getColumnKeys();
826: }
827:
828:
835: public int getItemCount() {
836: return this.categoryKeys.length;
837: }
838:
839: }