protected Property() 
{
           
        _raw_data = new byte[ POIFSConstants.PROPERTY_SIZE ];
        Arrays.fill(_raw_data, _default_fill);
        _name_size         = new ShortField(_name_size_offset);
        _property_type     =
            new ByteField(PropertyConstants.PROPERTY_TYPE_OFFSET);
        _node_color        = new ByteField(_node_color_offset);
        _previous_property = new IntegerField(_previous_property_offset,
                                              _NO_INDEX, _raw_data);
        _next_property     = new IntegerField(_next_property_offset,
                                              _NO_INDEX, _raw_data);
        _child_property    = new IntegerField(_child_property_offset,
                                              _NO_INDEX, _raw_data);
        _storage_clsid     = new ClassID(_raw_data,_storage_clsid_offset);
        _user_flags        = new IntegerField(_user_flags_offset, 0, _raw_data);
        _seconds_1         = new IntegerField(_seconds_1_offset, 0,
                                              _raw_data);
        _days_1            = new IntegerField(_days_1_offset, 0, _raw_data);
        _seconds_2         = new IntegerField(_seconds_2_offset, 0,
                                              _raw_data);
        _days_2            = new IntegerField(_days_2_offset, 0, _raw_data);
        _start_block       = new IntegerField(_start_block_offset);
        _size              = new IntegerField(_size_offset, 0, _raw_data);
        _index             = _NO_INDEX;
        setName("");
        setNextChild(null);
        setPreviousChild(null);
}

Default constructor

 protected Property(int index,
    byte[] array,
    int offset) 
{
        _raw_data = new byte[ POIFSConstants.PROPERTY_SIZE ];
        System.arraycopy(array, offset, _raw_data, 0,
                         POIFSConstants.PROPERTY_SIZE);
        _name_size         = new ShortField(_name_size_offset, _raw_data);
        _property_type     =
            new ByteField(PropertyConstants.PROPERTY_TYPE_OFFSET, _raw_data);
        _node_color        = new ByteField(_node_color_offset, _raw_data);
        _previous_property = new IntegerField(_previous_property_offset,
                                              _raw_data);
        _next_property     = new IntegerField(_next_property_offset,
                                              _raw_data);
        _child_property    = new IntegerField(_child_property_offset,
                                              _raw_data);
        _storage_clsid     = new ClassID(_raw_data,_storage_clsid_offset);
        _user_flags        = new IntegerField(_user_flags_offset, 0, _raw_data);
        _seconds_1         = new IntegerField(_seconds_1_offset, _raw_data);
        _days_1            = new IntegerField(_days_1_offset, _raw_data);
        _seconds_2         = new IntegerField(_seconds_2_offset, _raw_data);
        _days_2            = new IntegerField(_days_2_offset, _raw_data);
        _start_block       = new IntegerField(_start_block_offset, _raw_data);
        _size              = new IntegerField(_size_offset, _raw_data);
        _index             = index;
        int name_length = (_name_size.get() / LittleEndianConsts.SHORT_SIZE)
                          - 1;
        if (name_length <  1)
        {
            _name = "";
        }
        else
        {
            char[] char_array  = new char[ name_length ];
            int    name_offset = 0;
            for (int j = 0; j <  name_length; j++)
            {
                char_array[ j ] = ( char ) new ShortField(name_offset,
                                                          _raw_data).get();
                name_offset     += LittleEndianConsts.SHORT_SIZE;
            }
            _name = new String(char_array, 0, name_length);
        }
        _next_child     = null;
        _previous_child = null;
}

Constructor from byte data

Parameters:

index - index number

array - byte data

offset - offset into byte data

 protected int getChildIndex() 
{
        return _child_property.get();
}

Get the child property (its index in the Property Table)

 protected int getIndex() 
{
        return _index;
}

get the index for this Property

 public String getName() 
{
        return _name;
}

Get the name of this property

 public Child getNextChild() 
{
        return _next_child;
}

Get the next Child, if any

 int getNextChildIndex() 
{
        return _next_property.get();
}

get the next sibling

 public Child getPreviousChild() 
{
        return _previous_child;
}

Get the previous Child, if any

 int getPreviousChildIndex() 
{
        return _previous_property.get();
}

get the previous sibling

 public String getShortDescription() 
{
        StringBuffer buffer = new StringBuffer();
        buffer.append("Property: \"").append(getName()).append("\"");
        return buffer.toString();
}

Provides a short description of the object, to be used when a POIFSViewable object has not provided its contents.

 public int getSize() 
{
        return _size.get();
}

