public override ParsedResult <TSchema> Parse(ParseText text, TextSpan span)
{
if (span.Length == 0)
{
throw new MacheteParserException("The body was empty");
}
int i = span.Start;
for (; i < span.End; i++)
{
if (!char.IsWhiteSpace(text[i]))
{
break;
}
}
if (i + 8 > span.End)
{
throw new MacheteParserException("The body must contain at least 8 characters");
}
if (text[i] != 'M' || text[i + 1] != 'S' || text[i + 2] != 'H')
{
throw new MacheteParserException("The body must start with an MSH segment");
}
var settings = GetHL7Settings(text, TextSpan.FromBounds(i, span.End));
var streamText = new StreamText(text, null);
var textCursor = new StreamTextCursor(streamText, TextSpan.FromBounds(i, span.End), TextSpan.FromBounds(span.End, span.End), _messageParser);
return(new HL7ParsedSlice <TSchema>(Schema, settings, textCursor));
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
var next = span;
var parsed = _parser.Parse(text, span);
if (_atLeastOne && !parsed.HasResult)
{
return(new Unmatched <TextSpan, TextSpan>(parsed.Next));
}
var matched = parsed.Result.Head;
while (parsed.HasResult)
{
if (next == parsed.Next)
{
break;
}
if (!matched.IsAdjacentTo(parsed.Result))
{
break;
}
matched += parsed.Result;
next = parsed.Next;
parsed = _parser.Parse(text, next);
}
return(new Success <TextSpan, TextSpan>(matched, next));
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
if (span.IsEmpty)
{
return(new Unmatched <TextSpan, TextSpan>(span));
}
var offset = span.Start;
for (; offset < span.End && _isWhiteSpace(text[offset]); offset++)
{
}
var start = offset;
for (; offset < span.End; offset++)
{
var c = text[offset];
if (c == _separator)
{
break;
}
}
var end = offset;
for (; end > start && _isWhiteSpace(text[end - 1]); end--)
{
}
return(new Success <TextSpan, TextSpan>(TextSpan.FromBounds(start, end),
offset < span.End ? TextSpan.FromBounds(offset + 1, span.End) : new TextSpan(span.End, 0)));
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
int offset = span.Start;
if (offset < span.End)
{
if (_firstCharacter(text[offset]))
{
offset++;
for (; offset < span.End; offset++)
{
if (_nextCharacter(text[offset]) == false)
{
break;
}
}
}
}
if (offset > span.Start)
{
return(new Success <TextSpan, TextSpan>(TextSpan.FromBounds(span.Start, offset), TextSpan.FromBounds(offset, span.End)));
}
return(new Unmatched <TextSpan, TextSpan>(span));
}
public ParseTextSlice(ParseText text, TextSpan span)
{
SourceText = text;
SourceSpan = span;
Text = text.GetSubText(span);
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
if (span.IsEmpty)
{
return(new Unmatched <TextSpan, TextSpan>(span));
}
var next = span;
var element = _element.Parse(text, span);
if (element.HasResult)
{
var separator = _separator.Parse(text, element.Next);
if (separator.HasResult)
{
return(new Success <TextSpan, TextSpan>(element.Result, separator.Next));
}
if (element.Next == next)
{
return(new Unmatched <TextSpan, TextSpan>(next));
}
return(new Success <TextSpan, TextSpan>(element.Result, element.Next));
}
return(new Unmatched <TextSpan, TextSpan>(element.Next));
}
private void parseText(ParseText text)
{
var lines = text.Text.Replace("\r", "")
.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim()).ToList();
var emails = lines.Select(x =>
{
try
{
var parts = x.Split(';');
return(new EmailMessage(parts[0], parts[1], parts[2]));
}
catch (Exception e)
{
logger.Error(e.Message);
return(null);
}
})
.OfType <EmailMessage>().ToList();
if (emails.Any())
{
logger.Debug("Parsed items: " + emails.Count);
Context.Sender.Tell(new EmailsQueuedEvent(emails));
}
else
{
logger.Debug("No items parsed");
}
}
public Result <TextSpan, IReadOnlyList <TextSpan> > Parse(ParseText text, TextSpan span)
{
var next = span;
var result = _parser.Parse(text, span);
if (!result.HasResult)
{
return(new Unmatched <TextSpan, IReadOnlyList <TextSpan> >(result.Next));
}
List <TextSpan> spans = new List <TextSpan>();
while (result.HasResult)
{
if (next == result.Next)
{
break;
}
spans.Add(result.Result);
next = result.Next;
result = _parser.Parse(text, next);
}
return(new Success <TextSpan, IReadOnlyList <TextSpan> >(spans, next));
}
public void PlayGame()
{
LoadStatusData();
ParseText.AtScene(this, status["atScene"]);
mainUI.OnPlayGame();
}
public ConvertedValue(ParseText text, TextSpan span, TValue value, bool hasValue = true)
{
_text = text;
_span = span;
Value = value;
HasValue = hasValue;
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
if (span.Start < span.End && _condition(text[span.Start]))
{
return(new Success <TextSpan, TextSpan>(new TextSpan(span.Start, 1), TextSpan.FromBounds(span.Start + 1, span.End)));
}
return(new Unmatched <TextSpan, TextSpan>(span));
}
public SubText(ParseText text, TextSpan span)
{
Debug.Assert(text != null, "text != null");
Debug.Assert(span.Start <= text.Length, "span.Start <= text.Length");
Debug.Assert(span.Start + span.Length <= text.Length, "span.Start + span.Length <= text.Length");
_text = text;
_span = span;
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
if (span.Length > 0)
{
return(new Success <TextSpan, TextSpan>(span, span.Tail));
}
return(new Unmatched <TextSpan, TextSpan>(span));
}
protected TextParserSlice(ParseText text, TextSpan span, ITextParser parser)
{
_sourceText = text;
_sourceSpan = span;
_parser = parser;
_parseSpan = span;
_slices = new List <TSlice>();
}
async Task <StreamText> IStreamTextReader.Next(ParseText left)
{
var textSpan = await Text.ConfigureAwait(false);
var parseTexts = _separator != null
? new[] { left, _separator, textSpan }
: new[] { left, textSpan };
var compositeText = new CompositeText(parseTexts);
return(new StreamText(compositeText, textSpan.Reader));
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
var result = _first.Parse(text, span);
if (result.HasResult)
{
return(result);
}
return(_second.Parse(text, span));
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
var parsed = _except.Parse(text, span);
if (parsed.HasResult)
{
return(new Unmatched <TextSpan, TextSpan>(span));
}
return(_parser.Parse(text, span));
}
public static Task <TextCursor> ParseText(ParseText text, TextSpan span, ITextParser parser)
{
var result = parser.Parse(text, span);
if (result.HasResult)
{
return(Task.FromResult <TextCursor>(new StreamTextCursor(new StreamText(text, null), result.Result, result.Next, parser)));
}
return(Task.FromResult <TextCursor>(new EmptyTextCursor(new StreamText(text, null), span)));
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
var parsed = _parser.Parse(text, span);
if (parsed.HasResult)
{
return(parsed);
}
return(new Success <TextSpan, TextSpan>(_defaultValue, span));
}
static X12ParserSettings GetX12Settings(ParseText text, TextSpan span)
{
var offset = span.Start;
return(new ParsedX12Settings
{
ElementSeparator = text[offset + 3],
RepetitionSeparator = text[offset + 82],
SubElementSeparator = text[offset + 104],
SegmentSeparator = text[offset + 105],
});
}
public StreamTextCursor(StreamText text, TextSpan valueSpan, TextSpan nextSpan, ITextParser parser)
{
_text = text;
_valueSpan = valueSpan;
_nextSpan = nextSpan;
_parser = parser;
_next = null;
_nextComputed = false;
_value = null;
_valueComputed = false;
}
ParseText GetText()
{
ParseText[] texts = new ParseText[_slices.Length];
for (int i = 0; i < _slices.Length; i++)
{
texts[i] = _slices[i].Text;
}
_text = new CompositeText(texts);
_textComputed = true;
return(_text);
}
public PrefixMatcher <T> Match(ParseText text, TextSpan span)
{
var matcher = new PrefixMatcher <T>(_root);
for (var i = 0; i < span.Length; i++)
{
if (!matcher.Next(text[span.Start + i]))
{
break;
}
}
return(matcher);
}
public Result <TextSpan, T> Parse(ParseText text, TextSpan span)
{
var parsed = _parser.Parse(text, span);
if (parsed.HasResult)
{
if (_converter(text, parsed.Result, out T result))
{
return(new Success <TextSpan, T>(result, parsed.Next));
}
}
return(new Unmatched <TextSpan, T>(parsed.Next));
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
if (span.Length >= _constant.Length)
{
int compareLength = span.Length > _constant.Length ? _constant.Length : span.Length;
if (text.Compare(_constant, 0, new TextSpan(span.Start, compareLength), _comparisonType) == 0)
{
return(new Success <TextSpan, TextSpan>(new TextSpan(span.Start, compareLength), TextSpan.FromBounds(span.Start + compareLength, span.End)));
}
}
return(new Unmatched <TextSpan, TextSpan>(span));
}
public Result <TextSpan, char> Parse(ParseText text, TextSpan span)
{
if (span.Length > 0)
{
var value = text[span.Start];
if (_condition(value))
{
return(new Success <TextSpan, char>(value, span.Skip(1)));
}
}
return(new Unmatched <TextSpan, char>(span));
}
public Result <TextSpan, TextSpan> Parse(ParseText text, TextSpan span)
{
if (span.IsEmpty)
{
return(new Unmatched <TextSpan, TextSpan>(span));
}
if (span.Length == 2 && text[span.Start] == '"' && text[span.Start + 1] == '"')
{
return(new Success <TextSpan, TextSpan>(new TextSpan(span.Start, 2), TextSpan.FromBounds(span.Start + 2, span.End)));
}
return(new Success <TextSpan, TextSpan>(span, span.Tail));
}
//
void Update()
{
if (status["atScene"] != null)
{
ParseText.AtScene(this, status["atScene"]); // set: status["atScene"] = null
}
else
{
if (m_isGameOver)
{
m_isGameOver = false;
StartCoroutine(GameOver(0.3f));
}
}
}
private void OnSelect(int selectedIndex)
{
var action = Data.actions[selectedIndex];
Data.selectedIndex = selectedIndex;
OnDataChange();
var cm = GameApp.Instance;
cm.status["atScene"] = action.identifier;
cm.SaveStatusData(action.identifier);
ParseText.AtScene(GameApp.Instance, GameApp.Instance.status["atScene"]); // set: status["atScene"] = null
cm.mainUI.ShowNextMessage();
}
static HL7ParserSettings ParseSettings(ParseText text, TextSpan span)
{
var offset = span.Start;
HL7ParserSettings settings = new ParsedHL7Settings
{
FieldSeparator = text[offset + 3],
ComponentSeparator = text[offset + 4],
RepetitionSeparator = text[offset + 5],
EscapeCharacter = text[offset + 6] != '\\' ? default(char) : text[offset + 6],
SubComponentSeparator = text[offset + 7]
};
return(settings);
}
void Start()
{
parseText = gameObject.GetComponent<ParseText>();
}
