Java tutorial
/* * Copyright 2008 Google Inc. * * Licensed 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.google.gwt.core.ext.linker; import com.google.gwt.core.ext.Linker; import com.google.gwt.core.ext.TreeLogger; import com.google.gwt.core.ext.UnableToCompleteException; import com.google.gwt.dev.util.Util; import com.google.gwt.util.tools.Utility; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; /** * An artifact that will be emitted into the output. All EmittedArtifacts * contained in the {@link ArtifactSet} at the end of the Linking process will * be emitted by the compiler into the module's output directory. This type may * be extended by Linker providers to provide alternative implementations of * {@link #getContents(TreeLogger)}. * * TODO(bobv): provide a timestamp so we can make the time on output files match * that of input files? */ public abstract class EmittedArtifact extends Artifact<EmittedArtifact> { /** * Describes the visibility of an artifact. */ public enum Visibility { /** * A public artifact is something that may be served to clients. */ Public, /** * A private artifact is something that is only used during the build * process. */ Private { @Override public boolean matches(Visibility visibility) { switch (visibility) { case LegacyDeploy: case Private: return true; default: return false; } } }, /** * A deploy artifact is deployed to the server but is never served to the * client. */ Deploy { @Override public boolean matches(Visibility visibility) { switch (visibility) { case Deploy: case LegacyDeploy: return true; default: return false; } } }, /** * For legacy use only - used for artifacts that were previously marked as * private because they should not be delivered to the client, but actually * should be visible to the server. These artifacts will now be treated as * both Private and Deploy, so that existing build tools that expect to find * them in the output directory for Private artifacts will find them. * * New code should use Deploy instead. */ LegacyDeploy { @Override public boolean matches(Visibility visibility) { switch (visibility) { case Deploy: case LegacyDeploy: case Private: return true; default: return false; } } }; /** * Returns true if this visibility matches the requested visibility level, * dealing with the fact that {@link #LegacyDeploy} matches both * {@link #Private} and {@link #Deploy}. * * @param visibility * @return true if this visibility matches the requested level */ public boolean matches(Visibility visibility) { return this == visibility; } } private final String partialPath; /** * This is mutable because it has no effect on identity. */ private Visibility visibility; protected EmittedArtifact(Class<? extends Linker> linker, String partialPath) { super(linker); assert partialPath != null; this.partialPath = partialPath; visibility = Visibility.Public; } /** * Provides access to the contents of the EmittedResource. */ public abstract InputStream getContents(TreeLogger logger) throws UnableToCompleteException; /** * Returns the time, measured in milliseconds from the epoch, at which the * Artifact was last modified. This will be used to set the last-modified * timestamp on the files written to disk. * <p> * The default implementation always returns the current time. Subclasses * should override this method to provide a type-appropriate value. * * @return the time at which the Artifact was last modified */ public long getLastModified() { return System.currentTimeMillis(); } /** * Returns the partial path within the output directory of the * EmittedArtifact. */ public final String getPartialPath() { return partialPath; } /** * @return the visibility */ public Visibility getVisibility() { return visibility; } @Override public final int hashCode() { return getPartialPath().hashCode(); } /** * Returns whether or not the data contained in the EmittedArtifact should be * written into the module output directory or into an auxiliary directory. * <p> * EmittedArtifacts that return <code>true</code> for this method will not * be emitted into the normal module output location, but will instead be * written into a directory that is a sibling to the module output directory. * The partial path of the EmittedArtifact will be prepended with the * short-name of the Linker type that created the EmittedArtifact. * <p> * Private EmittedArtifacts are intended for resources that generally should * not be deployed to the server in the same location as the module * compilation artifacts. * * @deprecated use {@link #getVisibility()} instead */ @Deprecated public boolean isPrivate() { return visibility == Visibility.Private; } /** * Sets the private attribute of the EmittedResource. * * @param isPrivate true if this artifact is private * * @deprecated use {@link #setVisibility(Visibility)} instead */ @Deprecated public void setPrivate(boolean isPrivate) { this.visibility = isPrivate ? Visibility.Private : Visibility.Public; } /** * @param visibility the visibility to set */ public void setVisibility(Visibility visibility) { this.visibility = visibility; } @Override public String toString() { return getPartialPath(); } /** * Provides access to the contents of the EmittedResource. */ public void writeTo(TreeLogger logger, OutputStream out) throws UnableToCompleteException { try { InputStream in = getContents(logger); Util.copyNoClose(in, out); Utility.close(in); } catch (IOException e) { logger.log(TreeLogger.ERROR, "Unable to read or write stream", e); throw new UnableToCompleteException(); } } @Override protected final int compareToComparableArtifact(EmittedArtifact o) { return getPartialPath().compareTo(o.getPartialPath()); } @Override protected final Class<EmittedArtifact> getComparableArtifactType() { return EmittedArtifact.class; } }