440 lines
15 KiB
Java
440 lines
15 KiB
Java
package net.sf.jasperreports.engine.base;
|
|
|
|
import java.awt.Graphics2D;
|
|
import java.awt.geom.Dimension2D;
|
|
import java.awt.geom.Rectangle2D;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.io.Serializable;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Random;
|
|
import java.util.Set;
|
|
import net.sf.jasperreports.engine.JRException;
|
|
import net.sf.jasperreports.engine.JRPrintElement;
|
|
import net.sf.jasperreports.engine.JRPrintFrame;
|
|
import net.sf.jasperreports.engine.JRPrintImage;
|
|
import net.sf.jasperreports.engine.JRPrintPage;
|
|
import net.sf.jasperreports.engine.JRRenderable;
|
|
import net.sf.jasperreports.engine.JRRuntimeException;
|
|
import net.sf.jasperreports.engine.JRVirtualizable;
|
|
import net.sf.jasperreports.engine.JRVirtualizationHelper;
|
|
import net.sf.jasperreports.engine.JRVirtualizer;
|
|
import net.sf.jasperreports.engine.JasperPrint;
|
|
import net.sf.jasperreports.engine.fill.JRTemplateElement;
|
|
import net.sf.jasperreports.engine.fill.JRTemplatePrintElement;
|
|
import net.sf.jasperreports.engine.fill.JRVirtualizationContext;
|
|
import org.apache.commons.logging.Log;
|
|
import org.apache.commons.logging.LogFactory;
|
|
|
|
public class JRVirtualPrintPage implements JRPrintPage, JRVirtualizable, Serializable {
|
|
protected static final Log log = LogFactory.getLog(JRVirtualPrintPage.class);
|
|
|
|
private static final long serialVersionUID = 10200L;
|
|
|
|
public static class ObjectIDPair implements Serializable {
|
|
private static final long serialVersionUID = 10200L;
|
|
|
|
private final Object o;
|
|
|
|
private final int id;
|
|
|
|
public ObjectIDPair(Object o) {
|
|
this.o = o;
|
|
this.id = System.identityHashCode(o);
|
|
}
|
|
|
|
public Object getObject() {
|
|
return this.o;
|
|
}
|
|
|
|
public int getIdentity() {
|
|
return this.id;
|
|
}
|
|
}
|
|
|
|
private static final Random random = new Random(System.currentTimeMillis());
|
|
|
|
private static short counter = 1;
|
|
|
|
protected List elements = new ArrayList();
|
|
|
|
private String uid;
|
|
|
|
private transient JRVirtualizer virtualizer;
|
|
|
|
private transient IdentityDataProvider[] identityProviders;
|
|
|
|
protected JRVirtualizationContext virtualizationContext;
|
|
|
|
public JRVirtualPrintPage(JasperPrint printObject, JRVirtualizer virtualizer, JRVirtualizationContext virtualizationContext) {
|
|
this.virtualizationContext = virtualizationContext;
|
|
this.uid = makeUID(printObject);
|
|
this.virtualizer = virtualizer;
|
|
this.identityProviders = null;
|
|
if (virtualizer != null)
|
|
virtualizer.registerObject(this);
|
|
}
|
|
|
|
private static String makeUID(JasperPrint printObject) {
|
|
synchronized (random) {
|
|
counter = (short)(counter + 1);
|
|
return Integer.toString(System.identityHashCode(printObject)) + "_" + printObject.getPages().size() + "_" + Integer.toString(counter) + "_" + Integer.toString(random.nextInt());
|
|
}
|
|
}
|
|
|
|
public final String getUID() {
|
|
return this.uid;
|
|
}
|
|
|
|
public void setVirtualData(Object o) {
|
|
this.elements = (List)o;
|
|
}
|
|
|
|
public Object getVirtualData() {
|
|
return this.elements;
|
|
}
|
|
|
|
public void removeVirtualData() {
|
|
this.elements = null;
|
|
}
|
|
|
|
public void setIdentityData(Object o) {
|
|
if (this.identityProviders != null)
|
|
for (int i = 0; i < this.identityProviders.length; i++)
|
|
this.identityProviders[i].setIdentityData(this, (ObjectIDPair[])o);
|
|
}
|
|
|
|
public Object getIdentityData() {
|
|
ObjectIDPair[] data;
|
|
if (this.identityProviders != null) {
|
|
if (this.identityProviders.length == 1) {
|
|
data = this.identityProviders[0].getIdentityData(this);
|
|
} else if (this.identityProviders.length > 1) {
|
|
Set list = new HashSet();
|
|
for (int i = 0; i < this.identityProviders.length; i++) {
|
|
ObjectIDPair[] pairs = this.identityProviders[i].getIdentityData(this);
|
|
if (pairs != null)
|
|
for (int j = 0; j < pairs.length; j++)
|
|
list.add(pairs[j]);
|
|
}
|
|
data = list.<ObjectIDPair>toArray(new ObjectIDPair[list.size()]);
|
|
} else {
|
|
data = null;
|
|
}
|
|
} else {
|
|
data = null;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
public boolean isVirtualized() {
|
|
return (this.elements == null);
|
|
}
|
|
|
|
public void setVirtualizer(JRVirtualizer virtualizer) {
|
|
this.virtualizer = virtualizer;
|
|
}
|
|
|
|
public JRVirtualizer getVirtualizer() {
|
|
return this.virtualizer;
|
|
}
|
|
|
|
public void addIdentityDataProvider(IdentityDataProvider p) {
|
|
if (this.identityProviders == null) {
|
|
this.identityProviders = new IdentityDataProvider[] { p };
|
|
} else {
|
|
IdentityDataProvider[] newList = new IdentityDataProvider[this.identityProviders.length + 1];
|
|
System.arraycopy(this.identityProviders, 0, newList, 0, this.identityProviders.length);
|
|
newList[this.identityProviders.length] = p;
|
|
this.identityProviders = newList;
|
|
}
|
|
}
|
|
|
|
public void removeIdentityDataProvider(IdentityDataProvider p) {
|
|
if (this.identityProviders != null)
|
|
for (int idx = 0; idx < this.identityProviders.length; idx++) {
|
|
if (this.identityProviders[idx] == p) {
|
|
IdentityDataProvider[] newList = new IdentityDataProvider[this.identityProviders.length - 1];
|
|
System.arraycopy(this.identityProviders, 0, newList, 0, idx);
|
|
int remaining = this.identityProviders.length - idx - 1;
|
|
if (remaining > 0)
|
|
System.arraycopy(this.identityProviders, idx + 1, newList, idx, remaining);
|
|
this.identityProviders = newList;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public List getElements() {
|
|
ensureVirtualData();
|
|
return this.elements;
|
|
}
|
|
|
|
protected void ensureVirtualData() {
|
|
if (this.virtualizer != null)
|
|
this.virtualizer.requestData(this);
|
|
}
|
|
|
|
public void setElements(List elements) {
|
|
cleanVirtualData();
|
|
this.elements = elements;
|
|
cacheInContext(this.elements);
|
|
}
|
|
|
|
protected void cleanVirtualData() {
|
|
if (this.virtualizer != null)
|
|
this.virtualizer.clearData(this);
|
|
}
|
|
|
|
public void addElement(JRPrintElement element) {
|
|
ensureVirtualData();
|
|
this.elements.add(element);
|
|
cacheInContext(element);
|
|
}
|
|
|
|
public static interface IdentityDataProvider {
|
|
JRVirtualPrintPage.ObjectIDPair[] getIdentityData(JRVirtualPrintPage param1JRVirtualPrintPage);
|
|
|
|
void setIdentityData(JRVirtualPrintPage param1JRVirtualPrintPage, JRVirtualPrintPage.ObjectIDPair[] param1ArrayOfObjectIDPair);
|
|
}
|
|
|
|
protected static class JRIdHolderRenderer implements JRRenderable, Serializable {
|
|
private static final long serialVersionUID = 10200L;
|
|
|
|
protected final String id;
|
|
|
|
protected JRIdHolderRenderer(JRRenderable renderer) {
|
|
this.id = renderer.getId();
|
|
}
|
|
|
|
public String getId() {
|
|
return this.id;
|
|
}
|
|
|
|
public byte getType() {
|
|
return 0;
|
|
}
|
|
|
|
public byte getImageType() {
|
|
return 0;
|
|
}
|
|
|
|
public Dimension2D getDimension() throws JRException {
|
|
return null;
|
|
}
|
|
|
|
public byte[] getImageData() throws JRException {
|
|
return null;
|
|
}
|
|
|
|
public void render(Graphics2D grx, Rectangle2D rectanle) throws JRException {}
|
|
}
|
|
|
|
protected static class JRIdHolderTemplateElement extends JRTemplateElement {
|
|
private static final long serialVersionUID = 10200L;
|
|
|
|
protected JRIdHolderTemplateElement(String id) {
|
|
super(id);
|
|
}
|
|
}
|
|
|
|
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
|
|
this.uid = (String)in.readObject();
|
|
this.virtualizationContext = (JRVirtualizationContext)in.readObject();
|
|
int length = in.readInt();
|
|
byte[] buffer = new byte[length];
|
|
in.readFully(buffer);
|
|
ByteArrayInputStream inputStream = new ByteArrayInputStream(buffer, 0, buffer.length);
|
|
ObjectInputStream elementsStream = new ObjectInputStream(inputStream);
|
|
this.elements = (List)elementsStream.readObject();
|
|
afterInternalization();
|
|
setThreadVirtualizer();
|
|
}
|
|
|
|
private void writeObject(ObjectOutputStream out) throws IOException {
|
|
ensureVirtualData();
|
|
beforeExternalization();
|
|
try {
|
|
out.writeObject(this.uid);
|
|
out.writeObject(this.virtualizationContext);
|
|
ByteArrayOutputStream bout = new ByteArrayOutputStream();
|
|
ObjectOutputStream stream = new ObjectOutputStream(bout);
|
|
stream.writeObject(this.elements);
|
|
stream.flush();
|
|
byte[] bytes = bout.toByteArray();
|
|
out.writeInt(bytes.length);
|
|
out.write(bytes);
|
|
} finally {
|
|
afterExternalization();
|
|
}
|
|
}
|
|
|
|
private void setThreadVirtualizer() {
|
|
JRVirtualizer threadVirtualizer = JRVirtualizationHelper.getThreadVirtualizer();
|
|
if (threadVirtualizer != null) {
|
|
this.virtualizer = threadVirtualizer;
|
|
this.virtualizer.registerObject(this);
|
|
}
|
|
}
|
|
|
|
protected void finalize() {
|
|
if (this.virtualizer != null)
|
|
this.virtualizer.deregisterObject(this);
|
|
}
|
|
|
|
protected List getDeepElements() {
|
|
List deepElements = new ArrayList(this.elements.size());
|
|
collectDeepElements(this.elements, deepElements);
|
|
return deepElements;
|
|
}
|
|
|
|
protected void collectDeepElements(List elementsList, List deepElements) {
|
|
for (Iterator it = elementsList.iterator(); it.hasNext(); ) {
|
|
JRPrintElement element = it.next();
|
|
deepElements.add(element);
|
|
if (element instanceof JRPrintFrame) {
|
|
JRPrintFrame frame = (JRPrintFrame)element;
|
|
collectDeepElements(frame.getElements(), deepElements);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void beforeExternalization() {
|
|
setElementsExternalData();
|
|
}
|
|
|
|
protected void setElementsExternalData() {
|
|
traverseDeepElements(new ExternalizationElementVisitor());
|
|
}
|
|
|
|
protected void setExternalizationRenderer(JRPrintImage image) {
|
|
JRRenderable renderer = image.getRenderer();
|
|
if (renderer != null && this.virtualizationContext.hasCachedRenderer(renderer.getId()))
|
|
image.setRenderer(new JRIdHolderRenderer(renderer));
|
|
}
|
|
|
|
protected void cacheInContext(List elementList) {
|
|
if (elementList != null && !elementList.isEmpty())
|
|
for (Iterator it = elementList.iterator(); it.hasNext(); ) {
|
|
JRPrintElement element = it.next();
|
|
cacheInContext(element);
|
|
}
|
|
}
|
|
|
|
protected void cacheInContext(JRPrintElement element) {
|
|
if (element instanceof JRTemplatePrintElement) {
|
|
JRTemplatePrintElement templateElement = (JRTemplatePrintElement)element;
|
|
JRTemplateElement template = templateElement.getTemplate();
|
|
if (template != null)
|
|
this.virtualizationContext.cacheTemplate(template);
|
|
}
|
|
if (element instanceof JRPrintFrame) {
|
|
JRPrintFrame frame = (JRPrintFrame)element;
|
|
cacheInContext(frame.getElements());
|
|
}
|
|
}
|
|
|
|
public void afterInternalization() {
|
|
restoreElementsData();
|
|
}
|
|
|
|
protected void restoreElementsData() {
|
|
traverseDeepElements(new InternalizationElementVisitor());
|
|
}
|
|
|
|
public JRVirtualizationContext getContext() {
|
|
return this.virtualizationContext;
|
|
}
|
|
|
|
public void afterExternalization() {
|
|
restoreElementsData();
|
|
}
|
|
|
|
protected void traverseDeepElements(ElementVisitor visitor) {
|
|
traverseDeepElements(visitor, this.elements);
|
|
}
|
|
|
|
protected void traverseDeepElements(ElementVisitor visitor, List elementsList) {
|
|
for (Iterator it = elementsList.iterator(); it.hasNext(); ) {
|
|
JRPrintElement element = it.next();
|
|
visitor.visitElement(element);
|
|
if (element instanceof JRPrintFrame) {
|
|
JRPrintFrame frame = (JRPrintFrame)element;
|
|
traverseDeepElements(visitor, frame.getElements());
|
|
}
|
|
}
|
|
}
|
|
|
|
protected static interface ElementVisitor {
|
|
void visitElement(JRPrintElement param1JRPrintElement);
|
|
}
|
|
|
|
protected class ExternalizationElementVisitor implements ElementVisitor {
|
|
private final Map idTemplates = new HashMap();
|
|
|
|
private final JRVirtualPrintPage this$0;
|
|
|
|
public void visitElement(JRPrintElement element) {
|
|
if (element instanceof JRTemplatePrintElement)
|
|
setExternalizationTemplate((JRTemplatePrintElement)element);
|
|
if (element instanceof JRPrintImage)
|
|
JRVirtualPrintPage.this.setExternalizationRenderer((JRPrintImage)element);
|
|
}
|
|
|
|
protected void setExternalizationTemplate(JRTemplatePrintElement templateElement) {
|
|
JRTemplateElement template = templateElement.getTemplate();
|
|
if (template != null)
|
|
if (JRVirtualPrintPage.this.virtualizationContext.hasCachedTemplate(template.getId())) {
|
|
String templateId = template.getId();
|
|
JRVirtualPrintPage.JRIdHolderTemplateElement idTemplate = (JRVirtualPrintPage.JRIdHolderTemplateElement)this.idTemplates.get(templateId);
|
|
if (idTemplate == null) {
|
|
idTemplate = new JRVirtualPrintPage.JRIdHolderTemplateElement(templateId);
|
|
this.idTemplates.put(templateId, idTemplate);
|
|
}
|
|
templateElement.setTemplate(idTemplate);
|
|
} else if (JRVirtualPrintPage.log.isDebugEnabled()) {
|
|
JRVirtualPrintPage.log.debug("Template " + template + " having id " + template.getId() + " not found in virtualization context cache");
|
|
}
|
|
}
|
|
}
|
|
|
|
protected class InternalizationElementVisitor implements ElementVisitor {
|
|
private final JRVirtualPrintPage this$0;
|
|
|
|
public void visitElement(JRPrintElement element) {
|
|
if (element instanceof JRTemplatePrintElement)
|
|
restoreTemplate((JRTemplatePrintElement)element);
|
|
if (element instanceof JRPrintImage)
|
|
restoreRenderer((JRPrintImage)element);
|
|
}
|
|
|
|
protected void restoreTemplate(JRTemplatePrintElement element) {
|
|
JRTemplateElement template = element.getTemplate();
|
|
if (template != null && template instanceof JRVirtualPrintPage.JRIdHolderTemplateElement) {
|
|
JRTemplateElement cachedTemplate = JRVirtualPrintPage.this.virtualizationContext.getCachedTemplate(template.getId());
|
|
if (cachedTemplate == null)
|
|
throw new JRRuntimeException("Template " + template.getId() + " not found in virtualization context.");
|
|
element.setTemplate(cachedTemplate);
|
|
}
|
|
}
|
|
|
|
protected void restoreRenderer(JRPrintImage image) {
|
|
JRRenderable renderer = image.getRenderer();
|
|
if (renderer != null && renderer instanceof JRVirtualPrintPage.JRIdHolderRenderer) {
|
|
JRRenderable cachedRenderer = JRVirtualPrintPage.this.virtualizationContext.getCachedRenderer(renderer.getId());
|
|
if (cachedRenderer == null)
|
|
throw new JRRuntimeException("Renderer " + renderer.getId() + " not found in virtualization context.");
|
|
image.setRenderer(cachedRenderer);
|
|
}
|
|
}
|
|
}
|
|
}
|