public Manifest() 
{

}

Constructs a new, empty Manifest.

 public Manifest(InputStream is) throws IOException 
{
        read(is);
}

Constructs a new Manifest from the specified input stream.

Parameters:

is - the input stream containing manifest data

Throws:

IOException - if an I/O error has occured

 public Manifest(Manifest man) 
{
        attr.putAll(man.getMainAttributes());
        entries.putAll(man.getEntries());
}

Constructs a new Manifest that is a copy of the specified Manifest.

Parameters:

man - the Manifest to copy

 public  void clear() 
{
        attr.clear();
        entries.clear();
}

Clears the main Attributes as well as the entries in this Manifest.

 public Object clone() 
{
        return new Manifest(this);
}

Returns a shallow copy of this Manifest. The shallow copy is implemented as follows:

public Object clone() { return new Manifest(this); }

 public boolean equals(Object o) 
{
        if (o instanceof Manifest) {
            Manifest m = (Manifest)o;
            return attr.equals(m.getMainAttributes()) &&
                   entries.equals(m.getEntries());
        } else {
            return false;
        }
}

Returns true if the specified Object is also a Manifest and has the same main Attributes and entries.

 public Attributes getAttributes(String name) 
{
        return getEntries().get(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 #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 #getMainAttributes .

 public Map getEntries() 
{
        return entries;
}

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 #read , nor is such an entry written by using #write .

 public Attributes getMainAttributes() 
{
        return attr;
}

Returns the main Attributes for the Manifest.

 public int hashCode() 
{
        return attr.hashCode() + entries.hashCode();
}

Returns the hash code for this Manifest.

 static  void make72Safe(StringBuffer 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;
}

Adds line breaks to enforce a maximum 72 bytes per line.

 public  void read(InputStream is) throws IOException 
{
        // 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;
        }
}

Reads the Manifest from the specified InputStream. The entry names and attributes read will be merged in with the current manifest entries.

 public  void write(OutputStream out) throws IOException 
{
        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();
}

Writes the Manifest to the specified OutputStream. Attributes.Name.MANIFEST_VERSION must be set in MainAttributes prior to invoking this method.