The property's ID.

The property's type.

The property's value.

 protected Property() 
{

}

Creates an empty property. It must be filled using the set method to be usable.

 public Property(long id,
    long type,
    Object value) 
{
        this.id = id;
        this.type = type;
        this.value = value;
}

Creates a property.

Parameters:

id - the property's ID.

type - the property's type, see Variant .

value - the property's value. Only certain types are allowed, see Variant .

 public Property(long id,
    byte[] src,
    long offset,
    int length,
    int codepage) throws UnsupportedEncodingException 
{
        this.id = id;
        /*
         * ID 0 is a special case since it specifies a dictionary of
         * property IDs and property names.
         */
        if (id == 0)
        {
            value = readDictionary(src, offset, length, codepage);
            return;
        }
        int o = (int) offset;
        type = LittleEndian.getUInt(src, o);
        o += LittleEndian.INT_SIZE;
        try
        {
            value = VariantSupport.read(src, o, length, (int) type, codepage);
        }
        catch (UnsupportedVariantTypeException ex)
        {
            VariantSupport.writeUnsupportedTypeMessage(ex);
            value = ex.getValue();
        }
}

Creates a Property instance by reading its bytes from the property set stream.

Parameters:

id - The property's ID.

src - The bytes the property set stream consists of.

offset - The property's type/value pair's offset in the section.

length - The property's type/value pair's length in bytes.

codepage - The section's and thus the property's codepage. It is needed only when reading string values.

Throws:

UnsupportedEncodingException - if the specified codepage is not supported.

exception: UnsupportedEncodingException - if the specified codepage is not supported.

 public boolean equals(Object o) 
{
        if (!(o instanceof Property))
            return false;
        final Property p = (Property) o;
        final Object pValue = p.getValue();
        final long pId = p.getID();
        if (id != pId || (id != 0 && !typesAreEqual(type, p.getType())))
            return false;
        if (value == null && pValue == null)
            return true;
        if (value == null || pValue == null)
            return false;
        /* It's clear now that both values are non-null. */
        final Class valueClass = value.getClass();
        final Class pValueClass = pValue.getClass();
        if (!(valueClass.isAssignableFrom(pValueClass)) &&
            !(pValueClass.isAssignableFrom(valueClass)))
            return false;
        if (value instanceof byte[])
            return Util.equal((byte[]) value, (byte[]) pValue);
        return value.equals(pValue);
}

Compares two properties.

Please beware that a property with ID == 0 is a special case: It does not have a type, and its value is the section's dictionary. Another special case are strings: Two properties may have the different types Variant.VT_LPSTR and Variant.VT_LPWSTR;

 public long getID() 
{
        return id;
}

Returns the property's ID.

 protected int getSize() throws WritingNotSupportedException 
{
        int length = VariantSupport.getVariantLength(type);
        if (length  >= 0)
            return length; /* Fixed length */
        if (length == -2)
            /* Unknown length */
            throw new WritingNotSupportedException(type, null);
        /* Variable length: */
        final int PADDING = 4; /* Pad to multiples of 4. */
        switch ((int) type)
        {
            case Variant.VT_LPSTR:
            {
                int l = ((String) value).length() + 1;
                int r = l % PADDING;
                if (r  > 0)
                    l += PADDING - r;
                length += l;
                break;
            }
            case Variant.VT_EMPTY:
                break;
            default:
                throw new WritingNotSupportedException(type, value);
        }
        return length;
}

Returns the property's size in bytes. This is always a multiple of 4.

 public long getType() 
{
        return type;
}

Returns the property's type.

 public Object getValue() 
{
        return value;
}