find out the document size

 public int getStartBlock() 
{
        return _start_block.get();
}

 public ClassID getStorageClsid() 
{
        return _storage_clsid;
}

Sets the storage clsid, which is the Class ID of a COM object which reads and writes this stream

 public Object[] getViewableArray() 
{
        Object[] results = new Object[ 5 ];
        results[ 0 ] = "Name          = \"" + getName() + "\"";
        results[ 1 ] = "Property Type = " + _property_type.get();
        results[ 2 ] = "Node Color    = " + _node_color.get();
        long time = _days_1.get();
        time         < < = 32;
        time         += (( long ) _seconds_1.get()) & 0x0000FFFFL;
        results[ 3 ] = "Time 1        = " + time;
        time         = _days_2.get();
        time         < < = 32;
        time         += (( long ) _seconds_2.get()) & 0x0000FFFFL;
        results[ 4 ] = "Time 2        = " + time;
        return results;
}

Get an array of objects, some of which may implement POIFSViewable

 public Iterator getViewableIterator() 
{
        return Collections.EMPTY_LIST.iterator();
}

Get an Iterator of objects, some of which may implement POIFSViewable

 abstract public boolean isDirectory()

 public static boolean isSmall(int length) 
{
        return length <  _big_block_minimum_bytes;
}

does the length indicate a small document?

 static boolean isValidIndex(int index) 
{
        return index != _NO_INDEX;
}

determine whether the specified index is valid

 abstract protected  void preWrite()
Perform whatever activities need to be performed prior to
writing

 public boolean preferArray() 
{
        return true;
}

Give viewers a hint as to whether to call getViewableArray or getViewableIterator

 protected  void setChildProperty(int child) 
{
        _child_property.set(child, _raw_data);
}

Set the child property.

 protected  void setIndex(int index) 
{
        _index = index;
}

Set the index for this Property

 protected final  void setName(String name) 
{
        char[] char_array = name.toCharArray();
        int    limit      = Math.min(char_array.length, _max_name_length);
        _name = new String(char_array, 0, limit);
        short offset = 0;
        int   j      = 0;
        for (; j <  limit; j++)
        {
            new ShortField(offset, ( short ) char_array[ j ], _raw_data);
            offset += LittleEndianConsts.SHORT_SIZE;
        }
        for (; j <  _max_name_length + 1; j++)
        {
            new ShortField(offset, ( short ) 0, _raw_data);
            offset += LittleEndianConsts.SHORT_SIZE;
        }
        // double the count, and include the null at the end
        _name_size
            .set(( short ) ((limit + 1)
                            * LittleEndianConsts.SHORT_SIZE), _raw_data);
}

Set the name; silently truncates the name if it's too long.

 public  void setNextChild(Child child) 
{
        _next_child = child;
        _next_property.set((child == null) ? _NO_INDEX
                                           : (( Property ) child)
                                               .getIndex(), _raw_data);
}

Set the next Child

 protected  void setNodeColor(byte nodeColor) 
{
        _node_color.set(nodeColor, _raw_data);
}

Set the node color.

 public  void setPreviousChild(Child child) 
{
        _previous_child = child;
        _previous_property.set((child == null) ? _NO_INDEX
                                               : (( Property ) child)
                                                   .getIndex(), _raw_data);
}

Set the previous Child

 protected  void setPropertyType(byte propertyType) 
{
        _property_type.set(propertyType, _raw_data);
}

Set the property type. Makes no attempt to validate the value.

 protected  void setSize(int size) 
{
        _size.set(size, _raw_data);
}

Set the size of the document associated with this Property

 public  void setStartBlock(int startBlock) 
{
        _start_block.set(startBlock, _raw_data);
}

Set the start block for the document referred to by this Property.

 public  void setStorageClsid(ClassID clsidStorage) 
{
        _storage_clsid = clsidStorage;
        if( clsidStorage == null) {
            Arrays.fill( _raw_data, _storage_clsid_offset, _storage_clsid_offset + ClassID.LENGTH, (byte) 0);
        } else {
            clsidStorage.write( _raw_data, _storage_clsid_offset);
        }
}

Sets the storage class ID for this property stream. This is the Class ID of the COM object which can read and write this property stream

 public boolean shouldUseSmallBlocks() 
{
        return Property.isSmall(_size.get());
}

Based on the currently defined size, should this property use small blocks?

 public  void writeData(OutputStream stream) throws IOException 
{
        stream.write(_raw_data);
}

Write the raw data to an OutputStream.