## org.apache.poi.hssf.record
Class SSTRecord

    java.lang.Object
      org.apache.poi.hssf.record.Record
          org.apache.poi.hssf.record.SSTRecord

public class SSTRecord
extends Record

Title: Static String Table Record

Description: This holds all the strings for LabelSSTRecords.

REFERENCE: PG 389 Microsoft Excel 97 Developer's Kit (ISBN: 1-57231-498-2)

Author:
  Andrew C. Oliver (acoliver at apache dot org), Marc Johnson (mjohnson at apache dot org), Glen Stampoultzis (glens at apache.org)
See Also:
  `LabelSSTRecord`, `ContinueRecord`

Field Summary
`static short` `sid`

Constructor Summary
`SSTRecord()` default constructor
`SSTRecord(short id, short size, byte[] data)` Constructs an SST record and sets its fields appropriately.
`SSTRecord(short id, short size, byte[] data, int offset)` Constructs an SST record and sets its fields appropriately.

Method Summary
`int` `addString(java.lang.String string)` Add a string.
`int` `addString(java.lang.String string, boolean useUTF16)` Add a string and assert the encoding (8-bit or 16-bit) to be used.
`int` `calcExtSSTRecordSize()` Calculates the size in bytes of the EXTSST record as it would be if the record was serialized.
`ExtSSTRecord` `createExtSSTRecord(int sstOffset)` Creates an extended string record based on the current contents of the current SST record.
`boolean` `equals(java.lang.Object o)`
`protected void` `fillFields(byte[] data, short size, int offset)` Fill the fields from the data
`int` `getNumStrings()`
`int` `getNumUniqueStrings()`
`int` `getRecordSize()` gives the current serialized size of the record.
`short` `getSid()` return the non static version of the id for this record.
`java.lang.String` `getString(int id)` Get a particular string by its index
`int` `hashCode()`
`boolean` `isString16bit(int id)`
`void` `processContinueRecord(byte[] record)` Strange to handle continue records this way.
`int` `serialize(int offset, byte[] data)` called by the class that is responsible for writing this sucker.
`void` `setNumStrings(int count)` USE THIS METHOD AT YOUR OWN PERIL: THE `addString` METHODS MANIPULATE THE NUMBER OF STRINGS AS A SIDE EFFECT; YOUR ATTEMPTS AT MANIPULATING THE STRING COUNT IS LIKELY TO BE VERY WRONG AND WILL RESULT IN BAD BEHAVIOR WHEN THIS RECORD IS WRITTEN OUT AND ANOTHER PROCESS ATTEMPTS TO READ THE RECORD
`void` `setNumUniqueStrings(int count)` USE THIS METHOD AT YOUR OWN PERIL: THE `addString` METHODS MANIPULATE THE NUMBER OF UNIQUE STRINGS AS A SIDE EFFECT; YOUR ATTEMPTS AT MANIPULATING THE UNIQUE STRING COUNT IS LIKELY TO BE VERY WRONG AND WILL RESULT IN BAD BEHAVIOR WHEN THIS RECORD IS WRITTEN OUT AND ANOTHER PROCESS ATTEMPTS TO READ THE RECORD
`java.lang.String` `toString()` Return a debugging string representation
`protected void` `validateSid(short id)` validate SID

Methods inherited from class org.apache.poi.hssf.record.Record
`clone, fillFields, isInValueSection, isValue, serialize`

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### sid

    public static final short sid

See Also:
  Constant Field Values

Constructor Detail

### SSTRecord

    public SSTRecord()

  default constructor

### SSTRecord

    public SSTRecord(short id,
                     short size,
                     byte[] data)

  Constructs an SST record and sets its fields appropriately.

Parameters:
  `id` - must be 0xfc or an exception will be throw upon validation
  `size` - the size of the data area of the record
  `data` - of the record (should not contain sid/len)

### SSTRecord

    public SSTRecord(short id,
                     short size,
                     byte[] data,
                     int offset)

  Constructs an SST record and sets its fields appropriately.

Parameters:
  `id` - must be 0xfc or an exception will be throw upon validation
  `size` - the size of the data area of the record
  `data` - of the record (should not contain sid/len)
  `offset` - of the record

Method Detail

### addString

    public int addString(java.lang.String string)

  Add a string. Determines whether 8-bit encoding can be used, or whether 16-bit encoding must be used.

  THIS IS THE PREFERRED METHOD OF ADDING A STRING. IF YOU USE THE OTHER ,code>addString METHOD AND FORCE 8-BIT ENCODING ON A STRING THAT SHOULD USE 16-BIT ENCODING, YOU WILL CORRUPT THE STRING; IF YOU USE THAT METHOD AND FORCE 16-BIT ENCODING, YOU ARE WASTING SPACE WHEN THE WORKBOOK IS WRITTEN OUT.

  Parameters:
    `string` - string to be added
  Returns:
    the index of that string in the table

### addString

    public int addString(java.lang.String string,
                         boolean useUTF16)

  Add a string and assert the encoding (8-bit or 16-bit) to be used.

  USE THIS METHOD AT YOUR OWN RISK. IF YOU FORCE 8-BIT ENCODING, YOU MAY CORRUPT YOUR STRING. IF YOU FORCE 16-BIT ENCODING AND IT ISN'T NECESSARY, YOU WILL WASTE SPACE WHEN THIS RECORD IS WRITTEN OUT.

  Parameters:
    `string` - string to be added
    `useUTF16` - if true, forces 16-bit encoding. If false, forces 8-bit encoding
  Returns:
    the index of that string in the table

