140 lines
3.5 KiB
Java
140 lines
3.5 KiB
Java
package net.sf.jasperreports.crosstabs.fill.calculation;
|
|
|
|
import java.util.Comparator;
|
|
import net.sf.jasperreports.engine.JRException;
|
|
import org.apache.commons.collections.comparators.ReverseComparator;
|
|
|
|
public class BucketDefinition {
|
|
public static final byte ORDER_ASCENDING = 1;
|
|
|
|
public static final byte ORDER_DESCENDING = 2;
|
|
|
|
public static final byte TOTAL_POSITION_NONE = 0;
|
|
|
|
public static final byte TOTAL_POSITION_START = 1;
|
|
|
|
public static final byte TOTAL_POSITION_END = 2;
|
|
|
|
protected static final byte VALUE_TYPE_VALUE = 0;
|
|
|
|
protected static final byte VALUE_TYPE_NULL = 1;
|
|
|
|
protected static final byte VALUE_TYPE_TOTAL = 2;
|
|
|
|
protected final Bucket VALUE_TOTAL = new Bucket((byte)2);
|
|
|
|
protected final Bucket VALUE_NULL = new Bucket((byte)1);
|
|
|
|
protected final Comparator comparator;
|
|
|
|
private final byte totalPosition;
|
|
|
|
private boolean computeTotal;
|
|
|
|
public BucketDefinition(Class valueClass, Comparator comparator, byte order, byte totalPosition) throws JRException {
|
|
if (comparator == null && !Comparable.class.isAssignableFrom(valueClass))
|
|
throw new JRException("The bucket expression values are not comparable and no comparator specified.");
|
|
switch (order) {
|
|
case 2:
|
|
if (comparator == null) {
|
|
this.comparator = (Comparator)new ReverseComparator();
|
|
break;
|
|
}
|
|
this.comparator = (Comparator)new ReverseComparator(comparator);
|
|
break;
|
|
default:
|
|
this.comparator = comparator;
|
|
break;
|
|
}
|
|
this.totalPosition = totalPosition;
|
|
this.computeTotal = (totalPosition != 0);
|
|
}
|
|
|
|
public boolean computeTotal() {
|
|
return this.computeTotal;
|
|
}
|
|
|
|
public void setComputeTotal() {
|
|
this.computeTotal = true;
|
|
}
|
|
|
|
public byte getTotalPosition() {
|
|
return this.totalPosition;
|
|
}
|
|
|
|
public Comparator getComparator() {
|
|
return this.comparator;
|
|
}
|
|
|
|
public Bucket create(Object value) {
|
|
if (value == null)
|
|
return this.VALUE_NULL;
|
|
return new Bucket(value);
|
|
}
|
|
|
|
public class Bucket implements Comparable {
|
|
private final Object value;
|
|
|
|
private final byte type;
|
|
|
|
private final BucketDefinition this$0;
|
|
|
|
protected Bucket(byte type) {
|
|
this.value = null;
|
|
this.type = type;
|
|
}
|
|
|
|
protected Bucket(Object value) {
|
|
this.value = value;
|
|
this.type = 0;
|
|
}
|
|
|
|
public Object getValue() {
|
|
return this.value;
|
|
}
|
|
|
|
public boolean equals(Object o) {
|
|
if (o == null || !(o instanceof Bucket))
|
|
return false;
|
|
if (o == this)
|
|
return true;
|
|
Bucket v = (Bucket)o;
|
|
if (this.type != 0)
|
|
return (this.type == v.type);
|
|
return (v.type == 0 && this.value.equals(v.value));
|
|
}
|
|
|
|
public int hashCode() {
|
|
int hash = this.type;
|
|
if (this.type == 0)
|
|
hash = 37 * hash + this.value.hashCode();
|
|
return hash;
|
|
}
|
|
|
|
public String toString() {
|
|
switch (this.type) {
|
|
case 1:
|
|
return "NULL";
|
|
case 2:
|
|
return "TOTAL";
|
|
}
|
|
return String.valueOf(this.value);
|
|
}
|
|
|
|
public int compareTo(Object o) {
|
|
Bucket val = (Bucket)o;
|
|
if (this.type != val.type)
|
|
return this.type - val.type;
|
|
if (this.type != 0)
|
|
return 0;
|
|
if (BucketDefinition.this.comparator != null)
|
|
return BucketDefinition.this.comparator.compare(this.value, val.value);
|
|
return ((Comparable)this.value).compareTo(val.value);
|
|
}
|
|
|
|
public boolean isTotal() {
|
|
return (this.type == 2);
|
|
}
|
|
}
|
|
}
|