public static void WriteGetItemsResult(this DataOutputStream output, DashboardItem[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.Length);
foreach (var item in value)
{
output.WriteString(item.AskQuestion);
output.WriteDateTime(item.DateTime.ToDateTime());
output.WriteInt32(item.FeedItemType);
output.WriteString(item.Friend1FullName);
output.WriteString(item.Friend2FullName);
output.WriteString(item.FriendNickname1);
output.WriteString(item.FriendNickname2);
output.WriteString(item.FriendWebMemberID1);
output.WriteString(item.FriendWebMemberID2);
output.WriteString(item.Text);
output.WriteString(item.ThumbnailUrl);
output.WriteString(item.Title);
output.WriteInt32(item.ObjectID);
output.WriteString(item.WebPhotoCollectionID);
output.WriteString(item.WebPhotoID);
}
}
public static void WriteInt32Array(this DataOutputStream output, Int32[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.Length);
foreach (var item in value)
{
output.WriteInt32(item);
}
}
public static void WriteGetResponseResult(this DataOutputStream output, AskResponse value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.AskQuestionID);
output.WriteString(value.Question);
output.WriteByteArray(Convert.FromBase64String(value.PhotoBase64Binary));
output.WriteInt32Array(value.ResponseValues);
output.WriteFloat(Convert.ToSingle(value.Average));
output.WriteInt32(value.ResponseType);
output.WriteStringArray(value.CustomResponses);
}
public static void WriteGetCommentResult(this DataOutputStream output, WebComment value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.ID);
output.WriteInt32(value.ObjectID);
output.WriteString(value.Nickname);
output.WriteString(value.Text);
output.WriteDateTime(value.DTCreated.ToDateTime());
output.WriteInt32(value.InReplyToCommentID);
output.WriteInt32(value.ParentCommentID);
output.WriteInt32(value.CommentType);
}
public static void WriteGetPhotosForCollectionResult(this DataOutputStream output, WebPhoto[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.Length);
foreach (var item in value)
{
output.WriteInt32(item.ID);
output.WriteDateTime(item.CreatedDT.ToDateTime());
output.WriteString(item.Title);
output.WriteString(item.Description);
}
}
/// <summary>
/// Serialize the token data for communication between server and client.
/// </summary>
/// <exception cref="IOException"></exception>
public void Serialize(DataOutputStream writer)
{
writer.WriteUTF(Id);
writer.WriteUTF(Version);
writer.WriteInt32(SourceFiles.Count);
foreach (KeyValuePair <string, IList <RevisionFile> > pair in SourceFiles)
{
writer.WriteUTF(pair.Key);
writer.WriteInt32(pair.Value.Count);
foreach (RevisionFile file in pair.Value)
{
writer.WriteUTF(file.FileName);
writer.WriteInt64(file.Length);
}
}
}
public static void WriteGetQuestionResult(this DataOutputStream output, AskQuestion value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.ID);
output.WriteString(value.Question);
output.WriteDateTime(value.DTCreated.ToDateTime());
}
public static void WriteGetEntryResult(this DataOutputStream output, BlogEntry value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.ID);
output.WriteString(value.Title);
output.WriteString(value.Body);
output.WriteDateTime(value.DTCreated.ToDateTime());
}
public static void WriteGetQuestionsResult(this DataOutputStream output, AskQuestion[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.Length);
foreach (var item in value)
{
output.WriteGetQuestionResult(item);
}
}
/// <summary>
/// Writes an ICU data header.
/// Does not write a copyright string.
/// </summary>
/// <param name="dataFormat"></param>
/// <param name="formatVersion"></param>
/// <param name="dataVersion"></param>
/// <param name="dos"></param>
/// <returns>The length of the header (number of bytes written).</returns>
/// <exception cref="IOException">From the <see cref="DataOutputStream"/>.</exception>
public static int WriteHeader(int dataFormat, int formatVersion, int dataVersion,
DataOutputStream dos)
{
// ucmndata.h MappedData
dos.WriteChar(32); // headerSize
dos.WriteByte(MAGIC1);
dos.WriteByte(MAGIC2);
// unicode/udata.h UDataInfo
dos.WriteChar(20); // sizeof(UDataInfo)
dos.WriteChar(0); // reservedWord
dos.WriteByte(1); // isBigEndian
dos.WriteByte(CHAR_SET_); // charsetFamily
dos.WriteByte(CHAR_SIZE_); // sizeofUChar
dos.WriteByte(0); // reservedByte
dos.WriteInt32(dataFormat);
dos.WriteInt32(formatVersion);
dos.WriteInt32(dataVersion);
// 8 bytes padding for 32 bytes headerSize (multiple of 16).
dos.WriteInt64(0);
Debug.Assert(dos.Length == 32);
return(32);
}
/// <summary>
/// Serialize a <see cref="Trie2_32"/> onto an <see cref="Stream"/>.
/// </summary>
/// <remarks>
/// A <see cref="Trie2"/> can be serialized multiple times.
/// The serialized data is compatible with ICU4C UTrie2 serialization.
/// <see cref="Trie2"/> serialization is unrelated to .NET object serialization.
/// </remarks>
/// <param name="os">The stream to which the serialized Trie2 data will be written.</param>
/// <returns>The number of bytes written.</returns>
/// <exception cref="IOException">On an error writing to the <see cref="Stream"/>.</exception>
public int Serialize(Stream os)
{
DataOutputStream dos = new DataOutputStream(os);
int bytesWritten = 0;
bytesWritten += SerializeHeader(dos);
for (int i = 0; i < dataLength; i++)
{
dos.WriteInt32(data32[i]);
}
bytesWritten += dataLength * 4;
return(bytesWritten);
}
public static void WriteUploadTagsResult(this DataOutputStream output, TagConfirmation[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.Length);
foreach (var item in value)
{
output.WriteString(item.DeviceID);
output.WriteBoolean(item.ConfirmedByServer);
}
}
public static void WriteByteArray(this DataOutputStream output, Byte[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.Length);
_byte2SByteMap.ByteArray = value;
foreach (var item in _byte2SByteMap.SByteArray)
{
output.WriteByte(item);
}
}
public static void WriteGetNewFriendsResult(this DataOutputStream output, DashboardNewFriend[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.Length);
foreach (var item in value)
{
output.WriteDateTime(item.DateTime.ToDateTime());
output.WriteString(item.Nickname1);
output.WriteString(item.Nickname2);
}
}
public static void WriteGetVideosResult(this DataOutputStream output, DashboardVideo[] value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
output.WriteInt32(value.Length);
foreach (var item in value)
{
output.WriteDateTime(item.DateTime.ToDateTime());
output.WriteString(item.Nickname);
output.WriteString(item.Text);
output.WriteString(item.Title);
output.WriteString(item.ThumbnailUrl);
}
}
public void Return(DataOutputStream output)
{
output.WriteInt32(_result);
}
/// <summary>
/// Serializes the build table to an output stream.
/// <para/>
/// Compacts the build-time trie after all values are set, and then
/// writes the serialized form onto an output stream.
/// <para/>
/// After this, this build-time Trie can only be serialized again and/or closed;
/// no further values can be added.
/// <para/>
/// This function is the rough equivalent of utrie_seriaize() in ICU4C.
/// </summary>
/// <param name="os">The output stream to which the seriaized trie will be written.
/// If nul, the function still returns the size of the serialized Trie.</param>
/// <param name="reduceTo16Bits">If true, reduce the data size to 16 bits. The resulting
/// serialized form can then be used to create a <see cref="CharTrie"/>.</param>
/// <param name="datamanipulate">Builder raw fold method implementation.</param>
/// <returns>The number of bytes written to the output stream.</returns>
public virtual int Serialize(Stream os, bool reduceTo16Bits,
ITrieBuilderDataManipulate datamanipulate)
{
if (datamanipulate == null)
{
throw new ArgumentException("Parameters can not be null");
}
// fold and compact if necessary, also checks that indexLength is
// within limits
if (!m_isCompacted_)
{
// compact once without overlap to improve folding
Compact(false);
// fold the supplementary part of the index array
Fold(datamanipulate);
// compact again with overlap for minimum data array length
Compact(true);
m_isCompacted_ = true;
}
// is dataLength within limits?
int length;
if (reduceTo16Bits)
{
length = m_dataLength_ + m_indexLength_;
}
else
{
length = m_dataLength_;
}
if (length >= MaxDataLength)
{
throw new IndexOutOfRangeException("Data length too small");
}
// struct UTrieHeader {
// int32_t signature;
// int32_t options (a bit field)
// int32_t indexLength
// int32_t dataLength
length = Trie.HeaderLength + 2 * m_indexLength_;
if (reduceTo16Bits)
{
length += 2 * m_dataLength_;
}
else
{
length += 4 * m_dataLength_;
}
if (os == null)
{
// No output stream. Just return the length of the serialized Trie, in bytes.
return(length);
}
DataOutputStream dos = new DataOutputStream(os);
dos.WriteInt32(Trie.HeaderSignature);
int options = Trie.IndexStage1Shift | (Trie.IndexStage2Shift << Trie.HeaderOptionsIndexShift);
if (!reduceTo16Bits)
{
options |= Trie.HeaderOptionsDataIs32Bit;
}
if (m_isLatin1Linear_)
{
options |= Trie.HeaderOptionsLatin1IsLinearMask;
}
dos.WriteInt32(options);
dos.WriteInt32(m_indexLength_);
dos.WriteInt32(m_dataLength_);
/* write the index (stage 1) array and the 16/32-bit data (stage 2) array */
if (reduceTo16Bits)
{
/* write 16-bit index values shifted right by UTRIE_INDEX_SHIFT, after adding indexLength */
for (int i = 0; i < m_indexLength_; i++)
{
int v = (m_index_[i] + m_indexLength_).TripleShift(Trie.IndexStage2Shift);
dos.WriteChar(v);
}
/* write 16-bit data values */
for (int i = 0; i < m_dataLength_; i++)
{
int v = m_data_[i] & 0x0000ffff;
dos.WriteChar(v);
}
}
else
{
/* write 16-bit index values shifted right by UTRIE_INDEX_SHIFT */
for (int i = 0; i < m_indexLength_; i++)
{
int v = (m_index_[i]).TripleShift(Trie.IndexStage2Shift);
dos.WriteChar(v);
}
/* write 32-bit data values */
for (int i = 0; i < m_dataLength_; i++)
{
dos.WriteInt32(m_data_[i]);
}
}
return(length);
}
internal void FlattenData(Stream os)
{
DataOutputStream dos = new DataOutputStream(os);
int i;
// Remove comments and whitespace from the rules to make it smaller.
string strippedRules = RBBIRuleScanner.StripRules(fRules);
// Calculate the size of each section in the data in bytes.
// Sizes here are padded up to a multiple of 8 for better memory alignment.
// Sections sizes actually stored in the header are for the actual data
// without the padding.
//
int headerSize = 24 * 4; // align8(sizeof(RBBIDataHeader));
int forwardTableSize = Align8(fForwardTables.GetTableSize());
int reverseTableSize = Align8(fReverseTables.GetTableSize());
// int safeFwdTableSize = Align8(fSafeFwdTables.getTableSize());
int safeRevTableSize = Align8(fSafeRevTables.GetTableSize());
int trieSize = Align8(fSetBuilder.GetTrieSize());
int statusTableSize = Align8(fRuleStatusVals.Count * 4);
int rulesSize = Align8((strippedRules.Length) * 2);
int totalSize = headerSize
+ forwardTableSize
+ /* reverseTableSize */ 0
+ /* safeFwdTableSize */ 0
+ (safeRevTableSize > 0 ? safeRevTableSize : reverseTableSize)
+ statusTableSize + trieSize + rulesSize;
int outputPos = 0; // Track stream position, starting from RBBIDataHeader.
//
// Write out an ICU Data Header
//
ICUBinary.WriteHeader(RBBIDataWrapper.DATA_FORMAT, RBBIDataWrapper.FORMAT_VERSION, 0, dos);
//
// Write out the RBBIDataHeader
//
int[] header = new int[RBBIDataWrapper.DH_SIZE]; // sizeof struct RBBIDataHeader
header[RBBIDataWrapper.DH_MAGIC] = 0xb1a0;
header[RBBIDataWrapper.DH_FORMATVERSION] = RBBIDataWrapper.FORMAT_VERSION;
header[RBBIDataWrapper.DH_LENGTH] = totalSize; // fLength, the total size of all rule sections.
header[RBBIDataWrapper.DH_CATCOUNT] = fSetBuilder.NumCharCategories; // fCatCount.
// Only save the forward table and the safe reverse table,
// because these are the only ones used at run-time.
//
// For the moment, we still build the other tables if they are present in the rule source files,
// for backwards compatibility. Old rule files need to work, and this is the simplest approach.
//
// Additional backwards compatibility consideration: if no safe rules are provided, consider the
// reverse rules to actually be the safe reverse rules.
header[RBBIDataWrapper.DH_FTABLE] = headerSize; // fFTable
header[RBBIDataWrapper.DH_FTABLELEN] = forwardTableSize; // fTableLen
// Do not save Reverse Table.
header[RBBIDataWrapper.DH_RTABLE] = header[RBBIDataWrapper.DH_FTABLE] + forwardTableSize; // fRTable
header[RBBIDataWrapper.DH_RTABLELEN] = 0; // fRTableLen
// Do not save the Safe Forward table.
header[RBBIDataWrapper.DH_SFTABLE] = header[RBBIDataWrapper.DH_RTABLE]
+ 0; // fSTable
header[RBBIDataWrapper.DH_SFTABLELEN] = 0; // fSTableLen
// Safe reverse table. Use if present, otherwise save regular reverse table as the safe reverse.
header[RBBIDataWrapper.DH_SRTABLE] = header[RBBIDataWrapper.DH_SFTABLE]
+ 0; // fSRTable
if (safeRevTableSize > 0)
{
header[RBBIDataWrapper.DH_SRTABLELEN] = safeRevTableSize;
}
else
{
Debug.Assert(reverseTableSize > 0);
header[RBBIDataWrapper.DH_SRTABLELEN] = reverseTableSize;
}
header[RBBIDataWrapper.DH_TRIE] = header[RBBIDataWrapper.DH_SRTABLE]
+ header[RBBIDataWrapper.DH_SRTABLELEN]; // fTrie
header[RBBIDataWrapper.DH_TRIELEN] = fSetBuilder.GetTrieSize(); // fTrieLen
header[RBBIDataWrapper.DH_STATUSTABLE] = header[RBBIDataWrapper.DH_TRIE]
+ header[RBBIDataWrapper.DH_TRIELEN];
header[RBBIDataWrapper.DH_STATUSTABLELEN] = statusTableSize; // fStatusTableLen
header[RBBIDataWrapper.DH_RULESOURCE] = header[RBBIDataWrapper.DH_STATUSTABLE]
+ statusTableSize;
header[RBBIDataWrapper.DH_RULESOURCELEN] = strippedRules.Length * 2;
for (i = 0; i < header.Length; i++)
{
dos.WriteInt32(header[i]);
outputPos += 4;
}
// Write out the actual state tables.
short[] tableData;
tableData = fForwardTables.ExportTable();
Assert.Assrt(outputPos == header[4]);
for (i = 0; i < tableData.Length; i++)
{
dos.WriteInt16(tableData[i]);
outputPos += 2;
}
/* do not write the reverse table
* tableData = fReverseTables.exportTable();
* Assert.Assrt(outputPos == header[6]);
* for (i = 0; i < tableData.length; i++) {
* dos.WriteInt16(tableData[i]);
* outputPos += 2;
* }
*/
/* do not write safe forwards table
* Assert.Assrt(outputPos == header[8]);
* tableData = fSafeFwdTables.exportTable();
* for (i = 0; i < tableData.length; i++) {
* dos.WriteInt16(tableData[i]);
* outputPos += 2;
* }
*/
// Write the safe reverse table.
// If not present, write the plain reverse table (old style rule compatibility)
Assert.Assrt(outputPos == header[10]);
if (safeRevTableSize > 0)
{
tableData = fSafeRevTables.ExportTable();
}
else
{
tableData = fReverseTables.ExportTable();
}
for (i = 0; i < tableData.Length; i++)
{
dos.WriteInt16(tableData[i]);
outputPos += 2;
}
// write out the Trie table
Assert.Assrt(outputPos == header[12]);
fSetBuilder.SerializeTrie(os);
outputPos += header[13];
while (outputPos % 8 != 0)
{ // pad to an 8 byte boundary
dos.Write(0);
outputPos += 1;
}
// Write out the status {tag} table.
Assert.Assrt(outputPos == header[16]);
foreach (var val in fRuleStatusVals)
{
dos.WriteInt32(val);
outputPos += 4;
}
while (outputPos % 8 != 0)
{ // pad to an 8 byte boundary
dos.Write(0);
outputPos += 1;
}
// Write out the stripped rules (rules with extra spaces removed
// These go last in the data area, even though they are not last in the header.
Assert.Assrt(outputPos == header[14]);
dos.WriteChars(strippedRules);
outputPos += strippedRules.Length * 2;
while (outputPos % 8 != 0)
{ // pad to an 8 byte boundary
dos.Write(0);
outputPos += 1;
}
}
public void Return(DataOutputStream output)
{
output.WriteInt32(_result);
}
