public static ByteQuantifiedSize FromSpecifiedUnit(ulong number, ByteQuantifiedSize.Quantifier specifiedUnit)
{
ByteQuantifiedSize byteQuantifiedSize = default(ByteQuantifiedSize);
if (specifiedUnit <= ByteQuantifiedSize.Quantifier.KB)
{
if (specifiedUnit == ByteQuantifiedSize.Quantifier.None)
{
return(ByteQuantifiedSize.FromBytes(number));
}
if (specifiedUnit == ByteQuantifiedSize.Quantifier.KB)
{
return(ByteQuantifiedSize.FromKB(number));
}
}
else
{
if (specifiedUnit == ByteQuantifiedSize.Quantifier.MB)
{
return(ByteQuantifiedSize.FromMB(number));
}
if (specifiedUnit == ByteQuantifiedSize.Quantifier.GB)
{
return(ByteQuantifiedSize.FromGB(number));
}
if (specifiedUnit == ByteQuantifiedSize.Quantifier.TB)
{
return(ByteQuantifiedSize.FromTB(number));
}
}
throw new ArgumentException(DataStrings.ExceptionUnknownUnit);
}
private static void GetIntegerConstraints(ADSchemaAttributeObject schemaObject, ADPropertyDefinition propDef, List <PropertyDefinitionConstraint> constraints)
{
bool isUnlimited;
bool isNullable;
Type typeInformation = ADSchemaDataProvider.GetTypeInformation(propDef.Type, out isUnlimited, out isNullable);
if (typeInformation == typeof(int))
{
int minValue = schemaObject.RangeLower ?? int.MinValue;
int maxValue = schemaObject.RangeUpper ?? int.MaxValue;
constraints.Add(ADSchemaDataProvider.GetRangedConstraint <int>(minValue, maxValue, isUnlimited, isNullable));
return;
}
if (typeInformation == typeof(ByteQuantifiedSize))
{
IFormatProvider formatProvider = propDef.FormatProvider;
ByteQuantifiedSize.Quantifier quantifier = (formatProvider != null) ? ((ByteQuantifiedSize.Quantifier)formatProvider.GetFormat(typeof(ByteQuantifiedSize.Quantifier))) : ByteQuantifiedSize.Quantifier.None;
ulong number = (ulong)((long)(schemaObject.RangeLower ?? 0));
int? rangeUpper = schemaObject.RangeUpper;
ulong number2 = ((rangeUpper != null) ? new ulong?((ulong)((long)rangeUpper.GetValueOrDefault())) : null) ?? Math.Min((ulong)((ByteQuantifiedSize.Quantifier) 18446744073709551615UL / quantifier), 2147483647UL);
ByteQuantifiedSize minValue2 = ByteQuantifiedSize.FromSpecifiedUnit(number, quantifier);
ByteQuantifiedSize maxValue2 = ByteQuantifiedSize.FromSpecifiedUnit(number2, quantifier);
constraints.Add(ADSchemaDataProvider.GetRangedConstraint <ByteQuantifiedSize>(minValue2, maxValue2, isUnlimited, isNullable));
return;
}
ExTraceGlobals.SchemaInitializationTracer.TraceDebug <DataSyntax, ADPropertyDefinition>(0L, "Unsupported property type '{1}' for data syntax '{0}'.", schemaObject.DataSyntax, propDef);
}
public static Unlimited <ByteQuantifiedSize> Parse(string expression, ByteQuantifiedSize.Quantifier defaultUnit)
{
if (StringComparer.OrdinalIgnoreCase.Compare(expression, "Unlimited") == 0)
{
return(Unlimited <ByteQuantifiedSize> .UnlimitedValue);
}
return(ByteQuantifiedSize.Parse(expression, defaultUnit));
}
public ulong RoundUpToUnit(ByteQuantifiedSize.Quantifier quantifier)
{
if (quantifier == (ByteQuantifiedSize.Quantifier) 0UL || (quantifier & quantifier - 1UL) != (ByteQuantifiedSize.Quantifier) 0UL)
{
throw new ArgumentException("Invalid quantifier value", "quantifier");
}
ulong num = this.bytes / (ulong)quantifier;
if ((this.bytes & quantifier - ByteQuantifiedSize.Quantifier.None) != 0UL)
{
num += 1UL;
}
return(num);
}
public static ByteQuantifiedSize Parse(string expression, ByteQuantifiedSize.Quantifier defaultUnit)
{
ulong number;
ByteQuantifiedSize result;
if (ulong.TryParse(expression, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, CultureInfo.InvariantCulture, out number))
{
result = ByteQuantifiedSize.FromSpecifiedUnit(number, defaultUnit);
}
else
{
result = ByteQuantifiedSize.Parse(expression);
}
return(result);
}
public static bool TryParse(string expression, ByteQuantifiedSize.Quantifier defaultUnit, out Unlimited <ByteQuantifiedSize> result)
{
bool result2 = false;
result = Unlimited <ByteQuantifiedSize> .UnlimitedValue;
if (StringComparer.OrdinalIgnoreCase.Compare(expression, "Unlimited") == 0)
{
return(true);
}
ByteQuantifiedSize fromValue;
if (ByteQuantifiedSize.TryParse(expression, defaultUnit, out fromValue))
{
result = fromValue;
}
return(result2);
}
private string ToString(ByteQuantifiedSize.Quantifier quantifier)
{
if (quantifier <= ByteQuantifiedSize.Quantifier.KB)
{
if (quantifier == ByteQuantifiedSize.Quantifier.None)
{
return(string.Format(CultureInfo.InvariantCulture, "{0:N0} B", new object[]
{
this.ToBytes()
}));
}
if (quantifier == ByteQuantifiedSize.Quantifier.KB)
{
return(string.Format(CultureInfo.InvariantCulture, "{0:N0} KB", new object[]
{
this.ToKB()
}));
}
}
else
{
if (quantifier == ByteQuantifiedSize.Quantifier.MB)
{
return(string.Format(CultureInfo.InvariantCulture, "{0:N0} MB", new object[]
{
this.ToMB()
}));
}
if (quantifier == ByteQuantifiedSize.Quantifier.GB)
{
return(string.Format(CultureInfo.InvariantCulture, "{0:N0} GB", new object[]
{
this.ToGB()
}));
}
if (quantifier == ByteQuantifiedSize.Quantifier.TB)
{
return(string.Format(CultureInfo.InvariantCulture, "{0:N0} TB", new object[]
{
this.ToTB()
}));
}
}
return(this.ToLargestAppropriateUnitFormatString(true));
}
public static bool TryParse(string expression, ByteQuantifiedSize.Quantifier defaultUnit, out ByteQuantifiedSize byteQuantifiedSize)
{
bool result = true;
ulong number;
if (ulong.TryParse(expression, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite, CultureInfo.InvariantCulture, out number))
{
try
{
byteQuantifiedSize = ByteQuantifiedSize.FromSpecifiedUnit(number, defaultUnit);
return(result);
}
catch (ArgumentException)
{
byteQuantifiedSize = default(ByteQuantifiedSize);
return(false);
}
}
result = ByteQuantifiedSize.TryParse(expression, out byteQuantifiedSize);
return(result);
}
public QuantifierProvider(ByteQuantifiedSize.Quantifier quantifier)
{
this.quantifier = quantifier;
}
private static bool InternalTryParse(string expression, out ulong bytes, out ByteQuantifiedSize.Quantifier unit, out Exception error)
{
bytes = 0UL;
unit = ByteQuantifiedSize.Quantifier.None;
error = null;
expression = expression.Trim();
Match match = ByteQuantifiedSize.LargestAppropriateUnitFormatPattern.Match(expression);
if (!match.Success)
{
error = new FormatException(DataStrings.ExceptionFormatNotCorrect(expression));
return(false);
}
string a;
ByteQuantifiedSize.MaximumValues maximumValues;
if ((a = match.Groups["Unit"].Value.ToUpper()) != null)
{
if (a == "KB")
{
unit = ByteQuantifiedSize.Quantifier.KB;
maximumValues = ByteQuantifiedSize.MaximumValues.KB;
goto IL_EC;
}
if (a == "MB")
{
unit = ByteQuantifiedSize.Quantifier.MB;
maximumValues = ByteQuantifiedSize.MaximumValues.MB;
goto IL_EC;
}
if (a == "GB")
{
unit = ByteQuantifiedSize.Quantifier.GB;
maximumValues = ByteQuantifiedSize.MaximumValues.GB;
goto IL_EC;
}
if (a == "TB")
{
unit = ByteQuantifiedSize.Quantifier.TB;
maximumValues = ByteQuantifiedSize.MaximumValues.TB;
goto IL_EC;
}
}
unit = ByteQuantifiedSize.Quantifier.None;
maximumValues = ByteQuantifiedSize.MaximumValues.None;
IL_EC:
if (match.Groups["LongBytes"].Success)
{
if (!ulong.TryParse(match.Groups["LongBytes"].Value, NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out bytes))
{
error = new FormatException(DataStrings.ExceptionFormatNotCorrect(expression));
return(false);
}
}
else
{
double num;
if (!double.TryParse(match.Groups["ShortBytes"].Value, NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite | NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands | NumberStyles.AllowExponent, null, out num))
{
error = new FormatException(DataStrings.ExceptionFormatNotCorrect(expression));
return(false);
}
if (maximumValues < num || 0.0 > num)
{
error = new OverflowException(DataStrings.ExceptionValueOverflow(ByteQuantifiedSize.MinValue.ToString(unit), ByteQuantifiedSize.MaxValue.ToString(unit), expression));
return(false);
}
bytes = (ulong)(unit * num);
}
return(true);
}
private ByteQuantifiedSize(ulong byteValue, ByteQuantifiedSize.Quantifier desiredUnitToDisplay)
{
this.bytes = byteValue;
this.unit = desiredUnitToDisplay;
this.canonicalForm = null;
}
