org.apache.oodt.xmlquery.LargeResult Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of oodt-product Show documentation

The Product Service provides access to data products. Products can be scientific datasets, images, documents, or anything with an electronic representation. The Product Service accepts standard query expressions (see the Query Expression component) and returns zero or more matching products. In addition, the product service can transform products from proprietary formats and into Internet standard formats or run other transformations, all without impacting local stores or operations.

There is a newer version: 1.0

Show newest version

/*
 * 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 org.apache.oodt.xmlquery;

import java.util.List;
import java.util.StringTokenizer;
import java.io.InputStream;
import java.io.IOException;

// FIXME: change MIME type application/vnd.jpl.large-product?

/**
 * A large result is a result for large products.
 *
 * What is large?  Some might say large is something that exceeds most other things of
 * like kind in bulk, capacity, quantity, superficial dimensions, or number of constituent
 * units.  Large might be big, great, capacious, extensive.  Large might be opposed to
 * small; as, a large horse; a large house or room; a large lake or pool; a large jug or
 * spoon; a large vineyard; a large army; a large city.  Some might say that particularly
 * if they're named Webster.
 *
 * @author Kelly
 * @version $Revision: 1.2 $
 */
public class LargeResult extends Result {
	/**
	 * Creates a new LargeResult instance.
	 *
	 * @param result a Result value.
	 */
	public LargeResult(Result result) {
		super(result.getID(), "application/vnd.jpl.large-product", result.getProfileID(), result.getResourceID(),
			result.getHeaders(), transformMimeType(result));
		StringTokenizer st = new StringTokenizer((String) value);
		st.nextToken();
		this.size = Long.parseLong(st.nextToken());
	}

	/**
	 * Creates a new LargeResult instance.
	 *
	 * @param id Result ID.
	 * @param mimeType MIME type.
	 * @param profileID Profile ID.
	 * @param resourceID Resource ID.
	 * @param headers Headers.
	 * @param size Size of the product.
	 */
	public LargeResult(String id, String mimeType, String profileID, String resourceID, List headers, long size) {
		super(id, "application/vnd.jpl.large-product", profileID, resourceID, headers, mimeType + " " + size);
		this.size = size;
	}

	/**
	 * Get the size of the product.
	 *
	 * @return Its size.
	 */
	public final long getSize() {
		return size;
	}

	public final String getMimeType() {
		return new StringTokenizer((String) value).nextToken();
	}

	/**
	 * Return the result's value.
	 *
	 * @return a String.
	 * @deprecated This method always treats its value as if it were a String.  Worse,
	 * for very large results, it cannot contain the entire result in memory.  Use
	 * {@link #getInputStream} instead to perform stream processing on result data.
	 */
	public final Object getValue() {
		Object value = null;
		InputStream in = null;
		try {
			if (size > Integer.MAX_VALUE) {
			  throw new IllegalStateException("Cannot use getValue() for this product, result is too large; "
											  + "use LargeResult.getInputStream instead");
			}
			int sizeToRead = (int) size;
			byte[] buf = new byte[sizeToRead];
			int index = 0;
			int num;
			in = getInputStream();
			while ((num = in.read(buf, index, sizeToRead)) != -1) {
				index += num;
				sizeToRead -= num;
				if (sizeToRead == 0) {
				  break;
				}
			}

			// OK, this sucks.  Sucks sucks sucks.  Look, getValue is not to
			// be used anyway.  It sucks.  But dammit, there's some annoying
			// code over in EDRN which is using it when they should be using
			// getInputStream.  Basically, if you call this, you're a hoser.
			// And if you call it and you're not expecting a String, you're a
			// loser/hoser.  DEPRECATED!
			value = new String(buf);

		} catch (IOException ex) {
			throw new IllegalStateException("Unexpected IOException: " + ex.getMessage());
		} finally {
			if (in != null) {
			  try {
				in.close();
			  } catch (IOException ignore) {
			  }
			}
		}
		return value;
	}

	/** Size of the product. */
	private long size;

	/**
	 * Get an input stream that streams the result from the product server.
	 *
	 * @return an InputStream value.
	 * @throws IOException if an error occurs.
	 */
	public InputStream getInputStream() throws IOException {
		return new ChunkedProductInputStream(id, retriever, size);
	}

	/**
	 * Given an existing Result yield its MIME type.
	 *
	 * The existing Result might be a LargeResult, in which
	 * case the real MIME type is hidden in the value.  Otherwise, it's directly in
	 * the object.
	 *
	 * @param result a Result value.
	 * @return The MIME type.
	 */
	private static String transformMimeType(Result result) {
		if ("application/vnd.jpl.large-product".equals(result.mimeType)) {
		  return (String) result.value;
		} else {
		  return result.mimeType + " 0";
		}
	}

	/** Serial version unique ID. */
	static final long serialVersionUID = -969838775595705444L;
}