Regular expression extravaganza

namespace Siderite.Text.RegularExpressions
{
/// <summary>
/// Regex Match equivalent for Streams
/// </summary>
public class StreamMatch
{
private readonly Match _match;
private readonly StreamRegex _streamRegex;
private long _streamIndex;

/// <summary>
/// Constructor
/// </summary>
/// <param name="regex">StreamRegex that generated it</param>
/// <param name="m">internal Regex match</param>
/// <param name="streamIndex">real stream index</param>
internal StreamMatch(StreamRegex regex, Match m, long streamIndex)
{
_streamRegex = regex;
_match = m;
StreamIndex = streamIndex;
}

/// <summary>
/// Empty StreamMatch
/// </summary>
public static StreamMatch Empty
{
get { return new StreamMatch(null, null,0); }
}

/// <summary>
/// Success of matching
/// </summary>
public bool Success
{
get
{
if (_match == null) return false;
// matches with length 0 would only cause infinite loops
if ((_streamRegex.EmptyRegexMode==EmptyRegexMode.NoSuccess)&&(_match.Length == 0)) 
return false;
return _match.Success;
}
}

/// <summary>
/// Length of match
/// </summary>
public int Length
{
get
{
if (_match == null) return 0;
return _match.Length;
}
}

/// <summary>
/// Groups in the match. This is a regular Regex GroupCollection
/// </summary>
public GroupCollection Groups
{
get
{
if (_match == null) return null;
return _match.Groups;
}
}

/// <summary>
/// Value of the match
/// </summary>
public string Value
{
get
{
if (_match == null) return null;
return _match.Value;
}
}

/// <summary>
/// Group names in the match including "0","1", etc
/// </summary>
public string[] GroupNames
{
get
{
if (_streamRegex == null) return null;
return _streamRegex.GroupNames;
}
}

/// <summary>
/// Group names in the match that are non numeric (words only)
/// </summary>
public IEnumerable<string> NonNumericGroupNames
{
get
{
if (_streamRegex == null) return null;
return _streamRegex.NonNumericGroupNames;
}
}

public long StreamIndex
{
get { return _streamIndex; }
set { _streamIndex = value; }
}

/// <summary>
/// indexer using a name
/// </summary>
/// <param name="groupName"></param>
/// <returns>Regular Regex Group. The group Index has no meaning</returns>
public Group this[string groupName]
{
get
{
if (_match == null) return null;
return _match.Groups[groupName];
}
}

/// <summary>
/// indexer using a numeric index
/// </summary>
/// <param name="groupNr"></param>
/// <returns>Regular Regex Group. The group Index has no meaning</returns>
public Group this[int groupNr]
{
get
{
if (_match == null) return null;
return _match.Groups[groupNr];
}
}

/// <summary>
/// Find next match
/// </summary>
/// <returns></returns>
public StreamMatch NextMatch()
{
if (_streamRegex == null) return null;
return _streamRegex.NextMatch();
}
}

public enum EmptyRegexMode
{
NoSuccess,
ThrowException,
Success
}

/// <summary>
/// Regex equivalent for Streams
/// </summary>
public class StreamRegex
{
private readonly Regex _regex;
private readonly StringBuilder _sb;
private readonly Stream _stream;
private byte[] _buffer;
private int _bufferSize = 65536;
private long _currentPosition;
private Encoding _encoding;
private string[] _groupNames;
private long _internalStreamLength;
private bool _matchInitialised;
private long _maxMatchLength;
private EmptyRegexMode _emptyRegexMode;

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
public StreamRegex(Stream stream, string pattern)
: this(stream, pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline| RegexOptions.Compiled)
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions)
: this(stream, pattern, regexOptions, Encoding.GetEncoding(1252))
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
/// <param name="encoding">Encoding of the stream</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions, Encoding encoding)
: this(stream, pattern, regexOptions, encoding, long.MaxValue/2)
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
/// <param name="encoding">Encoding of the stream</param>
/// <param name="maxMatchLength">Maximum possible match. Specify this to minimize memory use</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions, Encoding encoding,
long maxMatchLength)
{
_regex = new Regex(pattern, regexOptions);
_stream = stream;
_matchInitialised = false;
Encoding = encoding;
MaxMatchLength = maxMatchLength;
_sb = new StringBuilder();
EmptyRegexMode = EmptyRegexMode.NoSuccess;
}

/// <summary>
/// Read buffer size. default 65536 bytes
/// Warning: this works on an internal string that will be 
/// a multiple of this number. Don't make it too large.
/// </summary>
public int BufferSize
{
get { return _bufferSize; }
set
{
_bufferSize = value;
// you cannot run NextMatch now
_matchInitialised = false;
}
}

/// <summary>
/// Encoding for the stream. default Windows-1252
/// </summary>
public Encoding Encoding
{
get { return _encoding; }
set { _encoding = value; }
}

/// <summary>
/// Maximum possible match length. default long.MaxValue/2
/// </summary>
public long MaxMatchLength
{
get { return _maxMatchLength; }
set { _maxMatchLength = value; }
}

/// <summary>
/// Names of the groups in the regex expression
/// </summary>
public string[] GroupNames
{
get
{
if (_regex == null) return null;
if (_groupNames == null)
{
_groupNames = _regex.GetGroupNames();
}
return _groupNames;
}
}

