| Methods Summary |
|---|
| public void | clear()Clears the main Attributes as well as the entries in this Manifest.
attr.clear();
entries.clear();
|
| public java.lang.Object | clone()Returns a shallow copy of this Manifest. The shallow copy is
implemented as follows:
public Object clone() { return new Manifest(this); }
return new Manifest(this);
|
| public boolean | equals(java.lang.Object o)Returns true if the specified Object is also a Manifest and has
the same main Attributes and entries.
if (o instanceof Manifest) {
Manifest m = (Manifest)o;
return attr.equals(m.getMainAttributes()) &&
entries.equals(m.getEntries());
} else {
return false;
}
|
| public java.util.jar.Attributes | getAttributes(java.lang.String name)Returns the Attributes for the specified entry name.
This method is defined as:
return (Attributes)getEntries().get(name)
Though {@code null} is a valid {@code name}, when
{@code getAttributes(null)} is invoked on a {@code Manifest}
obtained from a jar file, {@code null} will be returned. While jar
files themselves do not allow {@code null}-named attributes, it is
possible to invoke {@link #getEntries} on a {@code Manifest}, and
on that result, invoke {@code put} with a null key and an
arbitrary value. Subsequent invocations of
{@code getAttributes(null)} will return the just-{@code put}
value.
Note that this method does not return the manifest's main attributes;
see {@link #getMainAttributes}.
return (Attributes)getEntries().get(name);
|
| public java.util.Map | getEntries()Returns a Map of the entries contained in this Manifest. Each entry
is represented by a String name (key) and associated Attributes (value).
The Map permits the {@code null} key, but no entry with a null key is
created by {@link #read}, nor is such an entry written by using {@link
#write}.
return entries;
|
| public java.util.jar.Attributes | getMainAttributes()Returns the main Attributes for the Manifest.
return attr;
|
| public int | hashCode()Returns the hash code for this Manifest.
return attr.hashCode() + entries.hashCode();
|
| static void | make72Safe(java.lang.StringBuffer line)Adds line breaks to enforce a maximum 72 bytes per line.
int length = line.length();
if (length > 72) {
int index = 70;
while (index < length - 2) {
line.insert(index, "\r\n ");
index += 72;
length += 3;
}
}
return;
|
| private java.lang.String | parseName(byte[] lbuf, int len)
if (toLower(lbuf[0]) == 'n" && toLower(lbuf[1]) == 'a" &&
toLower(lbuf[2]) == 'm" && toLower(lbuf[3]) == 'e" &&
lbuf[4] == ':" && lbuf[5] == ' ") {
try {
return new String(lbuf, 6, len - 6, "UTF8");
}
catch (Exception e) {
}
}
return null;
|
| public void | read(java.io.InputStream is)Reads the Manifest from the specified InputStream. The entry
names and attributes read will be merged in with the current
manifest entries.
// Buffered input stream for reading manifest data
FastInputStream fis = new FastInputStream(is);
// Line buffer
byte[] lbuf = new byte[512];
// Read the main attributes for the manifest
attr.read(fis, lbuf);
// Total number of entries, attributes read
int ecount = 0, acount = 0;
// Average size of entry attributes
int asize = 2;
// Now parse the manifest entries
int len;
String name = null;
boolean skipEmptyLines = true;
byte[] lastline = null;
while ((len = fis.readLine(lbuf)) != -1) {
if (lbuf[--len] != '\n") {
throw new IOException("manifest line too long");
}
if (len > 0 && lbuf[len-1] == '\r") {
--len;
}
if (len == 0 && skipEmptyLines) {
continue;
}
skipEmptyLines = false;
if (name == null) {
name = parseName(lbuf, len);
if (name == null) {
throw new IOException("invalid manifest format");
}
if (fis.peek() == ' ") {
// name is wrapped
lastline = new byte[len - 6];
System.arraycopy(lbuf, 6, lastline, 0, len - 6);
continue;
}
} else {
// continuation line
byte[] buf = new byte[lastline.length + len - 1];
System.arraycopy(lastline, 0, buf, 0, lastline.length);
System.arraycopy(lbuf, 1, buf, lastline.length, len - 1);
if (fis.peek() == ' ") {
// name is wrapped
lastline = buf;
continue;
}
name = new String(buf, 0, buf.length, "UTF8");
lastline = null;
}
Attributes attr = getAttributes(name);
if (attr == null) {
attr = new Attributes(asize);
entries.put(name, attr);
}
attr.read(fis, lbuf);
ecount++;
acount += attr.size();
//XXX: Fix for when the average is 0. When it is 0,
// you get an Attributes object with an initial
// capacity of 0, which tickles a bug in HashMap.
asize = Math.max(2, acount / ecount);
name = null;
skipEmptyLines = true;
}
|
| private int | toLower(int c)
return (c >= 'A" && c <= 'Z") ? 'a" + (c - 'A") : c;
|
| public void | write(java.io.OutputStream out)Writes the Manifest to the specified OutputStream.
Attributes.Name.MANIFEST_VERSION must be set in
MainAttributes prior to invoking this method.
DataOutputStream dos = new DataOutputStream(out);
// Write out the main attributes for the manifest
attr.writeMain(dos);
// Now write out the pre-entry attributes
Iterator it = entries.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
StringBuffer buffer = new StringBuffer("Name: ");
String value = (String)e.getKey();
if (value != null) {
byte[] vb = value.getBytes("UTF8");
value = new String(vb, 0, 0, vb.length);
}
buffer.append(value);
buffer.append("\r\n");
make72Safe(buffer);
dos.writeBytes(buffer.toString());
((Attributes)e.getValue()).write(dos);
}
dos.flush();
|
