/// <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)); }