/// <summary>
/// Constructor from an array of existing <code>TileData</code> objects.
/// </summary>
/// <param name="tiles">The tiles.</param>
/// <returns>A constructed <code>TileSequence</code>.</returns>
public static TileSequence FromData(params TileData[] tiles)
{
var list = new List <TileData>(tiles);
var sequence = new TileSequence(list);
return(sequence);
}
/// <summary>
/// Constructor from an array of existing <code>TileData</code> objects.
/// </summary>
/// <param name="tiles">The tiles.</param>
/// <returns>A constructed <code>TileSequence</code>.</returns>
public static TileSequence FromData(IEnumerable <TileData> tiles)
{
var list = new List <TileData>(tiles);
var sequence = new TileSequence(list);
return(sequence);
}
public UtteranceData(TileSequence sequence,
DateTimeOffset?started = null,
TimeSpan?duration = null,
int?keyCount = null)
{
Sequence = sequence;
IsArtificial = false;
Started = started;
Duration = duration;
KeyCount = keyCount;
}
public bool Equals(TileSequence sequence)
{
var count = _sequence.Count;
var value = count == sequence._sequence.Count;
for (var i = 0; value && i < count; i++)
{
value = _sequence[i].Equals(sequence._sequence[i]);
}
return(value);
}
public static UtteranceData FromLine(string line) => line.ReadXmlFragment <UtteranceData>(reader =>
{
UtteranceData value;
reader.ValidatedRead();
if (reader.NodeType == XmlNodeType.Element && reader.Name == "U")
{
var isArtificial = false;
DateTimeOffset?started = null;
TimeSpan?duration = null;
int?keyCount = null;
for (var work = reader.MoveToFirstAttribute(); work; work = reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case nameof(IsArtificial):
isArtificial = true;
break;
case nameof(Started):
started = DateTimeOffset.Parse(reader.Value, null, DateTimeStyles.RoundtripKind);
break;
case nameof(Duration):
duration = TimeSpan.FromMilliseconds(double.Parse(reader.Value));
break;
case nameof(KeyCount):
keyCount = int.Parse(reader.Value);
break;
}
}
reader.ValidatedRead();
var sequence = TileSequence.FromEncoded(reader, XmlNodeType.EndElement);
reader.ReadEndOfFragment();
value = isArtificial ? new UtteranceData(sequence, true) : new UtteranceData(sequence, started, duration, keyCount);
}
else
{
var sequence = TileSequence.FromEncoded(line);
value = new UtteranceData(sequence, false);
}
return(value);
});
public static TileSequence FromSimpleEncoded(string text)
{
var list = new List <TileData>();
// The length of text to be processed.
var length = text.Length;
// The current processing position.
var position = 0;
// Count the amount of leading white space.
while (position < length && text[position] == ' ')
{
position++;
}
if (position != 0)
{
// There is leading space, so emit explicit space.
var tile = TileData.Create(new string(' ', position), isPrefix: true, isSuffix: true);
list.Add(tile);
}
var previousTile = SingleSimpleSpace;
while (position < length)
{
// Calculate start and limit of the next group.
var groupStart = position;
while (position < length && text[position] != ' ')
{
position++;
}
var groupLimit = position;
// Calculate the part of the group that is word.
var wordStart = groupStart;
while (wordStart < groupLimit && !char.IsLetterOrDigit(text[wordStart]))
{
wordStart++;
}
// Calculate the part of the group that is, or is not, word.
var wordLimit = groupLimit;
if (wordStart < groupLimit)
{
while (!char.IsLetterOrDigit(text[wordLimit - 1]))
{
wordLimit--;
}
}
// Skip over whitespace at end.
while (position < length && text[position] == ' ')
{
position++;
}
if (wordStart < wordLimit)
{
// Emit leading symbolds, word and trailing symbols.
for (var i = groupStart; i < wordStart; i++)
{
var ch = text[i];
var tile = TileData.Create(TileType.Prefix, ch.ToString());
list.Add(tile);
}
if (wordStart < wordLimit)
{
var word = text.Substring(wordStart, wordLimit - wordStart);
var tile = TileData.Create(word);
list.Add(tile);
Debug.Assert(tile.IsSimpleWord);
}
for (var i = wordLimit; i < groupLimit; i++)
{
var ch = text[i];
var tile = TileData.Create(TileType.Suffix, ch.ToString());
list.Add(tile);
}
}
else
{
Debug.Assert(previousTile.IsSpaces);
if (groupLimit < position || groupLimit == length)
{
// Emit as one string.
var group = text.Substring(groupStart, groupLimit - groupStart);
var tile = TileData.Create(group, isSuffix: false);
list.Add(tile);
}
}
// Add explicit whitespace if needed.
if (groupLimit + 1 < position || (groupLimit < position && position == length))
{
var tile = TileData.Create(new string(' ', position - groupLimit), isPrefix: true, isSuffix: true);
list.Add(tile);
Debug.Assert(tile.IsSpaces);
}
}
var sequence = new TileSequence(list);
return(sequence);
}
public UtteranceData(TileSequence sequence, bool isArtificial)
{
Sequence = sequence;
IsArtificial = isArtificial;
}
