The "byteOrder" field must equal this value.

Specifies this PropertySet 's byte order. See the HPFS documentation for details!

The "format" field must equal this value.

Specifies this PropertySet 's format. See the HPFS documentation for details!

Specifies the version of the operating system that created this PropertySet . See the HPFS documentation for details!

If the OS version field holds this value the property set stream was created on a 16-bit Windows system.

If the OS version field holds this value the property set stream was created on a Macintosh system.

If the OS version field holds this value the property set stream was created on a 32-bit Windows system.

Specifies this PropertySet 's "classID" field. See the HPFS documentation for details!

The sections in this PropertySet .

 protected PropertySet() 
{

}

Creates an empty (uninitialized) PropertySet .

Please note: For the time being this constructor is protected since it is used for internal purposes only, but expect it to become public once the property set's writing functionality is implemented.

 public PropertySet(InputStream stream) throws IOException, NoPropertySetStreamException, MarkUnsupportedException, UnsupportedEncodingException 
{
        if (isPropertySetStream(stream))
        {
            final int avail = stream.available();
            final byte[] buffer = new byte[avail];
            stream.read(buffer, 0, buffer.length);
            init(buffer, 0, buffer.length);
        }
        else
            throw new NoPropertySetStreamException();
}

Creates a PropertySet instance from an InputStream in the Horrible Property Set Format.

The constructor reads the first few bytes from the stream and determines whether it is really a property set stream. If it is, it parses the rest of the stream. If it is not, it resets the stream to its beginning in order to let other components mess around with the data and throws an exception.

Parameters:

stream - Holds the data making out the property set stream.

Throws:

MarkUnsupportedException - if the stream does not support the InputStream#markSupported method.

IOException - if the InputStream cannot not be accessed as needed.

NoPropertySetStreamException - if the input stream does not contain a property set.

UnsupportedEncodingException - if a character encoding is not supported.

exception: NoPropertySetStreamException - if the input stream does not contain a property set.

exception: UnsupportedEncodingException - if a character encoding is not supported.

 public PropertySet(byte[] stream) throws NoPropertySetStreamException, UnsupportedEncodingException 
{
        this(stream, 0, stream.length);
}

Creates a PropertySet instance from a byte array that represents a stream in the Horrible Property Set Format.

Parameters:

stream - The byte array holding the stream data. The complete byte array contents is the stream data.

Throws:

NoPropertySetStreamException - if the byte array is not a property set stream.

UnsupportedEncodingException - if the codepage is not supported.

exception: UnsupportedEncodingException - if the codepage is not supported.

 public PropertySet(byte[] stream,
    int offset,
    int length) throws NoPropertySetStreamException, UnsupportedEncodingException 
{
        if (isPropertySetStream(stream, offset, length))
            init(stream, offset, length);
        else
            throw new NoPropertySetStreamException();
}

Creates a PropertySet instance from a byte array that represents a stream in the Horrible Property Set Format.

Parameters:

stream - The byte array holding the stream data.

offset - The offset in stream where the stream data begin. If the stream data begin with the first byte in the array, the offset is 0.

length - The length of the stream data.

Throws:

NoPropertySetStreamException - if the byte array is not a property set stream.

UnsupportedEncodingException - if the codepage is not supported.

exception: UnsupportedEncodingException - if the codepage is not supported.

 public boolean equals(Object o) 
{
        if (o == null || !(o instanceof PropertySet))
            return false;
        final PropertySet ps = (PropertySet) o;
        int byteOrder1 = ps.getByteOrder();
        int byteOrder2 = getByteOrder();
        ClassID classID1 = ps.getClassID();
        ClassID classID2 = getClassID();
        int format1 = ps.getFormat();
        int format2 = getFormat();
        int osVersion1 = ps.getOSVersion();
        int osVersion2 = getOSVersion();
        int sectionCount1 = ps.getSectionCount();
        int sectionCount2 = getSectionCount();
        if (byteOrder1 != byteOrder2      ||
            !classID1.equals(classID2)    ||
            format1 != format2            ||
            osVersion1 != osVersion2      ||
            sectionCount1 != sectionCount2)
            return false;
        /* Compare the sections: */
        return Util.equals(getSections(), ps.getSections());
}

Returns true if the PropertySet is equal to the specified parameter, else false.

 public int getByteOrder() 
{
                                
        return byteOrder;
}

Returns the property set stream's low-level "byte order" field. It is always 0xFFFE .

 public ClassID getClassID() 
{
        return classID;
}

Returns the property set stream's low-level "class ID" field.

 public Section getFirstSection() 
{
        if (getSectionCount() <  1)
            throw new MissingSectionException("Property set does not contain any sections.");
        return ((Section) sections.get(0));
}

Gets the PropertySet 's first section.

 public int getFormat() 
{
                              
        return format;
}

Returns the property set stream's low-level "format" field. It is always 0x0000 .

 public int getOSVersion() 
{
                           
        return osVersion;
}

Returns the property set stream's low-level "OS version" field.

 public Property[] getProperties() throws NoSingleSectionException 
{
        return getFirstSection().getProperties();
}

Convenience method returning the Property array contained in this property set. It is a shortcut for getting the PropertySet 's Section s list and then getting the Property array from the first Section .

 protected Object getProperty(int id) throws NoSingleSectionException 
{
        return getFirstSection().getProperty(id);
}

