001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: *
017: */
018: package org.apache.tools.ant.types.resources;
019:
020: import java.io.IOException;
021: import java.io.InputStream;
022:
023: import org.apache.tools.ant.util.FileUtils;
024: import org.apache.tools.ant.types.Path;
025: import org.apache.tools.ant.types.Resource;
026: import org.apache.tools.ant.types.Reference;
027:
028: /**
029: * A Resource representation of something loadable via a Java classloader.
030: * @since Ant 1.7
031: */
032: public class JavaResource extends Resource {
033:
034: private Path classpath;
035: private Reference loader;
036:
037: /**
038: * Default constructor.
039: */
040: public JavaResource() {
041: }
042:
043: /**
044: * Construct a new JavaResource using the specified name and
045: * classpath.
046: *
047: * @param name the resource name.
048: * @param path the classpath.
049: */
050: public JavaResource(String name, Path path) {
051: setName(name);
052: classpath = path;
053: }
054:
055: /**
056: * Set the classpath to use when looking up a resource.
057: * @param classpath to add to any existing classpath
058: */
059: public void setClasspath(Path classpath) {
060: checkAttributesAllowed();
061: if (this .classpath == null) {
062: this .classpath = classpath;
063: } else {
064: this .classpath.append(classpath);
065: }
066: }
067:
068: /**
069: * Add a classpath to use when looking up a resource.
070: * @return The classpath to be configured
071: */
072: public Path createClasspath() {
073: checkChildrenAllowed();
074: if (this .classpath == null) {
075: this .classpath = new Path(getProject());
076: }
077: return this .classpath.createPath();
078: }
079:
080: /**
081: * Set the classpath to use when looking up a resource,
082: * given as reference to a <path> defined elsewhere
083: * @param r The reference value
084: */
085: public void setClasspathRef(Reference r) {
086: checkAttributesAllowed();
087: createClasspath().setRefid(r);
088: }
089:
090: /**
091: * get the classpath used by this <code>LoadProperties</code>.
092: * @return The classpath
093: */
094: public Path getClasspath() {
095: return isReference() ? ((JavaResource) getCheckedRef())
096: .getClasspath() : classpath;
097: }
098:
099: /**
100: * Use the reference to locate the loader. If the loader is not
101: * found, taskdef will use the specified classpath and register it
102: * with the specified name.
103: *
104: * This allow multiple taskdef/typedef to use the same class loader,
105: * so they can be used together. It eliminate the need to
106: * put them in the CLASSPATH.
107: *
108: * @param r the reference to locate the loader.
109: */
110: public void setLoaderRef(Reference r) {
111: checkAttributesAllowed();
112: loader = r;
113: }
114:
115: /**
116: * Overrides the super version.
117: * @param r the Reference to set.
118: */
119: public void setRefid(Reference r) {
120: if (loader != null || classpath != null) {
121: throw tooManyAttributes();
122: }
123: super .setRefid(r);
124: }
125:
126: /**
127: * Learn whether this file exists.
128: * @return true if this resource exists.
129: */
130: public boolean isExists() {
131: InputStream is = null;
132: try {
133: return isReference() ? ((Resource) getCheckedRef())
134: .isExists() : (is = getInputStream()) != null;
135: } catch (IOException ex) {
136: return false;
137: } finally {
138: FileUtils.close(is);
139: }
140: }
141:
142: /**
143: * Return an InputStream for reading the contents of this Resource.
144: * @return an InputStream object.
145: * @throws IOException if an error occurs.
146: */
147: public InputStream getInputStream() throws IOException {
148: if (isReference()) {
149: return ((Resource) getCheckedRef()).getInputStream();
150: }
151: ClassLoader cl = null;
152: if (loader != null) {
153: cl = (ClassLoader) loader.getReferencedObject();
154: }
155: if (cl == null) {
156: if (getClasspath() != null) {
157: cl = getProject().createClassLoader(classpath);
158: } else {
159: cl = JavaResource.class.getClassLoader();
160: }
161: if (loader != null && cl != null) {
162: getProject().addReference(loader.getRefId(), cl);
163: }
164: }
165:
166: return cl == null ? ClassLoader
167: .getSystemResourceAsStream(getName()) : cl
168: .getResourceAsStream(getName());
169: }
170:
171: /**
172: * Compare this JavaResource to another Resource.
173: * @param another the other Resource against which to compare.
174: * @return a negative integer, zero, or a positive integer as this
175: * JavaResource is less than, equal to, or greater than the
176: * specified Resource.
177: */
178: public int compareTo(Object another) {
179: if (isReference()) {
180: return ((Comparable) getCheckedRef()).compareTo(another);
181: }
182: if (another.getClass().equals(getClass())) {
183: JavaResource otherjr = (JavaResource) another;
184: if (!getName().equals(otherjr.getName())) {
185: return getName().compareTo(otherjr.getName());
186: }
187: if (loader != otherjr.loader) {
188: if (loader == null) {
189: return -1;
190: }
191: if (otherjr.loader == null) {
192: return 1;
193: }
194: return loader.getRefId().compareTo(
195: otherjr.loader.getRefId());
196: }
197: Path p = getClasspath();
198: Path op = otherjr.getClasspath();
199: if (p != op) {
200: if (p == null) {
201: return -1;
202: }
203: if (op == null) {
204: return 1;
205: }
206: return p.toString().compareTo(op.toString());
207: }
208: return 0;
209: }
210: return super.compareTo(another);
211: }
212:
213: }
|