| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| package com.sun.star.report; |
| |
| import com.sun.star.beans.PropertyVetoException; |
| import com.sun.star.beans.UnknownPropertyException; |
| import com.sun.star.beans.XPropertySet; |
| import com.sun.star.container.NoSuchElementException; |
| import com.sun.star.embed.ElementModes; |
| import com.sun.star.embed.InvalidStorageException; |
| import com.sun.star.embed.XStorage; |
| import com.sun.star.embed.XTransactedObject; |
| import com.sun.star.io.XStream; |
| import com.sun.star.lang.IllegalArgumentException; |
| import com.sun.star.lang.WrappedTargetException; |
| import com.sun.star.lib.uno.adapter.XInputStreamToInputStreamAdapter; |
| import com.sun.star.lib.uno.adapter.XOutputStreamToOutputStreamAdapter; |
| import com.sun.star.uno.UnoRuntime; |
| |
| import java.io.BufferedInputStream; |
| import java.io.BufferedOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| /** |
| * A directory holds all the contents here. |
| * |
| * |
| * @author Ocke Janssen |
| */ |
| public class StorageRepository implements InputRepository, OutputRepository |
| { |
| |
| private static final Log LOGGER = LogFactory.getLog(SDBCReportDataFactory.class); |
| private static final String REPORT_PROCESSING_FAILED = "ReportProcessing failed"; |
| private XStorage input; |
| private XStorage output; |
| private final String rootURL; |
| |
| /** |
| * |
| * @param input |
| * @param output |
| * @param rootURL |
| * @throws java.io.IOException |
| */ |
| public StorageRepository(final XStorage input, final XStorage output, final String rootURL) |
| { |
| this.input = input; |
| this.output = output; |
| this.rootURL = rootURL; |
| |
| } |
| |
| public StorageRepository(final XStorage storage, final boolean isOutput, final String rootURL) |
| { |
| this.rootURL = rootURL; |
| if (isOutput) |
| { |
| this.output = storage; |
| } |
| else |
| { |
| this.input = storage; |
| } |
| } |
| |
| public InputStream createInputStream(final String name) throws IOException |
| { |
| if (input == null) |
| { |
| throw new IOException("input is NULL"); |
| } |
| try |
| { |
| final XStream xStream = (XStream) UnoRuntime.queryInterface(XStream.class, input.openStreamElement(name, ElementModes.READ)); |
| return new BufferedInputStream(new XInputStreamToInputStreamAdapter(xStream.getInputStream()), 102400); |
| } |
| catch (com.sun.star.uno.Exception e) |
| { |
| throw new IOException("createInputStream"); |
| } |
| } |
| |
| /** |
| * Creates an output stream for writing the data. If there is an entry with |
| * that name already contained in the repository, try to overwrite it. |
| * |
| * @param name |
| * @param mimeType |
| * @return the outputstream |
| * @throws IOException if opening the stream fails |
| */ |
| public OutputStream createOutputStream(final String name, final String mimeType) throws IOException |
| { |
| if (output == null) |
| { |
| throw new IOException("output is NULL"); |
| } |
| try |
| { |
| final XStream stream = output.openStreamElement(name, ElementModes.WRITE | ElementModes.TRUNCATE); |
| stream.getInputStream().closeInput(); |
| if (mimeType != null) |
| { |
| final XPropertySet prop = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, stream); |
| prop.setPropertyValue("MediaType", mimeType); |
| } |
| return new BufferedOutputStream(new XOutputStreamToOutputStreamAdapter(stream.getOutputStream()), 204800); |
| } |
| catch (com.sun.star.uno.Exception e) |
| { |
| throw new IOException("createOutputStream"); |
| } |
| } |
| |
| public boolean exists(final String name) |
| { |
| try |
| { |
| return output.isStreamElement(name); |
| } |
| catch (InvalidStorageException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (com.sun.star.lang.IllegalArgumentException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (NoSuchElementException e) |
| { |
| // We expect this exception, no need to log it. |
| } |
| return false; |
| } |
| |
| public boolean isWritable(final String name) |
| { |
| return true; |
| } |
| |
| public Object getId() |
| { |
| return "1"; |
| } |
| |
| public long getVersion(final String name) |
| { |
| return 1; |
| } |
| |
| public boolean isReadable(final String name) |
| { |
| try |
| { |
| if (input != null) |
| { |
| return input.isStreamElement(name); |
| } |
| } |
| catch (InvalidStorageException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (com.sun.star.lang.IllegalArgumentException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (NoSuchElementException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| return false; |
| } |
| |
| public InputRepository openInputRepository(final String name) throws IOException |
| { |
| try |
| { |
| final String temp = shortenName(name); |
| if (!input.isStorageElement(temp)) |
| { |
| throw new IOException(); |
| } |
| final XStorage storage = (XStorage) UnoRuntime.queryInterface(XStorage.class, input.openStorageElement(temp, ElementModes.READ)); |
| return new StorageRepository(storage, false, rootURL); |
| } |
| catch (NoSuchElementException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (WrappedTargetException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (InvalidStorageException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (IllegalArgumentException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (com.sun.star.io.IOException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| throw new IOException(); |
| } |
| |
| final String shortenName(final String name) |
| { |
| final String temp; |
| if (name.startsWith("./")) |
| { |
| temp = name.substring(2); |
| } |
| else |
| { |
| temp = name; |
| } |
| return temp; |
| } |
| |
| public OutputRepository openOutputRepository(final String name, final String mimeType) throws IOException |
| { |
| try |
| { |
| final String temp = shortenName(name); |
| final XStorage storage = (XStorage) UnoRuntime.queryInterface(XStorage.class, output.openStorageElement(temp, ElementModes.WRITE)); |
| if (mimeType != null) |
| { |
| final XPropertySet prop = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, storage); |
| prop.setPropertyValue("MediaType", mimeType); |
| } |
| return new StorageRepository(storage, true, rootURL); |
| } |
| catch (UnknownPropertyException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (PropertyVetoException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (IllegalArgumentException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (WrappedTargetException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (InvalidStorageException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (com.sun.star.io.IOException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| |
| throw new IOException(); |
| } |
| |
| public void closeInputRepository() |
| { |
| if (input != null) |
| { |
| input.dispose(); |
| } |
| } |
| |
| public void closeOutputRepository() |
| { |
| if (output != null) |
| { |
| try |
| { |
| final XTransactedObject obj = (XTransactedObject) UnoRuntime.queryInterface(XTransactedObject.class, output); |
| if (obj != null) |
| { |
| obj.commit(); |
| } |
| } |
| catch (com.sun.star.io.IOException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (WrappedTargetException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| output.dispose(); |
| } |
| |
| } |
| |
| public boolean existsStorage(final String name) |
| { |
| try |
| { |
| return output.isStorageElement(name); |
| } |
| catch (InvalidStorageException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (com.sun.star.lang.IllegalArgumentException ex) |
| { |
| LOGGER.error(REPORT_PROCESSING_FAILED, ex); |
| } |
| catch (NoSuchElementException ex) |
| { |
| // We expect this exception, no need to log it. |
| } |
| return false; |
| } |
| |
| public String getRootURL() |
| { |
| return rootURL; |
| } |
| } |