public override void WriteTop(double count, double offset, TopType topType)
{
if (topType == TopType.Range)
{
this.IncrementStatementDepth();
StringBuilder builder = null;
System.IO.TextWriter writer = this.Writer;
if (writer is System.IO.StringWriter)
{
System.IO.StringWriter sw = writer as System.IO.StringWriter;
builder = sw.GetStringBuilder();
}
_range = new RangeOptions()
{
Count = (int)count - 1, //as we use between and we start from offset 1 - this works
Offset = (int)offset,
SelectInjectOffset = builder.Length,
Builder = builder,
CollectingFields = true
};
}
else
{
base.WriteTop(count, offset, topType);
}
}
/// <summary>
/// Remove range of pages from password-protected document of known format
/// </summary>
/// <param name="fileName">source file</param>
public static void RemovePagesRangeFromProtectedKnownFormatDoc(string fileName)
{
//ExStart:RemovePagesRangeFromProtectedKnownFormatDoc
string sourceFile = CommonUtilities.sourcePath + fileName;
// Preparing.
string password = "";
int startPage = 2;
int endPage = 4;
RangeMode mode = RangeMode.AllPages;
RangeOptions rangeOptions = new RangeOptions(startPage, endPage, mode);
rangeOptions.Password = password;
rangeOptions.FileFormat = FileFormat.Docx;
Stream openFile = new FileStream(sourceFile, FileMode.Open);
// Main method.
DocumentResult result = new DocumentHandler().RemovePages(openFile, rangeOptions);
Stream documentStream = result.Stream;
//output file
var fileStream = File.Create(CommonUtilities.outputPath + "OutPut." + FileFormat.Docx);
documentStream.CopyTo(fileStream);
documentStream.Close();
//ExEnd:RemovePagesRangeFromProtectedKnownFormatDoc
}
public ValueRangeToken(LeoMember member, TVal from, TVal to, RangeOptions options) : base(member)
{
_from = from;
_to = to;
_options = options;
}
/// <summary>
/// Splitting by page ranges to several documents
/// </summary>
/// <param name="fileName">source file</param>
public static void SplittingByPageRanges(string fileName)
{
//ExStart:SplittingByPageRanges
string sourceFile = CommonUtilities.sourcePath + fileName;
// Preparing.
string password = "******";
int startPage = 5;
int endPage = 8;
RangeMode mode = RangeMode.EvenPages;
RangeOptions rangeOptions = new RangeOptions(startPage, endPage, mode);
rangeOptions.Password = password;
rangeOptions.FileFormat = FileFormat.Pdf;
Stream openFile = new FileStream(sourceFile, FileMode.Open);
// Main method.
MultiDocumentResult splitResult = new DocumentHandler().Split(openFile, rangeOptions);
for (int i = 0; i < splitResult.Documents.Count; i++)
{
Stream documentStream = splitResult.Documents[i].Stream;
//output file
var fileStream = File.Create(CommonUtilities.outputPath + "OutPut " + i + "." + FileFormat.Pdf);
documentStream.CopyTo(fileStream);
documentStream.Close();
}
//ExEnd:SplittingByPageRanges
}
/// <inheritdoc />
public ValueRangeToken(VerifiableMemberContract contract, TVal from, TVal to, RangeOptions options) : base(contract)
{
_from = from;
_to = to;
_options = options;
}
private static async Task Main()
{
//Create a HttpClient
using (HttpClient client = new HttpClient())
{
//Create a builder to the accept-encoding header. We need this to construct which encodings we would like to accept in the response.
AcceptEncodingBuilder acceptEncoding = new AcceptEncodingBuilder();
acceptEncoding.Add(AcceptEncodingType.Identity, 0.5f);
acceptEncoding.Add(AcceptEncodingType.Compress, 0.1f);
//Add the Accept-Encoding header to the HttpClient
client.DefaultRequestHeaders.Add(acceptEncoding.HeaderName, acceptEncoding.Build());
//Now we create some options for the next header. These change the behavior of the builder.
RangeOptions rangeOptions = new RangeOptions();
rangeOptions.DiscardInvalidRanges = true;
rangeOptions.MergeOverlappingRanges = true;
rangeOptions.ShortenRanges = true;
rangeOptions.SortRanges = true;
//Create a RangeBuilder with the options we just made
RangeBuilder range = new RangeBuilder(Options.Create(rangeOptions));
range.Add(0, 10_000);
range.Add(5, 100); //This range is overlapping, but that's okay since MergeOverlappingRanges is set to true.
//We add the Range header to the HttpClient
client.DefaultRequestHeaders.Add(range.HeaderName, range.Build());
//We send the request to a website that echo the headers back to us in the response.
string echo = await client.GetStringAsync(new Uri("http://scooterlabs.com/echo")).ConfigureAwait(false);
//The response is written to the console
Console.WriteLine(echo);
}
}
/// <summary>
/// Creates a new <see cref="NumberConstraint"/> value.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
/// <param name="rangeOptions">The range options.</param>
/// <param name="multipleOf">The value which the range should be a multiple of.</param>
/// <param name="required"></param>
public NumberConstraint(Number?minimum, Number?maximum, RangeOptions rangeOptions, Number?multipleOf, bool required)
{
// Validate min/max/multiple
rangeOptions &= RangeOptions.Inclusive;
if (!minimum.HasValue)
{
rangeOptions &= ~RangeOptions.MinimumInclusive;
}
if (!maximum.HasValue)
{
rangeOptions &= ~RangeOptions.MaximumInclusive;
}
if (maximum.HasValue)
{
if (minimum.HasValue)
{
// Ensure min and max are of the same general type (integer, real or decimal)
if (minimum.Value.Kind != maximum.Value.Kind)
{
throw new ArgumentOutOfRangeException(nameof(maximum), $"{nameof(NumberConstraint)} {nameof(minimum)} and {nameof(maximum)} should have the same {nameof(NumberKinds)}");
}
if (minimum.Value > maximum.Value)
{
throw new ArgumentOutOfRangeException(nameof(maximum));
}
if (minimum.Value == maximum.Value &&
rangeOptions != RangeOptions.Inclusive)
{
throw new ArgumentOutOfRangeException(nameof(maximum));
}
}
if (multipleOf.HasValue)
{
// Ensure min and max are of the same general type (integer, real or decimal)
if (multipleOf.Value.Kind != maximum.Value.Kind)
{
throw new ArgumentOutOfRangeException(nameof(multipleOf), $"{nameof(NumberConstraint)} {nameof(multipleOf)} and {nameof(maximum)} should have the same {nameof(NumberKinds)}");
}
if (multipleOf.Value > maximum.Value)
{
throw new ArgumentOutOfRangeException(nameof(multipleOf));
}
}
}
Minimum = minimum;
Maximum = maximum;
MultipleOf = multipleOf;
RangeOptions = rangeOptions;
Required = required;
}
/// <summary>Returns the fully qualified type name of this instance.</summary>
/// <returns>The fully qualified type name.</returns>
public override string ToString()
{
if (!IsConstrained)
{
return(string.Empty);
}
// Use set notation for open/closed boundaries
var sb = new StringBuilder();
if (RangeOptions.HasFlag(RangeOptions.MinimumInclusive))
{
sb.Append("[");
}
else
{
sb.Append("(");
}
if (Minimum.HasValue)
{
sb.Append(Minimum.Value.ToString(CultureInfo.InvariantCulture));
}
else
{
sb.Append("-∞");
}
sb.Append(", ");
if (Maximum.HasValue)
{
sb.Append(Maximum.Value.ToString(CultureInfo.InvariantCulture));
}
else
{
sb.Append("∞");
}
if (RangeOptions.HasFlag(RangeOptions.MaximumInclusive))
{
sb.Append("]");
}
else
{
sb.Append(")");
}
if (MultipleOf.HasValue &&
MultipleOf.Value != 0)
{
sb.Append(" * ").Append(MultipleOf.Value.ToString(CultureInfo.InvariantCulture));
}
return(sb.ToString());
}
/// <summary>
/// Creates a new <see cref="NumberRange"/> value.
/// </summary>
/// <param name="minimum">The minimum count.</param>
/// <param name="maximum">The maximum count.</param>
/// <param name="rangeOptions">The range options.</param>
public CountRange(uint?minimum, uint?maximum, RangeOptions rangeOptions)
{
rangeOptions &= RangeOptions.Inclusive;
if (!minimum.HasValue)
{
rangeOptions &= ~RangeOptions.MinimumInclusive;
}
if (!maximum.HasValue)
{
rangeOptions &= ~RangeOptions.MaximumInclusive;
}
Minimum = minimum;
Maximum = maximum;
RangeOptions = rangeOptions;
}
/// <summary>
/// Creates a new <see cref="NumberRange"/> value.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
/// <param name="multipleOf">The value which the range should be a multiple of.</param>
/// <param name="rangeOptions">The range options.</param>
public NumberRange(Number?minimum, Number?maximum, Number?multipleOf, RangeOptions rangeOptions)
{
rangeOptions &= RangeOptions.Inclusive;
if (!minimum.HasValue)
{
rangeOptions &= ~RangeOptions.MinimumInclusive;
}
if (!maximum.HasValue)
{
rangeOptions &= ~RangeOptions.MaximumInclusive;
}
Minimum = minimum;
Maximum = maximum;
MultipleOf = multipleOf;
RangeOptions = rangeOptions;
}
/// <summary>
/// Creates a new <see cref="DoubleConstraint"/> value.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
/// <param name="rangeOptions">The range options.</param>
/// <param name="multipleOf">The value which the value should be a multiple of.</param>
/// <param name="required">Whether or not a value is required.</param>
public DoubleConstraint(double?minimum, double?maximum, RangeOptions rangeOptions, double?multipleOf, bool required)
{
rangeOptions &= RangeOptions.Inclusive;
if (!minimum.HasValue)
{
rangeOptions &= ~RangeOptions.MinimumInclusive;
}
if (!maximum.HasValue)
{
rangeOptions &= ~RangeOptions.MaximumInclusive;
}
// Validate min/max/multiple
if (maximum.HasValue)
{
if (minimum.HasValue)
{
if (minimum.Value > maximum.Value)
{
throw new ArgumentOutOfRangeException(nameof(maximum));
}
if (minimum.Value == maximum.Value &&
rangeOptions != RangeOptions.Inclusive)
{
throw new ArgumentOutOfRangeException(nameof(maximum));
}
}
if (multipleOf.HasValue &&
multipleOf.Value > maximum.Value)
{
throw new ArgumentOutOfRangeException(nameof(multipleOf));
}
}
Minimum = minimum;
Maximum = maximum;
RangeOptions = rangeOptions;
MultipleOf = multipleOf;
Required = required;
}
public override void EndSelectStatement()
{
base.EndSelectStatement();
if (_range != null)
{
string[] fields = _range.Fields.ToArray();
string order = "";
if (_range.OrderStartIndex > 0)
{
if (_range.OderEndIndex <= 0)
{
_range.OderEndIndex = _range.Builder.Length;
}
order = _range.Builder.ToString(_range.OrderStartIndex, _range.OderEndIndex - _range.OrderStartIndex);
_range.Builder.Remove(_range.OrderStartIndex, _range.OderEndIndex - _range.OrderStartIndex);
}
else
{
order = string.Join(",", fields);
}
//Inject the SELECT ROW_NUMBER() OVER(...) AS _rowNum, [Sort1], [Sort2] into the SQL statement
string extrasorts = _range.Sorts.Count == 0 ? "" : (string.Join(", ", _range.Sorts.ToArray()) + ", ");
string rowselect = string.Format(ROWSELECT_FORMAT, order, ROWNUM_VAR, extrasorts);
_range.Builder.Insert(_range.SelectInjectOffset, rowselect);
rowselect = string.Format(OUTER_ROWSELECT_FRONT, string.Join(", ", fields));
_range.Builder.Insert(0, rowselect);
rowselect = string.Format(OUTER_ROWSELECT_END, ROWSELECT_TABLENAME, ROWNUM_VAR,
_range.Offset, _range.Count, _range.Count + _range.Offset
, order);
_range.Builder.Append(rowselect);
this.DecrementStatementDepth();
_range = null;
}
}
public ValueRangeToken(LeoMember member, object from, object to, RangeOptions options) : base(member)
{
if (from is null || to is null)
{
_from = default;
_to = default;
_returnFalseDirectly = true;
}
if (!_returnFalseDirectly && from is IComparable from0)
{
_from = from0;
}
else
{
_from = default;
_returnFalseDirectly = true;
}
if (!_returnFalseDirectly && to is IComparable to0)
{
_to = to0;
}
else
{
_to = default;
_returnFalseDirectly = true;
}
if (!_returnFalseDirectly && _from !.CompareTo(_to) > 0)
{
_returnFalseDirectly = true;
}
_options = options;
}
/// <summary>
/// Trim document of known format by page numbers range
/// </summary>
/// <param name="fileName">source file</param>
public static void TrimDocumentByPageNumRange(string fileName)
{
//ExStart:TrimDocumentUnknownFormat
string sourceFile = CommonUtilities.sourcePath + fileName;
// Preparation.
string password = "******";
int startPage = 1;
int endPage = 5;
RangeMode mode = RangeMode.AllPages;
RangeOptions rangeOptions = new RangeOptions(startPage, endPage, mode);
rangeOptions.Password = password;
rangeOptions.FileFormat = FileFormat.Pdf;
Stream openFile = new FileStream(sourceFile, FileMode.Open);
// Main method.
DocumentResult result = new DocumentHandler().Trim(openFile, rangeOptions);
Stream documentStream = result.Stream;
var fileStream = File.Create(CommonUtilities.outputPath + "OutPut." + FileFormat.Pdf);
documentStream.CopyTo(fileStream);
documentStream.Close();
//ExEnd:TrimDocumentUnknownFormat
}
public static List <string> GetRangeOptions()
{
var options = new RangeOptions();
return(options.GetFieldValues());
}
/// <summary>
/// Creates a new <see cref="NumberConstraint"/> value.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
/// <param name="rangeOptions">The range options.</param>
public NumberConstraint(Number?minimum, Number?maximum, RangeOptions rangeOptions)
: this(minimum, maximum, rangeOptions, default, default)
{
}
/// <summary>
/// Creates a new <see cref="DoubleConstraint"/> value.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
/// <param name="rangeOptions">The range options.</param>
public DoubleConstraint(double?minimum, double?maximum, RangeOptions rangeOptions)
: this(minimum, maximum, rangeOptions, default, default)
{
}
public Range(TValue start, TValue end, RangeOptions options)
{
if (options.HasFlag(RangeOptions.IsEmpty))
{
// clear other flags
_options = RangeOptions.IsEmpty;
Start = default(TValue);
End = default(TValue);
return;
}
if (ReferenceEquals(start, null))
{
options &= ~RangeOptions.HasStart;
}
if (ReferenceEquals(end, null))
{
options &= ~RangeOptions.HasEnd;
}
if (!options.HasFlag(RangeOptions.HasStart))
{
start = default(TValue);
options &= ~RangeOptions.IncludingStart;
}
if (!options.HasFlag(RangeOptions.HasEnd))
{
end = default(TValue);
options &= ~RangeOptions.IncludingEnd;
}
_options = options;
if (!options.HasFlag(RangeOptions.HasStart) || !options.HasFlag(RangeOptions.HasEnd))
{
Start = start;
End = end;
return;
}
Debug.Assert(start != null, "start != null");
var compare = start.CompareTo(end);
if (compare > 0)
{
throw new ArgumentException("'Start' must be less or equal to the 'End' parameter");
}
Start = start;
End = end;
if (compare == 0)
{
if (!(options.HasFlag(RangeOptions.IncludingStart) ||
options.HasFlag(RangeOptions.IncludingEnd)))
{
// empty
Start = default(TValue);
End = default(TValue);
_options = RangeOptions.IsEmpty;
}
else
{
// ensure that everything are included
_options |= RangeOptions.IncludingStart | RangeOptions.IncludingEnd;
}
}
}
public DateRangeModel(RangeOptions rangeOptions, DateRangeCode defaultRangeCode, string title)
{
DateRangeCode = defaultRangeCode;
RangeOptions = rangeOptions;
Title = title;
}
/// <summary>
/// Range... from .. to .. <br />
/// 位于区间
/// </summary>
/// <param name="registrar"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="options"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IPredicateValidationRegistrar <T> Range <T>(this IValueFluentValidationRegistrar <T> registrar, object from, object to, RangeOptions options = RangeOptions.OpenInterval)
{
registrar._impl().ExposeValueRuleBuilder().Range(from, to, options);
return((IPredicateValidationRegistrar <T>)registrar);
}
public DateRangeModel(RangeOptions rangeOptions, DateRangeCode defaultRangeCode)
{
DateRangeCode = defaultRangeCode;
RangeOptions = rangeOptions;
}
/// <summary>
/// Creates a new <see cref="DecimalConstraint"/> value.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
/// <param name="rangeOptions">The range options.</param>
public DecimalConstraint(decimal?minimum, decimal?maximum, RangeOptions rangeOptions)
: this(minimum, maximum, rangeOptions, default, default)
{
}
//`1
public static IPredicateValueRuleBuilder <T> Range <T>(this IValueRuleBuilder <T> builder, object from, object to, RangeOptions options = RangeOptions.OpenInterval)
{
var current = builder._impl();
current.State.CurrentToken = new ValueRangeToken(current._contract, from, to, options);
return(current);
}
/// <summary>
/// Creates a new <see cref="NumberRange"/> value.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
/// <param name="rangeOptions">The range options.</param>
public NumberRange(Number?minimum, Number?maximum, RangeOptions rangeOptions)
: this(minimum, maximum, null, rangeOptions)
{
}
/// <summary>
/// Creates a new <see cref="Int64Constraint"/> value.
/// </summary>
/// <param name="minimum">The minimum value.</param>
/// <param name="maximum">The maximum value.</param>
/// <param name="rangeOptions">The range options.</param>
public Int64Constraint(long?minimum, long?maximum, RangeOptions rangeOptions)
: this(minimum, maximum, rangeOptions, default, default)
{
}
