Propertypublic class Property extends Object A property in a {@link Section} of a {@link PropertySet}.
The property's ID gives the property a meaning
in the context of its {@link Section}. Each {@link Section} spans
its own name space of property IDs.
The property's type determines how its
value is interpreted. For example, if the type is
{@link Variant#VT_LPSTR} (byte string), the value consists of a
DWord telling how many bytes the string contains. The bytes follow
immediately, including any null bytes that terminate the
string. The type {@link Variant#VT_I4} denotes a four-byte integer
value, {@link Variant#VT_FILETIME} some date and time (of a
file).
Please note that not all {@link Variant} types yet. This might change
over time but largely depends on your feedback so that the POI team knows
which variant types are really needed. So please feel free to submit error
reports or patches for the types you need.
Microsoft documentation:
Property Set Display Name Dictionary. |
| Fields Summary |
|---|
| protected long | id The property's ID. | | protected long | type The property's type. | | protected Object | value The property's value. |
| Constructors Summary |
|---|
public Property(long id, long type, Object value)Creates a property.
this.id = id;
this.type = type;
this.value = value;
| public Property(long id, byte[] src, long offset, int length, int codepage)Creates a {@link Property} instance by reading its bytes
from the property set stream.
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();
}
| protected Property()Creates an empty property. It must be filled using the set method to
be usable.
|
| Methods Summary |
|---|
| public boolean | equals(java.lang.Object o)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;
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);
| | public long | getID()Returns the property's ID.
return id;
| | protected int | getSize()Returns the property's size in bytes. This is always a multiple of
4.
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;
| | public long | getType()Returns the property's type.
return type;
| | public java.lang.Object | getValue()Returns the property's value.
return 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 java.util.Map | readDictionary(byte[] src, long offset, int length, int codepage)Reads a dictionary.
/* 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);
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());
}
return m;
| | public java.lang.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();
| | private boolean | typesAreEqual(long t1, long t2)
if (t1 == t2 ||
(t1 == Variant.VT_LPSTR && t2 == Variant.VT_LPWSTR) ||
(t2 == Variant.VT_LPSTR && t1 == Variant.VT_LPWSTR))
return true;
else
return false;
|
|