/// <summary>
/// Names of the groups in the regex expression
/// that are non numeric (so only the word names)
/// </summary>
public IEnumerable<string> NonNumericGroupNames
{
get
{
if (_regex == null) return null;
List<string> list = new List<string>();
foreach (string groupName in _regex.GetGroupNames())
{
if (!Regex.IsMatch(groupName, @"^\d+$")) list.Add(groupName);
}
return list;
}
}

/// <summary>
/// defines who empty matches are treated: 
/// no success match, exception or succesful match
/// defaults to no success match
/// </summary>
public EmptyRegexMode EmptyRegexMode
{
get { return _emptyRegexMode; }
set { _emptyRegexMode = value; }
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <returns></returns>
public StreamMatch Match()
{
return Match(0L);
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <param name="index">skip index bytes</param>
/// <returns></returns>
public StreamMatch Match(long index)
{
return Match(index, long.MaxValue/2);
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <param name="index">skip index bytes</param>
/// <param name="length">read no more than length bytes</param>
/// <returns></returns>
public StreamMatch Match(long index, long length)
{
if (!_stream.CanRead) throw new Exception("Stream is not readable");
if (length <= 0) return StreamMatch.Empty;
if (index != 0) SeekStream(index);
_buffer = new byte[BufferSize];
_sb.Length = 0;
// initialize real position in stream
_currentPosition = _stream.Position;
// this is the maximum length of bytes this match will read
_internalStreamLength = length;
// you can now call NextMatch
_matchInitialised = true;
return NextMatch();
}

internal StreamMatch NextMatch()
{
if (!_matchInitialised) 
throw new Exception("First run Match, then NextMatch");
// search the buffer string first
Match m = _regex.Match(_sb.ToString());
if (m.Success&&((EmptyRegexMode!=EmptyRegexMode.NoSuccess)||(m.Length>0)))
{
if (EmptyRegexMode == EmptyRegexMode.ThrowException)
{
if (m.Length == 0)
throw new Exception(
"Successful Match has empty value. If you use NextMatch in a loop it will become infinite");
}
StreamMatch sm = new StreamMatch(this, m, _currentPosition + m.Index);

//remove matches to minimize memory usage
int extra = m.Index + m.Length;
_sb.Remove(0, extra);
// update real position in stream
_currentPosition += extra;

return sm;
}
int l;
while ((l = _stream.Read(_buffer, 0, (int) Math.Min(_internalStreamLength, _buffer.Length))) > 0)
{
_internalStreamLength -= l;

// remove part of StringBuilder where there is no chance it contains a match
// this works only if MaxMatch is specified
long extraLength = _sb.Length - MaxMatchLength;
if (extraLength > 0)
{
_sb.Remove(0, (int) extraLength);
_currentPosition += extraLength;
}


_sb.Append(Encoding.GetString(_buffer, 0, l));

// TODO: remove this
Debug.WriteLine("SB length: " + _sb.Length);

m = _regex.Match(_sb.ToString());
if (m.Success)
{
StreamMatch sm = new StreamMatch(this, m, _currentPosition + m.Index);

//remove matches to minimize memory usage
int extra = m.Index + m.Length;
_sb.Remove(0, extra);
// update real position in stream
_currentPosition += extra;
return sm;
}
}
return new StreamMatch(this, m, 0);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches()
{
return Matches(0L);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <param name="index">skip index bytes</param>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches(long index)
{
return Matches(index, long.MaxValue/2);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <param name="index">skip index bytes</param>
/// <param name="length">read no more than length bytes</param>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches(long index, long length)
{
List<StreamMatch> list = new List<StreamMatch>();
StreamMatch m = Match(index, length);
while (m.Success)
{
list.Add(m);
m = NextMatch();
}
return list;
}

/// <summary>
/// Seek the stream to specified position
/// </summary>
/// <param name="index">seek to index from current position</param>
public void SeekStream(long index)
{
SeekStream(index, SeekOrigin.Current);
}

/// <summary>
/// Seek the stream to specified position
/// </summary>
/// <param name="index">seek to index position</param>
/// <param name="origin">from current position, start or end</param>
public void SeekStream(long index, SeekOrigin origin)
{
int _tmpSeekSize = 65536;
if (_stream.CanSeek)
{
_stream.Seek(index, origin);
}
else
{
if (origin != SeekOrigin.Current) throw new Exception("Stream is not seakable");
long l = 0;
try
{
l = _stream.Length;
}
#pragma warning disable EmptyGeneralCatchClause
catch (Exception)
{
}
#pragma warning restore EmptyGeneralCatchClause
if ((l > 0) && (l < 65536)) _tmpSeekSize = 4096;
if (l > 1000000) _tmpSeekSize = 409600;
if (index >= 0)
{
byte[] buff = new byte[_tmpSeekSize];
l = index;
while (l > 0)
{
l -= _stream.Read(buff, 0, (int) Math.Min(l, buff.Length));
}
}
else
{
throw new Exception("begin cannot be negative on a non seeking stream");
}
}

// update real position in stream
_currentPosition = _stream.Position;
// you cannot run NextMatch now
_matchInitialised = false;
}
}
}