|
/* ====================================================================
|
Licensed to the Apache Software Foundation (ASF) Under one or more
|
contributor license agreements. See the NOTICE file distributed with
|
this work for Additional information regarding copyright ownership.
|
The ASF licenses this file to You Under the Apache License, Version 2.0
|
(the "License"); you may not use this file except in compliance with
|
the License. You may obtain a copy of the License at
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
Unless required by applicable law or agreed to in writing, software
|
distributed Under the License is distributed on an "AS Is" BASIS,
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
See the License for the specific language governing permissions and
|
limitations Under the License.
|
==================================================================== */
|
|
|
namespace HH.WMS.Utils.NPOI.HSSF.Record
|
{
|
|
using System;
|
using System.Collections;
|
using System.Collections.Generic;
|
using System.Text;
|
using HH.WMS.Utils.NPOI.Util;
|
using HH.WMS.Utils.NPOI.Util.Collections;
|
using HH.WMS.Utils.NPOI.HSSF.Record.Cont;
|
|
|
/**
|
* 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)
|
* @author Marc Johnson (mjohnson at apache dot org)
|
* @author Glen Stampoultzis (glens at apache.org)
|
*
|
* @see org.apache.poi.hssf.record.LabelSSTRecord
|
* @see org.apache.poi.hssf.record.ContinueRecord
|
*/
|
|
public class SSTRecord : ContinuableRecord
|
{
|
public const short sid = 0x00FC;
|
private static UnicodeString EMPTY_STRING = new UnicodeString("");
|
|
/** how big can an SST record be? As big as any record can be: 8228 bytes */
|
public const int MAX_RECORD_SIZE = 8228;
|
|
/** standard record overhead: two shorts (record id plus data space size)*/
|
public const int STD_RECORD_OVERHEAD = 2 * LittleEndianConsts.SHORT_SIZE;
|
|
/** SST overhead: the standard record overhead, plus the number of strings and the number of Unique strings -- two ints */
|
public const int SST_RECORD_OVERHEAD = (STD_RECORD_OVERHEAD + (2 * LittleEndianConsts.INT_SIZE));
|
|
/** how much data can we stuff into an SST record? That would be _max minus the standard SST record overhead */
|
public const int MAX_DATA_SPACE = RecordInputStream.MAX_RECORD_DATA_SIZE - 8;//MAX_RECORD_SIZE - SST_RECORD_OVERHEAD;
|
|
// /** overhead for each string includes the string's Char count (a short) and the flag describing its Charistics (a byte) */
|
//public const int STRING_MINIMAL_OVERHEAD = LittleEndianConsts.SHORT_SIZE + LittleEndianConsts.BYTE_SIZE;
|
|
/** Union of strings in the SST and EXTSST */
|
private int field_1_num_strings;
|
|
/** according to docs ONLY SST */
|
private int field_2_num_unique_strings;
|
private IntMapper<UnicodeString> field_3_strings;
|
|
private SSTDeserializer deserializer;
|
|
/** Offsets from the beginning of the SST record (even across continuations) */
|
int[] bucketAbsoluteOffsets;
|
/** Offsets relative the start of the current SST or continue record */
|
int[] bucketRelativeOffsets;
|
|
/**
|
* default constructor
|
*/
|
public SSTRecord()
|
{
|
field_1_num_strings = 0;
|
field_2_num_unique_strings = 0;
|
field_3_strings = new IntMapper<UnicodeString>();
|
deserializer = new SSTDeserializer(field_3_strings);
|
}
|
|
/**
|
* Constructs an SST record and Sets its fields appropriately.
|
*
|
* @param in the RecordInputstream to Read the record from
|
*/
|
|
public SSTRecord(RecordInputStream in1)
|
{
|
// this method Is ALWAYS called after construction -- using
|
// the nontrivial constructor, of course -- so this Is where
|
// we initialize our fields
|
field_1_num_strings = in1.ReadInt();
|
field_2_num_unique_strings = in1.ReadInt();
|
field_3_strings = new IntMapper<UnicodeString>();
|
deserializer = new SSTDeserializer(field_3_strings);
|
deserializer.ManufactureStrings(field_2_num_unique_strings, in1);
|
}
|
|
/**
|
* Add a string.
|
*
|
* @param string string to be Added
|
*
|
* @return the index of that string in the table
|
*/
|
|
public int AddString(UnicodeString str)
|
{
|
field_1_num_strings++;
|
UnicodeString ucs = (str == null) ? EMPTY_STRING
|
: str;
|
int rval;
|
int index = field_3_strings.GetIndex(ucs);
|
|
if (index != -1)
|
{
|
rval = index;
|
}
|
else
|
{
|
// This is a new string -- we didn't see it among the
|
// strings we've already collected
|
rval = field_3_strings.Size;
|
field_2_num_unique_strings++;
|
SSTDeserializer.AddToStringTable(field_3_strings, ucs);
|
}
|
return rval;
|
}
|
|
/**
|
* @return number of strings
|
*/
|
|
public int NumStrings
|
{
|
get { return field_1_num_strings; }
|
set { field_1_num_strings = value; }
|
}
|
|
/**
|
* @return number of Unique strings
|
*/
|
|
public int NumUniqueStrings
|
{
|
get { return field_2_num_unique_strings; }
|
set { field_2_num_unique_strings = value; }
|
}
|
|
/**
|
* Get a particular string by its index
|
*
|
* @param id index into the array of strings
|
*
|
* @return the desired string
|
*/
|
|
public UnicodeString GetString(int id)
|
{
|
return (UnicodeString)field_3_strings[id];
|
}
|
|
public bool IsString16bit(int id)
|
{
|
UnicodeString unicodeString = ((UnicodeString)field_3_strings[id]);
|
return ((unicodeString.OptionFlags & 0x01) == 1);
|
}
|
|
/**
|
* Return a debugging string representation
|
*
|
* @return string representation
|
*/
|
|
public override String ToString()
|
{
|
StringBuilder buffer = new StringBuilder();
|
|
buffer.Append("[SST]\n");
|
buffer.Append(" .numstrings = ")
|
.Append(StringUtil.ToHexString(NumStrings)).Append("\n");
|
buffer.Append(" .uniquestrings = ")
|
.Append(StringUtil.ToHexString(NumUniqueStrings)).Append("\n");
|
for (int k = 0; k < field_3_strings.Size; k++)
|
{
|
UnicodeString s = (UnicodeString)field_3_strings[k];
|
buffer.Append(" .string_" + k + " = ")
|
.Append(s.GetDebugInfo()).Append("\n");
|
}
|
buffer.Append("[/SST]\n");
|
return buffer.ToString();
|
}
|
|
/**
|
* @return sid
|
*/
|
public override short Sid
|
{
|
get { return sid; }
|
}
|
|
/**
|
* @return hashcode
|
*/
|
public override int GetHashCode()
|
{
|
return field_2_num_unique_strings;
|
}
|
|
public override bool Equals(Object o)
|
{
|
if ((o == null) || (o.GetType() != this.GetType()))
|
{
|
return false;
|
}
|
SSTRecord other = (SSTRecord)o;
|
|
return ((field_1_num_strings == other
|
.field_1_num_strings) && (field_2_num_unique_strings == other
|
.field_2_num_unique_strings) && field_3_strings
|
.Equals(other.field_3_strings));
|
}
|
|
/**
|
* @return an iterator of the strings we hold. All instances are
|
* UnicodeStrings
|
*/
|
|
public IEnumerator GetStrings()
|
{
|
return field_3_strings.GetEnumerator();
|
}
|
|
/**
|
* @return count of the strings we hold.
|
*/
|
|
public int CountStrings
|
{
|
get { return field_3_strings.Size; }
|
}
|
|
/**
|
* 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.
|
*
|
* @return size
|
*/
|
|
protected override void Serialize(ContinuableRecordOutput out1) {
|
SSTSerializer serializer = new SSTSerializer(field_3_strings, NumStrings, NumUniqueStrings );
|
serializer.Serialize(out1);
|
bucketAbsoluteOffsets = serializer.BucketAbsoluteOffsets;
|
bucketRelativeOffsets = serializer.BucketRelativeOffsets;
|
}
|
|
SSTDeserializer GetDeserializer()
|
{
|
return deserializer;
|
}
|
|
/**
|
* 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.
|
*
|
* @param sstOffset The offset in the stream to the start of the
|
* SST record.
|
* @return The new SST record.
|
*/
|
public ExtSSTRecord CreateExtSSTRecord(int sstOffset)
|
{
|
if (bucketAbsoluteOffsets == null || bucketAbsoluteOffsets == null)
|
throw new InvalidOperationException("SST record has not yet been Serialized.");
|
|
ExtSSTRecord extSST = new ExtSSTRecord();
|
extSST.NumStringsPerBucket=((short)8);
|
int[] absoluteOffsets = (int[])bucketAbsoluteOffsets.Clone();
|
int[] relativeOffsets = (int[])bucketRelativeOffsets.Clone();
|
for (int i = 0; i < absoluteOffsets.Length; i++)
|
absoluteOffsets[i] += sstOffset;
|
extSST.SetBucketOffsets(absoluteOffsets, relativeOffsets);
|
return extSST;
|
}
|
|
/**
|
* Calculates the size in bytes of the EXTSST record as it would be if the
|
* record was Serialized.
|
*
|
* @return The size of the ExtSST record in bytes.
|
*/
|
public int CalcExtSSTRecordSize()
|
{
|
return ExtSSTRecord.GetRecordSizeForStrings(field_3_strings.Size);
|
}
|
}
|
}
|