### getNumStrings

    public int getNumStrings()

  Returns:
    number of strings

### getNumUniqueStrings

    public int getNumUniqueStrings()

  Returns:
    number of unique strings

### setNumStrings

    public void setNumStrings(int count)

  USE THIS METHOD AT YOUR OWN PERIL: THE `addString` METHODS MANIPULATE THE NUMBER OF STRINGS AS A SIDE EFFECT; YOUR ATTEMPTS AT MANIPULATING THE STRING COUNT IS LIKELY TO BE VERY WRONG AND WILL RESULT IN BAD BEHAVIOR WHEN THIS RECORD IS WRITTEN OUT AND ANOTHER PROCESS ATTEMPTS TO READ THE RECORD

  Parameters:
    `count` - number of strings

### setNumUniqueStrings

    public void setNumUniqueStrings(int count)

  USE THIS METHOD AT YOUR OWN PERIL: THE `addString` METHODS MANIPULATE THE NUMBER OF UNIQUE STRINGS AS A SIDE EFFECT; YOUR ATTEMPTS AT MANIPULATING THE UNIQUE STRING COUNT IS LIKELY TO BE VERY WRONG AND WILL RESULT IN BAD BEHAVIOR WHEN THIS RECORD IS WRITTEN OUT AND ANOTHER PROCESS ATTEMPTS TO READ THE RECORD

  Parameters:
    `count` - number of strings

### getString

    public java.lang.String getString(int id)

  Get a particular string by its index

  Parameters:
    `id` - index into the array of strings
  Returns:
    the desired string

### isString16bit

    public boolean isString16bit(int id)

### toString

    public java.lang.String toString()

  Return a debugging string representation

  Overrides:
    `toString` in class `Record`
  Returns:
    string representation

### getSid

    public short getSid()

  Description copied from class: `Record`
  return the non static version of the id for this record.

  Specified by:
    `getSid` in class `Record`
  Returns:
    sid

### hashCode

    public int hashCode()

  Returns:
    hashcode

### equals

    public boolean equals(java.lang.Object o)

### validateSid

    protected void validateSid(short id)
                        throws RecordFormatException

  validate SID

  Specified by:
    `validateSid` in class `Record`
  Parameters:
    `id` - the alleged SID
  Throws:
    `RecordFormatException` - if validation fails

### fillFields

    protected void fillFields(byte[] data,
                              short size,
                              int offset)

  Fill the fields from the data

  The data consists of sets of string data. This string data is arranged as follows:

  ``

       short  string_length;   // length of string data
       byte   string_flag;     // flag specifying special string
                               // handling
       short  run_count;       // optional count of formatting runs
       int    extend_length;   // optional extension length
       char[] string_data;     // string data, can be byte[] or
                               // short[] (length of array is
                               // string_length)
       int[]  formatting_runs; // optional formatting runs (length of
                               // array is run_count)
       byte[] extension;       // optional extension (length of array
                               // is extend_length)

  The string_flag is bit mapped as follows:

  Bit number | Meaning if 0 | Meaning if 1
  --- | --- | ---
  0 | string_data is byte[] | string_data is short[]
  1 | Should always be 0 | string_flag is defective
  2 | extension is not included | extension is included
  3 | formatting run data is not included | formatting run data is included
  4 | Should always be 0 | string_flag is defective
  5 | Should always be 0 | string_flag is defective
  6 | Should always be 0 | string_flag is defective
  7 | Should always be 0 | string_flag is defective

  We can handle eating the overhead associated with bits 2 or 3 (or both) being set, but we have no idea what to do with the associated data. The UnicodeString class can handle the byte[] vs short[] nature of the actual string data

  Specified by:
    `fillFields` in class `Record`
  Parameters:
    `data` - raw data
    `size` - size of the raw data
    `offset` - of the record's data (provided a big array of the file)

### serialize

    public int serialize(int offset,
                         byte[] data)

  called by the class that is responsible for writing this sucker. Subclasses should implement this so that their data is passed back in a byte array.

  Specified by:
    `serialize` in class `Record`
  Parameters:
    `offset` - to begin writing at
    `data` - byte array containing instance data
  Returns:
    size

### getRecordSize

    public int getRecordSize()

  Description copied from class: `Record`
  gives the current serialized size of the record. Should include the sid and reclength (4 bytes).

  Overrides:
    `getRecordSize` in class `Record`

### processContinueRecord

    public void processContinueRecord(byte[] record)

  Strange to handle continue records this way. Is it a smell?

  Overrides:
    `processContinueRecord` in class `Record`
  Parameters:
    `record` - the continuation record's data

### createExtSSTRecord

    public ExtSSTRecord createExtSSTRecord(int sstOffset)

  Creates an extended string record based on the current contents of the current SST record. The offset within the stream to the SST record is required because the extended string record points directly to the strings in the SST record.

  NOTE: THIS FUNCTION MUST ONLY BE CALLED AFTER THE SST RECORD HAS BEEN SERIALIZED.

  Parameters:
    `sstOffset` - The offset in the stream to the start of the SST record.
  Returns:
    The new SST record.

### calcExtSSTRecordSize

    public int calcExtSSTRecordSize()

  Calculates the size in bytes of the EXTSST record as it would be if the record was serialized.

  Returns:
    The size of the ExtSST record in bytes.

Copyright © 2003 Apache Software Foundation.