public bool Parse(ITextSegment textSegment)
{
Verify.Argument.IsNotNull(textSegment, nameof(textSegment));
Verify.State.IsFalse(_isCompleted, "Field is already completed.");
if (_offset == 0 && textSegment.Length > 0)
{
var term = textSegment.PeekChar();
if (term == '\n')
{
textSegment.Skip(1);
_isCompleted = true;
return(true);
}
}
if (_offset < 40 && textSegment.Length > 0)
{
int c = Math.Min(textSegment.Length, 40 - _offset);
textSegment.MoveTo(_buffer, _offset, c);
_offset += c;
}
if (_offset == 40 && textSegment.Length > 0)
{
_offset = 0;
_hashes.Add(new Hash(_buffer));
var separator = textSegment.ReadChar();
if (separator == '\n')
{
_isCompleted = true;
return(true);
}
}
return(false);
}
public bool Parse(ITextSegment textSegment)
{
Assert.IsNotNull(textSegment);
while (textSegment.Length > 0)
{
switch (_offset)
{
case -3:
X = textSegment.ReadChar();
++_offset;
break;
case -2:
Y = textSegment.ReadChar();
++_offset;
break;
case -1:
textSegment.Skip(1);
++_offset;
break;
case 0:
if (ParseFileName(textSegment, _to))
{
++_offset;
if (X != 'C' && X != 'R')
{
++_offset;
return(true);
}
}
break;
case 1:
if (ParseFileName(textSegment, _from))
{
++_offset;
return(true);
}
break;
}
}
return(false);
}
private bool ReadHash(ITextSegment textSegment)
{
int count = Math.Min(textSegment.Length, 40 - _bufferOffset);
if (count != 0)
{
textSegment.MoveTo(_buffer, _bufferOffset, count);
_bufferOffset += count;
}
if (_bufferOffset == 40)
{
if (textSegment.Length > 0)
{
textSegment.Skip(1);
return(true);
}
}
return(false);
}
public bool Parse(ITextSegment textSegment)
{
Verify.Argument.IsNotNull(textSegment, nameof(textSegment));
Verify.State.IsFalse(_offset == 41, "Field is already completed.");
if (_offset < 40)
{
int c = Math.Min(textSegment.Length, 40 - _offset);
textSegment.MoveTo(_buffer, _offset, c);
_offset += c;
}
if (_offset == 40 && textSegment.Length > 0)
{
_offset = 41;
textSegment.Skip(1);
return(true);
}
return(false);
}
private static bool ParseFileName(ITextSegment textSegment, StringBuilder stringBuilder)
{
Assert.IsNotNull(textSegment);
Assert.IsNotNull(stringBuilder);
int terminator = textSegment.IndexOf('\0');
if (terminator == -1)
{
textSegment.MoveTo(stringBuilder, textSegment.Length);
}
else
{
if (terminator != 0)
{
textSegment.MoveTo(stringBuilder, terminator);
}
textSegment.Skip(1);
RemoveTrailingSlash(stringBuilder);
return(true);
}
return(false);
}
public bool Parse(ITextSegment textSegment)
{
Verify.Argument.IsNotNull(textSegment, nameof(textSegment));
Verify.State.IsFalse(_isCompleted, "Field is already completed.");
if (textSegment.Length > 0)
{
int eol = textSegment.IndexOf('\n');
if (eol == -1)
{
textSegment.MoveTo(_line, textSegment.Length);
}
else
{
if (eol != 0)
{
textSegment.MoveTo(_line, eol);
}
textSegment.Skip(1);
return(true);
}
}
return(false);
}
private bool ReadHash(ITextSegment textSegment)
{
int count = Math.Min(textSegment.Length, 40 - _bufferOffset);
if(count != 0)
{
textSegment.MoveTo(_buffer, _bufferOffset, count);
_bufferOffset += count;
}
if(_bufferOffset == 40)
{
if(textSegment.Length > 0)
{
textSegment.Skip(1);
return true;
}
}
return false;
}
public bool Parse(ITextSegment textSegment)
{
while(textSegment.Length > 0)
{
switch(_state)
{
case State.ReadingHeader:
{
int terminator = textSegment.IndexOf(' ');
if(terminator == -1)
{
int count = textSegment.Length;
if(_bufferOffset + count > _buffer.Length)
{
throw new Exception("header is too large");
}
textSegment.MoveTo(_buffer, _bufferOffset, count);
_bufferOffset += count;
}
else
{
if(terminator != 0)
{
if(_bufferOffset + terminator > _buffer.Length)
{
throw new Exception("header is too large");
}
textSegment.MoveTo(_buffer, _bufferOffset, terminator);
_bufferOffset += terminator;
}
textSegment.Skip(1);
switch(_part)
{
case Part.None:
if(CurrentHeaderIs(@"commit"))
{
_part = Part.Commit;
}
else
{
throw new Exception("Expected header: commit");
}
break;
case Part.Commit:
if(CurrentHeaderIs(@"tree"))
{
_part = Part.Tree;
}
else
{
throw new Exception("Expected header: tree");
}
break;
case Part.Tree:
case Part.Parent:
if(CurrentHeaderIs(@"parent"))
{
_part = Part.Parent;
}
else if(CurrentHeaderIs(@"author"))
{
_part = Part.Author;
}
else
{
throw new Exception("Expected header: parent or author");
}
break;
case Part.Author:
if(CurrentHeaderIs("committer"))
{
_part = Part.Committer;
}
else
{
throw new Exception("Expected header: committer");
}
break;
default:
throw new Exception("Invalid parser state.");
}
_bufferOffset = 0;
_state = State.ReadingContent;
}
}
break;
case State.ReadingContent:
switch(_part)
{
case Part.Commit:
if(ReadHash(textSegment))
{
_commit = new Hash(_buffer);
_state = State.ReadingHeader;
}
break;
case Part.Tree:
if(ReadHash(textSegment))
{
_tree = new Hash(_buffer);
_state = State.ReadingHeader;
}
break;
case Part.Parent:
if(ReadHash(textSegment))
{
_parents.Add(new Hash(_buffer));
_state = State.ReadingHeader;
}
break;
}
break;
}
}
return false;
}
public bool Parse(ITextSegment textSegment)
{
while (textSegment.Length > 0)
{
switch (_state)
{
case State.ReadingHeader:
{
int terminator = textSegment.IndexOf(' ');
if (terminator == -1)
{
int count = textSegment.Length;
if (_bufferOffset + count > _buffer.Length)
{
throw new Exception("header is too large");
}
textSegment.MoveTo(_buffer, _bufferOffset, count);
_bufferOffset += count;
}
else
{
if (terminator != 0)
{
if (_bufferOffset + terminator > _buffer.Length)
{
throw new Exception("header is too large");
}
textSegment.MoveTo(_buffer, _bufferOffset, terminator);
_bufferOffset += terminator;
}
textSegment.Skip(1);
switch (_part)
{
case Part.None:
if (CurrentHeaderIs(@"commit"))
{
_part = Part.Commit;
}
else
{
throw new Exception("Expected header: commit");
}
break;
case Part.Commit:
if (CurrentHeaderIs(@"tree"))
{
_part = Part.Tree;
}
else
{
throw new Exception("Expected header: tree");
}
break;
case Part.Tree:
case Part.Parent:
if (CurrentHeaderIs(@"parent"))
{
_part = Part.Parent;
}
else if (CurrentHeaderIs(@"author"))
{
_part = Part.Author;
}
else
{
throw new Exception("Expected header: parent or author");
}
break;
case Part.Author:
if (CurrentHeaderIs("committer"))
{
_part = Part.Committer;
}
else
{
throw new Exception("Expected header: committer");
}
break;
default:
throw new Exception("Invalid parser state.");
}
_bufferOffset = 0;
_state = State.ReadingContent;
}
}
break;
case State.ReadingContent:
switch (_part)
{
case Part.Commit:
if (ReadHash(textSegment))
{
_commit = new Hash(_buffer);
_state = State.ReadingHeader;
}
break;
case Part.Tree:
if (ReadHash(textSegment))
{
_tree = new Hash(_buffer);
_state = State.ReadingHeader;
}
break;
case Part.Parent:
if (ReadHash(textSegment))
{
_parents.Add(new Hash(_buffer));
_state = State.ReadingHeader;
}
break;
}
break;
}
}
return(false);
}