/// <summary> /// Initializes a new instance of the <see cref="Property"/> class. /// </summary> /// <param name="id">The property's ID.</param> /// <param name="src">The bytes the property Set stream consists of.</param> /// <param name="offset">The property's type/value pair's offset in the /// section.</param> /// <param name="Length">The property's type/value pair's Length in bytes.</param> /// <param name="codepage">The section's and thus the property's /// codepage. It is needed only when Reading string values</param> public Property(long id, byte[] src, long offset, int Length, int codepage) { 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 += LittleEndianConsts.INT_SIZE; try { value = VariantSupport.Read(src, o, Length, (int)type, codepage); } catch (UnsupportedVariantTypeException ex) { VariantSupport.WriteUnsupportedTypeMessage(ex); value = ex.Value; } }
/** * Writes an array of {@link Property} instances To an output stream * according To the Horrible Property Format. * * @param out The stream To Write To * @param properties The array To Write To the stream * @param codepage The codepage number To use for writing strings * @exception IOException if an I/O error occurs * @throws UnsupportedVariantTypeException if HPSF does not support some * variant type. */ public static void WriteToStream(Stream out1, Property[] properties, int codepage) { /* If there are no properties don't Write anything. */ if (properties == null) { return; } /* Write the property list. This is a list containing pairs of property * ID and offset into the stream. */ for (int i = 0; i < properties.Length; i++) { Property p = properties[i]; WriteUIntToStream(out1, (uint)p.ID); WriteUIntToStream(out1, (uint)p.Count); } /* Write the properties themselves. */ for (int i = 0; i < properties.Length; i++) { Property p = properties[i]; long type = p.Type; WriteUIntToStream(out1, (uint)type); VariantSupport.Write(out1, (int)type, p.Value, codepage); } }
/// <summary> /// Writes the property To an output stream. /// </summary> /// <param name="out1">The output stream To Write To.</param> /// <param name="codepage">The codepage To use for writing non-wide strings</param> /// <returns>the number of bytes written To the stream</returns> public int Write(Stream out1, int codepage) { int length = 0; long variantType = this.Type; /* Ensure that wide strings are written if the codepage is Unicode. */ if (codepage == CodePageUtil.CP_UNICODE && variantType == Variant.VT_LPSTR) { variantType = Variant.VT_LPWSTR; } length += TypeWriter.WriteUIntToStream(out1, (uint)variantType); length += VariantSupport.Write(out1, variantType, this.Value, codepage); return(length); }