/// <summary>
/// 初始化 <see cref="RegexRepeat{T}"/> 类的新实例。该实例指定内部的正则对象。
/// </summary>
/// <param name="regex">指定的内部正则对象。</param>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
protected RegexRepeat(RegexObject <T> regex) : this()
{
if (regex == null)
{
throw new ArgumentNullException(nameof(regex));
}
this.innerRegex = regex;
}
/// <summary>
/// 确定指定的正则对象是否等于当前的正则对象。
/// </summary>
/// <param name="regex">指定的正则对象。</param>
/// <returns>如果 <paramref name="regex"/> 与当前的正则对象相同，则返回 true ；否则返回 false 。</returns>
public virtual bool Equals(RegexObject <T> regex)
{
if (regex == null)
{
return(false);
}
else
{
return(object.ReferenceEquals(this, regex));
}
}
/// <summary>
/// 初始化 <see cref="RegexRepeat{T}"/> 类的新实例。该实例指定内部的正则对象，重复次数的最小值、最大值。
/// </summary>
/// <param name="regex">指定的内部正则对象。</param>
/// <param name="minimumCount">最小重复次数。</param>
/// <param name="maximumCount">最大重复次数。</param>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
/// <exception cref="ArgumentOutOfRangeException">重复次数最小值 <paramref name="minimumCount"/> 大于重复次数最大值 <paramref name="maximumCount"/> 。</exception>
public RegexRepeat(RegexObject <T> regex, ulong?minimumCount, ulong?maximumCount) : this(regex)
{
if ((minimumCount.HasValue && maximumCount.HasValue) &&
(minimumCount.Value > maximumCount.Value)
)
{
throw new ArgumentOutOfRangeException(
string.Format("{0}, {1}", nameof(minimumCount), nameof(maximumCount)),
string.Format("{0}, {1}", minimumCount, maximumCount),
string.Format("次数最小值不能大于最大值。")
);
}
this.minimumCount = minimumCount;
this.maximumCount = maximumCount;
}
/// <summary>
/// 将此正则对象与另一个正则对象并联。
/// </summary>
/// <param name="regex">另一个正则对象。</param>
/// <returns>并联后形成的新正则对象。</returns>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
/// <seealso cref="RegexObject{T}.Unions(RegexObject{T})"/>
public override RegexObject <T> Unions(RegexObject <T> regex)
{
if (regex == null)
{
throw new ArgumentNullException(nameof(regex));
}
if (regex is RegexParallels <T> parallels)
{
return(new RegexParallels <T>(this.parallels.Concat(parallels.parallels)));
}
else
{
return(new RegexParallels <T>(this, regex));
}
}
/// <summary>
/// 将此串联正则与另一个正则对象串联。
/// </summary>
/// <param name="regex">另一个正则对象。</param>
/// <returns>串联后形成的新正则对象。</returns>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
/// <seealso cref="RegexObject{T}.Concat(RegexObject{T})"/>
public override RegexObject <T> Concat(RegexObject <T> regex)
{
if (regex == null)
{
throw new ArgumentNullException(nameof(regex));
}
if (regex is RegexSeries <T> series)
{
return(new RegexSeries <T>(this.series.Concat(series.series)));
}
else
{
return(new RegexSeries <T>(this, regex));
}
}
/// <summary>
/// 将此常量正则与另一个正则对象并联。
/// </summary>
/// <param name="regex">另一个正则对象。</param>
/// <returns>并联后形成的新正则对象。</returns>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
/// <seealso cref="RegexObject{T}.Unions(RegexObject{T})"/>
public override RegexObject <T> Unions(RegexObject <T> regex)
{
if (regex == null)
{
throw new ArgumentNullException(nameof(regex));
}
if ((regex is RegexRange <T> range) &&
(range.Comparison(range.Minimum, this.ConstValue) <= 0 &&
range.Comparison(this.ConstValue, range.Maximum) <= 0)
)
{
return(regex);
}
else
{
return(base.Unions(regex));
}
}
/// <summary>
/// 将此重复正则与另一个正则对象串联。
/// </summary>
/// <param name="regex">另一个正则对象。</param>
/// <returns>串联后形成的新正则对象。</returns>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
/// <seealso cref="RegexObject{T}.Concat(RegexObject{T})"/>
public override RegexObject <T> Concat(RegexObject <T> regex)
{
if (regex == null)
{
throw new ArgumentNullException(nameof(regex));
}
if (regex is RegexRepeat <T> repeat && this.InnerRegex.Equals(repeat.InnerRegex))
{
return(new RegexRepeat <T>(
this.InnerRegex,
((this.MinimumCount.HasValue && repeat.MinimumCount.HasValue) ? this.MinimumCount + repeat.MinimumCount : null),
((this.MaximumCount.HasValue && repeat.MaximumCount.HasValue) ? this.MaximumCount + repeat.MaximumCount : null)
));
}
else
{
return(base.Concat(regex));
}
}
/// <summary>
/// 将此正则对象与另一个正则对象串联。
/// </summary>
/// <param name="regex">另一个正则对象。</param>
/// <returns>串联后形成的新正则对象。</returns>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
public virtual RegexObject <T> Concat(RegexObject <T> regex)
{
if (regex == null)
{
throw new ArgumentNullException(nameof(regex));
}
if (regex is RegexRepeat <T> repeat && this.Equals(repeat.InnerRegex))
{
return(new RegexRepeat <T>(
this,
repeat.MinimumCount.HasValue ? repeat.MinimumCount + 1 : null,
repeat.MaximumCount.HasValue ? repeat.MaximumCount + 1 : null
));
}
else if (regex is RegexSeries <T> series)
{
return(new RegexSeries <T>(new RegexObject <T>[] { this }.Concat(series.Series)));
}
else
{
return(new RegexSeries <T>(this, regex));
}
}
/// <summary>
/// 初始化 <see cref="RegexRepeat{T}"/> 类的新实例。该实例指定内部的正则对象，重复次数的最小值以及重复次数的最大值是否为无限。
/// </summary>
/// <param name="regex">指定的内部正则对象。</param>
/// <param name="minimumCount">最小重复次数。</param>
/// <param name="isInfinite">一个值，指示重复次数的最大值是否为无限。</param>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
public RegexRepeat(RegexObject <T> regex, ulong minimumCount, bool isInfinite) : this(regex, (ulong?)minimumCount, isInfinite)
{
}
/// <summary>
/// 初始化 <see cref="RegexRepeat{T}"/> 类的新实例。该实例指定内部的正则对象，重复次数的最小值以及重复次数的最大值是否为无限。
/// </summary>
/// <param name="regex">指定的内部正则对象。</param>
/// <param name="minimumCount">最小重复次数。</param>
/// <param name="isInfinite">一个值，指示重复次数的最大值是否为无限。</param>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
public RegexRepeat(RegexObject <T> regex, ulong?minimumCount, bool isInfinite) : this(regex, minimumCount, (isInfinite ? null : (ulong?)(minimumCount ?? ulong.MinValue)))
{
}
/// <summary>
/// 初始化 <see cref="RegexRepeat{T}"/> 类的新实例。该实例指定内部的正则对象，重复次数的最大值是否为无限。
/// </summary>
/// <param name="regex">指定的内部正则对象。</param>
/// <param name="isInfinite">一个值，指示重复次数的最大值是否为无限。</param>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
public RegexRepeat(RegexObject <T> regex, bool isInfinite) : this(regex, null, isInfinite)
{
}
/// <summary>
/// 初始化 <see cref="RegexRepeat{T}"/> 类的新实例。该实例指定内部的正则对象，重复次数的最小值、最大值。
/// </summary>
/// <param name="regex">指定的内部正则对象。</param>
/// <param name="minimumCount">最小重复次数。</param>
/// <param name="maximumCount">最大重复次数。</param>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
/// <exception cref="ArgumentOutOfRangeException">重复次数最小值 <paramref name="minimumCount"/> 大于重复次数最大值 <paramref name="maximumCount"/> 。</exception>
public RegexRepeat(RegexObject <T> regex, ulong minimumCount, ulong maximumCount) : this(regex, (ulong?)minimumCount, (ulong?)maximumCount)
{
}
/// <summary>
/// 将此范围正则与另一个正则对象并联。
/// </summary>
/// <param name="regex">另一个正则对象。</param>
/// <returns>并联后形成的新正则对象。</returns>
/// <exception cref="ArgumentNullException"><paramref name="regex"/> 的值为 null 。</exception>
/// <seealso cref="RegexObject{T}.Unions(RegexObject{T})"/>
public override RegexObject <T> Unions(RegexObject <T> regex)
{
if (regex == null)
{
throw new ArgumentNullException(nameof(regex));
}
if (regex is RegexConst <T> regexConst)
{
return(regex.Unions(this));
}
else if (regex is RegexRange <T> range)
{
if (this.comparison != range.comparison)
{
throw new NotSupportedException("无法对使用不同比较方法的范围正则进行结合。");
}
else if (
(this.comparison(range.Minimum, this.Maximum) <= 0 &&
range.comparison(range.Minimum, this.Maximum) <= 0)
)
{
T newMinimum, newMaximum;
bool newCanTakeMinimum, newCanTakeMaximum;
int i;
i = this.comparison(this.Minimum, range.Minimum);
if (i < 0)
{
newMinimum = this.Minimum;
newCanTakeMinimum = this.canTakeMinimum;
}
else if (i > 0)
{
newMinimum = range.Minimum;
newCanTakeMinimum = range.canTakeMinimum;
}
else
{
newMinimum = this.Minimum;
newCanTakeMinimum = this.canTakeMinimum || range.canTakeMinimum;
}
i = this.comparison(this.Maximum, range.Maximum);
if (i < 0)
{
newMaximum = this.Maximum;
newCanTakeMaximum = this.canTakeMaximum;
}
else if (i > 0)
{
newMaximum = range.Maximum;
newCanTakeMaximum = range.canTakeMaximum;
}
else
{
newMaximum = this.Maximum;
newCanTakeMaximum = this.canTakeMaximum || range.canTakeMaximum;
}
return(new RegexRange <T>(
newMinimum, newMaximum,
newCanTakeMinimum, newCanTakeMaximum,
this.comparison
));
}
}
return(base.Unions(regex));
}