Returns the property's value.

 public int hashCode() 
{
        long hashCode = 0;
        hashCode += id;
        hashCode += type;
        if (value != null)
            hashCode += value.hashCode();
        final int returnHashCode = (int) (hashCode & 0x0ffffffffL );
        return returnHashCode;
}

 protected Map readDictionary(byte[] src,
    long offset,
    int length,
    int codepage) throws UnsupportedEncodingException 
{
        /* Check whether "offset" points into the "src" array". */
        if (offset <  0 || offset  > src.length)
            throw new HPSFRuntimeException
                ("Illegal offset " + offset + " while HPSF stream contains " +
                 length + " bytes.");
        int o = (int) offset;
        /*
         * Read the number of dictionary entries.
         */
        final long nrEntries = LittleEndian.getUInt(src, o);
        o += LittleEndian.INT_SIZE;
        final Map m = new HashMap((int) nrEntries, (float) 1.0);
        try
        {
            for (int i = 0; i <  nrEntries; i++)
            {
                /* The key. */
                final Long id = new Long(LittleEndian.getUInt(src, o));
                o += LittleEndian.INT_SIZE;
                /* The value (a string). The length is the either the
                 * number of (two-byte) characters if the character set is Unicode
                 * or the number of bytes if the character set is not Unicode.
                 * The length includes terminating 0x00 bytes which we have to strip
                 * off to create a Java string. */
                long sLength = LittleEndian.getUInt(src, o);
                o += LittleEndian.INT_SIZE;
                /* Read the string. */
                final StringBuffer b = new StringBuffer();
                switch (codepage)
                {
                    case -1:
                    {
                        /* Without a codepage the length is equal to the number of
                         * bytes. */
                        b.append(new String(src, o, (int) sLength));
                        break;
                    }
                    case Constants.CP_UNICODE:
                    {
                        /* The length is the number of characters, i.e. the number
                         * of bytes is twice the number of the characters. */
                        final int nrBytes = (int) (sLength * 2);
                        final byte[] h = new byte[nrBytes];
                        for (int i2 = 0; i2 <  nrBytes; i2 += 2)
                        {
                            h[i2] = src[o + i2 + 1];
                            h[i2 + 1] = src[o + i2];
                        }
                        b.append(new String(h, 0, nrBytes,
                                VariantSupport.codepageToEncoding(codepage)));
                        break;
                    }
                    default:
                    {
                        /* For encodings other than Unicode the length is the number
                         * of bytes. */
                        b.append(new String(src, o, (int) sLength,
                                 VariantSupport.codepageToEncoding(codepage)));
                        break;
                    }
                }
                /* Strip 0x00 characters from the end of the string: */
                while (b.length()  > 0 && b.charAt(b.length() - 1) == 0x00)
                    b.setLength(b.length() - 1);
                if (codepage == Constants.CP_UNICODE)
                {
                    if (sLength % 2 == 1)
                        sLength++;
                    o += (sLength + sLength);
                }
                else
                    o += sLength;
                m.put(id, b.toString());
            }
        }
        catch (RuntimeException ex)
        {
            final POILogger l = POILogFactory.getLogger(getClass());
            l.log(POILogger.WARN,
                    "The property set's dictionary contains bogus data. "
                    + "All dictionary entries starting with the one with ID "
                    + id + " will be ignored.", ex);
        }
        return m;
}

Reads a dictionary.

 public String toString() 
{
        final StringBuffer b = new StringBuffer();
        b.append(getClass().getName());
        b.append('[");
        b.append("id: ");
        b.append(getID());
        b.append(", type: ");
        b.append(getType());
        final Object value = getValue();
        b.append(", value: ");
        b.append(value.toString());
        if (value instanceof String)
        {
            final String s = (String) value;
            final int l = s.length();
            final byte[] bytes = new byte[l * 2];
            for (int i = 0; i <  l; i++)
            {
                final char c = s.charAt(i);
                final byte high = (byte) ((c & 0x00ff00)  > > 8);
                final byte low  = (byte) ((c & 0x0000ff)  > > 0);
                bytes[i * 2]     = high;
                bytes[i * 2 + 1] = low;
            }
            final String hex = HexDump.dump(bytes, 0L, 0);
            b.append(" [");
            b.append(hex);
            b.append("]");
        }
        b.append(']");
        return b.toString();
}