Convenience method returning the value of the property with the specified ID. If the property is not available, null is returned and a subsequent call to #wasNull will return true .

 protected boolean getPropertyBooleanValue(int id) throws NoSingleSectionException 
{
        return getFirstSection().getPropertyBooleanValue(id);
}

Convenience method returning the value of a boolean property with the specified ID. If the property is not available, false is returned. A subsequent call to #wasNull will return true to let the caller distinguish that case from a real property value of false.

 protected int getPropertyIntValue(int id) throws NoSingleSectionException 
{
        return getFirstSection().getPropertyIntValue(id);
}

Convenience method returning the value of the numeric property with the specified ID. If the property is not available, 0 is returned. A subsequent call to #wasNull will return true to let the caller distinguish that case from a real property value of 0.

 public int getSectionCount() 
{
        return sections.size();
}

Returns the number of Section s in the property set.

 public List getSections() 
{
        return sections;
}

Returns the Section s in the property set.

 public Section getSingleSection() 
{
        final int sectionCount = getSectionCount();
        if (sectionCount != 1)
            throw new NoSingleSectionException
                ("Property set contains " + sectionCount + " sections.");
        return ((Section) sections.get(0));
}

If the PropertySet has only a single section this method returns it.

 public int hashCode() 
{
        throw new UnsupportedOperationException("FIXME: Not yet implemented.");
}

 public boolean isDocumentSummaryInformation() 
{
        if (sections.size() < = 0)
            return false;
        return Util.equal(((Section) sections.get(0)).getFormatID().getBytes(),
                          SectionIDMap.DOCUMENT_SUMMARY_INFORMATION_ID[0]);
}

Checks whether this PropertySet is a Document Summary Information.

 public static boolean isPropertySetStream(InputStream stream) throws IOException, MarkUnsupportedException 
{
        /*
         * Read at most this many bytes.
         */
        final int BUFFER_SIZE = 50;
        /*
         * Mark the current position in the stream so that we can
         * reset to this position if the stream does not contain a
         * property set.
         */
        if (!stream.markSupported())
            throw new MarkUnsupportedException(stream.getClass().getName());
        stream.mark(BUFFER_SIZE);
        /*
         * Read a couple of bytes from the stream.
         */
        final byte[] buffer = new byte[BUFFER_SIZE];
        final int bytes =
            stream.read(buffer, 0,
                        Math.min(buffer.length, stream.available()));
        final boolean isPropertySetStream =
            isPropertySetStream(buffer, 0, bytes);
        stream.reset();
        return isPropertySetStream;
}

Checks whether an InputStream is in the Horrible Property Set Format.

 public static boolean isPropertySetStream(byte[] src,
    int offset,
    int length) 
{
        /* FIXME (3): Ensure that at most "length" bytes are read. */
        /*
         * Read the header fields of the stream. They must always be
         * there.
         */
        int o = offset;
        final int byteOrder = LittleEndian.getUShort(src, o);
        o += LittleEndian.SHORT_SIZE;
        byte[] temp = new byte[LittleEndian.SHORT_SIZE];
        LittleEndian.putShort(temp, (short) byteOrder);
        if (!Util.equal(temp, BYTE_ORDER_ASSERTION))
            return false;
        final int format = LittleEndian.getUShort(src, o);
        o += LittleEndian.SHORT_SIZE;
        temp = new byte[LittleEndian.SHORT_SIZE];
        LittleEndian.putShort(temp, (short) format);
        if (!Util.equal(temp, FORMAT_ASSERTION))
            return false;
        // final long osVersion = LittleEndian.getUInt(src, offset);
        o += LittleEndian.INT_SIZE;
        // final ClassID classID = new ClassID(src, offset);
        o += ClassID.LENGTH;
        final long sectionCount = LittleEndian.getUInt(src, o);
        o += LittleEndian.INT_SIZE;
        if (sectionCount <  0)
            return false;
        return true;
}

Checks whether a byte array is in the Horrible Property Set Format.

 public boolean isSummaryInformation() 
{
        if (sections.size() < = 0)
            return false;
        return Util.equal(((Section) sections.get(0)).getFormatID().getBytes(),
                          SectionIDMap.SUMMARY_INFORMATION_ID);
}

Checks whether this PropertySet represents a Summary Information.

 public String toString() 
{
        final StringBuffer b = new StringBuffer();
        final int sectionCount = getSectionCount();
        b.append(getClass().getName());
        b.append('[");
        b.append("byteOrder: ");
        b.append(getByteOrder());
        b.append(", classID: ");
        b.append(getClassID());
        b.append(", format: ");
        b.append(getFormat());
        b.append(", OSVersion: ");
        b.append(getOSVersion());
        b.append(", sectionCount: ");
        b.append(sectionCount);
        b.append(", sections: [\n");
        final List sections = getSections();
        for (int i = 0; i <  sectionCount; i++)
            b.append(((Section) sections.get(i)).toString());
        b.append(']");
        b.append(']");
        return b.toString();
}

 public boolean wasNull() throws NoSingleSectionException 
{
        return getFirstSection().wasNull();
}

Checks whether the property which the last call to #getPropertyIntValue or #getProperty tried to access was available or not. This information might be important for callers of #getPropertyIntValue since the latter returns 0 if the property does not exist. Using #wasNull , the caller can distiguish this case from a property's real value of 0.